ddtrace 0.49.0 → 1.12.1

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

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative '../negotiation'
+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 agent feature negotiation
+        module Negotiation
+          # Response from HTTP transport for agent feature negotiation
+          class Response
+            include Datadog::Transport::HTTP::Response
+            include Core::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::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

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+require_relative '../environment/container'
+require_relative '../environment/ext'
+require_relative '../../../ddtrace/transport/ext'
+require_relative '../../../ddtrace/transport/http/adapters/net'
+require_relative '../../../ddtrace/transport/http/adapters/test'
+require_relative '../../../ddtrace/transport/http/adapters/unix_socket'
+
+# TODO: Improve negotiation to allow per endpoint selection
+#
+# Since endpoint negotiation happens at the `API::Spec` level there can not be
+# a mix of enpoints at various versions or versionless without describing all
+# the possible combinations as specs. See http/api.
+#
+# Below should be:
+# require_relative '../../../ddtrace/transport/http/api'
+require_relative 'http/api'
+
+# TODO: Decouple transport/http/builder
+#
+# See http/builder
+#
+# Below should be:
+# require_relative '../../../ddtrace/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 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(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
+
+            if agent_settings.deprecated_for_removal_transport_configuration_proc
+              agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
+            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(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
+
+            if agent_settings.deprecated_for_removal_transport_configuration_proc
+              agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
+            end
+
+            # Call block to apply any customization, if provided
+            yield(transport) if block_given?
+          end
+        end
+
+        def default_headers
+          {
+            Datadog::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => '1',
+            Datadog::Transport::Ext::HTTP::HEADER_META_LANG => Datadog::Core::Environment::Ext::LANG,
+            Datadog::Transport::Ext::HTTP::HEADER_META_LANG_VERSION => Datadog::Core::Environment::Ext::LANG_VERSION,
+            Datadog::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER =>
+              Datadog::Core::Environment::Ext::LANG_INTERPRETER,
+            Datadog::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION => Datadog::Core::Environment::Ext::TRACER_VERSION
+          }.tap do |headers|
+            # Add container ID, if present.
+            container_id = Datadog::Core::Environment::Container.container_id
+            headers[Datadog::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+          end
+        end
+
+        def default_adapter
+          Datadog::Transport::Ext::HTTP::ADAPTER
+        end
+
+        def default_hostname(logger: Datadog.logger)
+          logger.warn(
+            'Deprecated for removal: Using #default_hostname for configuration is deprecated and will ' \
+            'be removed on a future ddtrace release.'
+          )
+
+          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.hostname
+        end
+
+        def default_port(logger: Datadog.logger)
+          logger.warn(
+            'Deprecated for removal: Using #default_hostname for configuration is deprecated and will ' \
+            'be removed on a future ddtrace release.'
+          )
+
+          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.port
+        end
+
+        def default_url(logger: Datadog.logger)
+          logger.warn(
+            'Deprecated for removal: Using #default_url for configuration is deprecated and will ' \
+            'be removed on a future ddtrace release.'
+          )
+
+          nil
+        end
+
+        # Add adapters to registry
+        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Net, Datadog::Transport::Ext::HTTP::ADAPTER)
+        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Test, Datadog::Transport::Ext::Test::ADAPTER)
+        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::UnixSocket, Datadog::Transport::Ext::UnixSocket::ADAPTER)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../../ddtrace/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 Transport
+      module Negotiation
+        # Negotiation request
+        class Request < Datadog::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

data/lib/datadog/core/utils/compression.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require 'zlib'
+
+module Datadog
+  module Core
+    module Utils
+      # Compression/decompression utility functions.
+      #
+      # @deprecated This is no longer used by ddtrace and will be removed in 2.0.
+      module Compression
+        module_function
+
+        # @deprecated This is no longer used by ddtrace and will be removed in 2.0.
+        def gzip(string, level: nil, strategy: nil)
+          sio = StringIO.new
+          sio.binmode
+          gz = Zlib::GzipWriter.new(sio, level, strategy)
+          gz.write(string)
+          gz.close
+          sio.string
+        end
+
+        # @deprecated This is no longer used by ddtrace and will be removed in 2.0.
+        def gunzip(string, encoding = ::Encoding::ASCII_8BIT)
+          sio = StringIO.new(string)
+          gz = Zlib::GzipReader.new(sio, encoding: encoding)
+          gz.read
+        ensure
+          gz && gz.close
+        end
+      end
+    end
+  end
+end