datadog 2.12.1 → 2.17.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: Datadog.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: Datadog.logger)
               @apis = apis
+              @logger = logger
 
-              @client = HTTP::Client.new(current_api)
+              @client = HTTP::Client.new(current_api, logger: 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: Datadog.logger)
               @api = api
+              @logger = logger
             end
 
             def send_request(request, &block)
@@ -27,12 +28,12 @@ module Datadog
 
               # Get responses from API
               yield(api, env)
-            rescue StandardError => e
+            rescue => e
               message =
                 "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

@@ -5,6 +5,7 @@ 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'
 
@@ -20,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
@@ -130,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}"
 
@@ -140,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}"
 
@@ -149,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}"
 
@@ -177,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
@@ -241,7 +231,7 @@ module Datadog
                   env.body = env.request.parcel.data
 
                   # Query for response
-                  http_response = super(env, &block)
+                  http_response = super
 
                   response_options = {}
 

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
@@ -105,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?

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: 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:,
-            **options
+            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
         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: 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/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