pyroscope-ruby33 0.5.13

data/ext/rbspy/src/lib.rs

@@ -0,0 +1,358 @@
+use std::collections::hash_map::DefaultHasher;
+use std::env;
+use std::ffi::CStr;
+use std::hash::Hasher;
+use std::os::raw::c_char;
+use std::str::FromStr;
+
+use ffikit::Signal;
+use pyroscope_rbspy::{rbspy_backend, RbspyConfig};
+
+use pyroscope;
+use pyroscope::{pyroscope::Compression, PyroscopeAgent};
+use pyroscope::backend::{Report, StackFrame, Tag};
+use pyroscope::pyroscope::ReportEncoding;
+
+const LOG_TAG: &str = "Pyroscope::rbspy::ffi";
+
+
+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_logging(logging_level: u32) -> bool {
+    // Force rustc to display the log messages in the console.
+    match logging_level {
+        50 => {
+            std::env::set_var("RUST_LOG", "error");
+        }
+        40 => {
+            std::env::set_var("RUST_LOG", "warn");
+        }
+        30 => {
+            std::env::set_var("RUST_LOG", "info");
+        }
+        20 => {
+            std::env::set_var("RUST_LOG", "debug");
+        }
+        10 => {
+            std::env::set_var("RUST_LOG", "trace");
+        }
+        _ => {
+            std::env::set_var("RUST_LOG", "debug");
+        }
+    }
+
+    // Initialize the logger.
+    pretty_env_logger::init_timed();
+
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn initialize_agent(
+    application_name: *const c_char,
+    server_address: *const c_char,
+    auth_token: *const c_char,
+    basic_auth_user: *const c_char,
+    basic_auth_password: *const c_char,
+    sample_rate: u32,
+    detect_subprocesses: bool,
+    oncpu: bool,
+    report_pid: bool,
+    report_thread_id: bool,
+    tags: *const c_char,
+    compression: *const c_char,
+    _report_encoding: *const c_char,
+    tenant_id: *const c_char,
+    http_headers_json: *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 mut server_address = unsafe { CStr::from_ptr(server_address) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let adhoc_server_address = std::env::var("PYROSCOPE_ADHOC_SERVER_ADDRESS");
+    if let Ok(adhoc_server_address) = adhoc_server_address {
+        server_address = adhoc_server_address
+    }
+
+    let auth_token = unsafe { CStr::from_ptr(auth_token) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let basic_auth_user = unsafe { CStr::from_ptr(basic_auth_user) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let basic_auth_password = unsafe { CStr::from_ptr(basic_auth_password) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let tags_string = unsafe { CStr::from_ptr(tags) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let compression_string = unsafe { CStr::from_ptr(compression) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let tenant_id = unsafe { CStr::from_ptr(tenant_id) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let http_headers_json = unsafe { CStr::from_ptr(http_headers_json) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let compression = Compression::from_str(&compression_string);
+
+    let pid = std::process::id();
+
+    let rbspy_config = RbspyConfig::new(pid.try_into().unwrap())
+        .sample_rate(sample_rate)
+        .lock_process(false)
+        .detect_subprocesses(detect_subprocesses)
+        .oncpu(oncpu)
+        .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)
+        .report_encoding(ReportEncoding::PPROF);
+
+    if auth_token != "" {
+        agent_builder = agent_builder.auth_token(auth_token);
+    } else if basic_auth_user != "" && basic_auth_password != "" {
+        agent_builder = agent_builder.basic_auth(basic_auth_user, basic_auth_password);
+    }
+
+    if tenant_id != "" {
+        agent_builder = agent_builder.tenant_id(tenant_id);
+    }
+
+    let http_headers = pyroscope::pyroscope::parse_http_headers_json(http_headers_json);
+    match http_headers {
+        Ok(http_headers) => {
+            agent_builder = agent_builder.http_headers(http_headers);
+        }
+        Err(e) => {
+            match e {
+                pyroscope::PyroscopeError::Json(e) => {
+                    log::error!(target: LOG_TAG, "parse_http_headers_json error {}", e);
+                }
+                pyroscope::PyroscopeError::AdHoc(e) => {
+                    log::error!(target: LOG_TAG, "parse_http_headers_json {}", e);
+                }
+                _ => {}
+            }
+        }
+    }
+
+    if let Ok(compression) = compression {
+        agent_builder = agent_builder.compression(compression);
+    }
+
+    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,15 @@
+[package]
+name = "thread_id"
+version = "0.1.0"
+edition = "2021"
+rust-version = "1.64"
+
+[lib]
+name = "thread_id"
+crate-type = ["cdylib"]
+
+[dependencies]
+libc = "*"
+
+[build-dependencies]
+cbindgen = "0.20.0"

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/include/thread_id.h

@@ -0,0 +1,17 @@
+/* Licensed under Apache-2.0 */
+
+#ifndef RBSPY_H_
+#define RBSPY_H_
+
+/* Generated with cbindgen:0.20.0 */
+
+/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+uint64_t thread_id(void);
+
+#endif /* RBSPY_H_ */

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.5.13'.freeze
+end