datadog 2.4.0 → 2.44.0

data/lib/datadog/core/metrics/client.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require_relative '../utils/time'
-require_relative '../utils/only_once'
-require_relative '../telemetry/logger'
-require_relative '../configuration/ext'
+require_relative "../utils/time"
+require_relative "../utils/only_once"
+require_relative "../telemetry/logger"
+require_relative "../configuration/ext"
 
-require_relative 'ext'
-require_relative 'options'
-require_relative 'helpers'
-require_relative 'logging'
-require_relative 'metric'
+require_relative "ext"
+require_relative "options"
+require_relative "helpers"
+require_relative "logging"
+require_relative "metric"
 
 module Datadog
   module Core
@@ -21,9 +21,11 @@ module Datadog
         extend Options
         extend Helpers
 
-        attr_reader :statsd
+        attr_reader :statsd, :logger, :telemetry
 
-        def initialize(statsd: nil, enabled: true, **_)
+        def initialize(telemetry:, logger: Datadog.logger, statsd: nil, enabled: true, **_)
+          @telemetry = telemetry
+          @logger = logger
           @statsd =
             if supported?
               statsd || default_statsd_client
@@ -37,10 +39,10 @@ module Datadog
         def supported?
           version = dogstatsd_version
 
-          !version.nil? && version >= Gem::Version.new('3.3.0') &&
+          !version.nil? && version >= Gem::Version.new("3.3.0") &&
             # dogstatsd-ruby >= 5.0 & < 5.2.0 has known issues with process forks
             # and do not support the single thread mode we use to avoid this problem.
-            !(version >= Gem::Version.new('5.0') && version < Gem::Version.new('5.3'))
+            !(version >= Gem::Version.new("5.0") && version < Gem::Version.new("5.3"))
         end
 
         def enabled?
@@ -52,15 +54,15 @@ module Datadog
         end
 
         def default_hostname
-          ENV.fetch(Configuration::Ext::Agent::ENV_DEFAULT_HOST, Ext::DEFAULT_HOST)
+          DATADOG_ENV.fetch(Configuration::Ext::Agent::ENV_DEFAULT_HOST, Ext::DEFAULT_HOST)
         end
 
         def default_port
-          ENV.fetch(Configuration::Ext::Metrics::ENV_DEFAULT_PORT, Ext::DEFAULT_PORT).to_i
+          DATADOG_ENV.fetch(Configuration::Ext::Metrics::ENV_DEFAULT_PORT, Ext::DEFAULT_PORT).to_i
         end
 
         def default_statsd_client
-          require 'datadog/statsd'
+          require "datadog/statsd"
 
           # Create a StatsD client that points to the agent.
           #
@@ -72,11 +74,11 @@ module Datadog
           # overhead.
           #
           # Versions < 5.0 are always single-threaded, but do not have the kwarg option.
-          options = if dogstatsd_version >= Gem::Version.new('5.2')
-                      { single_thread: true }
-                    else
-                      {}
-                    end
+          options = if dogstatsd_version >= Gem::Version.new("5.2")
+            {single_thread: true}
+          else
+            {}
+          end
 
           Datadog::Statsd.new(default_hostname, default_port, **options)
         end
@@ -97,11 +99,11 @@ module Datadog
           raise ArgumentError if value.nil?
 
           statsd.count(stat, value, metric_options(options))
-        rescue StandardError => e
-          Datadog.logger.error(
-            "Failed to send count stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        rescue => e
+          logger.error(
+            "Failed to send count stat. Cause: #{e.class}: #{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)
@@ -111,11 +113,11 @@ module Datadog
           raise ArgumentError if value.nil?
 
           statsd.distribution(stat, value, metric_options(options))
-        rescue StandardError => e
-          Datadog.logger.error(
-            "Failed to send distribution stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        rescue => e
+          logger.error(
+            "Failed to send distribution stat. Cause: #{e.class}: #{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)
@@ -124,11 +126,11 @@ module Datadog
           options = yield if block_given?
 
           statsd.increment(stat, metric_options(options))
-        rescue StandardError => e
-          Datadog.logger.error(
-            "Failed to send increment stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        rescue => e
+          logger.error(
+            "Failed to send increment stat. Cause: #{e.class}: #{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)
@@ -138,11 +140,11 @@ module Datadog
           raise ArgumentError if value.nil?
 
           statsd.gauge(stat, value, metric_options(options))
-        rescue StandardError => e
-          Datadog.logger.error(
-            "Failed to send gauge stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        rescue => e
+          logger.error(
+            "Failed to send gauge stat. Cause: #{e.class}: #{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)
@@ -155,14 +157,14 @@ module Datadog
           begin
             if send_stats? && !start.nil?
               finished = Utils::Time.get_time
-              distribution(stat, ((finished - start) * 1000), options)
+              distribution(stat, (finished - start) * 1000, options)
             end
-          rescue StandardError => e
+          rescue => e
             # TODO: Likely to be redundant, since `distribution` handles its own errors.
-            Datadog.logger.error(
-              "Failed to send time stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            logger.error(
+              "Failed to send time stat. Cause: #{e.class}: #{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
 
@@ -171,7 +173,7 @@ module Datadog
         end
 
         def close
-          @statsd.close if @statsd && @statsd.respond_to?(:close)
+          @statsd.close if @statsd&.respond_to?(:close)
         end
 
         private
@@ -183,10 +185,8 @@ module Datadog
             defined?(Datadog::Statsd::VERSION) &&
               Datadog::Statsd::VERSION &&
               Gem::Version.new(Datadog::Statsd::VERSION)
-          ) || (
-            Gem.loaded_specs['dogstatsd-ruby'] &&
-              Gem.loaded_specs['dogstatsd-ruby'].version
-          )
+          ) ||
+            Gem.loaded_specs["dogstatsd-ruby"]&.version
         end
 
         IGNORED_STATSD_ONLY_ONCE = Utils::OnlyOnce.new
@@ -194,8 +194,8 @@ module Datadog
 
         def ignored_statsd_warning
           IGNORED_STATSD_ONLY_ONCE.run do
-            Datadog.logger.warn(
-              'Ignoring user-supplied statsd instance as currently-installed version of dogstastd-ruby is incompatible. ' \
+            logger.warn(
+              "Ignoring user-supplied statsd instance as currently-installed version of dogstastd-ruby is incompatible. " \
               "To fix this, ensure that you have `gem 'dogstatsd-ruby', '~> 5.3'` on your Gemfile or gems.rb file."
             )
           end

data/lib/datadog/core/metrics/ext.rb

@@ -5,13 +5,13 @@ module Datadog
     module Metrics
       # @public_api
       module Ext
-        DEFAULT_HOST = '127.0.0.1'
+        DEFAULT_HOST = "127.0.0.1"
         DEFAULT_PORT = 8125
 
-        TAG_LANG = 'language'
-        TAG_LANG_INTERPRETER = 'language-interpreter'
-        TAG_LANG_VERSION = 'language-version'
-        TAG_TRACER_VERSION = 'tracer-version'
+        TAG_LANG = "language"
+        TAG_LANG_INTERPRETER = "language-interpreter"
+        TAG_LANG_VERSION = "language-version"
+        TAG_TRACER_VERSION = "tracer-version"
       end
     end
   end

data/lib/datadog/core/metrics/helpers.rb

@@ -10,7 +10,7 @@ module Datadog
           :distribution,
           :increment,
           :gauge,
-          :time
+          :time,
         ].each do |metric_type|
           define_method(metric_type) do |name, stat|
             name = name.to_sym

data/lib/datadog/core/metrics/logging.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'logger'
-require 'json'
+require "logger"
+require "json"
 
 module Datadog
   module Core
@@ -12,30 +12,30 @@ module Datadog
           attr_accessor :logger
 
           def initialize(logger = nil)
-            @logger = logger || Logger.new($stdout).tap do |l|
+            @logger = logger || Logger.new($stderr).tap do |l|
               l.level = ::Logger::INFO
               l.progname = nil
               l.formatter = proc do |_severity, datetime, _progname, msg|
                 stat = JSON.parse(msg[3..-1]) # Trim off leading progname...
-                "#{JSON.dump(timestamp: datetime.to_i, message: 'Metric sent.', metric: stat)}\n"
+                "#{JSON.dump(timestamp: datetime.to_i, message: "Metric sent.", metric: stat)}\n"
               end
             end
           end
 
           def count(stat, value, options = nil)
-            logger.info({ stat: stat, type: :count, value: value, options: options }.to_json)
+            logger.info({stat: stat, type: :count, value: value, options: options}.to_json)
           end
 
           def distribution(stat, value, options = nil)
-            logger.info({ stat: stat, type: :distribution, value: value, options: options }.to_json)
+            logger.info({stat: stat, type: :distribution, value: value, options: options}.to_json)
           end
 
           def increment(stat, options = nil)
-            logger.info({ stat: stat, type: :increment, options: options }.to_json)
+            logger.info({stat: stat, type: :increment, options: options}.to_json)
           end
 
           def gauge(stat, value, options = nil)
-            logger.info({ stat: stat, type: :gauge, value: value, options: options }.to_json)
+            logger.info({stat: stat, type: :gauge, value: value, options: options}.to_json)
           end
         end
       end

data/lib/datadog/core/metrics/options.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
-require_relative '../environment/ext'
-require_relative '../environment/identity'
+require_relative "ext"
+require_relative "../environment/ext"
+require_relative "../environment/identity"
 
 module Datadog
   module Core
@@ -16,8 +16,8 @@ module Datadog
             "#{Ext::TAG_LANG_VERSION}:#{Environment::Identity.lang_version}",
             # TODO: Technically not accurate, if tracing version diverges from datadog gem version
             #       If we extract tracing to its own gem, this needs to be updated.
-            "#{Ext::TAG_TRACER_VERSION}:#{Environment::Identity.gem_datadog_version}"
-          ].freeze
+            "#{Ext::TAG_TRACER_VERSION}:#{Environment::Identity.gem_datadog_version}",
+          ].freeze,
         }.freeze
 
         def metric_options(options = nil)

data/lib/datadog/core/pin.rb

@@ -43,18 +43,18 @@ module Datadog
       # rubocop:disable Style/TrivialAccessors
       def onto(obj)
         unless obj.respond_to? :datadog_pin=
-          obj.instance_exec do
-            def datadog_pin=(pin)
-              @datadog_pin = pin
-            end
+          obj.define_singleton_method(:datadog_pin=) do |pin|
+            # Steep: https://github.com/soutaro/steep/issues/380
+            # @type self: PinnedObject
+            @datadog_pin = pin
           end
         end
 
         unless obj.respond_to? :datadog_pin
-          obj.instance_exec do
-            def datadog_pin
-              @datadog_pin
-            end
+          obj.define_singleton_method(:datadog_pin) do
+            # Steep: https://github.com/soutaro/steep/issues/380
+            # @type self: PinnedObject
+            @datadog_pin
           end
         end
 
@@ -63,7 +63,7 @@ module Datadog
       # rubocop:enable Style/TrivialAccessors
 
       def to_s
-        pretty_options = options.to_a.map { |k, v| "#{k}:#{v}" }.join(', ')
+        pretty_options = options.to_a.map { |k, v| "#{k}:#{v}" }.join(", ")
         "Pin(#{pretty_options})"
       end
 

data/lib/datadog/core/process_discovery/tracer_memfd.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module ProcessDiscovery
+      class TracerMemfd
+        def shutdown!(logger)
+          ProcessDiscovery._native_close_tracer_memfd(self, logger)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/process_discovery.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "process_discovery/tracer_memfd"
+require_relative "environment/process"
+require_relative "environment/container"
+
+module Datadog
+  module Core
+    # Class used to store tracer metadata in a native file descriptor.
+    module ProcessDiscovery
+      class << self
+        def publish(settings)
+          if RUBY_PLATFORM.include?("darwin")
+            Datadog.logger.debug { "Skipping process discovery, not yet supported on macOS" }
+            return
+          end
+
+          if (libdatadog_api_failure = Datadog::Core::LIBDATADOG_API_FAILURE)
+            Datadog.logger.debug { "Cannot enable process discovery: #{libdatadog_api_failure}" }
+            return
+          end
+
+          metadata = get_metadata(settings)
+
+          shutdown!
+          @file_descriptor = _native_store_tracer_metadata(Datadog.logger, **metadata)
+        end
+
+        def shutdown!
+          if defined?(@file_descriptor)
+            @file_descriptor&.shutdown!(Datadog.logger)
+            @file_descriptor = nil
+          end
+        end
+
+        def after_fork
+          # The runtime-id changes after a fork. We call publish to ensure that the runtime-id is updated.
+          publish(Datadog.configuration)
+        end
+
+        private
+
+        # According to the RFC, runtime_id, service_name, service_env, service_version are optional.
+        # In the C method exposed by ddcommon, memfd_create replaces empty strings by None for these fields.
+        def get_metadata(settings)
+          {
+            runtime_id: Core::Environment::Identity.id,
+            tracer_language: Core::Environment::Identity.lang,
+            tracer_version: Core::Environment::Identity.gem_datadog_version_semver2,
+            hostname: Core::Environment::Socket.hostname,
+            service_name: settings.service || "",
+            service_env: settings.env || "",
+            service_version: settings.version || "",
+            # Follows Java: https://github.com/DataDog/dd-trace-java/blob/2ebc964340ac530342cc389ba68ff0f5070d5f9f/dd-trace-core/src/main/java/datadog/trace/core/servicediscovery/ServiceDiscovery.java#L37-L38
+            process_tags: settings.experimental_propagate_process_tags_enabled ? Core::Environment::Process.serialized : "",
+            container_id: Core::Environment::Container.container_id || "",
+          }
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/rate_limiter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'utils/time'
+require_relative "utils/time"
 
 module Datadog
   module Core
@@ -13,13 +13,17 @@ module Datadog
       # to be side-effect free.
       #
       # @return [Boolean] whether a resource conforms with the current limit
-      def allow?(size = 1); end
+      def allow?(size = 1)
+        raise NotImplementedError
+      end
 
       # The effective rate limiting ratio based on
       # recent calls to `allow?`.
       #
       # @return [Float] recent allowance ratio
-      def effective_rate; end
+      def effective_rate
+        raise NotImplementedError
+      end
     end
 
     # Implementation of the Token Bucket metering algorithm
@@ -79,6 +83,10 @@ module Datadog
 
         return current_window_rate if @prev_conforming_messages.nil? || @prev_total_messages.nil?
 
+        # Steep: Due to https://github.com/soutaro/steep/issues/477,
+        # the previous nil check does not narrow type to Integer
+        # The annotation fixes the typing error, but it takes effect in the method
+        # @type ivar @prev_total_messages: Integer
         (@conforming_messages.to_f + @prev_conforming_messages.to_f) / (@total_messages + @prev_total_messages)
       end
 
@@ -152,7 +160,11 @@ module Datadog
         if @current_window.nil?
           @current_window = now
         # If more than 1 second has past since last window, reset
-        elsif now - @current_window >= 1
+        #
+        # Steep: @current_window is a Float, but for some reason annotations does not work here
+        # Once a fix will be out for nil checks on instance variables, we can remove the ignore comment
+        # https://github.com/soutaro/steep/issues/477
+        elsif now - @current_window >= 1 # steep:ignore UnresolvedOverloading
           @prev_conforming_messages = @conforming_messages
           @prev_total_messages = @total_messages
           @conforming_messages = 0

data/lib/datadog/core/remote/client/capabilities.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
-require_relative '../../utils/base64'
-require_relative '../../../appsec/remote'
-require_relative '../../../tracing/remote'
+require_relative "../../utils/base64_codec"
+require_relative "../../../appsec/remote"
+require_relative "../../../tracing/remote"
+require_relative "../../../di/remote"
+require_relative "../../../symbol_database"
+require_relative "../../../symbol_database/remote"
+require_relative "../../../open_feature/remote"
 
 module Datadog
   module Core
@@ -10,31 +14,98 @@ module Datadog
       class Client
         # Capabilities
         class Capabilities
-          attr_reader :products, :capabilities, :receivers, :base64_capabilities
+          attr_reader :capabilities, :receivers, :base64_capabilities
 
-          def initialize(settings, telemetry)
+          def initialize(settings, telemetry, open_feature_component_provider: nil)
+            open_feature_component_provider ||= -> {}
             @capabilities = []
             @products = []
+            @products_mutex = Mutex.new
             @receivers = []
             @telemetry = telemetry
 
-            register(settings)
+            register(settings, open_feature_component_provider)
 
             @base64_capabilities = capabilities_to_base64
           end
 
+          def products
+            @products_mutex.synchronize { @products.dup }
+          end
+
+          def add_products(*products)
+            @products_mutex.synchronize do
+              products.each { |product| @products << product unless @products.include?(product) }
+            end
+            nil
+          end
+
+          def remove_products(*products)
+            @products_mutex.synchronize { products.each { |product| @products.delete(product) } }
+            nil
+          end
+
           private
 
-          def register(settings)
+          def register(settings, open_feature_component_provider)
             if settings.respond_to?(:appsec) && settings.appsec.enabled
               register_capabilities(Datadog::AppSec::Remote.capabilities)
               register_products(Datadog::AppSec::Remote.products)
               register_receivers(Datadog::AppSec::Remote.receivers(@telemetry))
             end
 
+            # Tracing must register before DI: on a combined RC dispatch,
+            # the APM_TRACING handler must run first to call
+            # Datadog::DI::Remote.handle_rc_enablement and start the
+            # component before the DI receiver processes LIVE_DEBUGGING
+            # changes against `component.started?`. Reversing the order
+            # silently drops the probe — the remote client only
+            # redispatches on content hash changes.
             register_capabilities(Datadog::Tracing::Remote.capabilities)
             register_products(Datadog::Tracing::Remote.products)
             register_receivers(Datadog::Tracing::Remote.receivers(@telemetry))
+
+            if settings.respond_to?(:dynamic_instrumentation) &&
+                !Datadog::DI::Remote.explicitly_disabled?(settings) &&
+                Datadog::DI.supported_runtime?
+              register_capabilities(Datadog::DI::Remote.capabilities)
+              register_receivers(Datadog::DI::Remote.receivers(@telemetry))
+            end
+
+            # Skip symbol database registration on runtimes that cannot run it
+            # (JRuby, Ruby < 2.7): DI supports Ruby 2.6 but Symbol Database does
+            # not, so advertising LIVE_DEBUGGING_SYMBOL_DB there would invite
+            # symbol-upload configs the component can never serve.
+            if settings.respond_to?(:symbol_database) && Datadog::SymbolDatabase.supported_runtime?
+              # Symbol database follows DI: when unset it advertises whenever DI
+              # advertises (mirror the DI branch above, including the unset/default
+              # case that RC may enable). An explicit symbol_database.enabled wins.
+              di_enabled = settings.respond_to?(:dynamic_instrumentation) &&
+                !Datadog::DI::Remote.explicitly_disabled?(settings)
+              if Datadog::SymbolDatabase.resolve_enabled(settings.symbol_database.enabled, di_enabled)
+                register_capabilities(Datadog::SymbolDatabase::Remote.capabilities)
+                register_receivers(Datadog::SymbolDatabase::Remote.receivers(@telemetry))
+                # Register the product at startup only when symbol_database is
+                # explicitly set (true here, since resolve_enabled already
+                # excluded false). When it follows DI (enabled nil, default or
+                # explicit), defer the product so it is advertised only once DI
+                # actually starts.
+                unless settings.symbol_database.enabled.nil?
+                  register_products(Datadog::SymbolDatabase::Remote.products)
+                end
+              end
+            end
+
+            if settings.respond_to?(:open_feature) && settings.open_feature.enabled
+              register_capabilities(Datadog::OpenFeature::Remote.capabilities)
+              register_products(Datadog::OpenFeature::Remote.products)
+              register_receivers(
+                Datadog::OpenFeature::Remote.receivers(
+                  @telemetry,
+                  component_provider: open_feature_component_provider,
+                ),
+              )
+            end
           end
 
           def register_capabilities(capabilities)
@@ -50,12 +121,12 @@ module Datadog
           end
 
           def capabilities_to_base64
-            return '' if capabilities.empty?
+            return "" if capabilities.empty?
 
-            cap_to_hexs = capabilities.reduce(:|).to_s(16).tap { |s| s.size.odd? && s.prepend('0') }.scan(/\h\h/)
-            binary = cap_to_hexs.each_with_object([]) { |hex, acc| acc << hex }.map { |e| e.to_i(16) }.pack('C*')
+            cap_to_hexs = capabilities.reduce(:|).to_s(16).tap { |s| s.size.odd? && s.prepend("0") }.scan(/\h\h/)
+            binary = cap_to_hexs.each_with_object([]) { |hex, acc| acc << hex }.map { |e| e.to_i(16) }.pack("C*")
 
-            Datadog::Core::Utils::Base64.strict_encode64(binary)
+            Datadog::Core::Utils::Base64Codec.strict_encode64(binary)
           end
         end
       end