test-prof 1.2.3 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9571b8fb7edc3bb1f92d9a6db079791a97c3cbeb11a29763ddc3e9f88bd5780a
-  data.tar.gz: 4011afa256c8a5f250a6a62e9745ed254f5fe020a366e3b3e4c0a91afb227d68
+  metadata.gz: '0678bc968a267ebeece00e12338f6408683140428ecdd041ece64c70e6bb91c0'
+  data.tar.gz: 3ab5bc88b7b5dea557847f05a16d7fc3e4c6c9212115cd16984a56b7dd7b1737
 SHA512:
-  metadata.gz: 9008e4dbd6131efde863a100447d0658663cfbea0486e3043664ddadff097f652230ddb162ee85893883eaf49c54ddeba806ba30563199857848466786e91d34
-  data.tar.gz: f86145f0d6539f6de7b3cedd315583d977df01e7e64ff22c8300bbc7f29bfd946e9f738d3b3388696c3344a8ab9e444371993e90b79f204cacf06846d314b930
+  metadata.gz: 5b32e7e689cef27e72ce5f7e65ca0463bae7b83dfcaf77eba17aa0cc9bae1b74d6223b6b141e805debb7640b74b75be34bf238a8f41cb3efaf0386929935d814
+  data.tar.gz: 34200774bc30c39acc48109fbc5031fd8f48abb5f7175799a1e1bbfd7650a11a441c9ba63638bf186d78ef5cd15b7b33e64782c781a7f28bd43e43cb6d1e5588

data/CHANGELOG.md

@@ -2,9 +2,17 @@
 
 ## 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 dependecies upgrades.
+- Minor fixes and dependencies upgrades.
 
 ## 1.2.2 (2023-06-27)
 
@@ -160,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)`.
 
@@ -221,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).
 
@@ -367,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/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/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

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module TestProf
+  module MemoryProf
+    class Tracker
+      # LinkedList is a linked list that track memory usage for individual examples/groups.
+      # A list node (`LinkedListNode`) represents an example/group and its memory usage info:
+      #
+      # * memory_at_start - the amount of memory at the start of an example/group
+      # * memory_at_finish - the amount of memory at the end of an example/group
+      # * nested_memory - the amount of memory allocated by examples/groups defined inside a group
+      # * previous - a link to the previous node
+      #
+      # Each node has a link to its previous node, and the head node points to the current example/group.
+      # If we picture a linked list as a tree with root being the top level group and leaves being
+      # current examples/groups, then the head node will always point to a leaf in that tree.
+      #
+      # For example, if we have the following spec:
+      #
+      #   describe Question do
+      #     decribe "#publish" do
+      #       context "when not published" do
+      #         it "makes the question visible" do
+      #           ...
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # At the moment when rspec is executing the example, the list has the following structure
+      # (^ denotes the head node):
+      #
+      #    ^"makes the question visible" ->  "when not published" -> "#publish" -> Question
+      #
+      # LinkedList supports two method for working with it:
+      #
+      #  * add_node – adds a node to the beginig of the list. At this point an example or group
+      #    has started and we track how much memory has already been used.
+      #  * remove_node – removes and returns the head node from the list. It means that the node
+      #    example/group has finished and it is time to calculate its memory usage.
+      #
+      # When we remove a node we add its total_memory to the previous node.nested_memory, thus
+      # gradually tracking the amount of memory used by nested examples inside a group.
+      #
+      # In the example above, after we remove the node "makes the question visible", we add its total
+      # memory usage to nested_memory of the "when not published" node. If the "when not published"
+      # group contains other examples or sub-groups, their total_memory will also be added to
+      # "when not published" nested_memory. So when the group finishes we will have the total amount
+      # of memory used by its nested examples/groups, and thus we will be able to calculate the memory
+      # used by hooks and other code inside a group by subtracting nested_memory from total_memory.
+      class LinkedList
+        attr_reader :head
+
+        def initialize(memory_at_start)
+          add_node(:total, memory_at_start)
+        end
+
+        def add_node(item, memory_at_start)
+          @head = LinkedListNode.new(
+            item: item,
+            previous: head,
+            memory_at_start: memory_at_start
+          )
+        end
+
+        def remove_node(item, memory_at_finish)
+          return if head.item != item
+          head.finish(memory_at_finish)
+
+          current = head
+          @head = head.previous
+
+          current
+        end
+      end
+
+      class LinkedListNode
+        attr_reader :item, :previous, :memory_at_start, :memory_at_finish, :nested_memory
+
+        def initialize(item:, memory_at_start:, previous:)
+          @item = item
+          @previous = previous
+
+          @memory_at_start = memory_at_start || 0
+          @memory_at_finish = nil
+          @nested_memory = 0
+        end
+
+        def total_memory
+          return 0 if memory_at_finish.nil?
+          # It seems that on Windows Minitest may release a lot of memory to
+          # the OS when it finishes and executes #report, leading to memory_at_finish
+          # being less than memory_at_start. In this case we return nested_memory
+          # which does not account for the memory used in `after` hooks, but it
+          # is better than nothing.
+          return nested_memory if memory_at_start > memory_at_finish
+
+          memory_at_finish - memory_at_start
+        end
+
+        def hooks_memory
+          total_memory - nested_memory
+        end
+
+        def finish(memory_at_finish)
+          @memory_at_finish = memory_at_finish
+
+          previous&.add_nested(self)
+        end
+
+        protected
+
+        def add_nested(node)
+          @nested_memory += node.total_memory
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module TestProf
+  module MemoryProf
+    class Tracker
+      module RssTool
+        class ProcFS
+          def initialize
+            @statm = File.open("/proc/#{$$}/statm", "r")
+            @page_size = get_page_size
+          end
+
+          def track
+            @statm.seek(0)
+            @statm.gets.split(/\s/)[1].to_i * @page_size
+          end
+
+          private
+
+          def get_page_size
+            [
+              -> {
+                require "etc"
+                Etc.sysconf(Etc::SC_PAGE_SIZE)
+              },
+              -> { `getconf PAGE_SIZE`.to_i },
+              -> { 0x1000 }
+            ].each do |strategy|
+              page_size = begin
+                strategy.call
+              rescue
+                next
+              end
+              return page_size
+            end
+          end
+        end
+
+        class PS
+          def track
+            `ps -o rss -p #{$$}`.strip.split.last.to_i * 1024
+          end
+        end
+
+        class GetProcess
+          def track
+            command.strip.split.last.to_i
+          end
+
+          private
+
+          def command
+            `powershell -Command "Get-Process -Id #{$$} | select WS"`
+          end
+        end
+
+        TOOLS = {
+          linux: ProcFS,
+          macosx: PS,
+          unix: PS,
+          windows: GetProcess
+        }.freeze
+
+        class << self
+          def tool
+            TOOLS[os_type]&.new
+          end
+
+          def os_type
+            case RbConfig::CONFIG["host_os"]
+            when /linux/
+              :linux
+            when /darwin|mac os/
+              :macosx
+            when /solaris|bsd/
+              :unix
+            when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+              :windows
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/memory_prof/tracker.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "test_prof/memory_prof/tracker/linked_list"
+require "test_prof/memory_prof/tracker/rss_tool"
+
+module TestProf
+  module MemoryProf
+    # Tracker is responsible for tracking memory usage and determining
+    # the top n examples and groups. There are two types of trackers:
+    # AllocTracker and RssTracker.
+    #
+    # A tracker consists of four main parts:
+    #  * list - a linked list that is being used to track memmory for individual groups/examples.
+    #    list is an instance of LinkedList (for more info see tracker/linked_list.rb)
+    #  * examples – the top n examples, an instance of Utils::SizedOrderedSet.
+    #  * groups – the top n groups, an instance of Utils::SizedOrderedSet.
+    #  * track - a method that fetches the amount of memory in use at a certain point.
+    class Tracker
+      attr_reader :top_count, :examples, :groups, :total_memory, :list
+
+      def initialize(top_count)
+        raise "Your Ruby Engine or OS is not supported" unless supported?
+
+        @top_count = top_count
+
+        @examples = Utils::SizedOrderedSet.new(top_count, sort_by: :memory)
+        @groups = Utils::SizedOrderedSet.new(top_count, sort_by: :memory)
+      end
+
+      def start
+        @list = LinkedList.new(track)
+      end
+
+      def finish
+        node = list.remove_node(:total, track)
+        @total_memory = node.total_memory
+      end
+
+      def example_started(example)
+        list.add_node(example, track)
+      end
+
+      def example_finished(example)
+        node = list.remove_node(example, track)
+        examples << {**example, memory: node.total_memory}
+      end
+
+      def group_started(group)
+        list.add_node(group, track)
+      end
+
+      def group_finished(group)
+        node = list.remove_node(group, track)
+        groups << {**group, memory: node.hooks_memory}
+      end
+    end
+
+    class AllocTracker < Tracker
+      def track
+        GC.stat[:total_allocated_objects]
+      end
+
+      def supported?
+        RUBY_ENGINE != "jruby"
+      end
+    end
+
+    class RssTracker < Tracker
+      def initialize(top_count)
+        @rss_tool = RssTool.tool
+
+        super
+      end
+
+      def track
+        @rss_tool.track
+      end
+
+      def supported?
+        !!@rss_tool
+      end
+    end
+  end
+end

data/lib/test_prof/memory_prof.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "test_prof/memory_prof/tracker"
+require "test_prof/memory_prof/printer"
+
+module TestProf
+  # MemoryProf can help in detecting test examples causing memory spikes.
+  # It supports two metrics: RSS and allocations.
+  #
+  # Example:
+  #
+  #   TEST_MEM_PROF='rss' rspec ...
+  #   TEST_MEM_PROF='alloc' 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`:
+  #
+  #   TEST_MEM_PROF='rss' TEST_MEM_PROF_COUNT=10 rspec ...
+  #
+  # The examples block shows the amount of memory used by each example, and the groups
+  # block displays the memory allocated by other code defined in the groups. For example,
+  # RSpec groups may include heavy `before(:all)` (or `before_all`) setup blocks, so it is
+  # helpful to see which groups use the most amount of memory outside of their examples.
+
+  module MemoryProf
+    # MemoryProf configuration
+    class Configuration
+      attr_reader :mode, :top_count
+
+      def initialize
+        self.mode = ENV["TEST_MEM_PROF"]
+        self.top_count = ENV["TEST_MEM_PROF_COUNT"]
+      end
+
+      def mode=(value)
+        @mode = (value == "alloc") ? :alloc : :rss
+      end
+
+      def top_count=(value)
+        @top_count = value.to_i
+        @top_count = 5 unless @top_count.positive?
+      end
+    end
+
+    class << self
+      TRACKERS = {
+        alloc: AllocTracker,
+        rss: RssTracker
+      }.freeze
+
+      PRINTERS = {
+        alloc: AllocPrinter,
+        rss: RssPrinter
+      }.freeze
+
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
+      def tracker
+        tracker = TRACKERS[config.mode]
+        tracker.new(config.top_count)
+      end
+
+      def printer(tracker)
+        printer = PRINTERS[config.mode]
+        printer.new(tracker)
+      end
+    end
+  end
+end
+
+require "test_prof/memory_prof/rspec" if TestProf.rspec?
+require "test_prof/memory_prof/minitest" if TestProf.minitest?

data/lib/test_prof/stack_prof/rspec.rb

@@ -19,12 +19,13 @@ module TestProf
 
       def example_started(notification)
         return unless profile?(notification.example)
+
         notification.example.metadata[:sprof_report] = TestProf::StackProf.profile
       end
 
       def example_finished(notification)
         return unless profile?(notification.example)
-        return unless notification.example.metadata[:sprof_report] == false
+        return if notification.example.metadata[:sprof_report] == false
 
         TestProf::StackProf.dump(
           self.class.report_name_generator.call(notification.example)

data/lib/test_prof/stack_prof.rb

@@ -33,7 +33,7 @@ module TestProf
           if FORMATS.include?(ENV["TEST_STACK_PROF_FORMAT"])
             ENV["TEST_STACK_PROF_FORMAT"]
           else
-            "html"
+            "json"
           end
 
         sample_interval = ENV["TEST_STACK_PROF_INTERVAL"].to_i
@@ -81,9 +81,9 @@ module TestProf
       def profile(name = nil)
         if locked?
           log :warn, <<~MSG
-            StackProf is activated globally, you cannot generate per-example report.
+            StackProf has been already activated.
 
-            Make sure you haven't set the TEST_STACK_PROF environmental variable.
+            Make sure you have not set the TEST_STACK_PROF environmental variable.
           MSG
           return false
         end

data/lib/test_prof/utils/sized_ordered_set.rb

@@ -53,6 +53,10 @@ module TestProf
         data.size
       end
 
+      def empty?
+        size.zero?
+      end
+
       def to_a
         data.dup
       end

data/lib/test_prof/vernier/rspec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "test_prof/utils/rspec"
+
+module TestProf
+  module Vernier
+    # Reporter for RSpec to profile specific examples with Vernier
+    class Listener # :nodoc:
+      class << self
+        attr_accessor :report_name_generator
+      end
+
+      self.report_name_generator = Utils::RSpec.method(:example_to_filename)
+
+      NOTIFICATIONS = %i[
+        example_started
+        example_finished
+      ].freeze
+
+      def example_started(notification)
+        return unless profile?(notification.example)
+        notification.example.metadata[:vernier_collector] = TestProf::Vernier.profile
+      end
+
+      def example_finished(notification)
+        return unless profile?(notification.example)
+        return unless notification.example.metadata[:vernier_collector]
+
+        TestProf::Vernier.dump(
+          notification.example.metadata[:vernier_collector],
+          self.class.report_name_generator.call(notification.example)
+        )
+      end
+
+      private
+
+      def profile?(example)
+        example.metadata.key?(:vernier)
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    listener = TestProf::Vernier::Listener.new
+
+    config.reporter.register_listener(
+      listener, *TestProf::Vernier::Listener::NOTIFICATIONS
+    )
+  end
+end
+
+# Handle boot profiling
+RSpec.configure do |config|
+  config.append_before(:suite) do
+    TestProf::Vernier.dump(TestProf::Vernier.default_collector, "boot") if TestProf::Vernier.config.boot?
+  end
+end

data/lib/test_prof/vernier.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module TestProf
+  # Vernier wrapper.
+  #
+  # Has 2 modes: global and per-example.
+  #
+  # Example:
+  #
+  #   # To activate global profiling you can use env variable
+  #   TEST_VERNIER=1 rspec ...
+  #
+  # To profile a specific examples add :vernier tag to it:
+  #
+  #   it "is doing heavy stuff", :vernier do
+  #     ...
+  #   end
+  #
+  module Vernier
+    # Vernier configuration
+    class Configuration
+      attr_accessor :mode, :target, :interval
+
+      def initialize
+        @mode = ENV.fetch("TEST_VERNIER_MODE", :wall).to_sym
+        @target = (ENV["TEST_VERNIER"] == "boot") ? :boot : :suite
+
+        sample_interval = ENV["TEST_VERNIER_INTERVAL"].to_i
+        @interval = (sample_interval > 0) ? sample_interval : nil
+      end
+
+      def boot?
+        target == :boot
+      end
+
+      def suite?
+        target == :suite
+      end
+    end
+
+    class << self
+      include Logging
+
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
+      attr_reader :default_collector
+
+      # Run Vernier and automatically dump
+      # a report when the process exits or when the application is booted.
+      def run
+        collector = profile
+        return unless collector
+
+        @locked = true
+        @default_collector = collector
+
+        log :info, "Vernier enabled globally: " \
+                   "mode – #{config.mode}, target – #{config.target}"
+
+        at_exit { dump(collector, "total") } if config.suite?
+      end
+
+      def profile(name = nil)
+        if locked?
+          log :warn, <<~MSG
+            Vernier has been already activated.
+
+            Make sure you do not have the TEST_VERNIER environmental variable set somewhere.
+          MSG
+
+          return false
+        end
+
+        return false unless init_vernier
+
+        options = {}
+
+        options[:interval] = config.interval if config.interval
+
+        if block_given?
+          options[:mode] = config.mode
+          options[:out] = build_path(name)
+          ::Vernier.trace(**options) { yield }
+        else
+          collector = ::Vernier::Collector.new(config.mode, **options)
+          collector.start
+
+          collector
+        end
+      end
+
+      def dump(collector, name)
+        result = collector.stop
+
+        path = build_path(name)
+
+        File.write(path, ::Vernier::Output::Firefox.new(result).output)
+
+        log :info, "Vernier report generated: #{path}"
+      end
+
+      private
+
+      def build_path(name)
+        TestProf.artifact_path(
+          "vernier-report-#{config.mode}-#{name}.json"
+        )
+      end
+
+      def locked?
+        @locked == true
+      end
+
+      def init_vernier
+        return @initialized if instance_variable_defined?(:@initialized)
+        @locked = false
+        @initialized = TestProf.require(
+          "vernier",
+          <<~MSG
+            Please, install 'vernier' first:
+               # Gemfile
+              gem 'vernier', '>= 0.3.0', require: false
+          MSG
+        ) { check_vernier_version }
+      end
+
+      def check_vernier_version
+        if Utils.verify_gem_version("vernier", at_least: "0.3.0")
+          true
+        else
+          log :error, <<~MSG
+            Please, upgrade 'vernier' to version >= 0.3.0.
+          MSG
+          false
+        end
+      end
+    end
+  end
+end
+
+require "test_prof/vernier/rspec" if TestProf.rspec?
+
+# Hook to run Vernier globally
+TestProf.activate("TEST_VERNIER") do
+  TestProf::Vernier.run
+end

data/lib/test_prof/version.rb

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

data/lib/test_prof.rb

@@ -5,9 +5,11 @@ require "test_prof/core"
 
 require "test_prof/ruby_prof"
 require "test_prof/stack_prof"
+require "test_prof/vernier"
 require "test_prof/event_prof"
 require "test_prof/factory_doctor"
 require "test_prof/factory_prof"
+require "test_prof/memory_prof"
 require "test_prof/rspec_stamp"
 require "test_prof/tag_prof"
 require "test_prof/rspec_dissect" if TestProf.rspec?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test-prof
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.3.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-12 00:00:00.000000000 Z
+date: 2023-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -180,6 +180,14 @@ files:
 - lib/test_prof/factory_prof/printers/nate_heckler.rb
 - lib/test_prof/factory_prof/printers/simple.rb
 - lib/test_prof/logging.rb
+- lib/test_prof/memory_prof.rb
+- lib/test_prof/memory_prof/minitest.rb
+- lib/test_prof/memory_prof/printer.rb
+- lib/test_prof/memory_prof/printer/number_to_human.rb
+- lib/test_prof/memory_prof/rspec.rb
+- lib/test_prof/memory_prof/tracker.rb
+- lib/test_prof/memory_prof/tracker/linked_list.rb
+- lib/test_prof/memory_prof/tracker/rss_tool.rb
 - lib/test_prof/recipes/logging.rb
 - lib/test_prof/recipes/minitest/before_all.rb
 - lib/test_prof/recipes/minitest/sample.rb
@@ -212,6 +220,8 @@ files:
 - lib/test_prof/utils/html_builder.rb
 - lib/test_prof/utils/rspec.rb
 - lib/test_prof/utils/sized_ordered_set.rb
+- lib/test_prof/vernier.rb
+- lib/test_prof/vernier/rspec.rb
 - lib/test_prof/version.rb
 homepage: http://github.com/test-prof/test-prof
 licenses:
@@ -238,7 +248,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.8
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
 summary: Ruby applications tests profiling tools