Merge pull request #30 from pyroscope-io/0.5.2

0.5.2

Author: omarabid

CHANGELOG.md

@@ -1,3 +1,21 @@
+# v0.5.2
+## New features
+- Authentication Token support
+
+## API Changes
+- use rust-tls instead of openssl
+
+# v0.5.1
+## API Changes
+- Backend shutdown bug
+- Docs update
+
+# v0.5.0
+## API Changes
+- New API for building, starting and stopping the profiling agent.
+- Backend supports reporting multiple threads.
+- Tagging within local thread-scope
+
 # v0.4.0
 ## API Changes
 - Backend now support passing a configuration struct.

Cargo.toml

@@ -5,7 +5,7 @@ Pyroscope Profiler Agent for continuous profiling of Rust, Python and Ruby appli
 """
 keywords = ["pyroscope", "profiler", "profiling", "pprof"]
 authors = ["Abid Omar <[email protected]>"]
-version = "0.5.1"
+version = "0.5.2"
 edition = "2021"
 license = "Apache-2.0"
 homepage = "https://pyroscope.io/docs/rust"
@@ -53,7 +53,8 @@ path = "examples/internal/rbspy-connect.rs"
 [dependencies]
 thiserror ="1.0"
 log = "0.4"
-reqwest = { version = "0.11", features = ["blocking"]}
+names = "0.13.0"
+reqwest = { version = "0.11", features = ["blocking", "rustls-tls-native-roots"]}
 libc = "^0.2.124"
 
 [dev-dependencies]

README.md

@@ -32,7 +32,7 @@ Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-pyroscope = "0.5.0"
+pyroscope = "0.5.2"
 pyroscope_pprofrs = "0.2"
 ```
 
@@ -83,8 +83,7 @@ The Pyroscope Agent doesn't do any profiling. The agent role is to orchasrate a
 ### Limitations
 
 - **Backend**: The Pyroscope Agent uses [pprof-rs](https://github.com/tikv/pprof-rs) as a backend. As a result, the [limitations](https://github.com/tikv/pprof-rs#why-not-) for pprof-rs also applies.
-- **Tagging**: ~~Adding or removing tags is not possible within threads. In general, the [Pyroscope Agent](https://docs.rs/pyroscope/latest/pyroscope/pyroscope/struct.PyroscopeAgent.html) is not Sync; and as a result a reference cannot be shared between threads. A multi-threaded program could be profiled but the agent is not thread-aware and a particular thread cannot be tagged.~~
-As of 0.5.0, the Pyroscope Agent support tagging within threads. Check the [Tags](examples/tags.rs) and [Multi-Thread](examples/multi-thread.rs) examples for usage.
+- **Tagging**: As of 0.5.0, the Pyroscope Agent support tagging within threads. Check the [Tags](examples/tags.rs) and [Multi-Thread](examples/multi-thread.rs) examples for usage.
 - **Timer**: epoll (for Linux) and kqueue (for macOS) are required for a more precise timer.
 - **Shutdown**: The Pyroscope Agent might take some time (usually less than 10 seconds) to shutdown properly and drop its threads. For a proper shutdown, it's recommended that you run the `shutdown` function before dropping the Agent.
 

examples/auth.rs

@@ -0,0 +1,64 @@
+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<()> {
+    // TODO: Change this token to your own.
+    let token = String::from("<your-token>");
+
+    let agent = PyroscopeAgent::builder("http://localhost:4040", "example.basic")
+        .backend(pprof_backend(PprofConfig::new().sample_rate(100)))
+        .auth_token(token)
+        .tags([("TagA", "ValueA"), ("TagB", "ValueB")].to_vec())
+        .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(())
+}

pyroscope_cli/Cargo.lock

@@ -40,6 +40,24 @@ pub struct PyroscopeConfig {
     pub sample_rate: u32,
     /// Spy Name
     pub spy_name: String,
+    /// Authentication Token
+    pub auth_token: Option<String>,
+}
+
+impl Default for PyroscopeConfig {
+    fn default() -> Self {
+        Self {
+            url: "http://localhost:4040".to_string(),
+            application_name: names::Generator::default()
+                .next()
+                .unwrap_or_else(|| "unassigned.app".to_string())
+                .replace('-', "."),
+            tags: HashMap::new(),
+            sample_rate: 100u32,
+            spy_name: "undefined".to_string(),
+            auth_token: None,
+        }
+    }
 }
 
 impl PyroscopeConfig {
@@ -57,6 +75,23 @@ impl PyroscopeConfig {
             tags: HashMap::new(),         // Empty tags
             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
+        }
+    }
+
+    // Set the Pyroscope Server URL
+    pub fn url(self, url: impl AsRef<str>) -> Self {
+        Self {
+            url: url.as_ref().to_owned(),
+            ..self
+        }
+    }
+
+    // Set the Application Name
+    pub fn application_name(self, application_name: impl AsRef<str>) -> Self {
+        Self {
+            application_name: application_name.as_ref().to_owned(),
+            ..self
         }
     }
 
@@ -73,6 +108,14 @@ impl PyroscopeConfig {
         Self { spy_name, ..self }
     }
 
+    /// Set the Authentication Token.
+    pub fn auth_token(self, auth_token: String) -> Self {
+        Self {
+            auth_token: Some(auth_token),
+            ..self
+        }
+    }
+
     /// Set the tags.
     ///
     /// # Example
@@ -115,6 +158,15 @@ pub struct PyroscopeAgentBuilder {
     config: PyroscopeConfig,
 }
 
+impl Default for PyroscopeAgentBuilder {
+    fn default() -> Self {
+        Self {
+            backend: void_backend(VoidConfig::default()),
+            config: PyroscopeConfig::default(),
+        }
+    }
+}
+
 impl PyroscopeAgentBuilder {
     /// Create a new PyroscopeAgentBuilder object. url and application_name are required.
     /// tags and sample_rate are optional.
@@ -130,19 +182,67 @@ impl PyroscopeAgentBuilder {
         }
     }
 
+    /// Set the Pyroscope Server URL. This can be used if the Builder was initialized with the default
+    /// trait. Default is "http://localhost:4040".
+    ///
+    /// # Example
+    /// ```ignore
+    /// let builder = PyroscopeAgentBuilder::default()
+    /// .url("http://localhost:8080")
+    /// .build()?;
+    /// ```
+    pub fn url(self, url: impl AsRef<str>) -> Self {
+        Self {
+            config: self.config.url(url),
+            ..self
+        }
+    }
+
+    /// Set the Application Name. This can be used if the Builder was initialized with the default
+    /// trait. Default is a randomly generated name.
+    ///
+    /// # Example
+    /// ```ignore
+    /// let builder = PyroscopeAgentBuilder::default()
+    /// .application_name("my-app")
+    /// .build()?;
+    /// ```
+    pub fn application_name(self, application_name: impl AsRef<str>) -> Self {
+        Self {
+            config: self.config.application_name(application_name),
+            ..self
+        }
+    }
+
     /// Set the agent backend. Default is void-backend.
     ///
     /// # Example
     /// ```ignore
     /// let builder = PyroscopeAgentBuilder::new("http://localhost:8080", "my-app")
     /// .backend(PprofConfig::new().sample_rate(100))
-    /// .build()
-    /// ?;
+    /// .build()?;
     /// ```
     pub fn backend(self, backend: BackendImpl<BackendUninitialized>) -> Self {
         Self { backend, ..self }
     }
 
+    /// Set JWT authentication token.
+    /// This is optional. If not set, the agent will not send any authentication token.
+    ///
+    /// #Example
+    /// ```ignore
+    /// let builder = PyroscopeAgentBuilder::new("http://localhost:8080", "my-app")
+    /// .auth_token("my-token")
+    /// .build()
+    /// ?;
+    /// ```
+    pub fn auth_token(self, auth_token: impl AsRef<str>) -> Self {
+        Self {
+            config: self.config.auth_token(auth_token.as_ref().to_owned()),
+            ..self
+        }
+    }
+
     /// Set tags. Default is empty.
     ///
     /// # Example

src/pyroscope.rs

@@ -168,10 +168,22 @@ impl Session {
             report.metadata.tags.clone().into_iter().collect(),
         )?;
 
-        // Create and send the request
-        client
+        // Create Reqwest builder
+        let mut req_builder = client
             .post(format!("{}/ingest", url))
-            .header("Content-Type", "binary/octet-stream")
+            .header("Content-Type", "binary/octet-stream");
+
+        // Set authentication token
+        //if self.config.auth_token.is_some() {
+        //req_builder = req_builder.bearer_auth(self.config.auth_token.clone().unwrap());
+        //}
+        // rewrite with let some
+        if let Some(auth_token) = self.config.auth_token.clone() {
+            req_builder = req_builder.bearer_auth(auth_token);
+        }
+
+        // Send the request
+        req_builder
             .query(&[
                 ("name", application_name.as_str()),
                 ("from", &format!("{}", self.from)),

src/session.rs

@@ -157,7 +157,7 @@ impl Timer {
         };
 
         // add loop event
-        let ke = kevent(
+        let _ke = kevent(
             kqueue,
             [loop_event].as_ptr() as *const libc::kevent,
             1,

src/timer/kqueue.rs

@@ -26,6 +26,7 @@ fn test_session_new() {
         tags: HashMap::new(),
         sample_rate: 100u32,
         spy_name: "test-rs".to_string(),
+        ..Default::default()
     };
 
     let report = vec![Report::new(HashMap::new())];
@@ -44,6 +45,7 @@ fn test_session_send_error() {
         tags: HashMap::new(),
         sample_rate: 100u32,
         spy_name: "test-rs".to_string(),
+        ..Default::default()
     };
 
     let report = vec![Report::new(HashMap::new())];