pyroscope 0.3.0-arm64-darwin → 0.3.1-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07e893dbb1d344a6408adf69d7e6692a9722f4afa6ceb1f30441596fa85a0529
-  data.tar.gz: 5d2fc262abf78dceb05a567f621f33c057dfc60f05a463c8b982db98509037e0
+  metadata.gz: 0b7eb0f69ff31b3fc5a6ac437cb4c4190da57cdfea4e81e87956259fcc2f19de
+  data.tar.gz: 9eab2b1c0dd80f29ccf88d9a6e52c37093b0effd70d54eb6fb718546f375453e
 SHA512:
-  metadata.gz: 3cf54f64e8830c63de312845c1da9d052ef2e054ae8e174fa28cbed6f6108d9101fcf957ccd61364b0b4354ddddfa71b5c0cbe9b7903c9aceea46b5071c632af
-  data.tar.gz: 7e8ca2f80a04a5e28f474540eafd1b4cad83e974ef2d6a410eeba33d017dec8a04f167f8979137dd648190845704e67d0385be6894be0fb040eb1978c0a35e57
+  metadata.gz: 95f3c03936e81ffb9b1ee5fe3632c01e822548305d691db28ba721411e4ccba3964197aeee71b7d17ed6e771991441da03f50015108786ad0e05b5dd6d961905
+  data.tar.gz: 0d411ee574f66eb488bc05f905ec52142061374e2bcdde83d028cb120b4f58167444b88dfa24b8fb5f343f1263ad12771b794f0da73f79a636d8f97ed3df4b3d

data/elflib/rbspy/manylinux.sh

@@ -2,20 +2,20 @@
 set -e
 
 # Install tooling
-#yum -y -q install wget gcc libffi-devel openssl-devel
+yum -y -q install wget gcc libffi-devel openssl-devel
 
 # Install Rust
-#curl https://sh.rustup.rs -sSf | sh -s -- -y
-#export PATH=~/.cargo/bin:$PATH
+curl https://sh.rustup.rs -sSf | sh -s -- -y
+export PATH=~/.cargo/bin:$PATH
 
 # Build wheels
-#/opt/python/cp37-cp37m/bin/python setup.py bdist_wheel
+/opt/python/cp37-cp37m/bin/python setup.py bdist_wheel
 
 # Audit wheels
-#for wheel in dist/*.whl; do
-  #auditwheel repair $wheel -w dist/
-  #rm $wheel
-#done
+for wheel in dist/*.whl; do
+  auditwheel repair $wheel -w dist/
+  rm $wheel
+done
 
 # Extract wheels
 for wheel in dist/*.whl; do

data/elflib/thread_id/manylinux.sh

@@ -2,20 +2,20 @@
 set -e
 
 # Install tooling
-#yum -y -q install wget gcc libffi-devel openssl-devel
+yum -y -q install wget gcc libffi-devel openssl-devel
 
 # Install Rust
-#curl https://sh.rustup.rs -sSf | sh -s -- -y
-#export PATH=~/.cargo/bin:$PATH
+curl https://sh.rustup.rs -sSf | sh -s -- -y
+export PATH=~/.cargo/bin:$PATH
 
 # Build wheels
-#/opt/python/cp37-cp37m/bin/python setup.py bdist_wheel
+/opt/python/cp37-cp37m/bin/python setup.py bdist_wheel
 
 # Audit wheels
-#for wheel in dist/*.whl; do
-  #auditwheel repair $wheel -w dist/
-  #rm $wheel
-#done
+for wheel in dist/*.whl; do
+  auditwheel repair $wheel -w dist/
+  rm $wheel
+done
 
 # Extract wheels
 for wheel in dist/*.whl; do

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,38 +1,11 @@
+use ffikit::Signal;
 use pyroscope::backend::Tag;
 use pyroscope::PyroscopeAgent;
 use pyroscope_rbspy::{rbspy_backend, RbspyConfig};
+use std::collections::hash_map::DefaultHasher;
 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};
-
-pub enum Signal {
-    Kill,
-    AddTag(u64, String, String),
-    RemoveTag(u64, String, String),
-}
-
-pub struct SignalPass {
-    inner_sender: Mutex<SyncSender<Signal>>,
-    inner_receiver: Mutex<Receiver<Signal>>,
-}
-
-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);
-    });
-
-    unsafe { SIGNAL_PASS.assume_init_ref() }
-}
 
 #[no_mangle]
 pub extern "C" fn initialize_agent(
@@ -40,6 +13,9 @@ pub extern "C" fn initialize_agent(
     sample_rate: u32, detect_subprocesses: bool, on_cpu: bool, report_pid: bool,
     report_thread_id: bool, tags: *const c_char,
 ) -> bool {
+    // Initialize FFIKit
+    let recv = ffikit::initialize_ffi().unwrap();
+
     let application_name = unsafe { CStr::from_ptr(application_name) }
         .to_str()
         .unwrap()
@@ -62,44 +38,50 @@ pub extern "C" fn initialize_agent(
 
     let pid = std::process::id();
 
-    let s = signalpass();
+    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);
 
-    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)
+        .tags(tags);
 
-        let agent = agent_builder.build().unwrap();
+    if auth_token != "" {
+        agent_builder = agent_builder.auth_token(auth_token);
+    }
+
+    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 +94,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.3.1'.freeze
 end

data/lib/pyroscope.rb

@@ -1,34 +1,36 @@
 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_agent, [:string, :string, :string, :int, :bool, :bool, :bool, :bool, :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
     def initialize(*)
+      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.report_pid = false
+      self.report_thread_id = false
+      self.log_level = 'info'
+      self.tags = {}
       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 ||= []
     end
   end
 
@@ -40,26 +42,25 @@ module Pyroscope
       yield @config
 
       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)
+        @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.report_pid || false,
+        @config.report_thread_id || false,
+        tags_to_string(@config.tags || {})
       )
-
-      puts @config
     end
 
     def tag_wrapper(tags)
-      add_tags(tags)
+      tid = thread_id
+      _add_tags(tid, tags)
       begin
         yield
       ensure
-        remove_tags(tags)
+        _remove_tags(tid, tags)
       end
     end
 
@@ -67,31 +68,33 @@ 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
+    def remove_tags(*tags)
+      warn("deprecated. Use `Pyroscope.tag_wrapper` instead.")
+    end
 
-# get thread id
-def thread_id
-  return Utils.thread_id()
-end
+    # convert tags object to string
+    def tags_to_string(tags)
+      tags.map { |k, v| "#{k}=#{v}" }.join(',')
+    end
 
-# add tags
-def add_tags(tags)
-  tags.each do |tag_name, tag_value|
-    thread_id = thread_id()
-    Rust.add_tag(thread_id, tag_name.to_s, tag_value.to_s)
-  end
-end
+    # get thread id
+    def thread_id
+      return Utils.thread_id
+    end
 
-# remove tags
-def remove_tags(tags)
-  tags.each do |tag_name, tag_value|
-    thread_id = thread_id()
-    Rust.remove_tag(thread_id, tag_name.to_s, tag_value.to_s)
-  end
-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
       Rust.drop_agent

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pyroscope
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: arm64-darwin
 authors:
 - Pyroscope Team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-30 00:00:00.000000000 Z
+date: 2022-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -108,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Pyroscope