datadog 2.23.0 → 2.24.0

data/lib/datadog/open_feature/remote.rb

@@ -6,8 +6,6 @@ module Datadog
   module OpenFeature
     # This module contains the remote configuration functionality for OpenFeature
     module Remote
-      ReadError = Class.new(StandardError)
-
       class << self
         FFE_FLAG_CONFIGURATION_RULES = 1 << 46
         FFE_PRODUCTS = ['FFE_FLAGS'].freeze
@@ -42,8 +40,6 @@ module Datadog
                   # @type var content: Core::Remote::Configuration::Content
                   engine.reconfigure!(read_content(content))
                   content.applied
-                rescue ReadError => e
-                  content.errored("Error reading Remote Configuration content: #{e.message}")
                 rescue EvaluationEngine::ReconfigurationError => e
                   content.errored("Error applying OpenFeature configuration: #{e.message}")
                 end
@@ -61,12 +57,9 @@ module Datadog
         private
 
         def read_content(content)
-          data = content.data.read
-          content.data.rewind
-
-          raise ReadError, 'EOF reached' if data.nil?
-
-          data
+          # Unlike all of the other remotes, this one does not JSON-parse
+          # the data.
+          content.data
         end
       end
     end

data/lib/datadog/open_feature/transport.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require_relative '../core/encoding'
 require_relative '../core/transport/http'
 require_relative '../core/transport/http/env'
+require_relative '../core/transport/http/api/endpoint'
+require_relative '../core/transport/http/api/instance'
 require_relative '../core/transport/parcel'
 require_relative '../core/transport/request'
 
@@ -17,15 +20,14 @@ module Datadog
       end
 
       class HTTP
-        class Spec < Core::Transport::HTTP::API::Spec
+        class Spec
           def initialize
             @endpoint = Core::Transport::HTTP::API::Endpoint.new(
               :post, '/evp_proxy/v2/api/v2/exposures'
             )
-
-            super
           end
 
+          # TODO rename to send_request?
           def call(env, &block)
             @endpoint.call(env) do |request_env|
               request_env.headers['Content-Type'] = Core::Encoding::JSONEncoder.content_type
@@ -37,15 +39,8 @@ module Datadog
           end
         end
 
-        class Instance < Core::Transport::HTTP::API::Instance
-          def send_exposures(env)
-            @spec.call(env) { |request_env| call(request_env) }
-          end
-        end
-
         def self.build(agent_settings:, logger:)
           Core::Transport::HTTP.build(
-            api_instance_class: HTTP::Instance,
             agent_settings: agent_settings,
             logger: logger
           ) { |t| t.api('exposures', HTTP::Spec.new) }.to_transport(self)
@@ -58,7 +53,10 @@ module Datadog
 
         def send_exposures(payload)
           request = Core::Transport::Request.new(EncodedParcel.new(payload))
-          @api.send_exposures(Core::Transport::HTTP::Env.new(request))
+
+          @api.endpoint.call(Core::Transport::HTTP::Env.new(request)) do |env|
+            @api.call(env)
+          end
         rescue => e
           message = "Internal error during request. Cause: #{e.class.name} #{e.message} " \
                     "Location: #{Array(e.backtrace).first}"

data/lib/datadog/opentelemetry/api/baggage.rb

@@ -26,7 +26,7 @@ module Datadog
         # to ::OpenTelemetry::Context.current
         # @return [Context]
         def clear(context: ::OpenTelemetry::Context.current)
-          context.ensure_trace.baggage.clear
+          context.ensure_trace&.baggage&.clear
           context
         end
 

data/lib/datadog/opentelemetry/configuration/settings.rb

@@ -140,13 +140,13 @@ module Datadog
                 option :timeout_millis do |o|
                   o.type :int, nilable: true
                   o.env 'OTEL_EXPORTER_OTLP_METRICS_TIMEOUT'
-                  o.default nil
+                  o.default 10000
                 end
 
                 option :protocol do |o|
                   o.type :string, nilable: true
                   o.env 'OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'
-                  o.default nil
+                  o.default "http/protobuf"
                   o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'))
                 end
               end

data/lib/datadog/opentelemetry/metrics.rb

@@ -70,12 +70,7 @@ module Datadog
         @logger.warn("Failed to configure OTLP metrics exporter:  #{e.class}: #{e}")
       end
 
-      def resolve_metrics_endpoint
-        metrics_config = @settings.opentelemetry.metrics
-        exporter_config = @settings.opentelemetry.exporter
-
-        return metrics_config.endpoint if metrics_config.endpoint
-        return exporter_config.endpoint if exporter_config.endpoint
+      def default_metrics_endpoint
         "#{@agent_ssl ? "https" : "http"}://#{@agent_host}:4318/v1/metrics"
       end
 
@@ -84,16 +79,19 @@ module Datadog
         require_relative 'sdk/metrics_exporter'
 
         metrics_config = @settings.opentelemetry.metrics
-        exporter_config = @settings.opentelemetry.exporter
-        timeout = metrics_config.timeout_millis || exporter_config.timeout_millis
-        headers = metrics_config.headers || exporter_config.headers || {}
-
-        protocol = metrics_config.protocol || exporter_config.protocol
+        endpoint = get_metrics_config_with_fallback(
+          option_name: :endpoint,
+          computed_default: default_metrics_endpoint
+        )
+        timeout = get_metrics_config_with_fallback(option_name: :timeout_millis)
+        headers = get_metrics_config_with_fallback(option_name: :headers)
+        # OpenTelemetry SDK only supports http/protobuf protocol.
+        # TODO: Add support for http/json and grpc.
+        # protocol = get_metrics_config_with_fallback(option_name: :protocol)
         exporter = Datadog::OpenTelemetry::SDK::MetricsExporter.new(
-          endpoint: resolve_metrics_endpoint,
+          endpoint: endpoint,
           timeout: timeout / 1000.0,
-          headers: headers,
-          protocol: protocol
+          headers: headers
         )
 
         reader = ::OpenTelemetry::SDK::Metrics::Export::PeriodicMetricReader.new(
@@ -105,6 +103,15 @@ module Datadog
       rescue LoadError => e
         @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e}")
       end
+
+      # Returns metrics config value if explicitly set, otherwise falls back to exporter config or computed default value.
+      def get_metrics_config_with_fallback(option_name:, computed_default: nil)
+        if @settings.opentelemetry.metrics.using_default?(option_name)
+          @settings.opentelemetry.exporter.public_send(option_name) || computed_default
+        else
+          @settings.opentelemetry.metrics.public_send(option_name)
+        end
+      end
     end
   end
 end

data/lib/datadog/opentelemetry/sdk/metrics_exporter.rb

@@ -9,21 +9,18 @@ module Datadog
         METRIC_EXPORT_ATTEMPTS = 'otel.metrics_export_attempts'
         METRIC_EXPORT_SUCCESSES = 'otel.metrics_export_successes'
         METRIC_EXPORT_FAILURES = 'otel.metrics_export_failures'
-
-        def initialize(endpoint:, timeout:, headers:, protocol:)
-          super(endpoint: endpoint, timeout: timeout, headers: headers)
-          @telemetry_tags = {'protocol' => protocol, 'encoding' => 'protobuf'}
-        end
+        TELEMETRY_NAMESPACE = 'tracers'
+        TELEMETRY_TAGS = {'protocol' => "http", 'encoding' => 'protobuf'}
 
         def export(metrics, timeout: nil)
-          telemetry&.inc('tracers', METRIC_EXPORT_ATTEMPTS, 1, tags: @telemetry_tags)
+          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_ATTEMPTS, 1, tags: TELEMETRY_TAGS)
           result = super
           metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
-          telemetry&.inc('tracers', metric_name, 1, tags: @telemetry_tags)
+          telemetry&.inc(TELEMETRY_NAMESPACE, metric_name, 1, tags: TELEMETRY_TAGS)
           result
         rescue => e
           Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e}")
-          telemetry&.inc('tracers', METRIC_EXPORT_FAILURES, 1, tags: @telemetry_tags)
+          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_FAILURES, 1, tags: TELEMETRY_TAGS)
           raise
         end
 

data/lib/datadog/profiling/collectors/code_provenance.rb

@@ -22,7 +22,7 @@ module Datadog
           @libraries_by_path = {}
           @seen_files = Set.new
           @seen_libraries = Set.new
-          @executable_paths = [Gem.bindir, (Bundler.bin_path.to_s if defined?(Bundler))].uniq.compact.freeze
+          @executable_paths = [Gem.bindir, bundler_bin_path].uniq.compact.freeze
 
           record_library(
             Library.new(
@@ -116,6 +116,30 @@ module Datadog
           end
         end
 
+        # This is intended to mirror bundler's `Bundler.bin_path` with one key difference: the bundler version of the
+        # method **tries to create the path** if it doesn't exist, whereas our version doesn't.
+        #
+        # This "try to create the path" is annoying because creating the path can fail if e.g. the app doesn't have
+        # permissions to do that, see https://github.com/DataDog/dd-trace-rb/issues/5137.
+        # Thus we have our own version that a) Avoids creating the path, and b) Rescues exceptions to avoid any
+        # bundler complaints here impacting the application. (Bundler tends to go "something is wrong, raise!" which
+        # I think makes a lot of sense given how bundler is intended to be used, but for this our kind of "ask a few
+        # questions usage" it's not what we want.)
+        def bundler_bin_path
+          return unless defined?(Bundler)
+
+          path = Bundler.settings[:bin] || "bin"
+          root = Bundler.root
+          result = Pathname.new(path).expand_path(root).expand_path
+          result.to_s
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          Datadog.logger.debug(
+            "CodeProvenance#bundler_bin_path failed. " \
+            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+          nil
+        end
+
         # Represents metadata we have for a ruby gem
         #
         # Important note: This class gets encoded to JSON with the built-in JSON gem. But, we've found that in some
@@ -137,7 +161,8 @@ module Datadog
           end
 
           def to_json(arg = nil)
-            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg)
+            # Steep: https://github.com/ruby/rbs/pull/2691
+            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg) # steep:ignore ArgumentTypeMismatch
           end
 
           def path

data/lib/datadog/profiling/collectors/info.rb

@@ -16,7 +16,8 @@ module Datadog
       class Info
         def initialize(settings)
           @profiler_info = nil
-          @info = {
+          # Steep: https://github.com/soutaro/steep/issues/363
+          @info = { # steep:ignore IncompatibleAssignment
             platform: collect_platform_info,
             runtime: collect_runtime_info,
             application: collect_application_info(settings),

data/lib/datadog/profiling/component.rb

@@ -4,9 +4,6 @@ module Datadog
   module Profiling
     # Responsible for wiring up the Profiler for execution
     module Component
-      ALLOCATION_WITH_RACTORS_ONLY_ONCE = Datadog::Core::Utils::OnlyOnce.new
-      private_constant :ALLOCATION_WITH_RACTORS_ONLY_ONCE
-
       # Passing in a `nil` tracer is supported and will disable the following profiling features:
       # * Profiling in the trace viewer, as well as scoping a profile down to a span
       # * Endpoint aggregation in the profiler UX, including normalization (resource per endpoint call)
@@ -145,7 +142,7 @@ module Datadog
           logger.debug(
             "Using Ractors may result in GC profiling unexpectedly " \
             "stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your " \
-            "application stability or performance. This does not happen if Ractors are not used."
+            "application stability or performance. This issue is fixed on Ruby 4."
           )
         end
 
@@ -195,13 +192,11 @@ module Datadog
         # On all known versions of Ruby 3.x, due to https://bugs.ruby-lang.org/issues/19112, when a ractor gets
         # garbage collected, Ruby will disable all active tracepoints, which this feature internally relies on.
         elsif RUBY_VERSION.start_with?("3.")
-          ALLOCATION_WITH_RACTORS_ONLY_ONCE.run do
-            logger.info(
-              "Using Ractors may result in allocation profiling " \
-              "stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your " \
-              "application stability or performance. This does not happen if Ractors are not used."
-            )
-          end
+          logger.debug(
+            "Using Ractors may result in allocation profiling " \
+            "stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your " \
+            "application stability or performance. This issue is fixed on Ruby 4."
+          )
         end
 
         logger.debug("Enabled allocation profiling")
@@ -220,6 +215,12 @@ module Datadog
             "Please upgrade to Ruby >= 3.1 in order to use this feature. Heap profiling has been disabled."
           )
           return false
+        elsif RUBY_VERSION.start_with?("4.")
+          logger.warn(
+            "Datadog Ruby heap profiler is currently incompatible with Ruby 4. " \
+            "Heap profiling has been disabled."
+          )
+          return false
         end
 
         unless allocation_profiling_enabled

data/lib/datadog/profiling/http_transport.rb

@@ -13,7 +13,10 @@ module Datadog
       def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:)
         @upload_timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
 
-        @exporter_configuration =
+        # Steep: multiple issues here
+        # first https://github.com/soutaro/steep/issues/363
+        # then https://github.com/soutaro/steep/issues/1603 (remove the .freeze to see it)
+        @exporter_configuration = # steep:ignore IncompatibleAssignment
           if agentless?(site, api_key)
             [:agentless, site, api_key].freeze
           else

data/lib/datadog/tracing/contrib/extensions.rb

@@ -220,12 +220,20 @@ module Datadog
             # `@instrumented_integrations` hash.
             # @!visibility private
             def instrumented_integrations
-              INSTRUMENTED_INTEGRATIONS_LOCK.synchronize { (@instrumented_integrations&.dup || {}).freeze }
+              INSTRUMENTED_INTEGRATIONS_LOCK.synchronize do
+                (if defined?(@instrumented_integrations)
+                   @instrumented_integrations&.dup
+                 end || {}).freeze
+              end
             end
 
             # @!visibility private
             def reset!
-              INSTRUMENTED_INTEGRATIONS_LOCK.synchronize { @instrumented_integrations&.clear }
+              INSTRUMENTED_INTEGRATIONS_LOCK.synchronize do
+                if defined?(@instrumented_integrations)
+                  @instrumented_integrations&.clear
+                end
+              end
               super
             end
 

data/lib/datadog/tracing/contrib/karafka/patcher.rb

@@ -25,35 +25,34 @@ module Datadog
           # @see https://github.com/karafka/karafka/blob/b06d1f7c17818e1605f80c2bb573454a33376b40/README.md?plain=1#L29-L35
           def each(&block)
             @messages_array.each do |message|
-              if configuration[:distributed_tracing]
+              trace_digest = if configuration[:distributed_tracing]
                 headers = if message.metadata.respond_to?(:raw_headers)
                   message.metadata.raw_headers
                 else
                   message.metadata.headers
                 end
-                trace_digest = Karafka.extract(headers)
-                Datadog::Tracing.continue_trace!(trace_digest) if trace_digest
+                Karafka.extract(headers)
               end
 
-              if Datadog::DataStreams.enabled?
-                begin
-                  headers = if message.metadata.respond_to?(:raw_headers)
-                    message.metadata.raw_headers
-                  else
-                    message.metadata.headers
+              Tracing.trace(Ext::SPAN_MESSAGE_CONSUME, continue_from: trace_digest) do |span, trace|
+                if Datadog::DataStreams.enabled?
+                  begin
+                    headers = if message.metadata.respond_to?(:raw_headers)
+                      message.metadata.raw_headers
+                    else
+                      message.metadata.headers
+                    end
+
+                    Datadog::DataStreams.set_consume_checkpoint(
+                      type: 'kafka',
+                      source: message.topic,
+                      auto_instrumentation: true
+                    ) { |key| headers[key] }
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
                   end
-
-                  Datadog::DataStreams.set_consume_checkpoint(
-                    type: 'kafka',
-                    source: message.topic,
-                    auto_instrumentation: true
-                  ) { |key| headers[key] }
-                rescue => e
-                  Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
                 end
-              end
 
-              Tracing.trace(Ext::SPAN_MESSAGE_CONSUME) do |span|
                 span.set_tag(Ext::TAG_OFFSET, message.metadata.offset)
                 span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, message.topic)
                 span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_SYSTEM)
@@ -66,22 +65,12 @@ module Datadog
           end
         end
 
-        module AppPatch
-          ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Core::Utils::OnlyOnce.new }
-
-          def initialized!
-            ONLY_ONCE_PER_APP[self].run do
-              # Activate tracing on components related to Karafka (e.g. WaterDrop)
-              Contrib::Karafka::Framework.setup
-            end
-            super
-          end
-        end
-
         # Patcher enables patching of 'karafka' module.
         module Patcher
           include Contrib::Patcher
 
+          ACTIVATE_FRAMEWORK_ONLY_ONCE = Core::Utils::OnlyOnce.new
+
           module_function
 
           def target_version
@@ -91,10 +80,20 @@ module Datadog
           def patch
             require_relative 'monitor'
             require_relative 'framework'
+            require_relative '../waterdrop'
 
             ::Karafka::Instrumentation::Monitor.prepend(Monitor)
             ::Karafka::Messages::Messages.prepend(MessagesPatch)
-            ::Karafka::App.singleton_class.prepend(AppPatch)
+
+            if Contrib::WaterDrop::Integration.compatible?
+              ::Karafka.monitor.subscribe('app.initialized') do |event|
+                ACTIVATE_FRAMEWORK_ONLY_ONCE.run do
+                  Contrib::Karafka::Framework.setup
+                end
+
+                Contrib::WaterDrop::Patcher.add_middleware(::Karafka.producer)
+              end
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/status_range_matcher.rb

@@ -8,7 +8,8 @@ module Datadog
         attr_reader :ranges
 
         def initialize(ranges)
-          @ranges = Array(ranges)
+          # Steep: https://github.com/ruby/rbs/issues/1874
+          @ranges = Array(ranges) # steep:ignore IncompatibleAssignment
         end
 
         def +(other)

data/lib/datadog/tracing/contrib/utils/quantization/hash.rb

@@ -10,7 +10,9 @@ module Datadog
             PLACEHOLDER = '?'
             EXCLUDE_KEYS = [].freeze
             SHOW_KEYS = [].freeze
-            DEFAULT_OPTIONS = {
+
+            # Steep: https://github.com/soutaro/steep/issues/363
+            DEFAULT_OPTIONS = { # steep:ignore IncompatibleAssignment
               exclude: EXCLUDE_KEYS,
               show: SHOW_KEYS,
               placeholder: PLACEHOLDER

data/lib/datadog/tracing/contrib/waterdrop/patcher.rb

@@ -25,9 +25,7 @@ module Datadog
             ::WaterDrop::Producer.prepend(Producer)
             ::WaterDrop.instrumentation.subscribe('producer.configured') do |event|
               producer = event[:producer]
-
-              included_middlewares = producer.middleware.instance_variable_get(:@steps)
-              producer.middleware.append(Middleware) unless included_middlewares.include?(Middleware)
+              add_middleware(producer)
 
               if Datadog.configuration.data_streams.enabled
                 producer.monitor.subscribe('message.acknowledged') do |ack_event|
@@ -39,6 +37,11 @@ module Datadog
               end
             end
           end
+
+          def add_middleware(producer)
+            included_middlewares = producer.middleware.instance_variable_get(:@steps)
+            producer.middleware.append(Middleware) unless included_middlewares.include?(Middleware)
+          end
         end
       end
     end

data/lib/datadog/tracing/diagnostics/environment_logger.rb

@@ -62,7 +62,7 @@ module Datadog
             # return `nil` with IO transport
             return unless transport.respond_to?(:client)
 
-            adapter = transport.client.api.adapter
+            adapter = transport.client.instance.adapter
             adapter.url
           end
 

data/lib/datadog/tracing/remote.rb

@@ -7,8 +7,6 @@ module Datadog
   module Tracing
     # Remote configuration declaration
     module Remote
-      class ReadError < StandardError; end
-
       class << self
         PRODUCT = 'APM_TRACING'
 
@@ -71,13 +69,7 @@ module Datadog
         private
 
         def parse_content(content)
-          data = content.data.read
-
-          content.data.rewind
-
-          raise ReadError, 'EOF reached' if data.nil?
-
-          JSON.parse(data)
+          JSON.parse(content.data)
         end
       end
     end

data/lib/datadog/tracing/span_event.rb

@@ -69,8 +69,8 @@ module Datadog
 
       private
 
-      MIN_INT64_SIGNED = -2**63
-      MAX_INT64_SIGNED = 2 << 63 - 1
+      MIN_INT64_SIGNED = -2 << 62
+      MAX_INT64_SIGNED = (2 << 62) - 1
 
       # Checks the attributes hash to ensure it only contains serializable values.
       # Invalid values are removed from the hash.

data/lib/datadog/tracing/span_operation.rb

@@ -289,7 +289,8 @@ module Datadog
       def duration
         return @duration_end - @duration_start if @duration_start && @duration_end
 
-        @end_time - @start_time if @start_time && @end_time
+        # Steep: https://github.com/soutaro/steep/issues/477
+        @end_time - @start_time if @start_time && @end_time # steep:ignore NoMethod
       end
 
       def set_error(e)
@@ -387,7 +388,8 @@ module Datadog
       class Events
         include Tracing::Events
 
-        DEFAULT_ON_ERROR = proc { |span_op, error| span_op&.set_error(error) }
+        # Steep: https://github.com/soutaro/steep/issues/335
+        DEFAULT_ON_ERROR = proc { |span_op, error| span_op&.set_error(error) } # steep:ignore IncompatibleAssignment
 
         attr_reader \
           :logger,
@@ -395,7 +397,7 @@ module Datadog
           :after_stop,
           :before_start
 
-        def initialize(logger: Datadog.logger, on_error: nil)
+        def initialize(logger: Datadog.logger)
           @logger = logger
           @after_finish = AfterFinish.new
           @after_stop = AfterStop.new
@@ -548,7 +550,10 @@ module Datadog
       # Used for serialization
       # @return [Integer] in nanoseconds since Epoch
       def start_time_nano
-        @start_time.to_i * 1000000000 + @start_time.nsec
+        return 0 if @start_time.nil?
+
+        # Steep: https://github.com/soutaro/steep/issues/477
+        @start_time.to_i * 1000000000 + @start_time.nsec # steep:ignore NoMethod
       end
 
       # Used for serialization