datadog 2.11.0 → 2.12.0

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative 'client'
+
+module Datadog
+  module DI
+    module Transport
+      module HTTP
+        module Diagnostics
+          module Client
+            def send_diagnostics_payload(request)
+              send_request(request) do |api, env|
+                api.send_diagnostics(env)
+              end
+            end
+          end
+
+          module API
+            module Instance
+              def send_diagnostics(env)
+                raise DiagnosticsNotSupportedError, spec unless spec.is_a?(Diagnostics::API::Spec)
+
+                spec.send_diagnostics(env) do |request_env|
+                  call(request_env)
+                end
+              end
+
+              class DiagnosticsNotSupportedError < StandardError
+                attr_reader :spec
+
+                def initialize(spec)
+                  super
+
+                  @spec = spec
+                end
+
+                def message
+                  'Diagnostics not supported for this API!'
+                end
+              end
+            end
+
+            module Spec
+              attr_accessor :diagnostics
+
+              def send_diagnostics(env, &block)
+                raise NoDiagnosticsEndpointDefinedError, self if diagnostics.nil?
+
+                diagnostics.call(env, &block)
+              end
+
+              class NoDiagnosticsEndpointDefinedError < StandardError
+                attr_reader :spec
+
+                def initialize(spec)
+                  super
+
+                  @spec = spec
+                end
+
+                def message
+                  'No diagnostics endpoint is defined for API specification!'
+                end
+              end
+            end
+
+            # Endpoint for negotiation
+            class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
+              attr_reader :encoder
+
+              def initialize(path, encoder)
+                super(:post, path)
+                @encoder = encoder
+              end
+
+              def call(env, &block)
+                event_payload = Core::Vendor::Multipart::Post::UploadIO.new(
+                  StringIO.new(env.request.parcel.data), 'application/json', 'event.json'
+                )
+                env.form = {'event' => event_payload}
+
+                super(env, &block)
+              end
+            end
+          end
+        end
+
+        HTTP::Client.include(Diagnostics::Client)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'client'
+
+module Datadog
+  module DI
+    module Transport
+      module HTTP
+        module Input
+          module Client
+            def send_input_payload(request)
+              send_request(request) do |api, env|
+                api.send_input(env)
+              end
+            end
+          end
+
+          module API
+            module Instance
+              def send_input(env)
+                raise InputNotSupportedError, spec unless spec.is_a?(Input::API::Spec)
+
+                spec.send_input(env) do |request_env|
+                  call(request_env)
+                end
+              end
+
+              class InputNotSupportedError < StandardError
+                attr_reader :spec
+
+                def initialize(spec)
+                  super
+
+                  @spec = spec
+                end
+
+                def message
+                  'Input not supported for this API!'
+                end
+              end
+            end
+
+            module Spec
+              attr_accessor :input
+
+              def send_input(env, &block)
+                raise NoInputEndpointDefinedError, self if input.nil?
+
+                input.call(env, &block)
+              end
+
+              class NoInputEndpointDefinedError < StandardError
+                attr_reader :spec
+
+                def initialize(spec)
+                  super
+
+                  @spec = spec
+                end
+
+                def message
+                  'No input endpoint is defined for API specification!'
+                end
+              end
+            end
+
+            # Endpoint for negotiation
+            class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
+              HEADER_CONTENT_TYPE = 'Content-Type'
+
+              attr_reader \
+                :encoder
+
+              def initialize(path, encoder)
+                super(:post, path)
+                @encoder = encoder
+              end
+
+              def call(env, &block)
+                # Encode body & type
+                env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
+                env.body = env.request.parcel.data
+
+                super(env, &block)
+              end
+            end
+          end
+        end
+
+        HTTP::Client.include(Input::Client)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+require_relative '../../core/environment/container'
+require_relative '../../core/environment/ext'
+require_relative '../../core/transport/ext'
+require_relative '../../core/transport/http/adapters/net'
+require_relative '../../core/transport/http/adapters/test'
+require_relative '../../core/transport/http/adapters/unix_socket'
+require_relative 'diagnostics'
+require_relative 'input'
+require_relative 'http/api'
+require_relative '../../core/transport/http/builder'
+require_relative '../../../datadog/version'
+
+module Datadog
+  module DI
+    module Transport
+      # Namespace for HTTP transport components
+      module HTTP
+        module_function
+
+        # Builds a new Transport::HTTP::Client
+        def new(klass, &block)
+          Core::Transport::HTTP::Builder.new(
+            api_instance_class: API::Instance, &block
+          ).to_transport(klass)
+        end
+
+        # Builds a new Transport::HTTP::Client with default settings
+        # Pass a block to override any settings.
+        def diagnostics(
+          agent_settings:,
+          **options
+        )
+          new(DI::Transport::Diagnostics::Transport) do |transport|
+            transport.adapter(agent_settings)
+            transport.headers default_headers
+
+            apis = API.defaults
+
+            transport.api API::DIAGNOSTICS, apis[API::DIAGNOSTICS]
+
+            # Apply any settings given by options
+            unless options.empty?
+              transport.default_api = options[:api_version] if options.key?(:api_version)
+              transport.headers options[:headers] if options.key?(:headers)
+            end
+
+            # Call block to apply any customization, if provided
+            yield(transport) if block_given?
+          end
+        end
+
+        # Builds a new Transport::HTTP::Client with default settings
+        # Pass a block to override any settings.
+        def input(
+          agent_settings:,
+          **options
+        )
+          new(DI::Transport::Input::Transport) do |transport|
+            transport.adapter(agent_settings)
+            transport.headers default_headers
+
+            apis = API.defaults
+
+            transport.api API::INPUT, apis[API::INPUT]
+
+            # Apply any settings given by options
+            unless options.empty?
+              transport.default_api = options[:api_version] if options.key?(:api_version)
+              transport.headers options[:headers] if options.key?(:headers)
+            end
+
+            # Call block to apply any customization, if provided
+            yield(transport) if block_given?
+          end
+        end
+
+        def default_headers
+          {
+            Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => '1',
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG => Datadog::Core::Environment::Ext::LANG,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_VERSION => Datadog::Core::Environment::Ext::LANG_VERSION,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER =>
+              Datadog::Core::Environment::Ext::LANG_INTERPRETER,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER_VENDOR => Core::Environment::Ext::LANG_ENGINE,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION =>
+              Datadog::Core::Environment::Ext::GEM_DATADOG_VERSION
+          }.tap do |headers|
+            # Add container ID, if present.
+            container_id = Datadog::Core::Environment::Container.container_id
+            headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+            # Pretend that stats computation are already done by the client
+            if Datadog.configuration.appsec.standalone.enabled
+              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_STATS] = 'yes'
+            end
+          end
+        end
+
+        def default_adapter
+          Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
+        end
+
+        # Add adapters to registry
+        Datadog::Core::Transport::HTTP::Builder::REGISTRY.set(
+          Datadog::Core::Transport::HTTP::Adapters::Net,
+          Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
+        )
+        Datadog::Core::Transport::HTTP::Builder::REGISTRY.set(Datadog::Core::Transport::HTTP::Adapters::Test, Datadog::Core::Transport::Ext::Test::ADAPTER)
+        Datadog::Core::Transport::HTTP::Builder::REGISTRY.set(
+          Datadog::Core::Transport::HTTP::Adapters::UnixSocket,
+          Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../../core/transport/parcel'
+require_relative 'http/client'
+
+module Datadog
+  module DI
+    module Transport
+      module Input
+        class EncodedParcel
+          include Datadog::Core::Transport::Parcel
+        end
+
+        class Request < Datadog::Core::Transport::Request
+        end
+
+        class Transport
+          attr_reader :client, :apis, :default_api, :current_api_id
+
+          def initialize(apis, default_api)
+            @apis = apis
+
+            @client = HTTP::Client.new(current_api)
+          end
+
+          def current_api
+            @apis[HTTP::API::INPUT]
+          end
+
+          def send_input(payload)
+            json = JSON.dump(payload)
+            parcel = EncodedParcel.new(json)
+            request = Request.new(parcel)
+
+            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}"
+            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
+    end
+  end
+end

data/lib/datadog/di.rb

@@ -16,7 +16,8 @@ require_relative 'di/probe_notifier_worker'
 require_relative 'di/redactor'
 require_relative 'di/remote'
 require_relative 'di/serializer'
-require_relative 'di/transport'
+#require_relative 'di/transport'
+require_relative 'di/transport/http'
 require_relative 'di/utils'
 
 module Datadog

data/lib/datadog/tracing/component.rb

@@ -49,6 +49,7 @@ module Datadog
         Tracing::Tracer.new(
           default_service: settings.service,
           enabled: settings.tracing.enabled,
+          logger: logger,
           trace_flush: trace_flush,
           sampler: sampler_delegator,
           span_sampler: build_span_sampler(settings),

data/lib/datadog/tracing/sync_writer.rb

@@ -17,6 +17,7 @@ module Datadog
     # @public_api
     class SyncWriter
       attr_reader \
+        :logger,
         :events,
         :transport
 
@@ -25,7 +26,9 @@ module Datadog
       # @param [Hash<Symbol,Object>] transport_options options for the default transport instance.
       # @param [Datadog::Tracing::Configuration::AgentSettingsResolver::AgentSettings] agent_settings agent options for
       #   the default transport instance.
-      def initialize(transport: nil, transport_options: {}, agent_settings: nil)
+      def initialize(transport: nil, transport_options: {}, agent_settings: nil, logger: Datadog.logger)
+        @logger = logger
+
         @transport = transport || begin
           transport_options[:agent_settings] = agent_settings if agent_settings
           Transport::HTTP.default(**transport_options)
@@ -40,7 +43,7 @@ module Datadog
       def write(trace)
         flush_trace(trace)
       rescue => e
-        Datadog.logger.debug(e)
+        logger.debug(e)
       end
 
       # Does nothing.

data/lib/datadog/tracing/tracer.rb

@@ -28,7 +28,8 @@ module Datadog
         :provider,
         :sampler,
         :span_sampler,
-        :tags
+        :tags,
+        :logger
 
       attr_accessor \
         :default_service,
@@ -52,17 +53,19 @@ module Datadog
         context_provider: DefaultContextProvider.new,
         default_service: Core::Environment::Ext::FALLBACK_SERVICE_NAME,
         enabled: true,
+        logger: Datadog.logger,
         sampler: Sampling::PrioritySampler.new(
           base_sampler: Sampling::AllSampler.new,
           post_sampler: Sampling::RuleSampler.new
         ),
         span_sampler: Sampling::Span::Sampler.new,
         tags: {},
-        writer: Writer.new
+        writer: Writer.new(logger: logger)
       )
         @trace_flush = trace_flush
         @default_service = default_service
         @enabled = enabled
+        @logger = logger
         @provider = context_provider
         @sampler = sampler
         @span_sampler = span_sampler
@@ -146,7 +149,7 @@ module Datadog
                     active_trace
                   end
         rescue StandardError => e
-          Datadog.logger.debug { "Failed to trace: #{e}" }
+          logger.debug { "Failed to trace: #{e}" }
 
           # Tracing failed: fallback and run code without tracing.
           return skip_trace(name, &block)
@@ -268,7 +271,7 @@ module Datadog
           @sampler.sample!(trace_op)
         rescue StandardError => e
           SAMPLE_TRACE_LOG_ONLY_ONCE.run do
-            Datadog.logger.warn { "Failed to sample trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+            logger.warn { "Failed to sample trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
           end
         end
       end
@@ -488,7 +491,7 @@ module Datadog
           @span_sampler.sample!(trace_op, span)
         rescue StandardError => e
           SAMPLE_SPAN_LOG_ONLY_ONCE.run do
-            Datadog.logger.warn { "Failed to sample span: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+            logger.warn { "Failed to sample span: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
           end
         end
       end
@@ -504,7 +507,7 @@ module Datadog
           write(trace) if trace && !trace.empty?
         rescue StandardError => e
           FLUSH_TRACE_LOG_ONLY_ONCE.run do
-            Datadog.logger.warn { "Failed to flush trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+            logger.warn { "Failed to flush trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
           end
         end
       end
@@ -518,7 +521,7 @@ module Datadog
         return unless trace && @writer
 
         if Datadog.configuration.diagnostics.debug
-          Datadog.logger.debug { "Writing #{trace.length} spans (enabled: #{@enabled})\n#{trace.spans.pretty_inspect}" }
+          logger.debug { "Writing #{trace.length} spans (enabled: #{@enabled})\n#{trace.spans.pretty_inspect}" }
         end
 
         @writer.write(trace)

data/lib/datadog/tracing/workers/trace_writer.rb

@@ -17,10 +17,13 @@ module Datadog
       # Writes traces to transport synchronously
       class TraceWriter < Core::Worker
         attr_reader \
+          :logger,
           :transport
 
         # rubocop:disable Lint/MissingSuper
         def initialize(options = {})
+          @logger = options[:logger] || Datadog.logger
+
           transport_options = options.fetch(:transport_options, {})
 
           transport_options[:agent_settings] = options[:agent_settings] if options.key?(:agent_settings)
@@ -43,7 +46,7 @@ module Datadog
           traces = process_traces(traces)
           flush_traces(traces)
         rescue StandardError => e
-          Datadog.logger.warn(
+          logger.warn(
             "Error while writing traces: dropped #{traces.length} items. Cause: #{e} Location: #{Array(e.backtrace).first}"
           )
         end

data/lib/datadog/tracing/workers.rb

@@ -18,8 +18,7 @@ module Datadog
         BACK_OFF_MAX = 5
         DEFAULT_SHUTDOWN_TIMEOUT = 1
 
-        attr_reader \
-          :trace_buffer
+        attr_reader :trace_buffer, :logger
 
         def initialize(options = {})
           @transport = options[:transport]
@@ -42,6 +41,8 @@ module Datadog
           @mutex = Mutex.new
           @worker = nil
           @run = false
+
+          @logger = options.fetch(:logger)
         end
 
         # Callback function that process traces and executes the +send_traces()+ method.
@@ -56,7 +57,7 @@ module Datadog
             # ensures that the thread will not die because of an exception.
             # TODO[manu]: findout the reason and reschedule the send if it's not
             # a fatal exception
-            Datadog.logger.warn(
+            logger.warn(
               "Error during traces flush: dropped #{traces.length} items. Cause: #{e} Location: #{Array(e.backtrace).first}"
             )
           end
@@ -68,7 +69,7 @@ module Datadog
             return if @run
 
             @run = true
-            Datadog.logger.debug { "Starting thread for: #{self}" }
+            logger.debug { "Starting thread for: #{self}" }
             @worker = Thread.new { perform }
             @worker.name = self.class.name
             @worker.thread_variable_set(:fork_safe, true)

data/lib/datadog/tracing/writer.rb

@@ -13,11 +13,14 @@ module Datadog
     # @public_api
     class Writer
       attr_reader \
+        :logger,
         :transport,
         :worker,
         :events
 
       def initialize(options = {})
+        @logger = options[:logger] || Datadog.logger
+
         # writer and transport parameters
         @buff_size = options.fetch(:buffer_size, Workers::AsyncTransport::DEFAULT_BUFFER_MAX_SIZE)
         @flush_interval = options.fetch(:flush_interval, Workers::AsyncTransport::DEFAULT_FLUSH_INTERVAL)
@@ -119,7 +122,7 @@ module Datadog
         if worker_local
           worker_local.enqueue_trace(trace)
         elsif !@stopped
-          Datadog.logger.debug('Writer either failed to start or was stopped before #write could complete')
+          logger.debug('Writer either failed to start or was stopped before #write could complete')
         end
       end
 
@@ -160,7 +163,8 @@ module Datadog
           buffer_size: @buff_size,
           on_trace: @trace_handler,
           interval: @flush_interval,
-          shutdown_timeout: @shutdown_timeout
+          shutdown_timeout: @shutdown_timeout,
+          logger: logger,
         )
 
         @worker.start

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 11
+    MINOR = 12
     PATCH = 0
     PRE = nil
     BUILD = nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.11.0
+  version: 2.12.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-24 00:00:00.000000000 Z
+date: 2025-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -210,6 +210,9 @@ files:
 - lib/datadog/appsec/contrib/rails/patcher.rb
 - lib/datadog/appsec/contrib/rails/request.rb
 - lib/datadog/appsec/contrib/rails/request_middleware.rb
+- lib/datadog/appsec/contrib/rest_client/integration.rb
+- lib/datadog/appsec/contrib/rest_client/patcher.rb
+- lib/datadog/appsec/contrib/rest_client/request_ssrf_detection_patch.rb
 - lib/datadog/appsec/contrib/sinatra/framework.rb
 - lib/datadog/appsec/contrib/sinatra/gateway/request.rb
 - lib/datadog/appsec/contrib/sinatra/gateway/route_params.rb
@@ -403,7 +406,13 @@ files:
 - lib/datadog/di/redactor.rb
 - lib/datadog/di/remote.rb
 - lib/datadog/di/serializer.rb
-- lib/datadog/di/transport.rb
+- lib/datadog/di/transport/diagnostics.rb
+- lib/datadog/di/transport/http.rb
+- lib/datadog/di/transport/http/api.rb
+- lib/datadog/di/transport/http/client.rb
+- lib/datadog/di/transport/http/diagnostics.rb
+- lib/datadog/di/transport/http/input.rb
+- lib/datadog/di/transport/input.rb
 - lib/datadog/di/utils.rb
 - lib/datadog/kit.rb
 - lib/datadog/kit/appsec/events.rb
@@ -920,8 +929,8 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.11.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.11.0
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.12.0/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.12.0
 post_install_message:
 rdoc_options: []
 require_paths: