AgentSignal -> TimerSignal, move to timer/mod.rs

Author: drahnr

src/pyroscope.rs

@@ -11,33 +11,12 @@ use crate::{
     backends::{pprof::Pprof, Backend},
     error::Result,
     session::{Session, SessionManager, SessionSignal},
-    timer::Timer,
+    timer::{Timer, TimerSignal},
 };
 
 const LOG_TAG: &str = "Pyroscope::Agent";
 
 
-/// A signal sent from the agent to the timer.
-///
-/// Either schedules another wake-up, or asks
-/// the timer thread to terminate.
-#[derive(Debug, Clone, Copy)]
-pub enum AgentSignal {
-    // Thread termination was requested.
-    Terminate,
-    // When to take the next snapshot using the `Backend`.
-    NextSnapshot(u64),
-}
-
-impl std::fmt::Display for AgentSignal {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match self {
-            Self::Terminate => write!(f, "Terminate"),
-            Self::NextSnapshot(when) => write!(f, "NextSnapshot({})", when),
-        }
-    }
-}
-
 /// Pyroscope Agent Configuration. This is the configuration that is passed to the agent.
 /// # Example
 /// ```
@@ -275,7 +254,7 @@ impl PyroscopeAgentBuilder {
 pub struct PyroscopeAgent {
     timer: Timer,
     session_manager: SessionManager,
-    tx: Option<Sender<AgentSignal>>,
+    tx: Option<Sender<TimerSignal>>,
     handle: Option<JoinHandle<Result<()>>>,
     running: Arc<(Mutex<bool>, Condvar)>,
 
@@ -371,7 +350,7 @@ impl PyroscopeAgent {
 
             while let Ok(signal) = rx.recv() {
                 match signal {
-                    AgentSignal::NextSnapshot(until) => {
+                    TimerSignal::NextSnapshot(until) => {
                         log::trace!(target: LOG_TAG, "Sending session {}", until);
 
                         // Generate report from backend
@@ -384,7 +363,7 @@ impl PyroscopeAgent {
                             report,
                         )?))?
                     }
-                    AgentSignal::Terminate => {
+                    TimerSignal::Terminate => {
                         log::trace!(target: LOG_TAG, "Session Killed");
 
                         let (lock, cvar) = &*pair;
@@ -420,8 +399,8 @@ impl PyroscopeAgent {
         // get tx and send termination signal
         if let Some(sender) = self.tx.take() {
             // best effort
-            let _ = sender.send(AgentSignal::NextSnapshot(0));
-            sender.send(AgentSignal::Terminate)?;
+            let _ = sender.send(TimerSignal::NextSnapshot(0));
+            sender.send(TimerSignal::Terminate)?;
         } else {
             log::error!("PyroscopeAgent - Missing sender")
         }

src/timer/epoll.rs

@@ -4,7 +4,7 @@
 // https://www.apache.org/licenses/LICENSE-2.0>. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use crate::pyroscope::AgentSignal;
+use super::TimerSignal;
 use crate::utils::check_err;
 use crate::utils::get_time_range;
 use crate::PyroscopeError;
@@ -27,7 +27,7 @@ use std::{thread, thread::JoinHandle};
 #[derive(Debug)]
 pub struct Timer {
     /// A vector to store listeners (mpsc::Sender)
-    txs: Arc<Mutex<Vec<Sender<AgentSignal>>>>,
+    txs: Arc<Mutex<Vec<Sender<TimerSignal>>>>,
 
     /// Thread handle
     pub handle: Option<JoinHandle<Result<()>>>,
@@ -61,7 +61,7 @@ impl Timer {
                     Timer::epoll_wait(timer_fd, epoll_fd)?;
 
                     // Get the current time range
-                    let from = AgentSignal::NextSnapshot(get_time_range(0)?.from);
+                    let from = TimerSignal::NextSnapshot(get_time_range(0)?.from);
 
                     // Iterate through Senders
                     txs.lock()?.iter().for_each(|tx| {
@@ -165,7 +165,7 @@ impl Timer {
     ///
     /// Timer will dispatch an event with the timestamp of the current instant,
     /// every 10th second to all attached senders
-    pub fn attach_listener(&mut self, tx: Sender<AgentSignal>) -> Result<()> {
+    pub fn attach_listener(&mut self, tx: Sender<TimerSignal>) -> Result<()> {
         // Push Sender to a Vector of Sender(s)
         let txs = Arc::clone(&self.txs);
         txs.lock()?.push(tx);

src/timer/mod.rs

@@ -4,6 +4,27 @@
 // https://www.apache.org/licenses/LICENSE-2.0>. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
+/// A signal sent to the timer.
+///
+/// Either schedules another wake-up, or asks
+/// the timer thread to terminate.
+#[derive(Debug, Clone, Copy)]
+pub enum TimerSignal {
+    // Thread termination was requested.
+    Terminate,
+    // When to take the next snapshot using the `Backend`.
+    NextSnapshot(u64),
+}
+
+impl std::fmt::Display for TimerSignal {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::Terminate => write!(f, "Terminate"),
+            Self::NextSnapshot(when) => write!(f, "NextSnapshot({})", when),
+        }
+    }
+}
 // Possibly: ios, netbsd, openbsd, freebsd
 #[cfg(target_os = "macos")] pub mod kqueue;
 #[cfg(target_os = "macos")] pub use kqueue::Timer;

tests/timer.rs

@@ -1,4 +1,4 @@
-use pyroscope::{pyroscope::AgentSignal, timer::Timer};
+use pyroscope::timer::{TimerSignal, Timer};
 use assert_matches::assert_matches;
 
 #[test]
@@ -12,7 +12,7 @@ fn test_timer() {
 
     // Wait for event (should arrive in 10s)
     let planned = rx.recv().unwrap();
-    assert_matches!(planned, AgentSignal::NextSnapshot(planned) => {
+    assert_matches!(planned, TimerSignal::NextSnapshot(planned) => {
         // Get current time
         let now = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)