pyroscope 0.3.2 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e4579716329cb055e247d5c05419d38889bae214ad4167dff49aa298c52f3b0
-  data.tar.gz: c2679ebbd856b7603c49ab20b956470ee32aaf03f8c37e145ea2bd0467dd7f94
+  metadata.gz: df36b61e5b8fde45ebc360aedc8e109e3d37c7817d539721a48c00f59f1f66bc
+  data.tar.gz: 9bdb35db6a01df630a489716caee628d67c52984391d867b1f2693e5f137b85a
 SHA512:
-  metadata.gz: a7f059b8a98c2b9c3bf553f296524a5004017f07fb1a7ea52821e6c2f4111f101a501f4edd1bd6d4a82a14a3e75aed3bb543bd2fff0d0c5e40d5a99395f7af61
-  data.tar.gz: 90dddc7d21658e6fa87d66dca7460e9856d771455464b3ca05776345496d3fe19fc9eb4f85a8bcee5cc480e89a6280a4a43a0f4598548ff00e8f7866d8b32d18
+  metadata.gz: 816ece1b66998b8e128ab8e7fd8a625c5ea37d941fefd4f5025b5cb06fb8a2fa5dd27bd8ab0dca0ab5473818ae315c9e749edb7e5d126e524a80ae56917df802
+  data.tar.gz: 468ef393fa6008d5f63d49554820be41b307c59b0d414f712e96da677a51c66880cbcf01b751b24f80a0913d0e9f5c9e174d0f3561717c9d11ae5db90d269198

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: ruby
 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/pyroscope/version.rb
 - 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:
   - - ">="