ddtrace 1.12.1 → 1.23.2

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

@@ -1,64 +0,0 @@
-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
-
-          attr_reader \
-            :auto_enabled,
-            :compatible,
-            :enabled,
-            :error,
-            :name,
-            :version
-
-          # @param enabled [Boolean] Whether integration is enabled at time of request
-          # @param name [String] Integration name
-          # @param auto_enabled [Boolean] If integration is not enabled by default, but by user choice
-          # @param compatible [Boolean] If integration is available, but incompatible
-          # @param error [String] Error message if integration fails to load
-          # @param version [String] Integration version (if specified in app-started, it should be for other events too)
-          def initialize(enabled:, name:, auto_enabled: nil, compatible: nil, error: nil, version: nil)
-            validate(enabled: enabled, name: name)
-            @auto_enabled = auto_enabled
-            @compatible = compatible
-            @enabled = enabled
-            @error = error
-            @name = name
-            @version = version
-          end
-
-          def to_h
-            hash = {
-              auto_enabled: @auto_enabled,
-              compatible: @compatible,
-              enabled: @enabled,
-              error: @error,
-              name: @name,
-              version: @version
-            }
-            hash.compact!
-            hash
-          end
-
-          private
-
-          # Validates all required arguments passed to the class on initialization are not nil
-          #
-          # @!visibility private
-          def validate(enabled:, name:)
-            raise ArgumentError, ERROR_NIL_ENABLED_MESSAGE if enabled.nil?
-            raise ArgumentError, ERROR_NIL_NAME_MESSAGE if name.nil?
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-# 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
-
-          # @param appsec [Telemetry::V1::AppSec] Holds custom information about the appsec product
-          # @param profiler [Telemetry::V1::Profiler] Holds custom information about the profiler product
-          def initialize(appsec: nil, profiler: nil)
-            @appsec = appsec
-            @profiler = profiler
-          end
-
-          def to_h
-            hash = {
-              appsec: @appsec,
-              profiler: @profiler
-            }
-            hash.compact!
-            hash
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-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
-          ERROR_NIL_PAYLOAD_MESSAGE = ':payload must not be nil'.freeze
-          ERROR_NIL_REQUEST_TYPE_MESSAGE = ':request_type must not be nil'.freeze
-          ERROR_NIL_RUNTIME_ID_MESSAGE = ':runtime_id must not be nil'.freeze
-          ERROR_NIL_SEQ_ID_MESSAGE = ':seq_id must not be nil'.freeze
-          ERROR_NIL_TRACER_TIME_MESSAGE = ':tracer_time must not be nil'.freeze
-
-          attr_reader \
-            :api_version,
-            :application,
-            :debug,
-            :host,
-            :payload,
-            :request_type,
-            :runtime_id,
-            :seq_id,
-            :session_id,
-            :tracer_time
-
-          # @param api_version [String] Requested API version, `v1`
-          # @param application [Telemetry::V1::Application] Object that contains information about the environment of the
-          #   application
-          # @param host [Telemetry::V1::Host] Object that holds host related information
-          # @param payload [Telemetry::V1::AppEvent] The payload of the request, type impacted by :request_type
-          # @param request_type [String] Requested API function impacting the Payload type, `app-started`
-          # @param runtime_id [String] V4 UUID that represents a tracer session
-          # @param seq_id [Integer] Counter that should be auto incremented every time an API call is being made
-          # @param tracer_time [Integer] Unix timestamp (in seconds) of when the message is being sent
-          # @param debug [Boolean] Flag that enables payload debug mode
-          # @param session_id [String] V4 UUID that represents the session of the top level tracer process, often same\
-          #   as runtime_id
-          def initialize(
-            api_version:, application:, host:, payload:, request_type:, runtime_id:, seq_id:, tracer_time:,
-            debug: nil, session_id: nil
-          )
-            validate(
-              api_version: api_version,
-              application: application,
-              host: host,
-              payload: payload,
-              request_type: request_type,
-              runtime_id: runtime_id,
-              seq_id: seq_id,
-              tracer_time: tracer_time
-            )
-            @api_version = api_version
-            @application = application
-            @debug = debug
-            @host = host
-            @payload = payload
-            @request_type = request_type
-            @runtime_id = runtime_id
-            @seq_id = seq_id
-            @session_id = session_id
-            @tracer_time = tracer_time
-          end
-
-          def to_h
-            hash = {
-              api_version: @api_version,
-              application: @application.to_h,
-              debug: @debug,
-              host: @host.to_h,
-              payload: @payload.to_h,
-              request_type: @request_type,
-              runtime_id: @runtime_id,
-              seq_id: @seq_id,
-              session_id: @session_id,
-              tracer_time: @tracer_time
-            }
-            hash.compact!
-            hash
-          end
-
-          private
-
-          # Validates all required arguments passed to the class on initialization are not nil
-          #
-          # @!visibility private
-          def validate(api_version:, application:, host:, payload:, request_type:, runtime_id:, seq_id:, tracer_time:)
-            raise ArgumentError, ERROR_NIL_API_VERSION_MESSAGE if api_version.nil?
-            raise ArgumentError, ERROR_NIL_APPLICATION_MESSAGE if application.nil?
-            raise ArgumentError, ERROR_NIL_HOST_MESSAGE if host.nil?
-            raise ArgumentError, ERROR_NIL_PAYLOAD_MESSAGE if payload.nil?
-            raise ArgumentError, ERROR_NIL_REQUEST_TYPE_MESSAGE if request_type.nil?
-            raise ArgumentError, ERROR_NIL_RUNTIME_ID_MESSAGE if runtime_id.nil?
-            raise ArgumentError, ERROR_NIL_SEQ_ID_MESSAGE if seq_id.nil?
-            raise ArgumentError, ERROR_NIL_TRACER_TIME_MESSAGE if tracer_time.nil?
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# 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.rb

@@ -1,57 +0,0 @@
-# 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/client.rb

@@ -1,45 +0,0 @@
-# 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

@@ -1,268 +0,0 @@
-# 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