test-prof-autopilot 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 88be05ff8b53b5d4c831a5ed872348af97a21489a214a0fe14db3ad37976bd37
+  data.tar.gz: 7e1d10dfc1b62abdc435972a3842b6ab4e9ff3c0ee9508f627014f55e28772fc
+SHA512:
+  metadata.gz: b45afde7024c8fe293348f434a506008bd7f40ca188c262e8876db693f9b758c7982371eb273dad2e9a012727046ef00d92447683f405da947493904ce64c39d
+  data.tar.gz: d985c1d20353e05a468d46978300f99264cc1f2f2f5bc890fe93b167f17cdeb564decd0677694d1fbe1a03364aa5e26ce1f0e7e77bf74e2ed0969a61bd8691f7

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Change log
+
+## master
+
+[@palkan]: https://github.com/palkan

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Vladimir Dementyev, Ruslan Shakirov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# TestProf Autopilot (PoC)
+
+[TestProf][] has been used by many Ruby/Rails teams to optimize their test suites performance for a while.
+
+Usually, it takes a decent amount of time to profile the test suite initially: we need run many profilers multiple times, tune configuration and sampling parameters. And we repeat this over and over again.
+
+There are some common patterns in the way we use TestProf, for example: we run StackProf/RubyProf multiple times for different test samples, or we run EventProf for `factory.create` and then use FactoryProf for the slowest tests.
+
+It seems that there is a room for optimization here: we can automate this common tasks, make robots do all the repetition.
+
+This project (codename _TestProf Autopilot_) aims to solve this problem.
+
+## Usage (proposal)
+
+Use a CLI to run a specific tests profiling plan:
+
+```sh
+auto-test-prof -i plan.rb -с "bundle exec rspec"
+```
+
+We specify the base command to run tests via the `-c` option.
+
+Profiling plan is a Ruby file using a custom DSL to run profilers and access their reports:
+
+Here is an example #2:
+
+```ruby
+# This plan runs multiple test samples and collects StackProf data.
+# The data is aggregated and the top-5 popular methods are displayed in the end.
+#
+# With the help of this plan, you can detect such problems as unnecessary logging/instrumentation in tests,
+# inproper encryption settings, etc.
+#
+# NOTE: `aggregate` takes a block, runs it the specified number of times and merge the reports (i.e., agg_result = prev_result.merge(curr_result))
+aggregate(3) { run :stackprof, sample: 100 }
+
+# `report` returns the latest generated report (both `run` and `aggregate` set this value automatically)
+# `#methods` returns the list of collected reports sorted by their popularity
+# `info` prints the information (ideally, it should be human-readable)
+info report.methods.take(5)
+```
+
+And example #2:
+
+```ruby
+# This plan first launch the test suite and collect the information about the time spent in factories.
+# Then it runs FactoryProf for the slowest tests and display the information.
+
+run :event_prof, event: "factory.create"
+run :factory_prof, paths: report.paths
+
+info report
+```
+
+### Notes on implementation
+
+We use `#run` method to launch tests with profiling. Each profiler has a uniq name (which is the first argument) and some options.
+Some options are common for all profilers (e.g., `sample:` and `paths:`).
+
+## Installation
+
+Adding to a gem:
+
+```ruby
+# my-cool-gem.gemspec
+Gem::Specification.new do |spec|
+  # ...
+  spec.add_dependency "test-prof-autopilot"
+  # ...
+end
+```
+
+Or adding to your project:
+
+```ruby
+# Gemfile
+group :development, :test do
+  gem "test-prof-autopilot"
+end
+```
+
+[TestProf]: https://test-prof.evilmartians.io/

data/bin/auto-test-prof

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+lib_path = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+
+require "test_prof/autopilot/cli"
+
+begin
+  cli = TestProf::Autopilot::CLI.new
+  cli.run(ARGV)
+rescue => e
+  raise e if $DEBUG
+  STDERR.puts e.message
+  STDERR.puts e.backtrace.join("\n") if ENV["DEBUG_TEST_PROF"] == "1"
+  exit 1
+end

data/lib/test-prof-autopilot.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "test_prof/autopilot/version"

data/lib/test_prof/autopilot/cli.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "test_prof/autopilot/runner"
+
+module TestProf
+  module Autopilot
+    class CLI
+      attr_reader :command, :plan_path
+
+      def run(args = ARGV)
+        optparser.parse!(args)
+
+        raise "Test command must be specified. See -h for options" unless command
+
+        raise "Plan path must be specified. See -h for options" unless plan_path
+
+        raise "Plan #{plan_path} doesn't exist" unless File.file?(plan_path)
+
+        Runner.invoke(plan_path, command)
+      end
+
+      private
+
+      def optparser
+        @optparser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: auto-test-prof [options]"
+
+          opts.on("-v", "--version", "Print version") do
+            $stdout.puts TestProf::Autopilot::VERSION
+            exit 0
+          end
+
+          opts.on("-c COMMAND", "--command", "Command to run tests") do |val|
+            @command = val
+          end
+
+          opts.on("-i FILE", "--plan", "Path to test plan") do |val|
+            @plan_path = val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/command_executor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module TestProf
+  module Autopilot
+    # Module is used for commands execution in child process.
+    module CommandExecutor
+      def execute(env, command)
+        Open3.popen2e(env, command) do |_stdin, stdout_and_stderr, _wait_thr|
+          while (line = stdout_and_stderr.gets)
+            Logging.log line
+          end
+        end
+      end
+
+      module_function :execute
+    end
+  end
+end

data/lib/test_prof/autopilot/configuration.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module TestProf
+  module Autopilot
+    # Global configuration
+    class Configuration
+      class << self
+        def config
+          @config ||= new
+        end
+
+        def configure
+          yield config
+        end
+      end
+
+      attr_accessor :output,
+        :tmp_dir,
+        :artifacts_dir,
+        :plan_path,
+        :command
+
+      def initialize
+        @output = $stdout
+        @tmp_dir = "tmp/test_prof_autopilot"
+        @artifacts_dir = "test_prof_autopilot"
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/dsl.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "test_prof/autopilot/event_prof/printer"
+require "test_prof/autopilot/event_prof/profiling_executor"
+
+require "test_prof/autopilot/factory_prof/printer"
+require "test_prof/autopilot/factory_prof/profiling_executor"
+
+require "test_prof/autopilot/stack_prof/printer"
+require "test_prof/autopilot/stack_prof/writer"
+require "test_prof/autopilot/stack_prof/profiling_executor"
+
+module TestProf
+  module Autopilot
+    # Module contains all available DSL instructions
+    module Dsl
+      # 'run' is used to start profiling
+      # profiler – uniq name of profiler; available profilers – :event_prof, :factory_prof, :stack_prof
+      # options; available options – :sample, :paths and :event ('event_prof' profiler only)
+      def run(profiler, **options)
+        Logging.log "Executing 'run' with profiler:#{profiler} and options:#{options}"
+
+        executor = Registry.fetch(:"#{profiler}_executor").new(options).start
+
+        @report = executor.report
+      end
+
+      # 'aggregate' is used to run one profiler several times and merge results
+      # supported profilers – 'stack_prof'
+      #
+      # example of using:
+      # aggregate(3) { run :stack_prof, sample: 100 }
+      def aggregate(number, &block)
+        raise ArgumentError, "Block is required!" unless block
+
+        agg_report = nil
+
+        number.times do
+          block.call
+
+          agg_report = agg_report.nil? ? report : agg_report.merge(report)
+        end
+
+        @report = agg_report
+      end
+
+      # 'info' prints report
+      # printable_object; available printable objects – 'report'
+      def info(printable_object)
+        Registry.fetch(:"#{printable_object.type}_printer").print_report(printable_object)
+      end
+
+      # 'save' writes report to file
+      def save(report, **options)
+        Registry.fetch(:"#{report.type}_writer").write_report(report, **options)
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/event_prof/printer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "test_prof/ext/float_duration"
+require "test_prof/ext/string_truncate"
+
+module TestProf
+  module Autopilot
+    module EventProf
+      # Module is used for printing :event_prof report
+      module Printer
+        Registry.register(:event_prof_printer, self)
+
+        using FloatDuration
+        using StringTruncate
+
+        def print_report(report)
+          result = report.raw_report
+          msgs = []
+
+          msgs <<
+            <<~MSG
+              EventProf results for #{result["event"]}
+  
+              Total time: #{result["total_time"].duration} of #{result["absolute_run_time"].duration} (#{result["time_percentage"]}%)
+              Total events: #{result["total_count"]}
+  
+              Top #{result["top_count"]} slowest suites (by #{result["rank_by"]}):
+            MSG
+
+          result["groups"].each do |group|
+            msgs <<
+              <<~GROUP
+                #{group["description"].truncate} (#{group["location"]}) – #{group["time"].duration} (#{group["count"]} / #{group["examples"]}) of #{group["run_time"].duration} (#{group["time_percentage"]}%)
+              GROUP
+          end
+
+          Logging.log msgs.join
+        end
+
+        module_function :print_report
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/event_prof/profiling_executor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "test_prof/autopilot/profiling_executor/base"
+
+module TestProf
+  module Autopilot
+    module EventProf
+      # Provides :event_prof specific validations, env and command building.
+      class ProfilingExecutor < ProfilingExecutor::Base
+        Registry.register(:event_prof_executor, self)
+
+        def initialize(options)
+          super
+          @profiler = :event_prof
+        end
+
+        private
+
+        def validate_profiler!
+          super
+          raise ArgumentError, "'event' option is required for 'event_prof' profiler" if @options[:event].nil?
+        end
+
+        def build_env
+          super.tap do |env|
+            env["EVENT_PROF"] = @options[:event]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/event_prof/report.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "json"
+require "test_prof/autopilot/report_builder"
+
+module TestProf
+  module Autopilot
+    module EventProf
+      # :event_prof report allows to add additional functionality
+      # for it's instances
+      class Report
+        Registry.register(:event_prof_report, self)
+
+        extend ReportBuilder
+
+        ARTIFACT_FILE = "event_prof_report.json"
+
+        attr_reader :type, :raw_report
+
+        def initialize(raw_report)
+          @type = :event_prof
+          @raw_report = raw_report
+        end
+
+        def paths
+          @raw_report["groups"].reduce("") { |paths, group| "#{paths} #{group["location"]}" }.strip
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/factory_prof/printer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module TestProf
+  module Autopilot
+    module FactoryProf
+      # Module is used for printing :factory_prof report
+      module Printer
+        Registry.register(:factory_prof_printer, self)
+
+        class PrinterError < StandardError; end
+
+        def print_report(report)
+          result = report.raw_report
+
+          raise PrinterError, result["error"] if result["error"]
+
+          msgs = []
+
+          msgs <<
+            <<~MSG
+              Factories usage
+
+               Total: #{result["total_count"]}
+               Total top-level: #{result["total_top_level_count"]}
+               Total time: #{format("%.4f", result["total_time"])}s
+               Total uniq factories: #{result["total_uniq_factories"]}
+
+                 total   top-level     total time      time per call      top-level time               name
+            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"])
+          end
+
+          Logging.log msgs.join("\n")
+        end
+
+        module_function :print_report
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/factory_prof/profiling_executor.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "test_prof/autopilot/profiling_executor/base"
+
+module TestProf
+  module Autopilot
+    module FactoryProf
+      # Provides :factory_prof specific validations, env and command building.
+      class ProfilingExecutor < ProfilingExecutor::Base
+        Registry.register(:factory_prof_executor, self)
+
+        def initialize(options)
+          super
+          @profiler = :factory_prof
+        end
+
+        private
+
+        def build_env
+          super.tap do |env|
+            env["FPROF"] = "1"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/factory_prof/report.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "json"
+require "test_prof/autopilot/report_builder"
+
+module TestProf
+  module Autopilot
+    module FactoryProf
+      # :factory_prof report allows to add additional functionality
+      # for it's instances
+      class Report
+        Registry.register(:factory_prof_report, self)
+
+        extend ReportBuilder
+
+        ARTIFACT_FILE = "factory_prof_report.json"
+
+        attr_reader :type, :raw_report
+
+        def initialize(raw_report)
+          @type = :factory_prof
+          @raw_report = raw_report
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/logging.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TestProf
+  module Autopilot
+    module Logging
+      def log(message)
+        Configuration.config.output.puts(message)
+      end
+
+      module_function :log
+    end
+  end
+end

data/lib/test_prof/autopilot/patches/event_prof_patch.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module TestProf
+  module Autopilot
+    module Patches
+      # Monkey-patch for 'TestProf::EventProf::RSpecListener'.
+      # Redefined 'report' method provides writing artifact to the directory
+      # instead of printing report
+      module EventProfPatch
+        ARTIFACT_FILE = "event_prof_report.json"
+
+        def patch
+          TestProf::EventProf::RSpecListener.class_eval do
+            def report(profiler)
+              result = profiler.results
+
+              profiler_hash = {
+                event: profiler.event,
+                total_time: profiler.total_time,
+                absolute_run_time: profiler.absolute_run_time,
+                total_count: profiler.total_count,
+                top_count: profiler.top_count,
+                rank_by: profiler.rank_by,
+                time_percentage: time_percentage(profiler.total_time, profiler.absolute_run_time)
+              }
+
+              profiler_hash[:groups] = result[:groups].map do |group|
+                {
+                  description: group[:id].top_level_description,
+                  location: group[:id].metadata[:location],
+                  time: group[:time],
+                  count: group[:count],
+                  examples: group[:examples],
+                  run_time: group[:run_time],
+                  time_percentage: time_percentage(group[:time], group[:run_time])
+                }
+              end
+
+              dir_path = FileUtils.mkdir_p(Configuration.config.tmp_dir)[0]
+              file_path = File.join(dir_path, ARTIFACT_FILE)
+
+              File.write(file_path, JSON.generate(profiler_hash))
+            end
+          end
+        end
+
+        module_function :patch
+      end
+    end
+  end
+end
+
+TestProf::Autopilot::Patches::EventProfPatch.patch

data/lib/test_prof/autopilot/patches/factory_prof_patch.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module TestProf
+  module Autopilot
+    module Patches
+      # Monkey-patch for 'TestProf::FactoryProf::Printers::Simple'.
+      # Redefined 'report' method provides writing artifact to the directory
+      # instead of printing report
+      module FactoryProfPatch
+        ARTIFACT_FILE = "factory_prof_report.json"
+
+        def patch
+          TestProf::FactoryProf::Printers::Simple.module_eval do
+            def self.dump(result, **)
+              profiler_hash =
+                if result.raw_stats == {}
+                  {
+                    error: "No factories detected"
+                  }
+                else
+                  {
+                    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.uniq { |stat| stat[:name] }.count,
+                    stats: result.stats
+                  }
+                end
+
+              dir_path = FileUtils.mkdir_p(Configuration.config.tmp_dir)[0]
+              file_path = File.join(dir_path, ARTIFACT_FILE)
+
+              File.write(file_path, JSON.generate(profiler_hash))
+            end
+          end
+        end
+
+        module_function :patch
+      end
+    end
+  end
+end
+
+TestProf::Autopilot::Patches::FactoryProfPatch.patch

data/lib/test_prof/autopilot/patches/stack_prof_patch.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module TestProf
+  module Autopilot
+    module Patches
+      module StackProfPatch
+        ARTIFACT_FILE = "stack_prof_report.dump"
+
+        def patch
+          TestProf::StackProf.module_eval do
+            private
+
+            def self.build_path(_name)
+              dir_path = FileUtils.mkdir_p(Configuration.config.tmp_dir)[0]
+              File.join(dir_path, ARTIFACT_FILE)
+            end
+          end
+        end
+
+        module_function :patch
+      end
+    end
+  end
+end
+
+TestProf::Autopilot::Patches::StackProfPatch.patch

data/lib/test_prof/autopilot/profiling_executor/base.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "test_prof/autopilot/command_executor"
+require "test_prof/autopilot/event_prof/report"
+require "test_prof/autopilot/factory_prof/report"
+require "test_prof/autopilot/stack_prof/report"
+
+module TestProf
+  module Autopilot
+    module ProfilingExecutor
+      # Provides base command and env variables building;
+      # Calls command executor;
+      # Builds report.
+      class Base
+        attr_reader :report
+
+        def initialize(options)
+          @options = options
+        end
+
+        def start
+          validate_profiler!
+
+          execute
+          build_report
+
+          self
+        end
+
+        private
+
+        def validate_profiler!
+        end
+
+        def execute
+          env = build_env
+          command = build_command
+
+          CommandExecutor.execute(env, command)
+        end
+
+        def build_env
+          env = {}
+
+          env["SAMPLE"] = @options[:sample].to_s if @options[:sample]
+          env
+        end
+
+        def build_command
+          return Configuration.config.command if @options[:paths].nil?
+
+          "#{Configuration.config.command} #{@options[:paths]}"
+        end
+
+        def build_report
+          @report = Registry.fetch(:"#{@profiler}_report").build
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/registry.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module TestProf
+  module Autopilot
+    # Global registry
+    class Registry
+      @items = {}
+
+      class << self
+        def register(key, klass)
+          @items[key] = klass
+        end
+
+        def fetch(key)
+          @items.fetch(key)
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/report_builder.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module TestProf
+  module Autopilot
+    # Common module that extends reports classes
+    module ReportBuilder
+      ARTIFACT_MISSING_HINT = "Have you required 'test_prof/autopilot' to your code? "
+
+      def build
+        report = JSON.parse(fetch_report)
+
+        new(report)
+      end
+
+      private
+
+      def fetch_report
+        file_path = File.join(Configuration.config.tmp_dir, self::ARTIFACT_FILE)
+        File.read(file_path)
+      rescue Errno::ENOENT => e
+        e.message.prepend(ARTIFACT_MISSING_HINT)
+        raise
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/runner.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "test_prof/autopilot/configuration"
+require "test_prof/autopilot/registry"
+require "test_prof/autopilot/logging"
+require "test_prof/autopilot/dsl"
+require "fileutils"
+
+module TestProf
+  module Autopilot
+    class Runner
+      prepend Dsl
+
+      attr_reader :report
+
+      class << self
+        def invoke(plan_path, command)
+          Configuration.configure do |config|
+            config.plan_path = plan_path
+            config.command = command
+          end
+
+          Logging.log "Reading #{plan_path}..."
+
+          new.instance_eval(File.read(Configuration.config.plan_path))
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/stack_prof/printer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module TestProf
+  module Autopilot
+    module StackProf
+      # Module is used for printing :stack_prof report
+      module Printer
+        Registry.register(:stack_prof_printer, self)
+
+        def print_report(report)
+          report.print_text
+        end
+
+        module_function :print_report
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/stack_prof/profiling_executor.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "test_prof/autopilot/profiling_executor/base"
+
+module TestProf
+  module Autopilot
+    module StackProf
+      # Provides :stack_prof specific validations, env and command building.
+      class ProfilingExecutor < ProfilingExecutor::Base
+        Registry.register(:stack_prof_executor, self)
+
+        def initialize(options)
+          super
+          @profiler = :stack_prof
+        end
+
+        private
+
+        def build_env
+          super.tap do |env|
+            env["TEST_STACK_PROF"] = "1"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/stack_prof/report.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "stackprof/report"
+
+module TestProf
+  module Autopilot
+    module StackProf
+      class Report < ::StackProf::Report
+        Registry.register(:stack_prof_report, self)
+
+        extend ReportBuilder
+
+        ARTIFACT_FILE = "stack_prof_report.dump"
+
+        attr_reader :type
+
+        def initialize(data)
+          @type = :stack_prof
+          super(data)
+        end
+
+        def self.build
+          new(Marshal.load(fetch_report))
+        end
+
+        def merge(other)
+          f1, f2 = data[:frames], other.data[:frames]
+
+          frames = (f1.keys + f2.keys).uniq.each_with_object({}) do |id, hash|
+            if f1[id].nil?
+              hash[id] = f2[id]
+            elsif f2[id]
+              hash[id] = f1[id]
+              hash[id][:total_samples] += f2[id][:total_samples]
+              hash[id][:samples] += f2[id][:samples]
+              if f2[id][:edges]
+                edges = hash[id][:edges] ||= {}
+                f2[id][:edges].each do |edge, weight|
+                  edges[edge] ||= 0
+                  edges[edge] += weight
+                end
+              end
+              if f2[id][:lines]
+                lines = hash[id][:lines] ||= {}
+                f2[id][:lines].each do |line, weight|
+                  lines[line] = add_lines(lines[line], weight)
+                end
+              end
+            else
+              hash[id] = f1[id]
+            end
+            hash
+          end
+
+          d1, d2 = data, other.data
+          data = {
+            version: version,
+            mode: d1[:mode],
+            interval: d1[:interval],
+            samples: d1[:samples] + d2[:samples],
+            gc_samples: d1[:gc_samples] + d2[:gc_samples],
+            missed_samples: d1[:missed_samples] + d2[:missed_samples],
+            metadata: d1[:metadata].merge(d2[:metadata]),
+            frames: frames,
+            raw: d1[:raw] + d2[:raw],
+            raw_timestamp_deltas: d1[:raw_timestamp_deltas] + d2[:raw_timestamp_deltas]
+          }
+
+          self.class.new(data)
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/stack_prof/writer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TestProf
+  module Autopilot
+    module StackProf
+      # Module is used for writing :stack_prof report in different formats
+      module Writer
+        Registry.register(:stack_prof_writer, self)
+
+        ARTIFACT_FILE = "stack_prof_report"
+
+        def write_report(report, file_name: ARTIFACT_FILE)
+          dir_path = FileUtils.mkdir_p(Configuration.config.artifacts_dir)[0]
+          file_path = File.join(dir_path, file_name + ".json")
+
+          File.write(file_path, JSON.generate(report.data))
+        end
+
+        module_function :write_report
+      end
+    end
+  end
+end

data/lib/test_prof/autopilot/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module TestProf
+  module Autopilot # :nodoc:
+    VERSION = "0.0.2"
+  end
+end

data/lib/test_prof/autopilot.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "test-prof"
+require "test_prof/autopilot/configuration"
+require "test_prof/autopilot/patches/event_prof_patch"
+require "test_prof/autopilot/patches/factory_prof_patch"
+require "test_prof/autopilot/patches/stack_prof_patch"

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: test-prof-autopilot
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Ruslan Shakirov
+- Vladimir Dementyev
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-prof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: stackprof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.9
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.10'
+description: Automatic TestProf runner
+email:
+- ruslan@shakirov.dev
+- dementiev.vm@gmail.com
+executables:
+- auto-test-prof
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- bin/auto-test-prof
+- lib/test-prof-autopilot.rb
+- lib/test_prof/autopilot.rb
+- lib/test_prof/autopilot/cli.rb
+- lib/test_prof/autopilot/command_executor.rb
+- lib/test_prof/autopilot/configuration.rb
+- lib/test_prof/autopilot/dsl.rb
+- lib/test_prof/autopilot/event_prof/printer.rb
+- lib/test_prof/autopilot/event_prof/profiling_executor.rb
+- lib/test_prof/autopilot/event_prof/report.rb
+- lib/test_prof/autopilot/factory_prof/printer.rb
+- lib/test_prof/autopilot/factory_prof/profiling_executor.rb
+- lib/test_prof/autopilot/factory_prof/report.rb
+- lib/test_prof/autopilot/logging.rb
+- lib/test_prof/autopilot/patches/event_prof_patch.rb
+- lib/test_prof/autopilot/patches/factory_prof_patch.rb
+- lib/test_prof/autopilot/patches/stack_prof_patch.rb
+- lib/test_prof/autopilot/profiling_executor/base.rb
+- lib/test_prof/autopilot/registry.rb
+- lib/test_prof/autopilot/report_builder.rb
+- lib/test_prof/autopilot/runner.rb
+- lib/test_prof/autopilot/stack_prof/printer.rb
+- lib/test_prof/autopilot/stack_prof/profiling_executor.rb
+- lib/test_prof/autopilot/stack_prof/report.rb
+- lib/test_prof/autopilot/stack_prof/writer.rb
+- lib/test_prof/autopilot/version.rb
+homepage: http://github.com/test-prof/test-prof-autopilot
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.15
+signing_key:
+specification_version: 4
+summary: Automatic TestProf runner
+test_files: []