test-prof 1.3.2 → 1.4.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed617176a00461b30a96b07f086b52ea89d28fff7d1e4b085110e1b2333b6c60
-  data.tar.gz: c2e425a439407505f4ac1ecbfe25d84517343d7e9d7f1260ce675382f3ee6f1f
+  metadata.gz: 2bb23a2e0630d64b02f4f755f801189a19a5d26179dcb5d9d9420b73a0b78319
+  data.tar.gz: 56fe8596860ac93bb46adb6d6c9ff027de6eddf43eb3fbd28d69f2fddd76c1eb
 SHA512:
-  metadata.gz: 3548abd19a6f283dd230e340a0651fc2196b7253bc4fcf4f5115d53a3e55b35e43ece87a875d4267a00edfa5105c303365bc1b7e9f787a0fcd5d3d8ffd86634b
-  data.tar.gz: 911ed9f79a48b4fd72b1ea7885f2eb5d3f75410421946cdd61966b9ffc50a245bb1f0c88b93b256ec5b06159267b16ccfcf129c06fde3d021605f1b15375c7cf
+  metadata.gz: 03f0304518182b46058f20f2a818067f264901278da60f0449cbc9ca37e3283bd093e737f7dff4312b3e4e99e3f24106d620ba90c6561b6218b3f99077785d53
+  data.tar.gz: 37608d5a827f5caff39f1fdd0ad066fed97d9cf42c1da532dac6b0019f3372f89b0779daf4ad3e570435c3aea624789d61723c6155c147e9d140d27d9db5f071

data/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 ## master (unreleased)
 
+- Drop support for **Ruby <2.7** and **Rails <6**.
+
+- FactoryDefault: Add `#get_factory_default`. [[@john-h-k][]]
+
+- Add variations information to FactorProf reports. ([@lHydra][])
+
+Get info on traits/overrides used by running `FPROF=1 FPROF_VARS=1 <your test command>`.
+
+- Add support for `report_duplicates` config option for `let_it_be` ([@lHydra][])
+
+- Support latest Timecop patching `Process.clock_gettime`. ([@palkan][])
+
+- Vernier: Add hooks configuration parameter. ([@lHydra][])
+
+Now you can add more insights to the resulting report by adding event markers from Active Support Notifications.
+To do this, specify the `TEST_VERNIER_HOOKS=rails` env var or set it through `Vernier` configuration:
+
+```ruby
+TestProf::Vernier.configure do |config|
+  config.hooks = :rails
+end
+```
+
+- FactoryProf: Add threshold configuration parameter. ([@lHydra][])
+
+Now you can ignore factories which total number of calls is less than the provided threshold. To do this, specify
+the `FPROF_THRESHOLD=30` env var or set it through `FactoryProf` configuration:
+
+```ruby
+TestProf::FactoryProf.configure do |config|
+  config.threshold = 30
+end
+```
+
+## 1.3.3 (2024-04-19)
+
+- Fix MemProf bugs. ([@palkan][])
+
 ## 1.3.2 (2024-03-08) 🌷
 
 - Add Minitest support for TagProf. ([@lioneldebauge][])
@@ -386,3 +424,5 @@ See [changelog](https://github.com/test-prof/test-prof/blob/v0.8.0/CHANGELOG.md)
 [@Vankiru]: https://github.com/Vankiru
 [@uzushino]: https://github.com/uzushino
 [@lioneldebauge]: https://github.com/lioneldebauge
+[@lHydra]: https://github.com/lHydra
+[@john-h-k]: https://github.com/john-h-k

data/README.md

@@ -83,9 +83,9 @@ And that's it)
 
 Supported Ruby versions:
 
-- Ruby (MRI) >= 2.5.0 (**NOTE:** for Ruby 2.2 use TestProf < 0.7.0, Ruby 2.3 use TestProf ~> 0.7.0, Ruby 2.4 use TestProf <0.12.0)
+- Ruby (MRI) >= 2.7.0 (**NOTE:** for Ruby 2.2 use TestProf < 0.7.0, Ruby 2.3 use TestProf ~> 0.7.0, Ruby 2.4 use TestProf <0.12.0, Ruby 2.5-2.6 use TestProf < 1.3)
 
-- JRuby >= 9.1.0.0 (**NOTE:** refinements-dependent features might require 9.2.7+)
+- JRuby >= 9.3.0
 
 Supported RSpec version (for RSpec features only): >= 3.5.0 (for older RSpec versions use TestProf < 0.8.0).
 

data/lib/test_prof/before_all/adapters/active_record.rb

@@ -8,44 +8,58 @@ module TestProf
         POOL_ARGS = ((::ActiveRecord::VERSION::MAJOR > 6) ? [:writing] : []).freeze
 
         class << self
-          def all_connections
-            @all_connections ||= if ::ActiveRecord::Base.respond_to? :connects_to
-              ::ActiveRecord::Base.connection_handler.connection_pool_list(*POOL_ARGS).filter_map { |pool|
-                begin
-                  pool.connection
-                rescue *pool_connection_errors => error
-                  log_pool_connection_error(pool, error)
-                  nil
-                end
-              }
-            else
-              Array.wrap(::ActiveRecord::Base.connection)
+          if ::ActiveRecord::Base.connection.pool.respond_to?(:pin_connection!)
+            def begin_transaction
+              ::ActiveRecord::Base.connection_handler.connection_pool_list(:writing).each do |pool|
+                pool.pin_connection!(true)
+              end
             end
-          end
 
-          def pool_connection_errors
-            @pool_connection_errors ||= []
-          end
+            def rollback_transaction
+              ::ActiveRecord::Base.connection_handler.connection_pool_list(:writing).each do |pool|
+                pool.unpin_connection!
+              end
+            end
+          else
+            def all_connections
+              @all_connections ||= if ::ActiveRecord::Base.respond_to? :connects_to
+                ::ActiveRecord::Base.connection_handler.connection_pool_list(*POOL_ARGS).filter_map { |pool|
+                  begin
+                    pool.connection
+                  rescue *pool_connection_errors => error
+                    log_pool_connection_error(pool, error)
+                    nil
+                  end
+                }
+              else
+                Array.wrap(::ActiveRecord::Base.connection)
+              end
+            end
 
-          def log_pool_connection_error(pool, error)
-            warn "Could not connect to pool #{pool.connection_class.name}. #{error.class}: #{error.message}"
-          end
+            def pool_connection_errors
+              @pool_connection_errors ||= []
+            end
 
-          def begin_transaction
-            @all_connections = nil
-            all_connections.each do |connection|
-              connection.begin_transaction(joinable: false)
+            def log_pool_connection_error(pool, error)
+              warn "Could not connect to pool #{pool.connection_class.name}. #{error.class}: #{error.message}"
             end
-          end
 
-          def rollback_transaction
-            all_connections.each do |connection|
-              if connection.open_transactions.zero?
-                warn "!!! before_all transaction has been already rollbacked and " \
-                      "could work incorrectly"
-                next
+            def begin_transaction
+              @all_connections = nil
+              all_connections.each do |connection|
+                connection.begin_transaction(joinable: false)
+              end
+            end
+
+            def rollback_transaction
+              all_connections.each do |connection|
+                if connection.open_transactions.zero?
+                  warn "!!! before_all transaction has been already rollbacked and " \
+                        "could work incorrectly"
+                  next
+                end
+                connection.rollback_transaction
               end
-              connection.rollback_transaction
             end
           end
 
@@ -67,23 +81,23 @@ module TestProf
       end
     end
 
-    # avoid instance variable collisions with cats
-    PREFIX_RESTORE_LOCK_THREAD = "@😺"
+    unless ::ActiveRecord::Base.connection.pool.respond_to?(:pin_connection!)
+      # avoid instance variable collisions with cats
+      PREFIX_RESTORE_LOCK_THREAD = "@😺"
 
-    configure do |config|
-      # Make sure ActiveRecord uses locked thread.
-      # It only gets locked in `before` / `setup` hook,
-      # thus using thread in `before_all` (e.g. ActiveJob async adapter)
-      # might lead to leaking connections
-      config.before(:begin) do
-        next unless ::ActiveRecord::Base.connection.pool.respond_to?(:lock_thread=)
-        instance_variable_set("#{PREFIX_RESTORE_LOCK_THREAD}_orig_lock_thread", ::ActiveRecord::Base.connection.pool.instance_variable_get(:@lock_thread)) unless instance_variable_defined? "#{PREFIX_RESTORE_LOCK_THREAD}_orig_lock_thread"
-        ::ActiveRecord::Base.connection.pool.lock_thread = true
-      end
+      configure do |config|
+        # Make sure ActiveRecord uses locked thread.
+        # It only gets locked in `before` / `setup` hook,
+        # thus using thread in `before_all` (e.g. ActiveJob async adapter)
+        # might lead to leaking connections
+        config.before(:begin) do
+          instance_variable_set("#{PREFIX_RESTORE_LOCK_THREAD}_orig_lock_thread", ::ActiveRecord::Base.connection.pool.instance_variable_get(:@lock_thread)) unless instance_variable_defined? "#{PREFIX_RESTORE_LOCK_THREAD}_orig_lock_thread"
+          ::ActiveRecord::Base.connection.pool.lock_thread = true
+        end
 
-      config.after(:rollback) do
-        next unless ::ActiveRecord::Base.connection.pool.respond_to?(:lock_thread=)
-        ::ActiveRecord::Base.connection.pool.lock_thread = instance_variable_get("#{PREFIX_RESTORE_LOCK_THREAD}_orig_lock_thread")
+        config.after(:rollback) do
+          ::ActiveRecord::Base.connection.pool.lock_thread = instance_variable_get("#{PREFIX_RESTORE_LOCK_THREAD}_orig_lock_thread")
+        end
       end
     end
   end

data/lib/test_prof/before_all.rb

@@ -66,7 +66,7 @@ module TestProf
       private
 
       def filters_apply?(metadata)
-        return true unless filters.present? && TestProf.rspec?
+        return true unless filters.is_a?(Hash) && TestProf.rspec?
 
         ::RSpec::Core::MetadataFilter.apply?(
           :all?,

data/lib/test_prof/core.rb

@@ -6,6 +6,29 @@ require "logger"
 require "test_prof/logging"
 require "test_prof/utils"
 
+# Add an alias for Process.clock_gettime "reserved" for TestProf
+# (in case some other tool would like to patch it)
+module ::Process
+  class << self
+    # Already patched by Timecop
+    if method_defined?(:clock_gettime_without_mock)
+      alias_method :clock_gettime_for_test_prof, :clock_gettime_without_mock
+    else
+      alias_method :clock_gettime_for_test_prof, :clock_gettime
+
+      def singleton_method_added(method_name)
+        return super unless method_name == :clock_gettime_without_mock
+
+        define_method(:clock_gettime_for_test_prof) { |*args| clock_gettime_without_mock(*args) }
+      end
+    end
+  end
+end
+
+# Main TestProf module
+#
+# Contains configuration and common methods
+
 # Ruby applications tests profiling tools.
 #
 # Contains tools to analyze factories usage, integrate with Ruby profilers,
@@ -54,7 +77,7 @@ module TestProf
 
     # Returns the current process time
     def now
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      Process.clock_gettime_for_test_prof(Process::CLOCK_MONOTONIC)
     end
 
     # Require gem and shows a custom

data/lib/test_prof/event_prof/monitor.rb

@@ -48,16 +48,9 @@ module TestProf
 
           patch = Module.new do
             mids.each do |mid|
-              if RUBY_VERSION >= "2.7.0"
-                define_method(mid) do |*args, **kwargs, &block|
-                  next super(*args, **kwargs, &block) unless guard.nil? || instance_exec(*args, **kwargs, &guard)
-                  tracker.track { super(*args, **kwargs, &block) }
-                end
-              else
-                define_method(mid) do |*args, &block|
-                  next super(*args, &block) unless guard.nil? || instance_exec(*args, &guard)
-                  tracker.track { super(*args, &block) }
-                end
+              define_method(mid) do |*args, **kwargs, &block|
+                next super(*args, **kwargs, &block) unless guard.nil? || instance_exec(*args, **kwargs, &guard)
+                tracker.track { super(*args, **kwargs, &block) }
               end
             end
           end

data/lib/test_prof/factory_bot.rb

@@ -3,6 +3,8 @@
 module TestProf # :nodoc: all
   FACTORY_GIRL_NAMES = {"factory_bot" => "::FactoryBot", "factory_girl" => "::FactoryGirl"}.freeze
 
+  TestProf.require("active_support/inflector")
+
   FACTORY_GIRL_NAMES.find do |name, cname|
     TestProf.require(name) do
       TestProf::FactoryBot = Object.const_get(cname)

data/lib/test_prof/factory_default/factory_bot_patch.rb

@@ -12,7 +12,7 @@ module TestProf
 
     module StrategyExt
       def association(runner)
-        FactoryDefault.get(runner.name, runner.traits, runner.overrides) ||
+        FactoryDefault.get(runner.name, runner.traits, runner.overrides, **{}) ||
           FactoryDefault.profiler.instrument(runner.name, runner.traits, runner.overrides) { super }
       end
     end

data/lib/test_prof/factory_default.rb

@@ -159,7 +159,8 @@ module TestProf
         set_factory_default(name, obj, **default_options)
       end
 
-      def set_factory_default(name, obj, preserve_traits: FactoryDefault.config.preserve_traits, preserve_attributes: FactoryDefault.config.preserve_attributes, **other)
+      def set_factory_default(*name, obj, preserve_traits: FactoryDefault.config.preserve_traits, preserve_attributes: FactoryDefault.config.preserve_attributes, **other)
+        name = name.first if name.size == 1
         FactoryDefault.register(
           name, obj,
           preserve_traits: preserve_traits,
@@ -168,6 +169,10 @@ module TestProf
         )
       end
 
+      def get_factory_default(name, *traits, **overrides)
+        FactoryDefault.get(name, traits, overrides, skip_stats: true)
+      end
+
       def skip_factory_default(&block)
         FactoryDefault.disable!(&block)
       end
@@ -236,7 +241,7 @@ module TestProf
         obj
       end
 
-      def get(name, traits = nil, overrides = nil)
+      def get(name, traits = nil, overrides = nil, skip_stats: false)
         return unless enabled?
 
         record = store[name]
@@ -248,7 +253,7 @@ module TestProf
           traits = nil
         end
 
-        stats[name][:miss] += 1
+        stats[name][:miss] += 1 unless skip_stats
 
         if traits && !traits.empty? && record[:preserve_traits]
           return
@@ -263,8 +268,10 @@ module TestProf
           end
         end
 
-        stats[name][:miss] -= 1
-        stats[name][:hit] += 1
+        unless skip_stats
+          stats[name][:miss] -= 1
+          stats[name][:hit] += 1
+        end
 
         if record[:context] && (record[:context] != :example)
           object.refind

data/lib/test_prof/factory_prof/fabrication_patch.rb

@@ -5,7 +5,13 @@ module TestProf
     # Wrap #run method with FactoryProf tracking
     module FabricationPatch
       def create(name, overrides = {})
-        FactoryBuilders::Fabrication.track(name) { super }
+        variation = ""
+
+        if FactoryProf.config.include_variations && !overrides.empty?
+          variation += overrides.keys.sort.to_s.gsub(/[\\":]/, "")
+        end
+
+        FactoryBuilders::Fabrication.track(name, variation: variation.to_sym) { super }
       end
     end
   end

data/lib/test_prof/factory_prof/factory_bot_patch.rb

@@ -5,7 +5,21 @@ module TestProf
     # Wrap #run method with FactoryProf tracking
     module FactoryBotPatch
       def run(strategy = @strategy)
-        FactoryBuilders::FactoryBot.track(strategy, @name) { super }
+        variation = ""
+
+        if FactoryProf.config.include_variations
+          if @traits || @overrides
+            unless @traits.empty?
+              variation += @traits.sort.join(".").prepend(".")
+            end
+
+            unless @overrides.empty?
+              variation += @overrides.keys.sort.to_s.gsub(/[\\":]/, "")
+            end
+          end
+        end
+
+        FactoryBuilders::FactoryBot.track(strategy, @name, variation: variation.to_sym) { super }
       end
     end
   end

data/lib/test_prof/factory_prof/factory_builders/fabrication.rb

@@ -15,8 +15,8 @@ module TestProf
           end
         end
 
-        def self.track(factory, &block)
-          FactoryProf.track(factory, &block)
+        def self.track(factory, **opts, &block)
+          FactoryProf.track(factory, **opts, &block)
         end
       end
     end

data/lib/test_prof/factory_prof/factory_builders/factory_bot.rb

@@ -18,9 +18,9 @@ module TestProf
             defined? TestProf::FactoryBot
         end
 
-        def self.track(strategy, factory, &block)
+        def self.track(strategy, factory, **opts, &block)
           return yield unless strategy.create?
-          FactoryProf.track(factory, &block)
+          FactoryProf.track(factory, **opts, &block)
         end
       end
     end

data/lib/test_prof/factory_prof/printers/json.rb

@@ -9,7 +9,7 @@ module TestProf::FactoryProf
         using TestProf::FloatDuration
         include TestProf::Logging
 
-        def dump(result, start_time:)
+        def dump(result, start_time:, **)
           return log(:info, "No factories detected") if result.raw_stats == {}
 
           outpath = TestProf.artifact_path("test-prof.result.json")

data/lib/test_prof/factory_prof/printers/nate_heckler.rb

@@ -10,7 +10,7 @@ module TestProf::FactoryProf
         using TestProf::FloatDuration
         include TestProf::Logging
 
-        def dump(result, start_time:)
+        def dump(result, start_time:, **)
           return if result.raw_stats == {}
 
           total_time = result.stats.sum { |stat| stat[:top_level_time] }

data/lib/test_prof/factory_prof/printers/simple.rb

@@ -9,7 +9,7 @@ module TestProf::FactoryProf
         using TestProf::FloatDuration
         include TestProf::Logging
 
-        def dump(result, start_time:)
+        def dump(result, start_time:, threshold:)
           return log(:info, "No factories detected") if result.raw_stats == {}
           msgs = []
 
@@ -28,17 +28,34 @@ module TestProf::FactoryProf
                Total time: #{total_time.duration} (out of #{total_run_time.duration})
                Total uniq factories: #{total_uniq_factories}
 
-                 total   top-level     total time      time per call      top-level time               name
+                 name                    total   top-level     total time      time per call      top-level time
             MSG
 
           result.stats.each do |stat|
-            time_per_call = stat[:total_time] / stat[:total_count]
-
-            msgs << format("%8d %11d %13.4fs %17.4fs %18.4fs %18s", stat[:total_count], stat[:top_level_count], stat[:total_time], time_per_call, stat[:top_level_time], stat[:name])
+            next if stat[:total_count] < threshold
+
+            msgs << format("%-3s%-20s %8d %11d %13.4fs %17.4fs %18.4fs", *format_args(stat))
+            # move other variation ("[...]") to the end of the array
+            sorted_variations = stat[:variations].sort_by.with_index do |variation, i|
+              (variation[:name] == "[...]") ? stat[:variations].size + 1 : i
+            end
+            sorted_variations.each do |variation_stat|
+              msgs << format("%-5s%-18s %8d %11d %13.4fs %17.4fs %18.4fs", *format_args(variation_stat))
+            end
           end
 
           log :info, msgs.join("\n")
         end
+
+        private
+
+        def format_args(stat)
+          time_per_call = stat[:total_time] / stat[:total_count]
+          format_args = [""]
+          format_args += stat.values_at(:name, :total_count, :top_level_count, :total_time)
+          format_args << time_per_call
+          format_args << stat[:top_level_time]
+        end
       end
     end
   end

data/lib/test_prof/factory_prof.rb

@@ -16,7 +16,7 @@ module TestProf
 
     # FactoryProf configuration
     class Configuration
-      attr_accessor :mode, :printer
+      attr_accessor :mode, :printer, :threshold, :include_variations, :variations_limit
 
       def initialize
         @mode = (ENV["FPROF"] == "flamegraph") ? :flamegraph : :simple
@@ -31,6 +31,9 @@ module TestProf
           else
             Printers::Simple
           end
+        @threshold = ENV.fetch("FPROF_THRESHOLD", 0).to_i
+        @include_variations = ENV["FPROF_VARS"] == "1"
+        @variations_limit = ENV.fetch("FPROF_VARIATIONS_LIMIT", 2).to_i
       end
 
       # Whether we want to generate flamegraphs
@@ -49,8 +52,14 @@ module TestProf
 
       # Returns sorted stats
       def stats
-        @stats ||= @raw_stats.values
-          .sort_by { |el| -el[:total_count] }
+        @stats ||= @raw_stats.values.sort_by { |el| -el[:total_count] }.map do |stat|
+          unless stat[:variations].empty?
+            stat = stat.dup
+            stat[:variations] = stat[:variations].values.sort_by { |nested_el| -nested_el[:total_count] }
+          end
+
+          stat
+        end
       end
 
       def total_count
@@ -60,14 +69,6 @@ module TestProf
       def total_time
         @total_time ||= @raw_stats.values.sum { |v| v[:total_time] }
       end
-
-      private
-
-      def sorted_stats(key)
-        @raw_stats.values
-          .map { |el| [el[:name], el[key]] }
-          .sort_by { |el| -el[1] }
-      end
     end
 
     class << self
@@ -115,7 +116,7 @@ module TestProf
       def print(started_at)
         printer = config.printer
 
-        printer.dump(result, start_time: started_at)
+        printer.dump(result, start_time: started_at, threshold: config.threshold)
       end
 
       def start
@@ -131,20 +132,19 @@ module TestProf
         Result.new(@stacks, @stats)
       end
 
-      def track(factory)
+      def track(factory, variation:)
         return yield unless running?
         @depth += 1
         @current_stack << factory if config.flamegraph?
-        @stats[factory][:total_count] += 1
-        @stats[factory][:top_level_count] += 1 if @depth == 1
+        track_count(@stats[factory])
+        track_count(@stats[factory][:variations][variation_name(variation)]) unless variation.empty?
         t1 = TestProf.now
         begin
           yield
         ensure
           t2 = TestProf.now
-          elapsed = t2 - t1
-          @stats[factory][:total_time] += elapsed
-          @stats[factory][:top_level_time] += elapsed if @depth == 1
+          track_time(@stats[factory], t1, t2)
+          track_time(@stats[factory][:variations][variation_name(variation)], t1, t2) unless variation.empty?
           @depth -= 1
           flush_stack if @depth.zero?
         end
@@ -152,21 +152,45 @@ module TestProf
 
       private
 
+      def variation_name(variation)
+        variations_count = variation.to_s.scan(/[\w]+/).size
+        return "[...]" if variations_count > config.variations_limit
+
+        variation
+      end
+
       def reset!
         @stacks = [] if config.flamegraph?
         @depth = 0
         @stats = Hash.new do |h, k|
-          h[k] = {
-            name: k,
-            total_count: 0,
-            top_level_count: 0,
-            total_time: 0.0,
-            top_level_time: 0.0
-          }
+          h[k] = hash_template(k)
+          h[k][:variations] = Hash.new { |hh, variation_key| hh[variation_key] = hash_template(variation_key) }
+          h[k]
         end
         flush_stack
       end
 
+      def hash_template(name)
+        {
+          name: name,
+          total_count: 0,
+          top_level_count: 0,
+          total_time: 0.0,
+          top_level_time: 0.0
+        }
+      end
+
+      def track_count(factory)
+        factory[:total_count] += 1
+        factory[:top_level_count] += 1 if @depth == 1
+      end
+
+      def track_time(factory, t1, t2)
+        elapsed = t2 - t1
+        factory[:total_time] += elapsed
+        factory[:top_level_time] += elapsed if @depth == 1
+      end
+
       def flush_stack
         return unless config.flamegraph?
         @stacks << @current_stack unless @current_stack.nil? || @current_stack.empty?

data/lib/test_prof/memory_prof/printer.rb

@@ -50,6 +50,8 @@ module TestProf
       end
 
       def memory_percentage(item)
+        return 0 if tracker.total_memory.zero? || item[:memory].zero?
+
         (100.0 * item[:memory] / tracker.total_memory).round(2)
       end
 

data/lib/test_prof/memory_prof/rspec.rb

@@ -16,23 +16,26 @@ module TestProf
         @tracker = MemoryProf.tracker
         @printer = MemoryProf.printer(tracker)
 
+        @current_group = nil
+        @current_example = nil
+
         @tracker.start
       end
 
       def example_started(notification)
-        tracker.example_started(example(notification))
+        tracker.example_started(notification.example, example(notification))
       end
 
       def example_finished(notification)
-        tracker.example_finished(example(notification))
+        tracker.example_finished(notification.example)
       end
 
       def example_group_started(notification)
-        tracker.group_started(group(notification))
+        tracker.group_started(notification.group, group(notification))
       end
 
       def example_group_finished(notification)
-        tracker.group_finished(group(notification))
+        tracker.group_finished(notification.group)
       end
 
       def report

data/lib/test_prof/memory_prof/tracker/linked_list.rb

@@ -52,19 +52,20 @@ module TestProf
         attr_reader :head
 
         def initialize(memory_at_start)
-          add_node(:total, memory_at_start)
+          add_node(:total, :total, memory_at_start)
         end
 
-        def add_node(item, memory_at_start)
+        def add_node(id, item, memory_at_start)
           @head = LinkedListNode.new(
+            id: id,
             item: item,
             previous: head,
             memory_at_start: memory_at_start
           )
         end
 
-        def remove_node(item, memory_at_finish)
-          return if head.item != item
+        def remove_node(id, memory_at_finish)
+          return if head.id != id
           head.finish(memory_at_finish)
 
           current = head
@@ -75,9 +76,10 @@ module TestProf
       end
 
       class LinkedListNode
-        attr_reader :item, :previous, :memory_at_start, :memory_at_finish, :nested_memory
+        attr_reader :id, :item, :previous, :memory_at_start, :memory_at_finish, :nested_memory
 
-        def initialize(item:, memory_at_start:, previous:)
+        def initialize(id:, item:, memory_at_start:, previous:)
+          @id = id
           @item = item
           @previous = previous
 

data/lib/test_prof/memory_prof/tracker.rb

@@ -36,22 +36,26 @@ module TestProf
         @total_memory = node.total_memory
       end
 
-      def example_started(example)
-        list.add_node(example, track)
+      def example_started(id, example = id)
+        list.add_node(id, example, track)
       end
 
-      def example_finished(example)
-        node = list.remove_node(example, track)
-        examples << {**example, memory: node.total_memory}
+      def example_finished(id)
+        node = list.remove_node(id, track)
+        return unless node
+
+        examples << {**node.item, memory: node.total_memory}
       end
 
-      def group_started(group)
-        list.add_node(group, track)
+      def group_started(id, group = id)
+        list.add_node(id, group, track)
       end
 
-      def group_finished(group)
-        node = list.remove_node(group, track)
-        groups << {**group, memory: node.hooks_memory}
+      def group_finished(id)
+        node = list.remove_node(id, track)
+        return unless node
+
+        groups << {**node.item, memory: node.hooks_memory}
       end
     end
 

data/lib/test_prof/recipes/minitest/sample.rb

@@ -7,14 +7,16 @@ module TestProf
     CORE_RUNNABLES = [
       Minitest::Test,
       defined?(Minitest::Unit::TestCase) ? Minitest::Unit::TestCase : nil,
-      Minitest::Spec
+      defined?(Minitest::Spec) ? Minitest::Spec : nil
     ].compact.freeze
 
     class << self
       def suites
         # Make sure that sample contains only _real_ suites
         Minitest::Runnable.runnables
-          .reject { |suite| CORE_RUNNABLES.include?(suite) }
+          .select do |suite|
+            CORE_RUNNABLES.any? { |kl| suite < kl } && suite.runnable_methods.any?
+          end
       end
 
       def sample_groups(sample_size)
@@ -27,11 +29,18 @@ module TestProf
         all_examples = suites.flat_map do |runnable|
           runnable.runnable_methods.map { |method| [runnable, method] }
         end
-        sample = all_examples.sample(sample_size)
+
+        sample = all_examples.sample(sample_size).group_by(&:first)
+        sample.transform_values! { |v| v.map(&:last) }
+
         # Filter examples by overriding #runnable_methods for all suites
         suites.each do |runnable|
-          runnable.define_singleton_method(:runnable_methods) do
-            super() & sample.select { |ex| ex.first.equal?(runnable) }.map(&:last)
+          if sample.key?(runnable)
+            runnable.define_singleton_method(:runnable_methods) do
+              super() & sample[runnable]
+            end
+          else
+            runnable.define_singleton_method(:runnable_methods) { [] }
           end
         end
       end

data/lib/test_prof/recipes/rspec/let_it_be.rb

@@ -7,6 +7,8 @@ module TestProf
   # Just like `let`, but persist the result for the whole group.
   # NOTE: Experimental and magical, for more control use `before_all`.
   module LetItBe
+    class DuplicationError < StandardError; end
+
     Modifier = Struct.new(:scope, :block) do
       def call(record, config)
         block.call(record, config)
@@ -14,6 +16,8 @@ module TestProf
     end
 
     class Configuration
+      attr_accessor :report_duplicates
+
       # Define an alias for `let_it_be` with the predefined options:
       #
       #   TestProf::LetItBe.configure do |config|
@@ -117,6 +121,8 @@ module TestProf
         instance_variable_get(:"#{PREFIX}#{identifier}")
       end
 
+      report_duplicates(identifier) if LetItBe.config.report_duplicates
+
       LetItBe.module_for(self).module_eval do
         define_method(identifier) do
           # Trying to detect the context
@@ -135,6 +141,19 @@ module TestProf
       let(identifier, &let_accessor)
     end
 
+    private def report_duplicates(identifier)
+      if instance_methods.include?(identifier) && File.basename(__FILE__) == File.basename(instance_method(identifier).source_location[0])
+        error_msg = "let_it_be(:#{identifier}) was redefined in nested group"
+        report_level = LetItBe.config.report_duplicates.to_sym
+
+        if report_level == :warn
+          ::RSpec.warn_with(error_msg)
+        elsif report_level == :raise
+          raise DuplicationError, error_msg
+        end
+      end
+    end
+
     module Freezer
       # Stoplist to prevent freezing objects and theirs associations that are defined
       # with `let_it_be`'s `freeze: false` options during deep freezing.

data/lib/test_prof/vernier.rb

@@ -19,7 +19,7 @@ module TestProf
   module Vernier
     # Vernier configuration
     class Configuration
-      attr_accessor :mode, :target, :interval
+      attr_accessor :mode, :target, :interval, :hooks
 
       def initialize
         @mode = ENV.fetch("TEST_VERNIER_MODE", :wall).to_sym
@@ -27,6 +27,7 @@ module TestProf
 
         sample_interval = ENV["TEST_VERNIER_INTERVAL"].to_i
         @interval = (sample_interval > 0) ? sample_interval : nil
+        @hooks = ENV["TEST_VERNIER_HOOKS"]&.split(",")&.map { |hook| hook.strip.to_sym }
       end
 
       def boot?
@@ -82,6 +83,7 @@ module TestProf
         options = {}
 
         options[:interval] = config.interval if config.interval
+        options[:hooks] = config.hooks if config.hooks
 
         if block_given?
           options[:mode] = config.mode

data/lib/test_prof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TestProf
-  VERSION = "1.3.2"
+  VERSION = "1.4.0.rc.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test-prof
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.4.0.rc.1
 platform: ruby
 authors:
 - Vladimir Dementyev
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-08 00:00:00.000000000 Z
+date: 2024-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -235,7 +235,7 @@ metadata:
   homepage_uri: https://test-prof.evilmartians.io/
   source_code_uri: https://github.com/test-prof/test-prof
   funding_uri: https://github.com/sponsors/test-prof
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -243,15 +243,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.4.20
-signing_key:
+rubygems_version: 3.4.19
+signing_key: 
 specification_version: 4
 summary: Ruby applications tests profiling tools
 test_files: []