pyroscope 1.0.9 → 1.1.0

data/ext/rbspy/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ffiruby"
-version = "1.0.9" # x-release-please-version
+version = "1.1.0" # x-release-please-version
 edition = "2021"
 rust-version = "1.66"
 
@@ -9,10 +9,17 @@ name = "rbspy"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyroscope = { version="2.0.0", default-features = false, features = ["native-tls"] }
-rbspy = { version = "0.48" }
+rbspy = { version = "0.49" }
 remoteprocess = "0.5"
 pretty_env_logger = "0.5"
 log = "0.4"
 libc = "0.2"
 anyhow = "1.0"
+thiserror = "2.0"
+reqwest = { version = "0.13", default-features = false, features = ["blocking", "query", "native-tls"] }
+uuid = { version = "1.20.0", features = ["v4"] }
+url = "2.2.2"
+libflate = "2.1.0"
+prost = "0.14"
+serde_json = "1.0.115"
+lazy_static = "1.5.0"

data/ext/rbspy/include/rbspy.h

@@ -24,6 +24,8 @@ bool initialize_agent(const char *application_name,
                       bool oncpu,
                       bool report_pid,
                       bool report_thread_id,
+                      const char *runtime_name,
+                      const char *runtime_version,
                       const char *tags,
                       const char *tenant_id,
                       const char *http_headers_json);

data/ext/rbspy/src/backend/backend.rs

@@ -0,0 +1,134 @@
+#![allow(clippy::module_inception)]
+
+use crate::error::{PyroscopeError, Result};
+use std::{
+    fmt::Debug,
+    sync::{Arc, Mutex},
+};
+
+use super::{ReportBatch, ThreadTag};
+
+/// Backend Config
+#[derive(Debug, Copy, Clone, Default)]
+pub struct BackendConfig {
+    pub report_thread_id: bool,
+    pub report_thread_name: bool,
+    pub report_pid: bool,
+}
+
+/// Backend Trait
+pub trait Backend: Send {
+    /// Initialize the backend.
+    fn initialize(&mut self) -> Result<()>;
+    /// Drop the backend.
+    fn shutdown(self: Box<Self>) -> Result<()>;
+    /// Generate profiling report
+    fn report(&mut self) -> Result<ReportBatch>;
+    fn add_tag(&self, tag: ThreadTag) -> Result<()>;
+    fn remove_tag(&self, tag: ThreadTag) -> Result<()>;
+}
+
+/// Marker struct for Empty BackendImpl
+#[derive(Debug)]
+pub struct BackendBare;
+
+/// Marker struct for Uninitialized Backend
+#[derive(Debug)]
+pub struct BackendUninitialized;
+
+/// Marker struct for Initialized Backend
+#[derive(Debug)]
+pub struct BackendReady;
+
+/// Backend State Trait
+pub trait BackendState {}
+impl BackendState for BackendBare {}
+impl BackendState for BackendUninitialized {}
+impl BackendState for BackendReady {}
+
+/// Backend Accessibility Trait
+pub trait BackendAccessible: BackendState {}
+impl BackendAccessible for BackendUninitialized {}
+impl BackendAccessible for BackendReady {}
+
+/// Precursor Backend Implementation
+/// This struct is used to implement the Backend trait. It serves two purposes:
+/// 1. It enforces state transitions using the Type System.
+/// 2. It manages the lifetime of the backend through an Arc<Mutex<T>>.
+pub struct BackendImpl<S: BackendState + ?Sized> {
+    /// Backend
+    pub backend: Arc<Mutex<Option<Box<dyn Backend>>>>,
+
+    /// Backend State
+    _state: std::marker::PhantomData<S>,
+}
+
+impl BackendImpl<BackendBare> {
+    /// Create a new BackendImpl instance
+    pub fn new(backend_box: Box<dyn Backend>) -> BackendImpl<BackendUninitialized> {
+        BackendImpl {
+            backend: Arc::new(Mutex::new(Some(backend_box))),
+            _state: std::marker::PhantomData,
+        }
+    }
+}
+
+impl BackendImpl<BackendUninitialized> {
+    /// Initialize the backend
+    pub fn initialize(self) -> Result<BackendImpl<BackendReady>> {
+        let backend = self.backend.clone();
+
+        // Initialize the backend
+        backend
+            .lock()?
+            .as_mut()
+            .ok_or(PyroscopeError::BackendImpl)?
+            .initialize()?;
+
+        // Transition to BackendReady
+        Ok(BackendImpl {
+            backend,
+            _state: std::marker::PhantomData,
+        })
+    }
+}
+
+impl<S: BackendAccessible> BackendImpl<S> {
+    pub fn add_tag(&self, tag: ThreadTag) -> Result<()> {
+        self.backend
+            .lock()?
+            .as_ref()
+            .ok_or(PyroscopeError::BackendImpl)?
+            .add_tag(tag)
+    }
+
+    pub fn remove_tag(&self, rule: ThreadTag) -> Result<()> {
+        self.backend
+            .lock()?
+            .as_ref()
+            .ok_or(PyroscopeError::BackendImpl)?
+            .remove_tag(rule)
+    }
+}
+
+impl BackendImpl<BackendReady> {
+    /// Shutdown the backend and destroy BackendImpl
+    pub fn shutdown(self) -> Result<()> {
+        self.backend
+            .lock()?
+            .take()
+            .ok_or(PyroscopeError::BackendImpl)?
+            .shutdown()?;
+
+        Ok(())
+    }
+
+    /// Generate profiling report
+    pub fn report(&mut self) -> Result<ReportBatch> {
+        self.backend
+            .lock()?
+            .as_mut()
+            .ok_or(PyroscopeError::BackendImpl)?
+            .report()
+    }
+}

data/ext/rbspy/src/backend/mod.rs

@@ -0,0 +1,8 @@
+pub mod backend;
+pub mod ruleset;
+pub mod tests;
+pub mod types;
+
+pub use backend::*;
+pub use ruleset::*;
+pub use types::*;

data/ext/rbspy/src/backend/ruleset.rs

@@ -0,0 +1,82 @@
+use super::{StackTrace, Tag};
+use crate::error::Result;
+use std::collections::HashSet;
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub struct ThreadTag {
+    tid: crate::utils::ThreadId,
+    tag: Tag,
+}
+
+impl ThreadTag {
+    pub fn new(tid: crate::ThreadId, tag: Tag) -> Self {
+        Self { tid, tag }
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct ThreadTagsSet {
+    pub rules: Arc<Mutex<HashSet<ThreadTag>>>,
+}
+
+impl ThreadTagsSet {
+    pub fn new() -> Self {
+        Self {
+            rules: Arc::new(Mutex::new(HashSet::new())),
+        }
+    }
+
+    pub fn add(&self, rule: ThreadTag) -> Result<bool> {
+        let rules = self.rules.clone();
+
+        let insert = rules.lock()?.insert(rule);
+
+        Ok(insert)
+    }
+
+    pub fn remove(&self, rule: ThreadTag) -> Result<bool> {
+        let rules = self.rules.clone();
+
+        let remove = rules.lock()?.remove(&rule);
+
+        Ok(remove)
+    }
+
+    #[cfg(test)]
+    pub fn thread_tags(&self, tid: crate::ThreadId) -> Vec<Tag> {
+        let s = StackTrace {
+            pid: None,
+            thread_id: Some(tid.clone()),
+            thread_name: None,
+            frames: vec![],
+            metadata: Default::default(),
+        };
+        let tags: Vec<Tag> = s.add_tag_rules(self).metadata.tags.into_iter().collect();
+        tags
+    }
+}
+
+impl StackTrace {
+    pub fn add_tag_rules(self, other: &ThreadTagsSet) -> Self {
+        let mut metadata = self.metadata;
+
+        if let Ok(rules) = other.rules.lock() {
+            rules.iter().for_each(|rule| {
+                if let Some(stack_thread_id) = &self.thread_id {
+                    if rule.tid == *stack_thread_id {
+                        metadata.add_tag(rule.tag.clone());
+                    }
+                }
+            })
+        }
+
+        Self {
+            pid: self.pid,
+            thread_id: self.thread_id,
+            thread_name: self.thread_name,
+            frames: self.frames,
+            metadata,
+        }
+    }
+}

data/ext/rbspy/src/backend/tests.rs

@@ -0,0 +1,378 @@
+#[cfg(test)]
+use crate::backend::{
+    BackendConfig, Report, StackBuffer, StackFrame, StackTrace, Tag, ThreadTag, ThreadTagsSet,
+};
+#[cfg(test)]
+use std::collections::{HashMap, HashSet};
+
+#[test]
+fn test_stack_frame_display() {
+    let frame = StackFrame::new(
+        Some("module".to_string()),
+        Some("name".to_string()),
+        Some("filename".to_string()),
+        Some("relative_path".to_string()),
+        Some("absolute_path".to_string()),
+        Some(1),
+    );
+
+    assert_eq!(format!("{frame}"), "filename:1 - name");
+}
+
+#[test]
+fn test_stack_trace_display() {
+    let frames = vec![
+        StackFrame::new(
+            Some("module".to_string()),
+            Some("name".to_string()),
+            Some("filename".to_string()),
+            Some("relative_path".to_string()),
+            Some("absolute_path".to_string()),
+            Some(1),
+        ),
+        StackFrame::new(
+            Some("module".to_string()),
+            Some("name".to_string()),
+            Some("filename".to_string()),
+            Some("relative_path".to_string()),
+            Some("absolute_path".to_string()),
+            Some(2),
+        ),
+    ];
+
+    let stack_trace = StackTrace::new(&BackendConfig::default(), None, None, None, frames);
+
+    assert_eq!(
+        format!("{stack_trace}"),
+        "filename:2 - name;filename:1 - name"
+    );
+}
+
+#[test]
+fn test_report_record() {
+    let mut report = Report::new(HashMap::new());
+
+    let stack_trace = StackTrace::new(&BackendConfig::default(), None, None, None, vec![]);
+
+    report.record(stack_trace);
+    assert_eq!(report.data.len(), 1);
+}
+
+#[test]
+fn test_tag_new() {
+    let tag = Tag::new("key".to_string(), "value".to_string());
+
+    assert_eq!(tag.key, "key");
+    assert_eq!(tag.value, "value");
+}
+
+#[test]
+fn test_rule_new() {
+    let tid = crate::ThreadId::pthread_self();
+    let rule = ThreadTag::new(
+        tid.clone(),
+        Tag::new("key".to_string(), "value".to_string()),
+    );
+
+    assert_eq!(
+        rule,
+        ThreadTag::new(tid, Tag::new("key".to_string(), "value".to_string()))
+    );
+}
+
+#[cfg(test)]
+fn test_thread_id(v: u64) -> crate::utils::ThreadId {
+    (v as libc::pthread_t).into()
+}
+
+#[test]
+fn test_ruleset_new() {
+    let ruleset = ThreadTagsSet::new();
+
+    assert_eq!(ruleset.rules.lock().unwrap().len(), 0);
+}
+
+#[test]
+fn test_ruleset_add_rule() {
+    let tid = crate::ThreadId::pthread_self();
+    let ruleset = ThreadTagsSet::new();
+
+    let rule = ThreadTag::new(tid, Tag::new("key".to_string(), "value".to_string()));
+
+    ruleset.add(rule).unwrap();
+
+    assert_eq!(ruleset.rules.lock().unwrap().len(), 1);
+}
+
+#[test]
+fn test_ruleset_remove_rule() {
+    let tid = crate::ThreadId::pthread_self();
+    let ruleset = ThreadTagsSet::new();
+
+    let add_rule = ThreadTag::new(
+        tid.clone(),
+        Tag::new("key".to_string(), "value".to_string()),
+    );
+
+    ruleset.add(add_rule).unwrap();
+
+    assert_eq!(ruleset.rules.lock().unwrap().len(), 1);
+
+    let remove_rule = ThreadTag::new(tid, Tag::new("key".to_string(), "value".to_string()));
+
+    ruleset.remove(remove_rule).unwrap();
+
+    assert_eq!(ruleset.rules.lock().unwrap().len(), 0);
+}
+
+#[test]
+fn test_ruleset() {
+    let ruleset = ThreadTagsSet::new();
+
+    ruleset
+        .add(ThreadTag::new(
+            test_thread_id(1),
+            Tag::new("key1".to_string(), "value".to_string()),
+        ))
+        .unwrap();
+
+    ruleset
+        .add(ThreadTag::new(
+            test_thread_id(2),
+            Tag::new("key1".to_string(), "value".to_string()),
+        ))
+        .unwrap();
+
+    ruleset
+        .add(ThreadTag::new(
+            test_thread_id(3),
+            Tag::new("key1".to_string(), "value".to_string()),
+        ))
+        .unwrap();
+
+    // Remove ThreadTag number 2
+    ruleset
+        .remove(ThreadTag::new(
+            test_thread_id(2),
+            Tag::new("key1".to_string(), "value".to_string()),
+        ))
+        .unwrap();
+
+    // Verify ThreadTag number 2 is removed from the ruleset Vector
+    assert_eq!(
+        ruleset.rules.lock().unwrap().clone(),
+        HashSet::from([
+            ThreadTag::new(
+                test_thread_id(1),
+                Tag::new("key1".to_string(), "value".to_string(),)
+            ),
+            ThreadTag::new(
+                test_thread_id(3),
+                Tag::new("key1".to_string(), "value".to_string(),)
+            )
+        ])
+    );
+}
+
+#[test]
+fn test_ruleset_duplicates() {
+    let ruleset = ThreadTagsSet::new();
+
+    let tid = crate::ThreadId::pthread_self();
+    ruleset
+        .add(ThreadTag::new(
+            tid.clone(),
+            Tag::new("key1".to_string(), "value".to_string()),
+        ))
+        .unwrap();
+
+    ruleset
+        .add(ThreadTag::new(
+            tid.clone(),
+            Tag::new("key1".to_string(), "value".to_string()),
+        ))
+        .unwrap();
+
+    assert_eq!(
+        ruleset.thread_tags(tid),
+        vec![Tag::new("key1".to_string(), "value".to_string())]
+    );
+}
+
+#[test]
+fn test_ruleset_remove_nonexistent() {
+    let ruleset = ThreadTagsSet::new();
+
+    let tid = crate::ThreadId::pthread_self();
+    ruleset
+        .add(ThreadTag::new(
+            tid.clone(),
+            Tag::new("key1".to_string(), "value".to_string()),
+        ))
+        .unwrap();
+
+    ruleset
+        .remove(ThreadTag::new(
+            tid.clone(),
+            Tag::new("key2".to_string(), "value".to_string()),
+        ))
+        .unwrap();
+
+    assert_eq!(
+        ruleset.thread_tags(tid),
+        vec![Tag::new("key1".to_string(), "value".to_string())]
+    );
+}
+
+#[test]
+fn test_stacktrace_add() {
+    let ruleset = ThreadTagsSet::new();
+
+    ruleset
+        .add(ThreadTag::new(
+            test_thread_id(55),
+            Tag::new("keyA".to_string(), "valueA".to_string()),
+        ))
+        .unwrap();
+
+    ruleset
+        .add(ThreadTag::new(
+            test_thread_id(100),
+            Tag::new("keyB".to_string(), "valueB".to_string()),
+        ))
+        .unwrap();
+
+    let backend_config = BackendConfig {
+        report_pid: true,
+        report_thread_id: true,
+        report_thread_name: true,
+    };
+
+    let stacktrace = StackTrace::new(
+        &backend_config,
+        Some(1),
+        Some(test_thread_id(55)),
+        Some("thread_name".to_string()),
+        vec![crate::backend::StackFrame::new(
+            Some("file1".to_string()),
+            Some("function1".to_string()),
+            Some("file1".to_string()),
+            Some("file1".to_string()),
+            Some("file1".to_string()),
+            Some(1),
+        )],
+    );
+
+    // assert initial metadata of the stacktrace
+    let mut initial_metadata = crate::backend::Metadata::default();
+    initial_metadata.add_tag(Tag::new("pid".to_string(), "1".to_string()));
+    initial_metadata.add_tag(Tag::new("thread_id".to_string(), "55".to_string()));
+    initial_metadata.add_tag(Tag::new(
+        "thread_name".to_string(),
+        "thread_name".to_string(),
+    ));
+
+    assert_eq!(stacktrace.metadata, initial_metadata);
+
+    // Add the Stacktrace to the Ruleset
+    let applied_stacktrace = stacktrace.add_tag_rules(&ruleset);
+
+    initial_metadata.add_tag(Tag::new("keyA".to_string(), "valueA".to_string()));
+
+    // assert that the metadata of the stacktrace is updated
+    assert_eq!(applied_stacktrace.metadata, initial_metadata);
+
+    // Re-apply the Ruleset
+    let re_applied_stacktrace = applied_stacktrace.add_tag_rules(&ruleset);
+
+    // assert that the metadata of the stacktrace is the same
+    assert_eq!(re_applied_stacktrace.metadata, initial_metadata);
+}
+
+#[test]
+fn test_stackbuffer_record() {
+    let mut buffer = StackBuffer::new(HashMap::new());
+    let stack_trace = StackTrace::new(
+        &BackendConfig::default(),
+        None,
+        None,
+        None,
+        vec![StackFrame::new(
+            None,
+            Some("test_record".to_string()),
+            None,
+            None,
+            None,
+            None,
+        )],
+    );
+    // First record
+    buffer.record(stack_trace.clone()).unwrap();
+    assert_eq!(buffer.data.len(), 1);
+    assert_eq!(buffer.data[&stack_trace], 1);
+
+    // Second record
+    buffer.record(stack_trace.clone()).unwrap();
+    assert_eq!(buffer.data.len(), 1);
+    assert_eq!(buffer.data[&stack_trace], 2);
+}
+
+#[test]
+fn test_stackbuffer_record_with_count() {
+    let mut buffer = StackBuffer::new(HashMap::new());
+    let stack_trace = StackTrace::new(
+        &BackendConfig::default(),
+        None,
+        None,
+        None,
+        vec![StackFrame::new(
+            None,
+            Some("test_record".to_string()),
+            None,
+            None,
+            None,
+            None,
+        )],
+    );
+    // First record
+    buffer.record_with_count(stack_trace.clone(), 1).unwrap();
+    assert_eq!(buffer.data.len(), 1);
+    assert_eq!(buffer.data[&stack_trace], 1);
+
+    // Second record
+    buffer.record_with_count(stack_trace.clone(), 2).unwrap();
+    assert_eq!(buffer.data.len(), 1);
+    assert_eq!(buffer.data[&stack_trace], 3);
+}
+
+#[test]
+fn test_stackbuffer_clear() {
+    let mut buffer = StackBuffer::new(HashMap::new());
+    let stack_trace = StackTrace::new(
+        &BackendConfig::default(),
+        None,
+        None,
+        None,
+        vec![StackFrame::new(
+            None,
+            Some("test_record".to_string()),
+            None,
+            None,
+            None,
+            None,
+        )],
+    );
+    // First record
+    buffer.record(stack_trace.clone()).unwrap();
+    assert_eq!(buffer.data.len(), 1);
+    assert_eq!(buffer.data[&stack_trace], 1);
+
+    // Second record
+    buffer.record(stack_trace.clone()).unwrap();
+    assert_eq!(buffer.data.len(), 1);
+    assert_eq!(buffer.data[&stack_trace], 2);
+
+    // Clear
+    buffer.clear();
+    assert_eq!(buffer.data.len(), 0);
+}