datadog-ci 0.3.0 → 0.5.1

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

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

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "set"
+
+require_relative "../../ext/test"
+
 module Datadog
   module CI
     module TestVisibility
@@ -9,11 +13,31 @@ module Datadog
           MINIMUM_DURATION_NANO = 0
           MAXIMUM_DURATION_NANO = 9223372036854775807
 
-          attr_reader :trace, :span
+          CONTENT_FIELDS = [
+            "name", "resource", "service",
+            "error", "start", "duration",
+            "meta", "metrics",
+            "type" => "span_type"
+          ].freeze
+
+          REQUIRED_FIELDS = [
+            "error",
+            "name",
+            "resource",
+            "start",
+            "duration"
+          ].freeze
+
+          attr_reader :trace, :span, :meta
 
           def initialize(trace, span)
             @trace = trace
             @span = span
+
+            @meta = @span.meta.reject { |key, _| Ext::Test::SPECIAL_TAGS.include?(key) }
+
+            @errors = {}
+            @validated = false
           end
 
           def to_msgpack(packer = nil)
@@ -40,7 +64,23 @@ module Datadog
 
           # validates according to citestcycle json schema
           def valid?
-            required_fields_present? && valid_start_time? && valid_duration?
+            validate! unless @validated
+
+            @errors.empty?
+          end
+
+          def validate!
+            @errors.clear
+
+            validate_required_fields!
+            validate_start_time!
+            validate_duration!
+
+            @validated = true
+          end
+
+          def validation_errors
+            @errors
           end
 
           def content_fields
@@ -67,6 +107,18 @@ module Datadog
             @span.parent_id
           end
 
+          def test_session_id
+            to_integer(@span.get_tag(Ext::Test::TAG_TEST_SESSION_ID))
+          end
+
+          def test_module_id
+            to_integer(@span.get_tag(Ext::Test::TAG_TEST_MODULE_ID))
+          end
+
+          def test_suite_id
+            to_integer(@span.get_tag(Ext::Test::TAG_TEST_SUITE_ID))
+          end
+
           def type
           end
 
@@ -98,10 +150,6 @@ module Datadog
             @duration ||= duration_nano(@span.duration)
           end
 
-          def meta
-            @span.meta
-          end
-
           def metrics
             @span.metrics
           end
@@ -122,16 +170,48 @@ module Datadog
 
           private
 
-          def valid_start_time?
-            !start.nil? && start >= MINIMUM_TIMESTAMP_NANO
+          def validate_start_time!
+            validate_required!("start")
+            validate_greater_than_or_equal!("start", MINIMUM_TIMESTAMP_NANO)
+          end
+
+          def validate_duration!
+            validate_required!("duration")
+            validate_greater_than_or_equal!("duration", MINIMUM_DURATION_NANO)
+            validate_less_than_or_equal!("duration", MAXIMUM_DURATION_NANO)
+          end
+
+          def validate_required_fields!
+            required_fields.each do |field|
+              validate_required!(field)
+            end
           end
 
-          def valid_duration?
-            !duration.nil? && duration >= MINIMUM_DURATION_NANO && duration <= MAXIMUM_DURATION_NANO
+          def validate_required!(field)
+            if send(field).nil?
+              add_error(field, "is required")
+            end
           end
 
-          def required_fields_present?
-            required_fields.all? { |field| !send(field).nil? }
+          def validate_greater_than_or_equal!(field, value)
+            return if send(field).nil?
+
+            if send(field) < value
+              add_error(field, "must be greater than or equal to #{value}")
+            end
+          end
+
+          def validate_less_than_or_equal!(field, value)
+            return if send(field).nil?
+
+            if send(field) > value
+              add_error(field, "must be less than or equal to #{value}")
+            end
+          end
+
+          def add_error(field, message)
+            @errors[field] ||= Set.new
+            @errors[field] << message
           end
 
           def required_fields
@@ -154,6 +234,14 @@ module Datadog
           def duration_nano(duration)
             (duration * 1e9).to_i
           end
+
+          def to_s
+            "#{self.class.name}(id:#{span_id},name:#{name})"
+          end
+
+          def to_integer(value)
+            value.to_i if value
+          end
         end
       end
     end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../test_v2"
+require_relative "../test_session"
+require_relative "../test_module"
+require_relative "../test_suite"
+require_relative "../span"
+
+module Datadog
+  module CI
+    module TestVisibility
+      module Serializers
+        module Factories
+          # This factory takes care of creating citestcycle serializers when test-suite-level visibility is enabled
+          module TestSuiteLevel
+            module_function
+
+            def serializer(trace, span)
+              case span.type
+              when Datadog::CI::Ext::AppTypes::TYPE_TEST
+                Serializers::TestV2.new(trace, span)
+              when Datadog::CI::Ext::AppTypes::TYPE_TEST_SESSION
+                Serializers::TestSession.new(trace, span)
+              when Datadog::CI::Ext::AppTypes::TYPE_TEST_MODULE
+                Serializers::TestModule.new(trace, span)
+              when Datadog::CI::Ext::AppTypes::TYPE_TEST_SUITE
+                Serializers::TestSuite.new(trace, span)
+              else
+                Serializers::Span.new(trace, span)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,25 +7,11 @@ module Datadog
     module TestVisibility
       module Serializers
         class Span < Base
-          CONTENT_FIELDS = [
-            "trace_id", "span_id", "parent_id",
-            "name", "resource", "service",
-            "error", "start", "duration",
-            "meta", "metrics",
-            "type" => "span_type"
-          ].freeze
+          CONTENT_FIELDS = (["trace_id", "span_id", "parent_id"] + Base::CONTENT_FIELDS).freeze
 
           CONTENT_MAP_SIZE = calculate_content_map_size(CONTENT_FIELDS)
 
-          REQUIRED_FIELDS = [
-            "trace_id",
-            "span_id",
-            "error",
-            "name",
-            "resource",
-            "start",
-            "duration"
-          ].freeze
+          REQUIRED_FIELDS = (["trace_id", "span_id"] + Base::REQUIRED_FIELDS).freeze
 
           def content_fields
             CONTENT_FIELDS

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../../ext/test"
+
+module Datadog
+  module CI
+    module TestVisibility
+      module Serializers
+        class TestModule < Base
+          CONTENT_FIELDS = (["test_session_id", "test_module_id"] + Base::CONTENT_FIELDS).freeze
+
+          CONTENT_MAP_SIZE = calculate_content_map_size(CONTENT_FIELDS)
+
+          REQUIRED_FIELDS = (["test_session_id", "test_module_id"] + Base::REQUIRED_FIELDS).freeze
+
+          def content_fields
+            CONTENT_FIELDS
+          end
+
+          def content_map_size
+            CONTENT_MAP_SIZE
+          end
+
+          def type
+            Ext::AppTypes::TYPE_TEST_MODULE
+          end
+
+          def name
+            "#{@span.get_tag(Ext::Test::TAG_FRAMEWORK)}.test_module"
+          end
+
+          def resource
+            "#{@span.get_tag(Ext::Test::TAG_FRAMEWORK)}.test_module.#{@span.get_tag(Ext::Test::TAG_MODULE)}"
+          end
+
+          private
+
+          def required_fields
+            REQUIRED_FIELDS
+          end
+        end
+      end
+    end
+  end
+end