rperf 0.4.0 → 0.6.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.label(job: job.class.name) do
+        block.call
+      end
+    end
+  end
+end

data/lib/rperf/middleware.rb

@@ -0,0 +1,15 @@
+require "rperf"
+
+class Rperf::Middleware
+  def initialize(app, label_key: :endpoint)
+    @app = app
+    @label_key = label_key
+  end
+
+  def call(env)
+    endpoint = "#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}"
+    Rperf.label(@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.label(job: job["class"]) do
+      yield
+    end
+  end
+end

data/lib/rperf/version.rb

@@ -1,3 +1,3 @@
 module Rperf
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/rperf.rb

@@ -1,4 +1,4 @@
-require "rperf/version"
+require_relative "rperf/version"
 require "zlib"
 require "stringio"
 
@@ -24,14 +24,27 @@ module Rperf
   #   .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)
+    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)
+    c_mode = mode == :cpu ? 0 : 1
+    c_signal = signal.nil? ? -1 : (signal ? signal.to_i : 0)
+    if c_signal > 0
+      raise ArgumentError, "signal mode is only supported on Linux" unless RUBY_PLATFORM =~ /linux/
+      uncatchable = [Signal.list["KILL"], Signal.list["STOP"]].compact
+      if uncatchable.include?(c_signal)
+        name = Signal.signame(c_signal) rescue c_signal.to_s
+        raise ArgumentError, "signal #{c_signal} (#{name}) cannot be caught; use a different signal"
+      end
+    end
     @verbose = verbose || ENV["RPERF_VERBOSE"] == "1"
     @output = output
     @format = format
     @stat = stat
     @stat_start_mono = Process.clock_gettime(Process::CLOCK_MONOTONIC) if @stat
-    c_opts = { frequency: frequency, mode: mode, aggregate: aggregate }
-    c_opts[:signal] = signal unless signal.nil?
-    _c_start(**c_opts)
+    @label_set_table = nil
+    @label_set_index = nil
+    _c_start(frequency, c_mode, aggregate, c_signal)
 
     if block_given?
       begin
@@ -46,6 +59,21 @@ module Rperf
     data = _c_stop
     return unless data
 
+    # When aggregate: false, C extension returns :raw_samples but not
+    # :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, 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, lsi), w| [frames, w, ts, lsi] }
+    end
+
     print_stats(data) if @verbose
     print_stat(data) if @stat
 
@@ -58,6 +86,77 @@ 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
+
+  # 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)
@@ -148,7 +247,7 @@ module Rperf
 
   # Samples from C are now [[path_str, label_str], ...], weight]
   def self.print_top(data)
-    samples_raw = data[:samples]
+    samples_raw = data[:aggregated_samples]
     return if !samples_raw || samples_raw.empty?
 
     result = compute_flat_cum(samples_raw)
@@ -180,7 +279,7 @@ module Rperf
   private_constant :STAT_PCT_LINE, :STAT_LINE
 
   def self.print_stat(data)
-    samples_raw = data[:samples] || []
+    samples_raw = data[:aggregated_samples] || []
     real_ns = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - @stat_start_mono) * 1_000_000_000).to_i
     times = Process.times
     user_ns = (times.utime * 1_000_000_000).to_i
@@ -198,7 +297,7 @@ module Rperf
     if samples_raw.size > 0
       breakdown, total_weight = compute_stat_breakdown(samples_raw)
       print_stat_breakdown(breakdown, total_weight)
-      print_stat_runtime_info
+      print_stat_runtime_info(data)
       print_stat_system_info
       print_stat_report(data) if ENV["RPERF_STAT_REPORT"] == "1"
       print_stat_footer(samples_raw, real_ns, data)
@@ -246,7 +345,9 @@ module Rperf
   end
   private_class_method :print_stat_breakdown
 
-  def self.print_stat_runtime_info
+  def self.print_stat_runtime_info(data)
+    thread_count = data[:detected_thread_count] || 0
+    $stderr.puts STAT_LINE.call(format_integer(thread_count), "  ", "[Ruby] detected threads") if thread_count > 0
     gc = GC.stat
     $stderr.puts STAT_LINE.call(format_ms(gc[:time] * 1_000_000), "ms",
                                 "[Ruby] GC time (%s count: %s minor, %s major)" % [
@@ -391,7 +492,7 @@ module Rperf
     module_function
 
     def encode(data, top_n: 50, header: true)
-      samples_raw = data[:samples]
+      samples_raw = data[:aggregated_samples]
       mode = data[:mode] || :cpu
       frequency = data[:frequency] || 0
 
@@ -433,8 +534,10 @@ module Rperf
     module_function
 
     def encode(data)
+      samples = data[:aggregated_samples]
+      return "" if !samples || samples.empty?
       merged = Hash.new(0)
-      data[:samples].each do |frames, weight|
+      samples.each do |frames, weight|
         key = frames.reverse.map { |_, label| label }.join(";")
         merged[key] += weight
       end
@@ -451,7 +554,7 @@ module Rperf
     module_function
 
     def encode(data)
-      samples_raw = data[:samples]
+      samples_raw = data[:aggregated_samples]
       frequency = data[:frequency]
       interval_ns = 1_000_000_000 / frequency
       mode = data[:mode] || :cpu
@@ -468,17 +571,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"
@@ -491,8 +607,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)
@@ -503,6 +619,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
 
@@ -537,7 +664,7 @@ module Rperf
 
       # field 6: string_table (repeated string)
       string_table.each do |s|
-        buf << encode_bytes(6, s.encode("UTF-8"))
+        buf << encode_bytes(6, s.encode("UTF-8", invalid: :replace, undef: :replace))
       end
 
       # field 9: time_nanos (int64)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rperf
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.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/middleware.rb
+- lib/rperf/sidekiq.rb
 - lib/rperf/version.rb
 homepage: https://github.com/ko1/rperf
 licenses: