pyroscope_beta 0.1.1

data/ext/rbspy/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "rbspy"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "rbspy"
+crate-type = ["cdylib"]
+
+[dependencies]
+rutie = "0.8.3"
+pyroscope = {version = "0.5" }
+pyroscope_rbspy = { version = "0.2" }

data/ext/rbspy/Rakefile

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+class RakeCargoHelper
+  attr_reader :gemname
+
+  def initialize(gemname=File.basename(__dir__))
+    @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
+    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: [:install, :clean]
+
+desc "set dev mode for subsequent task, run like `rake dev install`"
+task :dev do
+  @dev = true
+end
+
+desc "build gem native extension and copy to lib"
+task install: [:cd, :build] do
+  helper = RakeCargoHelper.new
+  profile_dir = @dev ? "debug" : "release"
+  source = File.join(RakeCargoHelper.cargo_target_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 build: [:cargo, :cd] do
+  sh "cargo", "rustc", *(["--locked", "--release"] unless @dev), "--", *RakeCargoHelper.flags
+end
+
+desc "clean up release build artifacts"
+task clean: [:cargo, :cd] do
+  sh "cargo clean --release"
+end
+
+desc "clean up build artifacts"
+task clobber: [:cargo, :cd] do
+  sh "cargo clean"
+end
+
+desc "check for cargo"
+task :cargo do
+  raise <<-MSG unless RakeCargoHelper.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? && RakeCargoHelper.rust_toolchain !~ /gnu/
+    Found Rust toolchain `#{RakeCargoHelper.rust_toolchain}' but the gem native
+    extension requires the gnu toolchain on Windows.
+  MSG
+end
+
+# ensure task is running in the right dir
+task :cd do
+  cd(__dir__) unless __dir__ == pwd
+end

data/ext/rbspy/extconf.rb

@@ -0,0 +1,11 @@
+require 'mkmf'
+require 'rake'
+
+create_makefile('rbspy')
+
+app = Rake.application
+app.init
+app.add_import 'Rakefile'
+app.load_rakefile
+
+app['default'].invoke

data/ext/rbspy/src/lib.rs

@@ -0,0 +1,156 @@
+use pyroscope::backend::Tag;
+use pyroscope::PyroscopeAgent;
+use pyroscope_rbspy::{rbspy_backend, RbspyConfig};
+use std::ffi::CStr;
+use std::mem::MaybeUninit;
+use std::os::raw::c_char;
+use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
+use std::sync::{Mutex, Once};
+
+pub enum Signal {
+    Kill,
+    AddTag(u64, String, String),
+    RemoveTag(u64, String, String),
+}
+
+pub struct SignalPass {
+    inner_sender: Mutex<SyncSender<Signal>>,
+    inner_receiver: Mutex<Receiver<Signal>>,
+}
+
+fn signalpass() -> &'static SignalPass {
+    static mut SIGNAL_PASS: MaybeUninit<SignalPass> = MaybeUninit::uninit();
+    static ONCE: Once = Once::new();
+
+    ONCE.call_once(|| unsafe {
+        let (sender, receiver) = sync_channel(1);
+        let singleton = SignalPass {
+            inner_sender: Mutex::new(sender),
+            inner_receiver: Mutex::new(receiver),
+        };
+        SIGNAL_PASS = MaybeUninit::new(singleton);
+    });
+
+    unsafe { SIGNAL_PASS.assume_init_ref() }
+}
+
+#[link(name = "pyroscope_ffi", vers = "0.1")]
+#[no_mangle]
+pub fn initialize_agent(
+    application_name: *const c_char, server_address: *const c_char, sample_rate: u32,
+    detect_subprocesses: bool, tags: *const c_char,
+) -> bool {
+    let application_name = unsafe { CStr::from_ptr(application_name) }
+        .to_str()
+        .unwrap()
+        .to_string();
+    let server_address = unsafe { CStr::from_ptr(server_address) }
+        .to_str()
+        .unwrap()
+        .to_string();
+    let tags_string = unsafe { CStr::from_ptr(tags) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let pid = std::process::id();
+
+    let s = signalpass();
+
+    std::thread::spawn(move || {
+        let rbspy_config = RbspyConfig::new(pid.try_into().unwrap())
+            .sample_rate(sample_rate)
+            .lock_process(false)
+            .with_subprocesses(detect_subprocesses);
+
+        let tags_ref = tags_string.as_str();
+        let tags = string_to_tags(tags_ref);
+        let rbspy = rbspy_backend(rbspy_config);
+        let agent = PyroscopeAgent::builder(server_address, application_name)
+            .backend(rbspy)
+            .tags(tags)
+            .build()
+            .unwrap();
+
+        let agent_running = agent.start().unwrap();
+
+        while let Ok(signal) = s.inner_receiver.lock().unwrap().recv() {
+            match signal {
+                Signal::Kill => {
+                    agent_running.stop().unwrap();
+                    break;
+                }
+                Signal::AddTag(thread_id, key, value) => {
+                    let tag = Tag::new(key, value);
+                    agent_running.add_thread_tag(thread_id, tag).unwrap();
+                }
+                Signal::RemoveTag(thread_id, key, value) => {
+                    let tag = Tag::new(key, value);
+                    agent_running.remove_thread_tag(thread_id, tag).unwrap();
+                }
+            }
+        }
+    });
+
+    true
+}
+
+#[link(name = "pyroscope_ffi", vers = "0.1")]
+#[no_mangle]
+pub fn drop_agent() -> bool {
+    let s = signalpass();
+    s.inner_sender.lock().unwrap().send(Signal::Kill).unwrap();
+    true
+}
+
+#[link(name = "pyroscope_ffi", vers = "0.1")]
+#[no_mangle]
+pub fn add_tag(thread_id: u64, key: *const c_char, value: *const c_char) -> bool {
+    let s = signalpass();
+    let key = unsafe { CStr::from_ptr(key) }.to_str().unwrap().to_owned();
+    let value = unsafe { CStr::from_ptr(value) }
+        .to_str()
+        .unwrap()
+        .to_owned();
+    s.inner_sender
+        .lock()
+        .unwrap()
+        .send(Signal::AddTag(thread_id, key, value))
+        .unwrap();
+    true
+}
+
+#[link(name = "pyroscope_ffi", vers = "0.1")]
+#[no_mangle]
+pub fn remove_tag(thread_id: u64, key: *const c_char, value: *const c_char) -> bool {
+    let s = signalpass();
+    let key = unsafe { CStr::from_ptr(key) }.to_str().unwrap().to_owned();
+    let value = unsafe { CStr::from_ptr(value) }
+        .to_str()
+        .unwrap()
+        .to_owned();
+    s.inner_sender
+        .lock()
+        .unwrap()
+        .send(Signal::RemoveTag(thread_id, key, value))
+        .unwrap();
+    true
+}
+
+// Convert a string of tags to a Vec<(&str, &str)>
+fn string_to_tags<'a>(tags: &'a str) -> Vec<(&'a str, &'a str)> {
+    let mut tags_vec = Vec::new();
+    // check if string is empty
+    if tags.is_empty() {
+        return tags_vec;
+    }
+
+    for tag in tags.split(',') {
+        let mut tag_split = tag.split('=');
+        let key = tag_split.next().unwrap();
+        let value = tag_split.next().unwrap();
+        tags_vec.push((key, value));
+    }
+
+    tags_vec
+}

data/ext/thread_id/Cargo.lock

@@ -0,0 +1,16 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "libc"
+version = "0.2.125"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5916d2ae698f6de9bfb891ad7a8d65c09d232dc58cc4ac433c7da3b2fd84bc2b"
+
+[[package]]
+name = "thread_id"
+version = "0.1.0"
+dependencies = [
+ "libc",
+]

data/ext/thread_id/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "thread_id"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "thread_id"
+crate-type = ["cdylib"]
+
+[dependencies]
+libc = "*"

data/ext/thread_id/Rakefile

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+class RakeCargoHelper
+  attr_reader :gemname
+
+  def initialize(gemname=File.basename(__dir__))
+    @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
+    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: [:install, :clean]
+
+desc "set dev mode for subsequent task, run like `rake dev install`"
+task :dev do
+  @dev = true
+end
+
+desc "build gem native extension and copy to lib"
+task install: [:cd, :build] do
+  helper = RakeCargoHelper.new
+  profile_dir = @dev ? "debug" : "release"
+  source = File.join(RakeCargoHelper.cargo_target_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 build: [:cargo, :cd] do
+  sh "cargo", "rustc", *(["--locked", "--release"] unless @dev), "--", *RakeCargoHelper.flags
+end
+
+desc "clean up release build artifacts"
+task clean: [:cargo, :cd] do
+  sh "cargo clean --release"
+end
+
+desc "clean up build artifacts"
+task clobber: [:cargo, :cd] do
+  sh "cargo clean"
+end
+
+desc "check for cargo"
+task :cargo do
+  raise <<-MSG unless RakeCargoHelper.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? && RakeCargoHelper.rust_toolchain !~ /gnu/
+    Found Rust toolchain `#{RakeCargoHelper.rust_toolchain}' but the gem native
+    extension requires the gnu toolchain on Windows.
+  MSG
+end
+
+# ensure task is running in the right dir
+task :cd do
+  cd(__dir__) unless __dir__ == pwd
+end

data/ext/thread_id/extconf.rb

@@ -0,0 +1,11 @@
+require 'mkmf'
+require 'rake'
+
+create_makefile('thread_id')
+
+app = Rake.application
+app.init
+app.add_import 'Rakefile'
+app.load_rakefile
+
+app['default'].invoke

data/ext/thread_id/src/lib.rs

@@ -0,0 +1,4 @@
+#[no_mangle]
+pub extern "C" fn thread_id() -> u64 {
+    unsafe { libc::pthread_self() as u64 }
+}

data/lib/pyroscope/version.rb

@@ -0,0 +1,3 @@
+module Pyroscope
+  VERSION = '0.1.1'.freeze
+end

data/lib/pyroscope_beta.rb

@@ -0,0 +1,87 @@
+require 'ffi'
+require 'fiddle'
+
+$libm = Fiddle.dlopen(File.expand_path(File.dirname(__FILE__)) + '/thread_id/thread_id.so')
+
+
+module Rust
+  extend FFI::Library
+  ffi_lib File.expand_path(File.dirname(__FILE__)) + '/rbspy/rbspy.' + FFI::Platform::LIBSUFFIX
+  attach_function :initialize_agent, [:string, :string, :int, :bool, :string], :bool
+  attach_function :add_tag, [:uint64, :string, :string], :bool
+  attach_function :remove_tag, [:uint64, :string, :string], :bool
+  attach_function :drop_agent, [], :bool
+end
+
+module Pyroscope
+  Config = Struct.new(:application_name, :server_address, :sample_rate, :detect_subprocesses, :log_level, :tags) do
+    def initialize(*)
+      super
+      self.application_name ||= ''
+      self.server_address ||= 'http://localhost:4040'
+      self.sample_rate ||= 100
+      self.detect_subprocesses ||= true
+      self.log_level ||= 'info'
+      self.tags ||= []
+    end
+  end
+
+  class << self
+    def configure
+      @config = Config.new
+
+      # Pass config to the block
+      yield @config
+
+      Rust.initialize_agent(
+        @config.application_name,
+        @config.server_address,
+        @config.sample_rate,
+        @config.detect_subprocesses,
+        tags_to_string(@config.tags)
+      )
+
+      puts @config
+    end
+
+    def tag_wrapper(tags)
+      add_tags(tags)
+      begin
+        yield
+      ensure
+        remove_tags(tags)
+      end
+    end
+
+    def drop
+      Rust.drop_agent
+    end
+end
+end
+
+# convert tags object to string
+def tags_to_string(tags)
+  tags.map { |k, v| "#{k}=#{v}" }.join(',')
+end
+
+# get thread id
+def thread_id
+  thread_id = Fiddle::Function.new($libm['thread_id'], [], Fiddle::TYPE_INT64_T)
+  thread_id.call
+end
+
+# add tags
+def add_tags(tags)
+  tags.each do |tag_name, tag_value|
+    thread_id = thread_id()
+    Rust.add_tag(thread_id, tag_name.to_s, tag_value.to_s)
+  end
+end
+
+# remove tags
+def remove_tags(tags)
+  tags.each do |tag_name, tag_value|
+    thread_id = thread_id()
+    Rust.remove_tag(thread_id, tag_name.to_s, tag_value.to_s)
+  end
+end