test-prof 0.8.0 → 0.9.0

data/README.md

@@ -85,3 +85,7 @@ Already using TestProf? [Share your story!](https://github.com/palkan/test-prof/
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 
 [docs]: https://test-prof.evilmartians.io
+
+## Security Contact
+
+To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure.

data/lib/test_prof.rb

@@ -44,15 +44,9 @@ module TestProf
       defined?(Minitest)
     end
 
-    # Avoid issues with wrong time due to monkey-patches (e.g. timecop)
-    # See https://github.com/rspec/rspec-core/blob/v3.6.0/lib/rspec/core.rb#L147
-    #
-    # We also want to handle Timecop specificaly
-    # See https://github.com/travisjeffery/timecop/blob/master/lib/timecop/time_extensions.rb#L11
-    if Time.respond_to?(:now_without_mock_time)
-      define_method(:now, &::Time.method(:now_without_mock_time))
-    else
-      define_method(:now, &::Time.method(:now))
+    # Returns the current process time
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
     # Require gem and shows a custom

data/lib/test_prof/before_all.rb

@@ -17,7 +17,10 @@ module TestProf
 
       def begin_transaction
         raise AdapterMissing if adapter.nil?
-        adapter.begin_transaction
+
+        config.run_hooks(:begin) do
+          adapter.begin_transaction
+        end
         yield
       end
 
@@ -27,8 +30,76 @@ module TestProf
 
       def rollback_transaction
         raise AdapterMissing if adapter.nil?
-        adapter.rollback_transaction
+
+        config.run_hooks(:rollback) do
+          adapter.rollback_transaction
+        end
+      end
+
+      def config
+        @config ||= Configuration.new
       end
+
+      def configure
+        yield config
+      end
+    end
+
+    class HooksChain # :nodoc:
+      attr_reader :type, :after, :before
+
+      def initialize(type)
+        @type = type
+        @before = []
+        @after = []
+      end
+
+      def run
+        before.each(&:call)
+        yield
+        after.each(&:call)
+      end
+    end
+
+    class Configuration
+      HOOKS = %i[begin rollback].freeze
+
+      def initialize
+        @hooks = Hash.new { |h, k| h[k] = HooksChain.new(k) }
+      end
+
+      # Add `before` hook for `begin` or
+      # `rollback` operation:
+      #
+      #   config.before(:rollback) { ... }
+      def before(type)
+        validate_hook_type!(type)
+        hooks[type].before << Proc.new
+      end
+
+      # Add `after` hook for `begin` or
+      # `rollback` operation:
+      #
+      #   config.after(:begin) { ... }
+      def after(type)
+        validate_hook_type!(type)
+        hooks[type].after << Proc.new
+      end
+
+      def run_hooks(type) # :nodoc:
+        validate_hook_type!(type)
+        hooks[type].run { yield }
+      end
+
+      private
+
+      def validate_hook_type!(type)
+        return if HOOKS.include?(type)
+
+        raise ArgumentError, "Unknown hook type: #{type}. Valid types: #{HOOKS.join(", ")}"
+      end
+
+      attr_reader :hooks
     end
   end
 end

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

@@ -12,7 +12,6 @@ module TestProf
       module ActiveRecord
         class << self
           def begin_transaction
-            lock_thread!
             ::ActiveRecord::Base.connection.begin_transaction(joinable: false)
           end
 
@@ -24,19 +23,19 @@ module TestProf
             end
             ::ActiveRecord::Base.connection.rollback_transaction
           end
-
-          private
-
-          # 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
-          def lock_thread!
-            return unless ::ActiveRecord::Base.connection.pool.respond_to?(:lock_thread=)
-            ::ActiveRecord::Base.connection.pool.lock_thread = true
-          end
         end
       end
     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
+        next unless ::ActiveRecord::Base.connection.pool.respond_to?(:lock_thread=)
+        ::ActiveRecord::Base.connection.pool.lock_thread = true
+      end
+    end
   end
 end

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

@@ -1,56 +1,38 @@
 # frozen_string_literal: true
 
 require "test_prof/factory_bot"
+require "test_prof/ext/factory_bot_strategy"
 
-module TestProf::EventProf::CustomEvents
-  module FactoryCreate # :nodoc: all
-    module RunnerPatch
-      def run(strategy = @strategy)
-        return super unless strategy == :create
-        FactoryCreate.track(@name) do
-          super
-        end
-      end
-    end
-
-    class << self
-      def setup!
-        @depth = 0
-        TestProf::FactoryBot::FactoryRunner.prepend RunnerPatch
-      end
+using TestProf::FactoryBotStrategy
 
-      def track(factory)
-        @depth += 1
-        res = nil
-        begin
-          res =
-            if @depth == 1
-              ActiveSupport::Notifications.instrument(
-                "factory.create",
-                name: factory
-              ) { yield }
-            else
-              yield
-            end
-        ensure
-          @depth -= 1
-        end
-        res
-      end
+TestProf::EventProf::CustomEvents.register("factory.create") do
+  if defined?(TestProf::FactoryBot) || defined?(Fabricate)
+    if defined?(TestProf::FactoryBot)
+      TestProf::EventProf.monitor(
+        TestProf::FactoryBot::FactoryRunner,
+        "factory.create",
+        :run,
+        top_level: true,
+        guard: ->(strategy = @strategy) { strategy.create? }
+      )
     end
-  end
-end
 
-TestProf::EventProf::CustomEvents.register("factory.create") do
-  if defined? TestProf::FactoryBot
-    TestProf::EventProf::CustomEvents::FactoryCreate.setup!
+    if defined?(Fabricate)
+      TestProf::EventProf.monitor(
+        Fabricate.singleton_class,
+        "factory.create",
+        :create,
+        top_level: true
+      )
+    end
   else
-    TestProf.log(:error,
-                 <<~MSG
-                   Failed to load factory_bot / factory_girl.
+    TestProf.log(
+      :error,
+      <<~MSG
+        Failed to load factory_bot / factory_girl / fabrication.
 
-                   Make sure that any of them is in your Gemfile.
-                 MSG
-                )
+        Make sure that any of them is in your Gemfile.
+      MSG
+    )
   end
 end

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

@@ -1,41 +1,5 @@
 # frozen_string_literal: true
 
-module TestProf::EventProf::CustomEvents
-  module SidekiqInline # :nodoc: all
-    module ClientPatch
-      def raw_push(*)
-        return super unless Sidekiq::Testing.inline?
-        SidekiqInline.track { super }
-      end
-    end
-
-    class << self
-      def setup!
-        @depth = 0
-        Sidekiq::Client.prepend ClientPatch
-      end
-
-      def track
-        @depth += 1
-        res = nil
-        begin
-          res =
-            if @depth == 1
-              ActiveSupport::Notifications.instrument(
-                "sidekiq.inline"
-              ) { yield }
-            else
-              yield
-            end
-        ensure
-          @depth -= 1
-        end
-        res
-      end
-    end
-  end
-end
-
 TestProf::EventProf::CustomEvents.register("sidekiq.inline") do
   if TestProf.require(
     "sidekiq/testing",
@@ -45,6 +9,12 @@ TestProf::EventProf::CustomEvents.register("sidekiq.inline") do
       Make sure that "sidekiq" gem is in your Gemfile.
     MSG
   )
-    TestProf::EventProf::CustomEvents::SidekiqInline.setup!
+    TestProf::EventProf.monitor(
+      Sidekiq::Client,
+      "sidekiq.inline",
+      :raw_push,
+      top_level: true,
+      guard: ->(*) { Sidekiq::Testing.inline? }
+    )
   end
 end

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

@@ -1,28 +1,5 @@
 # frozen_string_literal: true
 
-module TestProf::EventProf::CustomEvents
-  module SidekiqJobs # :nodoc: all
-    module ClientPatch
-      def raw_push(*)
-        return super unless Sidekiq::Testing.inline?
-        SidekiqJobs.track { super }
-      end
-    end
-
-    class << self
-      def setup!
-        Sidekiq::Client.prepend ClientPatch
-      end
-
-      def track
-        ActiveSupport::Notifications.instrument(
-          "sidekiq.jobs"
-        ) { yield }
-      end
-    end
-  end
-end
-
 TestProf::EventProf::CustomEvents.register("sidekiq.jobs") do
   if TestProf.require(
     "sidekiq/testing",
@@ -32,7 +9,12 @@ TestProf::EventProf::CustomEvents.register("sidekiq.jobs") do
       Make sure that "sidekiq" gem is in your Gemfile.
     MSG
   )
-    TestProf::EventProf::CustomEvents::SidekiqJobs.setup!
+    TestProf::EventProf.monitor(
+      Sidekiq::Client,
+      "sidekiq.jobs",
+      :raw_push,
+      guard: ->(*) { Sidekiq::Testing.inline? }
+    )
     TestProf::EventProf.configure do |config|
       config.rank_by = :count
     end

data/lib/test_prof/event_prof/monitor.rb

@@ -4,17 +4,54 @@ module TestProf
   module EventProf
     # Wrap methods with instrumentation
     module Monitor
+      class BaseTracker
+        attr_reader :event
+
+        def initialize(event)
+          @event = event
+        end
+
+        def track
+          TestProf::EventProf.instrumenter.instrument(event) { yield }
+        end
+      end
+
+      class TopLevelTracker < BaseTracker
+        attr_reader :id
+
+        def initialize(event)
+          super
+          @id = :"event_prof_monitor_#{event}"
+          Thread.current[id] = 0
+        end
+
+        def track
+          Thread.current[id] += 1
+          res = nil
+          begin
+            res =
+              if Thread.current[id] == 1
+                super { yield }
+              else
+                yield
+              end
+          ensure
+            Thread.current[id] -= 1
+          end
+          res
+        end
+      end
+
       class << self
-        def call(mod, event, *mids)
+        def call(mod, event, *mids, guard: nil, top_level: false)
+          tracker = top_level ? TopLevelTracker.new(event) : BaseTracker.new(event)
+
           patch = Module.new do
             mids.each do |mid|
-              module_eval <<~SRC, __FILE__, __LINE__ + 1
-                def #{mid}(*)
-                  TestProf::EventProf.instrumenter.instrument(
-                    '#{event}'
-                  ) { super }
-                end
-              SRC
+              define_method(mid) do |*args, &block|
+                next super(*args, &block) unless guard.nil? || instance_exec(*args, &guard)
+                tracker.track { super(*args, &block) }
+              end
             end
           end
 

data/lib/test_prof/ext/factory_bot_strategy.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module TestProf
+  # FactoryBot 5.0 uses strategy classes for associations,
+  # older versions and top-level invocations use Symbols.
+  #
+  # This Refinement should be used FactoryRunner patches to check
+  # that strategy is :create.
+  module FactoryBotStrategy
+    refine Symbol do
+      def create?
+        self == :create
+      end
+    end
+
+    if defined?(::FactoryBot::Strategy::Create)
+      refine Class do
+        def create?
+          self <= ::FactoryBot::Strategy::Create
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/factory_doctor.rb

@@ -3,6 +3,7 @@
 require "test_prof"
 require "test_prof/factory_bot"
 require "test_prof/factory_doctor/factory_bot_patch"
+require "test_prof/factory_doctor/fabrication_patch"
 
 module TestProf
   # FactoryDoctor is a tool that helps you identify
@@ -18,7 +19,7 @@ module TestProf
       end
 
       def bad?
-        count > 0 && queries_count.zero?
+        count > 0 && queries_count.zero? && time >= FactoryDoctor.config.threshold
       end
     end
 
@@ -38,23 +39,44 @@ module TestProf
       \ASAVEPOINT
     )}xi.freeze
 
+    class Configuration
+      attr_accessor :event, :threshold
+
+      def initialize
+        # event to track for DB interactions
+        @event = ENV.fetch("FDOC_EVENT", "sql.active_record")
+        # consider result good if time wasted less then threshold
+        @threshold = ENV.fetch("FDOC_THRESHOLD", "0.01").to_f
+      end
+    end
+
     class << self
       include TestProf::Logging
 
-      attr_reader :event
       attr_reader :count, :time, :queries_count
 
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
       # Patch factory lib, init counters
-      def init(event = "sql.active_record")
-        @event = event
+      def init
         reset!
 
-        log :info, "FactoryDoctor enabled"
+        log :info, "FactoryDoctor enabled (event: \"#{config.event}\", threshold: #{config.threshold})"
 
         # Monkey-patch FactoryBot / FactoryGirl
         TestProf::FactoryBot::FactoryRunner.prepend(FactoryBotPatch) if
           defined?(TestProf::FactoryBot)
 
+        # Monkey-patch Fabrication
+        ::Fabricate.singleton_class.prepend(FabricationPatch) if
+          defined?(::Fabricate)
+
         subscribe!
 
         @stamp = ENV["FDOC_STAMP"]
@@ -122,7 +144,7 @@ module TestProf
       end
 
       def subscribe!
-        ::ActiveSupport::Notifications.subscribe(event) do |_name, _start, _finish, _id, query|
+        ::ActiveSupport::Notifications.subscribe(config.event) do |_name, _start, _finish, _id, query|
           next if ignore? || !running? || within_factory?
           next if query[:sql] =~ IGNORED_QUERIES_PATTERN
           @queries_count += 1