pyroscope 1.0.6-x86_64-linux → 1.0.7-x86_64-linux

data/ext/rbspy/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "ffiruby"
+version = "1.0.7" # x-release-please-version
+edition = "2021"
+rust-version = "1.66"
+
+[lib]
+name = "rbspy"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyroscope = { version="2.0.0", default-features = false, features = ["native-tls"] }
+rbspy = { version = "0.47" }
+remoteprocess = "0.5"
+pretty_env_logger = "0.5"
+log = "0.4"
+libc = "0.2"
+anyhow = "1.0"

data/ext/rbspy/Rakefile

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+class RbspyRakeCargoHelper
+  attr_reader :gemname
+
+  def initialize(gemname="rbspy")
+    @gemname = gemname
+  end
+
+  def self.command?(name)
+    exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+    ENV["PATH"].split(File::PATH_SEPARATOR).any? do |path|
+      exts.any? do |ext|
+        exe = File.join(path, "#{name}#{ext}")
+        File.executable?(exe) && !File.directory?(exe)
+      end
+    end
+  end
+
+  def self.rust_toolchain
+    # return env variable if set
+    target = ENV["RUST_TARGET"]
+    return target if target
+
+    str = `rustc --version --verbose`
+    info = str.lines.map {|l| l.chomp.split(/:\s+/, 2)}.drop(1).to_h
+    info["host"]
+  end
+
+  def self.cargo_target_dir
+    return @cargo_target_dir if defined? @cargo_target_dir
+
+    str = `cargo metadata --format-version 1 --offline --no-deps --quiet`
+    begin
+      require "json"
+      dir = JSON.parse(str)["target_directory"]
+    rescue LoadError # json is usually part of the stdlib, but just in case
+      /"target_directory"\s*:\s*"(?<dir>[^"]*)"/ =~ str
+    end
+    @cargo_target_dir = dir || "target"
+  end
+
+  def self.flags
+    cc_flags = Shellwords.split(RbConfig.expand(RbConfig::MAKEFILE_CONFIG["CC"].dup))
+
+    ["-C", "linker=#{cc_flags.shift}",
+      *cc_flags.flat_map {|a| ["-C", "link-arg=#{a}"] },
+      "-L", "native=#{RbConfig::CONFIG["libdir"]}",
+      *dld_flags,
+      *platform_flags,
+    ]
+  end
+
+  def self.dld_flags
+    Shellwords.split(RbConfig::CONFIG["DLDFLAGS"]).flat_map do |arg|
+      arg = arg.gsub(/\$\((\w+)\)/) do
+        $1 == "DEFFILE" ? nil : RbConfig::CONFIG[name]
+      end.strip
+      next [] if arg.empty?
+
+      transform_flag(arg)
+    end
+  end
+
+  def self.platform_flags
+    return unless RbConfig::CONFIG["target_os"] =~ /mingw/i
+
+    [*Shellwords.split(RbConfig::CONFIG["LIBRUBYARG"]).flat_map {|arg| transform_flag(arg)},
+      "-C", "link-arg=-Wl,--dynamicbase",
+      "-C", "link-arg=-Wl,--disable-auto-image-base",
+      "-C", "link-arg=-static-libgcc"]
+  end
+
+  def self.transform_flag(arg)
+    k, v = arg.split(/(?<=..)/, 2)
+    case k
+    when "-L"
+      [k, "native=#{v}"]
+    when "-l"
+      [k, v]
+    when "-F"
+      ["-l", "framework=#{v}"]
+    else
+      ["-C", "link_arg=#{k}#{v}"]
+    end
+  end
+
+  def install_dir
+    File.expand_path(File.join("..", "..", "lib", gemname), __dir__)
+  end
+
+  def rust_name
+    prefix = "lib" unless Gem.win_platform?
+    suffix = if RbConfig::CONFIG["target_os"] =~ /darwin/i
+      ".dylib"
+    elsif Gem.win_platform?
+      ".dll"
+    else
+      ".so"
+    end
+    "#{prefix}#{gemname}#{suffix}"
+  end
+
+  def ruby_name
+    "#{gemname}.#{RbConfig::CONFIG["DLEXT"]}"
+  end
+
+end
+
+task default: [:rbspy_install, :rbspy_clean]
+task rbspy: [:rbspy_install, :rbspy_clean]
+
+desc "set dev mode for subsequent task, run like `rake dev install`"
+task :rbspy_dev do
+  @dev = true
+end
+
+desc "build gem native extension and copy to lib"
+task rbspy_install: [:rbspy_cd, :rbspy_build] do
+  helper = RbspyRakeCargoHelper.new
+  profile_dir = @dev ? "debug" : "release"
+  arch_dir = RbspyRakeCargoHelper.rust_toolchain
+  source = File.join(RbspyRakeCargoHelper.cargo_target_dir, arch_dir, profile_dir, helper.rust_name)
+  dest = File.join(helper.install_dir, helper.ruby_name)
+  mkdir_p(helper.install_dir)
+  rm(dest) if File.exist?(dest)
+  cp(source, dest)
+end
+
+desc "build gem native extension"
+task rbspy_build: [:rbspy_cargo, :rbspy_cd] do
+  sh "cargo", "rustc", *(["--locked", "--release"] unless @dev), "--target=#{RbspyRakeCargoHelper.rust_toolchain}", "--", *RbspyRakeCargoHelper.flags
+end
+
+desc "clean up release build artifacts"
+task rbspy_clean: [:rbspy_cargo, :rbspy_cd] do
+  sh "cargo clean --release"
+end
+
+desc "clean up build artifacts"
+task rbspy_clobber: [:rbspy_cargo, :rbspy_cd] do
+  sh "cargo clean"
+end
+
+desc "check for cargo"
+task :rbspy_cargo do
+  raise <<-MSG unless RbspyRakeCargoHelper.command?("cargo")
+    This gem requires a Rust compiler and the `cargo' build tool to build the
+    gem's native extension. See https://www.rust-lang.org/tools/install for
+    how to install Rust. `cargo' is usually part of the Rust installation.
+  MSG
+
+  raise <<-MSG if Gem.win_platform? && RbspyRakeCargoHelper.rust_toolchain !~ /gnu/
+    Found Rust toolchain `#{RbspyRakeCargoHelper.rust_toolchain}' but the gem native
+    extension requires the gnu toolchain on Windows.
+  MSG
+end
+
+# ensure task is running in the right dir
+task :rbspy_cd do
+  cd(__dir__) unless __dir__ == pwd
+end

data/ext/rbspy/cbindgen.toml

@@ -0,0 +1,17 @@
+language = "C"
+documentation_style = "C"
+
+style = "type"
+
+include_guard = "RBSPY_H_"
+include_version = false
+
+header = "/* Licensed under Apache-2.0 */"
+autogen_warning = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */"
+
+braces = "SameLine"
+tab_width = 2
+line_length = 80
+
+[parse]
+parse_deps = false

data/ext/rbspy/include/rbspy.h

@@ -0,0 +1,45 @@
+/* Licensed under Apache-2.0 */
+
+#ifndef RBSPY_H_
+#define RBSPY_H_
+
+/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+bool initialize_logging(uint32_t logging_level);
+
+/*
+ # Safety
+ All pointer arguments must be valid, non-null, null-terminated C strings.
+ */
+bool initialize_agent(const char *application_name,
+                      const char *server_address,
+                      const char *basic_auth_user,
+                      const char *basic_auth_password,
+                      uint32_t sample_rate,
+                      bool oncpu,
+                      bool report_pid,
+                      bool report_thread_id,
+                      const char *tags,
+                      const char *tenant_id,
+                      const char *http_headers_json);
+
+bool drop_agent(void);
+
+/*
+ # Safety
+ `key` and `value` must be valid, non-null, null-terminated C strings.
+ */
+bool add_thread_tag(const char *key, const char *value);
+
+/*
+ # Safety
+ `key` and `value` must be valid, non-null, null-terminated C strings.
+ */
+bool remove_thread_tag(const char *key, const char *value);
+
+#endif  /* RBSPY_H_ */

data/ext/rbspy/src/backend.rs

@@ -0,0 +1,199 @@
+use pyroscope::{
+    backend::{
+        Backend, BackendConfig, Report, ReportBatch, ReportData, StackBuffer, StackFrame,
+        StackTrace, ThreadTag, ThreadTagsSet,
+    },
+    error::{PyroscopeError, Result},
+};
+use rbspy::sampler::Sampler;
+use std::{
+    ops::Deref,
+    sync::{
+        mpsc::{channel, sync_channel, Receiver, Sender, SyncSender},
+        Arc, Mutex,
+    },
+    thread::JoinHandle,
+};
+
+const LOG_TAG: &str = "Pyroscope::Rbspy";
+
+pub struct Rbspy {
+    sample_rate: u32,
+    backend_config: BackendConfig,
+    sampler: Sampler,
+    /// Error Receiver
+    error_receiver: Option<Receiver<std::result::Result<(), anyhow::Error>>>,
+    /// Profiling buffer
+    buffer: Arc<Mutex<StackBuffer>>,
+    /// Rulset
+    ruleset: ThreadTagsSet,
+}
+
+impl std::fmt::Debug for Rbspy {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Rbspy Backend")
+    }
+}
+
+impl Rbspy {
+    /// Create a new Rbspy instance
+    pub fn new(sampler: Sampler, sample_rate: u32, backend_config: BackendConfig) -> Self {
+        Rbspy {
+            sample_rate,
+            sampler,
+            backend_config,
+            error_receiver: None,
+            buffer: Arc::new(Mutex::new(StackBuffer::default())),
+            ruleset: ThreadTagsSet::default(),
+        }
+    }
+}
+
+// Type aliases
+type ErrorSender = Sender<std::result::Result<(), anyhow::Error>>;
+type ErrorReceiver = Receiver<std::result::Result<(), anyhow::Error>>;
+
+impl Backend for Rbspy {
+    fn add_tag(&self, tag: ThreadTag) -> Result<()> {
+        self.ruleset.add(tag)?;
+
+        Ok(())
+    }
+
+    fn remove_tag(&self, tag: ThreadTag) -> Result<()> {
+        self.ruleset.remove(tag)?;
+
+        Ok(())
+    }
+
+    /// Initialize the backend
+    fn initialize(&mut self) -> Result<()> {
+        // Channel for Errors generated by the RubySpy Sampler
+        let (error_sender, error_receiver): (ErrorSender, ErrorReceiver) = channel();
+
+        // This is provides enough space for 100 threads.
+        // It might be a better idea to figure out how many threads are running and determine the
+        // size of the channel based on that.
+        let queue_size: usize = self.sample_rate as usize * 10 * 100;
+
+        // Channel for StackTraces generated by the RubySpy Sampler
+        let (stack_sender, stack_receiver): (
+            SyncSender<rbspy::StackTrace>,
+            Receiver<rbspy::StackTrace>,
+        ) = sync_channel(queue_size);
+
+        // Set Error and Stack Receivers
+        // self.stack_receiver = Some(stack_receiver);
+        self.error_receiver = Some(error_receiver);
+
+        self.sampler
+            .start(stack_sender, error_sender)
+            .map_err(|e| PyroscopeError::new(&format!("Rbspy: Sampler Error: {}", e)))?;
+
+        // Start own thread
+        //
+        // Get an Arc reference to the Report Buffer
+        let buffer = self.buffer.clone();
+
+        // ruleset reference
+        let ruleset = self.ruleset.clone();
+
+        let backend_config = self.backend_config;
+
+        let _: JoinHandle<Result<()>> = std::thread::spawn(move || {
+            // Iterate over the StackTrace
+            while let Ok(stack_trace) = stack_receiver.recv() {
+                // convert StackTrace
+                let own_trace: StackTrace =
+                    Into::<StackTraceWrapper>::into((stack_trace, &backend_config)).into();
+
+                let stacktrace = own_trace.add_tag_rules(&ruleset);
+
+                buffer.lock()?.record(stacktrace)?;
+            }
+
+            Ok(())
+        });
+
+        Ok(())
+    }
+
+    fn shutdown(self: Box<Self>) -> Result<()> {
+        log::trace!(target: LOG_TAG, "Shutting down sampler thread");
+
+        self.sampler.stop();
+
+        Ok(())
+    }
+
+    fn report(&mut self) -> Result<ReportBatch> {
+        let v8: StackBuffer = self.buffer.lock()?.deref().to_owned();
+        let reports: Vec<Report> = v8.into();
+
+        self.buffer.lock()?.clear();
+
+        Ok(ReportBatch {
+            profile_type: "process_cpu".into(),
+            data: ReportData::Reports(reports),
+        })
+    }
+}
+
+struct StackFrameWrapper(StackFrame);
+
+impl From<StackFrameWrapper> for StackFrame {
+    fn from(frame: StackFrameWrapper) -> Self {
+        frame.0
+    }
+}
+
+impl From<rbspy::StackFrame> for StackFrameWrapper {
+    fn from(frame: rbspy::StackFrame) -> Self {
+        StackFrameWrapper(StackFrame {
+            module: None,
+            name: Some(frame.name),
+            filename: Some(frame.relative_path.clone()),
+            relative_path: Some(frame.relative_path),
+            absolute_path: frame.absolute_path,
+            line: frame.lineno.map(|l| l as u32),
+        })
+    }
+}
+
+struct StackTraceWrapper(StackTrace);
+
+impl From<StackTraceWrapper> for StackTrace {
+    fn from(trace: StackTraceWrapper) -> Self {
+        trace.0
+    }
+}
+
+impl From<(rbspy::StackTrace, &BackendConfig)> for StackTraceWrapper {
+    fn from(arg: (rbspy::StackTrace, &BackendConfig)) -> Self {
+        let (trace, config) = arg;
+
+        let thread_id = trace.thread_id.map(|tid| {
+            // for rbspy we use pthread_t as thread id
+            // https://github.com/ruby/ruby/blob/54a74c42033e42869e69e7dc9e67efa1faf225be/include/ruby/thread_native.h#L41
+            let thread_id = tid as libc::pthread_t;
+            thread_id.into()
+        });
+
+        StackTraceWrapper(StackTrace::new(
+            config,
+            trace.pid.map(|pid| pid as u32),
+            thread_id,
+            None,
+            trace
+                .iter()
+                .map(|frame| Into::<StackFrameWrapper>::into(frame.clone()).into())
+                .collect(),
+        ))
+    }
+}
+
+pub fn self_thread_id() -> pyroscope::ThreadId {
+    // for rbspy we use pthread_t as thread id
+    // https://github.com/ruby/ruby/blob/54a74c42033e42869e69e7dc9e67efa1faf225be/include/ruby/thread_native.h#L41
+    pyroscope::ThreadId::pthread_self()
+}