datadog-ci 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63e9fdf2c856764bb9567cf89d76f27a4f327244152c510abcd4d64e180a0cc6
-  data.tar.gz: 963f5b534027215799efe65a108a4aa8267c2c31aa4fc1402d19d02f996fc2e9
+  metadata.gz: ae9b964bc83f82487cc72d99641bcd08a575c104ec311327d49715d88852d02d
+  data.tar.gz: 7f787507a51166a49e95c9b55049fc68f3b1d0952fa49d7974f857b37b10e56f
 SHA512:
-  metadata.gz: e94bbd5cc929f95a386cadd633b93f2a53962eefe686354712a9801a8b9865a52fc74c6401f96635a47b9001d71287cadc568ba3bb81ed764d68bdf232b85e5b
-  data.tar.gz: 7a33d2dc09b32798f2fcae80a96bec0e919b4c60f65283f4cf158a020ecd573e450bb925c790c822c63a86b4cf214fae4427e7d4bdb6cde28ca1105dcc95a20a
+  metadata.gz: 5947c6dd42ab0d629d1e7eecd2f116ea2c28e89b657e47e80eb0b127caf21e25b68e182ba5f3039671491f9335b0dda917091cbd43f18f64c9136e3e38ef1239
+  data.tar.gz: 7790297ed83c4bfedc4cfb9c2b9116a540c8f7c3cdc78ccd9b5ece5ecb506be427765851834f8abca4594ff5908ca99c4e7f4cd8ab601fe5c0228cf2c62f8971

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 ## [Unreleased]
 
+## [0.8.0] - 2024-03-08
+
+### Added
+
+* gzip agent payloads support via evp_proxy/v4 ([#123][])
+
+### Changed
+
+* Add note to README on using VCR ([#122][])
+
+### Fixed
+
+* use framework name as test module name to make test fingerprints stable ([#131][])
+
+## [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 +164,10 @@ 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.8.0...main
+[0.8.0]: https://github.com/DataDog/datadog-ci-rb/compare/v0.7.0...v0.8.0
+[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 +212,22 @@ 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
+[#122]: https://github.com/DataDog/datadog-ci-rb/issues/122
+[#123]: https://github.com/DataDog/datadog-ci-rb/issues/123
+[#131]: https://github.com/DataDog/datadog-ci-rb/issues/131

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.
@@ -175,7 +175,7 @@ Webmock accordingly.
 ```ruby
 # when using agentless mode
 # note to use the correct datadog site (e.g. datadoghq.eu, etc)
-WebMock.disable_net_connect!(:allow => "citestcycle-intake.datadoghq.com")
+WebMock.disable_net_connect!(:allow => /datadoghq.com/)
 
 # when using agent
 WebMock.disable_net_connect!(:allow_localhost => true)
@@ -184,6 +184,25 @@ WebMock.disable_net_connect!(:allow_localhost => true)
 WebMock.disable_net_connect!(:allow => "localhost:8126")
 ```
 
+### VCR
+
+[VCR](https://github.com/vcr/vcr) is another popular testing library for HTTP interactions.
+
+It requires additional configuration to correctly work with datadog-ci:
+
+```ruby
+VCR.configure do |config|
+  # ... your usual configuration here ...
+
+  # when using agent
+  config.ignore_hosts "127.0.0.1", "localhost"
+
+  # when using agentless mode
+  # note to use the correct datadog site (e.g. datadoghq.eu, etc)
+  config.ignore_hosts "citestcycle-intake.datadoghq.com", "api.datadoghq.com"
+end
+```
+
 ### Disabling startup logs
 
 Startup logs produce a report of tracing state when the application is initially configured.

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

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require "datadog/core/configuration/agent_settings_resolver"
-require "datadog/core/remote/negotiation"
-
-require_relative "../ext/transport"
 require_relative "../ext/settings"
+require_relative "../itr/runner"
 require_relative "../test_visibility/flush"
 require_relative "../test_visibility/recorder"
 require_relative "../test_visibility/null_recorder"
@@ -12,6 +9,7 @@ require_relative "../test_visibility/serializers/factories/test_level"
 require_relative "../test_visibility/serializers/factories/test_suite_level"
 require_relative "../test_visibility/transport"
 require_relative "../transport/api/builder"
+require_relative "../transport/remote_settings_api"
 
 module Datadog
   module CI
@@ -32,18 +30,7 @@ module Datadog
         end
 
         def activate_ci!(settings)
-          test_visibility_transport = nil
-          agent_settings = Datadog::Core::Configuration::AgentSettingsResolver.call(settings)
-
-          if settings.ci.agentless_mode_enabled
-            check_dd_site(settings)
-            test_visibility_transport = build_agentless_transport(settings)
-          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
-          end
-
+          # Configure ddtrace library for CI visibility mode
           # Deactivate telemetry
           settings.telemetry.enabled = false
 
@@ -60,69 +47,84 @@ module Datadog
           # Choose user defined TraceFlush or default to CI TraceFlush
           settings.tracing.test_mode.trace_flush = settings.ci.trace_flush || CI::TestVisibility::Flush::Partial.new
 
+          # transport creation
           writer_options = settings.ci.writer_options
-          if test_visibility_transport
-            writer_options[:transport] = test_visibility_transport
+          test_visibility_api = build_test_visibility_api(settings)
+
+          if test_visibility_api
+            writer_options[:transport] = Datadog::CI::TestVisibility::Transport.new(
+              api: test_visibility_api,
+              serializers_factory: serializers_factory(settings),
+              dd_env: settings.env
+            )
             writer_options[:shutdown_timeout] = 60
             writer_options[:buffer_size] = 10_000
 
             settings.tracing.test_mode.async = true
+          else
+            # only legacy APM protocol is supported, so no test suite level visibility
+            settings.ci.force_test_level_visibility = true
+
+            # ITR is not supported with APM protocol
+            settings.ci.itr_enabled = false
           end
 
           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
+          itr = Datadog::CI::ITR::Runner.new(
+            enabled: settings.ci.enabled && settings.ci.itr_enabled
           )
-        end
 
-        def can_use_evp_proxy?(settings, agent_settings)
-          Datadog::Core::Remote::Negotiation.new(settings, agent_settings).endpoint?(
-            Ext::Transport::EVP_PROXY_PATH_PREFIX
+          remote_settings_api = Transport::RemoteSettingsApi.new(
+            api: test_visibility_api,
+            dd_env: settings.env
+          )
+
+          # CI visibility recorder global instance
+          @ci_recorder = TestVisibility::Recorder.new(
+            test_suite_level_visibility_enabled: !settings.ci.force_test_level_visibility,
+            itr: itr,
+            remote_settings_api: remote_settings_api
           )
         end
 
-        def build_agentless_transport(settings)
-          if settings.api_key.nil?
-            # agentless mode is requested but no API key is provided -
-            # we cannot continue and log an error
-            # Tests are running without CI visibility enabled
+        def build_test_visibility_api(settings)
+          if settings.ci.agentless_mode_enabled
+            check_dd_site(settings)
 
-            Datadog.logger.error(
-              "DATADOG CONFIGURATION - CI VISIBILITY - ATTENTION - " \
-              "Agentless mode was enabled but DD_API_KEY is not set: CI visibility is disabled. " \
-              "Please make sure to set valid api key in DD_API_KEY environment variable"
-            )
+            Datadog.logger.debug("CI visibility configured to use agentless transport")
 
-            settings.ci.enabled = false
+            api = Transport::Api::Builder.build_agentless_api(settings)
+            if api.nil?
+              Datadog.logger.error do
+                "DATADOG CONFIGURATION - CI VISIBILITY - ATTENTION - " \
+                "Agentless mode was enabled but DD_API_KEY is not set: CI visibility is disabled. " \
+                "Please make sure to set valid api key in DD_API_KEY environment variable"
+              end
 
-            nil
-          else
-            Datadog.logger.debug("CI visibility configured to use agentless transport")
+              # Tests are running without CI visibility enabled
+              settings.ci.enabled = false
+            end
 
-            Datadog::CI::TestVisibility::Transport.new(
-              api: Transport::Api::Builder.build_ci_test_cycle_api(settings),
-              serializers_factory: serializers_factory(settings),
-              dd_env: settings.env
-            )
+          else
+            Datadog.logger.debug("CI visibility configured to use agent transport via EVP proxy")
+
+            api = Transport::Api::Builder.build_evp_proxy_api(settings)
+            if api.nil?
+              Datadog.logger.debug(
+                "Old agent version detected, no evp_proxy support. Forcing test level visibility mode"
+              )
+            end
           end
-        end
 
-        def build_evp_proxy_transport(settings, agent_settings)
-          Datadog.logger.debug("CI visibility configured to use agent transport via EVP proxy")
-
-          Datadog::CI::TestVisibility::Transport.new(
-            api: Transport::Api::Builder.build_evp_proxy_api(agent_settings),
-            serializers_factory: serializers_factory(settings),
-            dd_env: settings.env
-          )
+          api
         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
 
@@ -130,11 +132,11 @@ module Datadog
           return if settings.site.nil?
           return if Ext::Settings::DD_SITE_ALLOWLIST.include?(settings.site)
 
-          Datadog.logger.warn(
+          Datadog.logger.warn do
             "CI VISIBILITY CONFIGURATION " \
             "Agentless mode was enabled but DD_SITE is not set to one of the following: #{Ext::Settings::DD_SITE_ALLOWLIST.join(", ")}. " \
             "Please make sure to set valid site in DD_SITE environment variable"
-          )
+          end
         end
       end
     end

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

@@ -34,10 +34,31 @@ 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
+
+              option :itr_enabled do |o|
+                o.type :bool
+                o.env CI::Ext::Settings::ENV_ITR_ENABLED
+                o.default false
               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