method_timer 0.1.0 → 0.2.0

data/lib/method_timer/reporter.rb

@@ -1,69 +1,101 @@
 # frozen_string_literal: true
 
 module MethodTimer
-  # Prints the `run` and `bench` reports to stderr.
+  # Renders the last measurement as a table or a detached hash.
   module Reporter
-    def report(threshold: 0.001)
-      all = stats
-      @name_width = [65, *all.keys.map(&:length)].max
+    SORT_KEYS = { self: nil, total: :total_t, sql: :sql_t, gc: :gc_t, calls: :calls,
+                  sql_calls: :sql_calls, allocs: :allocs }.freeze
+
+    attr_reader :format
+
+    def format=(value)
+      raise ArgumentError, 'format must be :table or :hash' unless %i[table hash].include?(value)
+      @format = value
+    end
+
+    def report(threshold: 0.001, sort: :self, limit: nil)
+      raise ArgumentError, "unknown sort: #{sort.inspect}" unless SORT_KEYS.key?(sort)
+      valid_limit = limit.nil? || (limit.is_a?(Integer) && limit >= 0)
+      raise ArgumentError, 'limit must be a non-negative integer or nil' unless valid_limit
+      measurement = @last_measurement || { kind: :run, methods: {}, wall_t: 0.0, overhead: 0.0, rss: nil }
+      all = measurement[:methods]
+      key = SORT_KEYS.fetch(sort)
+      rows = all.reject { |_, values| values[:total_t] < threshold }
+                .sort_by { |name, values| [-(key ? values.fetch(key) : self_ruby(values)), name] }
+      rows = rows.first([limit, rows.length].min) if limit
+      data = { methods: rows.to_h.transform_values(&:dup), totals: measurement_totals(measurement),
+               rss: measurement[:rss]&.dup }
+      return data if format == :hash
+      if measurement[:kind] == :bench
+        report_bench(data[:totals], data[:rss])
+      else
+        report_profile(data, measurement[:overhead], all.keys)
+      end
+    end
+
+    private
+
+    def self_ruby(stats)
+      stats[:self_t] - stats[:sql_t] - stats[:gc_t]
+    end
+
+    def measurement_totals(measurement)
+      return measurement.slice(:wall_t, :sql_t, :gc_t, :sql_calls, :allocs) if measurement[:kind] == :bench
+      values = measurement[:methods].values
+      calls = values.sum { |value| value[:calls] }
+      {
+        wall_t: measurement[:wall_t], ruby_t: values.sum(0.0) { |value| self_ruby(value) },
+        sql_t: values.sum(0.0) { |value| value[:sql_t] }, gc_t: values.sum(0.0) { |value| value[:gc_t] },
+        calls:, sql_calls: values.sum { |value| value[:sql_calls] }, allocs: values.sum { |value| value[:allocs] },
+        overhead_t: calls * measurement[:overhead]
+      }
+    end
+
+    def report_profile(data, overhead, names)
+      @name_width = [65, *names.map(&:length)].max
       warn "\n%-*s %10s %10s %10s %10s %10s %10s %12s" %
         [@name_width, 'method', 'self(ruby)', 'self(sql)', 'self(gc)', 'total', 'calls', 'sql calls', 'allocs']
       warn '-' * (@name_width + 79)
-      all.sort_by { |_, v| -self_ruby(v) }.each do |name, v|
-        next if v[:total_t] < threshold
+      data[:methods].each do |name, v|
         warn '%-*s %9.5fs %9.5fs %9.5fs %9.5fs %10d %10d %12d' %
           [@name_width, name, self_ruby(v), v[:sql_t], v[:gc_t], v[:total_t], v[:calls], v[:sql_calls], v[:allocs]]
       end
       warn '-' * (@name_width + 79)
-      report_totals(all.values)
-      report_rss("peak (sampled every #{Memory::RSS_INTERVAL}s)") if @rss_peak
+      report_totals(data[:totals], overhead)
+      report_rss(data[:rss]) if data[:rss] && data[:rss][:peak]
       warn '-' * (@name_width + 79)
     end
 
-    private
-
-    def self_ruby(stats)
-      stats[:self_t] - stats[:sql_t] - stats[:gc_t]
-    end
-
-    def report_totals(values)
+    def report_totals(totals, overhead)
       w = @name_width
-      calls = values.sum { |v| v[:calls] }
-      sql_t = values.sum { |v| v[:sql_t] }
-      sql_calls = values.sum { |v| v[:sql_calls] }
-      gc_t = values.sum { |v| v[:gc_t] }
-      allocs = values.sum { |v| v[:allocs] }
-      warn '%-*s %10s %10s %10s %9.5fs' % [w, 'TOTAL (wall time of run block)', '', '', '', @grand_total]
-      warn '%-*s %9.5fs' % [w, '  of which captured (sum of self ruby)', values.sum { |v| self_ruby(v) }]
-      warn '%-*s %10s %9.5fs %10s %10s %10s %10d' % [w, '  of which SQL (sum of self sql / calls)', '', sql_t,
-                                                     '', '', '', sql_calls]
-      warn '%-*s %10s %10s %9.5fs' % [w, '  of which GC (sum of self gc)', '', '', gc_t]
+      warn '%-*s %10s %10s %10s %9.5fs' % [w, 'TOTAL (wall time of run block)', '', '', '', totals[:wall_t]]
+      warn '%-*s %9.5fs' % [w, '  of which captured (sum of self ruby)', totals[:ruby_t]]
+      warn '%-*s %10s %9.5fs %10s %10s %10s %10d' %
+        [w, '  of which SQL (sum of self sql / calls)', '', totals[:sql_t], '', '', '', totals[:sql_calls]]
+      warn '%-*s %10s %10s %9.5fs' % [w, '  of which GC (sum of self gc)', '', '', totals[:gc_t]]
       warn '%-*s %9.5fs  (%d calls x %.2fµs, counted in callers\' self)' %
-        [w, '  of which instrumentation overhead (estimated)', calls * @overhead, calls, @overhead * 1e6]
-      warn '%-*s %10s %10s %10s %10s %10s %10s %12d' % [w, '  total allocations (sum of self allocs)', '', '', '', '',
-                                                        '', '', allocs]
+        [w, '  of which instrumentation overhead (estimated)', totals[:overhead_t], totals[:calls], overhead * 1e6]
+      warn '%-*s %10s %10s %10s %10s %10s %10s %12d' %
+        [w, '  total allocations (sum of self allocs)', '', '', '', '', '', '', totals[:allocs]]
     end
 
-    def report_bench((t0, gc0, alloc0), (sql_t, sql_calls), rss, sampler)
-      warn "\n%-20s %9.3fs" % ['wall', Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0]
-      warn '%-20s %9.3fs' % ['GC', (GC.stat(:time) - gc0) / 1000.0]
-      warn '%-20s %9.3fs (%d queries)' % ['SQL', sql_t, sql_calls]
-      warn '%-20s %10d' % ['allocations', GC.stat(:total_allocated_objects) - alloc0]
-      return unless rss
-
-      @rss_end = current_rss
-      @rss_peak = [@rss_start, stop_rss_sampler(sampler), @rss_end].compact.max
-      report_rss("peak (sampled every #{Memory::RSS_INTERVAL}s)")
+    def report_bench(totals, rss)
+      warn "\n%-20s %9.3fs" % ['wall', totals[:wall_t]]
+      warn '%-20s %9.3fs' % ['GC', totals[:gc_t]]
+      warn '%-20s %9.3fs (%d queries)' % ['SQL', totals[:sql_t], totals[:sql_calls]]
+      warn '%-20s %10d' % ['allocations', totals[:allocs]]
+      report_rss(rss) if rss
     end
 
-    def report_rss(peak_label = 'peak')
+    def report_rss(rss)
       warn ''
-      warn '%-*s %10s' % [@name_width, '  RSS start', format_bytes(@rss_start)]
-      warn '%-*s %10s' % [@name_width, "  RSS #{peak_label}", format_bytes(@rss_peak)]
-      warn '%-*s %10s' % [@name_width, '  RSS end', format_bytes(@rss_end)]
-      return unless @rss_peak && @rss_start
+      warn '%-*s %10s' % [@name_width, '  RSS start', format_bytes(rss[:start])]
+      warn '%-*s %10s' %
+        [@name_width, "  RSS peak (sampled every #{Memory::RSS_INTERVAL}s)", format_bytes(rss[:peak])]
+      warn '%-*s %10s' % [@name_width, '  RSS end', format_bytes(rss[:end])]
+      return unless rss[:peak] && rss[:start]
 
-      warn '%-*s %10s' % [@name_width, '  RSS growth (peak - start)', format_bytes(@rss_peak - @rss_start)]
+      warn '%-*s %10s' % [@name_width, '  RSS growth (peak - start)', format_bytes(rss[:peak] - rss[:start])]
     end
 
     def format_bytes(bytes)

data/lib/method_timer/sql.rb

@@ -8,8 +8,14 @@ module MethodTimer
     def subscribe_sql
       return unless defined?(ActiveSupport::Notifications)
 
-      ActiveSupport::Notifications.subscribe('sql.active_record') do |_, start, finish, _, payload|
-        yield(start, finish) unless payload[:cached] || payload[:name] == 'SCHEMA'
+      thread = Thread.current
+      ActiveSupport::Notifications.subscribe('sql.active_record') do |event|
+        next unless Thread.current.equal?(thread)
+        next if event.payload[:cached] || event.payload[:name] == 'SCHEMA'
+
+        # shortcut: ActiveSupport < 7.2 lacks event GC timing; upgrade for a disjoint SQL/GC split.
+        gc_ms = event.respond_to?(:gc_time) ? event.gc_time : 0.0
+        yield((event.duration - gc_ms) / 1000.0)
       end
     end
 

data/lib/method_timer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MethodTimer
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/method_timer.rb

@@ -28,11 +28,12 @@ module MethodTimer
   @strip_root = true
   @common_prefix = ''
   @name_width = 65
+  @format = :table
 
   class << self
     def run(rss: false)
       reset
-      subscriber = subscribe_sql { |start, finish| record_sql(start, finish) }
+      subscriber = subscribe_sql { |duration| record_sql(duration) }
       GC.start
       @rss_start = @rss_peak = rss ? current_rss : nil
       sampler = start_rss_sampler if rss
@@ -42,28 +43,39 @@ module MethodTimer
     ensure
       @grand_total = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
       @thread = nil
-      if rss
-        @rss_end = current_rss
-        @rss_peak = [@rss_start, stop_rss_sampler(sampler), @rss_end].compact.max
-      end
+      memory = finish_rss(sampler) if rss
       unsubscribe_sql(subscriber)
-      report
+      @last_measurement = { kind: :run, methods: stats, wall_t: @grand_total, overhead: @overhead, rss: memory }
+      report if format == :table
     end
 
     def bench(rss: false)
+      reset
       sql = [0.0, 0] # [time, calls]
-      subscriber = subscribe_sql do |start, finish|
-        sql[0] += finish - start
+      subscriber = subscribe_sql do |duration|
+        sql[0] += duration
         sql[1] += 1
       end
       GC.start
       @rss_start = @rss_peak = rss ? current_rss : nil
       sampler = start_rss_sampler if rss
-      start = [Process.clock_gettime(Process::CLOCK_MONOTONIC), GC.stat(:time), GC.stat(:total_allocated_objects)]
+      start = [Process.clock_gettime(Process::CLOCK_MONOTONIC), GC.total_time, GC.stat(:total_allocated_objects)]
       yield
     ensure
+      if start
+        elapsed = [
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - start[0],
+          GC.total_time - start[1],
+          GC.stat(:total_allocated_objects) - start[2]
+        ]
+        memory = finish_rss(sampler) if rss
+        @last_measurement = {
+          kind: :bench, methods: {}, wall_t: elapsed[0], gc_t: elapsed[1] / 1_000_000_000.0,
+          allocs: elapsed[2], sql_t: sql[0], sql_calls: sql[1], rss: memory
+        }
+      end
       unsubscribe_sql(subscriber)
-      report_bench(start, sql, rss, sampler) if start
+      report if elapsed && format == :table
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: method_timer
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Konrad Jurkowski
@@ -18,8 +18,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
+- docs/examples/benchmarking.md
+- docs/examples/class-and-module-methods.md
+- docs/examples/plain-ruby.md
+- docs/examples/rails-console.md
+- docs/examples/real-world-export.md
+- docs/examples/reports-as-data.md
+- docs/reference.md
 - lib/method_timer.rb
 - lib/method_timer/instrumenter.rb
 - lib/method_timer/memory.rb
@@ -47,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Low-overhead per-method timing for Ruby code, made for profiling from a console.
 test_files: []