pyroscope 0.2.0 → 0.3.2

data/ext/rbspy/src/lib.rs

@@ -0,0 +1,253 @@
+use ffikit::Signal;
+use pyroscope::backend::{Report, StackFrame, Tag};
+use pyroscope::PyroscopeAgent;
+use pyroscope_rbspy::{rbspy_backend, RbspyConfig};
+use std::collections::hash_map::DefaultHasher;
+use std::ffi::CStr;
+use std::hash::Hasher;
+use std::os::raw::c_char;
+use std::env;
+
+pub fn transform_report(report: Report) -> Report {
+    let cwd = env::current_dir().unwrap();
+    let cwd = cwd.to_str().unwrap_or("");
+
+    let data = report
+        .data
+        .iter()
+        .map(|(stacktrace, count)| {
+            let new_frames = stacktrace
+                .frames
+                .iter()
+                .map(|frame| {
+                    let frame = frame.to_owned();
+                    let mut s = frame.filename.unwrap();
+                    match s.find(cwd) {
+                        Some(i) => {
+                            s = s[(i+cwd.len()+1)..].to_string();
+                        }
+                        None => {
+                            match s.find("/gems/") {
+                                Some(i) => {
+                                    s = s[(i+1)..].to_string();
+                                }
+                                None => {
+                                    match s.find("/ruby/") {
+                                        Some(i) => {
+                                            s = s[(i+6)..].to_string();
+                                            match s.find("/") {
+                                                Some(i) => {
+                                                    s = s[(i+1)..].to_string();
+                                                }
+                                                None => {
+                                                }
+                                            }
+                                        }
+                                        None => {
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    // something
+                    StackFrame::new(
+                        frame.module,
+                        frame.name,
+                        Some(s.to_string()),
+                        frame.relative_path,
+                        frame.absolute_path,
+                        frame.line,
+                    )
+                })
+                .collect();
+
+            let mut mystack = stacktrace.to_owned();
+
+            mystack.frames = new_frames;
+
+            (mystack, count.to_owned())
+        })
+        .collect();
+
+    let new_report = Report::new(data).metadata(report.metadata.clone());
+
+    new_report
+}
+
+#[no_mangle]
+pub extern "C" fn initialize_agent(
+    application_name: *const c_char, server_address: *const c_char, auth_token: *const c_char,
+    sample_rate: u32, detect_subprocesses: bool, on_cpu: bool, report_pid: bool,
+    report_thread_id: bool, tags: *const c_char,
+) -> bool {
+    // Initialize FFIKit
+    let recv = ffikit::initialize_ffi().unwrap();
+
+    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 auth_token = unsafe { CStr::from_ptr(auth_token) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let tags_string = unsafe { CStr::from_ptr(tags) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let pid = std::process::id();
+
+    let rbspy_config = RbspyConfig::new(pid.try_into().unwrap())
+        .sample_rate(sample_rate)
+        .lock_process(false)
+        .with_subprocesses(detect_subprocesses)
+        .on_cpu(on_cpu)
+        .report_pid(report_pid)
+        .report_thread_id(report_thread_id);
+
+    let tags_ref = tags_string.as_str();
+    let tags = string_to_tags(tags_ref);
+    let rbspy = rbspy_backend(rbspy_config);
+
+    let mut agent_builder = PyroscopeAgent::builder(server_address, application_name)
+        .backend(rbspy)
+        .func(transform_report)
+        .tags(tags);
+
+    if auth_token != "" {
+        agent_builder = agent_builder.auth_token(auth_token);
+    }
+
+    let agent = agent_builder.build().unwrap();
+
+    let agent_running = agent.start().unwrap();
+
+    std::thread::spawn(move || {
+        while let Ok(signal) = recv.recv() {
+            match signal {
+                Signal::Kill => {
+                    agent_running.stop().unwrap();
+                    break;
+                }
+                Signal::AddGlobalTag(name, value) => {
+                    agent_running.add_global_tag(Tag::new(name, value)).unwrap();
+                }
+                Signal::RemoveGlobalTag(name, value) => {
+                    agent_running
+                        .remove_global_tag(Tag::new(name, value))
+                        .unwrap();
+                }
+                Signal::AddThreadTag(thread_id, key, value) => {
+                    let tag = Tag::new(key, value);
+                    agent_running.add_thread_tag(thread_id, tag).unwrap();
+                }
+                Signal::RemoveThreadTag(thread_id, key, value) => {
+                    let tag = Tag::new(key, value);
+                    agent_running.remove_thread_tag(thread_id, tag).unwrap();
+                }
+            }
+        }
+    });
+
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn drop_agent() -> bool {
+    // Send Kill signal to the FFI merge channel.
+    ffikit::send(ffikit::Signal::Kill).unwrap();
+
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn add_thread_tag(thread_id: u64, key: *const c_char, value: *const c_char) -> bool {
+    let key = unsafe { CStr::from_ptr(key) }.to_str().unwrap().to_owned();
+    let value = unsafe { CStr::from_ptr(value) }
+        .to_str()
+        .unwrap()
+        .to_owned();
+
+    let pid = std::process::id();
+    let mut hasher = DefaultHasher::new();
+    hasher.write_u64(thread_id % pid as u64);
+    let id = hasher.finish();
+
+    ffikit::send(ffikit::Signal::AddThreadTag(id, key, value)).unwrap();
+
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn remove_thread_tag(
+    thread_id: u64, key: *const c_char, value: *const c_char,
+) -> bool {
+    let key = unsafe { CStr::from_ptr(key) }.to_str().unwrap().to_owned();
+    let value = unsafe { CStr::from_ptr(value) }
+        .to_str()
+        .unwrap()
+        .to_owned();
+
+    let pid = std::process::id();
+    let mut hasher = DefaultHasher::new();
+    hasher.write_u64(thread_id % pid as u64);
+    let id = hasher.finish();
+
+    ffikit::send(ffikit::Signal::RemoveThreadTag(id, key, value)).unwrap();
+
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn add_global_tag(key: *const c_char, value: *const c_char) -> bool {
+    let key = unsafe { CStr::from_ptr(key) }.to_str().unwrap().to_owned();
+    let value = unsafe { CStr::from_ptr(value) }
+        .to_str()
+        .unwrap()
+        .to_owned();
+
+    ffikit::send(ffikit::Signal::AddGlobalTag(key, value)).unwrap();
+
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn remove_global_tag(key: *const c_char, value: *const c_char) -> bool {
+    let key = unsafe { CStr::from_ptr(key) }.to_str().unwrap().to_owned();
+    let value = unsafe { CStr::from_ptr(value) }
+        .to_str()
+        .unwrap()
+        .to_owned();
+
+    ffikit::send(ffikit::Signal::RemoveGlobalTag(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.toml

@@ -0,0 +1,20 @@
+[package]
+name = "thread_id"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "thread_id"
+crate-type = ["cdylib"]
+
+[dependencies]
+libc = "*"
+
+[build-dependencies]
+cbindgen = "0.20.0"
+
+[profile.release]
+opt-level= "z"
+debug = false
+lto = true
+codegen-units = 1

data/ext/thread_id/Rakefile

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

data/ext/thread_id/build.rs

@@ -0,0 +1,12 @@
+extern crate cbindgen;
+
+use cbindgen::Config;
+
+fn main() {
+    let bindings = {
+        let crate_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+        let config = Config::from_file("cbindgen.toml").unwrap();
+        cbindgen::generate_with_config(&crate_dir, config).unwrap()
+    };
+    bindings.write_to_file("include/thread_id.h");
+}

data/ext/thread_id/cbindgen.toml

@@ -0,0 +1,22 @@
+# The language to output bindings in
+language = "C"
+documentation_style = "C"
+
+style = "type"
+
+# An optional name to use as an include guard
+include_guard = "RBSPY_H_"
+# include a comment with the version of cbindgen used to generate the file
+include_version = true
+
+# An optional string of text to output at the beginning of the generated file
+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]
+# Do not parse dependent crates
+parse_deps = false

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

@@ -1,3 +1,3 @@
 module Pyroscope
-  VERSION = "0.2.0".freeze
+  VERSION = '0.3.2'.freeze
 end

data/lib/pyroscope.rb

@@ -1,60 +1,103 @@
-require "pyroscope/version"
-require "pyroscope_c"
+require 'ffi'
 
 module Pyroscope
-  Config = Struct.new(:app_name, :server_address, :auth_token, :sample_rate, :with_subprocesses, :log_level, :tags)
+  module Rust
+    extend FFI::Library
+    ffi_lib File.expand_path(File.dirname(__FILE__)) + "/rbspy/rbspy.#{RbConfig::CONFIG["DLEXT"]}"
+    attach_function :initialize_agent, [:string, :string, :string, :int, :bool, :bool, :bool, :bool, :string], :bool
+    attach_function :add_thread_tag, [:uint64, :string, :string], :bool
+    attach_function :remove_thread_tag, [:uint64, :string, :string], :bool
+    attach_function :add_global_tag, [:string, :string], :bool
+    attach_function :remove_global_tag, [:string, :string], :bool
+    attach_function :drop_agent, [], :bool
+  end
+
+  module Utils
+    extend FFI::Library
+    ffi_lib File.expand_path(File.dirname(__FILE__)) + "/thread_id/thread_id.#{RbConfig::CONFIG["DLEXT"]}"
+    attach_function :thread_id, [], :uint64
+  end
+
+  Config = Struct.new(:application_name, :app_name, :server_address, :auth_token, :sample_rate, :detect_subprocesses, :on_cpu, :report_pid, :report_thread_id, :log_level, :tags) do
+    def initialize(*)
+      self.application_name = ''
+      self.server_address = 'http://localhost:4040'
+      self.auth_token = ''
+      self.sample_rate = 100
+      self.detect_subprocesses = false
+      self.on_cpu = true
+      self.report_pid = false
+      self.report_thread_id = false
+      self.log_level = 'info'
+      self.tags = {}
+      super
+    end
+  end
 
   class << self
     def configure
-      @configuration = Config.new
-      yield @configuration
-      _start(
-        @configuration.app_name,
-        @configuration.server_address,
-        @configuration.auth_token || "",
-        @configuration.sample_rate || 100,
-        @configuration.with_subprocesses || 0,
-        @configuration.log_level || "error",
-      )
-      tag(@configuration.tags) if @configuration.tags
-    end
+      @config = Config.new
 
-    def stop
-      _stop
-    end
+      # Pass config to the block
+      yield @config
 
-    def change_name(new_name)
-      _change_name(new_name)
+      Rust.initialize_agent(
+        @config.app_name || @config.application_name || "",
+        @config.server_address || "",
+        @config.auth_token || "",
+        @config.sample_rate || 100,
+        @config.detect_subprocesses || false,
+        @config.on_cpu || false,
+        @config.report_pid || false,
+        @config.report_thread_id || false,
+        tags_to_string(@config.tags || {})
+      )
     end
 
     def tag_wrapper(tags)
-      tag(tags)
-
+      tid = thread_id
+      _add_tags(tid, tags)
       begin
         yield
       ensure
-        remove_tags(*tags.keys)
+        _remove_tags(tid, tags)
       end
     end
 
     def tag(tags)
-      tags.each_pair do |key, val|
-        _set_tag(key.to_s, val.to_s)
-      end
+      warn("deprecated. Use `Pyroscope.tag_wrapper` instead.")
     end
 
-    def remove_tags(*keys)
-      keys.each do |key|
-        _set_tag(key.to_s, "")
+    def remove_tags(*tags)
+      warn("deprecated. Use `Pyroscope.tag_wrapper` instead.")
+    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
+      return Utils.thread_id
+    end
+
+    # add tags
+    def _add_tags(thread_id, tags)
+      tags.each do |tag_name, tag_value|
+        Rust.add_thread_tag(thread_id, tag_name.to_s, tag_value.to_s)
       end
     end
 
-    def test_logger
-      _test_logger
+    # remove tags
+    def _remove_tags(thread_id, tags)
+      tags.each do |tag_name, tag_value|
+        Rust.remove_thread_tag(thread_id, tag_name.to_s, tag_value.to_s)
+      end
     end
 
-    def build_summary
-      _build_summary
+    def drop
+      Rust.drop_agent
     end
   end
 end

data/pyroscope.gemspec

@@ -1,27 +1,32 @@
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require 'pyroscope/version'
+require_relative "lib/pyroscope/version"
 
 Gem::Specification.new do |s|
-  s.name          = "pyroscope"
-  s.version       = Pyroscope::VERSION
-  s.summary       = "pyroscope"
-  s.description   = "pyroscope client integration for ruby"
-  s.authors       = ["Pyroscope Team"]
-  s.email         = "contact@pyroscope.io"
-  s.files         = `git ls-files`.split("\n")
-  s.files         += Dir.glob("ext/**/**")
-  # s.files         << "lib/pyroscope_c.bundle"
-  s.homepage      = "http://rubygems.org/gems/pyroscope"
-  s.license       = "Apache-2.0"
-  s.require_paths = ["lib"]
-  s.require_paths << "ext/pyroscope"
-  s.extensions    << "ext/pyroscope/extconf.rb"
+  s.name = 'pyroscope'
+  s.version = Pyroscope::VERSION
+  s.summary = 'Pyroscope'
+  s.description = 'Pyroscope FFI Integration for Ruby'
+  s.authors = ['Pyroscope Team']
+  s.email = ['contact@pyroscope.io']
+  s.homepage = 'https://pyroscope.io'
+  s.license = 'Apache-2.0'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  #s.files = Dir.chdir(__dir__) do
+    #`git ls-files -z`.split("\x0").reject do |f|
+      #(f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    #end
+  #end
+  s.files = `git ls-files -z`.split("\0").reject { |f| f =~ /^(\.|G|spec|Rakefile)/ }
+
+  s.platform = Gem::Platform::RUBY
+
+  s.required_ruby_version = ">= 2.5.9"
+
+  s.extensions = ['ext/rbspy/extconf.rb', 'ext/thread_id/extconf.rb']
+
+  s.add_dependency 'ffi'
 
-  s.add_development_dependency "bundler"
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rake-compiler"
-  s.add_development_dependency "rubygems-tasks"
-  s.add_development_dependency "rspec"
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake', '~> 13.0'
 end