rspec_telemetry 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 796f640dcbe14855620f29d78972456705d29af7025b3e01171e9f4d76dfca04
-  data.tar.gz: 271548c28826a191510187593eaef599771f964c16b3061c7e6d6751e4dbd7fd
+  metadata.gz: cbedbd6b59f7770b4994ee3f8cc9d475f27b606b391e0a63ee8bae67c5ca9098
+  data.tar.gz: e6119f45762763a2b3aa2051085bf2b1d6933c664e186b2a55d45622dd0b59ff
 SHA512:
-  metadata.gz: 960b867f5af3ed3a290d637422dee0436ec10b72b7554a9bb348329cd7ba561dbeaca388148cb41f39c1e616708f570d8c2466855f6321cbd1f9bfbf4861e464
-  data.tar.gz: 1ddef07a9486a993f55073db7a717e185dba269cacc4f379dc43e117b42b35edebb09a07d81a2be9d652a07eb2208fced3e13faff4f3e70a82a78a71780c577b
+  metadata.gz: 6e21234960ca8f439c492f38c4fdf8ea8af5b25b5ca4afdb4722e4f6b15eb9a3a23c3fd5a244ca638f7d3840fa3940301166de51a4158b8b89201083441197e0
+  data.tar.gz: 3c0d0a3b778ea07ecb15948b8a8aaa30ff16f187bc5a78bf2d0e3c3d704f022ce8f48ec312012dbc2d5c3b05889a5c1ea56fa6d63df40ea75a5dad45e687aa00

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-07-19
+
+Example time is now broken down beyond factories, so you can tell what is
+slow when factories are not the answer.
+
+### Added
+- Rails request timing, with its database and view time.
+- SQL time, split into queries fired by factories and queries fired by the
+  code under test. Set `slow_sql_threshold_ms` to also record the individual
+  queries above a threshold.
+- GC time and allocation counts per example.
+- Config flags for the above: `capture_requests`, `capture_sql`,
+  `capture_gc` (all default to `true`).
+- `rspec-telemetry` reports the new numbers in its overview, adds a
+  "Slowest queries" section, and shows requests and SQL in the `--example`
+  drill-down.
+
 ## [0.5.0] - 2026-07-16
 
 ### Added
@@ -57,7 +74,8 @@
 
 First public release.
 
-[Unreleased]: https://github.com/takahashim/rspec_telemetry/compare/v0.5.0...HEAD
+[Unreleased]: https://github.com/takahashim/rspec_telemetry/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/takahashim/rspec_telemetry/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/takahashim/rspec_telemetry/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/takahashim/rspec_telemetry/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/takahashim/rspec_telemetry/compare/v0.2.0...v0.3.0

data/README.md

@@ -69,6 +69,10 @@ RSpecTelemetry.configure do |config|
   config.output_path = "tmp/rspec_telemetry.ndjson"
   config.capture_examples = true
   config.capture_factory_bot = true
+  config.capture_requests = true      # Rails request specs: process_action.action_controller
+  config.capture_sql = true           # sql.active_record, aggregated per example
+  config.capture_gc = true            # GC time / allocations per example, added to example.finished
+  config.slow_sql_threshold_ms = nil  # e.g. 50.0: also record individual sql.query events above this
   config.print_summary = false        # true: print a summary to stderr at the end
   config.flush_each = false           # true: flush after each event, useful for tail -f
   config.slow_factory_threshold_ms = nil
@@ -178,7 +182,9 @@ $ bundle exec rspec
 ```json
 {"type":"example.started","example_id":"./spec/models/user_spec.rb[1:1]", ...}
 {"type":"factory_bot.run_factory","example_id":"./spec/models/user_spec.rb[1:1]","factory":"user","strategy":"create","traits":["admin"],"overrides":["email"],"duration_ms":42.381,"self_duration_ms":30.12,"depth":0,"parent_factory":null}
-{"type":"example.finished","example_id":"./spec/models/user_spec.rb[1:1]","status":"passed","duration_ms":71.552}
+{"type":"action_controller.process_action","example_id":"./spec/requests/users_spec.rb[1:1]","controller":"UsersController","action":"show","http_method":"GET","format":"json","status":200,"duration_ms":210.5,"db_runtime_ms":85.2,"view_runtime_ms":60.1,"exception_class":null}
+{"type":"sql.group","example_id":"./spec/requests/users_spec.rb[1:1]","name":"User Load","count":42,"total_ms":118.3,"max_ms":12.1,"in_factory_count":30,"in_factory_ms":80.2,"cached_count":3}
+{"type":"example.finished","example_id":"./spec/models/user_spec.rb[1:1]","status":"passed","duration_ms":71.552,"gc_time_ms":4.2,"gc_count":3,"gc_major_count":0,"gc_minor_count":3,"allocated_objects":184023}
 ```
 
 ## Design notes
@@ -188,6 +194,26 @@ $ bundle exec rspec
 For FactoryBot overrides, `rspec_telemetry` records only the attribute names.
 It does not record the actual values, because they may contain personal information, secrets, or other sensitive data.
 
+For the same reason, request events record neither `path` nor `params`:
+query strings and parameter values may carry secrets, and `controller` + `action` already identify the endpoint.
+
+#### SQL is aggregated per example
+
+A single request spec example can fire thousands of queries, so writing one event per query
+would bloat the NDJSON file and slow the suite down. Instead, queries are grouped by their
+payload name (`"User Load"`, ...) and written as one `sql.group` event per (example, name) pair.
+Queries fired inside a factory are counted separately (`in_factory_count` / `in_factory_ms`),
+so factory-driven SQL can be told apart from the SQL your request actually runs.
+`SCHEMA`, `TRANSACTION` and nameless queries are skipped; cached queries are only counted.
+Set `slow_sql_threshold_ms` to also record individual `sql.query` events (SQL text truncated,
+bind values never included) for queries above the threshold.
+
+#### GC time is a trend indicator, not an exact per-example cost
+
+`example.finished` carries the GC time, GC counts and allocated object count measured across
+the example. GC time is process-global: an example may pay for garbage a previous example
+allocated, so use it to spot allocation-heavy areas rather than as an exact attribution.
+
 #### Nested factories and double counting
 
 FactoryBot associations can create other factories internally.

data/lib/rspec_telemetry/analyzer.rb

@@ -14,18 +14,37 @@ module RSpecTelemetry
       :duration_ms,
       :fb_self_total_ms,
       :fb_count,
+      :sql_total_ms,
+      :sql_count,
+      :gc_time_ms,
+      :allocated_objects,
       keyword_init: true
     )
 
     FileStat = Struct.new(:file_path, :example_count, :duration_ms, keyword_init: true)
 
+    QueryStat = Struct.new(:name, :count, :total_ms, :max_ms, :in_factory_ms, keyword_init: true) do
+      def avg_ms
+        count.to_i.zero? ? 0.0 : total_ms / count
+      end
+    end
+
     attr_reader(
       :examples,
       :files,
       :example_count,
       :failure_count,
       :pending_count,
-      :suite_duration_ms
+      :suite_duration_ms,
+      :request_count,
+      :total_request_ms,
+      :total_db_ms,
+      :total_view_ms,
+      :sql_query_count,
+      :total_sql_ms,
+      :total_sql_in_factory_ms,
+      :total_gc_ms,
+      :total_allocated_objects
     )
 
     def initialize
@@ -34,10 +53,21 @@ module RSpecTelemetry
       @files = {}
       # Factory events arrive before example.finished, so merge them after loading.
       @example_fb = Hash.new { |h, k| h[k] = [0.0, 0] }
+      @example_sql = Hash.new { |h, k| h[k] = [0.0, 0] }
+      @queries = {}
       @example_count = 0
       @failure_count = 0
       @pending_count = 0
       @suite_duration_ms = 0.0
+      @request_count = 0
+      @total_request_ms = 0.0
+      @total_db_ms = 0.0
+      @total_view_ms = 0.0
+      @sql_query_count = 0
+      @total_sql_ms = 0.0
+      @total_sql_in_factory_ms = 0.0
+      @total_gc_ms = 0.0
+      @total_allocated_objects = 0
     end
 
     def self.load(paths)
@@ -57,6 +87,10 @@ module RSpecTelemetry
         add_example(event)
       when "factory_bot.run_factory"
         add_factory(event)
+      when "action_controller.process_action"
+        add_request(event)
+      when "sql.group"
+        add_sql_group(event)
       when "suite.finished"
         add_suite(event)
       end
@@ -89,6 +123,9 @@ module RSpecTelemetry
         self_total, count = @example_fb[ex.example_id]
         ex.fb_self_total_ms = self_total
         ex.fb_count = count
+        sql_total, sql_count = @example_sql[ex.example_id]
+        ex.sql_total_ms = sql_total
+        ex.sql_count = sql_count
         ex
       end
     end
@@ -97,6 +134,10 @@ module RSpecTelemetry
       @factory_acc.top(limit)
     end
 
+    def top_queries(limit = 20)
+      @queries.values.sort_by { |q| -q.total_ms }.first(limit)
+    end
+
     def slow_files(limit = 20)
       @files.values.sort_by { |f| -f.duration_ms.to_f }.first(limit)
     end
@@ -131,6 +172,12 @@ module RSpecTelemetry
       ))
       ex.duration_ms = event["duration_ms"]
       ex.status = event["status"]
+      if event.key?("gc_time_ms")
+        ex.gc_time_ms = event["gc_time_ms"].to_f
+        ex.allocated_objects = event["allocated_objects"].to_i
+        @total_gc_ms += ex.gc_time_ms
+        @total_allocated_objects += ex.allocated_objects
+      end
       ex.file_path ||= event["file_path"]
       ex.line_number ||= event["line_number"]
       ex.full_description ||= event["full_description"]
@@ -160,6 +207,36 @@ module RSpecTelemetry
       acc[1] += 1
     end
 
+    def add_request(event)
+      @request_count += 1
+      @total_request_ms += event["duration_ms"].to_f
+      @total_db_ms += event["db_runtime_ms"].to_f
+      @total_view_ms += event["view_runtime_ms"].to_f
+    end
+
+    def add_sql_group(event)
+      count = event["count"].to_i
+      total = event["total_ms"].to_f
+      max = event["max_ms"].to_f
+      @sql_query_count += count
+      @total_sql_ms += total
+      @total_sql_in_factory_ms += event["in_factory_ms"].to_f
+
+      name = event["name"] || "SQL"
+      q = (@queries[name] ||= QueryStat.new(name: name, count: 0, total_ms: 0.0, max_ms: 0.0, in_factory_ms: 0.0))
+      q.count += count
+      q.total_ms += total
+      q.max_ms = max if max > q.max_ms
+      q.in_factory_ms += event["in_factory_ms"].to_f
+
+      id = event["example_id"]
+      return unless id
+
+      acc = @example_sql[id]
+      acc[0] += total
+      acc[1] += count
+    end
+
     def add_suite(event)
       @example_count += event["example_count"].to_i
       @failure_count += event["failure_count"].to_i

data/lib/rspec_telemetry/config.rb

@@ -7,6 +7,10 @@ module RSpecTelemetry
       :output_path,
       :capture_examples,
       :capture_factory_bot,
+      :capture_requests,
+      :capture_sql,
+      :capture_gc,
+      :slow_sql_threshold_ms,
       :print_summary,
       :flush_each,
       :slow_factory_threshold_ms,
@@ -20,6 +24,10 @@ module RSpecTelemetry
       @output_path = self.class.default_output_path
       @capture_examples = true
       @capture_factory_bot = true
+      @capture_requests = true
+      @capture_sql = true
+      @capture_gc = true
+      @slow_sql_threshold_ms = nil
       @print_summary = false
       @flush_each = false
       @slow_factory_threshold_ms = nil

data/lib/rspec_telemetry/console_report.rb

@@ -13,6 +13,10 @@ module RSpecTelemetry
 
       def truncate(str, len) = str.length > len ? "#{str[0, len - 1]}…" : str
 
+      def objects(count)
+        count >= 1_000_000 ? format("%.1fM", count / 1_000_000.0) : count.to_s
+      end
+
       def section(title) = ["", title, "-" * title.length]
     end
 
@@ -25,7 +29,7 @@ module RSpecTelemetry
     end
 
     def render
-      lines = overview + slow_files + slow_examples + top_factories
+      lines = overview + slow_files + slow_examples + top_factories + top_queries
       lines << ""
       lines << "Tip: drill into one example with `rspec-telemetry --example \"<example_id>\"`"
       lines.join("\n")
@@ -37,6 +41,38 @@ module RSpecTelemetry
       if finished
         lines << "  #{finished["full_description"]}"
         lines << "  status: #{finished["status"]}   duration: #{Helpers.fmt(finished["duration_ms"])}"
+        if finished["gc_time_ms"]
+          lines << "  gc: #{Helpers.fmt(finished["gc_time_ms"])} " \
+                   "(#{finished["gc_major_count"]} major / #{finished["gc_minor_count"]} minor, " \
+                   "#{Helpers.objects(finished["allocated_objects"].to_i)} objects allocated)"
+        end
+      end
+
+      requests = events.select { |e| e["type"] == "action_controller.process_action" }
+      unless requests.empty?
+        lines << ""
+        lines << "  Requests:"
+        requests.each { |r| lines << request_line(r) }
+      end
+
+      sql_groups = events.select { |e| e["type"] == "sql.group" }
+      unless sql_groups.empty?
+        lines << ""
+        lines << "  SQL (grouped by name):"
+        sql_groups.sort_by { |g| -g["total_ms"].to_f }.each { |g| lines << sql_group_line(g) }
+        total = sql_groups.sum { |g| g["total_ms"].to_f }
+        count = sql_groups.sum { |g| g["count"].to_i }
+        lines << "    sql total: #{Helpers.fmt(total)} across #{count} queries"
+      end
+
+      slow_queries = events.select { |e| e["type"] == "sql.query" }
+      unless slow_queries.empty?
+        lines << ""
+        lines << "  Slow queries:"
+        slow_queries.each do |q|
+          lines << "    #{Helpers.fmt(q["duration_ms"])}  #{q["name"]}#{q["in_factory"] ? "  (in factory)" : ""}"
+          lines << "      #{q["sql"]}"
+        end
       end
 
       factories = events.select { |e| e["type"] == "factory_bot.run_factory" }
@@ -51,6 +87,31 @@ module RSpecTelemetry
       lines.join("\n")
     end
 
+    def self.sql_group_line(fields)
+      in_factory = fields["in_factory_count"].to_i
+      factory_note = in_factory.positive? ? "  (in factories: #{Helpers.fmt(fields["in_factory_ms"])} / #{in_factory})" : ""
+      format(
+        "    %-32s count %4d   total %9s   max %9s%s",
+        Helpers.truncate(fields["name"].to_s, 32),
+        fields["count"].to_i,
+        Helpers.fmt(fields["total_ms"]),
+        Helpers.fmt(fields["max_ms"]),
+        factory_note
+      )
+    end
+
+    def self.request_line(fields)
+      db = fields["db_runtime_ms"]
+      view = fields["view_runtime_ms"]
+      breakdown = [
+        db ? "db #{Helpers.fmt(db)}" : nil,
+        view ? "view #{Helpers.fmt(view)}" : nil
+      ].compact.join(", ")
+      breakdown = "  (#{breakdown})" unless breakdown.empty?
+      "    #{fields["http_method"]} #{fields["controller"]}##{fields["action"]}  " \
+        "status #{fields["status"]}  #{Helpers.fmt(fields["duration_ms"])}#{breakdown}"
+    end
+
     def self.factory_line(fields)
       indent = "    " + ("  " * fields["depth"].to_i)
       traits = Array(fields["traits"]).empty? ? "" : " [#{fields["traits"].join(",")}]"
@@ -63,7 +124,7 @@ module RSpecTelemetry
 
     def overview
       a = @analyzer
-      section("Overview") +
+      lines = section("Overview") +
         [
           "  files analyzed:        #{@files_count}",
           "  examples:              #{a.example_count} (#{a.failure_count} failed, #{a.pending_count} pending)",
@@ -71,6 +132,21 @@ module RSpecTelemetry
           "  example time (sum):    #{fmt(a.total_example_ms)}",
           "  factory self time:     #{fmt(a.total_factory_self_ms)} (#{pct(a.factory_time_ratio)} of example time)"
         ]
+      if a.request_count.positive?
+        lines << "  request time (sum):    #{fmt(a.total_request_ms)} across #{a.request_count} requests " \
+                 "(db: #{fmt(a.total_db_ms)}, view: #{fmt(a.total_view_ms)})"
+      end
+      if a.sql_query_count.positive?
+        lines << "  sql time (sum):        #{fmt(a.total_sql_ms)} across #{a.sql_query_count} queries " \
+                 "(in factories: #{fmt(a.total_sql_in_factory_ms)}, " \
+                 "elsewhere: #{fmt(a.total_sql_ms - a.total_sql_in_factory_ms)})"
+      end
+      if a.total_gc_ms.positive?
+        ratio = a.total_example_ms.zero? ? 0.0 : a.total_gc_ms / a.total_example_ms
+        lines << "  gc time (sum):         #{fmt(a.total_gc_ms)} (#{pct(ratio)} of example time, " \
+                 "#{objects(a.total_allocated_objects)} objects allocated)"
+      end
+      lines
     end
 
     def slow_files
@@ -90,8 +166,34 @@ module RSpecTelemetry
       lines = section("Slowest examples")
       rows.each_with_index do |e, i|
         fb = e.fb_count.to_i.positive? ? "  [factories: #{fmt(e.fb_self_total_ms)} / #{e.fb_count} calls]" : ""
+        sql = e.sql_count.to_i.positive? ? "  [sql: #{fmt(e.sql_total_ms)} / #{e.sql_count} queries]" : ""
+        gc = e.gc_time_ms.to_f.positive? ? "  [gc: #{fmt(e.gc_time_ms)}]" : ""
         lines << format("  %2d. %-9s %s", i + 1, fmt(e.duration_ms), e.example_id)
-        lines << "        #{e.full_description}#{fb}" if e.full_description || !fb.empty?
+        annotations = "#{fb}#{sql}#{gc}"
+        lines << "        #{e.full_description}#{annotations}" if e.full_description || !annotations.empty?
+      end
+
+      lines
+    end
+
+    def top_queries
+      rows = @analyzer.top_queries(@top)
+      return [] if rows.empty?
+
+      lines = section("Slowest queries (grouped by name, cached queries excluded)")
+      lines << format("      %-28s %8s %10s %9s %9s %12s", "query", "count", "total", "avg", "max", "in factories")
+      rows.each_with_index do |q, i|
+        lines <<
+          format(
+            "  %2d. %-28s %8d %10s %9s %9s %12s",
+            i + 1,
+            truncate(q.name, 28),
+            q.count,
+            fmt(q.total_ms),
+            fmt(q.avg_ms),
+            fmt(q.max_ms),
+            fmt(q.in_factory_ms)
+          )
       end
 
       lines

data/lib/rspec_telemetry/formatter.rb

@@ -3,6 +3,8 @@
 require "rspec/core"
 require "rspec/core/formatters/base_formatter"
 
+require_relative "gc_sample"
+
 module RSpecTelemetry
   class Formatter < RSpec::Core::Formatters::BaseFormatter
     RSpec::Core::Formatters.register(
@@ -23,6 +25,7 @@ module RSpecTelemetry
         example = notification.example
         # Runs before before(:each), so FactoryBot calls inside hooks get this example_id.
         recorder.set_current_example(example.id)
+        @gc_before = config.capture_gc ? GcSample.take : nil
         next unless config.capture_examples
 
         recorder.record(
@@ -37,6 +40,9 @@ module RSpecTelemetry
     def example_finished(notification)
       RSpecTelemetry.safely("formatter#example_finished") do
         example = notification.example
+        # Flush per-example aggregates (sql.group) before example.finished so
+        # they land inside the example's event block, like factory events do.
+        RSpecTelemetry.flush_example_events!
         record_example_finished(example) if config.capture_examples
         recorder.flush
       ensure
@@ -68,8 +74,7 @@ module RSpecTelemetry
       result = example.execution_result
       exception = result.exception
 
-      recorder.record(
-        "example.finished",
+      fields = {
         file_path: example.file_path,
         line_number: example.metadata[:line_number],
         full_description: example.full_description,
@@ -77,7 +82,14 @@ module RSpecTelemetry
         duration_ms: (result.run_time.to_f * 1000.0).round(3),
         exception_class: exception&.class&.name,
         exception_message: exception&.message
-      )
+      }
+      if config.capture_gc
+        gc = GcSample.delta(@gc_before, GcSample.take)
+        fields.merge!(gc) if gc
+        @gc_before = nil
+      end
+
+      recorder.record("example.finished", fields)
     end
 
     def recorder

data/lib/rspec_telemetry/gc_sample.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RSpecTelemetry
+  # Snapshots GC counters around an example so example.finished can carry the
+  # GC cost of that example. GC time is process-global: an example may pay for
+  # garbage a previous example allocated, so treat the attribution as a trend
+  # indicator, not an exact per-example cost.
+  module GcSample
+    module_function
+
+    def take
+      stat = GC.stat
+      {
+        total_time_ns: GC.total_time,
+        count: stat[:count],
+        major: stat[:major_gc_count],
+        minor: stat[:minor_gc_count],
+        allocated: stat[:total_allocated_objects]
+      }
+    end
+
+    def delta(before, after)
+      return nil unless before && after
+
+      {
+        gc_time_ms: ((after[:total_time_ns] - before[:total_time_ns]) / 1_000_000.0).round(3),
+        gc_count: after[:count] - before[:count],
+        gc_major_count: after[:major] - before[:major],
+        gc_minor_count: after[:minor] - before[:minor],
+        allocated_objects: after[:allocated] - before[:allocated]
+      }
+    end
+  end
+end

data/lib/rspec_telemetry/subscribers/action_controller.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# isolated_execution_state only exists on Rails 7+; ActiveSupport::Notifications
+# works without it, so make it optional to support Rails 6.x (and earlier).
+begin
+  require "active_support/isolated_execution_state"
+rescue LoadError
+  nil
+end
+require "active_support/notifications"
+
+module RSpecTelemetry
+  module Subscribers
+    class ActionController
+      STACK_KEY = :rspec_telemetry_ac_stack
+
+      def initialize(recorder)
+        @recorder = recorder
+        @subscription = nil
+      end
+
+      def subscribe
+        @subscription = ActiveSupport::Notifications.subscribe("process_action.action_controller", self)
+      end
+
+      def unsubscribe
+        ActiveSupport::Notifications.unsubscribe(@subscription) if @subscription
+        @subscription = nil
+      end
+
+      def start(_name, _id, _payload)
+        RSpecTelemetry.safely("action_controller#start") do
+          stack.push(Process.clock_gettime(Process::CLOCK_MONOTONIC))
+        end
+      end
+
+      def finish(_name, _id, payload)
+        RSpecTelemetry.safely("action_controller#finish") do
+          started = stack.pop
+          next unless started
+          next unless @recorder.config.enabled && @recorder.config.capture_requests
+
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          # Deliberately no :path / :params: query strings and parameter values may
+          # carry secrets, and controller#action already identifies the endpoint.
+          @recorder.record(
+            "action_controller.process_action",
+            controller: payload[:controller],
+            action: payload[:action],
+            http_method: payload[:method],
+            format: payload[:format].to_s,
+            status: payload[:status],
+            duration_ms: ((now - started) * 1000.0).round(3),
+            db_runtime_ms: runtime_ms(payload[:db_runtime]),
+            view_runtime_ms: runtime_ms(payload[:view_runtime]),
+            exception_class: Array(payload[:exception]).first
+          )
+        end
+      end
+
+      private
+
+      def runtime_ms(value)
+        value.nil? ? nil : value.to_f.round(3)
+      end
+
+      def stack
+        Thread.current[STACK_KEY] ||= []
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/subscribers/sql.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+# isolated_execution_state only exists on Rails 7+; ActiveSupport::Notifications
+# works without it, so make it optional to support Rails 6.x (and earlier).
+begin
+  require "active_support/isolated_execution_state"
+rescue LoadError
+  nil
+end
+require "active_support/notifications"
+
+require_relative "../recorder"
+
+module RSpecTelemetry
+  module Subscribers
+    # Aggregates sql.active_record per example instead of writing one event per
+    # query: a request spec can fire thousands of queries per example, which
+    # would bloat the NDJSON file and slow the suite down. Queries are grouped
+    # by payload name ("Merchant Load", ...) and flushed as one sql.group event
+    # per (example, name) when the lifecycle calls #example_finished.
+    class Sql
+      STACK_KEY = :rspec_telemetry_sql_stack
+      # Mirrors Subscribers::FactoryBot::STACK_KEY without forcing that file to
+      # load; a non-empty stack means this query runs inside a factory.
+      FB_STACK_KEY = :rspec_telemetry_fb_stack
+
+      # SCHEMA is Rails introspection noise; TRANSACTION (BEGIN/COMMIT) mostly
+      # measures the test's own transaction wrapping. Nameless queries (raw
+      # #execute, and BEGIN/COMMIT on Rails < 7.1) are skipped too, because they
+      # cannot be told apart from transaction management reliably.
+      SKIP_NAMES = %w[SCHEMA TRANSACTION].freeze
+
+      SQL_TRUNCATE = 500
+
+      def initialize(recorder)
+        @recorder = recorder
+        @subscription = nil
+        # Queries can arrive from threads other than the example's (e.g. a
+        # Capybara app server), so buckets are shared and keyed by example_id.
+        @mutex = Mutex.new
+        @buckets = {}
+      end
+
+      def subscribe
+        @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", self)
+      end
+
+      def unsubscribe
+        ActiveSupport::Notifications.unsubscribe(@subscription) if @subscription
+        @subscription = nil
+      end
+
+      def start(_name, _id, _payload)
+        RSpecTelemetry.safely("sql#start") do
+          stack.push(Process.clock_gettime(Process::CLOCK_MONOTONIC))
+        end
+      end
+
+      def finish(_name, _id, payload)
+        RSpecTelemetry.safely("sql#finish") do
+          started = stack.pop
+          next unless started
+
+          config = @recorder.config
+          next unless config.enabled && config.capture_sql
+
+          name = payload[:name]
+          next if name.nil? || SKIP_NAMES.include?(name)
+
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          ms = (now - started) * 1000.0
+          cached = payload[:cached] ? true : false
+          fb_stack = Thread.current[FB_STACK_KEY]
+          in_factory = fb_stack && !fb_stack.empty?
+
+          accumulate(name, ms, cached: cached, in_factory: in_factory)
+          record_slow_query(name, ms, payload, in_factory) unless cached
+        end
+      end
+
+      # Called by the lifecycle at example end, while the example id is still
+      # set, so the flushed sql.group events attach to the right example.
+      def example_finished
+        RSpecTelemetry.safely("sql#example_finished") do
+          example_id = Thread.current[Recorder::EXAMPLE_ID]
+          groups = @mutex.synchronize { @buckets.delete(example_id) }
+          next unless groups
+
+          groups.each do |name, g|
+            @recorder.record(
+              "sql.group",
+              name: name,
+              count: g[:count],
+              total_ms: g[:total_ms].round(3),
+              max_ms: g[:max_ms].round(3),
+              in_factory_count: g[:in_factory_count],
+              in_factory_ms: g[:in_factory_ms].round(3),
+              cached_count: g[:cached_count]
+            )
+          end
+        end
+      end
+
+      private
+
+      def accumulate(name, ms, cached:, in_factory:)
+        example_id = Thread.current[Recorder::EXAMPLE_ID]
+        @mutex.synchronize do
+          groups = (@buckets[example_id] ||= {})
+          g = (groups[name] ||= {
+            count: 0, total_ms: 0.0, max_ms: 0.0,
+            in_factory_count: 0, in_factory_ms: 0.0, cached_count: 0
+          })
+          if cached
+            g[:cached_count] += 1
+            next
+          end
+
+          g[:count] += 1
+          g[:total_ms] += ms
+          g[:max_ms] = ms if ms > g[:max_ms]
+          next unless in_factory
+
+          g[:in_factory_count] += 1
+          g[:in_factory_ms] += ms
+        end
+      end
+
+      def record_slow_query(name, ms, payload, in_factory)
+        threshold = @recorder.config.slow_sql_threshold_ms
+        return unless threshold && ms >= threshold
+
+        @recorder.record(
+          "sql.query",
+          name: name,
+          duration_ms: ms.round(3),
+          sql: payload[:sql].to_s[0, SQL_TRUNCATE],
+          in_factory: in_factory
+        )
+      end
+
+      def stack
+        Thread.current[STACK_KEY] ||= []
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RSpecTelemetry
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/rspec_telemetry.rb

@@ -42,6 +42,12 @@ module RSpecTelemetry
       unsubscribe!
     end
 
+    # Lets subscribers that aggregate per example (e.g. SQL) flush their events
+    # while the example id is still set on the recorder.
+    def flush_example_events!
+      @subscribers&.each { |s| s.example_finished if s.respond_to?(:example_finished) }
+    end
+
     def reset!
       unsubscribe!
       @config = nil
@@ -71,30 +77,33 @@ module RSpecTelemetry
     end
 
     def subscribe!
-      return unless config.capture_factory_bot
-      return if @factory_bot_subscriber
+      return if @subscribers
 
-      subscriber = build_factory_bot_subscriber
-      return unless subscriber
+      subscribers = []
+      subscribers << build_subscriber("factory_bot", :FactoryBot) if config.capture_factory_bot
+      subscribers << build_subscriber("action_controller", :ActionController) if config.capture_requests
+      subscribers << build_subscriber("sql", :Sql) if config.capture_sql
+      subscribers.compact!
+      return if subscribers.empty?
 
-      @factory_bot_subscriber = subscriber
-      @factory_bot_subscriber.subscribe
+      @subscribers = subscribers
+      @subscribers.each(&:subscribe)
     end
 
-    # activesupport is an optional dependency: it is only needed for FactoryBot
-    # tracking, which relies on ActiveSupport::Notifications. FactoryBot itself
-    # pulls in activesupport, so when it is absent there are no factory events to
-    # capture and we silently skip the subscription.
-    def build_factory_bot_subscriber
-      require_relative "rspec_telemetry/subscribers/factory_bot"
-      Subscribers::FactoryBot.new(recorder)
+    # activesupport is an optional dependency: subscribers rely on
+    # ActiveSupport::Notifications, which the instrumented libraries (FactoryBot,
+    # Rails) pull in themselves. When it is absent there are no events to capture
+    # and we silently skip the subscription.
+    def build_subscriber(file, const)
+      require_relative "rspec_telemetry/subscribers/#{file}"
+      Subscribers.const_get(const).new(recorder)
     rescue LoadError
       nil
     end
 
     def unsubscribe!
-      @factory_bot_subscriber&.unsubscribe
-      @factory_bot_subscriber = nil
+      @subscribers&.each(&:unsubscribe)
+      @subscribers = nil
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec_telemetry
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - takahashimm
@@ -37,7 +37,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.4'
-description: Collect RSpec / FactoryBot telemetry as NDJSON to find slow tests.
+description: 'Collect RSpec telemetry as NDJSON to find slow tests: FactoryBot calls,
+  Rails requests, SQL time and GC cost, broken down per example.'
 email:
 - takahashimm@gmail.com
 executables:
@@ -64,9 +65,12 @@ files:
 - lib/rspec_telemetry/factory_comparison.rb
 - lib/rspec_telemetry/formatter.rb
 - lib/rspec_telemetry/formatting.rb
+- lib/rspec_telemetry/gc_sample.rb
 - lib/rspec_telemetry/ndjson.rb
 - lib/rspec_telemetry/recorder.rb
+- lib/rspec_telemetry/subscribers/action_controller.rb
 - lib/rspec_telemetry/subscribers/factory_bot.rb
+- lib/rspec_telemetry/subscribers/sql.rb
 - lib/rspec_telemetry/summary.rb
 - lib/rspec_telemetry/trace/viewer.rb
 - lib/rspec_telemetry/trace/viewer/app.rb
@@ -102,7 +106,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/takahashim/rspec_telemetry
   source_code_uri: https://github.com/takahashim/rspec_telemetry
-  changelog_uri: https://github.com/takahashim/rspec_telemetry
+  changelog_uri: https://github.com/takahashim/rspec_telemetry/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -119,5 +123,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Collect RSpec / FactoryBot telemetry as NDJSON to find slow tests.
+summary: Collect RSpec telemetry as NDJSON to find slow tests.
 test_files: []