imp(timer): wrap return for initialize function

Author: omarabid

examples/internals-timer.rs

@@ -13,7 +13,7 @@ use pyroscope::timer::Timer;
 
 fn main() {
     // Initialize the Timer
-    let mut timer = Timer::default().initialize();
+    let mut timer = Timer::default().initialize().unwrap();
 
     // Create a streaming channel
     let (tx, rx): (Sender<u64>, Receiver<u64>) = channel();
@@ -24,6 +24,14 @@ fn main() {
     timer.attach_listener(tx).unwrap();
     timer.attach_listener(tx2).unwrap();
 
+    // Show current time
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+
+    println!("Current Time: {}", now);
+
     // Listen to the Timer events
     std::thread::spawn(move || {
         while let result = rx.recv() {

src/pyroscope.rs

@@ -123,7 +123,7 @@ impl PyroscopeAgentBuilder {
         backend.lock()?.initialize(self.config.sample_rate)?;
 
         // Start Timer
-        let timer = Timer::default().initialize();
+        let timer = Timer::default().initialize()?;
 
         // Return PyroscopeAgent
         Ok(PyroscopeAgent {

src/timer/epoll.rs

@@ -20,23 +20,22 @@ pub struct Timer {
 }
 
 impl Timer {
-    pub fn initialize(self) -> Self {
+    pub fn initialize(self) -> Result<Self> {
         let txs = Arc::clone(&self.txs);
 
-        // TODO: use ? instead of unwrap, requires changing Timer initialize function
-        let timer_fd = Timer::set_timerfd().unwrap();
-        let epoll_fd = Timer::create_epollfd(timer_fd).unwrap();
+        let timer_fd = Timer::set_timerfd()?;
+        let epoll_fd = Timer::create_epollfd(timer_fd)?;
 
         let handle = Some(thread::spawn(move || {
             loop {
                 // Exit thread if there are no listeners
                 if txs.lock()?.len() == 0 {
-                    // TODO: should close file descriptor
+                    // TODO: should close file descriptors?
                     return Ok(());
                 }
 
                 // Fire @ 10th sec
-                Timer::epoll_wait(timer_fd, epoll_fd).unwrap();
+                Timer::epoll_wait(timer_fd, epoll_fd)?;
 
                 // Get current time
                 let current = std::time::SystemTime::now()
@@ -51,23 +50,27 @@ impl Timer {
             }
         }));
 
-        Self { handle, ..self }
+        Ok(Self { handle, ..self })
     }
 
+    /// create and set a timer file descriptor
     fn set_timerfd() -> Result<libc::c_int> {
+        // Set the timer to use the system time.
         let clockid: libc::clockid_t = libc::CLOCK_REALTIME;
+        // Non-blocking file descriptor
         let clock_flags: libc::c_int = libc::TFD_NONBLOCK;
 
-        let tfd = timerfd_create(clockid, clock_flags).unwrap();
+        // Create timer fd
+        let tfd = timerfd_create(clockid, clock_flags)?;
 
+        // Get the next event time
         let now = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)?
             .as_secs();
-
         let rem = 10u64.checked_sub(now.checked_rem(10).unwrap()).unwrap();
-
         let first_fire = now + rem;
 
+        // new_value sets the Timer
         let mut new_value = libc::itimerspec {
             it_interval: libc::timespec {
                 tv_sec: 10,
@@ -79,6 +82,7 @@ impl Timer {
             },
         };
 
+        // Empty itimerspec object
         let mut old_value = libc::itimerspec {
             it_interval: libc::timespec {
                 tv_sec: 0,
@@ -92,35 +96,44 @@ impl Timer {
 
         let set_flags = libc::TFD_TIMER_ABSTIME;
 
-        timerfd_settime(tfd, set_flags, &mut new_value, &mut old_value).unwrap();
+        // Set the timer
+        timerfd_settime(tfd, set_flags, &mut new_value, &mut old_value)?;
 
+        // Return file descriptor
         Ok(tfd)
     }
 
+    /// Create a new epoll file descriptor and add the timer to its interests
     fn create_epollfd(timer_fd: libc::c_int) -> Result<libc::c_int> {
-        let epoll_fd = epoll_create1(0).unwrap();
+        // create a new epoll fd
+        let epoll_fd = epoll_create1(0)?;
 
+        // event to pull
         let mut event = libc::epoll_event {
             events: libc::EPOLLIN as u32,
             u64: 1,
         };
 
         let epoll_flags = libc::EPOLL_CTL_ADD;
 
-        epoll_ctl(epoll_fd, epoll_flags, timer_fd, &mut event).unwrap();
+        // add event to the epoll
+        epoll_ctl(epoll_fd, epoll_flags, timer_fd, &mut event)?;
 
+        // return epoll fd
         Ok(epoll_fd)
     }
 
     fn epoll_wait(timer_fd: libc::c_int, epoll_fd: libc::c_int) -> Result<()> {
+        // vector to store events
         let mut events = Vec::with_capacity(1);
 
-        epoll_wait(epoll_fd, events.as_mut_ptr(), 1, -1).unwrap();
+        // wait for the timer to fire an event. This is function will block.
+        epoll_wait(epoll_fd, events.as_mut_ptr(), 1, -1)?;
 
+        // read the value from the timerfd. This is required to re-arm the timer.
         let mut buffer: u64 = 0;
         let bufptr: *mut _ = &mut buffer;
-
-        read(timer_fd, bufptr as *mut libc::c_void, 8).unwrap();
+        read(timer_fd, bufptr as *mut libc::c_void, 8)?;
 
         Ok(())
     }

src/timer/kqueue.rs

@@ -19,8 +19,8 @@ pub struct Timer {
 }
 
 impl Timer {
-    pub fn initialize(self) -> Self {
-        self
+    pub fn initialize(self) -> Result<Self> {
+        Ok(self)
     }
 
     /// Attach an mpsc::Sender to Timer

src/timer/sleep.rs

@@ -28,7 +28,7 @@ pub struct Timer {
 
 impl Timer {
     /// Initialize Timer and run a thread to send events to attached listeners
-    pub fn initialize(self) -> Self {
+    pub fn initialize(self) -> Result<Self> {
         let txs = Arc::clone(&self.txs);
 
         // Add tx
@@ -69,7 +69,7 @@ impl Timer {
             }
         }));
 
-        Self { handle, ..self }
+        Ok(Self { handle, ..self })
     }
 
     /// Attach an mpsc::Sender to Timer