method_timer 0.1.0 → 0.2.0

data/docs/examples/reports-as-data.md

@@ -0,0 +1,124 @@
+# Sorting reports and keeping results as data
+
+[README](../../README.md) · [Report reference and schema](../reference.md#report)
+
+Use hash mode when another piece of console code needs the numbers. Formatting is global,
+but measurement methods still return the block's value.
+
+## Measure without printing a table
+
+```ruby
+require 'method_timer'
+
+class ReportWork
+  def wait = sleep(0.003)
+
+  def allocate
+    Array.new(1_000) { Object.new }
+  end
+end
+
+MethodTimer.format = :hash
+MethodTimer.install(ReportWork)
+work = ReportWork.new
+
+value = MethodTimer.run do
+  work.wait
+  work.allocate
+  :done
+end
+
+first = MethodTimer.report(sort: :allocs, limit: 1, threshold: 0)
+require 'pp'
+pp first
+```
+
+`value` is still `:done`. Complete captured output on Ruby 4.0.9 (arm64 macOS), including
+the installation notice on stderr and `pp first` on stdout. `run` itself prints no report:
+
+```text
+MethodTimer: instrumented 1 classes/modules under ReportWork (overhead 0.60µs per call).
+{methods:
+  {"ReportWork#allocate" =>
+    {self_t: 7.100001676008105e-05,
+     sql_t: 0.0,
+     gc_t: 0.0,
+     total_t: 7.100001676008105e-05,
+     calls: 1,
+     sql_calls: 0,
+     allocs: 1007}},
+ totals:
+  {wall_t: 0.003851999994367361,
+   ruby_t: 0.003842000034637749,
+   sql_t: 0.0,
+   gc_t: 0.0,
+   calls: 2,
+   sql_calls: 0,
+   allocs: 1012,
+   overhead_t: 1.1989999999059364e-06},
+ rss: nil}
+```
+
+`first` contains:
+
+- `methods`: one selected row, `ReportWork#allocate`, with raw numeric method metrics.
+- `totals`: both calls, including the hidden `wait` method.
+- `rss`: `nil`, because this run did not request memory sampling.
+
+Use `threshold: 0` for all called methods, including those too fast for the default threshold.
+All times are unrounded seconds; memory readings are bytes.
+
+## Render the same saved measurement
+
+```ruby
+MethodTimer.format = :table
+MethodTimer.report(sort: :allocs, limit: 1, threshold: 0)
+```
+
+Complete stderr from that saved measurement, without rerunning the workload:
+
+```text
+method                                                            self(ruby)  self(sql)   self(gc)      total      calls  sql calls       allocs
+------------------------------------------------------------------------------------------------------------------------------------------------
+ReportWork#allocate                                                 0.00007s   0.00000s   0.00000s   0.00007s          1          0         1007
+------------------------------------------------------------------------------------------------------------------------------------------------
+TOTAL (wall time of run block)                                                                       0.00385s
+  of which captured (sum of self ruby)                              0.00384s
+  of which SQL (sum of self sql / calls)                                       0.00000s                                           0
+  of which GC (sum of self gc)                                                            0.00000s
+  of which instrumentation overhead (estimated)                     0.00000s  (2 calls x 0.60µs, counted in callers' self)
+  total allocations (sum of self allocs)                                                                                                    1012
+------------------------------------------------------------------------------------------------------------------------------------------------
+```
+
+No work is run again. The table uses exactly the same timing and allocation data as the hash.
+Sort keys are `:self`, `:total`, `:sql`, `:gc`, `:calls`, `:sql_calls` and `:allocs`, all
+descending with a method-name tie breaker. Filtering and limiting never reduce the totals.
+
+Do not sort on `self_t` to imitate the table's `self(ruby)` column: the raw `self_t` metric
+includes SQL and GC. The `:self` sort subtracts both, and `totals[:ruby_t]` already excludes them.
+
+## The next measurement replaces the saved one
+
+```ruby
+MethodTimer.format = :hash
+MethodTimer.bench { 100.times { Object.new } }
+latest = MethodTimer.report
+
+first[:totals][:calls] # => 2, still the original profile
+latest[:methods]      # => {}
+
+MethodTimer.uninstall
+MethodTimer.format = :table
+```
+
+The benchmark replaces the gem's internal snapshot, but does not mutate `first`.
+It has only block-level totals: `wall_t`, `sql_t`, `gc_t`, `sql_calls` and `allocs`.
+You may retain returned hashes yourself; MethodTimer does not keep a history.
+
+Returned hashes are detached, so changing their nested metrics does not affect later reports.
+`reset` and `uninstall` clear saved measurements but do not reset the configured format.
+The explicit final assignment above leaves the console ready to print tables again.
+
+For two comparable profiles, capture a report after each run rather than inspecting live
+`stats` after a later benchmark or reset. See the [reference](../reference.md#stats-reset-and-uninstall).

data/docs/reference.md

@@ -0,0 +1,272 @@
+# API reference
+
+[README](../README.md) · [Examples](../README.md#examples-and-reference)
+
+MethodTimer is a console profiler with global configuration and one saved measurement.
+It requires Ruby 3.4+ and has no runtime dependencies. The Ruby version floor keeps the
+argument-forwarding wrappers allocation-free.
+
+## `install`
+
+Start with just the namespace you want to investigate; no options are required:
+
+```ruby
+MethodTimer.install(MyApp::Billing)
+```
+
+The root is a class or namespace. Installation discovers classes under it and wraps existing
+instance methods at their defining owners, including named modules mixed directly into those
+classes. It does not automatically instrument external superclasses.
+
+For example, the call above covers instance methods of `MyApp::Billing::MonthlyRun`,
+`MyApp::Billing::InvoiceExport` and other classes already defined under that namespace.
+It does not include their class methods by default. The namespace and classes must already
+exist in your console; see the [complete CSV example](examples/plain-ruby.md) for a runnable setup.
+
+### Common ways to install
+
+These are alternative scopes, using your application's existing constants. Call
+`MethodTimer.uninstall` before trying a different scope so earlier wrappers do not stay active.
+
+**One class, including its private helpers:**
+
+```ruby
+MethodTimer.install(MyApp::Billing::MonthlyRun)
+```
+
+**Several specific classes instead of the whole namespace:**
+
+```ruby
+MethodTimer.install(MyApp::Billing::MonthlyRun)
+MethodTimer.install(MyApp::Billing::InvoiceExport)
+```
+
+Both installs remain active together; one `MethodTimer.uninstall` removes both.
+
+**Only entry points, without wrapping every helper:**
+
+```ruby
+MethodTimer.install(MyApp::Billing, only: [:call])
+```
+
+Helpers still execute, but their work belongs to the selected caller rather than separate rows.
+
+**Class and module methods as well as instance methods:**
+
+```ruby
+MethodTimer.install(MyApp::Billing, singleton: true)
+```
+
+To select only methods named `call` on both paths, combine `singleton: true` with `only: [:call]`.
+See the [class and module example](examples/class-and-module-methods.md) for owner labels and inheritance.
+
+**Full namespace labels and unchanged SQL logging:**
+
+```ruby
+MethodTimer.install(MyApp::Billing, strip_root: false, silence_sql: false)
+```
+
+This keeps labels such as `MyApp::Billing::MonthlyRun#call` and leaves the current
+ActiveRecord logger untouched.
+
+### Options and behavior
+
+| Option | Default | Meaning |
+| --- | --- | --- |
+| `only:` | `nil` | Array of method-name symbols; `nil` selects all, `[]` selects none. |
+| `singleton:` | `false` | Also wrap singleton methods on classes and modules, and named modules they extend. |
+| `strip_root:` | `true` | Remove the common namespace from method labels. |
+| `silence_sql:` | `true` | Set `ActiveRecord::Base.logger` to `nil`, if ActiveRecord is loaded. |
+
+`only:` applies to public, protected and private methods, including singleton methods.
+Missing names are skipped. Unselected methods do not get wrappers, so their time belongs
+to any selected caller rather than a separate row. Other `only:` types raise `ArgumentError`.
+
+Direct instance methods use `Service#call`; direct singleton methods use `Service.call`.
+`module_function` copies use `Tools.call`. Named mixin implementations keep their
+`Mixin#call` owner label, including `extend self`.
+
+A mixin shared by `include` and `extend` is instrumented once, with shared call counts.
+`super` is measured separately at each installed owner it reaches. See the
+[class and module walkthrough](examples/class-and-module-methods.md).
+
+You can install unrelated roots together. Existing owners keep their first selection:
+uninstall before changing that filter. A later install with `singleton: true` can add
+previously uninstrumented singleton owners without duplicating instance wrappers.
+Discovery reads constants and can trigger autoloading.
+
+The original SQL logger is saved across repeated installs. `uninstall` restores it only
+if the current logger is still `nil`, leaving a replacement logger untouched.
+
+## `run`
+
+```ruby
+result = MethodTimer.run(rss: true) { thing_to_profile }
+```
+
+Resets previous counters, forces GC before timing, then profiles the block on its current
+thread. Returns the block's value. Existing instrumentation stays installed between runs.
+
+- With the default `format = :table`, prints a method report to stderr on exit.
+- With `format = :hash`, saves the measurement without rendering a report.
+- `rss: false` is the default. `rss: true` additionally samples process memory.
+- Exceptions propagate normally. Measurements for a block that raises are still saved,
+  and table mode still attempts to print them.
+
+The wall time includes the block and its instrumentation overhead, but excludes initial
+GC, final RSS collection, SQL unsubscription and report output.
+
+## `bench`
+
+```ruby
+result = MethodTimer.bench(rss: true) { thing_to_measure }
+```
+
+Measures wall time, GC time, same-thread SQL and process-wide allocations without enabling
+per-method recording. Returns the block's value. It resets prior counters and replaces
+the saved measurement; its method map is empty.
+
+Like `run`, it forces GC before measurement, supports `rss:`, prints only in table mode,
+and preserves exceptions. End counters are captured before cleanup and rendering.
+For comparisons, use a fresh process without installed wrappers; already-installed wrappers
+still perform their inactive thread check during `bench`.
+
+## `format`
+
+```ruby
+MethodTimer.format = :hash
+MethodTimer.run { thing_to_profile }
+data = MethodTimer.report
+
+MethodTimer.format = :table
+MethodTimer.report
+```
+
+Only `:table` and `:hash` are accepted; other values raise `ArgumentError`.
+Set the format before measuring. It controls rendering, not collection or block return values.
+It may be changed afterward to render the same saved measurement differently.
+Installation notices are independent of the report format.
+
+## `report`
+
+```ruby
+MethodTimer.report(sort: :allocs, limit: 20, threshold: 0)
+```
+
+Renders the last `run` or `bench`, not a new measurement. In table mode it prints to stderr;
+in hash mode it returns the structure below without printing.
+
+| Option | Default | Meaning |
+| --- | --- | --- |
+| `sort:` | `:self` | Sort by self Ruby time, total time, SQL, GC, calls, SQL calls or allocations. |
+| `limit:` | `nil` | At most this many methods; a non-negative integer or `nil` for all. |
+| `threshold:` | `0.001` | Hide methods with total time below this many seconds. |
+
+Sort keys: `:self`, `:total`, `:sql`, `:gc`, `:calls`, `:sql_calls`, `:allocs`.
+All sort descending; equal values use the method name. Unknown sort keys and invalid limits
+raise `ArgumentError` before anything is printed.
+
+The threshold is applied before the limit. `limit: 0` leaves only totals.
+Selection affects both formats' method rows, never their totals. It has no effect on
+collection overhead. Pass `threshold: 0` when the hash should include tiny methods too.
+
+### Hash structure
+
+This is an actual returned hash from the [reports-as-data example](examples/reports-as-data.md),
+captured on Ruby 4.0.9. The example also shows its table rendering from the same measurement:
+
+```ruby
+{
+  methods: {
+    'ReportWork#allocate' => {
+      self_t: 7.100001676008105e-05, sql_t: 0.0, gc_t: 0.0,
+      total_t: 7.100001676008105e-05, calls: 1, sql_calls: 0, allocs: 1007
+    }
+  },
+  totals: {
+    wall_t: 0.003851999994367361, ruby_t: 0.003842000034637749, sql_t: 0.0, gc_t: 0.0,
+    calls: 2, sql_calls: 0, allocs: 1012, overhead_t: 1.1989999999059364e-06
+  },
+  rss: nil
+}
+```
+
+- All times are unrounded seconds; RSS values are bytes.
+- Per-method `self_t` includes SQL and GC. Self Ruby time is `self_t - sql_t - gc_t`.
+- `total_t` includes instrumented callees; `calls`, SQL and allocations on a row do not.
+- Profile totals sum every captured method's self metrics and counts, even when rows are hidden.
+  `wall_t` is the whole block's wall time; `overhead_t` is the estimated wrapper overhead.
+- Benchmark totals have only `wall_t`, `sql_t`, `gc_t`, `sql_calls` and `allocs`; `methods` is `{}`.
+- `rss` is `nil` without `rss: true`; otherwise it has `:start`, `:peak` and `:end` byte readings.
+  Unavailable requested readings can be `nil` within the hash.
+
+Only one internal measurement is kept. New measurements replace it; returned hashes are
+detached and may be edited without changing the saved data. Labels and overhead calibration
+are captured at measurement end, so installing another root does not change an old report.
+Before a measurement, or after `reset` / `uninstall`, reporting yields an empty profile.
+
+## `stats`, `reset` and `uninstall`
+
+- `stats` returns the live, unfiltered per-method counters, using the same fields as
+  `report[:methods]`. Its labels reflect the current installation's common namespace.
+  It does not include wall time or RSS. `bench`, `reset` and `uninstall` clear these counters.
+- `reset` clears counters and the saved measurement, but keeps wrappers installed.
+- `uninstall` removes every added method wrapper, clears measurements and restores the SQL
+  logger as described above. It returns the number of instrumented owners cleared, including
+  mixins and singleton classes. Ruby leaves the emptied prepended modules in the ancestor chain.
+- Both reset operations keep the configured `format`.
+
+## Measurement semantics
+
+| Report column | Meaning |
+| --- | --- |
+| `self(ruby)` | Own wall time minus instrumented callees, SQL and GC. |
+| `self(sql)` | SQL attributed directly to this frame, not instrumented children. |
+| `self(gc)` | GC attributed directly to this frame, not instrumented children. |
+| `total` | Inclusive wall time, including called methods. |
+| `calls` | Completed wrapper invocations, including those unwinding an exception. |
+| `sql calls` | Uncached, non-schema `sql.active_record` notifications. |
+| `allocs` | Allocations attributed directly to this frame, not instrumented children. |
+
+`run` attributes SQL only while an instrumented method is active; `bench` counts SQL anywhere
+in its block. Both ignore SQL from other threads. Timings use monotonic clocks.
+With ActiveSupport 7.2+, GC inside a SQL event is excluded from SQL time and counted only as
+GC. Older versions expose no per-event GC duration, so SQL and GC can overlap and self Ruby
+time can consequently be negative.
+
+Wall time includes uninstrumented code and all profiler overhead. The sum of the self columns
+describes captured work, not necessarily the whole block: wrapper bookkeeping and work outside
+timed frames also take time. Never sum the inclusive `total` column to estimate overall time.
+
+The overhead estimate is calibrated during installation. It is not automatically subtracted,
+and is not an exact correction for individual methods. Narrow the instrumented scope if this
+estimate dominates the result; use `bench` for an uninstrumented comparison.
+
+RSS is the process's resident memory, not object counts or retained Ruby heap size.
+A child `sh` process samples it every second, using `/proc` on Linux or `ps` elsewhere.
+Sampling adds no allocation or GC work to the measured Ruby process, but may miss short-lived
+memory spikes. Start and end readings are included when calculating the reported peak.
+
+## Limitations
+
+- Console use only; global state is not safe for overlapping measurements.
+- Only the measuring thread's methods are recorded. GC, allocations and RSS remain process-wide.
+- Installation is a snapshot of existing methods; later definitions are not wrapped.
+  Rails attribute readers may be generated lazily after installation.
+- Anonymous mixins are skipped. External inherited owners must be installed explicitly.
+- Lambdas and blocks are not separate method rows; their work belongs to the calling frame.
+- Profiling does not sandbox the block, roll back writes, or make destructive code safe.
+
+## Development
+
+The modules are extended onto `MethodTimer` and share its state:
+
+- `lib/method_timer.rb`: block measurement, saved snapshot and format default.
+- `instrumenter.rb`: discovery, owner labels, wrappers and overhead calibration.
+- `recorder.rb`: per-depth arrays, self / inclusive counters, reset and raw stats.
+- `reporter.rb`: sorting, selection, hash assembly and table rendering.
+- `sql.rb`: optional ActiveSupport subscriptions.
+- `memory.rb`: RSS reads and child-process sampling.
+
+Specs live under `spec/`; `spec/method_timer_spec.rb` exercises block APIs end to end.
+Wrappers must stay allocation-free while recording, not just while inactive.

data/lib/method_timer/instrumenter.rb

@@ -1,22 +1,27 @@
 # frozen_string_literal: true
 
 module MethodTimer
-  # Wraps every method of the instrumented classes (and their directly included modules) in a prepended module
+  # Wraps selected methods at their class, module or singleton-class owner in a prepended module
   # that calls MethodTimer.enter / MethodTimer.leave around it.
   module Instrumenter
     CALIBRATION_CALLS = 200_000
 
-    def install(root, silence_sql: true, strip_root: true)
+    def install(root, silence_sql: true, strip_root: true, only: nil, singleton: false)
+      valid_only = only.nil? || (only.is_a?(Array) && only.all?(Symbol))
+      raise ArgumentError, 'only must be an array of symbols or nil' unless valid_only
       @root = root
       @strip_root = strip_root
-      ActiveRecord::Base.logger = nil if silence_sql && defined?(ActiveRecord::Base)
-      classes = []
-      classes << root if root.is_a?(Class)
-      each_class(root) { |k| classes << k }
-      sources = classes.flat_map { |k| [k, *own_included_modules(k)] }
-      @common_prefix = common_namespace(sources.filter_map(&:name))
+      if silence_sql && defined?(ActiveRecord::Base)
+        # A saved nil logger must stay distinct from no saved logger.
+        @saved_sql_logger ||= [ActiveRecord::Base.logger]
+        ActiveRecord::Base.logger = nil
+      end
+      targets = [root]
+      each_module(root) { |mod| targets << mod }
+      targets.select! { |mod| mod.is_a?(Class) } unless singleton
       already = @instrumented.size
-      classes.each { |k| instrument(k) }
+      targets.each { |target| instrument(target, only, singleton) }
+      @common_prefix = common_namespace(@instrumented.keys.filter_map { |source| owner_name(source) })
       calibrate
       warn "MethodTimer: instrumented #{@instrumented.size - already} classes/modules under #{root} " \
            '(overhead %.2fµs per call).' % (@overhead * 1e6)
@@ -28,11 +33,20 @@ module MethodTimer
     def uninstall
       @instrumented.each_value do |wrapper|
         (wrapper.instance_methods(false) + wrapper.private_instance_methods(false)).each do |m|
+          verbosity = $VERBOSE
+          # Ruby warns even when removing only our prepended constructor wrapper.
+          $VERBOSE = nil if m == :initialize
           wrapper.send(:remove_method, m)
+        ensure
+          $VERBOSE = verbosity if m == :initialize
         end
       end
       count = @instrumented.size
       @instrumented.clear
+      if @saved_sql_logger && defined?(ActiveRecord::Base) && ActiveRecord::Base.logger.nil?
+        ActiveRecord::Base.logger = @saved_sql_logger.first
+      end
+      @saved_sql_logger = nil
       reset
       count
     end
@@ -71,14 +85,14 @@ module MethodTimer
       Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
     end
 
-    def each_class(mod, seen = {}, &blk)
+    def each_module(mod, seen = {}, &blk)
       return if seen[mod]
       seen[mod] = true
       mod.constants(false).each do |c|
         val = mod.const_get(c)
         next unless val.is_a?(Module) && val.name&.start_with?(mod.name.to_s)
-        yield(val) if val.is_a?(Class)
-        each_class(val, seen, &blk)
+        yield(val)
+        each_module(val, seen, &blk)
       end
     rescue StandardError
       nil
@@ -86,37 +100,49 @@ module MethodTimer
 
     # Strips the namespace shared by all instrumented sources, so labels stay short yet unique
     # (a single fixed prefix removed from already-unique names cannot collide).
-    def label_for(klass)
-      return klass.name unless @strip_root && klass.name && !@common_prefix.to_s.empty?
-      klass.name.sub(/\A#{Regexp.escape(@common_prefix)}::/, '')
+    def label_for(name)
+      return name unless @strip_root && !@common_prefix.to_s.empty?
+      name.delete_prefix("#{@common_prefix}::")
     end
 
-    def instrument(klass)
-      instrument_owner(klass)
-      own_included_modules(klass).each { |mod| instrument_owner(mod) }
+    def owner_name(source)
+      source.singleton_class? ? source.attached_object.name : source.name
+    end
+
+    def instrument(target, only, singleton)
+      sources = target.is_a?(Class) ? [target] : []
+      sources << target.singleton_class if singleton
+      sources.each do |source|
+        instrument_owner(source, only)
+        own_included_modules(source).each { |mod| instrument_owner(mod, only) }
+      end
     end
 
     # Prepend a timing wrapper into the method owner itself (class or module) so that each ancestor
     # layer is measured independently: a method reached via `super` still records its own-owner timing.
-    def instrument_owner(source)
+    def instrument_owner(source, only)
       return if @instrumented[source]
-      wrapper = @instrumented[source] = Module.new
-      wrap_methods(wrapper, source, label_for(source))
+      wrapper = Module.new
+      wrapped_methods = wrap_methods(wrapper, source, only)
+      return if wrapped_methods.empty? && (only || source.singleton_class?)
+      @instrumented[source] = wrapper
       source.prepend(wrapper)
     end
 
-    # Modules mixed directly into klass (not inherited from its superclass, not anonymous wrappers).
+    # Named modules mixed into a class or singleton class, excluding inherited and anonymous layers.
     def own_included_modules(klass)
       inherited = klass.superclass ? klass.superclass.ancestors : []
       (klass.ancestors - inherited).select { |a| a.instance_of?(Module) && a != klass && a.name }
     end
 
-    def wrap_methods(wrapper, source, label)
+    def wrap_methods(wrapper, source, only)
       privates = source.private_instance_methods(false)
       protecteds = source.protected_instance_methods(false)
       methods = source.instance_methods(false) + privates
+      methods &= only if only
+      prefix = "#{owner_name(source)}#{source.singleton_class? ? '.' : '#'}"
       methods.each do |m|
-        define_wrapper(wrapper, m, register("#{label}##{m}"))
+        define_wrapper(wrapper, m, register("#{prefix}#{m}"))
         wrapper.send(:private, m) if privates.include?(m)
         wrapper.send(:protected, m) if protecteds.include?(m)
       end

data/lib/method_timer/memory.rb

@@ -28,6 +28,12 @@ module MethodTimer
 
     private
 
+    def finish_rss(sampler)
+      @rss_end = current_rss
+      @rss_peak = [@rss_start, stop_rss_sampler(sampler), @rss_end].compact.max
+      { start: @rss_start, peak: @rss_peak, end: @rss_end }
+    end
+
     # Samples the peak RSS from a child shell process, so sampling allocates nothing in this process and can't
     # skew allocs or self(gc). The child keeps the maximum and prints it (in KB) once, when stopped.
     def start_rss_sampler

data/lib/method_timer/recorder.rb

@@ -3,7 +3,7 @@
 module MethodTimer
   # Collects per-method stats during a run.
   module Recorder
-    # Per-method stats, indexed by method id: [self_t, sql_t, gc_ms, total_t, calls, sql_calls, allocs]
+    # Per-method stats, indexed by method id: [self_t, sql_t, gc_ns, total_t, calls, sql_calls, allocs]
     NAMES = []
     STATS = []
     # Per-depth frame data; depth 0 is the code running outside instrumented methods.
@@ -19,15 +19,17 @@ module MethodTimer
     def reset
       STATS.map! { [0.0, 0.0, 0, 0.0, 0, 0, 0] }
       @depth = 0
+      @last_measurement = nil
       @grand_total = 0.0
     end
 
     # { "Class#method" => { self_t:, sql_t:, gc_t:, total_t:, calls:, sql_calls:, allocs: } } for called methods
     def stats
-      STATS.each_with_index.filter_map do |(self_t, sql_t, gc_ms, total_t, calls, sql_calls, allocs), id|
+      STATS.each_with_index.filter_map do |(self_t, sql_t, gc_ns, total_t, calls, sql_calls, allocs), id|
         next if calls.zero?
 
-        [NAMES[id], { self_t:, sql_t:, gc_t: gc_ms / 1000.0, total_t:, calls:, sql_calls:, allocs: }]
+        gc_t = gc_ns / 1_000_000_000.0
+        [label_for(NAMES[id]), { self_t:, sql_t:, gc_t:, total_t:, calls:, sql_calls:, allocs: }]
       end.to_h
     end
 
@@ -43,7 +45,7 @@ module MethodTimer
       CHILD_G[d] = 0
       SQL_T[d] = 0.0
       SQL_N[d] = 0
-      START_G[d] = GC.stat(:time)
+      START_G[d] = GC.total_time
       START_A[d] = GC.stat(:total_allocated_objects)
       START_T[d] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
@@ -54,30 +56,30 @@ module MethodTimer
       d = @depth
       total = Process.clock_gettime(Process::CLOCK_MONOTONIC) - START_T[d]
       allocs = GC.stat(:total_allocated_objects) - START_A[d]
-      gc_ms = GC.stat(:time) - START_G[d]
+      gc_ns = GC.total_time - START_G[d]
       @depth = d - 1
-      record(STATS[id], d, total, allocs, gc_ms)
+      record(STATS[id], d, total, allocs, gc_ns)
       CHILD_T[d - 1] += total
       CHILD_A[d - 1] += allocs
-      CHILD_G[d - 1] += gc_ms
+      CHILD_G[d - 1] += gc_ns
     end
 
     private
 
-    def record(stat, depth, total, allocs, gc_ms)
+    def record(stat, depth, total, allocs, gc_ns)
       stat[0] += total - CHILD_T[depth]
       stat[1] += SQL_T[depth] # SQL fired directly in this method (not in instrumented children)
-      stat[2] += gc_ms - CHILD_G[depth] # GC pauses that started directly in this method
+      stat[2] += gc_ns - CHILD_G[depth] # GC pauses that started directly in this method
       stat[3] += total
       stat[4] += 1
       stat[5] += SQL_N[depth]
       stat[6] += allocs - CHILD_A[depth] # objects allocated directly in this method
     end
 
-    def record_sql(start, finish)
+    def record_sql(duration)
       return if @depth.zero? || !Thread.current.equal?(@thread)
 
-      SQL_T[@depth] += finish - start
+      SQL_T[@depth] += duration
       SQL_N[@depth] += 1
     end