test-prof 1.5.2 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 794f7efe13d07689e57f27d14a50a6ac0dc1e01de5b52641a94b6b8fbc6f4f8e
-  data.tar.gz: 5258154393ae1e875df4ff416beb1155666d350a9cdb0c2e63f37b05d4879470
+  metadata.gz: b843db2a99bf53e8c380e748bb73340c573e1de8082f76519530eb0ddf32cb95
+  data.tar.gz: 94048d78eaf4857b0a869fad4d551701b0501074cb97ff9ac9ad13a5b69eee03
 SHA512:
-  metadata.gz: 1fc69db1c6064900b34fa0da7319ea48926d6d6f187059c7a63786370150e9e2b6c97f409c16afa7919f2e9e32652d6ba242624608c5b0f082e5a6b4721a2de7
-  data.tar.gz: cd24bd5a9fd594953a054a85cbc85ece2b2e36d0523ce9bd3f75b8840384a54cf1f92cfd6697951f84cb9d47073e7d39d6504325ee48ec7871bed00609a39167
+  metadata.gz: 5718228b4b63106230f730ef7ee2e1ed53de8457c266f82859a2824b7f9967ba30d0d26d2ee9e4fb1f6363e04eb6a790560e98d529d7e630d93f7dd9dd2dc990
+  data.tar.gz: b6df0f87115a3cfd159b1a132459a7958c204374e9b76a8f0c7282158fe6fe6a11a208a5e60f111d98f89c212d215c8cf6db1087c071257a92a7377f999cae0c

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## master (unreleased)
 
+## 1.6.0 (2026-03-18)
+
+- Add TPS profiler. ([@palkan][])
+
+- Add GC profiling to MemoryProf. ([@palkan][])
+
+- Upgrade to Sidekiq 8. ([@palkan][])
+
+- RSpecStamp now uses Prism if available. ([@kddnewton][])
+
+- Upgrade RSpecDissect to show total setup time and let breakdowns. ([@palkan][])
+
 ## 1.5.2 (2026-02-03)
 
 - Avoid using `Gem.loaded_specs` methods in RuboCop plugin version check. ([@Rylan12][])
@@ -489,3 +501,4 @@ See [changelog](https://github.com/test-prof/test-prof/blob/v0.8.0/CHANGELOG.md)
 [@devinburnette]: https://github.com/devinburnette
 [@elasticspoon]: https://github.com/elasticspoon
 [@Rylan12]: https://github.com/Rylan12
+[@kddnewton]: https://github.com/kddnewton

data/lib/test_prof/event_prof/custom_events/sidekiq_inline.rb

@@ -2,7 +2,7 @@
 
 TestProf::EventProf::CustomEvents.register("sidekiq.inline") do
   if TestProf.require(
-    "sidekiq/testing",
+    "sidekiq",
     <<~MSG
       Failed to load Sidekiq.
 

data/lib/test_prof/event_prof/custom_events/sidekiq_jobs.rb

@@ -2,7 +2,7 @@
 
 TestProf::EventProf::CustomEvents.register("sidekiq.jobs") do
   if TestProf.require(
-    "sidekiq/testing",
+    "sidekiq",
     <<~MSG
       Failed to load Sidekiq.
 

data/lib/test_prof/memory_prof/printer.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "test_prof/ext/float_duration"
 require "test_prof/memory_prof/printer/number_to_human"
 require "test_prof/ext/string_truncate"
 
@@ -92,5 +93,35 @@ module TestProf
         number_to_human(item[:memory])
       end
     end
+
+    class GCPrinter < Printer
+      using StringTruncate
+      using FloatDuration
+
+      private
+
+      def mode
+        "GC time"
+      end
+
+      def print_total
+        "Total GC time: #{(GC.total_time.to_f / 1_000_000_000).duration}\n\n"
+      end
+
+      def print_items(items)
+        messages =
+          items.map do |item|
+            <<~ITEM
+              #{item[:name].truncate(30)} (#{item[:location]}) – #{gc_time(item)}
+            ITEM
+          end
+
+        messages.join
+      end
+
+      def gc_time(item)
+        (item[:memory].to_f / 1_000_000_000).duration
+      end
+    end
   end
 end

data/lib/test_prof/memory_prof/rspec.rb

@@ -31,10 +31,12 @@ module TestProf
       end
 
       def example_group_started(notification)
+        return unless notification.group.top_level?
         tracker.group_started(notification.group, group(notification))
       end
 
       def example_group_finished(notification)
+        return unless notification.group.top_level?
         tracker.group_finished(notification.group)
       end
 

data/lib/test_prof/memory_prof/tracker.rb

@@ -55,7 +55,7 @@ module TestProf
         node = list.remove_node(id, track)
         return unless node
 
-        groups << {**node.item, memory: node.hooks_memory}
+        groups << {**node.item, memory: node.total_memory}
       end
     end
 
@@ -84,5 +84,15 @@ module TestProf
         !!@rss_tool
       end
     end
+
+    class GCTracker < Tracker
+      def track
+        ::GC.total_time
+      end
+
+      def supported?
+        ::GC.respond_to?(:total_time)
+      end
+    end
   end
 end

data/lib/test_prof/memory_prof.rb

@@ -11,6 +11,7 @@ module TestProf
   #
   #   TEST_MEM_PROF='rss' rspec ...
   #   TEST_MEM_PROF='alloc' rspec ...
+  #   TEST_MEM_PROF='gc' rspec ...
   #
   # By default MemoryProf shows the top 5 examples and groups (for RSpec) but you can
   # set how many items to display with `TEST_MEM_PROF_COUNT`:
@@ -25,6 +26,8 @@ module TestProf
   module MemoryProf
     # MemoryProf configuration
     class Configuration
+      MODES = %w[alloc rss gc].freeze
+
       attr_reader :mode, :top_count
 
       def initialize
@@ -33,7 +36,7 @@ module TestProf
       end
 
       def mode=(value)
-        @mode = (value == "alloc") ? :alloc : :rss
+        @mode = MODES.include?(value) ? value.to_sym : :rss
       end
 
       def top_count=(value)
@@ -45,12 +48,14 @@ module TestProf
     class << self
       TRACKERS = {
         alloc: AllocTracker,
-        rss: RssTracker
+        rss: RssTracker,
+        gc: GCTracker
       }.freeze
 
       PRINTERS = {
         alloc: AllocPrinter,
-        rss: RssPrinter
+        rss: RssPrinter,
+        gc: GCPrinter
       }.freeze
 
       def config

data/lib/test_prof/rspec_dissect/collector.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "test_prof/utils/sized_ordered_set"
+require "test_prof/ext/float_duration"
+require "test_prof/ext/string_truncate"
+
+module TestProf # :nodoc: all
+  using FloatDuration
+  using StringTruncate
+
+  module RSpecDissect
+    class Collector
+      attr_reader :results, :name, :top_count
+
+      def initialize(top_count:)
+        @top_count = top_count
+        @results = Utils::SizedOrderedSet.new(
+          top_count, sort_by: :total_setup
+        )
+      end
+
+      def <<(data)
+        results << data
+      end
+
+      def print_result_header
+        <<~MSG
+
+          Top #{top_count} slowest suites by setup time:
+
+        MSG
+      end
+
+      def print_group_result(group)
+        "#{group[:desc].truncate} (#{group[:loc]}) – \e[1m#{group[:total_setup].duration}\e[22m " \
+        "of #{group[:total].duration} / #{group[:count]} " \
+        "(before: #{(group[:total_setup] - group[:total_lazy_let]).duration}, " \
+        "before let: #{group[:total_before_let].duration}, " \
+        "lazy let: #{group[:total_lazy_let].duration})"
+      end
+
+      def print_results
+        msgs = [print_result_header]
+
+        results.each do |group|
+          msgs << print_group_result(group)
+          msgs << "\n" if group[:top_lets].any?
+          group[:top_lets].each do |let|
+            msgs << " ↳ #{let[:name]} – #{let[:duration].duration} (#{let[:size]})\n"
+          end
+          msgs << "\n"
+        end
+
+        msgs.join
+      end
+    end
+  end
+end

data/lib/test_prof/rspec_dissect/rspec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "test_prof/rspec_dissect/collector"
+
 require "test_prof/ext/float_duration"
 
 module TestProf
@@ -15,19 +17,12 @@ module TestProf
       ].freeze
 
       def initialize
-        @collectors = []
-
-        if RSpecDissect.config.let?
-          collectors << Collectors::Let.new(top_count: RSpecDissect.config.top_count)
-        end
-
-        if RSpecDissect.config.before?
-          collectors << Collectors::Before.new(top_count: RSpecDissect.config.top_count)
-        end
+        @collector = Collector.new(top_count: top_count)
 
         @examples_count = 0
         @examples_time = 0.0
         @total_examples_time = 0.0
+        @total_setup_time = 0.0
       end
 
       def example_finished(notification)
@@ -44,9 +39,11 @@ module TestProf
         data[:desc] = notification.group.top_level_description
         data[:loc] = notification.group.metadata[:location]
 
-        collectors.each { |c| c.populate!(data) }
-        collectors.each { |c| c << data }
+        RSpecDissect.populate_from_spans!(data)
 
+        collector << data
+
+        @total_setup_time += data[:total_setup]
         @total_examples_time += @examples_time
         @examples_count = 0
         @examples_time = 0.0
@@ -62,17 +59,12 @@ module TestProf
             RSpecDissect report
 
             Total time: #{@total_examples_time.duration}
+            Total setup time: #{@total_setup_time.duration}
           MSG
 
-        collectors.each do |c|
-          msgs << c.total_time_message
-        end
-
         msgs << "\n"
 
-        collectors.each do |c|
-          msgs << c.print_results
-        end
+        msgs << collector.print_results
 
         log :info, msgs.join
 
@@ -84,9 +76,9 @@ module TestProf
 
         examples = Hash.new { |h, k| h[k] = [] }
 
-        all_results = collectors.inject([]) { |acc, c| acc + c.results.to_a }
+        results = collector.results.to_a
 
-        all_results
+        results
           .map { |obj| obj[:loc] }.each do |location|
           file, line = location.split(":")
           examples[file] << line.to_i
@@ -114,7 +106,7 @@ module TestProf
 
       private
 
-      attr_reader :collectors
+      attr_reader :collector
 
       def top_count
         RSpecDissect.config.top_count

data/lib/test_prof/rspec_dissect.rb

@@ -7,6 +7,9 @@ module TestProf
   # RSpecDissect tracks how much time do you spend in `before` hooks
   # and memoization helpers (i.e. `let`) in your tests.
   module RSpecDissect
+    class Span < Struct.new(:id, :parent_id, :type, :duration, :meta)
+    end
+
     module ExampleInstrumentation # :nodoc:
       def run_before_example(*)
         RSpecDissect.track(:before) { super }
@@ -15,12 +18,15 @@ module TestProf
 
     module MemoizedInstrumentation # :nodoc:
       def fetch_or_store(id, *)
+        return super if id == :subject
+        return @memoized[id] if @memoized[id]
+
         res = nil
         Thread.current[:_rspec_dissect_let_depth] ||= 0
         Thread.current[:_rspec_dissect_let_depth] += 1
         begin
           res = if Thread.current[:_rspec_dissect_let_depth] == 1
-            RSpecDissect.track(:let, id) { super }
+            RSpecDissect.track(:let, name: id) { super }
           else
             super
           end
@@ -33,45 +39,25 @@ module TestProf
 
     # RSpecDisect configuration
     class Configuration
-      MODES = %w[all let before].freeze
-
       attr_accessor :top_count, :let_stats_enabled,
         :let_top_count
 
       alias_method :let_stats_enabled?, :let_stats_enabled
 
-      attr_reader :mode
-
       def initialize
         @let_stats_enabled = true
         @let_top_count = (ENV["RD_PROF_LET_TOP"] || 3).to_i
         @top_count = (ENV["RD_PROF_TOP"] || 5).to_i
         @stamp = ENV["RD_PROF_STAMP"]
-        @mode = (ENV["RD_PROF"] == "1") ? "all" : ENV["RD_PROF"]
-
-        unless MODES.include?(mode)
-          raise "Unknown RSpecDissect mode: #{mode};" \
-                "available modes: #{MODES.join(", ")}"
-        end
 
         RSpecStamp.config.tags = @stamp if stamp?
       end
 
-      def let?
-        mode == "all" || mode == "let"
-      end
-
-      def before?
-        mode == "all" || mode == "before"
-      end
-
       def stamp?
         !@stamp.nil?
       end
     end
 
-    METRICS = %w[before let].freeze
-
     class << self
       include Logging
 
@@ -89,56 +75,64 @@ module TestProf
         RSpec::Core::MemoizedHelpers::ThreadsafeMemoized.prepend(MemoizedInstrumentation)
         RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized.prepend(MemoizedInstrumentation)
 
-        @data = {}
-
-        METRICS.each do |type|
-          @data["total_#{type}"] = 0.0
-        end
-
         reset!
 
         log :info, "RSpecDissect enabled"
       end
 
-      def track(type, meta = nil)
-        start = TestProf.now
-        res = yield
-        delta = (TestProf.now - start)
-        type = type.to_s
-        @data[type][:time] += delta
-        @data[type][:meta] << meta unless meta.nil?
-        @data["total_#{type}"] += delta
-        res
+      def nextid
+        @last_id += 1
+        @last_id.to_s
       end
 
-      def reset!
-        METRICS.each do |type|
-          @data[type.to_s] = {time: 0.0, meta: []}
-        end
+      def current_span
+        Thread.current[:_rspec_dissect_spans_stack].last
       end
 
-      # Whether we are able to track `let` usage
-      def memoization_available?
-        defined?(::RSpec::Core::MemoizedHelpers::ThreadsafeMemoized)
+      def span_stack
+        Thread.current[:_rspec_dissect_spans_stack]
       end
 
-      def time_for(key)
-        @data[key.to_s][:time]
+      def track(type, id: nextid, **meta)
+        span = Span.new(id, current_span&.id, type, 0.0, meta)
+        span_stack << span
+
+        begin
+          start = TestProf.now
+          res = yield
+          delta = (TestProf.now - start)
+          span.duration = delta
+          @spans << span
+          res
+        ensure
+          span_stack.pop
+        end
       end
 
-      def meta_for(key)
-        @data[key.to_s][:meta]
+      def populate_from_spans!(data)
+        data[:total_setup] = @spans.select { !_1.parent_id }.sum(&:duration)
+        data[:total_before_let] = @spans.select { _1.type == :let && _1.parent_id }.sum(&:duration).to_f
+        data[:total_lazy_let] = @spans.select { _1.type == :let && !_1.parent_id }.sum(&:duration).to_f
+
+        data[:top_lets] = @spans.select { _1.type == :let }
+          .group_by { _1.meta[:name] }
+          .transform_values! do |spans|
+            {name: spans.first.meta[:name], duration: spans.sum(&:duration), size: spans.size}
+          end
+          .values
+          .sort_by { -_1[:duration] }
+          .take(RSpecDissect.config.let_top_count)
       end
 
-      def total_time_for(key)
-        @data["total_#{key}"]
+      def reset!
+        @last_id = 1
+        @spans = []
+        Thread.current[:_rspec_dissect_spans_stack] = []
       end
     end
   end
 end
 
-require "test_prof/rspec_dissect/collectors/let"
-require "test_prof/rspec_dissect/collectors/before"
 require "test_prof/rspec_dissect/rspec"
 
 TestProf.activate("RD_PROF") do

data/lib/test_prof/rspec_stamp/parser/prism.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module TestProf
+  module RSpecStamp
+    module Parser
+      class Prism
+        def parse(code)
+          result = ::Prism.parse(code)
+          return unless result.success?
+
+          node = result.value.statements.body.first
+          return unless node.is_a?(::Prism::CallNode)
+
+          res = Result.new
+          res.fname =
+            if node.receiver
+              "#{node.receiver.full_name}.#{node.name}"
+            else
+              node.name.name
+            end
+
+          args = node.arguments&.arguments
+          return res if args.nil?
+
+          rest =
+            case (first = args.first).type
+            when :string_node
+              res.desc = first.content
+              args[1..]
+            when :constant_read_node, :constant_path_node
+              res.desc_const = first.full_name
+              args[1..]
+            else
+              args
+            end
+
+          rest.each do |arg|
+            case arg.type
+            when :symbol_node
+              res.add_tag(arg.value.to_sym)
+            when :keyword_hash_node
+              arg.elements.each do |assoc|
+                res.add_htag(
+                  assoc.key.value.to_sym,
+                  parse_htag_value(assoc.value)
+                )
+              end
+            end
+          end
+
+          res
+        end
+
+        private
+
+        def parse_htag_value(node)
+          case node.type
+          when :true_node
+            true
+          when :false_node
+            false
+          when :integer_node, :float_node
+            node.value
+          when :string_node
+            node.unescaped
+          when :symbol_node
+            node.value.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/rspec_stamp/parser/ripper.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module TestProf
+  module RSpecStamp
+    module Parser
+      class Ripper
+        def parse(code)
+          sexp = ::Ripper.sexp(code)
+          return unless sexp
+
+          # sexp has the following format:
+          # [:program,
+          #   [
+          #     [
+          #       :command,
+          #       [:@ident, "it", [1, 0]],
+          #       [:args_add_block, [ ... ]]
+          #     ]
+          #   ]
+          # ]
+          #
+          # or
+          #
+          # [:program,
+          #   [
+          #     [
+          #       :vcall,
+          #       [:@ident, "it", [1, 0]]
+          #     ]
+          #   ]
+          # ]
+          res = Result.new
+
+          fcall = sexp[1][0][1]
+          args_block = sexp[1][0][2]
+
+          if fcall.first == :fcall
+            fcall = fcall[1]
+          elsif fcall.first == :var_ref
+            res.fname = [parse_const(fcall), sexp[1][0][3][1]].join(".")
+            args_block = sexp[1][0][4]
+          end
+
+          res.fname ||= fcall[1]
+
+          return res if args_block.nil?
+
+          args_block = args_block[1] if args_block.first == :arg_paren
+
+          args = args_block[1]
+
+          if args.first.first == :string_literal
+            res.desc = parse_literal(args.shift)
+          elsif args.first.first == :var_ref || args.first.first == :const_path_ref
+            res.desc_const = parse_const(args.shift)
+          end
+
+          parse_arg(res, args.shift) until args.empty?
+
+          res
+        end
+
+        private
+
+        def parse_arg(res, arg)
+          if arg.first == :symbol_literal
+            res.add_tag parse_literal(arg)
+          elsif arg.first == :bare_assoc_hash
+            parse_hash(res, arg[1])
+          end
+        end
+
+        def parse_hash(res, hash_arg)
+          hash_arg.each do |(_, label, val)|
+            res.add_htag label[1][0..-2].to_sym, parse_value(val)
+          end
+        end
+
+        # Expr of the form:
+        #  bool - [:var_ref, [:@kw, "true", [1, 24]]]
+        #  string - [:string_literal, [:string_content, [...]]]
+        #  int - [:@int, "3", [1, 52]]]]
+        def parse_value(expr)
+          case expr.first
+          when :var_ref
+            expr[1][1] == "true"
+          when :@int
+            expr[1].to_i
+          when :@float
+            expr[1].to_f
+          else
+            parse_literal(expr)
+          end
+        end
+
+        # Expr of the form:
+        #  [:string_literal, [:string_content, [:@tstring_content, "is", [1, 4]]]]
+        def parse_literal(expr)
+          val = expr[1][1][1]
+          val = val.to_sym if expr[0] == :symbol_literal ||
+            expr[0] == :assoc_new
+          val
+        end
+
+        # Expr of the form:
+        #  [:var_ref, [:@const, "User", [1, 9]]]
+        #
+        #  or
+        #
+        #  [:const_path_ref, [:const_path_ref, [:var_ref,
+        #    [:@const, "User", [1, 17]]],
+        #    [:@const, "Guest", [1, 23]]],
+        #    [:@const, "Collection", [1, 30]]
+        def parse_const(expr)
+          if expr.first == :var_ref
+            expr[1][1]
+          elsif expr.first == :@const
+            expr[1]
+          elsif expr.first == :const_path_ref
+            expr[1..].map(&method(:parse_const)).join("::")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/rspec_stamp/parser.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "ripper"
-
 module TestProf
   module RSpecStamp
     # Parse examples headers
@@ -27,126 +25,16 @@ module TestProf
         end
       end
 
-      class << self
-        def parse(code)
-          sexp = Ripper.sexp(code)
-          return unless sexp
-
-          # sexp has the following format:
-          # [:program,
-          #   [
-          #     [
-          #       :command,
-          #       [:@ident, "it", [1, 0]],
-          #       [:args_add_block, [ ... ]]
-          #     ]
-          #   ]
-          # ]
-          #
-          # or
-          #
-          # [:program,
-          #   [
-          #     [
-          #       :vcall,
-          #       [:@ident, "it", [1, 0]]
-          #     ]
-          #   ]
-          # ]
-          res = Result.new
-
-          fcall = sexp[1][0][1]
-          args_block = sexp[1][0][2]
-
-          if fcall.first == :fcall
-            fcall = fcall[1]
-          elsif fcall.first == :var_ref
-            res.fname = [parse_const(fcall), sexp[1][0][3][1]].join(".")
-            args_block = sexp[1][0][4]
-          end
-
-          res.fname ||= fcall[1]
-
-          return res if args_block.nil?
-
-          args_block = args_block[1] if args_block.first == :arg_paren
-
-          args = args_block[1]
-
-          if args.first.first == :string_literal
-            res.desc = parse_literal(args.shift)
-          elsif args.first.first == :var_ref || args.first.first == :const_path_ref
-            res.desc_const = parse_const(args.shift)
-          end
-
-          parse_arg(res, args.shift) until args.empty?
-
-          res
+      instance =
+        begin
+          require_relative "parser/prism"
+          self::Prism.new
+        rescue LoadError
+          require_relative "parser/ripper"
+          self::Ripper.new
         end
-        # rubocop: enable Metrics/CyclomaticComplexity
-        # rubocop: enable Metrics/PerceivedComplexity
 
-        private
-
-        def parse_arg(res, arg)
-          if arg.first == :symbol_literal
-            res.add_tag parse_literal(arg)
-          elsif arg.first == :bare_assoc_hash
-            parse_hash(res, arg[1])
-          end
-        end
-
-        def parse_hash(res, hash_arg)
-          hash_arg.each do |(_, label, val)|
-            res.add_htag label[1][0..-2].to_sym, parse_value(val)
-          end
-        end
-
-        # Expr of the form:
-        #  bool - [:var_ref, [:@kw, "true", [1, 24]]]
-        #  string - [:string_literal, [:string_content, [...]]]
-        #  int - [:@int, "3", [1, 52]]]]
-        def parse_value(expr)
-          case expr.first
-          when :var_ref
-            expr[1][1] == "true"
-          when :@int
-            expr[1].to_i
-          when :@float
-            expr[1].to_f
-          else
-            parse_literal(expr)
-          end
-        end
-
-        # Expr of the form:
-        #  [:string_literal, [:string_content, [:@tstring_content, "is", [1, 4]]]]
-        def parse_literal(expr)
-          val = expr[1][1][1]
-          val = val.to_sym if expr[0] == :symbol_literal ||
-            expr[0] == :assoc_new
-          val
-        end
-
-        # Expr of the form:
-        #  [:var_ref, [:@const, "User", [1, 9]]]
-        #
-        #  or
-        #
-        #  [:const_path_ref, [:const_path_ref, [:var_ref,
-        #    [:@const, "User", [1, 17]]],
-        #    [:@const, "Guest", [1, 23]]],
-        #    [:@const, "Collection", [1, 30]]
-        def parse_const(expr)
-          if expr.first == :var_ref
-            expr[1][1]
-          elsif expr.first == :@const
-            expr[1]
-          elsif expr.first == :const_path_ref
-            expr[1..].map(&method(:parse_const)).join("::")
-          end
-        end
-      end
+      define_singleton_method(:parse) { |code| instance.parse(code) }
     end
   end
 end

data/lib/test_prof/rspec_stamp.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "test_prof/core"
 require "test_prof/logging"
 require "test_prof/rspec_stamp/parser"
 

data/lib/test_prof/tps_prof/profiler.rb

@@ -1,18 +1,27 @@
 # frozen_string_literal: true
 
 require "test_prof/utils/sized_ordered_set"
+require "forwardable"
 
 module TestProf
   module TPSProf
     class Profiler
-      attr_reader :top_count, :groups, :total_count, :total_time, :threshold
+      extend Forwardable
 
-      def initialize(top_count, threshold: 10)
-        @threshold = threshold
-        @top_count = top_count
+      attr_reader :top_count, :groups, :total_count, :total_time,
+        :config
+
+      def_delegators :@config, :min_examples_count, :min_group_time, :min_target_tps,
+        :mode, :max_examples_count, :max_group_time, :min_tps
+
+      def initialize(top_count, config)
+        @config = config
+        # In strict mode, we use the sorted set to keep track of offenders
+        # to show in the end
+        @top_count = (config.mode == :strict) ? 100 : top_count
         @total_count = 0
         @total_time = 0.0
-        @groups = Utils::SizedOrderedSet.new(top_count, sort_by: :tps)
+        @groups = Utils::SizedOrderedSet.new(top_count, sort_by: :penalty)
       end
 
       def group_started(id)
@@ -22,20 +31,48 @@ module TestProf
         @group_started_at = TestProf.now
       end
 
-      def group_finished(id)
-        return unless @examples_count >= threshold
+      def group_finished(group)
+        return unless @examples_count >= min_examples_count
+
+        total_time = TestProf.now - @group_started_at
+        shared_setup_time = total_time - @examples_time
+
+        return unless total_time >= min_group_time
 
-        # Context-time
-        group_time = (TestProf.now - @group_started_at) - @examples_time
-        run_time = @examples_time + group_time
+        tps = (@examples_count / total_time).round(2)
 
-        groups << {
-          id: id,
-          run_time: run_time,
-          group_time: group_time,
+        return unless tps < min_target_tps
+
+        # How much time did we waste compared to the target TPS
+        penalty = @examples_count * ((1.0 / tps) - (1.0 / min_target_tps))
+
+        item = {
+          id: group,
+          total_time: total_time,
+          shared_setup_time: shared_setup_time,
           count: @examples_count,
-          tps: -(@examples_count / run_time).round(2)
+          tps: tps,
+          penalty: penalty
         }
+
+        if mode == :strict
+          location = group.metadata[:location]
+
+          if TPSProf.handle_group_strictly(
+            GroupInfo.new(
+              group: group,
+              location: location,
+              examples_count: @examples_count,
+              total_time: total_time,
+              tps: tps,
+              penalty: penalty
+            )
+          )
+            groups << item
+          end
+        else
+          groups << item
+        end
       end
 
       def example_started(id)

data/lib/test_prof/tps_prof/reporter/text.rb

@@ -23,25 +23,45 @@ module TestProf
             <<~MSG
               Total TPS (tests per second): #{total_tps}
 
-              Top #{profiler.top_count} slowest suites by TPS (tests per second) (min examples per group: #{profiler.threshold}):
-
             MSG
 
+          if profiler.mode == :strict
+            return if groups.empty?
+
+            msgs << if groups.size < profiler.top_count
+              <<~MSG
+                Suites violating TPS limits:
+
+              MSG
+            else
+              <<~MSG
+                Top #{profiler.top_count} suites violating TPS limits:
+
+              MSG
+            end
+          else
+            msgs <<
+              <<~MSG
+                Top #{profiler.top_count} slowest suites by TPS (tests per second):
+
+              MSG
+          end
+
           groups.each do |group|
             description = group[:id].top_level_description
             location = group[:id].metadata[:location]
-            time = group[:run_time]
-            group_time = group[:group_time]
+            time = group[:total_time]
+            setup_time = group[:shared_setup_time]
             count = group[:count]
-            tps = -group[:tps]
+            tps = group[:tps]
 
             msgs <<
               <<~GROUP
-                #{description.truncate} (#{location}) – #{tps} TPS (#{time.duration} / #{count}), group time: #{group_time.duration}
+                #{description.truncate} (#{location}) – #{tps} TPS (#{time.duration} / #{count}, shared setup time: #{setup_time.duration})
               GROUP
           end
 
-          log :info, msgs.join
+          log((profiler.mode == :strict) ? :error : :info, msgs.join)
         end
       end
     end

data/lib/test_prof/tps_prof/rspec.rb

@@ -15,27 +15,50 @@ module TestProf
       attr_reader :reporter, :profiler
 
       def initialize
-        @profiler = Profiler.new(TPSProf.config.top_count, threshold: TPSProf.config.threshold)
+        @profiler = Profiler.new(TPSProf.config.top_count, TPSProf.config)
         @reporter = TPSProf.config.reporter
 
-        log :info, "TPSProf enabled (top-#{TPSProf.config.top_count})"
+        conf = TPSProf.config
+        if conf.mode == :strict
+          config_parts = []
+
+          if conf.custom_strict_handler
+            config_parts << "custom handler"
+          else
+            config_parts << "max examples: #{conf.max_examples_count}" if conf.max_examples_count
+            config_parts << "max group time: #{conf.max_group_time}" if conf.max_group_time
+            config_parts << "min tps: #{conf.min_tps}" if conf.min_tps
+          end
+
+          log :info, "TPSProf strict enabled (#{config_parts.join(", ")})"
+        else
+          log :info, "TPSProf enabled (top-#{TPSProf.config.top_count})"
+        end
       end
 
       def example_group_started(notification)
         return unless notification.group.top_level?
+        return if notification.group.metadata[:tps_prof] == :ignore
+
         profiler.group_started notification.group
       end
 
       def example_group_finished(notification)
         return unless notification.group.top_level?
+        return if notification.group.metadata[:tps_prof] == :ignore
+
         profiler.group_finished notification.group
       end
 
       def example_started(notification)
+        return if notification.example.metadata[:tps_prof] == :ignore
+
         profiler.example_started notification.example
       end
 
       def example_finished(notification)
+        return if notification.example.metadata[:tps_prof] == :ignore
+
         profiler.example_finished notification.example
       end
 

data/lib/test_prof/tps_prof.rb

@@ -8,25 +8,81 @@ module TestProf
   #
   # Example:
   #
+  #   # Show top-10 groups with the worst TPS
   #   TPS_PROF=10 rspec ...
   #
+  #   # Report (as errors) groups with lower TPS
+  #   TPS_PROF_MIN_TPS=10 TPS_PROF=strict rspec ...
   module TPSProf
+    class Error < StandardError; end
+
+    class GroupInfo < Struct.new(:group, :location, :examples_count, :total_time, :tps, :penalty, keyword_init: true)
+    end
+
     class Configuration
-      attr_accessor :top_count, :threshold, :reporter
+      attr_accessor :top_count, :reporter, :mode
+
+      # Thresholds
+      attr_accessor(
+        :min_examples_count, # Ignore groups with fewer examples
+        :min_group_time,     # Ignore groups with less total time (in seconds)
+        :min_target_tps,     # Ignore groups with higher TPS
+        :max_examples_count, # Report groups with more examples in strict mode
+        :max_group_time,     # Report groups with more total time in strict mode
+        :min_tps             # Report groups with lower TPS in strict mode
+      )
+
+      attr_reader :custom_strict_handler
 
       def initialize
-        @top_count = ENV["TPS_PROF"].to_i
-        @top_count = 10 if @top_count == 1
-        @threshold = ENV.fetch("TPS_PROF_MIN", 10).to_i
+        @mode = (ENV["TPS_PROF_MODE"] || ((ENV["TPS_PROF"] == "strict") ? :strict : :profile)).to_sym
+        @top_count = ENV["TPS_PROF_COUNT"]&.to_i || ((ENV["TPS_PROF"].to_i > 1) ? ENV["TPS_PROF"].to_i : nil) || 10
+
+        @min_examples_count = ENV.fetch("TPS_PROF_MIN_EXAMPLES", 10).to_i
+        @min_group_time = ENV.fetch("TPS_PROF_MIN_TIME", 5).to_i
+        @min_target_tps = ENV.fetch("TPS_PROF_TARGET_TPS", 30).to_i
+
+        @max_examples_count = ENV["TPS_PROF_MAX_EXAMPLES"]&.to_i
+        @max_group_time = ENV["TPS_PROF_MAX_TIME"]&.to_i
+        @min_tps = ENV["TPS_PROF_MIN_TPS"]&.to_i
+
         @reporter = resolve_reporter(ENV["TPS_PROF_FORMAT"])
       end
 
+      def strict_handler
+        @strict_handler ||= method(:default_strict_handler)
+      end
+
+      def strict_handler=(val)
+        @strict_handler = val
+        @custom_strict_handler = true
+      end
+
       private
 
       def resolve_reporter(format)
         # TODO: support other formats
         TPSProf::Reporter::Text.new
       end
+
+      def default_strict_handler(group_info)
+        error_msg = nil
+        location = group_info.location
+
+        if max_examples_count && group_info.examples_count > max_examples_count
+          error_msg ||= "Group #{location} has too many examples: #{group_info.examples_count} > #{max_examples_count}"
+        end
+
+        if max_group_time && group_info.total_time > max_group_time
+          error_msg ||= "Group #{location} has too long total time: #{group_info.total_time} > #{max_group_time}"
+        end
+
+        if min_tps && group_info.tps < min_tps
+          error_msg ||= "Group #{location} has too low TPS: #{group_info.tps} < #{min_tps}"
+        end
+
+        raise error_msg if error_msg
+      end
     end
 
     class << self
@@ -37,6 +93,15 @@ module TestProf
       def configure
         yield config
       end
+
+      def handle_group_strictly(group_info)
+        reporter = ::RSpec.configuration.reporter
+        config.strict_handler.call(group_info)
+        false
+      rescue => err
+        reporter.notify_non_example_exception(Error.new(err.message), "")
+        true
+      end
     end
   end
 end

data/lib/test_prof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TestProf
-  VERSION = "1.5.2"
+  VERSION = "1.6.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test-prof
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-03 00:00:00.000000000 Z
+date: 2026-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -201,12 +201,12 @@ files:
 - lib/test_prof/recipes/rspec/let_it_be.rb
 - lib/test_prof/recipes/rspec/sample.rb
 - lib/test_prof/rspec_dissect.rb
-- lib/test_prof/rspec_dissect/collectors/base.rb
-- lib/test_prof/rspec_dissect/collectors/before.rb
-- lib/test_prof/rspec_dissect/collectors/let.rb
+- lib/test_prof/rspec_dissect/collector.rb
 - lib/test_prof/rspec_dissect/rspec.rb
 - lib/test_prof/rspec_stamp.rb
 - lib/test_prof/rspec_stamp/parser.rb
+- lib/test_prof/rspec_stamp/parser/prism.rb
+- lib/test_prof/rspec_stamp/parser/ripper.rb
 - lib/test_prof/rspec_stamp/rspec.rb
 - lib/test_prof/rubocop.rb
 - lib/test_prof/ruby_prof.rb

data/lib/test_prof/rspec_dissect/collectors/base.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "test_prof/utils/sized_ordered_set"
-require "test_prof/ext/float_duration"
-require "test_prof/ext/string_truncate"
-
-module TestProf # :nodoc: all
-  using FloatDuration
-  using StringTruncate
-
-  module RSpecDissect
-    module Collectors
-      class Base
-        attr_reader :results, :name, :top_count
-
-        def initialize(name:, top_count:)
-          @name = name
-          @top_count = top_count
-          @results = Utils::SizedOrderedSet.new(
-            top_count, sort_by: name
-          )
-        end
-
-        def populate!(data)
-          data[name] = RSpecDissect.time_for(name)
-        end
-
-        def <<(data)
-          results << data
-        end
-
-        def total_time
-          RSpecDissect.total_time_for(name)
-        end
-
-        def total_time_message
-          "\nTotal `#{print_name}` time: #{total_time.duration}"
-        end
-
-        def print_name
-          name
-        end
-
-        def print_result_header
-          <<~MSG
-
-            Top #{top_count} slowest suites (by `#{print_name}` time):
-
-          MSG
-        end
-
-        def print_group_result(group)
-          <<~GROUP
-            #{group[:desc].truncate} (#{group[:loc]}) – #{group[name].duration} of #{group[:total].duration} (#{group[:count]})
-          GROUP
-        end
-
-        def print_results
-          msgs = [print_result_header]
-
-          results.each do |group|
-            msgs << print_group_result(group)
-          end
-
-          msgs.join
-        end
-      end
-    end
-  end
-end

data/lib/test_prof/rspec_dissect/collectors/before.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "test_prof/rspec_dissect/collectors/base"
-
-module TestProf
-  module RSpecDissect
-    module Collectors # :nodoc: all
-      class Before < Base
-        def initialize(params)
-          super(name: :before, **params)
-        end
-
-        def print_name
-          "before(:each)"
-        end
-      end
-    end
-  end
-end

data/lib/test_prof/rspec_dissect/collectors/let.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require "test_prof/rspec_dissect/collectors/base"
-
-module TestProf
-  module RSpecDissect
-    module Collectors # :nodoc: all
-      class Let < Base
-        def initialize(params)
-          super(name: :let, **params)
-        end
-
-        def populate!(data)
-          super
-          data[:let_calls] = RSpecDissect.meta_for(name)
-        end
-
-        def print_results
-          return unless RSpecDissect.memoization_available?
-          super
-        end
-
-        def print_group_result(group)
-          return super unless RSpecDissect.config.let_stats_enabled?
-          msgs = [super]
-          group[:let_calls]
-            .group_by(&:itself)
-            .map { |id, calls| [id, -calls.size] }
-            .sort_by(&:last)
-            .take(RSpecDissect.config.let_top_count)
-            .each do |(id, size)|
-              msgs << " ↳ #{id} – #{-size}\n"
-          end
-          msgs.join
-        end
-      end
-    end
-  end
-end