reafactor: introduce LOG_TAG

Author: drahnr

src/lib.rs

@@ -24,6 +24,8 @@
 //!  agent.stop();
 //! ```
 
+pub(crate) static LOG_TAG: &str = "pyroscope";
+
 // Re-exports structs
 pub use crate::pyroscope::PyroscopeAgent;
 pub use error::{PyroscopeError, Result};

src/pyroscope.rs

@@ -7,6 +7,9 @@ use std::{
     thread::JoinHandle,
 };
 
+// Licensed under the Apache License, Version 2.0 <LICENSE or
+// https://www.apache.org/licenses/LICENSE-2.0>. This file may not be copied, modified, or distributed
+// except according to those terms.
 use crate::{
     backends::{pprof::Pprof, Backend},
     error::Result,
@@ -175,15 +178,15 @@ impl PyroscopeAgentBuilder {
         // Initiliaze the backend
         let backend = Arc::clone(&self.backend);
         backend.lock()?.initialize(self.config.sample_rate)?;
-        log::trace!("PyroscopeAgent - Backend initialized");
+        log::trace!(target:  LOG_TAG, "Backend initialized");
 
         // Start Timer
         let timer = Timer::default().initialize()?;
-        log::trace!("PyroscopeAgent - Timer initialized");
+        log::trace!(target:  LOG_TAG, "Timer initialized");
 
         // Start the SessionManager
         let session_manager = SessionManager::new()?;
-        log::trace!("PyroscopeAgent - SessionManager initialized");
+        log::trace!(target:  LOG_TAG, "SessionManager initialized");
 
         // Return PyroscopeAgent
         Ok(PyroscopeAgent {
@@ -217,44 +220,44 @@ pub struct PyroscopeAgent {
 impl Drop for PyroscopeAgent {
     /// Properly shutdown the agent.
     fn drop(&mut self) {
-        log::debug!("PyroscopeAgent - Dropping Agent");
+        log::debug!(target:  LOG_TAG, "Dropping Agent");
 
         // Drop Timer listeners
         match self.timer.drop_listeners() {
-            Ok(_) => log::trace!("PyroscopeAgent - Dropped timer listeners"),
-            Err(_) => log::error!("PyroscopeAgent - Error Dropping timer listeners"),
+            Ok(_) => log::trace!(target:  LOG_TAG, "Dropped timer listeners"),
+            Err(_) => log::error!(target:  LOG_TAG, "Error Dropping timer listeners"),
         }
 
         // Wait for the Timer thread to finish
         if let Some(handle) = self.timer.handle.take() {
             match handle.join() {
-                Ok(_) => log::trace!("PyroscopeAgent - Dropped timer thread"),
-                Err(_) => log::error!("PyroscopeAgent - Error Dropping timer thread"),
+                Ok(_) => log::trace!(target:  LOG_TAG, "Dropped timer thread"),
+                Err(_) => log::error!(target:  LOG_TAG, "Error Dropping timer thread"),
             }
         }
 
         // Stop the SessionManager
         match self.session_manager.push(SessionSignal::Kill) {
-            Ok(_) => log::trace!("PyroscopeAgent - Sent kill signal to SessionManager"),
-            Err(_) => log::error!("PyroscopeAgent - Error sending kill signal to SessionManager"),
+            Ok(_) => log::trace!(target:  LOG_TAG, "Sent kill signal to SessionManager"),
+            Err(_) => log::error!(target:  LOG_TAG, "Error sending kill signal to SessionManager"),
         }
 
         if let Some(handle) = self.session_manager.handle.take() {
             match handle.join() {
-                Ok(_) => log::trace!("PyroscopeAgent - Dropped SessionManager thread"),
-                Err(_) => log::error!("PyroscopeAgent - Error Dropping SessionManager thread"),
+                Ok(_) => log::trace!(target:  LOG_TAG, "Dropped SessionManager thread"),
+                Err(_) => log::error!(target:  LOG_TAG, "Error Dropping SessionManager thread"),
             }
         }
 
         // Wait for main thread to finish
         if let Some(handle) = self.handle.take() {
             match handle.join() {
-                Ok(_) => log::trace!("PyroscopeAgent - Dropped main thread"),
-                Err(_) => log::error!("PyroscopeAgent - Error Dropping main thread"),
+                Ok(_) => log::trace!(target:  LOG_TAG, "Dropped main thread"),
+                Err(_) => log::error!(target:  LOG_TAG, "Error Dropping main thread"),
             }
         }
 
-        log::debug!("PyroscopeAgent - Agent Dropped");
+        log::debug!(target:  LOG_TAG, "Agent Dropped");
     }
 }
 
@@ -271,7 +274,7 @@ impl PyroscopeAgent {
     }
 
     fn _start(&mut self) -> Result<()> {
-        log::debug!("PyroscopeAgent - Starting");
+        log::debug!(target:  LOG_TAG, "Starting");
 
         // Create a clone of Backend
         let backend = Arc::clone(&self.backend);
@@ -294,10 +297,10 @@ impl PyroscopeAgent {
         let stx = self.session_manager.tx.clone();
 
         self.handle = Some(std::thread::spawn(move || {
-            log::trace!("PyroscopeAgent - Main Thread started");
+            log::trace!(target:  LOG_TAG, "Main Thread started");
 
             while let Ok(until) = rx.recv() {
-                log::trace!("PyroscopeAgent - Sending session {}", until);
+                log::trace!(target:  LOG_TAG, "Sending session {}", until);
 
                 // Generate report from backend
                 let report = backend.lock()?.report()?;
@@ -310,7 +313,7 @@ impl PyroscopeAgent {
                 )?))?;
 
                 if until == 0 {
-                    log::trace!("PyroscopeAgent - Session Killed");
+                    log::trace!(target:  LOG_TAG, "Session Killed");
 
                     let (lock, cvar) = &*pair;
                     let mut running = lock.lock()?;
@@ -334,13 +337,13 @@ impl PyroscopeAgent {
     /// ```
     pub fn start(&mut self) {
         match self._start() {
-            Ok(_) => log::trace!("PyroscopeAgent - Agent started"),
-            Err(_) => log::error!("PyroscopeAgent - Error starting agent"),
+            Ok(_) => log::trace!(target:  LOG_TAG, "Agent started"),
+            Err(_) => log::error!(target:  LOG_TAG, "Error starting agent"),
         }
     }
 
     fn _stop(&mut self) -> Result<()> {
-        log::debug!("PyroscopeAgent - Stopping");
+        log::debug!(target:  LOG_TAG, "Stopping");
         // get tx and send termination signal
         if let Some(sender) = self.tx.take() {
             sender.send(0)?;
@@ -371,8 +374,8 @@ impl PyroscopeAgent {
     /// ```
     pub fn stop(&mut self) {
         match self._stop() {
-            Ok(_) => log::trace!("PyroscopeAgent - Agent stopped"),
-            Err(_) => log::error!("PyroscopeAgent - Error stopping agent"),
+            Ok(_) => log::trace!(target:  LOG_TAG, "Agent stopped"),
+            Err(_) => log::error!(target:  LOG_TAG, "Error stopping agent"),
         }
     }
 
@@ -387,7 +390,7 @@ impl PyroscopeAgent {
     /// agent.stop()?;
     /// ```
     pub fn add_tags(&mut self, tags: &[(&str, &str)]) -> Result<()> {
-        log::debug!("PyroscopeAgent - Adding tags");
+        log::debug!(target:  LOG_TAG, "Adding tags");
         // Check that tags are not empty
         if tags.is_empty() {
             return Ok(());
@@ -430,7 +433,7 @@ impl PyroscopeAgent {
     /// # }
     /// ```
     pub fn remove_tags(&mut self, tags: &[&str]) -> Result<()> {
-        log::debug!("PyroscopeAgent - Removing tags");
+        log::debug!(target:  LOG_TAG, "Removing tags");
 
         // Check that tags are not empty
         if tags.is_empty() {