ddtrace 1.1.0 → 1.12.1

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module API
+          # Specification for an HTTP API
+          # Defines behaviors without specific configuration details.
+          class Spec
+            def initialize
+              yield(self) if block_given?
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../../encoding'
+
+require_relative '../../../../ddtrace/transport/http/api/map'
+
+# TODO: Decouple standard transport/http/api/instance
+#
+# Separate classes are needed because transport/http/traces 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/spec'
+require_relative 'api/spec'
+
+# TODO: only needed for Negotiation::API::Endpoint
+require_relative 'negotiation'
+
+# TODO: only needed for Config::API::Endpoint
+require_relative 'config'
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        # Namespace for API components
+        module API
+          # Default API versions
+          ROOT = 'root'
+          V7 = 'v0.7'
+
+          module_function
+
+          def defaults
+            Datadog::Transport::HTTP::API::Map[
+              ROOT => Spec.new do |s|
+                s.info = Negotiation::API::Endpoint.new(
+                  '/info',
+                )
+              end,
+              V7 => Spec.new do |s|
+                s.config = Config::API::Endpoint.new(
+                  '/v0.7/config',
+                  Core::Encoding::JSONEncoder,
+                )
+              end,
+            ]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/agent_settings_resolver'
+require_relative '../../../../ddtrace/transport/http/adapters/registry'
+require_relative '../../../../ddtrace/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 Transport
+      module HTTP
+        # Builds new instances of Transport::HTTP::Client
+        class Builder
+          REGISTRY = Datadog::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::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::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

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../../../../ddtrace/transport/http/env'
+
+# 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 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.error(message)
+
+            Datadog::Transport::InternalErrorResponse.new(e)
+          end
+
+          def build_env(request)
+            Datadog::Transport::HTTP::Env.new(request)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'base64'
+
+require_relative '../config'
+require_relative 'client'
+require_relative '../../../../ddtrace/transport/http/response'
+require_relative '../../../../ddtrace/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 Transport
+      module HTTP
+        # HTTP transport behavior for remote configuration
+        module Config
+          # Response from HTTP transport for remote configuration
+          class Response
+            include Datadog::Transport::HTTP::Response
+            include Core::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
+
+            # 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::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