datadog 2.12.2 → 2.13.0

data/lib/datadog/core/remote/negotiation.rb

@@ -7,11 +7,11 @@ module Datadog
     module Remote
       # Endpoint negotiation
       class Negotiation
-        def initialize(_settings, agent_settings, suppress_logging: {})
-          transport_options = {}
-          transport_options[:agent_settings] = agent_settings if agent_settings
+        attr_reader :logger
 
-          @transport_root = Datadog::Core::Remote::Transport::HTTP.root(**transport_options) # steep:ignore
+        def initialize(_settings, agent_settings, logger:, suppress_logging: {})
+          @logger = logger
+          @transport_root = Datadog::Core::Remote::Transport::HTTP.root(agent_settings: agent_settings, logger: logger)
           @logged = suppress_logging
         end
 
@@ -20,7 +20,7 @@ module Datadog
 
           if res.internal_error? && network_error?(res.error)
             unless @logged[:agent_unreachable]
-              Datadog.logger.warn { "agent unreachable: cannot negotiate #{path}" }
+              logger.warn { "agent unreachable: cannot negotiate #{path}" }
               @logged[:agent_unreachable] = true
             end
 
@@ -29,7 +29,7 @@ module Datadog
 
           if res.not_found?
             unless @logged[:no_info_endpoint]
-              Datadog.logger.warn { "agent reachable but has no /info endpoint: cannot negotiate #{path}" }
+              logger.warn { "agent reachable but has no /info endpoint: cannot negotiate #{path}" }
               @logged[:no_info_endpoint] = true
             end
 
@@ -38,7 +38,7 @@ module Datadog
 
           unless res.ok?
             unless @logged[:unexpected_response]
-              Datadog.logger.warn { "agent reachable but unexpected response: cannot negotiate #{path}" }
+              logger.warn { "agent reachable but unexpected response: cannot negotiate #{path}" }
               @logged[:unexpected_response] = true
             end
 
@@ -47,14 +47,14 @@ module Datadog
 
           unless res.endpoints.include?(path)
             unless @logged[:no_config_endpoint]
-              Datadog.logger.warn { "agent reachable but does not report #{path}" }
+              logger.warn { "agent reachable but does not report #{path}" }
               @logged[:no_config_endpoint] = true
             end
 
             return false
           end
 
-          Datadog.logger.debug { "agent reachable and reports #{path}" }
+          logger.debug { "agent reachable and reports #{path}" }
 
           true
         end

data/lib/datadog/core/remote/transport/config.rb

@@ -32,12 +32,13 @@ module Datadog
 
           # Config transport
           class Transport
-            attr_reader :client, :apis, :default_api, :current_api_id
+            attr_reader :client, :apis, :default_api, :current_api_id, :logger
 
-            def initialize(apis, default_api)
+            def initialize(apis, default_api, logger)
               @apis = apis
+              @logger = logger
 
-              @client = HTTP::Client.new(current_api)
+              @client = HTTP::Client.new(current_api, logger)
             end
 
             ##### there is only one transport! it's negotiation!

data/lib/datadog/core/remote/transport/http/client.rb

@@ -15,10 +15,11 @@ module Datadog
         module HTTP
           # Routes, encodes, and sends tracer data to the trace agent via HTTP.
           class Client
-            attr_reader :api
+            attr_reader :api, :logger
 
-            def initialize(api)
+            def initialize(api, logger)
               @api = api
+              @logger = logger
             end
 
             def send_request(request, &block)
@@ -32,7 +33,7 @@ module Datadog
                 "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
                   "Location: #{Array(e.backtrace).first}"
 
-              Datadog.logger.debug(message)
+              logger.debug(message)
 
               Datadog::Core::Transport::InternalErrorResponse.new(e)
             end

data/lib/datadog/core/remote/transport/http/config.rb

@@ -177,51 +177,25 @@ module Datadog
                 end
 
                 def send_config(env, &block)
-                  raise NoConfigEndpointDefinedError, self if config.nil?
+                  raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('config', self) if config.nil?
 
                   config.call(env, &block)
                 end
-
-                # Raised when traces sent but no traces endpoint is defined
-                class NoConfigEndpointDefinedError < StandardError
-                  attr_reader :spec
-
-                  def initialize(spec)
-                    super()
-
-                    @spec = spec
-                  end
-
-                  def message
-                    'No config endpoint is defined for API specification!'
-                  end
-                end
               end
 
               # Extensions for HTTP API Instance
               module Instance
                 def send_config(env)
-                  raise ConfigNotSupportedError, spec unless spec.is_a?(Config::API::Spec)
+                  unless spec.is_a?(Config::API::Spec)
+                    raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new(
+                      'config', self
+                    )
+                  end
 
                   spec.send_config(env) do |request_env|
                     call(request_env)
                   end
                 end
-
-                # Raised when traces sent to API that does not support traces
-                class ConfigNotSupportedError < StandardError
-                  attr_reader :spec
-
-                  def initialize(spec)
-                    super()
-
-                    @spec = spec
-                  end
-
-                  def message
-                    'Config not supported for this API!'
-                  end
-                end
               end
 
               # Endpoint for remote configuration

data/lib/datadog/core/remote/transport/http/negotiation.rb

@@ -50,51 +50,25 @@ module Datadog
                 end
 
                 def send_info(env, &block)
-                  raise NoNegotiationEndpointDefinedError, self if info.nil?
+                  raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('info', self) if info.nil?
 
                   info.call(env, &block)
                 end
-
-                # Raised when traces sent but no traces endpoint is defined
-                class NoNegotiationEndpointDefinedError < StandardError
-                  attr_reader :spec
-
-                  def initialize(spec)
-                    super()
-
-                    @spec = spec
-                  end
-
-                  def message
-                    'No info endpoint is defined for API specification!'
-                  end
-                end
               end
 
               # Extensions for HTTP API Instance
               module Instance
                 def send_info(env)
-                  raise NegotiationNotSupportedError, spec unless spec.is_a?(Negotiation::API::Spec)
+                  unless spec.is_a?(Negotiation::API::Spec)
+                    raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new(
+                      'info', self
+                    )
+                  end
 
                   spec.send_info(env) do |request_env|
                     call(request_env)
                   end
                 end
-
-                # Raised when traces sent to API that does not support traces
-                class NegotiationNotSupportedError < StandardError
-                  attr_reader :spec
-
-                  def initialize(spec)
-                    super()
-
-                    @spec = spec
-                  end
-
-                  def message
-                    'Info not supported for this API!'
-                  end
-                end
               end
 
               # Endpoint for negotiation

data/lib/datadog/core/remote/transport/http.rb

@@ -29,87 +29,52 @@ module Datadog
         module HTTP
           module_function
 
-          # Builds a new Transport::HTTP::Client
-          def new(klass, &block)
-            Core::Transport::HTTP.build(
-              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 root(
             agent_settings:,
-            **options
+            logger:,
+            api_version: nil,
+            headers: nil
           )
-            new(Core::Remote::Transport::Negotiation::Transport) do |transport|
-              transport.adapter(agent_settings)
-              transport.headers(default_headers)
-
+            Core::Transport::HTTP.build(
+              api_instance_class: API::Instance,
+              agent_settings: agent_settings,
+              logger: logger,
+              api_version: api_version,
+              headers: headers
+            ) do |transport|
               apis = API.defaults
 
               transport.api API::ROOT, apis[API::ROOT]
 
-              # 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.to_transport(Core::Remote::Transport::Negotiation::Transport)
           end
 
           # Builds a new Transport::HTTP::Client with default settings
           # Pass a block to override any settings.
           def v7(
             agent_settings:,
-            **options
+            logger:,
+            api_version: nil,
+            headers: nil
           )
-            new(Core::Remote::Transport::Config::Transport) do |transport|
-              transport.adapter(agent_settings)
-              transport.headers default_headers
-
+            Core::Transport::HTTP.build(
+              api_instance_class: API::Instance,
+              agent_settings: agent_settings,
+              logger: logger,
+              api_version: api_version,
+              headers: headers
+            ) do |transport|
               apis = API.defaults
 
               transport.api API::V7, apis[API::V7]
 
-              # 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_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?
-              # Sending this header to the agent will disable metrics computation (and billing) on the agent side
-              # by pretending it has already been done on the library side.
-              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.to_transport(Core::Remote::Transport::Config::Transport)
           end
         end
       end

data/lib/datadog/core/remote/transport/negotiation.rb

@@ -49,12 +49,13 @@ module Datadog
 
           # Negotiation transport
           class Transport
-            attr_reader :client, :apis, :default_api, :current_api_id
+            attr_reader :client, :apis, :default_api, :current_api_id, :logger
 
-            def initialize(apis, default_api)
+            def initialize(apis, default_api, logger)
               @apis = apis
+              @logger = logger
 
-              @client = HTTP::Client.new(current_api)
+              @client = HTTP::Client.new(current_api, logger)
             end
 
             def send_info

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

@@ -21,6 +21,9 @@ module Datadog
           @services = Set.new(options.fetch(:services, []))
           @service_tags = nil
           compile_service_tags!
+
+          # Initialize the collection of runtime-id
+          @runtime_id_enabled = options.fetch(:experimental_runtime_id_enabled, false)
         end
 
         # Associate service with runtime metrics
@@ -105,6 +108,9 @@ module Datadog
 
             # Add services dynamically because they might change during runtime.
             options[:tags].concat(service_tags) unless service_tags.nil?
+
+            # Add runtime-id dynamically because it might change during runtime.
+            options[:tags].concat(["runtime-id:#{Core::Environment::Identity.id}"]) if @runtime_id_enabled
           end
         end
 
@@ -112,7 +118,8 @@ module Datadog
 
         attr_reader \
           :service_tags,
-          :services
+          :services,
+          :runtime_id_enabled
 
         def compile_service_tags!
           @service_tags = services.to_a.collect do |service|

data/lib/datadog/core/telemetry/http/adapters/net.rb

@@ -21,7 +21,7 @@ module Datadog
               @hostname = hostname
               @port = port
               @timeout = timeout
-              @ssl = ssl.nil? ? true : ssl
+              @ssl = ssl.nil? || ssl
             end
 
             def open(&block)

data/lib/datadog/core/transport/http/api/instance.rb

@@ -7,6 +7,23 @@ module Datadog
         module API
           # An API configured with adapter and routes
           class Instance
+            # Raised when an endpoint is invoked on an API that is not the
+            # of expected API class for that endpoint.
+            class EndpointNotSupportedError < StandardError
+              attr_reader :spec, :endpoint_name
+
+              def initialize(endpoint_name, spec)
+                @spec = spec
+                @endpoint_name = endpoint_name
+
+                super(message)
+              end
+
+              def message
+                "#{endpoint_name} not supported for this API!"
+              end
+            end
+
             attr_reader \
               :adapter,
               :headers,

data/lib/datadog/core/transport/http/api/spec.rb

@@ -8,6 +8,23 @@ module Datadog
           # Specification for an HTTP API
           # Defines behaviors without specific configuration details.
           class Spec
+            # Raised when an endpoint is invoked on an API that did not
+            # define that endpoint.
+            class EndpointNotDefinedError < StandardError
+              attr_reader :spec, :endpoint_name
+
+              def initialize(endpoint_name, spec)
+                @spec = spec
+                @endpoint_name = endpoint_name
+
+                super(message)
+              end
+
+              def message
+                "No #{endpoint_name} endpoint is defined for API specification!"
+              end
+            end
+
             def initialize
               yield(self) if block_given?
             end

data/lib/datadog/core/transport/http/builder.rb

@@ -18,9 +18,10 @@ module Datadog
             :api_options,
             :default_adapter,
             :default_api,
-            :default_headers
+            :default_headers,
+            :logger
 
-          def initialize(api_instance_class:)
+          def initialize(api_instance_class:, logger:)
             # Global settings
             @default_adapter = nil
             @default_headers = {}
@@ -33,6 +34,7 @@ module Datadog
             @api_options = {}
 
             @api_instance_class = api_instance_class
+            @logger = logger
 
             yield(self) if block_given?
           end
@@ -86,7 +88,7 @@ module Datadog
           def to_transport(klass)
             raise NoDefaultApiError if @default_api.nil?
 
-            klass.new(to_api_instances, @default_api)
+            klass.new(to_api_instances, @default_api, logger)
           end
 
           def to_api_instances

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

@@ -29,8 +29,45 @@ module Datadog
         # Helper function that delegates to Builder.new
         # but is under HTTP namespace so that client code requires this file
         # to get the adapters configured, and not the builder directly.
-        def build(api_instance_class:, &block)
-          Builder.new(api_instance_class: api_instance_class, &block)
+        def build(api_instance_class:, agent_settings:, logger:, api_version: nil, headers: nil, &block)
+          Builder.new(api_instance_class: api_instance_class, logger: logger) do |transport|
+            transport.adapter(agent_settings)
+            transport.headers(default_headers)
+
+            # The caller must define APIs before we set the default API.
+            yield transport
+
+            # Apply any settings given by options
+            transport.default_api = api_version if api_version
+            transport.headers(headers) if headers
+          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.
+            if (container_id = Datadog::Core::Environment::Container.container_id)
+              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id
+            end
+            # TODO: inject configuration rather than reading from global here
+            unless Datadog.configuration.apm.tracing.enabled
+              # Sending this header to the agent will disable metrics computation (and billing) on the agent side
+              # by pretending it has already been done on the library side.
+              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_STATS] = 'yes'
+            end
+          end
         end
       end
     end

data/lib/datadog/di/component.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../core'
-
 module Datadog
   module DI
     # Component for dynamic instrumentation.

data/lib/datadog/di/probe_notifier_worker.rb

@@ -171,7 +171,7 @@ module Datadog
       attr_reader :last_sent
 
       def status_transport
-        @status_transport ||= DI::Transport::HTTP.diagnostics(agent_settings: agent_settings)
+        @status_transport ||= DI::Transport::HTTP.diagnostics(agent_settings: agent_settings, logger: logger)
       end
 
       def do_send_status(batch)
@@ -179,7 +179,7 @@ module Datadog
       end
 
       def snapshot_transport
-        @snapshot_transport ||= DI::Transport::HTTP.input(agent_settings: agent_settings)
+        @snapshot_transport ||= DI::Transport::HTTP.input(agent_settings: agent_settings, logger: logger)
       end
 
       def do_send_snapshot(batch)
@@ -227,20 +227,6 @@ module Datadog
           start
         end
 
-        # Determine how much longer the worker thread should sleep
-        # so as not to send in less than min send interval since the last send.
-        # Important: this method must be called when @lock is held.
-        #
-        # Returns the time remaining to sleep.
-        def set_sleep_remaining
-          now = Core::Utils::Time.get_time
-          @sleep_remaining = if last_sent
-            [last_sent + min_send_interval - now, 0].max
-          else
-            0
-          end
-        end
-
         public "add_#{event_type}"
 
         # Sends pending probe statuses or snapshots.
@@ -288,6 +274,20 @@ module Datadog
         end
       end
 
+      # Determine how much longer the worker thread should sleep
+      # so as not to send in less than min send interval since the last send.
+      # Important: this method must be called when @lock is held.
+      #
+      # Returns the time remaining to sleep.
+      def set_sleep_remaining
+        now = Core::Utils::Time.get_time
+        @sleep_remaining = if last_sent
+          [last_sent + min_send_interval - now, 0].max
+        else
+          0
+        end
+      end
+
       def maybe_send
         rv = maybe_send_status
         maybe_send_snapshot || rv

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

@@ -15,12 +15,13 @@ module Datadog
         end
 
         class Transport
-          attr_reader :client, :apis, :default_api, :current_api_id
+          attr_reader :client, :apis, :default_api, :current_api_id, :logger
 
-          def initialize(apis, default_api)
+          def initialize(apis, default_api, logger)
             @apis = apis
+            @logger = logger
 
-            @client = HTTP::Client.new(current_api)
+            @client = HTTP::Client.new(current_api, logger)
           end
 
           def current_api

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

@@ -21,13 +21,13 @@ module Datadog
 
           def defaults
             Datadog::Core::Transport::HTTP::API::Map[
-              DIAGNOSTICS => Spec.new do |s|
+              DIAGNOSTICS => Diagnostics::API::Spec.new do |s|
                 s.diagnostics = Diagnostics::API::Endpoint.new(
                   '/debugger/v1/diagnostics',
                   Core::Encoding::JSONEncoder,
                 )
               end,
-              INPUT => Spec.new do |s|
+              INPUT => Input::API::Spec.new do |s|
                 s.input = Input::API::Endpoint.new(
                   '/debugger/v1/input',
                   Core::Encoding::JSONEncoder,
@@ -35,16 +35,6 @@ module Datadog
               end,
             ]
           end
-
-          class Instance < Core::Transport::HTTP::API::Instance
-            include Diagnostics::API::Instance
-            include Input::API::Instance
-          end
-
-          class Spec < Core::Transport::HTTP::API::Spec
-            include Diagnostics::API::Spec
-            include Input::API::Spec
-          end
         end
       end
     end

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

@@ -14,10 +14,11 @@ module Datadog
       module HTTP
         # Routes, encodes, and sends DI data to the trace agent via HTTP.
         class Client
-          attr_reader :api
+          attr_reader :api, :logger
 
-          def initialize(api)
+          def initialize(api, logger)
             @api = api
+            @logger = logger
           end
 
           def send_request(request, &block)
@@ -31,7 +32,7 @@ module Datadog
               "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
                 "Location: #{Array(e.backtrace).first}"
 
-            Datadog.logger.debug(message)
+            logger.debug(message)
 
             Datadog::Core::Transport::InternalErrorResponse.new(e)
           end