DEBUG-3573 Implement debug flag for telemetry

lib/datadog/core/configuration/settings.rb

@@ -888,6 +888,16 @@ def initialize(*_)
             o.env Core::Telemetry::Ext::ENV_LOG_COLLECTION
             o.default true
           end
+
+          # For internal use only.
+          # Enables telemetry debugging through the Datadog platform.
+          #
+          # @default `false`.
+          # @return [Boolean]
+          option :debug do |o|
+            o.type :bool
+            o.default false
+          end
         end
 
         # Remote configuration

lib/datadog/core/telemetry/component.rb

@@ -84,7 +84,11 @@ def initialize( # rubocop: disable Metrics/MethodLength
             enabled: @enabled,
             heartbeat_interval_seconds: settings.telemetry.heartbeat_interval_seconds,
             metrics_aggregation_interval_seconds: settings.telemetry.metrics_aggregation_interval_seconds,
-            emitter: Emitter.new(@transport, logger: @logger),
+            emitter: Emitter.new(
+              @transport,
+              logger: @logger,
+              debug: settings.telemetry.debug,
+            ),
             metrics_manager: @metrics_manager,
             dependency_collection: settings.telemetry.dependency_collection,
             logger: logger,

lib/datadog/core/telemetry/emitter.rb

@@ -16,15 +16,20 @@ class Emitter
 
         # @param transport [Datadog::Core::Telemetry::Transport::Telemetry::Transport]
         #   Transport object that can be used to send telemetry requests
-        def initialize(transport, logger: Datadog.logger)
+        def initialize(transport, logger: Datadog.logger, debug: false)
           @transport = transport
           @logger = logger
+          @debug = !!debug
+        end
+
+        def debug?
+          @debug
         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)
+          payload = Request.build_payload(event, seq_id, debug: debug?)
           res = @transport.send_telemetry(request_type: event.type, payload: payload)
           logger.debug { "Telemetry sent for event `#{event.type}` (response code: #{res.code})" }
           res

lib/datadog/core/telemetry/request.rb

@@ -11,11 +11,11 @@ module Request
         class << self
           using Core::Utils::Hash::Refinement
 
-          def build_payload(event, seq_id, api_version: 'v2')
+          def build_payload(event, seq_id, api_version: 'v2', debug: false)
             hash = {
               api_version: api_version,
               application: application,
-              debug: false,
+              debug: debug,
               host: host,
               payload: event.payload,
               request_type: event.type,

sig/datadog/core/telemetry/emitter.rbs

@@ -6,9 +6,11 @@ module Datadog
 
         attr_reader transport: untyped
         attr_reader logger: Core::Logger
+
+        def debug?: -> bool
 
         extend Core::Utils::Forking
-        def initialize: (untyped transport, ?logger: Core::Logger) -> void
+        def initialize: (untyped transport, ?logger: Core::Logger, ?debug: bool) -> void
         def request: (Datadog::Core::Telemetry::Event::Base event) -> (Datadog::Core::Transport::HTTP::Adapters::Net::Response | Datadog::Core::Transport::InternalErrorResponse)
         def self.sequence: () -> Datadog::Core::Utils::Sequence
       end

sig/datadog/core/telemetry/request.rbs

@@ -2,7 +2,7 @@ module Datadog
   module Core
     module Telemetry
       module Request
-        def self.build_payload: (Event::Base event, int seq_id) -> ::Hash[Symbol, untyped]
+        def self.build_payload: (Event::Base event, int seq_id, ?debug: bool) -> ::Hash[Symbol, untyped]
 
         private
 

spec/datadog/core/telemetry/emitter_spec.rb

@@ -82,7 +82,7 @@
       let(:payload) { { foo: 'bar' } }
 
       it 'creates a telemetry event with data' do
-        allow(Datadog::Core::Telemetry::Request).to receive(:build_payload).with(event, 1).and_return(payload)
+        allow(Datadog::Core::Telemetry::Request).to receive(:build_payload).with(event, 1, debug: false).and_return(payload)
 
         request
 

spec/datadog/core/telemetry/integration/telemetry_spec.rb

@@ -209,6 +209,36 @@
         )
       end
     end
+
+    context 'when telemetry debugging is enabled in settings' do
+      mark_telemetry_started
+
+      before do
+        settings.telemetry.debug = true
+      end
+
+      it 'sets debug to true in payload' do
+        component.worker.send(:heartbeat!)
+        component.worker.flush
+        expect(sent_payloads.length).to eq 1
+
+        payload = sent_payloads[0]
+        expect(payload.fetch(:payload)).to match(
+          'api_version' => 'v2',
+          'application' => expected_application_hash,
+          'debug' => true,
+          'host' => expected_host_hash,
+          'payload' => {},
+          'request_type' => 'app-heartbeat',
+          'runtime_id' => String,
+          'seq_id' => Integer,
+          'tracer_time' => Integer,
+        )
+        expect(payload.fetch(:headers)).to include(
+          expected_headers.merge('dd-telemetry-request-type' => %w[app-heartbeat])
+        )
+      end
+    end
   end
 
   let(:handler_proc) do