datadog 2.7.1 → 2.17.0

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

@@ -5,25 +5,10 @@ require 'json'
 require_relative '../config'
 require_relative 'client'
 require_relative '../../../utils/base64'
+require_relative '../../../utils/truncation'
 require_relative '../../../transport/http/response'
 require_relative '../../../transport/http/api/endpoint'
 
-# TODO: Decouple standard transport/http/api/instance
-#
-# Separate classes are needed because transport/http/trace includes
-# Trace::API::Instance which closes over and uses a single spec, which is
-# negotiated as either /v3 or /v4 for the whole API at the spec level, but we
-# need an independent toplevel path at the endpoint level.
-#
-# Separate classes are needed because of `include Trace::API::Instance`.
-#
-# Below should be:
-# require_relative '../../../core/transport/http/api/instance'
-require_relative 'api/instance'
-# Below should be:
-# require_relative '../../../core/transport/http/api/spec'
-require_relative 'api/spec'
-
 module Datadog
   module Core
     module Remote
@@ -36,9 +21,11 @@ module Datadog
               include Datadog::Core::Transport::HTTP::Response
               include Core::Remote::Transport::Config::Response
 
-              def initialize(http_response, options = {}) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+              def initialize(http_response, options = {}) # standard:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
                 super(http_response)
 
+                raise AgentErrorResponse.new(http_response.code, http_response.payload) if http_response.code != 200
+
                 begin
                   payload = JSON.parse(http_response.payload, symbolize_names: true)
                 rescue JSON::ParserError => e
@@ -146,8 +133,21 @@ module Datadog
                 end
               end
 
+              # Base class for Remote Configuration Config errors
+              class ConfigError < StandardError
+              end
+
+              # When the agent returned an error response to our request
+              class AgentErrorResponse < ConfigError
+                def initialize(code, body)
+                  truncated_body = Core::Utils::Truncation.truncate_in_middle(body, 700, 300)
+                  message = "Agent returned an error response: #{code}: #{truncated_body}"
+                  super(message)
+                end
+              end
+
               # When an expected value type is incorrect
-              class TypeError < StandardError
+              class TypeError < ConfigError
                 def initialize(type, value)
                   message = "not a #{type}: #{value.inspect}"
 
@@ -156,7 +156,7 @@ module Datadog
               end
 
               # When value decoding fails
-              class DecodeError < StandardError
+              class DecodeError < ConfigError
                 def initialize(key, value)
                   message = "could not decode key #{key.inspect}: #{value.inspect}"
 
@@ -165,7 +165,7 @@ module Datadog
               end
 
               # When value parsing fails
-              class ParseError < StandardError
+              class ParseError < ConfigError
                 def initialize(key, value)
                   message = "could not parse key #{key.inspect}: #{value.inspect}"
 
@@ -193,51 +193,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
@@ -257,7 +231,7 @@ module Datadog
                   env.body = env.request.parcel.data
 
                   # Query for response
-                  http_response = super(env, &block)
+                  http_response = super
 
                   response_options = {}
 
@@ -270,8 +244,6 @@ module Datadog
             # Add remote configuration behavior to transport components
             ###### overrides send_payload! which calls send_<endpoint>! kills any other possible endpoint!
             HTTP::Client.include(Config::Client)
-            HTTP::API::Spec.include(Config::API::Spec)
-            HTTP::API::Instance.include(Config::API::Instance)
           end
         end
       end

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

@@ -7,22 +7,6 @@ require_relative 'client'
 require_relative '../../../transport/http/response'
 require_relative '../../../transport/http/api/endpoint'
 
-# TODO: Decouple standard transport/http/api/instance
-#
-# Separate classes are needed because transport/http/trace includes
-# Trace::API::Instance which closes over and uses a single spec, which is
-# negotiated as either /v3 or /v4 for the whole API at the spec level, but we
-# need an independent toplevel path at the endpoint level.
-#
-# Separate classes are needed because of `include Trace::API::Instance`.
-#
-# Below should be:
-# require_relative '../../../../datadog/core/transport/http/api/instance'
-require_relative 'api/instance'
-# Below should be:
-# require_relative '../../../../datadog/core/transport/http/api/spec'
-require_relative 'api/spec'
-
 module Datadog
   module Core
     module Remote
@@ -43,6 +27,7 @@ module Datadog
                 @version = options[:version]
                 @endpoints = options[:endpoints]
                 @config = options[:config]
+                @span_events = options[:span_events]
               end
             end
 
@@ -65,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
@@ -120,7 +79,7 @@ module Datadog
 
                 def call(env, &block)
                   # Query for response
-                  http_response = super(env, &block)
+                  http_response = super
 
                   # Process the response
                   body = JSON.parse(http_response.payload, symbolize_names: true) if http_response.ok?
@@ -136,8 +95,6 @@ module Datadog
 
             # Add negotiation behavior to transport components
             HTTP::Client.include(Negotiation::Client)
-            HTTP::API::Spec.include(Negotiation::API::Spec)
-            HTTP::API::Instance.include(Negotiation::API::Instance)
           end
         end
       end

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

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
-require 'uri'
-
 require_relative '../../environment/container'
 require_relative '../../environment/ext'
 require_relative '../../transport/ext'
-require_relative '../../transport/http/adapters/net'
-require_relative '../../transport/http/adapters/unix_socket'
-require_relative '../../transport/http/adapters/test'
+require_relative '../../transport/http'
 
 # TODO: Improve negotiation to allow per endpoint selection
 #
@@ -19,14 +15,6 @@ require_relative '../../transport/http/adapters/test'
 # require_relative '../../transport/http/api'
 require_relative 'http/api'
 
-# TODO: Decouple transport/http/builder
-#
-# See http/builder
-#
-# Below should be:
-# require_relative '../../transport/http/builder'
-require_relative 'http/builder'
-
 # TODO: Decouple transport/http
 #
 # Because a new transport is required for every (API, Client, Transport)
@@ -39,112 +27,55 @@ module Datadog
       module Transport
         # Namespace for HTTP transport components
         module HTTP
-          # NOTE: Due to... legacy reasons... This class likes having a default `AgentSettings` instance to fall back to.
-          # Because we generate this instance with an empty instance of `Settings`, the resulting `AgentSettings` below
-          # represents only settings specified via environment variables + the usual defaults.
-          #
-          # DO NOT USE THIS IN NEW CODE, as it ignores any settings specified by users via `Datadog.configure`.
-          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS = Datadog::Core::Configuration::AgentSettingsResolver.call(
-            Datadog::Core::Configuration::Settings.new,
-            logger: nil,
-          )
-
           module_function
 
-          # Builds a new Transport::HTTP::Client
-          def new(klass, &block)
-            Builder.new(&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: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
-            **options
+            agent_settings:,
+            logger: Datadog.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: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
-            **options
+            agent_settings:,
+            logger: Datadog.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
-
-          # Add adapters to registry
-          Builder::REGISTRY.set(
-            Datadog::Core::Transport::HTTP::Adapters::Net,
-            Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-          )
-          Builder::REGISTRY.set(
-            Datadog::Core::Transport::HTTP::Adapters::Test,
-            Datadog::Core::Transport::Ext::Test::ADAPTER
-          )
-          Builder::REGISTRY.set(
-            Datadog::Core::Transport::HTTP::Adapters::UnixSocket,
-            Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER
-          )
         end
       end
     end

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

@@ -32,17 +32,30 @@ module Datadog
 
           # Negotiation response
           module Response
-            attr_reader :version, :endpoints, :config
+            # @!attribute [r] version
+            #   The version of the agent.
+            #   @return [String]
+            # @!attribute [r] endpoints
+            #   The HTTP endpoints the agent supports.
+            #   @return [Array<String>]
+            # @!attribute [r] config
+            #   The agent configuration. These are configured by the user when starting the agent, as well as any defaults.
+            #   @return [Hash]
+            # @!attribute [r] span_events
+            #   Whether the agent supports the top-level span events field in flushed spans.
+            #   @return [Boolean,nil]
+            attr_reader :version, :endpoints, :config, :span_events
           end
 
           # 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: Datadog.logger)
               @apis = apis
+              @logger = logger
 
-              @client = HTTP::Client.new(current_api)
+              @client = HTTP::Client.new(current_api, logger: logger)
             end
 
             def send_info

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

@@ -5,7 +5,7 @@ module Datadog
     module Remote
       # Worker executes a block every interval on a separate Thread
       class Worker
-        def initialize(interval:, &block)
+        def initialize(interval:, logger:, &block)
           @mutex = Mutex.new
           @thr = nil
 
@@ -14,18 +14,21 @@ module Datadog
           @stopped = false
 
           @interval = interval
+          @logger = logger
           raise ArgumentError, 'can not initialize a worker without a block' unless block
 
           @block = block
         end
 
+        attr_reader :logger
+
         def start
-          Datadog.logger.debug { 'remote worker starting' }
+          logger.debug { 'remote worker starting' }
 
           acquire_lock
 
           if @stopped
-            Datadog.logger.debug('remote worker: refusing to restart after previous stop')
+            logger.debug('remote worker: refusing to restart after previous stop')
             return
           end
 
@@ -41,13 +44,13 @@ module Datadog
           @started = true
           @starting = false
 
-          Datadog.logger.debug { 'remote worker started' }
+          logger.debug { 'remote worker started' }
         ensure
           release_lock
         end
 
         def stop
-          Datadog.logger.debug { 'remote worker stopping' }
+          logger.debug { 'remote worker stopping' }
 
           acquire_lock
 
@@ -62,7 +65,7 @@ module Datadog
           @thr = nil
           @stopped = true
 
-          Datadog.logger.debug { 'remote worker stopped' }
+          logger.debug { 'remote worker stopped' }
         ensure
           release_lock
         end
@@ -92,7 +95,7 @@ module Datadog
         end
 
         def call
-          Datadog.logger.debug { 'remote worker perform' }
+          logger.debug { 'remote worker perform' }
 
           @block.call
         end

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

@@ -14,13 +14,16 @@ module Datadog
     module Runtime
       # For generating runtime metrics
       class Metrics < Core::Metrics::Client
-        def initialize(**options)
+        def initialize(telemetry:, **options)
           super
 
           # Initialize service list
           @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
@@ -93,7 +96,7 @@ module Datadog
 
         def try_flush
           yield
-        rescue StandardError => e
+        rescue => e
           Datadog.logger.warn("Error while sending runtime metric. Cause: #{e.class.name} #{e.message}")
         end
 
@@ -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|
@@ -140,7 +147,7 @@ module Datadog
           gauge(metric_name, metric_value) if metric_value
         end
 
-        # rubocop:disable Metrics/MethodLength
+        # standard:disable Metrics/MethodLength
         def flush_yjit_stats
           # Only on Ruby >= 3.2
           try_flush do
@@ -188,7 +195,7 @@ module Datadog
             end
           end
         end
-        # rubocop:enable Metrics/MethodLength
+        # standard:enable Metrics/MethodLength
       end
     end
   end