datadog-ci 1.1.0 → 1.3.0

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
 

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

@@ -3,6 +3,8 @@
 require "delegate"
 require "socket"
 
+require "datadog/core/utils/time"
+
 require_relative "gzip"
 require_relative "adapters/net"
 require_relative "../ext/transport"
@@ -39,27 +41,36 @@ module Datadog
           backoff: INITIAL_BACKOFF,
           accept_compressed_response: false
         )
-          if compress
-            headers[Ext::Transport::HEADER_CONTENT_ENCODING] = Ext::Transport::CONTENT_ENCODING_GZIP
-            payload = Gzip.compress(payload)
-          end
+          response = nil
 
-          if accept_compressed_response
-            headers[Ext::Transport::HEADER_ACCEPT_ENCODING] = Ext::Transport::CONTENT_ENCODING_GZIP
-          end
+          duration_ms = Core::Utils::Time.measure(:float_millisecond) do
+            if compress
+              headers[Ext::Transport::HEADER_CONTENT_ENCODING] = Ext::Transport::CONTENT_ENCODING_GZIP
+              payload = Gzip.compress(payload)
+            end
 
-          Datadog.logger.debug do
-            "Sending #{verb} request: host=#{host}; port=#{port}; ssl_enabled=#{ssl}; " \
-              "compression_enabled=#{compress}; path=#{path}; payload_size=#{payload.size}"
-          end
+            if accept_compressed_response
+              headers[Ext::Transport::HEADER_ACCEPT_ENCODING] = Ext::Transport::CONTENT_ENCODING_GZIP
+            end
 
-          response = ResponseDecorator.new(
-            perform_http_call(path: path, payload: payload, headers: headers, verb: verb, retries: retries, backoff: backoff)
-          )
+            Datadog.logger.debug do
+              "Sending #{verb} request: host=#{host}; port=#{port}; ssl_enabled=#{ssl}; " \
+                "compression_enabled=#{compress}; path=#{path}; payload_size=#{payload.size}"
+            end
+
+            response = perform_http_call(path: path, payload: payload, headers: headers, verb: verb, retries: retries, backoff: backoff)
 
-          Datadog.logger.debug do
-            "Received server response: #{response.inspect}"
+            Datadog.logger.debug do
+              "Received server response: #{response.inspect}"
+            end
           end
+          # @type var response: Datadog::CI::Transport::Adapters::Net::Response
+          # @type var duration_ms: Float
+
+          # set some stats about the request
+          response.request_compressed = compress
+          response.request_size = payload.bytesize
+          response.duration_ms = duration_ms
 
           response
         end
@@ -81,7 +92,7 @@ module Datadog
             )
           else
             Datadog.logger.error("Failed to send request after #{MAX_RETRIES} retries")
-            raise e
+            ErrorResponse.new(e)
           end
         end
 
@@ -91,10 +102,27 @@ module Datadog
           )
         end
 
-        # adds compatibility with Datadog::Tracing transport
-        class ResponseDecorator < ::SimpleDelegator
-          def trace_count
-            0
+        class ErrorResponse < Adapters::Net::Response
+          def initialize(error)
+            @error = error
+          end
+
+          attr_reader :error
+
+          def payload
+            ""
+          end
+
+          def header(name)
+            nil
+          end
+
+          def code
+            nil
+          end
+
+          def inspect
+            "ErrorResponse error:#{error}"
           end
         end
       end

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

@@ -4,8 +4,11 @@ require "json"
 
 require "datadog/core/environment/identity"
 
+require_relative "../ext/telemetry"
 require_relative "../ext/transport"
+require_relative "../transport/telemetry"
 require_relative "../utils/parsing"
+require_relative "../utils/telemetry"
 
 module Datadog
   module CI
@@ -36,6 +39,14 @@ module Datadog
                 default_payload
             rescue JSON::ParserError => e
               Datadog.logger.error("Failed to parse settings response payload: #{e}. Payload was: #{resp.payload}")
+
+              Transport::Telemetry.api_requests_errors(
+                Ext::Telemetry::METRIC_GIT_REQUESTS_SETTINGS_ERRORS,
+                1,
+                error_type: "invalid_json",
+                status_code: nil
+              )
+
               @json = default_payload
             end
           end
@@ -69,7 +80,34 @@ module Datadog
             payload: request_payload
           )
 
-          Response.new(http_response)
+          Transport::Telemetry.api_requests(
+            Ext::Telemetry::METRIC_GIT_REQUESTS_SETTINGS,
+            1,
+            compressed: http_response.request_compressed
+          )
+          Utils::Telemetry.distribution(Ext::Telemetry::METRIC_GIT_REQUESTS_SETTINGS_MS, http_response.duration_ms)
+
+          unless http_response.ok?
+            Transport::Telemetry.api_requests_errors(
+              Ext::Telemetry::METRIC_GIT_REQUESTS_SETTINGS_ERRORS,
+              1,
+              error_type: http_response.telemetry_error_type,
+              status_code: http_response.code
+            )
+          end
+
+          response = Response.new(http_response)
+
+          Utils::Telemetry.inc(
+            Ext::Telemetry::METRIC_GIT_REQUESTS_SETTINGS_RESPONSE,
+            1,
+            {
+              Ext::Telemetry::TAG_COVERAGE_ENABLED => response.payload[Ext::Transport::DD_API_SETTINGS_RESPONSE_CODE_COVERAGE_KEY],
+              Ext::Telemetry::TAG_ITR_SKIP_ENABLED => response.payload[Ext::Transport::DD_API_SETTINGS_RESPONSE_TESTS_SKIPPING_KEY]
+            }
+          )
+
+          response
         end
 
         private

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../ext/telemetry"
+require_relative "../utils/telemetry"
+
+module Datadog
+  module CI
+    module Transport
+      module Telemetry
+        def self.events_enqueued_for_serialization(count)
+          Utils::Telemetry.inc(Ext::Telemetry::METRIC_EVENTS_ENQUEUED, count)
+        end
+
+        def self.endpoint_payload_events_count(count, endpoint:)
+          Utils::Telemetry.distribution(
+            Ext::Telemetry::METRIC_ENDPOINT_PAYLOAD_EVENTS_COUNT,
+            count.to_f,
+            tags(endpoint: endpoint)
+          )
+        end
+
+        def self.endpoint_payload_serialization_ms(duration_ms, endpoint:)
+          Utils::Telemetry.distribution(
+            Ext::Telemetry::METRIC_ENDPOINT_PAYLOAD_EVENTS_SERIALIZATION_MS,
+            duration_ms,
+            tags(endpoint: endpoint)
+          )
+        end
+
+        def self.endpoint_payload_dropped(count, endpoint:)
+          Utils::Telemetry.inc(
+            Ext::Telemetry::METRIC_ENDPOINT_PAYLOAD_DROPPED,
+            count,
+            tags(endpoint: endpoint)
+          )
+        end
+
+        def self.endpoint_payload_requests(count, endpoint:, compressed:)
+          tags = tags(endpoint: endpoint)
+          tags[Ext::Telemetry::TAG_REQUEST_COMPRESSED] = "true" if compressed
+
+          Utils::Telemetry.inc(Ext::Telemetry::METRIC_ENDPOINT_PAYLOAD_REQUESTS, count, tags)
+        end
+
+        def self.endpoint_payload_requests_ms(duration_ms, endpoint:)
+          Utils::Telemetry.distribution(
+            Ext::Telemetry::METRIC_ENDPOINT_PAYLOAD_REQUESTS_MS,
+            duration_ms,
+            tags(endpoint: endpoint)
+          )
+        end
+
+        def self.endpoint_payload_bytes(bytesize, endpoint:)
+          Utils::Telemetry.distribution(
+            Ext::Telemetry::METRIC_ENDPOINT_PAYLOAD_BYTES,
+            bytesize.to_f,
+            tags(endpoint: endpoint)
+          )
+        end
+
+        def self.endpoint_payload_requests_errors(count, endpoint:, error_type:, status_code:)
+          tags = tags(endpoint: endpoint)
+          set_error_tags(tags, error_type: error_type, status_code: status_code)
+
+          Utils::Telemetry.inc(Ext::Telemetry::METRIC_ENDPOINT_PAYLOAD_REQUESTS_ERRORS, count, tags)
+        end
+
+        def self.api_requests(metric_name, count, compressed:)
+          tags = {}
+          tags[Ext::Telemetry::TAG_REQUEST_COMPRESSED] = "true" if compressed
+
+          Utils::Telemetry.inc(metric_name, count, tags)
+        end
+
+        def self.api_requests_errors(metric_name, count, error_type:, status_code:)
+          tags = {}
+          set_error_tags(tags, error_type: error_type, status_code: status_code)
+
+          Utils::Telemetry.inc(metric_name, count, tags)
+        end
+
+        def self.tags(endpoint:)
+          {Ext::Telemetry::TAG_ENDPOINT => endpoint}
+        end
+
+        def self.set_error_tags(tags, error_type:, status_code:)
+          tags[Ext::Telemetry::TAG_ERROR_TYPE] = error_type if error_type
+          tags[Ext::Telemetry::TAG_STATUS_CODE] = status_code.to_s if status_code
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module Utils
+      module Identity
+        def self.included(base)
+          base.singleton_class.prepend(ClassMethods)
+        end
+
+        module ClassMethods
+          # return datadog-ci gem version instead of datadog gem version
+          def gem_datadog_version
+            Datadog::CI::VERSION::STRING
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,8 @@ module Datadog
     module Utils
       module Parsing
         def self.convert_to_bool(value)
-          value.to_s.downcase == "true"
+          normalized_value = value.to_s.downcase
+          normalized_value == "true" || normalized_value == "1"
         end
       end
     end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../ext/telemetry"
+
+module Datadog
+  module CI
+    module Utils
+      module Telemetry
+        def self.inc(metric_name, count, tags = {})
+          telemetry.inc(Ext::Telemetry::NAMESPACE, metric_name, count, tags: tags)
+        end
+
+        def self.distribution(metric_name, value, tags = {})
+          telemetry.distribution(Ext::Telemetry::NAMESPACE, metric_name, value, tags: tags)
+        end
+
+        def self.telemetry
+          Datadog.send(:components).telemetry
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/version.rb

@@ -4,7 +4,7 @@ module Datadog
   module CI
     module VERSION
       MAJOR = 1
-      MINOR = 1
+      MINOR = 3
       PATCH = 0
       PRE = nil
       BUILD = nil

data/lib/datadog/ci.rb

@@ -2,7 +2,9 @@
 
 require_relative "ci/version"
 require_relative "ci/utils/configuration"
+require_relative "ci/utils/telemetry"
 require_relative "ci/ext/app_types"
+require_relative "ci/ext/telemetry"
 
 require "datadog/core"
 
@@ -39,7 +41,12 @@ module Datadog
       # @return [Datadog::CI::TestSession] the active, running {Datadog::CI::TestSession}.
       # @return [nil] if test suite level visibility is disabled or CI mode is disabled.
       def start_test_session(service: Utils::Configuration.fetch_service_name("test"), tags: {})
-        recorder.start_test_session(service: service, tags: tags)
+        Utils::Telemetry.inc(
+          Ext::Telemetry::METRIC_MANUAL_API_EVENTS,
+          1,
+          {Ext::Telemetry::TAG_EVENT_TYPE => Ext::Telemetry::EventType::SESSION}
+        )
+        test_visibility.start_test_session(service: service, tags: tags)
       end
 
       # The active, unfinished test session.
@@ -61,7 +68,7 @@ module Datadog
       # @return [Datadog::CI::TestSession] the active test session
       # @return [nil] if no test session is active
       def active_test_session
-        recorder.active_test_session
+        test_visibility.active_test_session
       end
 
       # Starts a {Datadog::CI::TestModule ci_test_module} that represents a single test module (for most Ruby test frameworks
@@ -93,7 +100,13 @@ module Datadog
       # @return [Datadog::CI::TestModule] the active, running {Datadog::CI::TestModule}.
       # @return [nil] if test suite level visibility is disabled or CI mode is disabled.
       def start_test_module(test_module_name, service: nil, tags: {})
-        recorder.start_test_module(test_module_name, service: service, tags: tags)
+        Utils::Telemetry.inc(
+          Ext::Telemetry::METRIC_MANUAL_API_EVENTS,
+          1,
+          {Ext::Telemetry::TAG_EVENT_TYPE => Ext::Telemetry::EventType::MODULE}
+        )
+
+        test_visibility.start_test_module(test_module_name, service: service, tags: tags)
       end
 
       # The active, unfinished test module.
@@ -116,7 +129,7 @@ module Datadog
       # @return [Datadog::CI::TestModule] the active test module
       # @return [nil] if no test module is active
       def active_test_module
-        recorder.active_test_module
+        test_visibility.active_test_module
       end
 
       # Starts a {Datadog::CI::TestSuite ci_test_suite} that represents a single test suite.
@@ -145,7 +158,13 @@ module Datadog
       # @return [Datadog::CI::TestSuite] the active, running {Datadog::CI::TestSuite}.
       # @return [nil] if test suite level visibility is disabled or CI mode is disabled.
       def start_test_suite(test_suite_name, service: nil, tags: {})
-        recorder.start_test_suite(test_suite_name, service: service, tags: tags)
+        Utils::Telemetry.inc(
+          Ext::Telemetry::METRIC_MANUAL_API_EVENTS,
+          1,
+          {Ext::Telemetry::TAG_EVENT_TYPE => Ext::Telemetry::EventType::SUITE}
+        )
+
+        test_visibility.start_test_suite(test_suite_name, service: service, tags: tags)
       end
 
       # The active, unfinished test suite.
@@ -168,7 +187,7 @@ module Datadog
       # @return [Datadog::CI::TestSuite] the active test suite
       # @return [nil] if no test suite with given name is active
       def active_test_suite(test_suite_name)
-        recorder.active_test_suite(test_suite_name)
+        test_visibility.active_test_suite(test_suite_name)
       end
 
       # Return a {Datadog::CI::Test ci_test} that will trace a test called `test_name`.
@@ -222,7 +241,13 @@ module Datadog
       # @yieldparam [Datadog::CI::Test] ci_test the newly created and active [Datadog::CI::Test]
       # @yieldparam [nil] if CI mode is disabled
       def trace_test(test_name, test_suite_name, service: nil, tags: {}, &block)
-        recorder.trace_test(test_name, test_suite_name, service: service, tags: tags, &block)
+        Utils::Telemetry.inc(
+          Ext::Telemetry::METRIC_MANUAL_API_EVENTS,
+          1,
+          {Ext::Telemetry::TAG_EVENT_TYPE => Ext::Telemetry::EventType::TEST}
+        )
+
+        test_visibility.trace_test(test_name, test_suite_name, service: service, tags: tags, &block)
       end
 
       # Same as {.trace_test} but it does not accept a block.
@@ -248,7 +273,12 @@ module Datadog
       # @return [Datadog::CI::Test] the active, unfinished {Datadog::CI::Test}.
       # @return [nil] if CI mode is disabled.
       def start_test(test_name, test_suite_name, service: nil, tags: {})
-        recorder.trace_test(test_name, test_suite_name, service: service, tags: tags)
+        Utils::Telemetry.inc(
+          Ext::Telemetry::METRIC_MANUAL_API_EVENTS,
+          1,
+          {Ext::Telemetry::TAG_EVENT_TYPE => Ext::Telemetry::EventType::TEST}
+        )
+        test_visibility.trace_test(test_name, test_suite_name, service: service, tags: tags)
       end
 
       # Trace any custom span inside a test. For example, you could trace:
@@ -300,7 +330,7 @@ module Datadog
           )
         end
 
-        recorder.trace(span_name, type: type, tags: tags, &block)
+        test_visibility.trace(span_name, type: type, tags: tags, &block)
       end
 
       # The active, unfinished custom (i.e. not test/suite/module/session) span.
@@ -326,7 +356,7 @@ module Datadog
       # @return [Datadog::CI::Span] the active span
       # @return [nil] if no span is active, or if the active span is not a custom span
       def active_span
-        span = recorder.active_span
+        span = test_visibility.active_span
         span if span && !Ext::AppTypes::CI_SPAN_TYPES.include?(span.type)
       end
 
@@ -352,7 +382,7 @@ module Datadog
       # @return [Datadog::CI::Test] the active test
       # @return [nil] if no test is active
       def active_test
-        recorder.active_test
+        test_visibility.active_test
       end
 
       private
@@ -361,12 +391,12 @@ module Datadog
         Datadog.send(:components)
       end
 
-      def recorder
-        components.ci_recorder
+      def test_visibility
+        components.test_visibility
       end
 
-      def itr_runner
-        components.itr
+      def test_optimisation
+        components.test_optimisation
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog-ci
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-01 00:00:00.000000000 Z
+date: 2024-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: datadog
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: msgpack
   requirement: !ruby/object:Gem::Requirement
@@ -126,30 +126,32 @@ files:
 - lib/datadog/ci/ext/environment/providers/user_defined_tags.rb
 - lib/datadog/ci/ext/git.rb
 - lib/datadog/ci/ext/settings.rb
+- lib/datadog/ci/ext/telemetry.rb
 - lib/datadog/ci/ext/test.rb
 - lib/datadog/ci/ext/transport.rb
 - lib/datadog/ci/git/local_repository.rb
 - lib/datadog/ci/git/packfiles.rb
 - lib/datadog/ci/git/search_commits.rb
+- lib/datadog/ci/git/telemetry.rb
 - lib/datadog/ci/git/tree_uploader.rb
 - lib/datadog/ci/git/upload_packfile.rb
 - lib/datadog/ci/git/user.rb
-- lib/datadog/ci/itr/coverage/ddcov.rb
-- lib/datadog/ci/itr/coverage/event.rb
-- lib/datadog/ci/itr/coverage/transport.rb
-- lib/datadog/ci/itr/coverage/writer.rb
-- lib/datadog/ci/itr/runner.rb
-- lib/datadog/ci/itr/skippable.rb
 - lib/datadog/ci/span.rb
 - lib/datadog/ci/test.rb
 - lib/datadog/ci/test_module.rb
+- lib/datadog/ci/test_optimisation/component.rb
+- lib/datadog/ci/test_optimisation/coverage/ddcov.rb
+- lib/datadog/ci/test_optimisation/coverage/event.rb
+- lib/datadog/ci/test_optimisation/coverage/transport.rb
+- lib/datadog/ci/test_optimisation/coverage/writer.rb
+- lib/datadog/ci/test_optimisation/skippable.rb
+- lib/datadog/ci/test_optimisation/telemetry.rb
 - lib/datadog/ci/test_session.rb
 - lib/datadog/ci/test_suite.rb
-- lib/datadog/ci/test_visibility/context/global.rb
-- lib/datadog/ci/test_visibility/context/local.rb
+- lib/datadog/ci/test_visibility/component.rb
+- lib/datadog/ci/test_visibility/context.rb
 - lib/datadog/ci/test_visibility/flush.rb
-- lib/datadog/ci/test_visibility/null_recorder.rb
-- lib/datadog/ci/test_visibility/recorder.rb
+- lib/datadog/ci/test_visibility/null_component.rb
 - lib/datadog/ci/test_visibility/serializers/base.rb
 - lib/datadog/ci/test_visibility/serializers/factories/test_level.rb
 - lib/datadog/ci/test_visibility/serializers/factories/test_suite_level.rb
@@ -159,8 +161,13 @@ files:
 - lib/datadog/ci/test_visibility/serializers/test_suite.rb
 - lib/datadog/ci/test_visibility/serializers/test_v1.rb
 - lib/datadog/ci/test_visibility/serializers/test_v2.rb
+- lib/datadog/ci/test_visibility/store/global.rb
+- lib/datadog/ci/test_visibility/store/local.rb
+- lib/datadog/ci/test_visibility/telemetry.rb
 - lib/datadog/ci/test_visibility/transport.rb
 - lib/datadog/ci/transport/adapters/net.rb
+- lib/datadog/ci/transport/adapters/net_http_client.rb
+- lib/datadog/ci/transport/adapters/telemetry_webmock_safe_adapter.rb
 - lib/datadog/ci/transport/api/agentless.rb
 - lib/datadog/ci/transport/api/base.rb
 - lib/datadog/ci/transport/api/builder.rb
@@ -169,10 +176,13 @@ files:
 - lib/datadog/ci/transport/gzip.rb
 - lib/datadog/ci/transport/http.rb
 - lib/datadog/ci/transport/remote_settings_api.rb
+- lib/datadog/ci/transport/telemetry.rb
 - lib/datadog/ci/utils/bundle.rb
 - lib/datadog/ci/utils/configuration.rb
 - lib/datadog/ci/utils/git.rb
+- lib/datadog/ci/utils/identity.rb
 - lib/datadog/ci/utils/parsing.rb
+- lib/datadog/ci/utils/telemetry.rb
 - lib/datadog/ci/utils/test_run.rb
 - lib/datadog/ci/version.rb
 - lib/datadog/ci/worker.rb