DEBUG-3700 Inject telemetry into metrics client

lib/datadog/core/configuration/components.rb

@@ -27,12 +27,12 @@ class Components
         class << self
           include Datadog::Tracing::Component
 
-          def build_health_metrics(settings, logger)
+          def build_health_metrics(settings, logger, telemetry)
             settings = settings.health_metrics
             options = { enabled: settings.enabled }
             options[:statsd] = settings.statsd unless settings.statsd.nil?
 
-            Core::Diagnostics::Health::Metrics.new(logger: logger, **options)
+            Core::Diagnostics::Health::Metrics.new(telemetry: telemetry, logger: logger, **options)
           end
 
           def build_logger(settings)
@@ -42,24 +42,24 @@ def build_logger(settings)
             logger
           end
 
-          def build_runtime_metrics(settings, logger)
+          def build_runtime_metrics(settings, logger, telemetry)
             options = { enabled: settings.runtime_metrics.enabled }
             options[:statsd] = settings.runtime_metrics.statsd unless settings.runtime_metrics.statsd.nil?
             options[:services] = [settings.service] unless settings.service.nil?
             options[:experimental_runtime_id_enabled] = settings.runtime_metrics.experimental_runtime_id_enabled
 
-            Core::Runtime::Metrics.new(logger: logger, **options)
+            Core::Runtime::Metrics.new(logger: logger, telemetry: telemetry, **options)
           end
 
-          def build_runtime_metrics_worker(settings, logger)
+          def build_runtime_metrics_worker(settings, logger, telemetry)
             # NOTE: Should we just ignore building the worker if its not enabled?
             options = settings.runtime_metrics.opts.merge(
               enabled: settings.runtime_metrics.enabled,
-              metrics: build_runtime_metrics(settings, logger),
+              metrics: build_runtime_metrics(settings, logger, telemetry),
               logger: logger,
             )
 
-            Core::Workers::RuntimeMetrics.new(options)
+            Core::Workers::RuntimeMetrics.new(telemetry: telemetry, **options)
           end
 
           def build_telemetry(settings, agent_settings, logger)
@@ -119,8 +119,8 @@ def initialize(settings)
           )
           @environment_logger_extra.merge!(profiler_logger_extra) if profiler_logger_extra
 
-          @runtime_metrics = self.class.build_runtime_metrics_worker(settings, @logger)
-          @health_metrics = self.class.build_health_metrics(settings, @logger)
+          @runtime_metrics = self.class.build_runtime_metrics_worker(settings, @logger, telemetry)
+          @health_metrics = self.class.build_health_metrics(settings, @logger, telemetry)
           @appsec = Datadog::AppSec::Component.build_appsec_component(settings, telemetry: telemetry)
           @dynamic_instrumentation = Datadog::DI::Component.build(settings, agent_settings, @logger, telemetry: telemetry)
           @environment_logger_extra[:dynamic_instrumentation_enabled] = !!@dynamic_instrumentation

lib/datadog/core/metrics/client.rb

@@ -21,9 +21,10 @@ class Client
         extend Options
         extend Helpers
 
-        attr_reader :statsd, :logger
+        attr_reader :statsd, :logger, :telemetry
 
-        def initialize(logger: Datadog.logger, statsd: nil, enabled: true, **_)
+        def initialize(telemetry:, logger: Datadog.logger, statsd: nil, enabled: true, **_)
+          @telemetry = telemetry
           @logger = logger
           @statsd =
             if supported?
@@ -102,7 +103,7 @@ def count(stat, value = nil, options = nil, &block)
           logger.error(
             "Failed to send count stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
-          Telemetry::Logger.report(e, description: 'Failed to send count stat')
+          telemetry&.report(e, description: 'Failed to send count stat')
         end
 
         def distribution(stat, value = nil, options = nil, &block)
@@ -116,7 +117,7 @@ def distribution(stat, value = nil, options = nil, &block)
           logger.error(
             "Failed to send distribution stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
-          Telemetry::Logger.report(e, description: 'Failed to send distribution stat')
+          telemetry&.report(e, description: 'Failed to send distribution stat')
         end
 
         def increment(stat, options = nil)
@@ -129,7 +130,7 @@ def increment(stat, options = nil)
           logger.error(
             "Failed to send increment stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
-          Telemetry::Logger.report(e, description: 'Failed to send increment stat')
+          telemetry&.report(e, description: 'Failed to send increment stat')
         end
 
         def gauge(stat, value = nil, options = nil, &block)
@@ -143,7 +144,7 @@ def gauge(stat, value = nil, options = nil, &block)
           logger.error(
             "Failed to send gauge stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
-          Telemetry::Logger.report(e, description: 'Failed to send gauge stat')
+          telemetry&.report(e, description: 'Failed to send gauge stat')
         end
 
         def time(stat, options = nil)
@@ -163,7 +164,7 @@ def time(stat, options = nil)
             logger.error(
               "Failed to send time stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
             )
-            Telemetry::Logger.report(e, description: 'Failed to send time stat')
+            telemetry&.report(e, description: 'Failed to send time stat')
           end
         end
 

lib/datadog/core/runtime/metrics.rb

@@ -14,7 +14,7 @@ module Core
     module Runtime
       # For generating runtime metrics
       class Metrics < Core::Metrics::Client
-        def initialize(**options)
+        def initialize(telemetry:, **options)
           super
 
           # Initialize service list

lib/datadog/core/workers/runtime_metrics.rb

@@ -20,8 +20,8 @@ class RuntimeMetrics < Worker
         attr_reader \
           :metrics
 
-        def initialize(options = {})
-          @metrics = options.fetch(:metrics) { Core::Runtime::Metrics.new(logger: options[:logger]) }
+        def initialize(telemetry:, **options)
+          @metrics = options.fetch(:metrics) { Core::Runtime::Metrics.new(logger: options[:logger], telemetry: telemetry) }
 
           # Workers::Async::Thread settings
           self.fork_policy = options.fetch(:fork_policy, Workers::Async::Thread::FORK_POLICY_STOP)

sig/datadog/core/metrics/client.rbs

@@ -13,7 +13,7 @@ module Datadog
         attr_reader statsd: untyped
 	attr_reader logger: Core::Logger
 
-        def initialize: (?statsd: untyped?, ?enabled: bool, logger: Core::Logger, **untyped _) -> void
+        def initialize: (telemetry: Core::Telemetry::Component, ?statsd: untyped?, ?enabled: bool, logger: Core::Logger, **untyped _) -> void
 
         def supported?: () -> untyped
 

spec/datadog/core/configuration/components_spec.rb

@@ -82,11 +82,11 @@
       ).and_return([profiler, environment_logger_extra])
 
       expect(described_class).to receive(:build_runtime_metrics_worker)
-        .with(settings, logger)
+        .with(settings, logger, telemetry)
         .and_return(runtime_metrics)
 
       expect(described_class).to receive(:build_health_metrics)
-        .with(settings, logger)
+        .with(settings, logger, telemetry)
         .and_return(health_metrics)
     end
 
@@ -155,7 +155,7 @@
   end
 
   describe '::build_health_metrics' do
-    subject(:build_health_metrics) { described_class.build_health_metrics(settings, logger) }
+    subject(:build_health_metrics) { described_class.build_health_metrics(settings, logger, telemetry) }
 
     context 'given settings' do
       shared_examples_for 'new health metrics' do
@@ -165,7 +165,7 @@
 
         before do
           expect(Datadog::Core::Diagnostics::Health::Metrics).to receive(:new)
-            .with(default_options.merge(options).merge(logger: logger))
+            .with(default_options.merge(options).merge(logger: logger, telemetry: telemetry))
             .and_return(health_metrics)
         end
 
@@ -291,7 +291,7 @@
   end
 
   describe '::build_runtime_metrics' do
-    subject(:build_runtime_metrics) { described_class.build_runtime_metrics(settings, logger) }
+    subject(:build_runtime_metrics) { described_class.build_runtime_metrics(settings, logger, telemetry) }
 
     context 'given settings' do
       shared_examples_for 'new runtime metrics' do
@@ -305,7 +305,7 @@
 
         before do
           expect(Datadog::Core::Runtime::Metrics).to receive(:new)
-            .with(default_options.merge(options).merge(logger: logger))
+            .with(**default_options.merge(options).merge(logger: logger, telemetry: telemetry))
             .and_return(runtime_metrics)
         end
 
@@ -375,7 +375,7 @@
   end
 
   describe '::build_runtime_metrics_worker' do
-    subject(:build_runtime_metrics_worker) { described_class.build_runtime_metrics_worker(settings, logger) }
+    subject(:build_runtime_metrics_worker) { described_class.build_runtime_metrics_worker(settings, logger, telemetry) }
 
     context 'given settings' do
       shared_examples_for 'new runtime metrics worker' do
@@ -391,11 +391,11 @@
 
         before do
           allow(described_class).to receive(:build_runtime_metrics)
-            .with(settings, logger)
+            .with(settings, logger, telemetry)
             .and_return(runtime_metrics)
 
           expect(Datadog::Core::Workers::RuntimeMetrics).to receive(:new)
-            .with(default_options.merge(options).merge(logger: logger))
+            .with(**default_options.merge(options).merge(logger: logger, telemetry: telemetry))
             .and_return(runtime_metrics_worker)
         end
 

spec/datadog/core/metrics/client_spec.rb

@@ -7,9 +7,10 @@
   include_context 'metrics'
 
   let(:logger) { Logger.new($stderr) }
+  let(:telemetry) { double(Datadog::Core::Telemetry::Component) }
   let(:options) { { statsd: statsd } }
 
-  subject(:metrics) { described_class.new(logger: logger, **options) }
+  subject(:metrics) { described_class.new(telemetry: telemetry, logger: logger, **options) }
   after { metrics.close }
 
   it { is_expected.to have_attributes(statsd: statsd) }
@@ -19,7 +20,7 @@
       expect(logger).to receive(:error).with(
         /Failed to send #{action} stat/
       )
-      expect(Datadog::Core::Telemetry::Logger).to receive(:report).with(
+      expect(telemetry).to receive(:report).with(
         a_kind_of(StandardError),
         description: "Failed to send #{action} stat"
       )
@@ -758,6 +759,7 @@
       context 'which raises an error' do
         before do
           expect(statsd).to receive(:distribution).and_raise(StandardError)
+          expect(telemetry).to receive(:report)
           expect(logger).to receive(:error)
         end
 

spec/datadog/core/metrics/logging_spec.rb

@@ -10,6 +10,7 @@
   subject(:adapter) { described_class.new(logger) }
 
   let(:logger) { instance_double(Logger) }
+  let(:telemetry) { double(Datadog::Core::Telemetry::Component) }
 
   def have_received_json_metric(expected_hash)
     have_received(:info) do |msg|
@@ -121,7 +122,7 @@ def have_received_json_metric(expected_hash)
   end
 
   context 'when used in Datadog::Metrics' do
-    subject(:metrics) { Datadog::Core::Metrics::Client.new(statsd: adapter, logger: logger) }
+    subject(:metrics) { Datadog::Core::Metrics::Client.new(statsd: adapter, logger: logger, telemetry: telemetry) }
 
     describe 'and #count is sent' do
       subject(:count) { metrics.count(stat, value, options) }

spec/datadog/core/runtime/metrics_spec.rb

@@ -5,8 +5,9 @@
 
 RSpec.describe Datadog::Core::Runtime::Metrics do
   let(:logger) { logger_allowing_debug }
+  let(:telemetry) { double(Datadog::Core::Telemetry::Component) }
   let(:options) { {} }
-  subject(:runtime_metrics) { described_class.new(logger: logger, **options) }
+  subject(:runtime_metrics) { described_class.new(logger: logger, telemetry: telemetry, **options) }
 
   describe '::new' do
     context 'given :services' do

spec/datadog/core/workers/runtime_metrics_spec.rb

@@ -4,12 +4,13 @@
 require 'datadog/core/workers/runtime_metrics'
 
 RSpec.describe Datadog::Core::Workers::RuntimeMetrics do
-  subject(:worker) { described_class.new(options) }
+  subject(:worker) { described_class.new(telemetry: telemetry, **options) }
 
   let(:metrics) { instance_double(Datadog::Core::Runtime::Metrics, close: nil) }
   let(:options) { { metrics: metrics, enabled: true } }
 
   let(:logger) { logger_allowing_debug }
+  let(:telemetry) { double(Datadog::Core::Telemetry::Component) }
 
   before { allow(metrics).to receive(:flush) }
 
@@ -19,7 +20,7 @@
     it { expect(worker).to be_a_kind_of(Datadog::Core::Workers::Polling) }
 
     context 'by default' do
-      subject(:worker) { described_class.new(logger: logger) }
+      subject(:worker) { described_class.new(logger: logger, telemetry: telemetry) }
 
       it { expect(worker.enabled?).to be false }
       it { expect(worker.loop_base_interval).to eq 10 }

spec/datadog/tracing/diagnostics/health_spec.rb

@@ -7,9 +7,10 @@
   # TODO: Core::Health::Metrics directly extends Tracing::Health::Metrics
   #       In the future, have tracing add this behavior itself. For now,
   #       just use the core metrics class to drive the tests.
-  subject(:health_metrics) { Datadog::Core::Diagnostics::Health::Metrics.new(logger: logger) }
+  subject(:health_metrics) { Datadog::Core::Diagnostics::Health::Metrics.new(logger: logger, telemetry: telemetry) }
 
   let(:logger) { logger_allowing_debug }
+  let(:telemetry) { double(Datadog::Core::Telemetry::Component) }
 
   shared_examples_for 'a health metric' do |type, name, stat|
     subject(:health_metric) { health_metrics.send(name, *args, &block) }