datadog-ci 1.2.0 → 1.3.0

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

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "datadog/tracing"
+require "datadog/tracing/contrib/component"
+require "datadog/tracing/trace_digest"
+
+require_relative "store/global"
+require_relative "store/local"
+
+require_relative "../ext/app_types"
+require_relative "../ext/environment"
+require_relative "../ext/test"
+
+require_relative "../span"
+require_relative "../test"
+require_relative "../test_session"
+require_relative "../test_module"
+require_relative "../test_suite"
+
+module Datadog
+  module CI
+    module TestVisibility
+      # Manages current in-memory context for test visibility (such as active test session, suite, test, etc.).
+      # Its responsibility includes building domain models for test visibility as well.
+      # Internally it uses Datadog::Tracing module to create spans.
+      class Context
+        def initialize
+          @local_context = Store::Local.new
+          @global_context = Store::Global.new
+        end
+
+        def start_test_session(service: nil, tags: {})
+          @global_context.fetch_or_activate_test_session do
+            tracer_span = start_datadog_tracer_span(
+              "test.session", build_tracing_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: {})
+          @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_tracing_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: {})
+          @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_tracing_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)
+          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
+          tags[Ext::Test::TAG_TYPE] ||= Ext::Test::Type::TEST
+
+          span_options = build_tracing_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_name, type: "span", tags: {}, &block)
+          span_options = build_tracing_span_options(
+            nil, # service name is completely optional for custom spans
+            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 single_active_test_suite
+          @global_context.fetch_single_test_suite
+        end
+
+        def deactivate_test
+          @local_context.deactivate_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
+
+        # BUILDING DOMAIN MODELS
+        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
+
+        # TAGGING
+        def set_initial_tags(ci_span, tags)
+          @environment_tags ||= Ext::Environment.tags(ENV).freeze
+
+          ci_span.set_default_tags
+          ci_span.set_environment_runtime_tags
+
+          ci_span.set_tags(tags)
+          ci_span.set_tags(@environment_tags)
+        end
+
+        # PROPAGATING CONTEXT FROM TOP-LEVEL TO THE LOWER LEVELS
+        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_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
+
+        # INTERACTIONS WITH TRACING
+        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
+
+        # Sets trace's origin to ciapp-test because tracing requires so
+        def set_trace_origin(trace)
+          trace&.origin = Ext::Test::CONTEXT_ORIGIN
+        end
+
+        def build_tracing_span_options(service, type, other_options = {})
+          other_options[:service] = service || @global_context.service
+          other_options[:type] = type
+
+          other_options
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/test_visibility/{context → store}/global.rb

@@ -3,7 +3,7 @@
 module Datadog
   module CI
     module TestVisibility
-      module Context
+      module Store
         # This context is shared between threads and represents the current test session and test module.
         class Global
           def initialize

data/lib/datadog/ci/test_visibility/{context → store}/local.rb

@@ -3,7 +3,7 @@
 module Datadog
   module CI
     module TestVisibility
-      module Context
+      module Store
         class Local
           def initialize
             @key = :datadog_ci_active_test

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../ext/app_types"
+require_relative "../ext/environment"
+require_relative "../ext/telemetry"
+require_relative "../ext/test"
+require_relative "../utils/telemetry"
+
+module Datadog
+  module CI
+    module TestVisibility
+      # Telemetry for test visibility
+      module Telemetry
+        SPAN_TYPE_TO_TELEMETRY_EVENT_TYPE = {
+          Ext::AppTypes::TYPE_TEST => Ext::Telemetry::EventType::TEST,
+          Ext::AppTypes::TYPE_TEST_SUITE => Ext::Telemetry::EventType::SUITE,
+          Ext::AppTypes::TYPE_TEST_MODULE => Ext::Telemetry::EventType::MODULE,
+          Ext::AppTypes::TYPE_TEST_SESSION => Ext::Telemetry::EventType::SESSION
+        }.freeze
+
+        def self.event_created(span)
+          Utils::Telemetry.inc(Ext::Telemetry::METRIC_EVENT_CREATED, 1, event_tags_from_span(span))
+        end
+
+        def self.event_finished(span)
+          tags = event_tags_from_span(span)
+          add_browser_tags!(span, tags)
+          Utils::Telemetry.inc(Ext::Telemetry::METRIC_EVENT_FINISHED, 1, tags)
+        end
+
+        def self.test_session_started(test_session)
+          Utils::Telemetry.inc(
+            Ext::Telemetry::METRIC_TEST_SESSION,
+            1,
+            {
+              Ext::Telemetry::TAG_AUTO_INJECTED => "false", # ruby doesn't support auto injection yet
+              Ext::Telemetry::TAG_PROVIDER =>
+                test_session.get_tag(Ext::Environment::TAG_PROVIDER_NAME) ||
+                Ext::Telemetry::Provider::UNSUPPORTED
+            }
+          )
+        end
+
+        def self.event_tags_from_span(span)
+          # base tags for span
+          # @type var tags: Hash[String, String]
+          tags = {
+            Ext::Telemetry::TAG_EVENT_TYPE => SPAN_TYPE_TO_TELEMETRY_EVENT_TYPE.fetch(span.type, "unknown"),
+            Ext::Telemetry::TAG_TEST_FRAMEWORK => span.get_tag(Ext::Test::TAG_FRAMEWORK)
+          }
+
+          # ci provider tag
+          tags[Ext::Telemetry::TAG_IS_UNSUPPORTED_CI] = "true" if span.get_tag(Ext::Environment::TAG_PROVIDER_NAME).nil?
+
+          # codeowner tag
+          tags[Ext::Telemetry::TAG_HAS_CODEOWNER] = "true" if span.get_tag(Ext::Test::TAG_CODEOWNERS)
+
+          tags
+        end
+
+        def self.add_browser_tags!(span, tags)
+          tags[Ext::Telemetry::TAG_IS_RUM] = "true" if span.get_tag(Ext::Test::TAG_IS_RUM_ACTIVE)
+          browser_driver = span.get_tag(Ext::Test::TAG_BROWSER_DRIVER)
+          tags[Ext::Telemetry::TAG_BROWSER_DRIVER] = browser_driver if browser_driver
+        end
+      end
+    end
+  end
+end

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

@@ -3,8 +3,10 @@
 require "datadog/core/environment/identity"
 
 require_relative "serializers/factories/test_level"
+require_relative "../ext/telemetry"
 require_relative "../ext/transport"
 require_relative "../transport/event_platform_transport"
+require_relative "../transport/telemetry"
 
 module Datadog
   module CI
@@ -31,6 +33,10 @@ module Datadog
 
         private
 
+        def telemetry_endpoint_tag
+          Ext::Telemetry::Endpoint::TEST_CYCLE
+        end
+
         def send_payload(encoded_payload)
           api.citestcycle_request(
             path: Datadog::CI::Ext::Transport::TEST_VISIBILITY_INTAKE_PATH,
@@ -46,21 +52,14 @@ module Datadog
 
         def encode_span(trace, span)
           serializer = serializers_factory.serializer(trace, span, options: {itr_correlation_id: itr&.correlation_id})
-
           if serializer.valid?
             encoded = encoder.encode(serializer)
-
-            if encoded.size > max_payload_size
-              # This single event is too large, we can't flush it
-              Datadog.logger.warn("Dropping test event. Payload too large: '#{span.inspect}'")
-              Datadog.logger.warn(encoded)
-
-              return nil
-            end
+            return nil if event_too_large?(span, encoded)
 
             encoded
           else
             Datadog.logger.warn("Invalid event skipped: #{serializer} Errors: #{serializer.validation_errors}")
+            CI::Transport::Telemetry.endpoint_payload_dropped(1, endpoint: telemetry_endpoint_tag)
             nil
           end
         end

data/lib/datadog/ci/transport/adapters/net.rb

@@ -3,7 +3,9 @@
 require "datadog/core/transport/response"
 require "datadog/core/transport/ext"
 
+require_relative "net_http_client"
 require_relative "../gzip"
+require_relative "../../ext/telemetry"
 require_relative "../../ext/transport"
 
 module Datadog
@@ -26,7 +28,7 @@ module Datadog
           end
 
           def open(&block)
-            req = net_http_client.new(hostname, port)
+            req = NetHttpClient.original_net_http.new(hostname, port)
 
             req.use_ssl = ssl
             req.open_timeout = req.read_timeout = timeout
@@ -63,6 +65,8 @@ module Datadog
             include Datadog::Core::Transport::Response
 
             attr_reader :http_response
+            # Stats for telemetry
+            attr_accessor :duration_ms, :request_compressed, :request_size
 
             def initialize(http_response)
               @http_response = http_response
@@ -77,6 +81,10 @@ module Datadog
               @decompressed_payload = Gzip.decompress(http_response.body)
             end
 
+            def response_size
+              http_response.body.bytesize
+            end
+
             def header(name)
               http_response[name]
             end
@@ -86,7 +94,10 @@ module Datadog
             end
 
             def ok?
-              code.between?(200, 299)
+              http_code = code
+              return false if http_code.nil?
+
+              http_code.between?(200, 299)
             end
 
             def unsupported?
@@ -98,11 +109,17 @@ module Datadog
             end
 
             def client_error?
-              code.between?(400, 499)
+              http_code = code
+              return false if http_code.nil?
+
+              http_code.between?(400, 499)
             end
 
             def server_error?
-              code.between?(500, 599)
+              http_code = code
+              return false if http_code.nil?
+
+              http_code.between?(500, 599)
             end
 
             def gzipped_content?
@@ -119,17 +136,31 @@ module Datadog
               first_bytes.b == Ext::Transport::GZIP_MAGIC_NUMBER
             end
 
-            def inspect
-              "#{super}, http_response:#{http_response}"
+            def error
+              nil
             end
-          end
 
-          private
+            def telemetry_error_type
+              return nil if ok?
+
+              case error
+              when nil
+                Ext::Telemetry::ErrorType::STATUS_CODE
+              when Timeout::Error
+                Ext::Telemetry::ErrorType::TIMEOUT
+              else
+                Ext::Telemetry::ErrorType::NETWORK
+              end
+            end
 
-          def net_http_client
-            return ::Net::HTTP unless defined?(WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP)
+            # compatibility with Datadog::Tracing transport layer
+            def trace_count
+              0
+            end
 
-            WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP
+            def inspect
+              "#{super}, http_response:#{http_response}"
+            end
           end
         end
       end

data/lib/datadog/ci/transport/adapters/net_http_client.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module Transport
+      module Adapters
+        module NetHttpClient
+          def self.original_net_http
+            return ::Net::HTTP unless defined?(WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP)
+
+            WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/transport/adapters/telemetry_webmock_safe_adapter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "net_http_client"
+
+module Datadog
+  module CI
+    module Transport
+      module Adapters
+        module TelemetryWebmockSafeAdapter
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          module InstanceMethods
+            def open(&block)
+              req = NetHttpClient.original_net_http.new(@hostname, @port)
+
+              req.use_ssl = @ssl
+              req.open_timeout = req.read_timeout = @timeout
+
+              req.start(&block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,8 @@ require "msgpack"
 require "datadog/core/encoding"
 require "datadog/core/chunker"
 
+require_relative "telemetry"
+
 module Datadog
   module CI
     module Transport
@@ -24,12 +26,19 @@ module Datadog
 
           Datadog.logger.debug { "[#{self.class.name}] Sending #{events.count} events..." }
 
-          encoded_events = encode_events(events)
-          if encoded_events.empty?
-            Datadog.logger.debug { "[#{self.class.name}] Empty encoded events list, skipping send" }
-            return []
+          encoded_events = []
+          # @type var serialization_duration_ms: Float
+          serialization_duration_ms = Core::Utils::Time.measure(:float_millisecond) do
+            encoded_events = encode_events(events)
+            if encoded_events.empty?
+              Datadog.logger.debug { "[#{self.class.name}] Empty encoded events list, skipping send" }
+              return []
+            end
           end
 
+          Telemetry.events_enqueued_for_serialization(encoded_events.count)
+          Telemetry.endpoint_payload_serialization_ms(serialization_duration_ms, endpoint: telemetry_endpoint_tag)
+
           responses = []
 
           Datadog::Core::Chunker.chunk_by_size(encoded_events, max_payload_size).map do |chunk|
@@ -37,9 +46,28 @@ module Datadog
             Datadog.logger.debug do
               "[#{self.class.name}] Send chunk of #{chunk.count} events; payload size #{encoded_payload.size}"
             end
+            Telemetry.endpoint_payload_events_count(chunk.count, endpoint: telemetry_endpoint_tag)
 
             response = send_payload(encoded_payload)
 
+            Telemetry.endpoint_payload_requests(
+              1,
+              endpoint: telemetry_endpoint_tag, compressed: response.request_compressed
+            )
+            Telemetry.endpoint_payload_requests_ms(response.duration_ms, endpoint: telemetry_endpoint_tag)
+            Telemetry.endpoint_payload_bytes(response.request_size, endpoint: telemetry_endpoint_tag)
+
+            # HTTP layer could send events and exhausted retries (if any)
+            unless response.ok?
+              Telemetry.endpoint_payload_dropped(chunk.count, endpoint: telemetry_endpoint_tag)
+              Telemetry.endpoint_payload_requests_errors(
+                1,
+                endpoint: telemetry_endpoint_tag,
+                error_type: response.telemetry_error_type,
+                status_code: response.code
+              )
+            end
+
             responses << response
           end
 
@@ -48,6 +76,10 @@ module Datadog
 
         private
 
+        def telemetry_endpoint_tag
+          raise NotImplementedError, "must be implemented by the subclass"
+        end
+
         def encoder
           Datadog::Core::Encoding::MsgpackEncoder
         end
@@ -65,9 +97,14 @@ module Datadog
           return false unless encoded_event.size > max_payload_size
 
           # This single event is too large, we can't flush it
-          Datadog.logger.warn("[#{self.class.name}] Dropping coverage event. Payload too large: '#{event.inspect}'")
+          Datadog.logger.warn(
+            "[#{self.class.name}] Dropping test visibility event for endpoint [#{telemetry_endpoint_tag}]. " \
+            "Payload too large: '#{event.inspect}'"
+          )
           Datadog.logger.warn(encoded_event)
 
+          Telemetry.endpoint_payload_dropped(1, endpoint: telemetry_endpoint_tag)
+
           true
         end