datadog-ci 1.8.1 → 1.10.0

data/lib/datadog/ci/contrib/integration.rb

@@ -1,147 +1,131 @@
 # frozen_string_literal: true
 
 require_relative "settings"
+require_relative "instrumentation"
 
 module Datadog
   module CI
     module Contrib
-      module Integration
-        @registry = {}
-
-        def self.included(base)
-          base.extend(ClassMethods)
-          base.include(InstanceMethods)
+      class Integration
+        def self.inherited(subclass)
+          Instrumentation.register_integration(subclass)
         end
 
-        def self.register(klass, name)
-          registry[name] = klass.new
+        # List of integrations names that depend on this integration.
+        # Specify when you might need to automatically instrument other integrations (like test runner for the
+        # test framework).
+        def dependants
+          []
         end
 
-        def self.registry
-          @registry
+        # Version of the integration target code in the environment.
+        #
+        # This is the gem version, when the instrumentation target is a Ruby gem.
+        #
+        # If the target for instrumentation has concept of versioning, override {.version},
+        # otherwise override {.available?} and implement a custom target presence check.
+        # @return [Object] the target version
+        def version
+          nil
         end
 
-        # Class-level methods for Integration
-        module ClassMethods
-          def register_as(name)
-            Integration.register(self, name)
-          end
-
-          # Version of the integration target code in the environment.
-          #
-          # This is the gem version, when the instrumentation target is a Ruby gem.
-          #
-          # If the target for instrumentation has concept of versioning, override {.version},
-          # otherwise override {.available?} and implement a custom target presence check.
-          # @return [Object] the target version
-          def version
-            nil
-          end
+        # Is the target available to be instrumented? (e.g. gem installed?)
+        #
+        # The target doesn't have to be loaded (e.g. `require`) yet, but needs to be able
+        # to be loaded before instrumentation can commence.
+        #
+        # By default, {.available?} checks if {.version} returned a non-nil object.
+        #
+        # If the target for instrumentation has concept of versioning, override {.version},
+        # otherwise override {.available?} and implement a custom target presence check.
+        # @return [Boolean] is the target available for instrumentation in this Ruby environment?
+        def available?
+          !version.nil?
+        end
 
-          # Is the target available to be instrumented? (e.g. gem installed?)
-          #
-          # The target doesn't have to be loaded (e.g. `require`) yet, but needs to be able
-          # to be loaded before instrumentation can commence.
-          #
-          # By default, {.available?} checks if {.version} returned a non-nil object.
-          #
-          # If the target for instrumentation has concept of versioning, override {.version},
-          # otherwise override {.available?} and implement a custom target presence check.
-          # @return [Boolean] is the target available for instrumentation in this Ruby environment?
-          def available?
-            !version.nil?
-          end
+        # Is the target loaded into the application? (e.g. gem required? Constant defined?)
+        #
+        # The target's objects should be ready to be referenced by the instrumented when {.loaded}
+        # returns `true`.
+        #
+        # @return [Boolean] is the target ready to be referenced during instrumentation?
+        def loaded?
+          true
+        end
 
-          # Is the target loaded into the application? (e.g. gem required? Constant defined?)
-          #
-          # The target's objects should be ready to be referenced by the instrumented when {.loaded}
-          # returns `true`.
-          #
-          # @return [Boolean] is the target ready to be referenced during instrumentation?
-          def loaded?
-            true
-          end
+        # Is this instrumentation compatible with the available target? (e.g. minimum version met?)
+        # @return [Boolean] is the available target compatible with this instrumentation?
+        def compatible?
+          available?
+        end
 
-          # Is this instrumentation compatible with the available target? (e.g. minimum version met?)
-          # @return [Boolean] is the available target compatible with this instrumentation?
-          def compatible?
-            available?
-          end
+        # Can the patch for this integration be applied?
+        #
+        # By default, this is equivalent to {#available?}, {#loaded?}, and {#compatible?}
+        # all being truthy.
+        def patchable?
+          available? && loaded? && compatible?
+        end
 
-          # Can the patch for this integration be applied?
-          #
-          # By default, this is equivalent to {#available?}, {#loaded?}, and {#compatible?}
-          # all being truthy.
-          def patchable?
-            available? && loaded? && compatible?
-          end
+        # returns the configuration instance.
+        def configuration
+          @configuration ||= new_configuration
         end
 
-        module InstanceMethods
-          # returns the configuration instance.
-          def configuration
-            @configuration ||= new_configuration
-          end
+        def configure(options = {}, &block)
+          configuration.configure(options, &block)
+          configuration
+        end
 
-          def configure(options = {}, &block)
-            configuration.configure(options, &block)
-            configuration
-          end
+        def enabled
+          configuration.enabled
+        end
 
-          # Resets all configuration options
-          def reset_configuration!
-            @configuration = nil
-          end
+        # The patcher module to inject instrumented objects into the instrumentation target.
+        #
+        # {Contrib::Patcher} includes the basic functionality of a patcher. `include`ing
+        # {Contrib::Patcher} into a new module is the recommend way to create a custom patcher.
+        #
+        # @return [Contrib::Patcher] a module that `include`s {Contrib::Patcher}
+        def patcher
+          nil
+        end
 
-          def enabled
-            configuration.enabled
+        # @!visibility private
+        def patch
+          if !patchable? || patcher.nil?
+            return {
+              ok: false,
+              available: available?,
+              loaded: loaded?,
+              compatible: compatible?,
+              patchable: patchable?
+            }
           end
 
-          # The patcher module to inject instrumented objects into the instrumentation target.
-          #
-          # {Contrib::Patcher} includes the basic functionality of a patcher. `include`ing
-          # {Contrib::Patcher} into a new module is the recommend way to create a custom patcher.
-          #
-          # @return [Contrib::Patcher] a module that `include`s {Contrib::Patcher}
-          def patcher
-            nil
-          end
+          patcher.patch
+          {ok: true}
+        end
 
-          # @!visibility private
-          def patch
-            # @type var patcher_klass: untyped
-            patcher_klass = patcher
-            if !self.class.patchable? || patcher_klass.nil?
-              return {
-                available: self.class.available?,
-                loaded: self.class.loaded?,
-                compatible: self.class.compatible?,
-                patchable: self.class.patchable?
-              }
-            end
-
-            patcher_klass.patch
-            true
-          end
+        def patched?
+          patcher&.patched?
+        end
 
-          # Can the patch for this integration be applied automatically?
-          # @return [Boolean] can the tracer activate this instrumentation without explicit user input?
-          def auto_instrument?
-            true
-          end
+        # Can the patch for this integration be applied automatically?
+        # @return [Boolean] can the tracer activate this instrumentation without explicit user input?
+        def late_instrument?
+          false
+        end
 
-          protected
-
-          # Returns a new configuration object for this integration.
-          #
-          # This method normally needs to be overridden for each integration
-          # as their settings, defaults and environment variables are
-          # specific for each integration.
-          #
-          # @return [Datadog::CI::Contrib::Settings] a new, integration-specific settings object
-          def new_configuration
-            Datadog::CI::Contrib::Settings.new
-          end
+        # Returns a new configuration object for this integration.
+        #
+        # This method normally needs to be overridden for each integration
+        # as their settings, defaults and environment variables are
+        # specific for each integration.
+        #
+        # @return [Datadog::CI::Contrib::Settings] a new, integration-specific settings object
+        def new_configuration
+          Datadog::CI::Contrib::Settings.new
         end
       end
     end

data/lib/datadog/ci/contrib/knapsack/extension.rb

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

data/lib/datadog/ci/contrib/knapsack/integration.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../integration"
+require_relative "patcher"
+
+module Datadog
+  module CI
+    module Contrib
+      module Knapsack
+        # Knapsack Pro test runner instrumentation
+        # https://github.com/KnapsackPro/knapsack_pro-ruby
+        class Integration < Contrib::Integration
+          MINIMUM_VERSION = Gem::Version.new("7.0.0")
+
+          def version
+            Gem.loaded_specs["knapsack_pro"]&.version
+          end
+
+          def loaded?
+            !defined?(::KnapsackPro).nil? &&
+              !defined?(::KnapsackPro::Extensions::RSpecExtension).nil? &&
+              !defined?(::KnapsackPro::Extensions::RSpecExtension::Runner).nil?
+          end
+
+          def compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../patcher"
+
+module Datadog
+  module CI
+    module Contrib
+      module Knapsack
+        module Patcher
+          include Datadog::CI::Contrib::Patcher
+
+          module_function
+
+          def patch
+            if ::RSpec::Core::Runner.ancestors.include?(::KnapsackPro::Extensions::RSpecExtension::Runner)
+              # knapsack already patched rspec runner
+              require_relative "runner"
+              ::RSpec::Core::Runner.include(Datadog::CI::Contrib::Knapsack::Runner)
+            else
+              # knapsack didn't patch rspec runner yet
+              require_relative "extension"
+              ::KnapsackPro::Extensions::RSpecExtension.include(Datadog::CI::Contrib::Knapsack::Extension)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/contrib/knapsack/runner.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../../ext/test"
+require_relative "../rspec/ext"
+require_relative "../instrumentation"
+
+module Datadog
+  module CI
+    module Contrib
+      module Knapsack
+        module Runner
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          module InstanceMethods
+            # TODO: this is coupled to RSpec integration being present, not sure if it's bad or not at this point
+            def knapsack__run_specs(*args)
+              return super if ::RSpec.configuration.dry_run? && !datadog_configuration[:dry_run_enabled]
+              return super unless datadog_configuration[:enabled]
+
+              test_session = test_visibility_component.start_test_session(
+                tags: {
+                  CI::Ext::Test::TAG_FRAMEWORK => CI::Contrib::RSpec::Ext::FRAMEWORK,
+                  CI::Ext::Test::TAG_FRAMEWORK_VERSION => datadog_integration.version.to_s
+                },
+                service: datadog_configuration[:service_name]
+              )
+
+              test_module = test_visibility_component.start_test_module(CI::Contrib::RSpec::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_integration
+              CI::Contrib::Instrumentation.fetch_integration(:rspec)
+            end
+
+            def datadog_configuration
+              Datadog.configuration.ci[:rspec]
+            end
+
+            def test_visibility_component
+              Datadog.send(:components).test_visibility
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,30 +9,22 @@ module Datadog
     module Contrib
       module Minitest
         # Description of Minitest integration
-        class Integration
-          include Datadog::CI::Contrib::Integration
-
+        class Integration < Contrib::Integration
           MINIMUM_VERSION = Gem::Version.new("5.0.0")
 
-          register_as :minitest
-
-          def self.version
+          def version
             Gem.loaded_specs["minitest"]&.version
           end
 
-          def self.loaded?
-            !defined?(::Minitest).nil?
+          def loaded?
+            !defined?(::Minitest).nil? && !defined?(::Minitest::Runnable).nil? && !defined?(::Minitest::Test).nil? &&
+              !defined?(::Minitest::CompositeReporter).nil?
           end
 
-          def self.compatible?
+          def compatible?
             super && version >= MINIMUM_VERSION
           end
 
-          # test environments should not auto instrument test libraries
-          def auto_instrument?
-            false
-          end
-
           def new_configuration
             Configuration::Settings.new
           end

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

@@ -11,14 +11,10 @@ module Datadog
       module Minitest
         # Patcher enables patching of 'minitest' module.
         module Patcher
-          include Datadog::Tracing::Contrib::Patcher
+          include Datadog::CI::Contrib::Patcher
 
           module_function
 
-          def target_version
-            Integration.version
-          end
-
           def patch
             # test session start
             ::Minitest.include(Runner)

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../ext/test"
+require_relative "../instrumentation"
 require_relative "ext"
 
 module Datadog
@@ -25,7 +26,7 @@ module Datadog
               test_visibility_component.start_test_session(
                 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_FRAMEWORK_VERSION => datadog_integration.version.to_s
                 },
                 service: datadog_configuration[:service_name],
                 total_tests_count: (DD_ESTIMATED_TESTS_PER_SUITE * ::Minitest::Runnable.runnables.size).to_i
@@ -47,6 +48,10 @@ module Datadog
 
             private
 
+            def datadog_integration
+              CI::Contrib::Instrumentation.fetch_integration(:minitest)
+            end
+
             def datadog_configuration
               Datadog.configuration.ci[:minitest]
             end

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

@@ -2,6 +2,7 @@
 
 require_relative "../../ext/test"
 require_relative "../../git/local_repository"
+require_relative "../instrumentation"
 require_relative "ext"
 require_relative "helpers"
 
@@ -36,7 +37,7 @@ module Datadog
                 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_FRAMEWORK_VERSION => datadog_integration.version.to_s,
                   CI::Ext::Test::TAG_SOURCE_FILE => Git::LocalRepository.relative_to_root(source_file),
                   CI::Ext::Test::TAG_SOURCE_START => line_number.to_s
                 },
@@ -79,6 +80,10 @@ module Datadog
               span.finish
             end
 
+            def datadog_integration
+              CI::Contrib::Instrumentation.fetch_integration(:minitest)
+            end
+
             def datadog_configuration
               Datadog.configuration.ci[:minitest]
             end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "datadog/core/utils/only_once"
+
+module Datadog
+  module CI
+    module Contrib
+      # Common behavior for patcher modules.
+      module Patcher
+        def self.included(base)
+          base.singleton_class.prepend(CommonMethods)
+        end
+
+        # Prepended instance methods for all patchers
+        module CommonMethods
+          attr_accessor \
+            :patch_error_result,
+            :patch_successful
+
+          def patch_name
+            (self.class != Class && self.class != Module) ? self.class.name : name
+          end
+
+          def patched?
+            patch_only_once.ran?
+          end
+
+          def patch
+            return unless defined?(super)
+
+            patch_only_once.run do
+              super.tap do
+                @patch_successful = true
+              end
+            rescue => e
+              on_patch_error(e)
+            end
+          end
+
+          # Processes patching errors. This default implementation logs the error and reports relevant metrics.
+          # @param e [Exception]
+          def on_patch_error(e)
+            Datadog.logger.error("Failed to apply #{patch_name} patch. Cause: #{e} Location: #{Array(e.backtrace).first}")
+
+            @patch_error_result = {
+              type: e.class.name,
+              message: e.message,
+              line: Array(e.backtrace).first
+            }
+          end
+
+          private
+
+          def patch_only_once
+            # NOTE: This is not thread-safe
+            @patch_only_once ||= Datadog::Core::Utils::OnlyOnce.new
+          end
+        end
+      end
+    end
+  end
+end