test-prof 1.2.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13127b82bf827a56e15c8d060ff5a8e5be791e16deea31e899d88ecd7b76bb38
-  data.tar.gz: 1ae017bc058b3017355c75fd871c17aad9ec3649f7b982af062d606b93d9fe2c
+  metadata.gz: '0678bc968a267ebeece00e12338f6408683140428ecdd041ece64c70e6bb91c0'
+  data.tar.gz: 3ab5bc88b7b5dea557847f05a16d7fc3e4c6c9212115cd16984a56b7dd7b1737
 SHA512:
-  metadata.gz: b272b01aca1fb3bf9328fcd97fc148f5f329acf66650337071568aff6e20e1f3f95c066295df4777a7bd401976879bdddb3ff43fb2ce5093bca261fe65c07a94
-  data.tar.gz: 309644b36e328286ea52705196daa99e8af2f5237cf27f33ffa0091961f642eb29da73bcf48cb05e51896e3bfe9d709a1c08cbc1cfcd9abae1b429674a98fb2b
+  metadata.gz: 5b32e7e689cef27e72ce5f7e65ca0463bae7b83dfcaf77eba17aa0cc9bae1b74d6223b6b141e805debb7640b74b75be34bf238a8f41cb3efaf0386929935d814
+  data.tar.gz: 34200774bc30c39acc48109fbc5031fd8f48abb5f7175799a1e1bbfd7650a11a441c9ba63638bf186d78ef5cd15b7b33e64782c781a7f28bd43e43cb6d1e5588

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## master (unreleased)
 
+## 1.3.0 (2023-11-21)
+
+- Add Vernier integration. ([@palkan][])
+
+- StackProf uses JSON format by default. ([@palkan][])
+
+- MemoryProf ia added. ([@Vankiru][])
+
+## 1.2.3 (2023-09-11)
+
+- Minor fixes and dependencies upgrades.
+
 ## 1.2.2 (2023-06-27)
 
 - Ignore inaccessible connection pools in `before_all`. ([@bf4][])
@@ -156,7 +168,7 @@ And for every test run see the overall factories usage:
 
 ## 1.0.0.rc2 (2021-01-06)
 
-- Make Rails fixtures accesible in `before_all`. ([@palkan][])
+- Make Rails fixtures accessible in `before_all`. ([@palkan][])
 
 You can load and access fixtures when explicitly enabling them via `before_all(setup_fixtures: true, &block)`.
 
@@ -217,7 +229,7 @@ end
 
   See more in [#181](https://github.com/test-prof/test-prof/issues/181).
 
-- Adds the ability to define stackprof's interval sampling by using `TEST_STACK_PROF_INTERVAL` env variable ([@LynxEyes][])
+- Adds the ability to define stackprof interval sampling by using `TEST_STACK_PROF_INTERVAL` env variable ([@LynxEyes][])
 
   Now you can use `$ TEST_STACK_PROF=1 TEST_STACK_PROF_INTERVAL=10000 rspec` to define a custom interval (in microseconds).
 
@@ -363,3 +375,4 @@ See [changelog](https://github.com/test-prof/test-prof/blob/v0.8.0/CHANGELOG.md)
 [@cbarton]: https://github.com/cbarton
 [@peret]: https://github.com/peret
 [@bf4]: https://github.com/bf4
+[@Vankiru]: https://github.com/Vankiru

data/README.md

@@ -93,7 +93,7 @@ Supported RSpec version (for RSpec features only): >= 3.5.0 (for older RSpec ver
 
 Check out our [docs][].
 
-## What's next?
+## What's next
 
 Have an idea? [Propose](https://github.com/test-prof/test-prof/issues/new) a feature request!
 

data/lib/minitest/test_prof_plugin.rb

@@ -2,6 +2,7 @@
 
 require "test_prof/event_prof/minitest"
 require "test_prof/factory_doctor/minitest"
+require "test_prof/memory_prof/minitest"
 
 module Minitest # :nodoc:
   module TestProf # :nodoc:
@@ -13,6 +14,8 @@ module Minitest # :nodoc:
         opts[:per_example] = true if ENV["EVENT_PROF_EXAMPLES"]
         opts[:fdoc] = true if ENV["FDOC"]
         opts[:sample] = true if ENV["SAMPLE"] || ENV["SAMPLE_GROUPS"]
+        opts[:mem_prof_mode] = ENV["TEST_MEM_PROF"] if ENV["TEST_MEM_PROF"]
+        opts[:mem_prof_top_count] = ENV["TEST_MEM_PROF_COUNT"] if ENV["TEST_MEM_PROF_COUNT"]
       end
     end
   end
@@ -33,6 +36,12 @@ module Minitest # :nodoc:
     opts.on "--factory-doctor", TrueClass, "Enable Factory Doctor for your examples" do |flag|
       options[:fdoc] = flag
     end
+    opts.on "--mem-prof=MODE", "Enable MemoryProf for your examples" do |flag|
+      options[:mem_prof_mode] = flag
+    end
+    opts.on "--mem-prof-top-count=N", "Limits MemoryProf results with N groups/examples" do |flag|
+      options[:mem_prof_top_count] = flag
+    end
   end
 
   def self.plugin_test_prof_init(options)
@@ -40,6 +49,7 @@ module Minitest # :nodoc:
 
     reporter << TestProf::EventProfReporter.new(options[:io], options) if options[:event]
     reporter << TestProf::FactoryDoctorReporter.new(options[:io], options) if options[:fdoc]
+    reporter << TestProf::MemoryProfReporter.new(options[:io], options) if options[:mem_prof_mode]
 
     ::TestProf::MinitestSample.call if options[:sample]
   end

data/lib/test_prof/any_fixture/dump/sqlite.rb

@@ -18,7 +18,7 @@ module TestProf
         end
 
         def compile_sql(sql, binds)
-          sql.gsub(/\?/) { binds.shift.gsub("\n", "' || char(10) || '") }
+          sql.gsub("?") { binds.shift.gsub("\n", "' || char(10) || '") }
         end
 
         def import(path)

data/lib/test_prof/any_fixture.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "test_prof"
+require "test_prof/core"
 require "test_prof/ext/float_duration"
 require "test_prof/any_fixture/dump"
 

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

@@ -5,10 +5,12 @@ module TestProf
     module Adapters
       # ActiveRecord adapter for `before_all`
       module ActiveRecord
+        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.filter_map { |pool|
+              ::ActiveRecord::Base.connection_handler.connection_pool_list(*POOL_ARGS).filter_map { |pool|
                 begin
                   pool.connection
                 rescue *pool_connection_errors => error

data/lib/test_prof/before_all.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "test_prof"
+require "test_prof/core"
 
 module TestProf
   # `before_all` helper configuration

data/lib/test_prof/core.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "logger"
+
+require "test_prof/logging"
+require "test_prof/utils"
+
+# Ruby applications tests profiling tools.
+#
+# Contains tools to analyze factories usage, integrate with Ruby profilers,
+# profile your examples using ActiveSupport notifications (if any) and
+# statically analyze your code with custom RuboCop cops.
+#
+# Example usage:
+#
+#   require 'test_prof'
+#
+#   # Activate a tool by providing environment variable, e.g.
+#   TEST_RUBY_PROF=1 rspec ...
+#
+#   # or manually in your code
+#   TestProf::RubyProf.run
+#
+# See other modules for more examples.
+module TestProf
+  class << self
+    include Logging
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield config
+    end
+
+    # Returns true if we're inside RSpec
+    def rspec?
+      defined?(RSpec::Core)
+    end
+
+    # Returns true if we're inside Minitest
+    def minitest?
+      defined?(Minitest)
+    end
+
+    # Returns true if Spring is used and not disabled
+    def spring?
+      # See https://github.com/rails/spring/blob/577cf01f232bb6dbd0ade7df2df2ac209697e741/lib/spring/binstub.rb
+      disabled = ENV["DISABLE_SPRING"]
+      defined?(::Spring::Application) && (disabled.nil? || disabled.empty? || disabled == "0")
+    end
+
+    # Returns the current process time
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    # Require gem and shows a custom
+    # message if it fails to load
+    def require(gem_name, msg = nil)
+      Kernel.require gem_name
+      block_given? ? yield : true
+    rescue LoadError
+      log(:error, msg) if msg
+      false
+    end
+
+    # Run block only if provided env var is present and
+    # equal to the provided value (if any).
+    # Contains workaround for applications using Spring.
+    def activate(env_var, val = nil)
+      if spring?
+        notify_spring_detected
+        ::Spring.after_fork do
+          activate!(env_var, val) do
+            notify_spring_activate env_var
+            yield
+          end
+        end
+      else
+        activate!(env_var, val) { yield }
+      end
+    end
+
+    # Return absolute path to asset
+    def asset_path(filename)
+      ::File.expand_path(filename, ::File.join(::File.dirname(__FILE__), "..", "..", "assets"))
+    end
+
+    # Return a path to store artifact
+    def artifact_path(filename)
+      create_artifact_dir
+
+      with_timestamps(
+        ::File.join(
+          config.output_dir,
+          with_report_suffix(
+            filename
+          )
+        )
+      )
+    end
+
+    def create_artifact_dir
+      FileUtils.mkdir_p(config.output_dir)[0]
+    end
+
+    private
+
+    def activate!(env_var, val)
+      yield if ENV[env_var] && (val.nil? || val === ENV[env_var])
+    end
+
+    def with_timestamps(path)
+      return path unless config.timestamps?
+      timestamps = "-#{now.to_i}"
+      "#{path.sub(/\.\w+$/, "")}#{timestamps}#{::File.extname(path)}"
+    end
+
+    def with_report_suffix(path)
+      return path if config.report_suffix.nil?
+
+      "#{path.sub(/\.\w+$/, "")}-#{config.report_suffix}#{::File.extname(path)}"
+    end
+
+    def notify_spring_detected
+      return if instance_variable_defined?(:@spring_notified)
+      log :info, "Spring detected"
+      @spring_notified = true
+    end
+
+    def notify_spring_activate(env_var)
+      log :info, "Activating #{env_var} with `Spring.after_fork`"
+    end
+  end
+
+  # TestProf configuration
+  class Configuration
+    attr_accessor :output, # IO to write logs
+      :color, # Whether to colorize output or not
+      :output_dir, # Directory to store artifacts
+      :timestamps, # Whether to use timestamped names for artifacts,
+      :report_suffix # Custom suffix for reports/artifacts
+
+    def initialize
+      @output = $stdout
+      @color = true
+      @output_dir = "tmp/test_prof"
+      @timestamps = false
+      @report_suffix = ENV["TEST_PROF_REPORT"]
+    end
+
+    def color?
+      color == true && output.is_a?(IO) && output.tty?
+    end
+
+    def timestamps?
+      timestamps == true
+    end
+
+    def logger
+      @logger ||= Logger.new(output, formatter: Logging::Formatter.new)
+    end
+  end
+end

data/lib/test_prof/factory_all_stub.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "test_prof"
+require "test_prof/core"
 require "test_prof/factory_bot"
 require "test_prof/factory_all_stub/factory_bot_patch"
 

data/lib/test_prof/factory_default.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "test_prof"
+require "test_prof/core"
 require "test_prof/factory_bot"
 require "test_prof/factory_default/factory_bot_patch"
 require "test_prof/ext/float_duration"

data/lib/test_prof/memory_prof/minitest.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "minitest/base_reporter"
+
+module Minitest
+  module TestProf
+    class MemoryProfReporter < BaseReporter # :nodoc:
+      attr_reader :tracker, :printer, :current_example
+
+      def initialize(io = $stdout, options = {})
+        super
+
+        configure_profiler(options)
+
+        @tracker = ::TestProf::MemoryProf.tracker
+        @printer = ::TestProf::MemoryProf.printer(tracker)
+
+        @current_example = nil
+      end
+
+      def prerecord(group, example)
+        set_current_example(group, example)
+        tracker.example_started(current_example)
+      end
+
+      def record(example)
+        tracker.example_finished(current_example)
+      end
+
+      def start
+        tracker.start
+      end
+
+      def report
+        tracker.finish
+        printer.print
+      end
+
+      private
+
+      def set_current_example(group, example)
+        @current_example = {
+          name: example.gsub(/^test_(?:\d+_)?/, ""),
+          location: location_with_line_number(group, example)
+        }
+      end
+
+      def configure_profiler(options)
+        ::TestProf::MemoryProf.configure do |config|
+          config.mode = options[:mem_prof_mode]
+          config.top_count = options[:mem_prof_top_count] if options[:mem_prof_top_count]
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/memory_prof/printer/number_to_human.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module TestProf
+  module MemoryProf
+    class Printer
+      module NumberToHuman
+        BASE = 1024
+        UNITS = %w[B KB MB GB TB PB EB ZB]
+
+        class << self
+          def convert(number)
+            exponent = exponent(number)
+            human_size = number.to_f / (BASE**exponent)
+
+            "#{round(human_size)}#{UNITS[exponent]}"
+          end
+
+          private
+
+          def exponent(number)
+            return 0 unless number.positive?
+
+            max = UNITS.size - 1
+
+            exponent = (Math.log(number) / Math.log(BASE)).to_i
+            (exponent > max) ? max : exponent
+          end
+
+          def round(number)
+            if integer?(number)
+              number.round
+            else
+              number.round(2)
+            end
+          end
+
+          def integer?(number)
+            number.round == number
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/memory_prof/printer.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "test_prof/memory_prof/printer/number_to_human"
+require "test_prof/ext/string_truncate"
+
+module TestProf
+  module MemoryProf
+    class Printer
+      include Logging
+      using StringTruncate
+
+      def initialize(tracker)
+        @tracker = tracker
+      end
+
+      def print
+        messages = [
+          "MemoryProf results\n\n",
+          print_total,
+          print_block("groups", tracker.groups),
+          print_block("examples", tracker.examples)
+        ]
+
+        log :info, messages.join
+      end
+
+      private
+
+      attr_reader :tracker
+
+      def print_block(name, items)
+        return if items.empty?
+
+        <<~GROUP
+          Top #{tracker.top_count} #{name} (by #{mode}):
+
+          #{print_items(items)}
+        GROUP
+      end
+
+      def print_items(items)
+        messages =
+          items.map do |item|
+            <<~ITEM
+              #{item[:name].truncate(30)} (#{item[:location]}) – +#{memory_amount(item)} (#{memory_percentage(item)}%)
+            ITEM
+          end
+
+        messages.join
+      end
+
+      def memory_percentage(item)
+        (100.0 * item[:memory] / tracker.total_memory).round(2)
+      end
+
+      def number_to_human(value)
+        NumberToHuman.convert(value)
+      end
+    end
+
+    class AllocPrinter < Printer
+      private
+
+      def mode
+        "allocations"
+      end
+
+      def print_total
+        "Total allocations: #{tracker.total_memory}\n\n"
+      end
+
+      def memory_amount(item)
+        item[:memory]
+      end
+    end
+
+    class RssPrinter < Printer
+      private
+
+      def mode
+        "RSS"
+      end
+
+      def print_total
+        "Final RSS: #{number_to_human(tracker.total_memory)}\n\n"
+      end
+
+      def memory_amount(item)
+        number_to_human(item[:memory])
+      end
+    end
+  end
+end

data/lib/test_prof/memory_prof/rspec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module TestProf
+  module MemoryProf
+    class RSpecListener
+      NOTIFICATIONS = %i[
+        example_started
+        example_finished
+        example_group_started
+        example_group_finished
+      ].freeze
+
+      attr_reader :tracker, :printer
+
+      def initialize
+        @tracker = MemoryProf.tracker
+        @printer = MemoryProf.printer(tracker)
+
+        @tracker.start
+      end
+
+      def example_started(notification)
+        tracker.example_started(example(notification))
+      end
+
+      def example_finished(notification)
+        tracker.example_finished(example(notification))
+      end
+
+      def example_group_started(notification)
+        tracker.group_started(group(notification))
+      end
+
+      def example_group_finished(notification)
+        tracker.group_finished(group(notification))
+      end
+
+      def report
+        tracker.finish
+        printer.print
+      end
+
+      private
+
+      def example(notification)
+        {
+          name: notification.example.description,
+          location: notification.example.metadata[:location]
+        }
+      end
+
+      def group(notification)
+        {
+          name: notification.group.description,
+          location: notification.group.metadata[:location]
+        }
+      end
+    end
+  end
+end
+
+TestProf.activate("TEST_MEM_PROF") do
+  RSpec.configure do |config|
+    listener = nil
+
+    config.before(:suite) do
+      listener = TestProf::MemoryProf::RSpecListener.new
+
+      config.reporter.register_listener(
+        listener, *TestProf::MemoryProf::RSpecListener::NOTIFICATIONS
+      )
+    end
+
+    config.after(:suite) { listener&.report }
+  end
+end