pyroscope 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d844d0ba44d32a1201923e772b917ec927b3c95f0e09a051f7d212e33a603d1c
-  data.tar.gz: ebf2419e55b0fb78cdb8701fce737e274215b8dcec1da30c84c3c91b1cd51643
+  metadata.gz: eba4490cd4dc65fb1219814e002baab05754afe2270e083e8bb697cfa5c452ea
+  data.tar.gz: 69e27707297c593ca5aacd3978fe318dd92219e54caa66c2d2451d24a2a0d70b
 SHA512:
-  metadata.gz: 0aa05eaa6246a501c9e41a7843b13dd91fedbb1ec553e79cad75a03760222a3f8d8b292b12a23364b84e066ea8d5114a4d49eff961d78d894de6bc74b86de723
-  data.tar.gz: ac00d00f2daebcfec6e2cd49665f2406e9ebc238805bef87aa69a3d6a98638aef91f02d765bc7708c605e215dda6eac2176cb18139183587ae269b747d5de2f9
+  metadata.gz: 6c9950536925d36afc03c2461d62793f33ebb514e81b3bc308708bdea33fa4dba560d19ef1b5ccd450e0c5b58604e36d1231caa218bb5d1861dd7e3149f932f0
+  data.tar.gz: d08dcba721bf53f1ea3ce929c3bbbe2dd8b6866da347151d442f0d9281fbc779ccc08c16ef37dd7ec1c1b38846b64d2c8e6357d5906e3b81c15908cd3106f546

data/README.md

@@ -1,57 +1,71 @@
-Pyroscope Ruby Integration --Beta--
-=====================================
+# Pyroscope Ruby Gem
 
-**note**: This is a beta release. It requires local compilation, might be
-buggy and is frequently updated. For the initial implementation, find it [here](https://github.com/pyroscope-io/pyroscope-ruby). Please report any [issues](https://github.com/pyroscope-io/pyroscope-rs/issues).
+**Pyroscope integration for Ruby**
 
-## Installation
+[![license](https://img.shields.io/badge/license-Apache2.0-blue.svg)](LICENSE) 
+![tests](https://github.com/pyroscope-io/pyroscope-rs/workflows/Tests/badge.svg)
+![build](https://github.com/pyroscope-io/pyroscope-rs/workflows/Build/badge.svg)
+[![Gem version](https://badge.fury.io/rb/pyroscope.svg)](https://badge.fury.io/rb/pyroscope)
 
-1. You need the Rust toolchain to compile the library locally. To install
-   Rust:
+---
 
-```
-curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain stable -y 
-export PATH=$PATH:/root/.cargo/bin
-```
+### What is Pyroscope
+[Pyroscope](https://github.com/pyroscope-io/pyroscope) is a tool that lets you continuously profile your applications to prevent and debug performance issues in your code. It consists of a low-overhead agent which sends data to the Pyroscope server which includes a custom-built storage engine. This allows for you to store and query any applications profiling data in an extremely efficient and cost effective way.
 
-2. Building/Insalling from Rubygems 
 
-```
-gem install pyroscope_beta
-```
+### Supported platforms
 
-3. Building/Installing from source
+| Linux | macOS | Windows | Docker |
+|:-----:|:-----:|:-------:|:------:|
+|   ✅  |   ✅  |         |   ✅   |
 
-Change directory to `pyroscope_ffi/ruby` and run
+### Profiling Ruby applications
 
+Add the `pyroscope` gem to your Gemfile:
+
+```bash
+bundle add pyroscope
 ```
-gem build pyroscope.gemspec
-gem install ./pyroscope.gemspec
-```
 
-## Configuration
+### Basic Configuration
+
+Add the following code to your application. If you're using rails, put this into `config/initializers` directory. This code will initialize pyroscope profiler and start profiling:
 
-Configuration is similar to the old package except for `application_name`:
+```ruby
+require 'pyroscope'
 
+Pyroscope.configure do |config|
+  config.application_name = "my.ruby.app" # replace this with some name for your application
+  config.server_address   = "http://my-pyroscope-server:4040" # replace this with the address of your pyroscope server
+  # config.auth_token     = "{YOUR_API_KEY}" # optionally, if authentication is enabled, specify the API key
+end
 ```
-require 'pyroscope_beta'
+
+### Tags
+
+Pyroscope ruby integration provides a number of ways to tag profiling data. For example, you can provide tags when you're initializing the profiler:
+
+```ruby
+require 'pyroscope'
 
 Pyroscope.configure do |config|
-  config.application_name = "ruby.app"
-  config.server_address = "http://localhost:4040"
-  config.detect_subprocesses = true 
+  config.application_name = "my.ruby.app"
+  config.server_address   = "http://my-pyroscope-server:4040"
+
   config.tags = {
-    :key => "value",
+    "hostname" => ENV["HOSTNAME"],
   }
 end
 ```
 
-## Adding tags
+or you can dynamically tag certain parts of your code:
 
-Tags passed to configure are global. To tag code locally, you can use:
-
-```
-Pyroscope.tag_wrapper({"profile": "profile-1"}) do
-    // Tagged profile
+```ruby
+Pyroscope.tag_wrapper({ "controller": "slow_controller_i_want_to_profile" }) do
+  slow_code
 end
 ```
+
+### Example
+
+Check out this [example ruby project in our repository](https://github.com/pyroscope-io/pyroscope/tree/main/examples/ruby) for examples of how you can use these features.

data/ext/rbspy/Cargo.toml

@@ -12,6 +12,8 @@ crate-type = ["cdylib"]
 pyroscope = { path = "../../../../" }
 #pyroscope_rbspy = { version = "0.2" }
 pyroscope_rbspy = { path = "../../../../pyroscope_backends/pyroscope_rbspy" }
+ffikit = { path = "../../../ffikit" }
+pretty_env_logger = "0.4.0"
 
 [patch.crates-io]
 read-process-memory = {git = "https://github.com/omarabid/read-process-memory.git", branch = "0.1.4-fix"}

data/ext/rbspy/src/lib.rs

@@ -1,45 +1,117 @@
-use pyroscope::backend::Tag;
-use pyroscope::PyroscopeAgent;
-use pyroscope_rbspy::{rbspy_backend, RbspyConfig};
+use std::collections::hash_map::DefaultHasher;
+use std::env;
 use std::ffi::CStr;
-use std::mem::MaybeUninit;
+use std::hash::Hasher;
 use std::os::raw::c_char;
-use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
-use std::sync::{Mutex, Once};
+use std::str::FromStr;
 
-pub enum Signal {
-    Kill,
-    AddTag(u64, String, String),
-    RemoveTag(u64, String, String),
-}
+use ffikit::Signal;
+use pyroscope_rbspy::{rbspy_backend, RbspyConfig};
+
+use pyroscope::{pyroscope::Compression, PyroscopeAgent};
+use pyroscope::backend::{Report, StackFrame, Tag};
+
+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;
 
-pub struct SignalPass {
-    inner_sender: Mutex<SyncSender<Signal>>,
-    inner_receiver: Mutex<Receiver<Signal>>,
+            (mystack, count.to_owned())
+        })
+        .collect();
+
+    let new_report = Report::new(data).metadata(report.metadata.clone());
+
+    new_report
 }
 
-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);
-    });
+#[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");
+        }
+    }
 
-    unsafe { SIGNAL_PASS.assume_init_ref() }
+    // 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,
-    sample_rate: u32, detect_subprocesses: bool, on_cpu: bool, report_pid: bool,
-    report_thread_id: bool, tags: *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
 ) -> bool {
+    // Initialize FFIKit
+    let recv = ffikit::initialize_ffi().unwrap();
+
     let application_name = unsafe { CStr::from_ptr(application_name) }
         .to_str()
         .unwrap()
@@ -60,46 +132,64 @@ pub extern "C" fn initialize_agent(
         .unwrap()
         .to_string();
 
+    let compression_string = unsafe { CStr::from_ptr(compression) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let compression = Compression::from_str(&compression_string);
+
     let pid = std::process::id();
 
-    let s = signalpass();
+    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);
 
-    std::thread::spawn(move || {
-        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)
-            .tags(tags);
-
-        if auth_token != "" {
-            agent_builder = agent_builder.auth_token(auth_token);
-        }
+    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);
+    }
+
+    if let Ok(compression) = compression {
+        agent_builder = agent_builder.compression(compression);
+    }
 
-        let agent = agent_builder.build().unwrap();
+    let agent = agent_builder.build().unwrap();
 
-        let agent_running = agent.start().unwrap();
+    let agent_running = agent.start().unwrap();
 
-        while let Ok(signal) = s.inner_receiver.lock().unwrap().recv() {
+    std::thread::spawn(move || {
+        while let Ok(signal) = recv.recv() {
             match signal {
                 Signal::Kill => {
                     agent_running.stop().unwrap();
                     break;
                 }
-                Signal::AddTag(thread_id, key, value) => {
+                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::RemoveTag(thread_id, key, value) => {
+                Signal::RemoveThreadTag(thread_id, key, value) => {
                     let tag = Tag::new(key, value);
                     agent_running.remove_thread_tag(thread_id, tag).unwrap();
                 }
@@ -112,40 +202,73 @@ pub extern "C" fn initialize_agent(
 
 #[no_mangle]
 pub extern "C" fn drop_agent() -> bool {
-    let s = signalpass();
-    s.inner_sender.lock().unwrap().send(Signal::Kill).unwrap();
+    // Send Kill signal to the FFI merge channel.
+    ffikit::send(ffikit::Signal::Kill).unwrap();
+
     true
 }
 
 #[no_mangle]
-pub extern "C" fn add_tag(thread_id: u64, key: *const c_char, value: *const c_char) -> bool {
-    let s = signalpass();
+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();
-    s.inner_sender
-        .lock()
+
+    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()
-        .send(Signal::AddTag(thread_id, key, value))
-        .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 remove_tag(thread_id: u64, key: *const c_char, value: *const c_char) -> bool {
-    let s = signalpass();
+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();
-    s.inner_sender
-        .lock()
+
+    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()
-        .send(Signal::RemoveTag(thread_id, key, value))
-        .unwrap();
+        .to_owned();
+
+    ffikit::send(ffikit::Signal::RemoveGlobalTag(key, value)).unwrap();
+
     true
 }
 

data/lib/pyroscope/version.rb

@@ -1,3 +1,3 @@
 module Pyroscope
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.4.0'.freeze
 end

data/lib/pyroscope.rb

@@ -1,34 +1,42 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 require 'ffi'
 
-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_tag, [:uint64, :string, :string], :bool
-  attach_function :remove_tag, [:uint64, :string, :string], :bool
-  attach_function :drop_agent, [], :bool
-end
+module Pyroscope
+  module Rust
+    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, :int, :bool, :bool, :bool, :bool, :string, :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
+  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
 
-module Pyroscope
-  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
+  Config = Struct.new(:application_name, :app_name, :server_address, :auth_token, :log_level, :sample_rate, :detect_subprocesses, :oncpu, :report_pid, :report_thread_id, :tags, :compression) do
     def initialize(*)
       super
-      self.application_name ||= ''
-      self.server_address ||= 'http://localhost:4040'
-      self.auth_token ||= ''
-      self.sample_rate ||= 100
-      self.detect_subprocesses ||= true
-      self.on_cpu ||= true
-      self.report_pid ||= false
-      self.report_thread_id ||= false
-      self.log_level ||= 'info'
-      self.tags ||= []
+      # defaults:
+      self.application_name = ''
+      self.server_address = 'http://localhost:4040'
+      self.auth_token = ''
+      self.sample_rate = 100
+      self.detect_subprocesses = false
+      self.oncpu = true
+      self.report_pid = false
+      self.report_thread_id = false
+      self.log_level = 'error'
+      self.tags = {}
+      self.compression = 'gzip'
     end
   end
 
@@ -39,16 +47,39 @@ module Pyroscope
       # Pass config to the block
       yield @config
 
+      # Determine Logging level (kinda like an enum).
+      case @config.log_level
+      when 'trace'
+        @log_level = 10
+      when 'debug'
+        @log_level = 20
+      when 'info'
+        @log_level = 30
+      when 'warn'
+        @log_level = 40
+      when 'error'
+        @log_level = 50
+      else
+        @log_level = 50
+      end
+
+      # Initialize Logging
+      Rust.initialize_logging(@log_level)
+
+
+      # initialize Pyroscope Agent
       Rust.initialize_agent(
-        @config.app_name || @config.application_name,
-        @config.server_address,
-        @config.auth_token,
-        @config.sample_rate,
-        @config.detect_subprocesses,
-        @config.on_cpu,
-        @config.report_pid,
-        @config.report_thread_id,
-        tags_to_string(@config.tags)
+        # these are defaults in case user-provided values are nil:
+        @config.app_name || @config.application_name || "",
+        @config.server_address || "",
+        @config.auth_token || "",
+        @config.sample_rate || 100,
+        @config.detect_subprocesses || false,
+        @config.oncpu || false,
+        @config.report_pid || false,
+        @config.report_thread_id || false,
+        tags_to_string(@config.tags || {}),
+        @config.compression || ""
       )
     end
 
@@ -83,18 +114,18 @@ module Pyroscope
     # add tags
     def _add_tags(thread_id, tags)
       tags.each do |tag_name, tag_value|
-        Rust.add_tag(thread_id, tag_name.to_s, tag_value.to_s)
+        Rust.add_thread_tag(thread_id, tag_name.to_s, tag_value.to_s)
       end
     end
 
     # remove tags
     def _remove_tags(thread_id, tags)
       tags.each do |tag_name, tag_value|
-        Rust.remove_tag(thread_id, tag_name.to_s, tag_value.to_s)
+        Rust.remove_thread_tag(thread_id, tag_name.to_s, tag_value.to_s)
       end
     end
 
-    def drop
+    def shutdown
       Rust.drop_agent
     end
   end

data/pyroscope.gemspec

@@ -1,4 +1,11 @@
-require_relative "lib/pyroscope/version"
+# coding: utf-8
+# frozen_string_literal: true
+
+begin
+  require File.expand_path(File.join(File.dirname(__FILE__), "lib/pyroscope/version"))
+rescue LoadError
+  puts "WARNING: Could not load Pyroscope::VERSION"
+end
 
 Gem::Specification.new do |s|
   s.name = 'pyroscope'
@@ -9,6 +16,13 @@ Gem::Specification.new do |s|
   s.email = ['contact@pyroscope.io']
   s.homepage = 'https://pyroscope.io'
   s.license = 'Apache-2.0'
+  s.metadata = {
+    "homepage_uri" => "https://pyroscope.io",
+    "bug_tracker_uri" => "https://github.com/pyroscope-io/pyroscope-rs/issues",
+    "documentation_uri" => "https://pyroscope.io/docs/ruby/",
+    "changelog_uri" => "https://github.com/pyroscope-io/pyroscope-rs/tree/main/pyroscope_ffi/ruby/CHANGELOG.md",
+    "source_code_uri" => "https://github.com/pyroscope-io/pyroscope-rs/tree/main/pyroscope_ffi/ruby",
+  }
 
   # 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.
@@ -21,7 +35,7 @@ Gem::Specification.new do |s|
 
   s.platform = Gem::Platform::RUBY
 
-  s.required_ruby_version = ">= 2.5.9"
+  s.required_ruby_version = ">= 1.9.3"
 
   s.extensions = ['ext/rbspy/extconf.rb', 'ext/thread_id/extconf.rb']
 

data/scripts/tests/test.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require "pyroscope"
+require "pyroscope/version"
+
+puts Pyroscope::VERSION
+puts RUBY_VERSION
+
+Pyroscope.configure do |config|
+  config.application_name = "#{ENV["PYROSCOPE_RUN_ID"]}"
+  config.server_address = "https://ingest.pyroscope.cloud"
+  config.auth_token = ENV["PYROSCOPE_API_TOKEN"]
+  config.detect_subprocesses = ENV["PYROSCOPE_DETECT_SUBPROCESSES"] == "1"
+  config.oncpu = ENV["PYROSCOPE_ONCPU"] == "1"
+  config.log_level = "trace"
+  config.report_pid = true
+  config.report_thread_id = true
+  config.tags = {
+    :region => "us-east",
+    :detect_subprocesses => ENV["PYROSCOPE_DETECT_SUBPROCESSES"],
+    :oncpu => ENV["PYROSCOPE_ONCPU"],
+    :version => ENV["RUBY_VERSION"],
+    :arch => ENV["PYROSCOPE_ARCH"]
+  }
+end
+
+def work(n)
+  i = 0
+  while i < n
+    i += 1
+  end
+end
+
+def fast_function
+  Pyroscope.tag_wrapper({"function": "fast"}) do
+    work(2001002000)
+  end
+end
+
+def slow_function
+  work(8001008000)
+end
+
+child_pid = fork do
+  puts "This is the child process"
+  Pyroscope.tag_wrapper({"fork": "forked"}) do
+    slow_function()
+  end
+end
+
+puts "This is the master process."
+
+Pyroscope.tag_wrapper({"fork": "master"}) do
+  fast_function()
+end
+
+puts "The PID of the child process is #{child_pid}"
+
+Pyroscope.shutdown()

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pyroscope
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Pyroscope Team
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-30 00:00:00.000000000 Z
+date: 2022-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -89,11 +89,17 @@ files:
 - lib/pyroscope/version.rb
 - pyroscope.gemspec
 - scripts/docker.sh
+- scripts/tests/test.rb
 homepage: https://pyroscope.io
 licenses:
 - Apache-2.0
-metadata: {}
-post_install_message:
+metadata:
+  homepage_uri: https://pyroscope.io
+  bug_tracker_uri: https://github.com/pyroscope-io/pyroscope-rs/issues
+  documentation_uri: https://pyroscope.io/docs/ruby/
+  changelog_uri: https://github.com/pyroscope-io/pyroscope-rs/tree/main/pyroscope_ffi/ruby/CHANGELOG.md
+  source_code_uri: https://github.com/pyroscope-io/pyroscope-rs/tree/main/pyroscope_ffi/ruby
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -101,15 +107,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.9
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.15
-signing_key:
+rubygems_version: 3.3.7
+signing_key: 
 specification_version: 4
 summary: Pyroscope
 test_files: []