pyroscope 1.0.9 → 1.1.0

data/ext/rbspy/src/timer/kqueue.rs

@@ -0,0 +1,191 @@
+use super::TimerSignal;
+use crate::{
+    utils::{check_err, get_time_range},
+    Result,
+};
+
+use std::sync::{
+    mpsc::{channel, Receiver, Sender},
+    Arc, Mutex,
+};
+use std::{
+    thread::{self, JoinHandle},
+    time::Duration,
+};
+
+const LOG_TAG: &str = "Pyroscope::Timer";
+
+/// A thread that sends a notification every 10th second
+///
+/// Timer will send an event to attached listeners (mpsc::Sender) every 10th
+/// second (...10, ...20, ...)
+///
+/// The Timer thread will run continously until all Senders are dropped.
+/// The Timer thread will be joined when all Senders are dropped.
+
+#[derive(Debug, Default)]
+pub struct Timer {
+    /// A vector to store listeners (mpsc::Sender)
+    txs: Arc<Mutex<Vec<Sender<TimerSignal>>>>,
+
+    /// Thread handle
+    pub handle: Option<JoinHandle<Result<()>>>,
+}
+
+impl Timer {
+    /// Initialize Timer and run a thread to send events to attached listeners
+    pub fn initialize(cycle: Duration) -> Result<Self> {
+        log::info!(target: LOG_TAG, "Initializing Timer");
+
+        let txs = Arc::new(Mutex::new(Vec::new()));
+
+        // Add Default tx
+        let (tx, _rx): (Sender<TimerSignal>, Receiver<TimerSignal>) = channel();
+        txs.lock()?.push(tx);
+
+        let kqueue = kqueue()?;
+
+        let handle = Some({
+            let txs = txs.clone();
+            thread::spawn(move || {
+                // Wait for initial expiration
+                let initial_event = Timer::register_initial_expiration(kqueue)?;
+                Timer::wait_event(kqueue, [initial_event].as_mut_ptr())?;
+
+                // Register loop event
+                let loop_event = Timer::register_loop_expiration(kqueue, cycle)?;
+
+                // Loop 10s
+                loop {
+                    // Exit thread if there are no listeners
+                    if txs.lock()?.is_empty() {
+                        // TODO: should close file descriptors?
+                        log::info!(target: LOG_TAG, "Timer thread terminated");
+                        return Ok(());
+                    }
+
+                    // Get current time
+                    let from = TimerSignal::NextSnapshot(get_time_range(0)?.from);
+
+                    // Iterate through Senders
+                    txs.lock()?.iter().for_each(|tx| {
+                        // Send event to attached Sender
+                        match tx.send(from) {
+                            Ok(_) => {
+                                log::trace!(target: LOG_TAG, "Sent event to listener @ {:?}", &tx)
+                            }
+                            Err(_e) => {} // There could be a less confusing message, or this
+                                          // refactored to avoid a first sender
+                                          //log::warn!(
+                                          //target: LOG_TAG,
+                                          //"Failed to send event to listener @ {:?} - {}",
+                                          //&tx,
+                                          //e
+                                          //),
+                        }
+                    });
+
+                    // Wait 10s
+                    Timer::wait_event(kqueue, [loop_event].as_mut_ptr())?;
+                }
+            })
+        });
+
+        Ok(Self { handle, txs })
+    }
+
+    /// Attach an mpsc::Sender to 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<TimerSignal>) -> Result<()> {
+        // Push Sender to a Vector of Sender(s)
+        let txs = Arc::clone(&self.txs);
+        txs.lock()?.push(tx);
+
+        Ok(())
+    }
+
+    /// Clear the listeners (txs) from Timer. This will shutdown the Timer thread
+    pub fn drop_listeners(&mut self) -> Result<()> {
+        let txs = Arc::clone(&self.txs);
+        txs.lock()?.clear();
+
+        Ok(())
+    }
+
+    /// Wait for the timer event
+    fn wait_event(kqueue: i32, events: *mut libc::kevent) -> Result<()> {
+        kevent(kqueue, [].as_mut_ptr(), 0, events, 1, std::ptr::null())?;
+        Ok(())
+    }
+
+    /// Register an initial expiration event
+    fn register_initial_expiration(kqueue: i32) -> Result<libc::kevent> {
+        // Get first event time
+        let first_fire = get_time_range(0)?.until;
+
+        let initial_event = libc::kevent {
+            ident: 1,
+            filter: libc::EVFILT_TIMER,
+            flags: libc::EV_ADD | libc::EV_ENABLE | libc::EV_ONESHOT,
+            fflags: libc::NOTE_ABSOLUTE | libc::NOTE_SECONDS,
+            data: first_fire as isize,
+            udata: std::ptr::null_mut::<libc::c_void>(),
+        };
+
+        // add first event
+        kevent(
+            kqueue,
+            [initial_event].as_ptr(),
+            1,
+            [].as_mut_ptr(),
+            0,
+            std::ptr::null(),
+        )?;
+
+        Ok(initial_event)
+    }
+
+    /// Register a loop expiration event
+    fn register_loop_expiration(kqueue: i32, duration: Duration) -> Result<libc::kevent> {
+        let loop_event = libc::kevent {
+            ident: 1,
+            filter: libc::EVFILT_TIMER,
+            flags: libc::EV_ADD | libc::EV_ENABLE,
+            fflags: 0,
+            data: duration.as_millis() as isize,
+            udata: std::ptr::null_mut::<libc::c_void>(),
+        };
+
+        // add loop event
+        kevent(
+            kqueue,
+            [loop_event].as_ptr(),
+            1,
+            [].as_mut_ptr(),
+            0,
+            std::ptr::null(),
+        )?;
+
+        Ok(loop_event)
+    }
+}
+
+/// libc::kqueue wrapper
+fn kqueue() -> Result<i32> {
+    check_err(unsafe { libc::kqueue() })
+}
+
+/// libc::kevent wrapper
+fn kevent(
+    kqueue: i32,
+    change: *const libc::kevent,
+    c_count: libc::c_int,
+    events: *mut libc::kevent,
+    e_count: libc::c_int,
+    timeout: *const libc::timespec,
+) -> Result<()> {
+    check_err(unsafe { libc::kevent(kqueue, change, c_count, events, e_count, timeout) })?;
+    Ok(())
+}

data/ext/rbspy/src/timer/mod.rs

@@ -0,0 +1,38 @@
+/// 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;
+
+// Possibly: android
+#[cfg(target_os = "linux")]
+pub mod epoll;
+#[cfg(target_os = "linux")]
+pub use epoll::Timer;
+
+#[cfg(not(any(target_os = "linux", target_os = "macos")))]
+pub mod sleep;
+#[cfg(not(any(target_os = "linux", target_os = "macos")))]
+pub use sleep::Timer;

data/ext/rbspy/src/timer/sleep.rs

@@ -0,0 +1,114 @@
+use super::TimerSignal;
+use crate::{utils::get_time_range, Result};
+
+use std::{
+    sync::{
+        mpsc::{channel, Receiver, Sender},
+        Arc, Mutex,
+    },
+    thread::{self, JoinHandle},
+    time::Duration,
+};
+
+const LOG_TAG: &str = "Pyroscope::Timer";
+
+/// A thread that sends a notification every 10th second
+///
+/// Timer will send an event to attached listeners (mpsc::Sender) every 10th
+/// second (...10, ...20, ...)
+///
+/// The Timer thread will run continously until all Senders are dropped.
+/// The Timer thread will be joined when all Senders are dropped.
+
+#[derive(Debug, Default)]
+pub struct Timer {
+    /// A vector to store listeners (mpsc::Sender)
+    txs: Arc<Mutex<Vec<Sender<TimerSignal>>>>,
+
+    /// Thread handle
+    pub handle: Option<JoinHandle<Result<()>>>,
+}
+
+impl Timer {
+    /// Initialize Timer and run a thread to send events to attached listeners
+    pub fn initialize(cycle: Duration) -> Result<Self> {
+        log::info!(target: LOG_TAG, "Initializing Timer");
+
+        let txs = Arc::new(Mutex::new(Vec::new()));
+
+        // Add Default tx
+        let (tx, _rx): (Sender<TimerSignal>, Receiver<TimerSignal>) = channel();
+        txs.lock()?.push(tx);
+
+        // Spawn a Thread
+        let handle = Some({
+            let txs = txs.clone();
+
+            thread::spawn(move || {
+                // Get remaining time for 10th second fire event
+                let rem = get_time_range(0)?.rem;
+
+                // Sleep for rem seconds
+                thread::sleep(Duration::from_secs(rem));
+
+                loop {
+                    // Exit thread if there are no listeners
+                    if txs.lock()?.len() == 0 {
+                        log::info!(target: LOG_TAG, "Timer thread terminated");
+
+                        return Ok(());
+                    }
+
+                    // Get current time
+                    let from = TimerSignal::NextSnapshot(get_time_range(0)?.from);
+
+                    log::trace!(target: LOG_TAG, "Timer fired @ {}", from);
+
+                    // Iterate through Senders
+                    txs.lock()?.iter().for_each(|tx| {
+                        // Send event to attached Sender
+                        // Send event to attached Sender
+                        match tx.send(from) {
+                            Ok(_) => {
+                                log::trace!(target: LOG_TAG, "Sent event to listener @ {:?}", &tx)
+                            }
+                            Err(_e) => {} // There could be a less confusing message, or this
+                                          // refactored to avoid a first sender
+                                          //log::warn!(
+                                          //target: LOG_TAG,
+                                          //"Failed to send event to listener @ {:?} - {}",
+                                          //&tx,
+                                          //e
+                                          //),
+                        }
+                    });
+
+                    // Sleep for 10s
+                    thread::sleep(cycle);
+                }
+            })
+        });
+
+        Ok(Self { handle, txs })
+    }
+
+    /// Attach an mpsc::Sender to 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<TimerSignal>) -> Result<()> {
+        // Push Sender to a Vector of Sender(s)
+        let txs = Arc::clone(&self.txs);
+        txs.lock()?.push(tx);
+
+        Ok(())
+    }
+
+    /// Clear the listeners (txs) from Timer. This will shutdown the Timer thread
+    pub fn drop_listeners(&mut self) -> Result<()> {
+        let txs = Arc::clone(&self.txs);
+        txs.lock()?.clear();
+
+        Ok(())
+    }
+}

data/ext/rbspy/src/utils.rs

@@ -0,0 +1,141 @@
+use std::fmt;
+
+use crate::{error::Result, PyroscopeError};
+
+/// Error Wrapper for libc return. Only check for errors.
+pub fn check_err<T: Ord + Default>(num: T) -> Result<T> {
+    if num < T::default() {
+        return Err(PyroscopeError::from(std::io::Error::last_os_error()));
+    }
+    Ok(num)
+}
+
+#[cfg(test)]
+mod check_err_tests {
+    use crate::utils::check_err;
+
+    #[test]
+    fn check_err_success() {
+        assert_eq!(check_err(1).unwrap(), 1)
+    }
+
+    #[test]
+    fn check_err_error() {
+        assert!(check_err(-1).is_err())
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub struct ThreadId {
+    pthread: libc::pthread_t,
+}
+
+// SAFETY: pthread_t is an opaque thread identifier used as a handle,
+// never dereferenced. On musl it's *mut c_void, on glibc it's c_ulong.
+unsafe impl Send for ThreadId {}
+unsafe impl Sync for ThreadId {}
+
+impl From<libc::pthread_t> for ThreadId {
+    fn from(value: libc::pthread_t) -> Self {
+        Self { pthread: value }
+    }
+}
+impl ThreadId {
+    pub fn pthread_self() -> Self {
+        Self {
+            pthread: unsafe { libc::pthread_self() },
+        }
+    }
+}
+
+impl fmt::Display for ThreadId {
+    #[cfg(target_env = "musl")]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", { self.pthread as libc::uintptr_t })
+    }
+    #[cfg(not(target_env = "musl"))]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", { self.pthread })
+    }
+}
+
+/// Return the current time in seconds.
+pub fn get_current_time_secs() -> Result<u64> {
+    Ok(std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)?
+        .as_secs())
+}
+
+#[cfg(test)]
+mod get_current_time_secs_tests {
+    use crate::utils::get_current_time_secs;
+
+    #[test]
+    fn get_current_time_secs_success() {
+        assert!(get_current_time_secs().is_ok())
+    }
+}
+
+/// A representation of a time range. The time range is represented by a start
+/// time, an end time, a current time and remaining time in seconds. The
+/// remaining time is the duration in seconds until the end time.
+#[derive(Debug, PartialEq)]
+pub struct TimeRange {
+    pub from: u64,
+    pub until: u64,
+    pub current: u64,
+    pub rem: u64,
+}
+
+/// Return a range of timestamps in the form [start, end).
+/// The range is inclusive of start and exclusive of end.
+pub fn get_time_range(timestamp: u64) -> Result<TimeRange> {
+    // if timestamp is 0, then get the current time
+    if timestamp == 0 {
+        return get_time_range(get_current_time_secs()?);
+    }
+
+    // Determine the start and end of the range
+    Ok(TimeRange {
+        from: timestamp / 10 * 10,
+        until: timestamp / 10 * 10 + 10,
+        current: timestamp,
+        rem: 10 - (timestamp % 10),
+    })
+}
+
+#[cfg(test)]
+mod get_time_range_tests {
+    use crate::utils::{get_time_range, TimeRange};
+
+    #[test]
+    fn get_time_range_verify() {
+        assert_eq!(
+            get_time_range(1644194479).unwrap(),
+            TimeRange {
+                from: 1644194470,
+                until: 1644194480,
+                current: 1644194479,
+                rem: 1,
+            }
+        );
+        assert_eq!(
+            get_time_range(1644194470).unwrap(),
+            TimeRange {
+                from: 1644194470,
+                until: 1644194480,
+                current: 1644194470,
+                rem: 10,
+            }
+        );
+        assert_eq!(
+            get_time_range(1644194476).unwrap(),
+            TimeRange {
+                from: 1644194470,
+                until: 1644194480,
+                current: 1644194476,
+                rem: 4,
+            }
+        );
+    }
+}

data/lib/pyroscope/version.rb

@@ -1,3 +1,3 @@
 module Pyroscope
-  VERSION = '1.0.9'.freeze # x-release-please-version
+  VERSION = '1.1.0'.freeze # x-release-please-version
 end

data/lib/pyroscope.rb

@@ -9,7 +9,7 @@ module Pyroscope
     extend FFI::Library
     ffi_lib File.expand_path(File.dirname(__FILE__)) + "/rbspy/rbspy.#{RbConfig::CONFIG["DLEXT"]}"
     attach_function :initialize_logging, [:int], :bool
-    attach_function :initialize_agent, [:string, :string, :string, :string, :int, :bool, :bool, :bool, :string, :string, :string], :bool
+    attach_function :initialize_agent, [:string, :string, :string, :string, :int, :bool, :bool, :bool, :string, :string, :string, :string, :string], :bool
     attach_function :add_thread_tag, [:string, :string], :bool
     attach_function :remove_thread_tag, [:string, :string], :bool
     attach_function :drop_agent, [], :bool
@@ -103,6 +103,8 @@ module Pyroscope
         @config.oncpu || false,
         @config.report_pid || false,
         @config.report_thread_id || false,
+        runtime_name,
+        runtime_version,
         tags_to_string(@config.tags || {}),
         @config.tenant_id || "",
         http_headers_to_json(@config.http_headers || {})
@@ -159,6 +161,14 @@ module Pyroscope
 
     private
 
+    def runtime_name
+      defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby"
+    end
+
+    def runtime_version
+      defined?(RUBY_ENGINE_VERSION) ? RUBY_ENGINE_VERSION : RUBY_VERSION
+    end
+
     def tags_to_string(tags)
       tags.map { |k, v| "#{k}=#{v}" }.join(',')
     end

data/pyroscope.gemspec

@@ -34,12 +34,10 @@ Gem::Specification.new do |s|
     "ext/rbspy/cbindgen.toml",
     "ext/rbspy/extconf.rb",
     "ext/rbspy/include/rbspy.h",
-    "ext/rbspy/src/backend.rs",
-    "ext/rbspy/src/lib.rs",
     "lib/pyroscope.rb",
     "lib/pyroscope/version.rb",
     "pyroscope.gemspec",
-  ]
+  ] + Dir["ext/rbspy/src/**/*.rs"].sort
   s.platform = Gem::Platform::RUBY
 
   s.required_ruby_version = ">= 1.9.3"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pyroscope
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.1.0
 platform: ruby
 authors:
 - Pyroscope Team
@@ -69,8 +69,28 @@ files:
 - ext/rbspy/cbindgen.toml
 - ext/rbspy/extconf.rb
 - ext/rbspy/include/rbspy.h
-- ext/rbspy/src/backend.rs
+- ext/rbspy/src/backend/backend.rs
+- ext/rbspy/src/backend/mod.rs
+- ext/rbspy/src/backend/ruleset.rs
+- ext/rbspy/src/backend/tests.rs
+- ext/rbspy/src/backend/types.rs
+- ext/rbspy/src/encode/gen/google.rs
+- ext/rbspy/src/encode/gen/mod.rs
+- ext/rbspy/src/encode/gen/push.rs
+- ext/rbspy/src/encode/gen/types.rs
+- ext/rbspy/src/encode/mod.rs
+- ext/rbspy/src/encode/pprof.rs
+- ext/rbspy/src/error.rs
+- ext/rbspy/src/ffikit.rs
 - ext/rbspy/src/lib.rs
+- ext/rbspy/src/pyroscope.rs
+- ext/rbspy/src/rbspy_backend.rs
+- ext/rbspy/src/session.rs
+- ext/rbspy/src/timer/epoll.rs
+- ext/rbspy/src/timer/kqueue.rs
+- ext/rbspy/src/timer/mod.rs
+- ext/rbspy/src/timer/sleep.rs
+- ext/rbspy/src/utils.rs
 - lib/pyroscope.rb
 - lib/pyroscope/version.rb
 - pyroscope.gemspec