rperf 0.5.0 → 0.7.0

data/lib/rperf/active_job.rb

@@ -0,0 +1,13 @@
+require "rperf"
+
+module Rperf::ActiveJobMiddleware
+  extend ActiveSupport::Concern
+
+  included do
+    around_perform do |job, block|
+      Rperf.profile(job: job.class.name) do
+        block.call
+      end
+    end
+  end
+end

data/lib/rperf/rack.rb

@@ -0,0 +1,15 @@
+require "rperf"
+
+class Rperf::RackMiddleware
+  def initialize(app, label_key: :endpoint)
+    @app = app
+    @label_key = label_key
+  end
+
+  def call(env)
+    endpoint = "#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
+    Rperf.profile(@label_key => endpoint) do
+      @app.call(env)
+    end
+  end
+end

data/lib/rperf/sidekiq.rb

@@ -0,0 +1,9 @@
+require "rperf"
+
+class Rperf::SidekiqMiddleware
+  def call(_worker, job, _queue)
+    Rperf.profile(job: job["class"]) do
+      yield
+    end
+  end
+end

data/lib/rperf/version.rb

@@ -1,3 +1,3 @@
 module Rperf
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

data/lib/rperf.rb

@@ -1,4 +1,4 @@
-require "rperf/version"
+require_relative "rperf/version"
 require "zlib"
 require "stringio"
 
@@ -23,7 +23,7 @@ module Rperf
   #   .collapsed → collapsed stacks (FlameGraph / speedscope compatible)
   #   .txt       → text report (human/AI readable flat + cumulative table)
   #   otherwise (.pb.gz etc) → pprof protobuf (gzip compressed)
-  def self.start(frequency: 1000, mode: :cpu, output: nil, verbose: false, format: nil, stat: false, signal: nil, aggregate: true)
+  def self.start(frequency: 1000, mode: :cpu, output: nil, verbose: false, format: nil, stat: false, signal: nil, aggregate: true, defer: false)
     raise ArgumentError, "frequency must be a positive integer (got #{frequency.inspect})" unless frequency.is_a?(Integer) && frequency > 0
     raise ArgumentError, "frequency must be <= 10000 (10KHz), got #{frequency}" if frequency > 10_000
     raise ArgumentError, "mode must be :cpu or :wall, got #{mode.inspect}" unless %i[cpu wall].include?(mode)
@@ -42,7 +42,9 @@ module Rperf
     @format = format
     @stat = stat
     @stat_start_mono = Process.clock_gettime(Process::CLOCK_MONOTONIC) if @stat
-    _c_start(frequency, c_mode, aggregate, c_signal)
+    @label_set_table = nil
+    @label_set_index = nil
+    _c_start(frequency, c_mode, aggregate, c_signal, defer)
 
     if block_given?
       begin
@@ -61,15 +63,15 @@ module Rperf
     # :aggregated_samples.  Build aggregated view so encoders always work.
     if data[:raw_samples] && !data[:aggregated_samples]
       merged = {}
-      data[:raw_samples].each do |frames, weight, thread_seq|
-        key = [frames, thread_seq || 0]
+      data[:raw_samples].each do |frames, weight, thread_seq, label_set_id|
+        key = [frames, thread_seq || 0, label_set_id || 0]
         if merged.key?(key)
           merged[key] += weight
         else
           merged[key] = weight
         end
       end
-      data[:aggregated_samples] = merged.map { |(frames, ts), w| [frames, w, ts] }
+      data[:aggregated_samples] = merged.map { |(frames, ts, lsi), w| [frames, w, ts, lsi] }
     end
 
     print_stats(data) if @verbose
@@ -84,6 +86,109 @@ module Rperf
     data
   end
 
+  # Returns a snapshot of the current profiling data without stopping.
+  # Only works in aggregate mode (the default). Returns nil if not profiling.
+  # The returned data has the same format as stop's return value and can be
+  # passed to save(), PProf.encode(), Collapsed.encode(), or Text.encode().
+  #
+  # +clear:+ if true, resets aggregated data after taking the snapshot.
+  # This allows interval-based profiling where each snapshot covers only
+  # the period since the last clear.
+  def self.snapshot(clear: false)
+    _c_snapshot(clear)
+  end
+
+  # Label set management for per-context profiling.
+  # Label sets are stored as an Array of Hashes, indexed by label_set_id.
+  # Index 0 is reserved (no labels).
+
+  @label_set_table = nil  # Array of frozen Hash
+  @label_set_index = nil  # Hash → id (for dedup)
+
+  def self._init_label_sets
+    @label_set_table = [{}]  # id 0 = no labels
+    @label_set_index = { {} => 0 }
+  end
+
+  def self._intern_label_set(hash)
+    frozen = hash.frozen? ? hash : hash.freeze
+    @label_set_index[frozen] ||= begin
+      id = @label_set_table.size
+      @label_set_table << frozen
+      _c_set_label_sets(@label_set_table)
+      id
+    end
+  end
+
+  # Sets labels on the current thread for profiling annotation.
+  # With a block: restores previous labels when the block exits.
+  # Without a block: sets labels persistently on the current thread.
+  # Labels are key-value pairs written into pprof sample labels.
+  #
+  #   Rperf.label(request: "abc") { handle_request }
+  #   Rperf.label(request: "abc")  # persistent set
+  #
+  # Values of nil remove that key. Existing labels are merged.
+  def self.label(**kw, &block)
+    _init_label_sets unless @label_set_table
+
+    cur_id = _c_get_label
+    cur_labels = @label_set_table[cur_id] || {}
+
+    new_labels = cur_labels.merge(kw).reject { |_, v| v.nil? }
+    new_id = _intern_label_set(new_labels)
+    _c_set_label(new_id)
+
+    if block
+      begin
+        yield
+      ensure
+        _c_set_label(cur_id)
+      end
+    end
+  end
+
+  # Profiles the given block: activates timer sampling for the duration
+  # and optionally applies labels. Use with start(defer: true) to profile
+  # only specific sections of code.
+  #
+  #   Rperf.start(defer: true, mode: :wall)
+  #   Rperf.profile(endpoint: "/users") { handle_request }
+  #   data = Rperf.stop
+  #
+  # Nesting is supported: timer stays active until the outermost profile exits.
+  # Requires a block. Raises if profiling is not started.
+  def self.profile(**kw, &block)
+    raise ArgumentError, "Rperf.profile requires a block" unless block
+    raise RuntimeError, "Rperf is not started" unless _c_running?
+
+    _init_label_sets unless @label_set_table
+
+    cur_id = _c_get_label
+    cur_labels = @label_set_table[cur_id] || {}
+    new_labels = cur_labels.merge(kw).reject { |_, v| v.nil? }
+    new_id = _intern_label_set(new_labels)
+    _c_set_label(new_id)
+
+    _c_profile_inc
+
+    begin
+      yield
+    ensure
+      _c_profile_dec
+      _c_set_label(cur_id)
+    end
+  end
+
+  # Returns the current thread's labels as a Hash.
+  # Returns an empty Hash if no labels are set or profiling is not running.
+  def self.labels
+    return {} unless @label_set_table
+    cur_id = _c_get_label
+    @label_set_table[cur_id] || {}
+  end
+
+
   # Saves profiling data to a file.
   # format: :pprof, :collapsed, or :text. nil = auto-detect from path extension
   #   .collapsed → collapsed stacks (FlameGraph / speedscope compatible)
@@ -498,17 +603,30 @@ module Rperf
         end
       }
 
-      # Convert string frames to index frames and merge identical stacks per thread
+      # Convert string frames to index frames and merge identical stacks per thread/label
       merged = Hash.new(0)
       thread_seq_key = intern.("thread_seq")
-      samples_raw.each do |frames, weight, thread_seq|
-        key = [frames.map { |path, label| [intern.(path), intern.(label)] }, thread_seq || 0]
+      label_sets = data[:label_sets]  # Array of Hash (may be nil)
+      samples_raw.each do |frames, weight, thread_seq, label_set_id|
+        key = [frames.map { |path, label| [intern.(path), intern.(label)] }, thread_seq || 0, label_set_id || 0]
         merged[key] += weight
       end
       merged = merged.to_a
 
+      # Intern label set keys/values for pprof labels
+      label_key_indices = {}  # String key → string_table index
+      if label_sets
+        label_sets.each do |ls|
+          ls.each do |k, v|
+            sk = k.to_s
+            label_key_indices[sk] ||= intern.(sk)
+            intern.(v.to_s)  # ensure value is interned
+          end
+        end
+      end
+
       # Build location/function tables
-      locations, functions = build_tables(merged.map { |(frames, _), w| [frames, w] })
+      locations, functions = build_tables(merged.map { |(frames, _, _), w| [frames, w] })
 
       # Intern type label and unit
       type_label = mode == :wall ? "wall" : "cpu"
@@ -521,8 +639,8 @@ module Rperf
       # field 1: sample_type (repeated ValueType)
       buf << encode_message(1, encode_value_type(type_idx, ns_idx))
 
-      # field 2: sample (repeated Sample) with thread_seq label
-      merged.each do |(frames, thread_seq), weight|
+      # field 2: sample (repeated Sample) with thread_seq + user labels
+      merged.each do |(frames, thread_seq, label_set_id), weight|
         sample_buf = "".b
         loc_ids = frames.map { |f| locations[f] }
         sample_buf << encode_packed_uint64(1, loc_ids)
@@ -533,6 +651,17 @@ module Rperf
           label_buf << encode_int64(3, thread_seq)       # num
           sample_buf << encode_message(3, label_buf)
         end
+        if label_sets && label_set_id && label_set_id > 0
+          ls = label_sets[label_set_id]
+          if ls
+            ls.each do |k, v|
+              label_buf = "".b
+              label_buf << encode_int64(1, label_key_indices[k.to_s])  # key
+              label_buf << encode_int64(2, string_index[v.to_s])       # str
+              sample_buf << encode_message(3, label_buf)
+            end
+          end
+        end
         buf << encode_message(2, sample_buf)
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rperf
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Koichi Sasada
@@ -52,6 +52,9 @@ files:
 - ext/rperf/extconf.rb
 - ext/rperf/rperf.c
 - lib/rperf.rb
+- lib/rperf/active_job.rb
+- lib/rperf/rack.rb
+- lib/rperf/sidekiq.rb
 - lib/rperf/version.rb
 homepage: https://github.com/ko1/rperf
 licenses: