pyroscope 1.0.1 → 1.0.8

data/ext/rbspy/Cargo.toml

@@ -1,23 +1,18 @@
 [package]
 name = "ffiruby"
-version = "0.0.1"
+version = "1.0.8" # x-release-please-version
 edition = "2021"
-rust-version = "1.64"
+rust-version = "1.66"
 
 [lib]
 name = "rbspy"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyroscope = { path = "../../../../" }
-rbspy = { version="0.42" }
-remoteprocess = "0.5.0"
-anyhow = "1.0"
-# todo remove this dependency
+pyroscope = { version="2.0.0", default-features = false, features = ["native-tls"] }
+rbspy = { version = "0.48" }
+remoteprocess = "0.5"
 pretty_env_logger = "0.5"
 log = "0.4"
-libc = "0.2.180"
-
-[build-dependencies]
-cbindgen = "0.29"
-
+libc = "0.2"
+anyhow = "1.0"

data/ext/rbspy/Rakefile

@@ -5,7 +5,7 @@ require "shellwords"
 class RbspyRakeCargoHelper
   attr_reader :gemname
 
-  def initialize(gemname=File.basename(__dir__))
+  def initialize(gemname="rbspy")
     @gemname = gemname
   end
 

data/ext/rbspy/include/rbspy.h

@@ -12,6 +12,10 @@
 
 bool initialize_logging(uint32_t logging_level);
 
+/*
+ # Safety
+ All pointer arguments must be valid, non-null, null-terminated C strings.
+ */
 bool initialize_agent(const char *application_name,
                       const char *server_address,
                       const char *basic_auth_user,
@@ -26,8 +30,16 @@ bool initialize_agent(const char *application_name,
 
 bool drop_agent(void);
 
+/*
+ # Safety
+ `key` and `value` must be valid, non-null, null-terminated C strings.
+ */
 bool add_thread_tag(const char *key, const char *value);
 
+/*
+ # Safety
+ `key` and `value` must be valid, non-null, null-terminated C strings.
+ */
 bool remove_thread_tag(const char *key, const char *value);
 
 #endif  /* RBSPY_H_ */

data/ext/rbspy/src/backend.rs

@@ -0,0 +1,199 @@
+use pyroscope::{
+    backend::{
+        Backend, BackendConfig, Report, ReportBatch, ReportData, StackBuffer, StackFrame,
+        StackTrace, ThreadTag, ThreadTagsSet,
+    },
+    error::{PyroscopeError, Result},
+};
+use rbspy::sampler::Sampler;
+use std::{
+    ops::Deref,
+    sync::{
+        mpsc::{channel, sync_channel, Receiver, Sender, SyncSender},
+        Arc, Mutex,
+    },
+    thread::JoinHandle,
+};
+
+const LOG_TAG: &str = "Pyroscope::Rbspy";
+
+pub struct Rbspy {
+    sample_rate: u32,
+    backend_config: BackendConfig,
+    sampler: Sampler,
+    /// Error Receiver
+    error_receiver: Option<Receiver<std::result::Result<(), anyhow::Error>>>,
+    /// Profiling buffer
+    buffer: Arc<Mutex<StackBuffer>>,
+    /// Rulset
+    ruleset: ThreadTagsSet,
+}
+
+impl std::fmt::Debug for Rbspy {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Rbspy Backend")
+    }
+}
+
+impl Rbspy {
+    /// Create a new Rbspy instance
+    pub fn new(sampler: Sampler, sample_rate: u32, backend_config: BackendConfig) -> Self {
+        Rbspy {
+            sample_rate,
+            sampler,
+            backend_config,
+            error_receiver: None,
+            buffer: Arc::new(Mutex::new(StackBuffer::default())),
+            ruleset: ThreadTagsSet::default(),
+        }
+    }
+}
+
+// Type aliases
+type ErrorSender = Sender<std::result::Result<(), anyhow::Error>>;
+type ErrorReceiver = Receiver<std::result::Result<(), anyhow::Error>>;
+
+impl Backend for Rbspy {
+    fn add_tag(&self, tag: ThreadTag) -> Result<()> {
+        self.ruleset.add(tag)?;
+
+        Ok(())
+    }
+
+    fn remove_tag(&self, tag: ThreadTag) -> Result<()> {
+        self.ruleset.remove(tag)?;
+
+        Ok(())
+    }
+
+    /// Initialize the backend
+    fn initialize(&mut self) -> Result<()> {
+        // Channel for Errors generated by the RubySpy Sampler
+        let (error_sender, error_receiver): (ErrorSender, ErrorReceiver) = channel();
+
+        // This is provides enough space for 100 threads.
+        // It might be a better idea to figure out how many threads are running and determine the
+        // size of the channel based on that.
+        let queue_size: usize = self.sample_rate as usize * 10 * 100;
+
+        // Channel for StackTraces generated by the RubySpy Sampler
+        let (stack_sender, stack_receiver): (
+            SyncSender<rbspy::StackTrace>,
+            Receiver<rbspy::StackTrace>,
+        ) = sync_channel(queue_size);
+
+        // Set Error and Stack Receivers
+        // self.stack_receiver = Some(stack_receiver);
+        self.error_receiver = Some(error_receiver);
+
+        self.sampler
+            .start(stack_sender, error_sender)
+            .map_err(|e| PyroscopeError::new(&format!("Rbspy: Sampler Error: {}", e)))?;
+
+        // Start own thread
+        //
+        // Get an Arc reference to the Report Buffer
+        let buffer = self.buffer.clone();
+
+        // ruleset reference
+        let ruleset = self.ruleset.clone();
+
+        let backend_config = self.backend_config;
+
+        let _: JoinHandle<Result<()>> = std::thread::spawn(move || {
+            // Iterate over the StackTrace
+            while let Ok(stack_trace) = stack_receiver.recv() {
+                // convert StackTrace
+                let own_trace: StackTrace =
+                    Into::<StackTraceWrapper>::into((stack_trace, &backend_config)).into();
+
+                let stacktrace = own_trace.add_tag_rules(&ruleset);
+
+                buffer.lock()?.record(stacktrace)?;
+            }
+
+            Ok(())
+        });
+
+        Ok(())
+    }
+
+    fn shutdown(self: Box<Self>) -> Result<()> {
+        log::trace!(target: LOG_TAG, "Shutting down sampler thread");
+
+        self.sampler.stop();
+
+        Ok(())
+    }
+
+    fn report(&mut self) -> Result<ReportBatch> {
+        let v8: StackBuffer = self.buffer.lock()?.deref().to_owned();
+        let reports: Vec<Report> = v8.into();
+
+        self.buffer.lock()?.clear();
+
+        Ok(ReportBatch {
+            profile_type: "process_cpu".into(),
+            data: ReportData::Reports(reports),
+        })
+    }
+}
+
+struct StackFrameWrapper(StackFrame);
+
+impl From<StackFrameWrapper> for StackFrame {
+    fn from(frame: StackFrameWrapper) -> Self {
+        frame.0
+    }
+}
+
+impl From<rbspy::StackFrame> for StackFrameWrapper {
+    fn from(frame: rbspy::StackFrame) -> Self {
+        StackFrameWrapper(StackFrame {
+            module: None,
+            name: Some(frame.name),
+            filename: Some(frame.relative_path.clone()),
+            relative_path: Some(frame.relative_path),
+            absolute_path: frame.absolute_path,
+            line: frame.lineno.map(|l| l as u32),
+        })
+    }
+}
+
+struct StackTraceWrapper(StackTrace);
+
+impl From<StackTraceWrapper> for StackTrace {
+    fn from(trace: StackTraceWrapper) -> Self {
+        trace.0
+    }
+}
+
+impl From<(rbspy::StackTrace, &BackendConfig)> for StackTraceWrapper {
+    fn from(arg: (rbspy::StackTrace, &BackendConfig)) -> Self {
+        let (trace, config) = arg;
+
+        let thread_id = trace.thread_id.map(|tid| {
+            // for rbspy we use pthread_t as thread id
+            // https://github.com/ruby/ruby/blob/54a74c42033e42869e69e7dc9e67efa1faf225be/include/ruby/thread_native.h#L41
+            let thread_id = tid as libc::pthread_t;
+            thread_id.into()
+        });
+
+        StackTraceWrapper(StackTrace::new(
+            config,
+            trace.pid.map(|pid| pid as u32),
+            thread_id,
+            None,
+            trace
+                .iter()
+                .map(|frame| Into::<StackFrameWrapper>::into(frame.clone()).into())
+                .collect(),
+        ))
+    }
+}
+
+pub fn self_thread_id() -> pyroscope::ThreadId {
+    // for rbspy we use pthread_t as thread id
+    // https://github.com/ruby/ruby/blob/54a74c42033e42869e69e7dc9e67efa1faf225be/include/ruby/thread_native.h#L41
+    pyroscope::ThreadId::pthread_self()
+}

data/ext/rbspy/src/lib.rs

@@ -7,18 +7,20 @@ use std::ffi::CStr;
 use std::os::raw::c_char;
 
 use crate::backend::Rbspy;
-use pyroscope;
 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 = "1.0.1";
+const RBSPY_VERSION: &str = env!("CARGO_PKG_VERSION");
 
-pub fn transform_report(report: Report) -> Report {
-    let cwd = env::current_dir().unwrap();
-    let cwd = cwd.to_str().unwrap_or("");
+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()
@@ -29,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
@@ -72,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]
@@ -108,7 +99,9 @@ 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,
     basic_auth_user: *const c_char,
@@ -178,14 +171,14 @@ pub extern "C" fn initialize_agent(
         RBSPY_VERSION,
         rbspy,
     )
-    .func(transform_report)
+    .func(transform_report_with_current_dir)
     .tags(tags);
 
-    if basic_auth_user != "" && basic_auth_password != "" {
+    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);
     }
 
@@ -214,7 +207,9 @@ pub extern "C" fn drop_agent() -> bool {
 }
 
 #[no_mangle]
-pub extern "C" fn add_thread_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 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()
@@ -229,7 +224,9 @@ pub extern "C" fn add_thread_tag(key: *const c_char, value: *const c_char) -> bo
 }
 
 #[no_mangle]
-pub extern "C" fn remove_thread_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()
@@ -243,7 +240,7 @@ pub extern "C" fn remove_thread_tag(key: *const c_char, value: *const c_char) ->
     .is_ok()
 }
 
-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() {
@@ -259,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 = '1.0.1'.freeze
+  VERSION = '1.0.8'.freeze # x-release-please-version
 end

data/pyroscope.gemspec

@@ -14,42 +14,31 @@ 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",
     "lib/pyroscope.rb",
     "lib/pyroscope/version.rb",
     "pyroscope.gemspec",
-#     "scripts/tests/test.rb",
   ]
   s.platform = Gem::Platform::RUBY
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pyroscope
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.8
 platform: ruby
 authors:
 - Pyroscope Team
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-15 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -24,7 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  force_ruby_platform: false
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -65,26 +63,25 @@ files:
 - Gemfile.lock
 - LICENSE
 - README.md
+- 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
 - lib/pyroscope.rb
 - lib/pyroscope/version.rb
 - pyroscope.gemspec
-homepage: https://pyroscope.io
+homepage: https://grafana.com/oss/pyroscope/
 licenses:
 - Apache-2.0
 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
-post_install_message:
+  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
 rdoc_options: []
 require_paths:
 - lib
@@ -99,8 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Pyroscope
 test_files: []

data/ext/rbspy/build.rs

@@ -1,12 +0,0 @@
-extern crate cbindgen;
-
-use cbindgen::Config;
-
-fn main() {
-    let bindings = {
-        let crate_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
-        let config = Config::from_file("cbindgen.toml").unwrap();
-        cbindgen::generate_with_config(&crate_dir, config).unwrap()
-    };
-    bindings.write_to_file("include/rbspy.h");
-}