datadog-ci 0.4.1 → 0.5.1

data/lib/datadog/ci/span.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "ext/test"
+require_relative "utils/test_run"
 
 module Datadog
   module CI
@@ -15,11 +16,21 @@ module Datadog
         @tracer_span = tracer_span
       end
 
+      # @return [Integer] the ID of the span.
+      def id
+        tracer_span.id
+      end
+
       # @return [String] the name of the span.
       def name
         tracer_span.name
       end
 
+      # @return [String] the service name of the span.
+      def service
+        tracer_span.service
+      end
+
       # @return [String] the type of the span (for example "test" or type that was provided to [Datadog::CI.trace]).
       def span_type
         tracer_span.type
@@ -83,9 +94,7 @@ module Datadog
       # @param [Hash[String, String]] tags the tags to set.
       # @return [void]
       def set_tags(tags)
-        tags.each do |key, value|
-          tracer_span.set_tag(key, value)
-        end
+        tracer_span.set_tags(tags)
       end
 
       def set_environment_runtime_tags
@@ -93,6 +102,7 @@ module Datadog
         tracer_span.set_tag(Ext::Test::TAG_OS_PLATFORM, ::RbConfig::CONFIG["host_os"])
         tracer_span.set_tag(Ext::Test::TAG_RUNTIME_NAME, Core::Environment::Ext::LANG_ENGINE)
         tracer_span.set_tag(Ext::Test::TAG_RUNTIME_VERSION, Core::Environment::Ext::ENGINE_VERSION)
+        tracer_span.set_tag(Ext::Test::TAG_COMMAND, Utils::TestRun.command)
       end
 
       def set_default_tags

data/lib/datadog/ci/test.rb

@@ -5,7 +5,6 @@ require_relative "span"
 module Datadog
   module CI
     # Represents a single part of a test run.
-    # Could be a session, suite, test, or any custom span.
     #
     # @public_api
     class Test < Span

data/lib/datadog/ci/test_module.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "concurrent_span"
+
+module Datadog
+  module CI
+    # Represents a single test module.
+    # Read here on what test module could mean:
+    # https://docs.datadoghq.com/continuous_integration/explorer/?tab=testruns#module
+    # This object can be shared between multiple threads.
+    #
+    # @public_api
+    class TestModule < ConcurrentSpan
+      # Finishes this test module.
+      # @return [void]
+      def finish
+        super
+
+        CI.deactivate_test_module
+      end
+    end
+  end
+end

data/lib/datadog/ci/test_session.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "concurrent_span"
+require_relative "ext/test"
+
+module Datadog
+  module CI
+    # Represents the whole test session process.
+    # Documentation on test sessions is here:
+    # https://docs.datadoghq.com/continuous_integration/explorer/?tab=testruns#sessions
+    # This object can be shared between multiple threads.
+    #
+    # @public_api
+    class TestSession < ConcurrentSpan
+      # Finishes the current test session.
+      # @return [void]
+      def finish
+        super
+
+        CI.deactivate_test_session
+      end
+
+      def inheritable_tags
+        return @inheritable_tags if defined?(@inheritable_tags)
+
+        # this method is not synchronized because it does not iterate over the tags collection, but rather
+        # uses synchronized method to get each tag value
+        res = {}
+        Ext::Test::INHERITABLE_TAGS.each do |tag|
+          res[tag] = get_tag(tag)
+        end
+        @inheritable_tags = res.freeze
+      end
+    end
+  end
+end

data/lib/datadog/ci/test_suite.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "concurrent_span"
+
+module Datadog
+  module CI
+    # Represents a single test suite.
+    #
+    # Read here on what test suite means:
+    # https://docs.datadoghq.com/continuous_integration/explorer/?tab=testruns#suite
+    #
+    # This object can be shared between multiple threads.
+    #
+    # @public_api
+    class TestSuite < ConcurrentSpan
+      # Finishes this test suite.
+      # @return [void]
+      def finish
+        super
+
+        CI.deactivate_test_suite(name)
+      end
+    end
+  end
+end

data/lib/datadog/ci/test_visibility/context/global.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module TestVisibility
+      module Context
+        # This context is shared between threads and represents the current test session and test module.
+        class Global
+          def initialize
+            # we are using Monitor instead of Mutex because it is reentrant
+            @mutex = Monitor.new
+
+            @test_session = nil
+            @test_module = nil
+            @test_suites = {}
+          end
+
+          def fetch_or_activate_test_suite(test_suite_name, &block)
+            @mutex.synchronize do
+              @test_suites[test_suite_name] ||= block.call
+            end
+          end
+
+          def fetch_or_activate_test_module(&block)
+            @mutex.synchronize do
+              @test_module ||= block.call
+            end
+          end
+
+          def fetch_or_activate_test_session(&block)
+            @mutex.synchronize do
+              @test_session ||= block.call
+            end
+          end
+
+          def active_test_module
+            @test_module
+          end
+
+          def active_test_session
+            @test_session
+          end
+
+          def active_test_suite(test_suite_name)
+            @mutex.synchronize { @test_suites[test_suite_name] }
+          end
+
+          def service
+            @mutex.synchronize do
+              # thank you RBS for this weirdness
+              test_session = @test_session
+              test_session.service if test_session
+            end
+          end
+
+          def inheritable_session_tags
+            @mutex.synchronize do
+              test_session = @test_session
+              if test_session
+                test_session.inheritable_tags
+              else
+                {}
+              end
+            end
+          end
+
+          def deactivate_test_session!
+            @mutex.synchronize { @test_session = nil }
+          end
+
+          def deactivate_test_module!
+            @mutex.synchronize { @test_module = nil }
+          end
+
+          def deactivate_test_suite!(test_suite_name)
+            @mutex.synchronize { @test_suites.delete(test_suite_name) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/test_visibility/context/local.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module TestVisibility
+      module Context
+        class Local
+          def initialize
+            @key = :datadog_ci_active_test
+
+            self.active_test = nil
+          end
+
+          def activate_test!(test)
+            raise "Nested tests are not supported. Currently active test: #{active_test}" unless active_test.nil?
+
+            if block_given?
+              begin
+                self.active_test = test
+                yield
+              ensure
+                self.active_test = nil
+              end
+            else
+              self.active_test = test
+            end
+          end
+
+          def deactivate_test!(test)
+            return if active_test.nil?
+
+            if active_test == test
+              self.active_test = nil
+            else
+              raise "Trying to deactivate test #{test}, but currently active test is #{active_test}"
+            end
+          end
+
+          def active_test
+            Thread.current[@key]
+          end
+
+          private
+
+          def active_test=(test)
+            Thread.current[@key] = test
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require "datadog/tracing"
+require "datadog/tracing/trace_digest"
+
+require "rbconfig"
+
+require_relative "context/global"
+require_relative "context/local"
+
+require_relative "../ext/app_types"
+require_relative "../ext/test"
+require_relative "../ext/environment"
+
+require_relative "../span"
+require_relative "../null_span"
+require_relative "../test"
+require_relative "../test_session"
+require_relative "../test_module"
+require_relative "../test_suite"
+
+module Datadog
+  module CI
+    module TestVisibility
+      # Common behavior for CI tests
+      # Note: this class has too many responsibilities and should be split into multiple classes
+      class Recorder
+        attr_reader :environment_tags, :test_suite_level_visibility_enabled, :enabled
+
+        def initialize(enabled: true, test_suite_level_visibility_enabled: false)
+          @enabled = enabled
+          @test_suite_level_visibility_enabled = enabled && test_suite_level_visibility_enabled
+
+          @environment_tags = @enabled ? Ext::Environment.tags(ENV).freeze : {}
+          @local_context = Context::Local.new
+          @global_context = Context::Global.new
+        end
+
+        def start_test_session(service: nil, tags: {})
+          return skip_tracing unless test_suite_level_visibility_enabled
+
+          @global_context.fetch_or_activate_test_session do
+            tracer_span = start_datadog_tracer_span(
+              "test.session", build_span_options(service, Ext::AppTypes::TYPE_TEST_SESSION)
+            )
+            set_session_context(tags, tracer_span)
+
+            build_test_session(tracer_span, tags)
+          end
+        end
+
+        def start_test_module(test_module_name, service: nil, tags: {})
+          return skip_tracing unless test_suite_level_visibility_enabled
+
+          @global_context.fetch_or_activate_test_module do
+            set_inherited_globals(tags)
+            set_session_context(tags)
+
+            tracer_span = start_datadog_tracer_span(
+              test_module_name, build_span_options(service, Ext::AppTypes::TYPE_TEST_MODULE)
+            )
+            set_module_context(tags, tracer_span)
+
+            build_test_module(tracer_span, tags)
+          end
+        end
+
+        def start_test_suite(test_suite_name, service: nil, tags: {})
+          return skip_tracing unless test_suite_level_visibility_enabled
+
+          @global_context.fetch_or_activate_test_suite(test_suite_name) do
+            set_inherited_globals(tags)
+            set_session_context(tags)
+            set_module_context(tags)
+
+            tracer_span = start_datadog_tracer_span(
+              test_suite_name, build_span_options(service, Ext::AppTypes::TYPE_TEST_SUITE)
+            )
+            set_suite_context(tags, span: tracer_span)
+
+            build_test_suite(tracer_span, tags)
+          end
+        end
+
+        def trace_test(test_name, test_suite_name, service: nil, tags: {}, &block)
+          return skip_tracing(block) unless enabled
+
+          set_inherited_globals(tags)
+          set_session_context(tags)
+          set_module_context(tags)
+          set_suite_context(tags, name: test_suite_name)
+
+          tags[Ext::Test::TAG_NAME] = test_name
+
+          span_options = build_span_options(
+            service,
+            Ext::AppTypes::TYPE_TEST,
+            # :resource is needed for the agent APM protocol to work correctly (for older agent versions)
+            # :continue_from is required to start a new trace for each test
+            {resource: test_name, continue_from: Datadog::Tracing::TraceDigest.new}
+          )
+
+          if block
+            start_datadog_tracer_span(test_name, span_options) do |tracer_span|
+              test = build_test(tracer_span, tags)
+
+              @local_context.activate_test!(test) do
+                block.call(test)
+              end
+            end
+          else
+            tracer_span = start_datadog_tracer_span(test_name, span_options)
+
+            test = build_test(tracer_span, tags)
+            @local_context.activate_test!(test)
+            test
+          end
+        end
+
+        def trace(span_type, span_name, tags: {}, &block)
+          return skip_tracing(block) unless enabled
+
+          span_options = build_span_options(
+            nil, # service name is completely optional for custom spans
+            span_type,
+            {resource: span_name}
+          )
+
+          if block
+            start_datadog_tracer_span(span_name, span_options) do |tracer_span|
+              block.call(build_span(tracer_span, tags))
+            end
+          else
+            tracer_span = start_datadog_tracer_span(span_name, span_options)
+
+            build_span(tracer_span, tags)
+          end
+        end
+
+        def active_span
+          tracer_span = Datadog::Tracing.active_span
+          Span.new(tracer_span) if tracer_span
+        end
+
+        def active_test
+          @local_context.active_test
+        end
+
+        def active_test_session
+          @global_context.active_test_session
+        end
+
+        def active_test_module
+          @global_context.active_test_module
+        end
+
+        def active_test_suite(test_suite_name)
+          @global_context.active_test_suite(test_suite_name)
+        end
+
+        def deactivate_test(test)
+          @local_context.deactivate_test!(test)
+        end
+
+        def deactivate_test_session
+          @global_context.deactivate_test_session!
+        end
+
+        def deactivate_test_module
+          @global_context.deactivate_test_module!
+        end
+
+        def deactivate_test_suite(test_suite_name)
+          @global_context.deactivate_test_suite!(test_suite_name)
+        end
+
+        private
+
+        def skip_tracing(block = nil)
+          if block
+            block.call(null_span)
+          else
+            null_span
+          end
+        end
+
+        # Sets trace's origin to ciapp-test
+        def set_trace_origin(trace)
+          trace.origin = Ext::Test::CONTEXT_ORIGIN if trace
+        end
+
+        def build_test_session(tracer_span, tags)
+          test_session = TestSession.new(tracer_span)
+          set_initial_tags(test_session, tags)
+          test_session
+        end
+
+        def build_test_module(tracer_span, tags)
+          test_module = TestModule.new(tracer_span)
+          set_initial_tags(test_module, tags)
+          test_module
+        end
+
+        def build_test_suite(tracer_span, tags)
+          test_suite = TestSuite.new(tracer_span)
+          set_initial_tags(test_suite, tags)
+          test_suite
+        end
+
+        def build_test(tracer_span, tags)
+          test = Test.new(tracer_span)
+          set_initial_tags(test, tags)
+          test
+        end
+
+        def build_span(tracer_span, tags)
+          span = Span.new(tracer_span)
+          set_initial_tags(span, tags)
+          span
+        end
+
+        def build_span_options(service, span_type, other_options = {})
+          other_options[:service] = service || @global_context.service
+          other_options[:span_type] = span_type
+
+          other_options
+        end
+
+        def set_inherited_globals(tags)
+          # this code achieves the same as @global_context.inheritable_session_tags.merge(tags)
+          # but without allocating a new hash
+          @global_context.inheritable_session_tags.each do |key, value|
+            tags[key] = value unless tags.key?(key)
+          end
+        end
+
+        def set_initial_tags(ci_span, tags)
+          ci_span.set_default_tags
+          ci_span.set_environment_runtime_tags
+
+          ci_span.set_tags(tags)
+          ci_span.set_tags(environment_tags)
+        end
+
+        def set_session_context(tags, test_session = nil)
+          test_session ||= active_test_session
+          tags[Ext::Test::TAG_TEST_SESSION_ID] = test_session.id.to_s if test_session
+        end
+
+        def set_module_context(tags, test_module = nil)
+          test_module ||= active_test_module
+          if test_module
+            tags[Ext::Test::TAG_TEST_MODULE_ID] = test_module.id.to_s
+            tags[Ext::Test::TAG_MODULE] = test_module.name
+          end
+        end
+
+        def set_suite_context(tags, span: nil, name: nil)
+          return if span.nil? && name.nil?
+
+          test_suite = span || active_test_suite(name)
+
+          if test_suite
+            tags[Ext::Test::TAG_TEST_SUITE_ID] = test_suite.id.to_s
+            tags[Ext::Test::TAG_SUITE] = test_suite.name
+          else
+            tags[Ext::Test::TAG_SUITE] = name
+          end
+        end
+
+        def start_datadog_tracer_span(span_name, span_options, &block)
+          if block
+            Datadog::Tracing.trace(span_name, **span_options) do |tracer_span, trace|
+              set_trace_origin(trace)
+
+              yield tracer_span
+            end
+          else
+            tracer_span = Datadog::Tracing.trace(span_name, **span_options)
+            trace = Datadog::Tracing.active_trace
+            set_trace_origin(trace)
+
+            tracer_span
+          end
+        end
+
+        def null_span
+          @null_span ||= NullSpan.new
+        end
+      end
+    end
+  end
+end