datadog 2.23.0 → 2.25.0

data/lib/datadog/di/transport/http/diagnostics.rb

@@ -1,43 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/transport/http/api/instance'
-require_relative '../../../core/transport/http/api/spec'
-require_relative '../../../core/transport/http/client'
+require_relative '../../../core/transport/http/api/endpoint'
 
 module Datadog
   module DI
     module Transport
       module HTTP
         module Diagnostics
-          class Client < Core::Transport::HTTP::Client
-            def send_diagnostics_payload(request)
-              send_request(request) do |api, env|
-                api.send_diagnostics(env)
-              end
-            end
-          end
-
           module API
-            class Instance < Core::Transport::HTTP::API::Instance
-              def send_diagnostics(env)
-                raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new('diagnostics', self) unless spec.is_a?(Diagnostics::API::Spec)
-
-                spec.send_diagnostics(env) do |request_env|
-                  call(request_env)
-                end
-              end
-            end
-
-            class Spec < Core::Transport::HTTP::API::Spec
-              attr_accessor :diagnostics
-
-              def send_diagnostics(env, &block)
-                raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('diagnostics', self) if diagnostics.nil?
-
-                diagnostics.call(env, &block)
-              end
-            end
-
             class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
               attr_reader :encoder
 

data/lib/datadog/di/transport/http/input.rb

@@ -1,43 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/transport/http/api/instance'
-require_relative '../../../core/transport/http/api/spec'
-require_relative '../../../core/transport/http/client'
+require_relative '../../../core/transport/http/api/endpoint'
 
 module Datadog
   module DI
     module Transport
       module HTTP
         module Input
-          class Client < Core::Transport::HTTP::Client
-            def send_input_payload(request)
-              send_request(request) do |api, env|
-                api.send_input(env)
-              end
-            end
-          end
-
           module API
-            class Instance < Core::Transport::HTTP::API::Instance
-              def send_input(env)
-                raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new('input', self) unless spec.is_a?(Input::API::Spec)
-
-                spec.send_input(env) do |request_env|
-                  call(request_env)
-                end
-              end
-            end
-
-            class Spec < Core::Transport::HTTP::API::Spec
-              attr_accessor :input
-
-              def send_input(env, &block)
-                raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('input', self) if input.nil?
-
-                input.call(env, &block)
-              end
-            end
-
             class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
               HEADER_CONTENT_TYPE = 'Content-Type'
 

data/lib/datadog/di/transport/http.rb

@@ -1,31 +1,46 @@
 # frozen_string_literal: true
 
+require_relative '../../core/encoding'
+require_relative '../../core/transport/http'
 require_relative 'diagnostics'
 require_relative 'input'
-require_relative 'http/api'
-require_relative '../../core/transport/http'
 
 module Datadog
   module DI
     module Transport
       # Namespace for HTTP transport components
       module HTTP
-        module_function
+        DIAGNOSTICS = Diagnostics::API::Endpoint.new(
+          '/debugger/v1/diagnostics',
+          Core::Encoding::JSONEncoder,
+        )
+
+        INPUT = Input::API::Endpoint.new(
+          '/debugger/v2/input',
+          Core::Encoding::JSONEncoder,
+        )
+
+        LEGACY_INPUT = Input::API::Endpoint.new(
+          # We used to use /debugger/v1/input, but now input
+          # payloads should be going to the diagnostics endpoint
+          # which I gather performs data redaction.
+          '/debugger/v1/diagnostics',
+          Core::Encoding::JSONEncoder,
+        )
 
         # Builds a new Transport::HTTP::Client with default settings
         # Pass a block to override any settings.
-        def diagnostics(
+        def self.diagnostics(
           agent_settings:,
           logger:,
-          api_version: nil,
           headers: nil
         )
-          Core::Transport::HTTP.build(api_instance_class: Diagnostics::API::Instance,
+          Core::Transport::HTTP.build(
             logger: logger,
-            agent_settings: agent_settings, api_version: api_version, headers: headers) do |transport|
-            apis = API.defaults
-
-            transport.api API::DIAGNOSTICS, apis[API::DIAGNOSTICS]
+            agent_settings: agent_settings,
+            headers: headers,
+          ) do |transport|
+            transport.api 'diagnostics', DIAGNOSTICS
 
             # Call block to apply any customization, if provided
             yield(transport) if block_given?
@@ -34,22 +49,18 @@ module Datadog
 
         # Builds a new Transport::HTTP::Client with default settings
         # Pass a block to override any settings.
-        def input(
+        def self.input(
           agent_settings:,
           logger:,
-          api_version: nil,
           headers: nil
         )
           Core::Transport::HTTP.build(
-            api_instance_class: Input::API::Instance,
             logger: logger,
             agent_settings: agent_settings,
-            api_version: api_version,
             headers: headers,
           ) do |transport|
-            apis = API.defaults
-
-            transport.api API::INPUT, apis[API::INPUT]
+            transport.api 'input', INPUT, fallback: 'legacy_input', default: true
+            transport.api 'legacy_input', LEGACY_INPUT
 
             # Call block to apply any customization, if provided
             yield(transport) if block_given?

data/lib/datadog/di/transport/input.rb

@@ -5,6 +5,7 @@ require_relative '../../core/encoding'
 require_relative '../../core/tag_builder'
 require_relative '../../core/transport/parcel'
 require_relative '../../core/transport/request'
+require_relative '../../core/transport/transport'
 require_relative '../error'
 require_relative 'http/input'
 
@@ -26,9 +27,7 @@ module Datadog
           end
         end
 
-        class Transport
-          attr_reader :client, :apis, :default_api, :current_api_id, :logger
-
+        class Transport < Core::Transport::Transport
           # The limit on an individual snapshot payload, aka "log line",
           # is 1 MB.
           #
@@ -48,17 +47,6 @@ module Datadog
           # max chunk size, it will still get sent out.
           DEFAULT_CHUNK_SIZE = 2 * 1024 * 1024
 
-          def initialize(apis, default_api, logger:)
-            @apis = apis
-            @logger = logger
-
-            @client = DI::Transport::HTTP::Input::Client.new(current_api, logger: logger)
-          end
-
-          def current_api
-            @apis[HTTP::API::INPUT]
-          end
-
           def send_input(payload, tags)
             # Tags are the same for all chunks, serialize them one time.
             serialized_tags = Core::TagBuilder.serialize_tags(tags)
@@ -101,27 +89,12 @@ module Datadog
             parcel = EncodedParcel.new(chunked_payload)
             request = Request.new(parcel, serialized_tags)
 
-            response = @client.send_input_payload(request)
-            unless response.ok?
-              # TODO Datadog::Core::Transport::InternalErrorResponse
-              # does not have +code+ method, what is the actual API of
-              # these response objects?
-              raise Error::AgentCommunicationError, "send_input failed: #{begin
-                response.code
-              rescue
-                "???"
-              end}: #{response.payload}"
+            client.send_request(:input, request).tap do |response|
+              if downgrade?(response)
+                downgrade!
+                return send_input_chunk(chunked_payload, serialized_tags)
+              end
             end
-          rescue Error::AgentCommunicationError
-            raise
-          # Datadog::Core::Transport does not perform any exception mapping,
-          # therefore we could have any exception here from failure to parse
-          # agent URI for example.
-          # If we ever implement retries for network errors, we should distinguish
-          # actual network errors from non-network errors that are raised by
-          # transport code.
-          rescue => exc
-            raise Error::AgentCommunicationError, "send_input failed: #{exc.class}: #{exc}"
           end
         end
       end

data/lib/datadog/di.rb

@@ -9,16 +9,13 @@ module Datadog
   #
   # @api private
   module DI
+    INSTRUMENTED_COUNTERS_LOCK = Mutex.new
+
     class << self
       def enabled?
         Datadog.configuration.dynamic_instrumentation.enabled
       end
-    end
-
-    # Expose DI to global shared objects
-    Extensions.activate!
 
-    class << self
       # This method is called from DI Remote handler to issue DI operations
       # to the probe manager (add or remove probes).
       #
@@ -31,6 +28,65 @@ module Datadog
       def component
         Datadog.send(:components).dynamic_instrumentation
       end
+
+      # Track how many outstanding instrumentations are in DI.
+      #
+      # It is hard to find the actual instrumentations - there is no
+      # method provided by Ruby to list all trace points, and we would
+      # need to manually track our instrumentation modules for method probes.
+      # Plus, tracking the modules could create active references to
+      # instrumentation, which is not desired.
+      #
+      # A simpler solution is to maintain a counter which is increased
+      # whenever a probe is installed and decreased when a probe is removed.
+      #
+      # This counter does not include pending probes - being not installed,
+      # those pose no concerns to customer applications.
+      def instrumented_count(kind = nil)
+        INSTRUMENTED_COUNTERS_LOCK.synchronize do
+          if defined?(@instrumented_count)
+            if kind
+              validate_kind!(kind)
+              @instrumented_count[kind] || 0
+            else
+              @instrumented_count.inject(0) do |sum, (_kind, count)|
+                sum + count
+              end
+            end
+          else
+            0
+          end
+        end
+      end
+
+      def instrumented_count_inc(kind)
+        validate_kind!(kind)
+        INSTRUMENTED_COUNTERS_LOCK.synchronize do
+          @instrumented_count = Hash.new(0) unless defined?(@instrumented_count)
+          @instrumented_count[kind] += 1
+        end
+      end
+
+      def instrumented_count_dec(kind)
+        validate_kind!(kind)
+        INSTRUMENTED_COUNTERS_LOCK.synchronize do
+          @instrumented_count = Hash.new(0) unless defined?(@instrumented_count)
+          if @instrumented_count[kind] <= 0
+            Datadog.logger.debug { "di: attempting to decrease instrumented count below zero for #{kind}" }
+            return
+          end
+          @instrumented_count[kind] -= 1
+        end
+      end
+
+      private def validate_kind!(kind)
+        unless %i[line method].include?(kind)
+          raise ArgumentError, "Invalid kind: #{kind}"
+        end
+      end
     end
+
+    # Expose DI to global shared objects
+    Extensions.activate!
   end
 end

data/lib/datadog/error_tracking/filters.rb

@@ -18,10 +18,10 @@ module Datadog
         regex_match = regex.match(file_path)
         return unless regex_match
 
-        gem_name = regex_match[1]
+        gem_name = regex_match[1] #: String
 
         begin
-          Gem::Specification.find_by_name(gem_name) # steep:ignore
+          Gem::Specification.find_by_name(gem_name)
         rescue Gem::MissingSpecError
           nil
         end

data/lib/datadog/kit/appsec/events/v2.rb

@@ -66,8 +66,7 @@ module Datadog
               record_event_telemetry_metric(LOGIN_SUCCESS_EVENT)
               ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', LOGIN_SUCCESS_EVENT)
 
-              # NOTE: Guard-clause will not work with Steep typechecking
-              return Kit::Identity.set_user(trace, span, **user_attributes) if user_attributes.key?(:id) # steep:ignore
+              return Kit::Identity.set_user(trace, span, **user_attributes) if user_attributes.key?(:id)
 
               # NOTE: This is a fallback for the case when we don't have an ID,
               #       but need to trigger WAF.
@@ -156,7 +155,7 @@ module Datadog
                 raise ArgumentError, 'missing required user key `:id`' unless user_or_id.key?(:id)
                 raise TypeError, 'user key `:id` must be a String' unless user_or_id[:id].is_a?(String)
 
-                user_or_id.merge(login: login)
+                user_or_id.merge(login: login) #: {login: ::String, ?id: ::String?}
               else
                 raise TypeError, '`user_or_id` argument must be either String or Hash'
               end

data/lib/datadog/open_feature/evaluation_engine.rb

@@ -9,7 +9,8 @@ module Datadog
   module OpenFeature
     # This class performs the evaluation of the feature flag
     class EvaluationEngine
-      ReconfigurationError = Class.new(StandardError)
+      # Steep: https://github.com/soutaro/steep/issues/1880
+      ReconfigurationError = Class.new(StandardError) # steep:ignore IncompatibleAssignment
 
       ALLOWED_TYPES = %i[boolean string number float integer object].freeze
 

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 (remove after RBS 4.0 release)
+            {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,9 @@ 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),
@@ -96,7 +98,7 @@ module Datadog
         end
 
         def collect_profiler_info(settings)
-          unless @profiler_info
+          @profiler_info ||= begin
             lib_datadog_gem = ::Gem.loaded_specs["libdatadog"]
 
             libdatadog_version =
@@ -108,13 +110,12 @@ module Datadog
                 "#{Libdatadog::VERSION}-(unknown)"
               end
 
-            @profiler_info = {
+            {
               version: Datadog::Core::Environment::Identity.gem_datadog_version,
               libdatadog: libdatadog_version,
               settings: collect_settings_recursively(settings.profiling),
             }.freeze
           end
-          @profiler_info
         end
 
         # The settings/option model isn't directly serializable because