pull telemtry transport creation up to Core::Configuration::Component…

…s class

lib/datadog/core/configuration/components.rb

@@ -63,6 +63,7 @@ def build_telemetry(settings, agent_settings, logger)
             end
 
             Telemetry::Component.new(
+              http_transport: Datadog::Core::Telemetry::Http::Transport.new,
               enabled: enabled,
               metrics_enabled: enabled && settings.telemetry.metrics_enabled,
               heartbeat_interval_seconds: settings.telemetry.heartbeat_interval_seconds,

lib/datadog/core/telemetry/component.rb

@@ -24,6 +24,7 @@ def initialize(
           heartbeat_interval_seconds:,
           metrics_aggregation_interval_seconds:,
           dependency_collection:,
+          http_transport:,
           enabled: true,
           metrics_enabled: true
         )
@@ -39,7 +40,7 @@ def initialize(
             enabled: @enabled,
             heartbeat_interval_seconds: heartbeat_interval_seconds,
             metrics_aggregation_interval_seconds: metrics_aggregation_interval_seconds,
-            emitter: Emitter.new,
+            emitter: Emitter.new(http_transport: http_transport),
             metrics_manager: @metrics_manager,
             dependency_collection: dependency_collection
           )

lib/datadog/core/telemetry/emitter.rb

@@ -16,22 +16,20 @@ class Emitter
 
         # @param http_transport [Datadog::Core::Telemetry::Http::Transport] Transport object that can be used to send
         #   telemetry requests via the agent
-        def initialize(http_transport: Datadog::Core::Telemetry::Http::Transport.new)
+        def initialize(http_transport:)
           @http_transport = http_transport
         end
 
         # Retrieves and emits a TelemetryRequest object based on the request type specified
         def request(event)
-          begin
-            seq_id = self.class.sequence.next
-            payload = Request.build_payload(event, seq_id)
-            res = @http_transport.request(request_type: event.type, payload: payload.to_json)
-            Datadog.logger.debug { "Telemetry sent for event `#{event.type}` (code: #{res.code.inspect})" }
-            res
-          rescue => e
-            Datadog.logger.debug("Unable to send telemetry request for event `#{event.type rescue 'unknown'}`: #{e}")
-            Telemetry::Http::InternalErrorResponse.new(e)
-          end
+          seq_id = self.class.sequence.next
+          payload = Request.build_payload(event, seq_id)
+          res = @http_transport.request(request_type: event.type, payload: payload.to_json)
+          Datadog.logger.debug { "Telemetry sent for event `#{event.type}` (code: #{res.code.inspect})" }
+          res
+        rescue => e
+          Datadog.logger.debug("Unable to send telemetry request for event `#{event.type rescue 'unknown'}`: #{e}")
+          Telemetry::Http::InternalErrorResponse.new(e)
         end
 
         # Initializes a Sequence object to track seq_id if not already initialized; else returns stored

sig/datadog/core/telemetry/component.rbs

@@ -11,7 +11,7 @@ module Datadog
 
         include Core::Utils::Forking
 
-        def initialize: (heartbeat_interval_seconds: Float, metrics_aggregation_interval_seconds: Float, dependency_collection: bool, ?enabled: bool, ?metrics_enabled: bool) -> void
+        def initialize: (http_transport: Datadog::Core::Telemetry::Http::Transport, heartbeat_interval_seconds: Float, metrics_aggregation_interval_seconds: Float, dependency_collection: bool, ?enabled: bool, ?metrics_enabled: bool) -> void
 
         def disable!: () -> void
 

sig/datadog/core/telemetry/emitter.rbs

@@ -7,7 +7,7 @@ module Datadog
         attr_reader http_transport: untyped
 
         extend Core::Utils::Forking
-        def initialize: (?http_transport: untyped) -> void
+        def initialize: (http_transport: untyped) -> void
         def request: (Datadog::Core::Telemetry::Event::Base event) -> Datadog::Core::Telemetry::Http::Adapters::Net::Response
         def self.sequence: () -> untyped
       end

sig/datadog/core/telemetry/event.rbs

@@ -10,7 +10,7 @@ module Datadog
 
         class Base
           def payload: () -> (Hash[Symbol, untyped] | Array[Hash[Symbol, untyped]])
-          def type: -> String?
+          def type: -> String
         end
 
         class AppStarted < Base

spec/datadog/core/configuration/components_spec.rb

@@ -225,7 +225,8 @@
     context 'given settings' do
       let(:telemetry) { instance_double(Datadog::Core::Telemetry::Component) }
       let(:expected_options) do
-        { enabled: enabled, metrics_enabled: metrics_enabled, heartbeat_interval_seconds: heartbeat_interval_seconds,
+        { enabled: enabled, http_transport: an_instance_of(Datadog::Core::Telemetry::Http::Transport),
+          metrics_enabled: metrics_enabled, heartbeat_interval_seconds: heartbeat_interval_seconds,
           metrics_aggregation_interval_seconds: metrics_aggregation_interval_seconds,
           dependency_collection: dependency_collection }
       end
@@ -249,7 +250,8 @@
 
         context 'and :unix agent adapter' do
           let(:expected_options) do
-            { enabled: false, metrics_enabled: false, heartbeat_interval_seconds: heartbeat_interval_seconds,
+            { enabled: false, http_transport: an_instance_of(Datadog::Core::Telemetry::Http::Transport),
+              metrics_enabled: false, heartbeat_interval_seconds: heartbeat_interval_seconds,
               metrics_aggregation_interval_seconds: metrics_aggregation_interval_seconds,
               dependency_collection: dependency_collection }
           end

spec/datadog/core/telemetry/component_spec.rb

@@ -6,6 +6,7 @@
   subject(:telemetry) do
     described_class.new(
       enabled: enabled,
+      http_transport: http_transport,
       metrics_enabled: metrics_enabled,
       heartbeat_interval_seconds: heartbeat_interval_seconds,
       metrics_aggregation_interval_seconds: metrics_aggregation_interval_seconds,
@@ -19,6 +20,7 @@
   let(:metrics_aggregation_interval_seconds) { 1 }
   let(:dependency_collection) { true }
   let(:worker) { double(Datadog::Core::Telemetry::Worker) }
+  let(:http_transport) { double(Datadog::Core::Telemetry::Http::Transport) }
   let(:not_found) { false }
 
   before do
@@ -45,6 +47,7 @@
     context 'with default parameters' do
       subject(:telemetry) do
         described_class.new(
+          http_transport: http_transport,
           heartbeat_interval_seconds: heartbeat_interval_seconds,
           metrics_aggregation_interval_seconds: metrics_aggregation_interval_seconds,
           dependency_collection: dependency_collection

spec/datadog/core/telemetry/emitter_spec.rb

@@ -18,16 +18,8 @@
   end
 
   describe '#initialize' do
-    context 'when no params provided' do
-      subject(:emitter) { described_class.new }
-      it { is_expected.to be_a_kind_of(described_class) }
-    end
-
-    context 'when :http_transport is provided' do
-      let(:http_transport) { double(Datadog::Core::Telemetry::Http::Transport) }
-      it { is_expected.to be_a_kind_of(described_class) }
-      it { expect(emitter.http_transport).to be(http_transport) }
-    end
+    it { is_expected.to be_a_kind_of(described_class) }
+    it { expect(emitter.http_transport).to be(http_transport) }
 
     it 'seq_id begins with 1' do
       original_seq_id = emitter.class.sequence.instance_variable_get(:@current)