add labels, fix double ".cpu.cpu"

Author: korniltsev

pyroscope_ffi/ruby/ext/rbspy/src/lib.rs

@@ -146,7 +146,7 @@ pub extern "C" fn initialize_agent(
 
     let compression = Compression::from_str(&compression_string);
     let report_encoding = ReportEncoding::from_str(&report_encoding)
-        .unwrap_or(ReportEncoding::PPROF);
+        .unwrap_or(ReportEncoding::FOLDED);
 
     let pid = std::process::id();
 

src/encode/pprof.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use prost::Message;
 
 use crate::backend::types::{EncodedReport, Report};
-use crate::encode::profiles::{Function, Line, Location, Profile, Sample, ValueType};
+use crate::encode::profiles::{Function, Label, Line, Location, Profile, Sample, ValueType};
 
 
 struct PProfBuilder {
@@ -68,7 +68,7 @@ impl PProfBuilder {
     }
 }
 
-pub fn encode(reports: Vec<Report>) -> Vec<EncodedReport> {
+pub fn encode(reports: Vec<Report>, sample_rate: u32, start_time_nanos: u64, duration_nanos: u64) -> Vec<EncodedReport> {
     let mut b = PProfBuilder {
         strings: HashMap::new(),
         functions: HashMap::new(),
@@ -82,8 +82,8 @@ pub fn encode(reports: Vec<Report>) -> Vec<EncodedReport> {
             string_table: vec![],
             drop_frames: 0,
             keep_frames: 0,
-            time_nanos: 0,
-            duration_nanos: 0,
+            time_nanos: start_time_nanos as i64,
+            duration_nanos: duration_nanos as i64,
             period_type: None,
             period: 0,
             comment: vec![],
@@ -93,10 +93,16 @@ pub fn encode(reports: Vec<Report>) -> Vec<EncodedReport> {
     {
         let count = b.add_string(&"count".to_string());
         let samples = b.add_string(&"samples".to_string());
+        let milliseconds = b.add_string(&"milliseconds".to_string());
         b.profile.sample_type.push(ValueType {
             r#type: samples,
             unit: count,
         });
+        b.profile.period = 1_000 / sample_rate as i64;
+        b.profile.period_type = Some(ValueType {
+            r#type: 0,
+            unit: milliseconds,
+        })
     }
     for report in &reports {
         for (stacktrace, value) in &report.data {
@@ -115,6 +121,25 @@ pub fn encode(reports: Vec<Report>) -> Vec<EncodedReport> {
                 let location_id = b.add_location(function_id);
                 sample.location_id.push(location_id as u64);
             }
+            let mut labels = HashMap::new();
+            for l in &stacktrace.metadata.tags {
+                let k = b.add_string(&l.key);
+                let v = b.add_string(&l.value);
+                labels.insert(k, v);
+            }
+            for l in &report.metadata.tags {
+                let k = b.add_string(&l.key);
+                let v = b.add_string(&l.value);
+                labels.insert(k, v);
+            }
+            for (k, v) in &labels {
+                sample.label.push(Label {
+                    key: *k,
+                    str: *v,
+                    num: 0,
+                    num_unit: 0,
+                })
+            }
             b.profile.sample.push(sample);
         }
     }
@@ -126,4 +151,4 @@ pub fn encode(reports: Vec<Report>) -> Vec<EncodedReport> {
         data: b.profile.encode_to_vec(),
         metadata: Default::default(),
     }]
-}
+}

src/pyroscope.rs

@@ -20,6 +20,7 @@ use crate::{
 
 use crate::backend::BackendImpl;
 use crate::pyroscope::Compression::GZIP;
+use crate::pyroscope::ReportEncoding::{PPROF};
 
 const LOG_TAG: &str = "Pyroscope::Agent";
 
@@ -181,7 +182,8 @@ impl PyroscopeConfig {
             report_encoding: report_encoding,
             ..self
         }
-    }}
+    }
+}
 
 /// PyroscopeAgent Builder
 ///
@@ -353,8 +355,12 @@ impl PyroscopeAgentBuilder {
         // use match instead of if let to avoid the need to borrow
         let config = match self.backend.spy_extension()? {
             Some(extension) => {
-                let application_name = config.application_name.clone();
-                config.application_name(format!("{}.{}", application_name, extension))
+                if config.report_encoding == PPROF {
+                    config
+                } else {
+                    let application_name = config.application_name.clone();
+                    config.application_name(format!("{}.{}", application_name, extension))
+                }
             }
             None => config,
         };
@@ -390,7 +396,7 @@ impl PyroscopeAgentBuilder {
             handle: None,
             running: Arc::new((
                 #[allow(clippy::mutex_atomic)]
-                Mutex::new(false),
+                    Mutex::new(false),
                 Condvar::new(),
             )),
             _state: PhantomData,
@@ -413,10 +419,10 @@ impl FromStr for Compression {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, PartialEq, Debug)]
 pub enum ReportEncoding {
     FOLDED,
-    PPROF
+    PPROF,
 }
 
 impl FromStr for ReportEncoding {
@@ -425,7 +431,7 @@ impl FromStr for ReportEncoding {
         match input {
             "collapsed" => Ok(ReportEncoding::FOLDED),
             "folded" => Ok(ReportEncoding::FOLDED),
-            "PPROF" => Ok(ReportEncoding::PPROF),
+            "pprof" => Ok(ReportEncoding::PPROF),
             _ => Err(()),
         }
     }
@@ -447,7 +453,9 @@ pub struct PyroscopeAgentReady;
 pub struct PyroscopeAgentRunning;
 
 impl PyroscopeAgentState for PyroscopeAgentBare {}
+
 impl PyroscopeAgentState for PyroscopeAgentReady {}
+
 impl PyroscopeAgentState for PyroscopeAgentRunning {}
 
 /// PyroscopeAgent is the main object of the library. It is used to start and stop the profiler, schedule the timer, and send the profiler data to the server.
@@ -643,6 +651,7 @@ impl PyroscopeAgent<PyroscopeAgentReady> {
         Ok(self.transition())
     }
 }
+
 impl PyroscopeAgent<PyroscopeAgentRunning> {
     /// Stop the agent. The agent will stop profiling and send a last report to the server.
     ///

src/session.rs

@@ -13,7 +13,7 @@ use crate::{
     pyroscope::{PyroscopeConfig, Compression},
     utils::{get_time_range, merge_tags_with_app_name},
     Result,
-    encode::{folded, pprof}
+    encode::{folded, pprof},
 };
 use crate::backend::EncodedReport;
 use crate::pyroscope::ReportEncoding;
@@ -140,7 +140,6 @@ impl Session {
             return Ok(());
         }
 
-
         let reports = self.process_reports(&self.reports);
         let reports = self.encode_reports(reports);
         let reports = self.compress_reports(reports);
@@ -161,16 +160,20 @@ impl Session {
         }
     }
 
-    // Encode reports to folded or protobuf format
     fn encode_reports(&self, reports: Vec<Report>) -> Vec<EncodedReport> {
+        log::debug!(target: LOG_TAG, "Encoding {} reports to {:?}", reports.len(), self.config.report_encoding);
         match &self.config.report_encoding {
             ReportEncoding::FOLDED => folded::encode(reports),
-            ReportEncoding::PPROF => pprof::encode(reports),
+            ReportEncoding::PPROF => pprof::encode(reports,
+                                                   self.config.sample_rate,
+                                                   self.from * 1_000_000,
+                                                   (self.until - self.from) * 1_000_000,
+            ),
         }
     }
 
-    // Optionally compress reports
     fn compress_reports(&self, reports: Vec<EncodedReport>) -> Vec<EncodedReport> {
+        log::debug!(target: LOG_TAG, "Compressing {} reports to {:?}", reports.len(), self.config.compression);
         reports.into_iter().map(|r|
             match &self.config.compression {
                 None => r,

tests/session.rs

@@ -4,8 +4,6 @@ use pyroscope::{
     session::{Session, SessionManager, SessionSignal},
 };
 use std::collections::HashMap;
-use pyroscope::backend::{StackFrame, StackTrace};
-use pyroscope::pyroscope::ReportEncoding;
 
 #[test]
 fn test_session_manager_new() {
@@ -23,54 +21,20 @@ fn test_session_manager_push_kill() {
 #[test]
 fn test_session_new() {
     let config = PyroscopeConfig {
-        url: "http://localhost:4040".to_string(),
+        url: "http://localhost:8080".to_string(),
         application_name: "test".to_string(),
         tags: HashMap::new(),
         sample_rate: 100u32,
         spy_name: "test-rs".to_string(),
-        // report_encoding: ReportEncoding::PPROF,
-        report_encoding: ReportEncoding::FOLDED,
         ..Default::default()
     };
-    let f1 = StackFrame {
-        module: None,
-        name: Some("f1".to_string()),
 
-        filename: None,
-        relative_path: None,
-        absolute_path: None,
-        line: None,
-    };
-    let f2 = StackFrame {
-        module: None,
-        name: Some("f2".to_string()),
-        filename: None,
-        relative_path: None,
-        absolute_path: None,
-        line: None,
-    };
-
-    let s1 = StackTrace{
-        pid: None,
-        thread_id: None,
-        thread_name: None,
-        frames: vec![f1.clone(), f2.clone()],
-        metadata: Default::default()
-    };
-    let s2 = StackTrace{
-        pid: None,
-        thread_id: None,
-        thread_name: None,
-        frames: vec![f2.clone(), f1.clone()],
-        metadata: Default::default()
-    };
-
-
-    let report = vec![Report::new(HashMap::from([(s1, 2), (s2, 4)]))];
+    let report = vec![Report::new(HashMap::new())];
 
-    let session = Session::new(1661783070, config, report).unwrap();
+    let session = Session::new(1950, config, report).unwrap();
 
-    session.send().unwrap()
+    assert_eq!(session.from, 1940);
+    assert_eq!(session.until, 1950);
 }
 
 #[test]