pyroscope 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d24a58cc1e931711355e430131e01565c4c15c149ac96d0323826ad03101f22c
-  data.tar.gz: 6f86a62f50e924859e404894bb47850a550b99fab146074f8c6cb4ddd6cf3089
+  metadata.gz: c54d01d273a289584bf1ecd0f69c7349e775f3e8a8b0a07a71a78095b4bbc78c
+  data.tar.gz: ef6dfa8b2da02bcfdd17d8a6d49cd86cfe7666615bcbb690bd04459c0300599d
 SHA512:
-  metadata.gz: 8d65c0d1ef7eeb636caa2b945fb485144f81f934630bf3736ffccb65b966d9b3c66dea974d275f078c6d94613b52f0893f55ec145e066acd430cf55f1c8bfc9f
-  data.tar.gz: 22e8e5a0b3a2a43bf11775539dabefa3e5d1d7d4bc6d7a3e40a4c3a80f117693b1a0b139f4e6d86c3db25da63b827b3f616531e385feabdd797cf4a5b3601c36
+  metadata.gz: c45a42bff9b659125547281a11a9623ef12469a91b61444a178d7895482a3889a6ed687f650cde9bb7bdfdaee163f5c1fa8a905e254116ad50ec6ece06f983d8
+  data.tar.gz: '0108e948e4d9bf98a729b5628fe6d243d849e7d7721463b8f5623629330d8ebbbaa1cc95dbddd5966ab0849409ca9858240414169d69182a7dbc92e583ebb6dd'

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,17 +1,115 @@
-use ffikit::Signal;
-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::hash::Hasher;
 use std::os::raw::c_char;
+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();
+    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,
-    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();
@@ -36,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);
 
@@ -52,12 +164,18 @@ pub extern "C" fn initialize_agent(
 
     let mut agent_builder = PyroscopeAgent::builder(server_address, application_name)
         .backend(rbspy)
-        .tags(tags);
+        .func(transform_report)
+        .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.1'.freeze
+  VERSION = '0.5.0'.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,19 +22,22 @@ 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
+  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) 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'
     end
   end
 
@@ -41,16 +48,40 @@ 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(
+        # 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
 
@@ -96,7 +127,7 @@ module Pyroscope
       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.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Pyroscope Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-19 00:00:00.000000000 Z
+date: 2022-09-06 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:
   - - ">="