datadog-ci 0.5.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85bb3584dc8081e8f6e8531d2a600e3948f4f9ea23d551dd99df0eab9daf2a3c
-  data.tar.gz: b6f686d49d3dbb1695c0f6e20b434b77648a118c32e1691f4a0f30b13d38dc62
+  metadata.gz: 14828e8c64b8eeb9c04d4ae2563e568b3b920b587f8e97e628896b143219daf0
+  data.tar.gz: b538d180acd0c18e1d8070adfdcd9f44dad65331048619de40db04cd876dfe01
 SHA512:
-  metadata.gz: 8e8ae716ea7c7408c59c11efa5a3bc30e0767a02c659e231f1cec2a02d5494d451c1e2b43c7c16240cbe7c9418f004ead32faa09b08c83bcd878156fa1062ae9
-  data.tar.gz: 15bdfb45e32660356fcc4c5726c4a640c78cfc2d5007807623f532a0b7c321f0b11a32d0a75f571a64ae263159d4b86b0a750dda5d7e8a5c33f9c110bf7682a0
+  metadata.gz: 60f8fda5f530404027669902b194c7e056af834c882adbc2b7d350eb62f7f75c2d63dae23bf6e98a8bebea0cc8ec34d4f5416fe667d1c30dff1fdb7ebb42854d
+  data.tar.gz: 1b2ad405dee8a1dd2ce24c3d5738ddcbc751f85d5aa5c29a287b614dcfc0a4764230a3b53e59967247fd0f64711fd81fc3863e49895098e7664aa81a3bf1b8e6

data/CHANGELOG.md

@@ -1,5 +1,43 @@
 ## [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
+
+* Test suite level visibility instrumentation for RSpec ([#86][])
+* Test suite level visibility instrumentation for Cucumber ([#90][])
+* Test suite level visibility instrumentation for Minitest framework ([#92][])
+
+### Fixed
+
+* Do not instantiate TestVisibility::Recorder unless CI visibility is enabled ([#89][])
+
 ## [0.5.1] - 2023-12-11
 
 ### Fixed
@@ -112,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
@@ -153,4 +193,23 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#82]: https://github.com/DataDog/datadog-ci-rb/issues/82
 [#84]: https://github.com/DataDog/datadog-ci-rb/issues/84
 [#85]: https://github.com/DataDog/datadog-ci-rb/issues/85
+[#86]: https://github.com/DataDog/datadog-ci-rb/issues/86
 [#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
+[#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

@@ -7,6 +7,7 @@ require_relative "../ext/transport"
 require_relative "../ext/settings"
 require_relative "../test_visibility/flush"
 require_relative "../test_visibility/recorder"
+require_relative "../test_visibility/null_recorder"
 require_relative "../test_visibility/serializers/factories/test_level"
 require_relative "../test_visibility/serializers/factories/test_suite_level"
 require_relative "../test_visibility/transport"
@@ -21,14 +22,12 @@ module Datadog
 
         def initialize(settings)
           # Activate CI mode if enabled
-          activate_ci!(settings) if settings.ci.enabled
-
-          @ci_recorder = TestVisibility::Recorder.new(
-            enabled: settings.ci.enabled,
-            test_suite_level_visibility_enabled: settings.ci.experimental_test_suite_level_visibility_enabled
-          )
+          if settings.ci.enabled
+            activate_ci!(settings)
+          else
+            @ci_recorder = TestVisibility::NullRecorder.new
+          end
 
-          # Initialize normally
           super
         end
 
@@ -42,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
@@ -65,11 +64,16 @@ module Datadog
           if test_visibility_transport
             writer_options[:transport] = test_visibility_transport
             writer_options[:shutdown_timeout] = 60
+            writer_options[:buffer_size] = 10_000
 
             settings.tracing.test_mode.async = true
           end
 
           settings.tracing.test_mode.writer_options = writer_options
+
+          @ci_recorder = TestVisibility::Recorder.new(
+            test_suite_level_visibility_enabled: !settings.ci.force_test_level_visibility
+          )
         end
 
         def can_use_evp_proxy?(settings, agent_settings)
@@ -115,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::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/ext.rb

@@ -7,14 +7,16 @@ module Datadog
         # Cucumber integration constants
         # TODO: mark as `@public_api` when GA, to protect from resource and tag name changes.
         module Ext
-          APP = "cucumber"
           ENV_ENABLED = "DD_TRACE_CUCUMBER_ENABLED"
-          ENV_OPERATION_NAME = "DD_TRACE_CUCUMBER_OPERATION_NAME"
+          DEFAULT_SERVICE_NAME = "cucumber"
+
           FRAMEWORK = "cucumber"
-          OPERATION_NAME = "cucumber.test"
-          SERVICE_NAME = "cucumber"
+
           STEP_SPAN_TYPE = "step"
-          TEST_TYPE = "test"
+
+          # TODO: remove in 1.0
+          ENV_OPERATION_NAME = "DD_TRACE_CUCUMBER_OPERATION_NAME"
+          OPERATION_NAME = "cucumber.test"
         end
       end
     end

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
@@ -9,71 +10,181 @@ module Datadog
       module Cucumber
         # Defines collection of instrumented Cucumber events
         class Formatter
-          attr_reader :config, :current_feature_span, :current_step_span
+          attr_reader :config
           private :config
-          private :current_feature_span, :current_step_span
 
           def initialize(config)
+            @ast_lookup = ::Cucumber::Formatter::AstLookup.new(config) if defined?(::Cucumber::Formatter::AstLookup)
             @config = config
 
+            @current_test_suite = nil
+
+            @failed_tests_count = 0
+
             bind_events(config)
           end
 
           def bind_events(config)
+            config.on_event :test_run_started, &method(:on_test_run_started)
+            config.on_event :test_run_finished, &method(:on_test_run_finished)
             config.on_event :test_case_started, &method(:on_test_case_started)
             config.on_event :test_case_finished, &method(:on_test_case_finished)
             config.on_event :test_step_started, &method(:on_test_step_started)
             config.on_event :test_step_finished, &method(:on_test_step_finished)
           end
 
-          def on_test_case_started(event)
-            CI.start_test(
-              event.test_case.name,
-              event.test_case.location.file,
+          def on_test_run_started(event)
+            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 => Ext::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) if test_session
+          end
+
+          def on_test_run_finished(event)
+            if event.respond_to?(:success)
+              finish_session(event.success)
+            else
+              finish_session(@failed_tests_count.zero?)
+            end
+          end
+
+          def on_test_case_started(event)
+            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)
+
+            test_span = CI.start_test(
+              event.test_case.name,
+              test_suite_name,
+              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?
 
-            if event.result.skipped?
-              test_span.skipped!
-            elsif event.result.ok?
-              test_span.passed!
-            elsif event.result.failed?
-              test_span.failed!
-            end
-
-            test_span.finish
+            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?
 
-            if event.result.skipped?
-              current_step_span.skipped!
-            elsif event.result.ok?
-              current_step_span.passed!
-            elsif event.result.failed?
-              current_step_span.failed!(exception: event.result.exception)
+            finish_span(current_step_span, event.result)
+          end
+
+          private
+
+          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
 
-            current_step_span.finish
+            if feature
+              "#{feature.name} at #{test_case.location.file}"
+            else
+              test_case.location.file
+            end
           end
 
-          private
+          def finish_span(span, result)
+            if !result.passed? && result.ok?(@config.strict)
+              span.skipped!(reason: result.message)
+            elsif result.passed?
+              span.passed!
+            else
+              span.failed!(exception: result.exception)
+            end
+            span.finish
+          end
+
+          def finish_session(result)
+            finish_current_test_suite
+
+            test_session = CI.active_test_session
+            test_module = CI.active_test_module
+
+            return unless test_session && test_module
+
+            if result
+              test_module.passed!
+              test_session.passed!
+            else
+              test_module.failed!
+              test_session.failed!
+            end
+
+            test_module.finish
+            test_session.finish
+          end
+
+          def start_test_suite(test_suite_name)
+            finish_current_test_suite
+
+            @current_test_suite = CI.start_test_suite(test_suite_name)
+          end
+
+          def finish_current_test_suite
+            test_suite = @current_test_suite
+            return unless test_suite
+
+            test_suite.finish
+
+            @current_test_suite = nil
+          end
+
+          def same_test_suite_as_current?(test_suite_name)
+            test_suite = @current_test_suite
+            return false unless test_suite
+
+            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]

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::SERVICE_NAME }
+              o.default do
+                Utils::Configuration.fetch_service_name(Ext::DEFAULT_SERVICE_NAME)
+              end
             end
 
             # @deprecated Will be removed in 1.0