datadog-ci 1.0.0.beta2 → 1.0.0.beta4

data/lib/datadog/ci/contrib/rspec/knapsack_pro/extension.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "knapsack_pro/extensions/rspec_extension"
+
+require_relative "runner"
+
+module Datadog
+  module CI
+    module Contrib
+      module RSpec
+        # Instrument RSpec::Core::Example
+        module KnapsackPro
+          module Extension
+            def self.included(base)
+              base.singleton_class.prepend(ClassMethods)
+            end
+
+            module ClassMethods
+              def setup!
+                super
+
+                ::RSpec::Core::Runner.include(Datadog::CI::Contrib::RSpec::KnapsackPro::Runner)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/contrib/rspec/knapsack_pro/runner.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../../../ext/test"
+require_relative "../ext"
+
+module Datadog
+  module CI
+    module Contrib
+      module RSpec
+        module KnapsackPro
+          module Runner
+            def self.included(base)
+              base.prepend(InstanceMethods)
+            end
+
+            module InstanceMethods
+              def knapsack__run_specs(*)
+                return super unless datadog_configuration[:enabled]
+
+                test_session = CI.start_test_session(
+                  tags: {
+                    CI::Ext::Test::TAG_FRAMEWORK => Ext::FRAMEWORK,
+                    CI::Ext::Test::TAG_FRAMEWORK_VERSION => CI::Contrib::RSpec::Integration.version.to_s
+                  },
+                  service: datadog_configuration[:service_name]
+                )
+
+                test_module = CI.start_test_module(Ext::FRAMEWORK)
+
+                result = super
+                return result unless test_module && test_session
+
+                if result != 0
+                  test_module.failed!
+                  test_session.failed!
+                else
+                  test_module.passed!
+                  test_session.passed!
+                end
+                test_module.finish
+                test_session.finish
+
+                result
+              end
+
+              private
+
+              def datadog_configuration
+                Datadog.configuration.ci[:rspec]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,19 +21,35 @@ module Datadog
           end
 
           def patch
+            # ci-queue test runner instrumentation
+            # https://github.com/Shopify/ci-queue
             if ci_queue?
               ::RSpec::Queue::Runner.include(Runner)
             end
 
+            # Knapsack Pro test runner instrumentation
+            # https://github.com/KnapsackPro/knapsack_pro-ruby
+            if knapsack_pro?
+              require_relative "knapsack_pro/extension"
+              ::KnapsackPro::Extensions::RSpecExtension.include(KnapsackPro::Extension)
+            end
+
             ::RSpec::Core::Runner.include(Runner)
             ::RSpec::Core::Example.include(Example)
             ::RSpec::Core::ExampleGroup.include(ExampleGroup)
           end
 
           def ci_queue?
-            # ::RSpec::Queue::Runner is a ci-queue runner
             defined?(::RSpec::Queue::Runner)
           end
+
+          def knapsack_pro?
+            knapsack_version = Gem.loaded_specs["knapsack_pro"]&.version
+
+            # additional instrumentation is needed for KnapsackPro version 7 and later
+            defined?(::KnapsackPro) &&
+              knapsack_version && knapsack_version >= Gem::Version.new("7")
+          end
         end
       end
     end

data/lib/datadog/ci/ext/environment.rb

@@ -23,6 +23,11 @@ module Datadog
         TAG_NODE_NAME = "ci.node.name"
         TAG_CI_ENV_VARS = "_dd.ci.env_vars"
 
+        POSSIBLE_BUNDLE_LOCATIONS = [
+          "vendor/bundle",
+          ".bundle"
+        ].freeze
+
         module_function
 
         def tags(env)

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

@@ -12,6 +12,7 @@ module Datadog
         ENV_FORCE_TEST_LEVEL_VISIBILITY = "DD_CIVISIBILITY_FORCE_TEST_LEVEL_VISIBILITY"
         ENV_ITR_ENABLED = "DD_CIVISIBILITY_ITR_ENABLED"
         ENV_GIT_METADATA_UPLOAD_ENABLED = "DD_CIVISIBILITY_GIT_METADATA_UPLOAD_ENABLED"
+        ENV_ITR_CODE_COVERAGE_EXCLUDED_BUNDLE_PATH = "DD_CIVISIBILITY_ITR_CODE_COVERAGE_EXCLUDED_BUNDLE_PATH"
 
         # Source: https://docs.datadoghq.com/getting_started/site/
         DD_SITE_ALLOWLIST = [

data/lib/datadog/ci/ext/test.rb

@@ -8,7 +8,6 @@ module Datadog
       module Test
         CONTEXT_ORIGIN = "ciapp-test"
 
-        TAG_ARGUMENTS = "test.arguments"
         TAG_FRAMEWORK = "test.framework"
         TAG_FRAMEWORK_VERSION = "test.framework_version"
         TAG_NAME = "test.name"
@@ -29,6 +28,8 @@ module Datadog
         TAG_ITR_TEST_SKIPPING_COUNT = "test.itr.tests_skipping.count"
         TAG_ITR_SKIPPED_BY_ITR = "test.skipped_by_itr"
         TAG_ITR_TESTS_SKIPPED = "_dd.ci.itr.tests_skipped"
+        TAG_ITR_UNSKIPPABLE = "test.itr.unskippable"
+        TAG_ITR_FORCED_RUN = "test.itr.forced_run"
 
         # Code coverage tags
         TAG_CODE_COVERAGE_ENABLED = "test.code_coverage.enabled"
@@ -58,6 +59,7 @@ module Datadog
         # we use test skipping for Ruby
         ITR_TEST_SKIPPING_MODE = "test"
         ITR_TEST_SKIP_REASON = "Skipped by Datadog's intelligent test runner"
+        ITR_UNSKIPPABLE_OPTION = :datadog_itr_unskippable
 
         # test status as recognized by Datadog
         module Status

data/lib/datadog/ci/itr/coverage/writer.rb

@@ -58,9 +58,15 @@ module Datadog
           def perform(*events)
             responses = transport.send_events(events)
 
-            loop_back_off! if responses.find(&:server_error?)
+            if responses.find(&:server_error?)
+              loop_back_off!
+              Datadog.logger.warn { "Encountered server error while sending coverage events" }
+            end
 
             nil
+          rescue => e
+            Datadog.logger.warn { "Error while sending coverage events: #{e}" }
+            loop_back_off!
           end
 
           def stop(force_stop = false, timeout = @shutdown_timeout)

data/lib/datadog/ci/itr/runner.rb

@@ -27,13 +27,22 @@ module Datadog
 
         def initialize(
           dd_env:,
+          config_tags: {},
           api: nil,
           coverage_writer: nil,
-          enabled: false
+          enabled: false,
+          bundle_location: nil
         )
           @enabled = enabled
           @api = api
           @dd_env = dd_env
+          @config_tags = config_tags || {}
+
+          @bundle_location = if bundle_location && !File.absolute_path?(bundle_location)
+            File.join(Git::LocalRepository.root, bundle_location)
+          else
+            bundle_location
+          end
 
           @test_skipping_enabled = false
           @code_coverage_enabled = false
@@ -41,7 +50,7 @@ module Datadog
           @coverage_writer = coverage_writer
 
           @correlation_id = nil
-          @skippable_tests = []
+          @skippable_tests = Set.new
 
           @skipped_tests_count = 0
           @mutex = Mutex.new
@@ -127,6 +136,11 @@ module Datadog
 
           skippable_test_id = Utils::TestRun.skippable_test_id(test.name, test.test_suite_name, test.parameters)
           if @skippable_tests.include?(skippable_test_id)
+            if forked?
+              Datadog.logger.warn { "ITR is not supported for forking test runners yet" }
+              return
+            end
+
             test.set_tag(Ext::Test::TAG_ITR_SKIPPED_BY_ITR, "true")
 
             Datadog.logger.debug { "Marked test as skippable: #{skippable_test_id}" }
@@ -136,13 +150,13 @@ module Datadog
         end
 
         def count_skipped_test(test)
+          return if !test.skipped? || !test.skipped_by_itr?
+
           if forked?
             Datadog.logger.warn { "ITR is not supported for forking test runners yet" }
             return
           end
 
-          return if !test.skipped? || !test.skipped_by_itr?
-
           @mutex.synchronize do
             @skipped_tests_count += 1
           end
@@ -151,6 +165,9 @@ module Datadog
         def write_test_session_tags(test_session)
           return if !enabled?
 
+          Datadog.logger.debug { "Finished ITR session with test skipping enabled: #{@test_skipping_enabled}" }
+          Datadog.logger.debug { "#{@skipped_tests_count} tests were skipped" }
+
           test_session.set_tag(Ext::Test::TAG_ITR_TESTS_SKIPPED, @skipped_tests_count.positive?.to_s)
           test_session.set_tag(Ext::Test::TAG_ITR_TEST_SKIPPING_COUNT, @skipped_tests_count)
         end
@@ -167,7 +184,10 @@ module Datadog
         end
 
         def coverage_collector
-          Thread.current[:dd_coverage_collector] ||= Coverage::DDCov.new(root: Git::LocalRepository.root)
+          Thread.current[:dd_coverage_collector] ||= Coverage::DDCov.new(
+            root: Git::LocalRepository.root,
+            ignored_path: @bundle_location
+          )
         end
 
         def load_datadog_cov!
@@ -191,11 +211,15 @@ module Datadog
           # we can only request skippable tests if git metadata is already uploaded
           git_tree_upload_worker.wait_until_done
 
-          skippable_response = Skippable.new(api: @api, dd_env: @dd_env).fetch_skippable_tests(test_session)
+          skippable_response =
+            Skippable.new(api: @api, dd_env: @dd_env, config_tags: @config_tags)
+              .fetch_skippable_tests(test_session)
+
           @correlation_id = skippable_response.correlation_id
           @skippable_tests = skippable_response.tests
 
           Datadog.logger.debug { "Fetched skippable tests: \n #{@skippable_tests}" }
+          Datadog.logger.debug { "Found #{@skippable_tests.count} skippable tests." }
           Datadog.logger.debug { "ITR correlation ID: #{@correlation_id}" }
         end
       end

data/lib/datadog/ci/itr/skippable.rb

@@ -57,9 +57,10 @@ module Datadog
           end
         end
 
-        def initialize(dd_env:, api: nil)
+        def initialize(dd_env:, api: nil, config_tags: {})
           @api = api
           @dd_env = dd_env
+          @config_tags = config_tags
         end
 
         def fetch_skippable_tests(test_session)
@@ -94,7 +95,8 @@ module Datadog
                   Ext::Test::TAG_OS_ARCHITECTURE => test_session.os_architecture,
                   Ext::Test::TAG_OS_VERSION => test_session.os_version,
                   Ext::Test::TAG_RUNTIME_NAME => test_session.runtime_name,
-                  Ext::Test::TAG_RUNTIME_VERSION => test_session.runtime_version
+                  Ext::Test::TAG_RUNTIME_VERSION => test_session.runtime_version,
+                  "custom" => @config_tags
                 }
               }
             }

data/lib/datadog/ci/span.rb

@@ -102,6 +102,13 @@ module Datadog
         tracer_span.set_tag(key, value)
       end
 
+      # Removes tag by key.
+      # @param [String] key the key of the tag.
+      # @return [void]
+      def clear_tag(key)
+        tracer_span.clear_tag(key)
+      end
+
       # Sets metric value by key.
       # @param [String] key the key of the metric.
       # @param [Numeric] value the value of the metric.

data/lib/datadog/ci/test.rb

@@ -69,6 +69,24 @@ module Datadog
         get_tag(Ext::Test::TAG_ITR_SKIPPED_BY_ITR) == "true"
       end
 
+      # Marks this test as unskippable by the intelligent test runner.
+      # This must be done before the test execution starts.
+      #
+      # Examples of tests that should be unskippable:
+      # - tests that read files from disk
+      # - tests that make network requests
+      # - tests that call external processes
+      # - tests that use forking or threading
+      #
+      # @return [void]
+      def itr_unskippable!
+        set_tag(Ext::Test::TAG_ITR_UNSKIPPABLE, "true")
+        if skipped_by_itr?
+          clear_tag(Ext::Test::TAG_ITR_SKIPPED_BY_ITR)
+          set_tag(Ext::Test::TAG_ITR_FORCED_RUN, "true")
+        end
+      end
+
       # Sets the status of the span to "pass".
       # @return [void]
       def passed!

data/lib/datadog/ci/test_visibility/serializers/base.rb

@@ -28,11 +28,12 @@ module Datadog
             "duration"
           ].freeze
 
-          attr_reader :trace, :span, :meta
+          attr_reader :trace, :span, :meta, :options
 
-          def initialize(trace, span)
+          def initialize(trace, span, options: {})
             @trace = trace
             @span = span
+            @options = options
 
             @meta = @span.meta.reject { |key, _| Ext::Test::TRANSIENT_TAGS.include?(key) }
 

data/lib/datadog/ci/test_visibility/serializers/factories/test_level.rb

@@ -14,12 +14,12 @@ module Datadog
           module TestLevel
             module_function
 
-            def serializer(trace, span)
+            def serializer(trace, span, options: {})
               case span.type
               when Datadog::CI::Ext::AppTypes::TYPE_TEST
-                Serializers::TestV1.new(trace, span)
+                Serializers::TestV1.new(trace, span, options: options)
               else
-                Serializers::Span.new(trace, span)
+                Serializers::Span.new(trace, span, options: options)
               end
             end
           end

data/lib/datadog/ci/test_visibility/serializers/factories/test_suite_level.rb

@@ -15,18 +15,18 @@ module Datadog
           module TestSuiteLevel
             module_function
 
-            def serializer(trace, span)
+            def serializer(trace, span, options: {})
               case span.type
               when Datadog::CI::Ext::AppTypes::TYPE_TEST
-                Serializers::TestV2.new(trace, span)
+                Serializers::TestV2.new(trace, span, options: options)
               when Datadog::CI::Ext::AppTypes::TYPE_TEST_SESSION
-                Serializers::TestSession.new(trace, span)
+                Serializers::TestSession.new(trace, span, options: options)
               when Datadog::CI::Ext::AppTypes::TYPE_TEST_MODULE
-                Serializers::TestModule.new(trace, span)
+                Serializers::TestModule.new(trace, span, options: options)
               when Datadog::CI::Ext::AppTypes::TYPE_TEST_SUITE
-                Serializers::TestSuite.new(trace, span)
+                Serializers::TestSuite.new(trace, span, options: options)
               else
-                Serializers::Span.new(trace, span)
+                Serializers::Span.new(trace, span, options: options)
               end
             end
           end

data/lib/datadog/ci/test_visibility/serializers/test_v2.rb

@@ -10,22 +10,34 @@ module Datadog
         class TestV2 < TestV1
           CONTENT_FIELDS = (["test_session_id", "test_module_id", "test_suite_id"] + TestV1::CONTENT_FIELDS).freeze
 
+          CONTENT_FIELDS_WITH_ITR_CORRELATION_ID = (CONTENT_FIELDS + ["itr_correlation_id"]).freeze
+
           CONTENT_MAP_SIZE = calculate_content_map_size(CONTENT_FIELDS)
 
+          CONTENT_MAP_SIZE_WITH_ITR_CORRELATION_ID = calculate_content_map_size(CONTENT_FIELDS_WITH_ITR_CORRELATION_ID)
+
           REQUIRED_FIELDS = (["test_session_id", "test_module_id", "test_suite_id"] + TestV1::REQUIRED_FIELDS).freeze
 
           def content_fields
-            CONTENT_FIELDS
+            return CONTENT_FIELDS if itr_correlation_id.nil?
+
+            CONTENT_FIELDS_WITH_ITR_CORRELATION_ID
           end
 
           def content_map_size
-            CONTENT_MAP_SIZE
+            return CONTENT_MAP_SIZE if itr_correlation_id.nil?
+
+            CONTENT_MAP_SIZE_WITH_ITR_CORRELATION_ID
           end
 
           def version
             2
           end
 
+          def itr_correlation_id
+            options[:itr_correlation_id]
+          end
+
           private
 
           def required_fields

data/lib/datadog/ci/test_visibility/transport.rb

@@ -45,7 +45,7 @@ module Datadog
         end
 
         def encode_span(trace, span)
-          serializer = serializers_factory.serializer(trace, span)
+          serializer = serializers_factory.serializer(trace, span, options: {itr_correlation_id: itr&.correlation_id})
 
           if serializer.valid?
             encoded = encoder.encode(serializer)
@@ -98,6 +98,10 @@ module Datadog
 
           packer.write("events")
         end
+
+        def itr
+          @itr ||= Datadog::CI.send(:itr_runner)
+        end
       end
     end
   end

data/lib/datadog/ci/transport/remote_settings_api.rb

@@ -51,9 +51,10 @@ module Datadog
           end
         end
 
-        def initialize(dd_env:, api: nil)
+        def initialize(dd_env:, api: nil, config_tags: {})
           @api = api
           @dd_env = dd_env
+          @config_tags = config_tags || {}
         end
 
         def fetch_library_settings(test_session)
@@ -90,7 +91,8 @@ module Datadog
                   Ext::Test::TAG_OS_ARCHITECTURE => test_session.os_architecture,
                   Ext::Test::TAG_OS_VERSION => test_session.os_version,
                   Ext::Test::TAG_RUNTIME_NAME => test_session.runtime_name,
-                  Ext::Test::TAG_RUNTIME_VERSION => test_session.runtime_version
+                  Ext::Test::TAG_RUNTIME_VERSION => test_session.runtime_version,
+                  "custom" => @config_tags
                 }
               }
             }

data/lib/datadog/ci/utils/bundle.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../ext/environment"
+require_relative "../git/local_repository"
+
+module Datadog
+  module CI
+    module Utils
+      module Bundle
+        def self.location
+          require "bundler"
+          bundle_path = Bundler.bundle_path.to_s
+          bundle_path if bundle_path&.start_with?(Datadog::CI::Git::LocalRepository.root)
+        rescue => e
+          Datadog.logger.warn("Failed to find bundled gems location: #{e}")
+
+          Ext::Environment::POSSIBLE_BUNDLE_LOCATIONS.each do |location|
+            path = File.join(Datadog::CI::Git::LocalRepository.root, location)
+            return path if File.directory?(path)
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/utils/test_run.rb

@@ -22,6 +22,18 @@ module Datadog
             }
           )
         end
+
+        def self.custom_configuration(env_tags)
+          return {} if env_tags.nil?
+
+          res = {}
+          env_tags.each do |tag, value|
+            next unless tag.start_with?("test.configuration.")
+
+            res[tag.sub("test.configuration.", "")] = value
+          end
+          res
+        end
       end
     end
   end

data/lib/datadog/ci/version.rb

@@ -6,7 +6,7 @@ module Datadog
       MAJOR = "1"
       MINOR = "0"
       PATCH = "0"
-      PRE = "beta2"
+      PRE = "beta4"
       BUILD = nil
       # PRE and BUILD above are modified for dev gems during gem build GHA workflow
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog-ci
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta2
+  version: 1.0.0.beta4
 platform: ruby
 authors:
 - Datadog, Inc.
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-24 00:00:00.000000000 Z
+date: 2024-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: datadog
@@ -77,17 +77,19 @@ files:
 - lib/datadog/ci/contrib/minitest/configuration/settings.rb
 - lib/datadog/ci/contrib/minitest/ext.rb
 - lib/datadog/ci/contrib/minitest/helpers.rb
-- lib/datadog/ci/contrib/minitest/hooks.rb
 - lib/datadog/ci/contrib/minitest/integration.rb
 - lib/datadog/ci/contrib/minitest/patcher.rb
 - lib/datadog/ci/contrib/minitest/reporter.rb
 - lib/datadog/ci/contrib/minitest/runnable.rb
 - lib/datadog/ci/contrib/minitest/runner.rb
+- lib/datadog/ci/contrib/minitest/test.rb
 - lib/datadog/ci/contrib/rspec/configuration/settings.rb
 - lib/datadog/ci/contrib/rspec/example.rb
 - lib/datadog/ci/contrib/rspec/example_group.rb
 - lib/datadog/ci/contrib/rspec/ext.rb
 - lib/datadog/ci/contrib/rspec/integration.rb
+- lib/datadog/ci/contrib/rspec/knapsack_pro/extension.rb
+- lib/datadog/ci/contrib/rspec/knapsack_pro/runner.rb
 - lib/datadog/ci/contrib/rspec/patcher.rb
 - lib/datadog/ci/contrib/rspec/runner.rb
 - lib/datadog/ci/contrib/settings.rb
@@ -156,6 +158,7 @@ files:
 - lib/datadog/ci/transport/gzip.rb
 - lib/datadog/ci/transport/http.rb
 - lib/datadog/ci/transport/remote_settings_api.rb
+- lib/datadog/ci/utils/bundle.rb
 - lib/datadog/ci/utils/configuration.rb
 - lib/datadog/ci/utils/git.rb
 - lib/datadog/ci/utils/parsing.rb
@@ -170,7 +173,7 @@ metadata:
   changelog_uri: https://github.com/DataDog/datadog-ci-rb/blob/main/CHANGELOG.md
   homepage_uri: https://github.com/DataDog/datadog-ci-rb
   source_code_uri: https://github.com/DataDog/datadog-ci-rb
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -188,8 +191,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.5.6
-signing_key:
+rubygems_version: 3.4.19
+signing_key: 
 specification_version: 4
 summary: Datadog CI visibility for your ruby application
 test_files: []