ddtrace 1.4.2 → 1.19.0

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

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative '../../../configuration/agent_settings_resolver'
+require_relative '../../../transport/http/adapters/registry'
+require_relative '../../../transport/http/api/map'
+
+# 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 '../../../../ddtrace/transport/http/api/instance'
+require_relative 'api/instance'
+
+# TODO: Decouple transport/http/client
+#
+# The standard one does `include Transport::HTTP::Statistics` and performs
+# stats updates, which may or may not be desirable in general.
+#
+# Below should be:
+# require_relative '../../../../ddtrace/transport/http/client'
+require_relative 'client'
+
+# TODO: Decouple transport/http/builder
+#
+# This class is duplicated even though it is tantalisingly close to the
+# one in ddtrace/transport mostly because it refers to a different
+# `API::Instance` in `#api_instance_class` but also because it operates on a
+# different `HTTP::Client`, as well as de-hardcoding the transport class
+# `Transport::Traces::Transport` in `#to_transport`
+#
+# Additionally, its design makes it so there can be only one (API, Client,
+# Transport) triplet, requiring a new transport instance for any varying
+# element of the triplet.
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module HTTP
+          # Builds new instances of Transport::HTTP::Client
+          class Builder
+            REGISTRY = Datadog::Core::Transport::HTTP::Adapters::Registry.new
+
+            attr_reader \
+              :apis,
+              :api_options,
+              :default_adapter,
+              :default_api,
+              :default_headers
+
+            def initialize
+              # Global settings
+              @default_adapter = nil
+              @default_headers = {}
+
+              # Client settings
+              @apis = Datadog::Core::Transport::HTTP::API::Map.new
+              @default_api = nil
+
+              # API settings
+              @api_options = {}
+
+              yield(self) if block_given?
+            end
+
+            def adapter(config, *args, **kwargs)
+              @default_adapter = case config
+                                 when Core::Configuration::AgentSettingsResolver::AgentSettings
+                                   registry_klass = REGISTRY.get(config.adapter)
+                                   raise UnknownAdapterError, config.adapter if registry_klass.nil?
+
+                                   registry_klass.build(config)
+                                 when Symbol
+                                   registry_klass = REGISTRY.get(config)
+                                   raise UnknownAdapterError, config if registry_klass.nil?
+
+                                   registry_klass.new(*args, **kwargs)
+                                 else
+                                   config
+                                 end
+            end
+
+            def headers(values = {})
+              @default_headers.merge!(values)
+            end
+
+            # Adds a new API to the client
+            # Valid options:
+            #  - :adapter
+            #  - :default
+            #  - :fallback
+            #  - :headers
+            def api(key, spec, options = {})
+              options = options.dup
+
+              # Copy spec into API map
+              @apis[key] = spec
+
+              # Apply as default API, if specified to do so.
+              @default_api = key if options.delete(:default) || @default_api.nil?
+
+              # Save all other settings for initialization
+              (@api_options[key] ||= {}).merge!(options)
+            end
+
+            def default_api=(key)
+              raise UnknownApiError, key unless @apis.key?(key)
+
+              @default_api = key
+            end
+
+            def to_transport(klass)
+              raise NoDefaultApiError if @default_api.nil?
+
+              klass.new(to_api_instances, @default_api)
+            end
+
+            def to_api_instances
+              raise NoApisError if @apis.empty?
+
+              @apis.inject(Datadog::Core::Transport::HTTP::API::Map.new) do |instances, (key, spec)|
+                instances.tap do
+                  api_options = @api_options[key].dup
+
+                  # Resolve the adapter to use for this API
+                  adapter = api_options.delete(:adapter) || @default_adapter
+                  raise NoAdapterForApiError, key if adapter.nil?
+
+                  # Resolve fallback and merge headers
+                  fallback = api_options.delete(:fallback)
+                  api_options[:headers] = @default_headers.merge((api_options[:headers] || {}))
+
+                  # Add API::Instance with all settings
+                  instances[key] = api_instance_class.new(
+                    spec,
+                    adapter,
+                    api_options
+                  )
+
+                  # Configure fallback, if provided.
+                  instances.with_fallbacks(key => fallback) unless fallback.nil?
+                end
+              end
+            end
+
+            def api_instance_class
+              API::Instance
+            end
+
+            # Raised when the API key does not match known APIs.
+            class UnknownApiError < StandardError
+              attr_reader :key
+
+              def initialize(key)
+                super()
+
+                @key = key
+              end
+
+              def message
+                "Unknown transport API '#{key}'!"
+              end
+            end
+
+            # Raised when the identifier cannot be matched to an adapter.
+            class UnknownAdapterError < StandardError
+              attr_reader :type
+
+              def initialize(type)
+                super()
+
+                @type = type
+              end
+
+              def message
+                "Unknown transport adapter '#{type}'!"
+              end
+            end
+
+            # Raised when an adapter cannot be resolved for an API instance.
+            class NoAdapterForApiError < StandardError
+              attr_reader :key
+
+              def initialize(key)
+                super()
+
+                @key = key
+              end
+
+              def message
+                "No adapter resolved for transport API '#{key}'!"
+              end
+            end
+
+            # Raised when built without defining APIs.
+            class NoApisError < StandardError
+              def message
+                'No APIs configured for transport!'
+              end
+            end
+
+            # Raised when client built without defining a default API.
+            class NoDefaultApiError < StandardError
+              def message
+                'No default API configured for transport!'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/transport/http/env'
+require_relative '../../../../core/transport/http/response'
+
+# TODO: Decouple transport/http/client
+#
+# The standard one does `include Transport::HTTP::Statistics` and performs
+# stats updates, which may or may not be desirable in general.
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module HTTP
+          # Routes, encodes, and sends tracer data to the trace agent via HTTP.
+          class Client
+            attr_reader :api
+
+            def initialize(api)
+              @api = api
+            end
+
+            def send_request(request, &block)
+              # Build request into env
+              env = build_env(request)
+
+              # Get responses from API
+              yield(api, env)
+            rescue StandardError => e
+              message =
+                "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
+                  "Location: #{Array(e.backtrace).first}"
+
+              Datadog.logger.debug(message)
+
+              Datadog::Core::Transport::InternalErrorResponse.new(e)
+            end
+
+            def build_env(request)
+              Datadog::Core::Transport::HTTP::Env.new(request)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'base64'
+
+require_relative '../config'
+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 '../../../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
+      module Transport
+        module HTTP
+          # HTTP transport behavior for remote configuration
+          module Config
+            # Response from HTTP transport for remote configuration
+            class Response
+              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
+                super(http_response)
+
+                begin
+                  payload = JSON.parse(http_response.payload, symbolize_names: true)
+                rescue JSON::ParserError => e
+                  raise ParseError.new(:roots, e)
+                end
+
+                raise TypeError.new(Hash, payload) unless payload.is_a?(Hash)
+
+                @empty = true if payload.empty?
+
+                # TODO: these fallbacks should be improved
+                roots = payload[:roots] || []
+                targets = payload[:targets] || Base64.encode64('{}').chomp
+                target_files = payload[:target_files] || []
+                client_configs = payload[:client_configs] || []
+
+                raise TypeError.new(Array, roots) unless roots.is_a?(Array)
+
+                @roots = roots.map do |root|
+                  raise TypeError.new(String, root) unless root.is_a?(String)
+
+                  decoded = begin
+                    Base64.strict_decode64(root) # TODO: unprocessed, don't symbolize_names
+                  rescue ArgumentError
+                    raise DecodeError.new(:roots, root)
+                  end
+
+                  parsed = begin
+                    JSON.parse(decoded)
+                  rescue JSON::ParserError
+                    raise ParseError.new(:roots, decoded)
+                  end
+
+                  # TODO: perform more processing to validate content. til then, no freeze
+
+                  parsed
+                end
+
+                raise TypeError.new(String, targets) unless targets.is_a?(String)
+
+                @targets = begin
+                  decoded = begin
+                    Base64.strict_decode64(targets)
+                  rescue ArgumentError
+                    raise DecodeError.new(:targets, targets)
+                  end
+
+                  parsed = begin
+                    JSON.parse(decoded) # TODO: unprocessed, don't symbolize_names
+                  rescue JSON::ParserError
+                    raise ParseError.new(:targets, decoded)
+                  end
+
+                  # TODO: perform more processing to validate content. til then, no freeze
+
+                  parsed
+                end
+
+                raise TypeError.new(Array, target_files) unless target_files.is_a?(Array)
+
+                @target_files = target_files.map do |h|
+                  raise TypeError.new(Hash, h) unless h.is_a?(Hash)
+                  raise KeyError.new(:raw) unless h.key?(:raw) # rubocop:disable Style/RaiseArgs
+                  raise KeyError.new(:path) unless h.key?(:path) # rubocop:disable Style/RaiseArgs
+
+                  raw = h[:raw]
+
+                  raise TypeError.new(String, raw) unless raw.is_a?(String)
+
+                  content = begin
+                    Base64.strict_decode64(raw)
+                  rescue ArgumentError
+                    raise DecodeError.new(:target_files, raw)
+                  end
+
+                  {
+                    path: h[:path].freeze,
+                    content: StringIO.new(content.freeze),
+                  }
+                end.freeze
+
+                @client_configs = client_configs.map do |s|
+                  raise TypeError.new(String, s) unless s.is_a?(String)
+
+                  s.freeze
+                end.freeze
+              end
+
+              def inspect
+                "#{super}, #{
+                  {
+                    roots: @roots,
+                    targets: @targets,
+                    target_files: @target_files,
+                    client_configs: @client_configs,
+                  }}"
+              end
+
+              # When an expected key is missing
+              class KeyError < StandardError
+                def initialize(key)
+                  message = "key not found: #{key.inspect}"
+
+                  super(message)
+                end
+              end
+
+              # When an expected value type is incorrect
+              class TypeError < StandardError
+                def initialize(type, value)
+                  message = "not a #{type}: #{value.inspect}"
+
+                  super(message)
+                end
+              end
+
+              # When value decoding fails
+              class DecodeError < StandardError
+                def initialize(key, value)
+                  message = "could not decode key #{key.inspect}: #{value.inspect}"
+
+                  super(message)
+                end
+              end
+
+              # When value parsing fails
+              class ParseError < StandardError
+                def initialize(key, value)
+                  message = "could not parse key #{key.inspect}: #{value.inspect}"
+
+                  super(message)
+                end
+              end
+            end
+
+            # Extensions for HTTP client
+            module Client
+              def send_config_payload(request)
+                send_request(request) do |api, env|
+                  api.send_config(env)
+                end
+              end
+            end
+
+            module API
+              # Extensions for HTTP API Spec
+              module Spec
+                attr_reader :config
+
+                def config=(endpoint)
+                  @config = endpoint
+                end
+
+                def send_config(env, &block)
+                  raise NoConfigEndpointDefinedError, 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)
+
+                  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
+              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
+
+                  # Query for response
+                  http_response = super(env, &block)
+
+                  response_options = {}
+
+                  # Build and return a response
+                  Config::Response.new(http_response, response_options)
+                end
+              end
+            end
+
+            # 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
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative '../negotiation'
+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 '../../../../ddtrace/transport/http/api/instance'
+require_relative 'api/instance'
+# Below should be:
+# require_relative '../../../../ddtrace/transport/http/api/spec'
+require_relative 'api/spec'
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module HTTP
+          # HTTP transport behavior for agent feature negotiation
+          module Negotiation
+            # Response from HTTP transport for agent feature negotiation
+            class Response
+              include Datadog::Core::Transport::HTTP::Response
+              include Core::Remote::Transport::Negotiation::Response
+
+              def initialize(http_response, options = {})
+                super(http_response)
+
+                # TODO: transform endpoint hash in a better object for negotiation
+                # TODO: transform config in a better object, notably config has max_request_bytes
+                @version = options[:version]
+                @endpoints = options[:endpoints]
+                @config = options[:config]
+              end
+            end
+
+            # Extensions for HTTP client
+            module Client
+              def send_info_payload(request)
+                send_request(request) do |api, env|
+                  api.send_info(env)
+                end
+              end
+            end
+
+            module API
+              # Extensions for HTTP API Spec
+              module Spec
+                attr_reader :info
+
+                def info=(endpoint)
+                  @info = endpoint
+                end
+
+                def send_info(env, &block)
+                  raise NoNegotiationEndpointDefinedError, 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)
+
+                  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
+              class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
+                def initialize(path)
+                  super(:get, path)
+                end
+
+                def call(env, &block)
+                  # Query for response
+                  http_response = super(env, &block)
+
+                  # Process the response
+                  body = JSON.parse(http_response.payload, symbolize_names: true) if http_response.ok?
+
+                  # TODO: there should be more processing here to ensure a proper response_options
+                  response_options = body.is_a?(Hash) ? body : {}
+
+                  # Build and return a trace response
+                  Negotiation::Response.new(http_response, response_options)
+                end
+              end
+            end
+
+            # 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
+    end
+  end
+end