pyroscope 1.0.6-aarch64-linux → 1.0.7-aarch64-linux

data/ext/rbspy/src/lib.rs

@@ -0,0 +1,348 @@
+mod backend;
+
+use rbspy::sampler::Sampler;
+use remoteprocess::Pid;
+use std::env;
+use std::ffi::CStr;
+use std::os::raw::c_char;
+
+use crate::backend::Rbspy;
+use pyroscope::backend::{BackendConfig, BackendImpl, Report, StackFrame, Tag};
+use pyroscope::pyroscope::PyroscopeAgentBuilder;
+
+const LOG_TAG: &str = "Pyroscope::rbspy::ffi";
+const RBSPY_NAME: &str = "rbspy";
+const RBSPY_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+fn transform_report_with_current_dir(report: Report) -> Report {
+    let cwd = env::current_dir().ok();
+    let cwd = cwd.as_deref().and_then(|p| p.to_str());
+    transform_report(report, cwd)
+}
+
+pub fn transform_report(report: Report, cwd: Option<&str>) -> Report {
+    let data = report
+        .data
+        .iter()
+        .map(|(stacktrace, count)| {
+            let new_frames = stacktrace
+                .frames
+                .iter()
+                .map(|frame| {
+                    let frame = frame.to_owned();
+                    let mut s = frame.filename.unwrap();
+                    let stripped = cwd
+                        .and_then(|c| s.strip_prefix(c))
+                        .and_then(|rest| rest.strip_prefix('/'));
+                    if let Some(rest) = stripped {
+                        s = rest.to_string();
+                    } else if let Some(i) = s.find("/gems/") {
+                        s = s[(i + 1)..].to_string();
+                    } else if let Some(i) = s.find("/ruby/") {
+                        s = s[(i + 6)..].to_string();
+                        if let Some(i) = s.find('/') {
+                            s = s[(i + 1)..].to_string();
+                        }
+                    }
+
+                    // something
+                    StackFrame::new(
+                        frame.module,
+                        frame.name,
+                        Some(s.to_string()),
+                        frame.relative_path,
+                        frame.absolute_path,
+                        frame.line,
+                    )
+                })
+                .collect();
+
+            let mut mystack = stacktrace.to_owned();
+
+            mystack.frames = new_frames;
+
+            (mystack, count.to_owned())
+        })
+        .collect();
+
+    Report::new(data).metadata(report.metadata.clone())
+}
+
+#[no_mangle]
+pub extern "C" fn initialize_logging(logging_level: u32) -> bool {
+    // Force rustc to display the log messages in the console.
+    match logging_level {
+        50 => {
+            std::env::set_var("RUST_LOG", "error");
+        }
+        40 => {
+            std::env::set_var("RUST_LOG", "warn");
+        }
+        30 => {
+            std::env::set_var("RUST_LOG", "info");
+        }
+        20 => {
+            std::env::set_var("RUST_LOG", "debug");
+        }
+        10 => {
+            std::env::set_var("RUST_LOG", "trace");
+        }
+        _ => {
+            std::env::set_var("RUST_LOG", "debug");
+        }
+    }
+
+    // Initialize the logger.
+    pretty_env_logger::init_timed();
+
+    true
+}
+
+#[no_mangle]
+/// # Safety
+/// All pointer arguments must be valid, non-null, null-terminated C strings.
+pub unsafe extern "C" fn initialize_agent(
+    application_name: *const c_char,
+    server_address: *const c_char,
+    basic_auth_user: *const c_char,
+    basic_auth_password: *const c_char,
+    sample_rate: u32,
+    oncpu: bool,
+    report_pid: bool,
+    report_thread_id: bool,
+    tags: *const c_char,
+    tenant_id: *const c_char,
+    http_headers_json: *const c_char,
+) -> bool {
+    let application_name = unsafe { CStr::from_ptr(application_name) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let server_address = unsafe { CStr::from_ptr(server_address) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let basic_auth_user = unsafe { CStr::from_ptr(basic_auth_user) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let basic_auth_password = unsafe { CStr::from_ptr(basic_auth_password) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let tags_string = unsafe { CStr::from_ptr(tags) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let tenant_id = unsafe { CStr::from_ptr(tenant_id) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let http_headers_json = unsafe { CStr::from_ptr(http_headers_json) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let pid = std::process::id();
+
+    let backend_config = BackendConfig {
+        report_thread_id,
+        report_thread_name: false,
+        report_pid,
+    };
+
+    let sampler = Sampler::new(pid as Pid, sample_rate, false, None, false, None, oncpu);
+
+    let tags_ref = tags_string.as_str();
+    let tags = string_to_tags(tags_ref);
+    let rbspy = BackendImpl::new(Box::new(Rbspy::new(sampler, sample_rate, backend_config)));
+
+    let mut agent_builder = PyroscopeAgentBuilder::new(
+        server_address,
+        application_name,
+        sample_rate,
+        RBSPY_NAME,
+        RBSPY_VERSION,
+        rbspy,
+    )
+    .func(transform_report_with_current_dir)
+    .tags(tags);
+
+    if !basic_auth_user.is_empty() && !basic_auth_password.is_empty() {
+        agent_builder = agent_builder.basic_auth(basic_auth_user, basic_auth_password);
+    }
+
+    if !tenant_id.is_empty() {
+        agent_builder = agent_builder.tenant_id(tenant_id);
+    }
+
+    let http_headers = pyroscope::pyroscope::parse_http_headers_json(http_headers_json);
+    match http_headers {
+        Ok(http_headers) => {
+            agent_builder = agent_builder.http_headers(http_headers);
+        }
+        Err(e) => match e {
+            pyroscope::PyroscopeError::Json(e) => {
+                log::error!(target: LOG_TAG, "parse_http_headers_json error {}", e);
+            }
+            pyroscope::PyroscopeError::AdHoc(e) => {
+                log::error!(target: LOG_TAG, "parse_http_headers_json {}", e);
+            }
+            _ => {}
+        },
+    }
+
+    pyroscope::ffikit::run(agent_builder).is_ok()
+}
+
+#[no_mangle]
+pub extern "C" fn drop_agent() -> bool {
+    pyroscope::ffikit::send(pyroscope::ffikit::Signal::Kill).is_ok()
+}
+
+#[no_mangle]
+/// # Safety
+/// `key` and `value` must be valid, non-null, null-terminated C strings.
+pub unsafe extern "C" fn add_thread_tag(key: *const c_char, value: *const c_char) -> bool {
+    let key = unsafe { CStr::from_ptr(key) }.to_str().unwrap().to_owned();
+    let value = unsafe { CStr::from_ptr(value) }
+        .to_str()
+        .unwrap()
+        .to_owned();
+
+    pyroscope::ffikit::send(pyroscope::ffikit::Signal::AddThreadTag(
+        backend::self_thread_id(),
+        Tag { key, value },
+    ))
+    .is_ok()
+}
+
+#[no_mangle]
+/// # Safety
+/// `key` and `value` must be valid, non-null, null-terminated C strings.
+pub unsafe extern "C" fn remove_thread_tag(key: *const c_char, value: *const c_char) -> bool {
+    let key = unsafe { CStr::from_ptr(key) }.to_str().unwrap().to_owned();
+    let value = unsafe { CStr::from_ptr(value) }
+        .to_str()
+        .unwrap()
+        .to_owned();
+
+    pyroscope::ffikit::send(pyroscope::ffikit::Signal::RemoveThreadTag(
+        backend::self_thread_id(),
+        Tag { key, value },
+    ))
+    .is_ok()
+}
+
+fn string_to_tags(tags: &str) -> Vec<(&str, &str)> {
+    let mut tags_vec = Vec::new();
+    // check if string is empty
+    if tags.is_empty() {
+        return tags_vec;
+    }
+
+    for tag in tags.split(',') {
+        let mut tag_split = tag.split('=');
+        let key = tag_split.next().unwrap();
+        let value = tag_split.next().unwrap();
+        tags_vec.push((key, value));
+    }
+
+    tags_vec
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pyroscope::backend::{Report, StackFrame, StackTrace};
+    use std::collections::HashMap;
+
+    fn report_with_filename(filename: &str) -> Report {
+        let stacktrace = StackTrace {
+            frames: vec![StackFrame {
+                filename: Some(filename.to_string()),
+                ..Default::default()
+            }],
+            ..Default::default()
+        };
+        Report::new(HashMap::from([(stacktrace, 1)]))
+    }
+
+    fn transformed_filename(report: Report) -> String {
+        let (stacktrace, _) = report.data.iter().next().unwrap();
+        stacktrace.frames[0].filename.clone().unwrap()
+    }
+
+    #[test]
+    fn transform_report_does_not_panic_when_cwd_is_a_suffix_of_filename() {
+        let report = report_with_filename("bin/rails");
+        let out = transform_report(report, Some("/rails"));
+        assert_eq!(transformed_filename(out), "bin/rails");
+    }
+
+    #[test]
+    fn transform_report_strips_cwd_prefix() {
+        let report = report_with_filename("/rails/app/models/user.rb");
+        let out = transform_report(report, Some("/rails"));
+        assert_eq!(transformed_filename(out), "app/models/user.rb");
+    }
+
+    #[test]
+    fn transform_report_rewrites_gems_path() {
+        let report =
+            report_with_filename("/usr/local/bundle/gems/activerecord-7.0.0/lib/active_record.rb");
+        let out = transform_report(report, None);
+        assert_eq!(
+            transformed_filename(out),
+            "gems/activerecord-7.0.0/lib/active_record.rb",
+        );
+    }
+
+    #[test]
+    fn transform_report_rewrites_ruby_stdlib_path() {
+        let report = report_with_filename("/usr/local/lib/ruby/3.3.0/json/common.rb");
+        let out = transform_report(report, None);
+        assert_eq!(transformed_filename(out), "json/common.rb");
+    }
+
+    #[test]
+    fn transform_report_leaves_unrelated_filename_unchanged() {
+        let report = report_with_filename("/tmp/unrelated.rb");
+        let out = transform_report(report, Some("/app"));
+        assert_eq!(transformed_filename(out), "/tmp/unrelated.rb");
+    }
+
+    #[test]
+    fn test_cargo_version_matches_ruby_version() {
+        let cargo_version = env!("CARGO_PKG_VERSION");
+        let version_rb = include_str!("../../../lib/pyroscope/version.rb");
+        let ruby_version = version_rb
+            .lines()
+            .find_map(|line| {
+                let line = line.trim();
+                if line.starts_with("VERSION") {
+                    let start = line.find('\'')?;
+                    let end = line.rfind('\'')?;
+                    if start < end {
+                        Some(&line[start + 1..end])
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            })
+            .expect("could not find VERSION in lib/pyroscope/version.rb");
+
+        assert_eq!(
+            cargo_version, ruby_version,
+            "Cargo.toml version ({cargo_version}) does not match lib/pyroscope/version.rb ({ruby_version})"
+        );
+    }
+}

data/lib/pyroscope/version.rb

@@ -1,3 +1,3 @@
 module Pyroscope
-  VERSION = '1.0.6'.freeze # x-release-please-version
+  VERSION = '1.0.7'.freeze # x-release-please-version
 end

data/pyroscope.gemspec

@@ -23,13 +23,19 @@ Gem::Specification.new do |s|
     "source_code_uri" => "https://github.com/grafana/pyroscope-ruby",
   }
 
-  # TODO: s.files is incomplete — ext/rbspy/ sources are missing, so building
-  # the gem from source does not work. See https://github.com/grafana/pyroscope-ruby/issues/2
   s.files = [
     "Gemfile",
     "Gemfile.lock",
     "LICENSE",
     "README.md",
+    "ext/rbspy/Cargo.lock",
+    "ext/rbspy/Cargo.toml",
+    "ext/rbspy/Rakefile",
+    "ext/rbspy/cbindgen.toml",
+    "ext/rbspy/extconf.rb",
+    "ext/rbspy/include/rbspy.h",
+    "ext/rbspy/src/backend.rs",
+    "ext/rbspy/src/lib.rs",
     "lib/pyroscope.rb",
     "lib/pyroscope/version.rb",
     "pyroscope.gemspec",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pyroscope
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
 platform: aarch64-linux
 authors:
 - Pyroscope Team
@@ -62,7 +62,14 @@ files:
 - Gemfile.lock
 - LICENSE
 - README.md
+- ext/rbspy/Cargo.lock
+- ext/rbspy/Cargo.toml
+- ext/rbspy/Rakefile
+- ext/rbspy/cbindgen.toml
 - ext/rbspy/extconf.rb
+- ext/rbspy/include/rbspy.h
+- ext/rbspy/src/backend.rs
+- ext/rbspy/src/lib.rs
 - lib/pyroscope.rb
 - lib/pyroscope/version.rb
 - lib/rbspy/rbspy.so