pyroscope 0.6.7 → 1.0.9

data/ext/rbspy/src/lib.rs

@@ -1,25 +1,26 @@
-use std::collections::hash_map::DefaultHasher;
+mod backend;
+
+use rbspy::sampler::Sampler;
+use remoteprocess::Pid;
 use std::env;
 use std::ffi::CStr;
-use std::hash::Hasher;
 use std::os::raw::c_char;
-use std::str::FromStr;
-
-use ffikit::Signal;
-use pyroscope_rbspy::{rbspy_backend, RbspyConfig};
 
-use pyroscope;
-use pyroscope::{pyroscope::Compression, PyroscopeAgent};
-use pyroscope::backend::{Report, StackFrame, Tag};
-use pyroscope::pyroscope::ReportEncoding;
+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) -> Report {
-    let cwd = env::current_dir().unwrap();
-    let cwd = cwd.to_str().unwrap_or("");
-
+pub fn transform_report(report: Report, cwd: Option<&str>) -> Report {
     let data = report
         .data
         .iter()
@@ -30,27 +31,18 @@ pub fn transform_report(report: Report) -> Report {
                 .map(|frame| {
                     let frame = frame.to_owned();
                     let mut s = frame.filename.unwrap();
-                    match s.find(cwd) {
-                        Some(i) => {
-                            s = s[(i + cwd.len() + 1)..].to_string();
+                    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();
                         }
-                        None => match s.find("/gems/") {
-                            Some(i) => {
-                                s = s[(i + 1)..].to_string();
-                            }
-                            None => match s.find("/ruby/") {
-                                Some(i) => {
-                                    s = s[(i + 6)..].to_string();
-                                    match s.find("/") {
-                                        Some(i) => {
-                                            s = s[(i + 1)..].to_string();
-                                        }
-                                        None => {}
-                                    }
-                                }
-                                None => {}
-                            },
-                        },
                     }
 
                     // something
@@ -73,9 +65,7 @@ pub fn transform_report(report: Report) -> Report {
         })
         .collect();
 
-    let new_report = Report::new(data).metadata(report.metadata.clone());
-
-    new_report
+    Report::new(data).metadata(report.metadata.clone())
 }
 
 #[no_mangle]
@@ -109,42 +99,27 @@ pub extern "C" fn initialize_logging(logging_level: u32) -> bool {
 }
 
 #[no_mangle]
-pub extern "C" fn initialize_agent(
+/// # 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,
-    auth_token: *const c_char,
     basic_auth_user: *const c_char,
     basic_auth_password: *const c_char,
     sample_rate: u32,
-    detect_subprocesses: bool,
     oncpu: bool,
     report_pid: bool,
     report_thread_id: bool,
     tags: *const c_char,
-    compression: *const c_char,
-    _report_encoding: *const c_char,
     tenant_id: *const c_char,
     http_headers_json: *const c_char,
 ) -> bool {
-    // Initialize FFIKit
-    let recv = ffikit::initialize_ffi().unwrap();
-
     let application_name = unsafe { CStr::from_ptr(application_name) }
         .to_str()
         .unwrap()
         .to_string();
 
-    let mut server_address = unsafe { CStr::from_ptr(server_address) }
-        .to_str()
-        .unwrap()
-        .to_string();
-
-    let adhoc_server_address = std::env::var("PYROSCOPE_ADHOC_SERVER_ADDRESS");
-    if let Ok(adhoc_server_address) = adhoc_server_address {
-        server_address = adhoc_server_address
-    }
-
-    let auth_token = unsafe { CStr::from_ptr(auth_token) }
+    let server_address = unsafe { CStr::from_ptr(server_address) }
         .to_str()
         .unwrap()
         .to_string();
@@ -164,11 +139,6 @@ pub extern "C" fn initialize_agent(
         .unwrap()
         .to_string();
 
-    let compression_string = unsafe { CStr::from_ptr(compression) }
-        .to_str()
-        .unwrap()
-        .to_string();
-
     let tenant_id = unsafe { CStr::from_ptr(tenant_id) }
         .to_str()
         .unwrap()
@@ -179,35 +149,36 @@ pub extern "C" fn initialize_agent(
         .unwrap()
         .to_string();
 
-    let compression = Compression::from_str(&compression_string);
-
     let pid = std::process::id();
 
-    let rbspy_config = RbspyConfig::new(pid.try_into().unwrap())
-        .sample_rate(sample_rate)
-        .lock_process(false)
-        .detect_subprocesses(detect_subprocesses)
-        .oncpu(oncpu)
-        .report_pid(report_pid)
-        .report_thread_id(report_thread_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 = rbspy_backend(rbspy_config);
-
-    let mut agent_builder = PyroscopeAgent::builder(server_address, application_name)
-        .backend(rbspy)
-        .func(transform_report)
-        .tags(tags)
-        .report_encoding(ReportEncoding::PPROF);
-
-    if auth_token != "" {
-        agent_builder = agent_builder.auth_token(auth_token);
-    } else if basic_auth_user != "" && basic_auth_password != "" {
+    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 != "" {
+    if !tenant_id.is_empty() {
         agent_builder = agent_builder.tenant_id(tenant_id);
     }
 
@@ -216,131 +187,60 @@ pub extern "C" fn initialize_agent(
         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);
-                }
-                _ => {}
+        Err(e) => match e {
+            pyroscope::PyroscopeError::Json(e) => {
+                log::error!(target: LOG_TAG, "parse_http_headers_json error {}", e);
             }
-        }
-    }
-
-    if let Ok(compression) = compression {
-        agent_builder = agent_builder.compression(compression);
-    }
-
-    let agent = agent_builder.build().unwrap();
-
-    let agent_running = agent.start().unwrap();
-
-    std::thread::spawn(move || {
-        while let Ok(signal) = recv.recv() {
-            match signal {
-                Signal::Kill => {
-                    agent_running.stop().unwrap();
-                    break;
-                }
-                Signal::AddGlobalTag(name, value) => {
-                    agent_running.add_global_tag(Tag::new(name, value)).unwrap();
-                }
-                Signal::RemoveGlobalTag(name, value) => {
-                    agent_running
-                        .remove_global_tag(Tag::new(name, value))
-                        .unwrap();
-                }
-                Signal::AddThreadTag(thread_id, key, value) => {
-                    let tag = Tag::new(key, value);
-                    agent_running.add_thread_tag(thread_id, tag).unwrap();
-                }
-                Signal::RemoveThreadTag(thread_id, key, value) => {
-                    let tag = Tag::new(key, value);
-                    agent_running.remove_thread_tag(thread_id, tag).unwrap();
-                }
+            pyroscope::PyroscopeError::AdHoc(e) => {
+                log::error!(target: LOG_TAG, "parse_http_headers_json {}", e);
             }
-        }
-    });
+            _ => {}
+        },
+    }
 
-    true
+    pyroscope::ffikit::run(agent_builder).is_ok()
 }
 
 #[no_mangle]
 pub extern "C" fn drop_agent() -> bool {
-    // Send Kill signal to the FFI merge channel.
-    ffikit::send(ffikit::Signal::Kill).unwrap();
-
-    true
-}
-
-#[no_mangle]
-pub extern "C" fn add_thread_tag(thread_id: u64, 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();
-
-    let pid = std::process::id();
-    let mut hasher = DefaultHasher::new();
-    hasher.write_u64(thread_id % pid as u64);
-    let id = hasher.finish();
-
-    ffikit::send(ffikit::Signal::AddThreadTag(id, key, value)).unwrap();
-
-    true
+    pyroscope::ffikit::send(pyroscope::ffikit::Signal::Kill).is_ok()
 }
 
 #[no_mangle]
-pub extern "C" fn remove_thread_tag(
-    thread_id: u64, key: *const c_char, value: *const c_char,
-) -> bool {
+/// # 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();
 
-    let pid = std::process::id();
-    let mut hasher = DefaultHasher::new();
-    hasher.write_u64(thread_id % pid as u64);
-    let id = hasher.finish();
-
-    ffikit::send(ffikit::Signal::RemoveThreadTag(id, key, value)).unwrap();
-
-    true
+    pyroscope::ffikit::send(pyroscope::ffikit::Signal::AddThreadTag(
+        backend::self_thread_id(),
+        Tag { key, value },
+    ))
+    .is_ok()
 }
 
 #[no_mangle]
-pub extern "C" fn add_global_tag(key: *const c_char, value: *const c_char) -> bool {
+/// # 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();
 
-    ffikit::send(ffikit::Signal::AddGlobalTag(key, value)).unwrap();
-
-    true
+    pyroscope::ffikit::send(pyroscope::ffikit::Signal::RemoveThreadTag(
+        backend::self_thread_id(),
+        Tag { key, value },
+    ))
+    .is_ok()
 }
 
-#[no_mangle]
-pub extern "C" fn remove_global_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();
-
-    ffikit::send(ffikit::Signal::RemoveGlobalTag(key, value)).unwrap();
-
-    true
-}
-
-// Convert a string of tags to a Vec<(&str, &str)>
-fn string_to_tags<'a>(tags: &'a str) -> Vec<(&'a str, &'a str)> {
+fn string_to_tags(tags: &str) -> Vec<(&str, &str)> {
     let mut tags_vec = Vec::new();
     // check if string is empty
     if tags.is_empty() {
@@ -356,3 +256,93 @@ fn string_to_tags<'a>(tags: &'a str) -> Vec<(&'a str, &'a str)> {
 
     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 = '0.6.7'.freeze
+  VERSION = '1.0.9'.freeze # x-release-please-version
 end

data/lib/pyroscope.rb

@@ -9,20 +9,12 @@ module Pyroscope
     extend FFI::Library
     ffi_lib File.expand_path(File.dirname(__FILE__)) + "/rbspy/rbspy.#{RbConfig::CONFIG["DLEXT"]}"
     attach_function :initialize_logging, [:int], :bool
-    attach_function :initialize_agent, [:string, :string, :string, :string, :string, :int, :bool, :bool, :bool, :bool, :string, :string, :string, :string, :string], :bool
-    attach_function :add_thread_tag, [:uint64, :string, :string], :bool
-    attach_function :remove_thread_tag, [:uint64, :string, :string], :bool
-    attach_function :add_global_tag, [:string, :string], :bool
-    attach_function :remove_global_tag, [:string, :string], :bool
+    attach_function :initialize_agent, [:string, :string, :string, :string, :int, :bool, :bool, :bool, :string, :string, :string], :bool
+    attach_function :add_thread_tag, [:string, :string], :bool
+    attach_function :remove_thread_tag, [:string, :string], :bool
     attach_function :drop_agent, [], :bool
   end
 
-  module Utils
-    extend FFI::Library
-    ffi_lib File.expand_path(File.dirname(__FILE__)) + "/thread_id/thread_id.#{RbConfig::CONFIG["DLEXT"]}"
-    attach_function :thread_id, [], :uint64
-  end
-
   if defined?(::Rails::Engine)
     class Engine < ::Rails::Engine
       config.after_initialize do
@@ -37,12 +29,10 @@ module Pyroscope
     :application_name,
     :app_name,
     :server_address,
-    :auth_token,
     :basic_auth_username,
     :basic_auth_password,
     :log_level,
     :sample_rate,
-    :detect_subprocesses,
     :oncpu,
     :report_pid,
     :report_thread_id,
@@ -58,11 +48,9 @@ module Pyroscope
       # defaults:
       self.application_name = ''
       self.server_address = 'http://localhost:4040'
-      self.auth_token = ''
       self.basic_auth_username = ''
       self.basic_auth_password = ''
       self.sample_rate = 100
-      self.detect_subprocesses = false
       self.oncpu = true
       self.report_pid = false
       self.report_thread_id = false
@@ -109,17 +97,13 @@ module Pyroscope
         # these are defaults in case user-provided values are nil:
         @config.app_name || @config.application_name || "",
         @config.server_address || "",
-        @config.auth_token || "",
         @config.basic_auth_username || "",
         @config.basic_auth_password || "",
         @config.sample_rate || 100,
-        @config.detect_subprocesses || false,
         @config.oncpu || false,
         @config.report_pid || false,
         @config.report_thread_id || false,
         tags_to_string(@config.tags || {}),
-        @config.compression || "",
-        @config.report_encoding || "pprof",
         @config.tenant_id || "",
         http_headers_to_json(@config.http_headers || {})
       )
@@ -137,12 +121,11 @@ module Pyroscope
     end
 
     def tag_wrapper(tags)
-      tid = thread_id
-      _add_tags(tid, tags)
+      _add_tags(tags)
       begin
         yield
       ensure
-        _remove_tags(tid, tags)
+        _remove_tags(tags)
       end
     end
 
@@ -154,19 +137,15 @@ module Pyroscope
       warn("deprecated. Use `Pyroscope.tag_wrapper` instead.")
     end
 
-    def thread_id
-      return Utils.thread_id
-    end
-
-    def _add_tags(thread_id, tags)
+    def _add_tags(tags)
       tags.each do |tag_name, tag_value|
-        Rust.add_thread_tag(thread_id, tag_name.to_s, tag_value.to_s)
+        Rust.add_thread_tag(tag_name.to_s, tag_value.to_s)
       end
     end
 
-    def _remove_tags(thread_id, tags)
+    def _remove_tags(tags)
       tags.each do |tag_name, tag_value|
-        Rust.remove_thread_tag(thread_id, tag_name.to_s, tag_value.to_s)
+        Rust.remove_thread_tag(tag_name.to_s, tag_value.to_s)
       end
     end
 

data/pyroscope.gemspec

@@ -14,55 +14,37 @@ Gem::Specification.new do |s|
   s.description = 'Pyroscope FFI Integration for Ruby'
   s.authors = ['Pyroscope Team']
   s.email = ['contact@pyroscope.io']
-  s.homepage = 'https://pyroscope.io'
+  s.homepage = 'https://grafana.com/oss/pyroscope/'
   s.license = 'Apache-2.0'
   s.metadata = {
-    "homepage_uri" => "https://pyroscope.io",
-    "bug_tracker_uri" => "https://github.com/pyroscope-io/pyroscope-rs/issues",
-    "documentation_uri" => "https://pyroscope.io/docs/ruby/",
-    "changelog_uri" => "https://github.com/pyroscope-io/pyroscope-rs/tree/main/pyroscope_ffi/ruby/CHANGELOG.md",
-    "source_code_uri" => "https://github.com/pyroscope-io/pyroscope-rs/tree/main/pyroscope_ffi/ruby",
+    "homepage_uri" => "https://grafana.com/oss/pyroscope/",
+    "bug_tracker_uri" => "https://github.com/grafana/pyroscope-ruby/issues",
+    "documentation_uri" => "https://grafana.com/docs/pyroscope/latest/configure-client/language-sdks/ruby/",
+    "source_code_uri" => "https://github.com/grafana/pyroscope-ruby",
   }
 
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  #s.files = Dir.chdir(__dir__) do
-    #`git ls-files -z`.split("\x0").reject do |f|
-      #(f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
-    #end
-  #end
-#   s.files = `git ls-files -z`.split("\0").reject { |f| f =~ /^(\.|G|spec|Rakefile)/ }
   s.files = [
     "Gemfile",
     "Gemfile.lock",
     "LICENSE",
-#     "Makefile",
     "README.md",
-#     "Rakefile",
+    "ext/rbspy/Cargo.lock",
     "ext/rbspy/Cargo.toml",
     "ext/rbspy/Rakefile",
-    "ext/rbspy/build.rs",
     "ext/rbspy/cbindgen.toml",
     "ext/rbspy/extconf.rb",
     "ext/rbspy/include/rbspy.h",
+    "ext/rbspy/src/backend.rs",
     "ext/rbspy/src/lib.rs",
-    "ext/thread_id/Cargo.toml",
-    "ext/thread_id/Rakefile",
-    "ext/thread_id/build.rs",
-    "ext/thread_id/cbindgen.toml",
-    "ext/thread_id/extconf.rb",
-    "ext/thread_id/include/thread_id.h",
-    "ext/thread_id/src/lib.rs",
     "lib/pyroscope.rb",
     "lib/pyroscope/version.rb",
     "pyroscope.gemspec",
-#     "scripts/tests/test.rb",
   ]
   s.platform = Gem::Platform::RUBY
 
   s.required_ruby_version = ">= 1.9.3"
 
-  s.extensions = ['ext/rbspy/extconf.rb', 'ext/thread_id/extconf.rb']
+  s.extensions = ['ext/rbspy/extconf.rb']
 
   s.add_dependency 'ffi'