inject logger

Author: p

lib/datadog/core/telemetry/component.rb

@@ -85,7 +85,7 @@ def initialize(
               enabled: @enabled,
               heartbeat_interval_seconds: settings.telemetry.heartbeat_interval_seconds,
               metrics_aggregation_interval_seconds: settings.telemetry.metrics_aggregation_interval_seconds,
-              emitter: Emitter.new(transport: @transport),
+              emitter: Emitter.new(transport: @transport, logger: @logger),
               metrics_manager: @metrics_manager,
               dependency_collection: settings.telemetry.dependency_collection,
               logger: logger,

lib/datadog/core/telemetry/emitter.rb

@@ -10,25 +10,26 @@ module Core
     module Telemetry
       # Class that emits telemetry events
       class Emitter
-        attr_reader :transport
+        attr_reader :transport, :logger
 
         extend Core::Utils::Forking
 
         # @param transport [Datadog::Core::Telemetry::Transport::Telemetry::Transport]
         #   Transport object that can be used to send telemetry requests
-        def initialize(transport:)
+        def initialize(transport:, logger: Datadog.logger)
           @transport = transport
+          @logger = logger
         end
 
         # Retrieves and emits a TelemetryRequest object based on the request type specified
         def request(event)
           seq_id = self.class.sequence.next
           payload = Request.build_payload(event, seq_id)
           res = @transport.send_telemetry(request_type: event.type, payload: payload)
-          Datadog.logger.debug { "Telemetry sent for event `#{event.type}` (response code: #{res.code})" }
+          logger.debug { "Telemetry sent for event `#{event.type}` (response code: #{res.code})" }
           res
         rescue => e
-          Datadog.logger.debug("Unable to send telemetry request for event `#{event.type rescue 'unknown'}`: #{e}")
+          logger.debug { "Unable to send telemetry request for event `#{event.type rescue 'unknown'}`: #{e}" }
           Core::Transport::InternalErrorResponse.new(e)
         end
 

spec/datadog/core/telemetry/emitter_spec.rb

@@ -5,7 +5,8 @@
 require 'datadog/core/transport/response'
 
 RSpec.describe Datadog::Core::Telemetry::Emitter do
-  subject(:emitter) { described_class.new(transport: transport) }
+  subject(:emitter) { described_class.new(transport: transport, logger: logger) }
+  let(:logger) { logger_allowing_debug }
   let(:transport) { double(Datadog::Core::Telemetry::Transport::HTTP::Client) }
   let(:response) { double(Datadog::Core::Transport::HTTP::Adapters::Net::Response) }
   let(:response_ok) { true }
@@ -35,22 +36,13 @@
     let(:request_type) { double('request_type') }
     let(:payload) { { foo: 'bar' } }
 
-    before do
-      logger = double(Datadog::Core::Logger)
-      allow(logger).to receive(:debug)
-      allow(Datadog).to receive(:logger).and_return(logger)
-    end
-
     context 'when event' do
       context 'is invalid' do
         let(:event) { 'Not an event' }
 
         it do
+          expect_lazy_log(logger, :debug, /Unable to send telemetry request/)
           request
-
-          expect(Datadog.logger).to have_received(:debug) do |message|
-            expect(message).to include('Unable to send telemetry request')
-          end
         end
       end
 
@@ -75,12 +67,8 @@
           end
 
           it 'logs the request correctly' do
-            log_message = nil
-            expect(Datadog.logger).to receive(:debug) { |&message| log_message = message.call }
-
+            expect_lazy_log(logger, :debug, 'Telemetry sent for event')
             request
-
-            expect(log_message).to match('Telemetry sent for event')
           end
         end
       end