datadog 2.7.1 → 2.17.0

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

@@ -1,219 +0,0 @@
-# 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 '../../../../datadog/core/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 '../../../../datadog/core/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 datadog/core/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/telemetry/http/env.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Core
-    module Telemetry
-      module Http
-        # Data structure for an HTTP request
-        class Env
-          attr_accessor :path, :body
-
-          attr_writer :headers
-
-          def headers
-            @headers ||= {}
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/telemetry/http/ext.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Core
-    module Telemetry
-      module Http
-        module Ext
-          HEADER_DD_API_KEY = 'DD-API-KEY'
-          HEADER_CONTENT_TYPE = 'Content-Type'
-          HEADER_CONTENT_LENGTH = 'Content-Length'
-          HEADER_DD_TELEMETRY_API_VERSION = 'DD-Telemetry-API-Version'
-          HEADER_DD_TELEMETRY_REQUEST_TYPE = 'DD-Telemetry-Request-Type'
-          HEADER_TELEMETRY_DEBUG_ENABLED = 'DD-Telemetry-Debug-Enabled'
-          HEADER_CLIENT_LIBRARY_LANGUAGE = 'DD-Client-Library-Language'
-          HEADER_CLIENT_LIBRARY_VERSION = 'DD-Client-Library-Version'
-
-          CONTENT_TYPE_APPLICATION_JSON = 'application/json'
-          API_VERSION = 'v2'
-
-          AGENTLESS_HOST_PREFIX = 'instrumentation-telemetry-intake'
-
-          AGENT_ENDPOINT = '/telemetry/proxy/api/v2/apmtelemetry'
-          AGENTLESS_ENDPOINT = '/api/v2/apmtelemetry'
-        end
-      end
-    end
-  end
-end

data/lib/datadog/core/telemetry/http/response.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Core
-    module Telemetry
-      module Http
-        # Module for base HTTP response
-        module Response
-          def payload
-            nil
-          end
-
-          def ok?
-            nil
-          end
-
-          def unsupported?
-            nil
-          end
-
-          def not_found?
-            nil
-          end
-
-          def client_error?
-            nil
-          end
-
-          def server_error?
-            nil
-          end
-
-          def internal_error?
-            nil
-          end
-
-          def code
-            nil
-          end
-
-          def inspect
-            "#{self.class} ok?:#{ok?} unsupported?:#{unsupported?}, " \
-            "not_found?:#{not_found?}, client_error?:#{client_error?}, " \
-            "server_error?:#{server_error?}, internal_error?:#{internal_error?}, " \
-            "payload:#{payload}"
-          end
-        end
-
-        # A generic error response for internal errors
-        class InternalErrorResponse
-          include Response
-
-          attr_reader :error
-
-          def initialize(error)
-            @error = error
-          end
-
-          def internal_error?
-            true
-          end
-
-          def inspect
-            "#{super}, error_type:#{error.class} error:#{error}"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../configuration/settings'
-require_relative '../../environment/ext'
-require_relative '../../transport/ext'
-require_relative 'env'
-require_relative 'ext'
-require_relative 'adapters/net'
-
-module Datadog
-  module Core
-    module Telemetry
-      module Http
-        # Class to send telemetry data to Telemetry API
-        # Currently only supports the HTTP protocol.
-        class Transport
-          def self.build_agent_transport(agent_settings)
-            Transport.new(
-              host: agent_settings.hostname,
-              port: agent_settings.port,
-              path: Http::Ext::AGENT_ENDPOINT
-            )
-          end
-
-          def self.build_agentless_transport(api_key:, dd_site:, url_override: nil)
-            url = url_override || "https://#{Http::Ext::AGENTLESS_HOST_PREFIX}.#{dd_site}:443"
-
-            uri = URI.parse(url)
-            raise "Invalid agentless mode URL: #{url}" if uri.host.nil?
-
-            Transport.new(
-              host: uri.host,
-              port: uri.port || 80,
-              path: Http::Ext::AGENTLESS_ENDPOINT,
-              ssl: uri.scheme == 'https' || uri.port == 443,
-              api_key: api_key
-            )
-          end
-
-          attr_reader \
-            :host,
-            :port,
-            :ssl,
-            :path,
-            :api_key
-
-          def initialize(host:, port:, path:, ssl: false, api_key: nil)
-            @host = host
-            @port = port
-            @ssl = ssl
-            @path = path
-            @api_key = api_key
-          end
-
-          def request(request_type:, payload:)
-            env = Http::Env.new
-            env.path = @path
-            env.body = payload
-            env.headers = headers(request_type: request_type)
-            adapter.post(env)
-          end
-
-          private
-
-          def headers(request_type:, api_version: Http::Ext::API_VERSION)
-            result = {
-              Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => '1',
-              Ext::HEADER_CONTENT_TYPE => Http::Ext::CONTENT_TYPE_APPLICATION_JSON,
-              Ext::HEADER_DD_TELEMETRY_API_VERSION => api_version,
-              Ext::HEADER_DD_TELEMETRY_REQUEST_TYPE => request_type,
-              Ext::HEADER_CLIENT_LIBRARY_LANGUAGE => Core::Environment::Ext::LANG,
-              Ext::HEADER_CLIENT_LIBRARY_VERSION => Core::Environment::Identity.gem_datadog_version_semver2,
-
-              # Enable debug mode for telemetry
-              # HEADER_TELEMETRY_DEBUG_ENABLED => 'true',
-            }
-
-            result[Ext::HEADER_DD_API_KEY] = api_key unless api_key.nil?
-
-            result
-          end
-
-          def adapter
-            @adapter ||= Http::Adapters::Net.new(hostname: @host, port: @port, ssl: @ssl)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/datadog/di/transport.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'ostruct'
-require_relative 'error'
-
-module Datadog
-  module DI
-    # Transport for sending probe statuses and snapshots to local agent.
-    #
-    # Handles encoding of the payloads into multipart posts if necessary,
-    # body formatting/encoding, setting correct headers, etc.
-    #
-    # The transport does not handle batching of statuses or snapshots -
-    # the batching should be implemented upstream of this class.
-    #
-    # Timeout settings are forwarded from agent settings to the Net adapter.
-    #
-    # The send_* methods raise Error::AgentCommunicationError on errors
-    # (network errors and HTTP protocol errors). It is the responsibility
-    # of upstream code to rescue these exceptions appropriately to prevent them
-    # from being propagated to the application.
-    #
-    # @api private
-    class Transport
-      DIAGNOSTICS_PATH = '/debugger/v1/diagnostics'
-      INPUT_PATH = '/debugger/v1/input'
-
-      def initialize(agent_settings)
-        # Note that this uses host, port, timeout and TLS flag from
-        # agent settings.
-        @client = Core::Transport::HTTP::Adapters::Net.new(agent_settings)
-      end
-
-      def send_diagnostics(payload)
-        event_payload = Core::Vendor::Multipart::Post::UploadIO.new(
-          StringIO.new(JSON.dump(payload)), 'application/json', 'event.json'
-        )
-        payload = {'event' => event_payload}
-        # Core transport unconditionally specifies headers to underlying
-        # Net::HTTP client, ends up passing 'nil' as headers if none are
-        # specified by us, which then causes Net::HTTP to die with an exception.
-        send_request('Probe status submission',
-          path: DIAGNOSTICS_PATH, form: payload, headers: {})
-      end
-
-      def send_input(payload)
-        send_request('Probe snapshot submission',
-          path: INPUT_PATH, body: payload.to_s,
-          headers: {'content-type' => 'application/json'},)
-      end
-
-      # TODO status should use either input or diagnostics endpoints
-      # depending on agent version.
-      alias_method :send_status, :send_diagnostics
-
-      alias_method :send_snapshot, :send_input
-
-      private
-
-      attr_reader :client
-
-      def send_request(desc, **options)
-        # steep:ignore:start
-        env = OpenStruct.new(**options)
-        # steep:ignore:end
-        response = client.post(env)
-        unless response.ok?
-          raise Error::AgentCommunicationError, "#{desc} failed: #{response.code}: #{response.payload}"
-        end
-      # Datadog::Core::Transport does not perform any exception mapping,
-      # therefore we could have any exception here from failure to parse
-      # agent URI for example.
-      # If we ever implement retries for network errors, we should distinguish
-      # actual network errors from non-network errors that are raised by
-      # transport code.
-      rescue => exc
-        raise Error::AgentCommunicationError, "#{desc} failed: #{exc.class}: #{exc}"
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Tracing
-    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