imp(regex): initial regex implementation

Author: omarabid

Cargo.toml

@@ -57,6 +57,7 @@ names = "0.13.0"
 reqwest = { version = "0.11", features = ["blocking", "rustls-tls-native-roots"]}
 url = "2.2.2"
 libc = "^0.2.124"
+regex = "1"
 
 [dev-dependencies]
 tokio = { version = "1.18", features = ["full"] }

examples/regex.rs

@@ -0,0 +1,61 @@
+extern crate pyroscope;
+
+use pyroscope::{PyroscopeAgent, Result};
+use pyroscope_pprofrs::{pprof_backend, PprofConfig};
+use std::hash::{Hash, Hasher};
+
+fn hash_rounds(n: u64) -> u64 {
+    let hash_str = "Some string to hash";
+    let mut default_hasher = std::collections::hash_map::DefaultHasher::new();
+
+    for _ in 0..n {
+        for _ in 0..1000 {
+            default_hasher.write(hash_str.as_bytes());
+        }
+        hash_str.hash(&mut default_hasher);
+    }
+
+    n
+}
+
+fn main() -> Result<()> {
+    let agent = PyroscopeAgent::builder("http://localhost:4040", "example.regex")
+        .backend(pprof_backend(PprofConfig::new().sample_rate(100)))
+        .tags([("TagA", "ValueA"), ("TagB", "ValueB")].to_vec())
+        .regex(regex::Regex::new(r"std::").unwrap())
+        .build()?;
+
+    // Show start time
+    let start = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+    println!("Start Time: {}", start);
+
+    // Start Agent
+    let agent_running = agent.start()?;
+
+    let _result = hash_rounds(300_000);
+
+    // Show stop time
+    let stop = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+    println!("Stop Time: {}", stop);
+
+    // Stop Agent
+    let agent_ready = agent_running.stop()?;
+
+    // Shutdown the Agent
+    agent_ready.shutdown();
+
+    // Show program exit time
+    let exit = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+    println!("Exit Time: {}", exit);
+
+    Ok(())
+}

src/pyroscope.rs

@@ -1,3 +1,4 @@
+use regex::Regex;
 use std::{
     collections::HashMap,
     marker::PhantomData,
@@ -42,6 +43,8 @@ pub struct PyroscopeConfig {
     pub spy_name: String,
     /// Authentication Token
     pub auth_token: Option<String>,
+    /// Regex to apply
+    pub regex: Option<Regex>,
 }
 
 impl Default for PyroscopeConfig {
@@ -56,6 +59,7 @@ impl Default for PyroscopeConfig {
             sample_rate: 100u32,
             spy_name: "undefined".to_string(),
             auth_token: None,
+            regex: None,
         }
     }
 }
@@ -76,6 +80,7 @@ impl PyroscopeConfig {
             sample_rate: 100u32,          // Default sample rate
             spy_name: String::from("undefined"), // Spy Name should be set by the backend
             auth_token: None,             // No authentication token
+            regex: None,                  // No regex
         }
     }
 
@@ -116,6 +121,14 @@ impl PyroscopeConfig {
         }
     }
 
+    /// Set the Regex.
+    pub fn regex(self, regex: Regex) -> Self {
+        Self {
+            regex: Some(regex),
+            ..self
+        }
+    }
+
     /// Set the tags.
     ///
     /// # Example
@@ -243,6 +256,22 @@ impl PyroscopeAgentBuilder {
         }
     }
 
+    /// Set Regex.
+    /// This is optional. If not set, the agent will not apply any regex.
+    /// #Example
+    /// ```ignore
+    /// let builder = PyroscopeAgentBuilder::new("http://localhost:8080", "my-app")
+    /// .regex(Regex::new("^my-app.*").unwrap())
+    /// .build()
+    /// ?;
+    /// ```
+    pub fn regex(self, regex: Regex) -> Self {
+        Self {
+            config: self.config.regex(regex),
+            ..self
+        }
+    }
+
     /// Set tags. Default is empty.
     ///
     /// # Example

src/session.rs

@@ -151,7 +151,14 @@ impl Session {
         );
 
         // Convert a report to a byte array
-        let report_u8 = report.to_string().into_bytes();
+        let mut report_string = report.to_string();
+
+        // Apply Regex to the report
+        if let Some(regex) = self.config.regex.clone() {
+            report_string = regex.replace_all(&report_string, "").to_string();
+        }
+
+        let report_u8 = report_string.into_bytes();
 
         // Check if the report is empty
         if report_u8.is_empty() {