pyroscope 0.3.2-x86_64-darwin → 0.5.1-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04463bc7a3a932eef056c8d20e677b042fc921b5df2df4296279fd34c7dc9bfd
-  data.tar.gz: 4fa8c6865eea79b89781600691c06c63a1160a66b7d4815881fc4ae4be37c622
+  metadata.gz: 9cb87b3d680d036992d9e4dc5c24623005acfc2025ec4578b3d87f62af60eef1
+  data.tar.gz: bf83c8dd6257c99e2a9e6bb288a446bbbddbc3b322ab4fed8a81b7a9422bf54f
 SHA512:
-  metadata.gz: 6b23669db4195412878522947572126877e33fa0596f24086efdd80b2ad6f46874520ea3201687a78d1f1da8093ad77493eb0b0390ad5a4aeab7cdd280866c5c
-  data.tar.gz: 4bdbccad469ba8adf06b181b60544faa04b634d9bfeedce3c048ca54fd6aa645a460cf2b79abd4f307353fa79f02ffcdc9ed69cce545c1bfa91813fc13b3b191
+  metadata.gz: 78b08c983b3e61158df1a9b8cf80ae79c4f947d10d6b868bf9f8d8c600f1d2c6112783ebe0b2d7c3412bc731fdb0a121170c2abc73981337e1487d2ccbe7c603
+  data.tar.gz: df6ea2ce9a7aeea50718f47ed8feada39324fea35e56bcfd59608d673832ea825077bcc793fee507cb7edf641dd9e272e71e91554a7f52807aacce58e099fd5d

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/src/lib.rs

@@ -1,12 +1,16 @@
-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::env;
 use std::ffi::CStr;
 use std::hash::Hasher;
 use std::os::raw::c_char;
-use std::env;
+use std::str::FromStr;
+
+use ffikit::Signal;
+use pyroscope_rbspy::{rbspy_backend, RbspyConfig};
+
+use pyroscope::{pyroscope::Compression, PyroscopeAgent};
+use pyroscope::backend::{Report, StackFrame, Tag};
+use pyroscope::pyroscope::ReportEncoding;
 
 pub fn transform_report(report: Report) -> Report {
     let cwd = env::current_dir().unwrap();
@@ -24,31 +28,25 @@ pub fn transform_report(report: Report) -> Report {
                     let mut s = frame.filename.unwrap();
                     match s.find(cwd) {
                         Some(i) => {
-                            s = s[(i+cwd.len()+1)..].to_string();
+                            s = s[(i + cwd.len() + 1)..].to_string();
                         }
-                        None => {
-                            match s.find("/gems/") {
+                        None => match s.find("/gems/") {
+                            Some(i) => {
+                                s = s[(i + 1)..].to_string();
+                            }
+                            None => match s.find("/ruby/") {
                                 Some(i) => {
-                                    s = s[(i+1)..].to_string();
-                                }
-                                None => {
-                                    match s.find("/ruby/") {
+                                    s = s[(i + 6)..].to_string();
+                                    match s.find("/") {
                                         Some(i) => {
-                                            s = s[(i+6)..].to_string();
-                                            match s.find("/") {
-                                                Some(i) => {
-                                                    s = s[(i+1)..].to_string();
-                                                }
-                                                None => {
-                                                }
-                                            }
-                                        }
-                                        None => {
+                                            s = s[(i + 1)..].to_string();
                                         }
+                                        None => {}
                                     }
                                 }
-                            }
-                        }
+                                None => {}
+                            },
+                        },
                     }
 
                     // something
@@ -76,11 +74,42 @@ pub fn transform_report(report: Report) -> Report {
     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,
-    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,
+    report_encoding: *const c_char
 ) -> bool {
     // Initialize FFIKit
     let recv = ffikit::initialize_ffi().unwrap();
@@ -105,13 +134,27 @@ pub extern "C" fn initialize_agent(
         .unwrap()
         .to_string();
 
+    let compression_string = unsafe { CStr::from_ptr(compression) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let report_encoding = unsafe { CStr::from_ptr(report_encoding) }
+        .to_str()
+        .unwrap()
+        .to_string();
+
+    let compression = Compression::from_str(&compression_string);
+    let report_encoding = ReportEncoding::from_str(&report_encoding)
+        .unwrap_or(ReportEncoding::FOLDED);
+
     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)
+        .detect_subprocesses(detect_subprocesses)
+        .oncpu(oncpu)
         .report_pid(report_pid)
         .report_thread_id(report_thread_id);
 
@@ -122,12 +165,17 @@ pub extern "C" fn initialize_agent(
     let mut agent_builder = PyroscopeAgent::builder(server_address, application_name)
         .backend(rbspy)
         .func(transform_report)
-        .tags(tags);
+        .tags(tags)
+        .report_encoding(report_encoding);
 
     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_running = agent.start().unwrap();

data/lib/pyroscope/version.rb

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

data/lib/pyroscope.rb

@@ -1,10 +1,14 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 require 'ffi'
 
 module Pyroscope
   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 :initialize_logging, [:int], :bool
+    attach_function :initialize_agent, [:string, :string, :string, :int, :bool, :bool, :bool, :bool, :string, :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
@@ -18,42 +22,107 @@ module Pyroscope
     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
+  if defined?(::Rails::Engine)
+    class Engine < ::Rails::Engine
+      config.after_initialize do
+        next unless ::Pyroscope.current_config && ::Pyroscope.current_config.autoinstrument_rails
+
+        ::Pyroscope.initialize_rails_hooks
+      end
+    end
+  end
+
+  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,
+    :report_encoding,
+    :autoinstrument_rails,
+  ) do
     def initialize(*)
+      super
+      # defaults:
       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.oncpu = true
       self.report_pid = false
       self.report_thread_id = false
-      self.log_level = 'info'
+      self.log_level = 'error'
       self.tags = {}
-      super
+      self.compression = 'gzip'
+      self.report_encoding = 'pprof'
+      self.autoinstrument_rails = true
     end
   end
 
   class << self
+    def current_config
+      @config
+    end
+
     def configure
       @config = Config.new
 
       # 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
+
+      Rust.initialize_logging(@log_level)
+
       Rust.initialize_agent(
+        # 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.on_cpu || false,
+        @config.oncpu || false,
         @config.report_pid || false,
         @config.report_thread_id || false,
-        tags_to_string(@config.tags || {})
+        tags_to_string(@config.tags || {}),
+        @config.compression || "",
+        @config.report_encoding || "pprof"
       )
     end
 
+    def initialize_rails_hooks
+      block = lambda do |ctrl, action|
+        Pyroscope.tag_wrapper({
+          "action" => "#{ctrl.controller_name}/#{ctrl.action_name}"
+        }, &action)
+      end
+
+      ActionController::API.__send__(:around_action, block) if defined? ActionController::API
+      ActionController::Base.__send__(:around_action, block) if defined? ActionController::Base
+    end
+
     def tag_wrapper(tags)
       tid = thread_id
       _add_tags(tid, tags)
@@ -72,32 +141,34 @@ module Pyroscope
       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
 
-    # 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 drop
+    def stop
       Rust.drop_agent
     end
+
+    def shutdown
+      stop
+    end
+
+    private
+
+    def tags_to_string(tags)
+      tags.map { |k, v| "#{k}=#{v}" }.join(',')
+    end
   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.2
+  version: 0.5.1
 platform: x86_64-darwin
 authors:
 - Pyroscope Team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-22 00:00:00.000000000 Z
+date: 2022-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -89,10 +89,16 @@ files:
 - lib/thread_id/thread_id.bundle
 - pyroscope.gemspec
 - scripts/docker.sh
+- scripts/tests/test.rb
 homepage: https://pyroscope.io
 licenses:
 - Apache-2.0
-metadata: {}
+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:
@@ -101,7 +107,7 @@ 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:
   - - ">="