test-prof 1.3.0 → 1.4.4

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")
+
   FACTORY_GIRL_NAMES.find do |name, cname|
     TestProf.require(name) do
       TestProf::FactoryBot = Object.const_get(cname)

data/lib/test_prof/factory_default/fabrication_patch.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module TestProf
+  module FactoryDefault # :nodoc: all
+    module FabricationPatch
+      module DefaultExt
+        def create_default(name, overrides = {}, &block)
+          obj = ::Fabricate.create(name, overrides, &block)
+          set_fabricate_default(name, obj)
+        end
+
+        def set_fabricate_default(name, obj, **opts)
+          FactoryDefault.register(
+            name, obj,
+            preserve_attributes: FactoryDefault.config.preserve_attributes,
+            preserve_traits: FactoryDefault.config.preserve_traits,
+            **opts
+          )
+        end
+
+        def get_fabricate_default(name, **overrides)
+          FactoryDefault.get(name, nil, overrides, skip_stats: true)
+        end
+
+        def skip_fabricate_default(&block)
+          FactoryDefault.disable!(&block)
+        end
+
+        def create(name, overrides = {}, &block)
+          self.fabrication_depth += 1
+          # We do not support defaults for objects created with attribute blocks
+          return super if block
+
+          return super if fabrication_depth < 2
+
+          FactoryDefault.get(name, nil, overrides, **{}) ||
+            FactoryDefault.profiler.instrument(name, nil, overrides) { super }
+        ensure
+          self.fabrication_depth -= 1
+        end
+
+        private
+
+        def fabrication_depth
+          Thread.current[:_fab_depth_] ||= 0
+        end
+
+        def fabrication_depth=(value)
+          Thread.current[:_fab_depth_] = value
+        end
+      end
+
+      def self.patch
+        TestProf.require "fabrication" do
+          ::Fabricate.singleton_class.prepend(DefaultExt)
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/factory_default/factory_bot_patch.rb

@@ -1,19 +1,69 @@
 # frozen_string_literal: true
 
+require "test_prof/factory_bot"
+
 module TestProf
   module FactoryDefault # :nodoc: all
-    module RunnerExt
-      refine TestProf::FactoryBot::FactoryRunner do
-        attr_reader :name, :traits, :overrides
+    module FactoryBotPatch
+      if defined?(TestProf::FactoryBot::FactoryRunner)
+        module RunnerExt
+          refine TestProf::FactoryBot::FactoryRunner do
+            attr_reader :name, :traits, :overrides
+          end
+        end
+
+        using RunnerExt
+      end
+
+      module StrategyExt
+        def association(runner)
+          FactoryDefault.get(runner.name, runner.traits, runner.overrides, **{}) ||
+            FactoryDefault.profiler.instrument(runner.name, runner.traits, runner.overrides) { super }
+        end
+      end
+
+      module SyntaxExt
+        def create_default(name, *args, &block)
+          options = args.extract_options!
+          default_options = {}
+          default_options[:preserve_traits] = options.delete(:preserve_traits) if options.key?(:preserve_traits)
+          default_options[:preserve_attributes] = options.delete(:preserve_attributes) if options.key?(:preserve_attributes)
+
+          obj = TestProf::FactoryBot.create(name, *args, options, &block)
+
+          # Factory with traits
+          name = [name, *args] if args.any?
+
+          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)
+          name = name.first if name.size == 1
+          FactoryDefault.register(
+            name, obj,
+            preserve_traits: preserve_traits,
+            preserve_attributes: preserve_attributes,
+            **other
+          )
+        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
       end
-    end
 
-    using RunnerExt
+      def self.patch
+        return unless defined?(TestProf::FactoryBot)
 
-    module StrategyExt
-      def association(runner)
-        FactoryDefault.get(runner.name, runner.traits, runner.overrides) ||
-          FactoryDefault.profiler.instrument(runner.name, runner.traits, runner.overrides) { super }
+        TestProf::FactoryBot::Syntax::Methods.include SyntaxExt
+        TestProf::FactoryBot.extend SyntaxExt
+        TestProf::FactoryBot::Strategy::Create.prepend StrategyExt
+        TestProf::FactoryBot::Strategy::Build.prepend StrategyExt
+        TestProf::FactoryBot::Strategy::Stub.prepend StrategyExt
       end
     end
   end

data/lib/test_prof/factory_default.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require "test_prof/core"
-require "test_prof/factory_bot"
+
 require "test_prof/factory_default/factory_bot_patch"
+require "test_prof/factory_default/fabrication_patch"
+
 require "test_prof/ext/float_duration"
 require "test_prof/ext/active_record_refind" if defined?(::ActiveRecord::Base)
 
@@ -144,35 +146,6 @@ module TestProf
       end
     end
 
-    module DefaultSyntax # :nodoc:
-      def create_default(name, *args, &block)
-        options = args.extract_options!
-        default_options = {}
-        default_options[:preserve_traits] = options.delete(:preserve_traits) if options.key?(:preserve_traits)
-        default_options[:preserve_attributes] = options.delete(:preserve_attributes) if options.key?(:preserve_attributes)
-
-        obj = TestProf::FactoryBot.create(name, *args, options, &block)
-
-        # Factory with traits
-        name = [name, *args] if args.any?
-
-        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)
-        FactoryDefault.register(
-          name, obj,
-          preserve_traits: preserve_traits,
-          preserve_attributes: preserve_attributes,
-          **other
-        )
-      end
-
-      def skip_factory_default(&block)
-        FactoryDefault.disable!(&block)
-      end
-    end
-
     class Configuration
       attr_accessor :preserve_traits, :preserve_attributes,
         :report_summary, :report_stats,
@@ -197,11 +170,8 @@ module TestProf
       attr_reader :stats, :profiler
 
       def init
-        TestProf::FactoryBot::Syntax::Methods.include DefaultSyntax
-        TestProf::FactoryBot.extend DefaultSyntax
-        TestProf::FactoryBot::Strategy::Create.prepend StrategyExt
-        TestProf::FactoryBot::Strategy::Build.prepend StrategyExt
-        TestProf::FactoryBot::Strategy::Stub.prepend StrategyExt
+        FactoryBotPatch.patch
+        FabricationPatch.patch
 
         @profiler = config.profiling_enabled? ? Profiler.new : NoopProfiler.new
         @enabled = ENV["FACTORY_DEFAULT_DISABLED"] != "1"
@@ -236,7 +206,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 +218,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 +233,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_doctor.rb

@@ -105,10 +105,9 @@ module TestProf
       # Do not analyze code within the block
       def ignore
         @ignored = true
-        res = yield
+        yield
       ensure
         @ignored = false
-        res
       end
 
       def ignore!

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "test_prof/ext/float_duration"
+
+module TestProf::FactoryProf
+  module Printers
+    module Json  # :nodoc: all
+      class << self
+        using TestProf::FloatDuration
+        include TestProf::Logging
+
+        def dump(result, start_time:, **)
+          return log(:info, "No factories detected") if result.raw_stats == {}
+
+          outpath = TestProf.artifact_path("test-prof.result.json")
+          File.write(outpath, convert_stats(result, start_time).to_json)
+
+          log :info, "Profile results to JSON: #{outpath}"
+        end
+
+        def convert_stats(result, start_time)
+          total_run_time = TestProf.now - start_time
+          total_count = result.stats.sum { |stat| stat[:total_count] }
+          total_top_level_count = result.stats.sum { |stat| stat[:top_level_count] }
+          total_time = result.stats.sum { |stat| stat[:top_level_time] }
+          total_uniq_factories = result.stats.map { |stat| stat[:name] }.uniq.count
+
+          {
+            total_count: total_count,
+            total_top_level_count: total_top_level_count,
+            total_time: total_time.duration,
+            total_run_time: total_run_time.duration,
+            total_uniq_factories: total_uniq_factories,
+
+            stats: result.stats
+          }
+        end
+      end
+    end
+  end
+end

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,36 @@ 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]
+            next if stat[:total_count] < threshold
 
-            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])
+            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|
+              next if variation_stat[:total_count] < threshold
+
+              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

@@ -3,6 +3,7 @@
 require "test_prof/factory_prof/printers/simple"
 require "test_prof/factory_prof/printers/flamegraph"
 require "test_prof/factory_prof/printers/nate_heckler"
+require "test_prof/factory_prof/printers/json"
 require "test_prof/factory_prof/factory_builders/factory_bot"
 require "test_prof/factory_prof/factory_builders/fabrication"
 
@@ -15,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
@@ -25,15 +26,24 @@ module TestProf
             Printers::Flamegraph
           when "nate_heckler"
             Printers::NateHeckler
+          when "json"
+            Printers::Json
           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
       def flamegraph?
         @mode == :flamegraph
       end
+
+      def include_variations?
+        @include_variations == true
+      end
     end
 
     class Result # :nodoc:
@@ -46,8 +56,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
@@ -57,14 +73,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
@@ -112,7 +120,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
@@ -128,20 +136,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)]) if config.include_variations?
         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) if config.include_variations?
           @depth -= 1
           flush_stack if @depth.zero?
         end
@@ -149,21 +156,46 @@ module TestProf
 
       private
 
+      def variation_name(variation)
+        return "-" if variation.empty?
+        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