datadog-ci 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63e9fdf2c856764bb9567cf89d76f27a4f327244152c510abcd4d64e180a0cc6
-  data.tar.gz: 963f5b534027215799efe65a108a4aa8267c2c31aa4fc1402d19d02f996fc2e9
+  metadata.gz: 14828e8c64b8eeb9c04d4ae2563e568b3b920b587f8e97e628896b143219daf0
+  data.tar.gz: b538d180acd0c18e1d8070adfdcd9f44dad65331048619de40db04cd876dfe01
 SHA512:
-  metadata.gz: e94bbd5cc929f95a386cadd633b93f2a53962eefe686354712a9801a8b9865a52fc74c6401f96635a47b9001d71287cadc568ba3bb81ed764d68bdf232b85e5b
-  data.tar.gz: 7a33d2dc09b32798f2fcae80a96bec0e919b4c60f65283f4cf158a020ecd573e450bb925c790c822c63a86b4cf214fae4427e7d4bdb6cde28ca1105dcc95a20a
+  metadata.gz: 60f8fda5f530404027669902b194c7e056af834c882adbc2b7d350eb62f7f75c2d63dae23bf6e98a8bebea0cc8ec34d4f5416fe667d1c30dff1fdb7ebb42854d
+  data.tar.gz: 1b2ad405dee8a1dd2ce24c3d5738ddcbc751f85d5aa5c29a287b614dcfc0a4764230a3b53e59967247fd0f64711fd81fc3863e49895098e7664aa81a3bf1b8e6

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## [Unreleased]
 
+## [0.7.0] - 2024-01-26
+
+### Added
+
+* Source code integration ([#95][])
+* CODEOWNERS support ([#98][])
+* Cucumber scenarios with examples are treated as parametrized tests ([#100][])
+* Deduplicate dynamically generated RSpec examples using test.parameters ([#101][])
+* Repository name is used as default test service name ([#104][])
+* Cucumber v9 support ([#99][])
+* ci-queue runner support for minitest ([#110][])
+* ci-queue support for rspec ([#112][])
+
+### Fixed
+
+* do not publish sig folder when publishing this gem to prevent steep errors in client applications ([#114][])
+* minitest: fix rails parallel test runner ([#115][])
+* Test suites and tests skipped by frameworks are correctly reported as skipped to Datadog ([#113][])
+
+### Changed
+
+* Enable test suite level visibility by default (with killswitch) ([#109][])
+* Test suite names are more human-readable now ([#105][])
+* Remove span_type method in tracer-related models ([#107][])
+* Manual tracing API: convert type parameter to keyword in Datadog::CI.trace, remove internal-only methods from public API ([#108][])
+
 ## [0.6.0] - 2024-01-03
 
 ### Added
@@ -124,7 +150,9 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 
 * Ruby versions < 2.7 no longer supported ([#8][])
 
-[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v0.5.1...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v0.7.0...main
+[0.7.0]: https://github.com/DataDog/datadog-ci-rb/compare/v0.6.0...v0.7.0
+[0.6.0]: https://github.com/DataDog/datadog-ci-rb/compare/v0.5.1...v0.6.0
 [0.5.1]: https://github.com/DataDog/datadog-ci-rb/compare/v0.5.0...v0.5.1
 [0.5.0]: https://github.com/DataDog/datadog-ci-rb/compare/v0.4.1...v0.5.0
 [0.4.1]: https://github.com/DataDog/datadog-ci-rb/compare/v0.4.0...v0.4.1
@@ -169,4 +197,19 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#87]: https://github.com/DataDog/datadog-ci-rb/issues/87
 [#89]: https://github.com/DataDog/datadog-ci-rb/issues/89
 [#90]: https://github.com/DataDog/datadog-ci-rb/issues/90
-[#92]: https://github.com/DataDog/datadog-ci-rb/issues/92
+[#92]: https://github.com/DataDog/datadog-ci-rb/issues/92
+[#95]: https://github.com/DataDog/datadog-ci-rb/issues/95
+[#98]: https://github.com/DataDog/datadog-ci-rb/issues/98
+[#99]: https://github.com/DataDog/datadog-ci-rb/issues/99
+[#100]: https://github.com/DataDog/datadog-ci-rb/issues/100
+[#101]: https://github.com/DataDog/datadog-ci-rb/issues/101
+[#104]: https://github.com/DataDog/datadog-ci-rb/issues/104
+[#105]: https://github.com/DataDog/datadog-ci-rb/issues/105
+[#107]: https://github.com/DataDog/datadog-ci-rb/issues/107
+[#108]: https://github.com/DataDog/datadog-ci-rb/issues/108
+[#109]: https://github.com/DataDog/datadog-ci-rb/issues/109
+[#110]: https://github.com/DataDog/datadog-ci-rb/issues/110
+[#112]: https://github.com/DataDog/datadog-ci-rb/issues/112
+[#113]: https://github.com/DataDog/datadog-ci-rb/issues/113
+[#114]: https://github.com/DataDog/datadog-ci-rb/issues/114
+[#115]: https://github.com/DataDog/datadog-ci-rb/issues/115

data/README.md

@@ -6,7 +6,7 @@
 [![CircleCI](https://dl.circleci.com/status-badge/img/gh/DataDog/datadog-ci-rb/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/DataDog/datadog-ci-rb/tree/main)
 
 Datadog's Ruby Library for instrumenting your test and continuous integration pipeline.
-Learn more on our [official website](https://docs.datadoghq.com/continuous_integration/tests/ruby/).
+Learn more on our [official website](https://docs.datadoghq.com/tests/) and check out our [documentation for this library](https://docs.datadoghq.com/tests/setup/ruby/?tab=cloudciprovideragentless).
 
 > [!IMPORTANT]
 > The `datadog-ci` gem is currently a component of [`ddtrace`](https://github.com/datadog/dd-trace-rb) and should not be used without it.

data/lib/datadog/ci/codeowners/matcher.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "rule"
+
+module Datadog
+  module CI
+    module Codeowners
+      # Responsible for matching a test source file path to a list of owners
+      class Matcher
+        def initialize(codeowners_file_path)
+          @rules = parse(codeowners_file_path)
+          @rules.reverse!
+        end
+
+        def list_owners(file_path)
+          # treat all file paths that we check as absolute from the repository root
+          file_path = "/#{file_path}" unless file_path.start_with?("/")
+
+          Datadog.logger.debug { "Matching file path #{file_path} to CODEOWNERS rules" }
+
+          @rules.each do |rule|
+            if rule.match?(file_path)
+              Datadog.logger.debug { "Matched rule [#{rule.pattern}] with owners #{rule.owners}" }
+              return rule.owners
+            end
+          end
+
+          Datadog.logger.debug { "CODEOWNERS rule not matched" }
+          nil
+        end
+
+        private
+
+        def parse(codeowners_file_path)
+          unless File.exist?(codeowners_file_path)
+            Datadog.logger.debug { "CODEOWNERS file not found at #{codeowners_file_path}" }
+            return []
+          end
+
+          result = []
+          section_default_owners = []
+
+          File.open(codeowners_file_path, "r") do |f|
+            f.each_line do |line|
+              line.strip!
+
+              next if line.empty?
+              next if comment?(line)
+
+              pattern, *line_owners = line.strip.split(/\s+/)
+              next if pattern.nil? || pattern.empty?
+
+              # if the current line starts with section record the default owners for this section
+              if section?(pattern)
+                section_default_owners = line_owners
+                next
+              end
+
+              pattern = expand_pattern(pattern)
+              # if the current line doesn't have any owners then use the default owners for this section
+              if line_owners.empty? && !section_default_owners.empty?
+                line_owners = section_default_owners
+              end
+
+              result << Rule.new(pattern, line_owners)
+            end
+          end
+
+          result
+        rescue => e
+          Datadog.logger.warn(
+            "Failed to parse codeowners file at #{codeowners_file_path}: " \
+              "#{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          )
+          []
+        end
+
+        def comment?(line)
+          line.start_with?("#")
+        end
+
+        def section?(line)
+          line.start_with?("[", "^[") && line.end_with?("]")
+        end
+
+        def expand_pattern(pattern)
+          return pattern if pattern == "*"
+
+          # if pattern ends with a slash then it matches everything deeply nested in this directory
+          pattern += "**" if pattern.end_with?(::File::SEPARATOR)
+
+          # if pattern doesn't start with a slash then it matches anywhere in the repository
+          if !pattern.start_with?(::File::SEPARATOR, "**#{::File::SEPARATOR}", "*#{::File::SEPARATOR}")
+            pattern = "**#{::File::SEPARATOR}#{pattern}"
+          end
+
+          pattern
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/codeowners/parser.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "matcher"
+
+module Datadog
+  module CI
+    module Codeowners
+      # Responsible for parsing a CODEOWNERS file
+      class Parser
+        DEFAULT_LOCATION = "CODEOWNERS"
+        POSSIBLE_CODEOWNERS_LOCATIONS = [
+          "CODEOWNERS",
+          ".github/CODEOWNERS",
+          ".gitlab/CODEOWNERS",
+          "docs/CODEOWNERS"
+        ].freeze
+
+        def initialize(root_file_path)
+          @root_file_path = root_file_path || Dir.pwd
+        end
+
+        def parse
+          default_path = File.join(@root_file_path, DEFAULT_LOCATION)
+          # We are using the first codeowners file that we find or
+          # default location if nothing is found
+          #
+          # Matcher handles it internally and creates a class with
+          # an empty list of rules if the file is not found
+          codeowners_file_path = POSSIBLE_CODEOWNERS_LOCATIONS.map do |codeowners_location|
+            File.join(@root_file_path, codeowners_location)
+          end.find do |path|
+            File.exist?(path)
+          end || default_path
+
+          ::Datadog.logger.debug { "Using CODEOWNERS file from: #{codeowners_file_path}" }
+
+          Matcher.new(codeowners_file_path)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/codeowners/rule.rb

@@ -0,0 +1,33 @@
+module Datadog
+  module CI
+    module Codeowners
+      class Rule
+        attr_reader :pattern, :owners
+
+        def initialize(pattern, owners)
+          @pattern = pattern
+          @owners = owners
+        end
+
+        def match?(file_path)
+          res = false
+          # if pattern does not end with a separator or a wildcard, it could be either a directory or a file
+          if !pattern.end_with?(::File::SEPARATOR, "*")
+            directory_pattern = "#{pattern}#{::File::SEPARATOR}*"
+            res ||= File.fnmatch?(directory_pattern, file_path, flags)
+          end
+
+          res ||= File.fnmatch?(pattern, file_path, flags)
+          res
+        end
+
+        private
+
+        def flags
+          return ::File::FNM_PATHNAME if pattern.end_with?("#{::File::SEPARATOR}*")
+          0
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/concurrent_span.rb

@@ -12,7 +12,8 @@ module Datadog
       def initialize(tracer_span)
         super
 
-        @mutex = Mutex.new
+        # we use Monitor instead of Mutex because it is reentrant
+        @mutex = Monitor.new
       end
 
       # Gets tag value by key. This method is thread-safe.

data/lib/datadog/ci/configuration/components.rb

@@ -41,7 +41,7 @@ module Datadog
           elsif can_use_evp_proxy?(settings, agent_settings)
             test_visibility_transport = build_evp_proxy_transport(settings, agent_settings)
           else
-            settings.ci.experimental_test_suite_level_visibility_enabled = false
+            settings.ci.force_test_level_visibility = true
           end
 
           # Deactivate telemetry
@@ -72,7 +72,7 @@ module Datadog
           settings.tracing.test_mode.writer_options = writer_options
 
           @ci_recorder = TestVisibility::Recorder.new(
-            test_suite_level_visibility_enabled: settings.ci.experimental_test_suite_level_visibility_enabled
+            test_suite_level_visibility_enabled: !settings.ci.force_test_level_visibility
           )
         end
 
@@ -119,10 +119,10 @@ module Datadog
         end
 
         def serializers_factory(settings)
-          if settings.ci.experimental_test_suite_level_visibility_enabled
-            Datadog::CI::TestVisibility::Serializers::Factories::TestSuiteLevel
-          else
+          if settings.ci.force_test_level_visibility
             Datadog::CI::TestVisibility::Serializers::Factories::TestLevel
+          else
+            Datadog::CI::TestVisibility::Serializers::Factories::TestSuiteLevel
           end
         end
 

data/lib/datadog/ci/configuration/settings.rb

@@ -34,10 +34,25 @@ module Datadog
                 o.env CI::Ext::Settings::ENV_AGENTLESS_URL
               end
 
+              option :force_test_level_visibility do |o|
+                o.type :bool
+                o.env CI::Ext::Settings::ENV_FORCE_TEST_LEVEL_VISIBILITY
+                o.default false
+              end
+
               option :experimental_test_suite_level_visibility_enabled do |o|
                 o.type :bool
                 o.env CI::Ext::Settings::ENV_EXPERIMENTAL_TEST_SUITE_LEVEL_VISIBILITY_ENABLED
                 o.default false
+                o.after_set do |value|
+                  if value
+                    Datadog::Core.log_deprecation do
+                      "The experimental_test_suite_level_visibility_enabled setting has no effect and will be removed in 1.0. " \
+                        "Test suite level visibility is now enabled by default. " \
+                        "If you want to disable test suite level visibility set configuration.ci.force_test_level_visibility = true."
+                    end
+                  end
+                end
               end
 
               define_method(:instrument) do |integration_name, options = {}, &block|

data/lib/datadog/ci/contrib/cucumber/configuration/settings.rb

@@ -4,6 +4,7 @@ require "datadog/core"
 
 require_relative "../ext"
 require_relative "../../settings"
+require_relative "../../../utils/configuration"
 
 module Datadog
   module CI
@@ -21,7 +22,9 @@ module Datadog
 
             option :service_name do |o|
               o.type :string
-              o.default { Datadog.configuration.service_without_fallback || Ext::DEFAULT_SERVICE_NAME }
+              o.default do
+                Utils::Configuration.fetch_service_name(Ext::DEFAULT_SERVICE_NAME)
+              end
             end
 
             # @deprecated Will be removed in 1.0

data/lib/datadog/ci/contrib/cucumber/formatter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../ext/test"
+require_relative "../../utils/git"
 require_relative "ext"
 
 module Datadog
@@ -13,11 +14,12 @@ module Datadog
           private :config
 
           def initialize(config)
+            @ast_lookup = ::Cucumber::Formatter::AstLookup.new(config) if defined?(::Cucumber::Formatter::AstLookup)
             @config = config
-            @failed_tests_count = 0
 
             @current_test_suite = nil
-            @failed_tests_in_current_test_suite = 0
+
+            @failed_tests_count = 0
 
             bind_events(config)
           end
@@ -35,12 +37,11 @@ module Datadog
             test_session = CI.start_test_session(
               tags: {
                 CI::Ext::Test::TAG_FRAMEWORK => Ext::FRAMEWORK,
-                CI::Ext::Test::TAG_FRAMEWORK_VERSION => CI::Contrib::Cucumber::Integration.version.to_s,
-                CI::Ext::Test::TAG_TYPE => CI::Ext::Test::TEST_TYPE
+                CI::Ext::Test::TAG_FRAMEWORK_VERSION => CI::Contrib::Cucumber::Integration.version.to_s
               },
               service: configuration[:service_name]
             )
-            CI.start_test_module(test_session.name)
+            CI.start_test_module(test_session.name) if test_session
           end
 
           def on_test_run_finished(event)
@@ -52,58 +53,71 @@ module Datadog
           end
 
           def on_test_case_started(event)
-            test_suite_name = event.test_case.location.file
+            test_suite_name = test_suite_name(event.test_case)
+
+            tags = {
+              CI::Ext::Test::TAG_FRAMEWORK => Ext::FRAMEWORK,
+              CI::Ext::Test::TAG_FRAMEWORK_VERSION => CI::Contrib::Cucumber::Integration.version.to_s,
+              CI::Ext::Test::TAG_SOURCE_FILE => Utils::Git.relative_to_root(event.test_case.location.file),
+              CI::Ext::Test::TAG_SOURCE_START => event.test_case.location.line.to_s
+            }
 
             start_test_suite(test_suite_name) unless same_test_suite_as_current?(test_suite_name)
 
-            CI.start_test(
+            test_span = CI.start_test(
               event.test_case.name,
               test_suite_name,
-              tags: {
-                CI::Ext::Test::TAG_FRAMEWORK => Ext::FRAMEWORK,
-                CI::Ext::Test::TAG_FRAMEWORK_VERSION => CI::Contrib::Cucumber::Integration.version.to_s,
-                CI::Ext::Test::TAG_TYPE => CI::Ext::Test::TEST_TYPE
-              },
+              tags: tags,
               service: configuration[:service_name]
             )
+
+            if test_span && (parameters = extract_parameters_hash(event.test_case))
+              test_span.set_parameters(parameters)
+            end
           end
 
           def on_test_case_finished(event)
             test_span = CI.active_test
             return if test_span.nil?
 
-            # We need to track overall test failures manually if we are using cucumber < 8.0 because
-            # TestRunFinished event does not have a success attribute before 8.0.
-            #
-            # To track whether test suite failed or passed we need to
-            # track the number of failed tests in the current test suite.
-            if event.result.failed?
-              @failed_tests_count += 1
-              @failed_tests_in_current_test_suite += 1
-            end
-
-            finish_test(test_span, event.result)
+            finish_span(test_span, event.result)
+            @failed_tests_count += 1 if test_span.failed?
           end
 
           def on_test_step_started(event)
-            CI.trace(Ext::STEP_SPAN_TYPE, event.test_step.to_s)
+            CI.trace(event.test_step.to_s, type: Ext::STEP_SPAN_TYPE)
           end
 
           def on_test_step_finished(event)
-            current_step_span = CI.active_span(Ext::STEP_SPAN_TYPE)
+            current_step_span = CI.active_span
             return if current_step_span.nil?
 
-            finish_test(current_step_span, event.result)
+            finish_span(current_step_span, event.result)
           end
 
           private
 
-          def finish_test(span, result)
-            if result.skipped?
-              span.skipped!
-            elsif result.ok?
+          def test_suite_name(test_case)
+            feature = if test_case.respond_to?(:feature)
+              test_case.feature
+            elsif @ast_lookup
+              gherkin_doc = @ast_lookup.gherkin_document(test_case.location.file)
+              gherkin_doc.feature if gherkin_doc
+            end
+
+            if feature
+              "#{feature.name} at #{test_case.location.file}"
+            else
+              test_case.location.file
+            end
+          end
+
+          def finish_span(span, result)
+            if !result.passed? && result.ok?(@config.strict)
+              span.skipped!(reason: result.message)
+            elsif result.passed?
               span.passed!
-            elsif result.failed?
+            else
               span.failed!(exception: result.exception)
             end
             span.finish
@@ -139,13 +153,9 @@ module Datadog
             test_suite = @current_test_suite
             return unless test_suite
 
-            if @failed_tests_in_current_test_suite.zero?
-              test_suite.passed!
-            else
-              test_suite.failed!
-            end
-            @failed_tests_in_current_test_suite = 0
             test_suite.finish
+
+            @current_test_suite = nil
           end
 
           def same_test_suite_as_current?(test_suite_name)
@@ -155,6 +165,27 @@ module Datadog
             test_suite.name == test_suite_name
           end
 
+          def extract_parameters_hash(test_case)
+            # not supported in cucumber < 4.0
+            return nil unless @ast_lookup
+
+            scenario_source = @ast_lookup.scenario_source(test_case)
+
+            # cucumber examples are only supported for scenario outlines
+            return nil unless scenario_source.type == :ScenarioOutline
+
+            scenario_source.examples.table_header.cells.map(&:value).zip(
+              scenario_source.row.cells.map(&:value)
+            ).to_h
+          rescue => e
+            Datadog.logger.warn do
+              "Unable to extract parameters from test case #{test_case.name}: " \
+                "#{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+            end
+
+            nil
+          end
+
           def configuration
             Datadog.configuration.ci[:cucumber]
           end

data/lib/datadog/ci/contrib/cucumber/instrumentation.rb

@@ -17,8 +17,9 @@ module Datadog
             attr_reader :datadog_formatter
 
             def formatters
+              existing_formatters = super
               @datadog_formatter ||= CI::Contrib::Cucumber::Formatter.new(@configuration)
-              [@datadog_formatter] + super
+              [@datadog_formatter] + existing_formatters
             end
           end
         end

data/lib/datadog/ci/contrib/minitest/configuration/settings.rb

@@ -2,6 +2,7 @@
 
 require_relative "../ext"
 require_relative "../../settings"
+require_relative "../../../utils/configuration"
 
 module Datadog
   module CI
@@ -19,7 +20,9 @@ module Datadog
 
             option :service_name do |o|
               o.type :string
-              o.default { Datadog.configuration.service_without_fallback || Ext::DEFAULT_SERVICE_NAME }
+              o.default do
+                Utils::Configuration.fetch_service_name(Ext::DEFAULT_SERVICE_NAME)
+              end
             end
 
             # @deprecated Will be removed in 1.0

data/lib/datadog/ci/contrib/minitest/helpers.rb

@@ -13,7 +13,8 @@ module Datadog
           end
 
           def self.parallel?(klass)
-            klass.ancestors.include?(::Minitest::Parallel::Test)
+            klass.ancestors.include?(::Minitest::Parallel::Test) ||
+              (defined?(::Minitest::Queue) && ::Minitest.singleton_class.ancestors.include?(::Minitest::Queue))
           end
         end
       end

data/lib/datadog/ci/contrib/minitest/hooks.rb

@@ -14,8 +14,6 @@ module Datadog
             super
             return unless datadog_configuration[:enabled]
 
-            test_name = "#{class_name}##{name}"
-
             test_suite_name = Helpers.test_suite_name(self.class, name)
             if Helpers.parallel?(self.class)
               test_suite_name = "#{test_suite_name} (#{name} concurrently)"
@@ -24,13 +22,16 @@ module Datadog
               CI.start_test_suite(test_suite_name)
             end
 
+            source_file, line_number = method(name).source_location
+
             CI.start_test(
-              test_name,
+              name,
               test_suite_name,
               tags: {
                 CI::Ext::Test::TAG_FRAMEWORK => Ext::FRAMEWORK,
                 CI::Ext::Test::TAG_FRAMEWORK_VERSION => CI::Contrib::Minitest::Integration.version.to_s,
-                CI::Ext::Test::TAG_TYPE => CI::Ext::Test::TEST_TYPE
+                CI::Ext::Test::TAG_SOURCE_FILE => Utils::Git.relative_to_root(source_file),
+                CI::Ext::Test::TAG_SOURCE_START => line_number.to_s
               },
               service: datadog_configuration[:service_name]
             )
@@ -40,9 +41,9 @@ module Datadog
             test_span = CI.active_test
             return super unless test_span
 
-            finish_test(test_span, result_code)
+            finish_with_result(test_span, result_code)
             if Helpers.parallel?(self.class)
-              finish_test_suite(test_span.test_suite, result_code)
+              finish_with_result(test_span.test_suite, result_code)
             end
 
             super
@@ -50,23 +51,9 @@ module Datadog
 
           private
 
-          def finish_test(test_span, result_code)
-            finish_with_result(test_span, result_code)
-
-            # mark test suite as failed if any test failed
-            if test_span.failed?
-              test_suite = test_span.test_suite
-              test_suite.failed! if test_suite
-            end
-          end
-
-          def finish_test_suite(test_suite, result_code)
-            return unless test_suite
-
-            finish_with_result(test_suite, result_code)
-          end
-
           def finish_with_result(span, result_code)
+            return unless span
+
             case result_code
             when "."
               span.passed!

data/lib/datadog/ci/contrib/minitest/patcher.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "runner"
+require_relative "reporter"
 require_relative "hooks"
 require_relative "runnable"
 
@@ -18,13 +20,14 @@ module Datadog
           end
 
           def patch
-            require_relative "plugin"
-
-            ::Minitest::Test.include(Hooks)
-            ::Minitest.include(Plugin)
+            # test session start
+            ::Minitest.include(Runner)
+            # test suites (when not executed concurrently)
             ::Minitest::Runnable.include(Runnable)
-
-            ::Minitest.extensions << "datadog_ci"
+            # tests; test suites (when executed concurrently)
+            ::Minitest::Test.include(Hooks)
+            # test session finish
+            ::Minitest::CompositeReporter.include(Reporter)
           end
         end
       end