pyroscope 0.6.7 → 1.0.9

data/ext/rbspy/Cargo.toml

@@ -1,21 +1,18 @@
 [package]
 name = "ffiruby"
-version = "0.1.0"
+version = "1.0.9" # x-release-please-version
 edition = "2021"
-rust-version = "1.64"
+rust-version = "1.66"
 
 [lib]
 name = "rbspy"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyroscope = { path = "../../../../" }
-pyroscope_rbspy = { path = "../../../../pyroscope_backends/pyroscope_rbspy" }
-ffikit = { path = "../../../ffikit" }
-# 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"
-
-[build-dependencies]
-cbindgen = "0.28"
-
+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/cbindgen.toml

@@ -1,15 +1,11 @@
-# The language to output bindings in
 language = "C"
 documentation_style = "C"
 
 style = "type"
 
-# An optional name to use as an include guard
 include_guard = "RBSPY_H_"
-# include a comment with the version of cbindgen used to generate the file
-include_version = true
+include_version = false
 
-# An optional string of text to output at the beginning of the generated file
 header = "/* Licensed under Apache-2.0 */"
 autogen_warning = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */"
 
@@ -18,5 +14,4 @@ tab_width = 2
 line_length = 80
 
 [parse]
-# Do not parse dependent crates
 parse_deps = false

data/ext/rbspy/include/rbspy.h

@@ -3,8 +3,6 @@
 #ifndef RBSPY_H_
 #define RBSPY_H_
 
-/* Generated with cbindgen:0.28.0 */
-
 /* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
 
 #include <stdarg.h>
@@ -14,30 +12,34 @@
 
 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 *auth_token,
                       const char *basic_auth_user,
                       const char *basic_auth_password,
                       uint32_t sample_rate,
-                      bool detect_subprocesses,
                       bool oncpu,
                       bool report_pid,
                       bool report_thread_id,
                       const char *tags,
-                      const char *compression,
-                      const char *_report_encoding,
                       const char *tenant_id,
                       const char *http_headers_json);
 
 bool drop_agent(void);
 
-bool add_thread_tag(uint64_t thread_id, const char *key, const char *value);
-
-bool remove_thread_tag(uint64_t thread_id, const char *key, const char *value);
-
-bool add_global_tag(const char *key, const char *value);
-
-bool remove_global_tag(const char *key, const char *value);
+/*
+ # 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()
+}