datadog 2.0.0.beta1

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 '../../../../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
+      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

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

@@ -0,0 +1,147 @@
+# 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'
+
+# TODO: Improve negotiation to allow per endpoint selection
+#
+# Since endpoint negotiation happens at the `API::Spec` level there can not be
+# a mix of endpoints at various versions or versionless without describing all
+# the possible combinations as specs. See http/api.
+#
+# Below should be:
+# 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)
+# triplet and endpoints cannot be negotiated independently, there can not be a
+# single `default` transport, but only endpoint-specific ones.
+
+module Datadog
+  module Core
+    module Remote
+      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
+          )
+            new(Core::Remote::Transport::Negotiation::Transport) do |transport|
+              transport.adapter(agent_settings)
+              transport.headers(default_headers)
+
+              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
+
+          # 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
+          )
+            new(Core::Remote::Transport::Config::Transport) do |transport|
+              transport.adapter(agent_settings)
+              transport.headers default_headers
+
+              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?
+            end
+          end
+
+          def default_adapter
+            Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
+          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
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/transport/request'
+
+# TODO: Resolve conceptual conundrum
+#
+# It seems that through naming of `Transport::Traces::Transport` the transport
+# is specific to traces, which kind of matches the almost-generic-but-not-quite
+# implementation.
+#
+# This may be why `Transport::Traces::Transport` negotiates only considering
+# the `/vX/traces` path, but here we don't negotiate since we are at the root.
+#
+# In turn this means that API::Spec cannot describe multiple roots, or even
+# endpoints that happen to differ in version.
+#
+# Concepts such as Spec, API, Endpoint, and Transport should be clarified
+# before attempting further refactoring here, to attempt to resolve whether a
+# Transport - via its negotiated Spec - describes a function (implemented as
+# one or more endpoints) or whether the Spec describes the API towards the
+# agent as a whole, morphing through negotiation into the best available
+# version for each endpoint.
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module Negotiation
+          # Negotiation request
+          class Request < Datadog::Core::Transport::Request
+          end
+
+          # Negotiation response
+          module Response
+            attr_reader :version, :endpoints, :config
+          end
+
+          # Negotiation transport
+          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 send_info
+              request = Request.new
+
+              @client.send_info_payload(request)
+            end
+
+            def current_api
+              @apis[HTTP::API::ROOT]
+            end
+          end
+        end
+      end
+    end
+  end
+end