ddtrace 1.10.1 → 1.11.0.beta1

data/lib/datadog/core/telemetry/v1/dependency.rb

@@ -1,9 +1,13 @@
+require_relative '../../utils/hash'
+
 module Datadog
   module Core
     module Telemetry
       module V1
         # Describes attributes for dependency object
         class Dependency
+          using Core::Utils::Hash::Refinement
+
           ERROR_NIL_NAME_MESSAGE = ':name must not be nil'.freeze
 
           attr_reader \
@@ -23,11 +27,13 @@ module Datadog
           end
 
           def to_h
-            {
+            hash = {
               hash: @hash,
               name: @name,
               version: @version
             }
+            hash.compact!
+            hash
           end
         end
       end

data/lib/datadog/core/telemetry/v1/host.rb

@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
+require_relative '../../utils/hash'
+
 module Datadog
   module Core
     module Telemetry
       module V1
         # Describes attributes for host object
         class Host
+          using Core::Utils::Hash::Refinement
+
           attr_reader \
             :container_id,
             :hostname,
@@ -34,7 +40,7 @@ module Datadog
           end
 
           def to_h
-            {
+            hash = {
               container_id: @container_id,
               hostname: @hostname,
               kernel_name: @kernel_name,
@@ -43,6 +49,8 @@ module Datadog
               os: @os,
               os_version: @os_version,
             }
+            hash.compact!
+            hash
           end
         end
       end

data/lib/datadog/core/telemetry/v1/integration.rb

@@ -1,9 +1,13 @@
+require_relative '../../utils/hash'
+
 module Datadog
   module Core
     module Telemetry
       module V1
         # Describes attributes for integration object
         class Integration
+          using Core::Utils::Hash::Refinement
+
           ERROR_NIL_ENABLED_MESSAGE = ':enabled must not be nil'.freeze
           ERROR_NIL_NAME_MESSAGE = ':name must not be nil'.freeze
 
@@ -32,7 +36,7 @@ module Datadog
           end
 
           def to_h
-            {
+            hash = {
               auto_enabled: @auto_enabled,
               compatible: @compatible,
               enabled: @enabled,
@@ -40,6 +44,8 @@ module Datadog
               name: @name,
               version: @version
             }
+            hash.compact!
+            hash
           end
 
           private

data/lib/datadog/core/telemetry/v1/product.rb

@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
+require_relative '../../utils/hash'
+
 module Datadog
   module Core
     module Telemetry
       module V1
         # Describes attributes for products object
         class Product
+          using Core::Utils::Hash::Refinement
+
           attr_reader \
             :appsec,
             :profiler
@@ -16,10 +22,12 @@ module Datadog
           end
 
           def to_h
-            {
+            hash = {
               appsec: @appsec,
               profiler: @profiler
             }
+            hash.compact!
+            hash
           end
         end
       end

data/lib/datadog/core/telemetry/v1/telemetry_request.rb

@@ -1,9 +1,13 @@
+require_relative '../../utils/hash'
+
 module Datadog
   module Core
     module Telemetry
       module V1
         # Describes attributes for telemetry API request
         class TelemetryRequest
+          using Core::Utils::Hash::Refinement
+
           ERROR_NIL_API_VERSION_MESSAGE = ':api_version must not be nil'.freeze
           ERROR_NIL_APPLICATION_MESSAGE = ':application must not be nil'.freeze
           ERROR_NIL_HOST_MESSAGE = ':host must not be nil'.freeze
@@ -64,7 +68,7 @@ module Datadog
           end
 
           def to_h
-            {
+            hash = {
               api_version: @api_version,
               application: @application.to_h,
               debug: @debug,
@@ -76,6 +80,8 @@ module Datadog
               session_id: @session_id,
               tracer_time: @tracer_time
             }
+            hash.compact!
+            hash
           end
 
           private

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../../../ddtrace/transport/request'
+require_relative '../../../ddtrace/transport/parcel'
+
+module Datadog
+  module Core
+    module Transport
+      module Config
+        # Data transfer object for encoded traces
+        class EncodedParcel
+          include Datadog::Transport::Parcel
+
+          def count
+            data.length
+          end
+        end
+
+        # Config request
+        class Request < Datadog::Transport::Request
+        end
+
+        # Config response
+        module Response
+          attr_reader :roots, :targets, :target_files, :client_configs
+
+          def empty?
+            @empty
+          end
+        end
+
+        # Config 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
+
+          ##### there is only one transport! it's negotiation!
+          def send_config(payload)
+            json = JSON.dump(payload)
+            parcel = EncodedParcel.new(json)
+            request = Request.new(parcel)
+
+            @client.send_config_payload(request)
+          end
+
+          def current_api
+            @apis[HTTP::API::V7]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module API
+          # An API configured with adapter and routes
+          class Instance
+            attr_reader \
+              :adapter,
+              :headers,
+              :spec
+
+            def initialize(spec, adapter, options = {})
+              @spec = spec
+              @adapter = adapter
+              @headers = options.fetch(:headers, {})
+            end
+
+            def encoder
+              spec.encoder
+            end
+
+            def call(env)
+              # Add headers to request env, unless empty.
+              env.headers.merge!(headers) unless headers.empty?
+
+              # Send request env to the adapter.
+              adapter.call(env)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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