ddtrace 1.1.0 → 1.12.1

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

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+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
+          attr_reader \
+            :host,
+            :port,
+            :ssl,
+            :path
+
+          def initialize
+            agent_settings = Configuration::AgentSettingsResolver.call(Datadog.configuration)
+            @host = agent_settings.hostname
+            @port = agent_settings.port
+            @ssl = false
+            @path = Http::Ext::AGENT_ENDPOINT
+          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)
+            {
+              Http::Ext::HEADER_CONTENT_TYPE => Http::Ext::CONTENT_TYPE_APPLICATION_JSON,
+              Http::Ext::HEADER_DD_TELEMETRY_API_VERSION => api_version,
+              Http::Ext::HEADER_DD_TELEMETRY_REQUEST_TYPE => request_type,
+            }
+          end
+
+          def adapter
+            @adapter ||= Http::Adapters::Net.new(hostname: @host, port: @port, ssl: @ssl)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Telemetry
+      module V1
+        # Describes payload for telemetry V1 API app-integrations-change event
+        class AppEvent
+          attr_reader \
+            :additional_payload,
+            :configuration,
+            :dependencies,
+            :integrations
+
+          # @param additional_payload [Array<Telemetry::V1::Configuration>] List of Additional payload to track (any key
+          #   value not mentioned and doesn't fit under a metric)
+          # @param configuration [Array<Telemetry::V1::Configuration>] List of Tracer related configuration data
+          # @param dependencies [Array<Telemetry::V1::Dependency>] List of all loaded modules requested by the app
+          # @param integrations [Array<Telemetry::V1::Integration>] List of integrations that are available within the app
+          #   and applicable to be traced
+          def initialize(additional_payload: nil, configuration: nil, dependencies: nil, integrations: nil)
+            @additional_payload = additional_payload
+            @configuration = configuration
+            @dependencies = dependencies
+            @integrations = integrations
+          end
+
+          def to_h
+            {}.tap do |hash|
+              hash[:additional_payload] = map_hash(@additional_payload) if @additional_payload
+              hash[:configuration] = map_hash(@configuration) if @configuration
+              hash[:dependencies] = map_array(@dependencies) if @dependencies
+              hash[:integrations] = map_array(@integrations) if @integrations
+            end
+          end
+
+          private
+
+          def map_hash(hash)
+            hash.map do |k, v|
+              { name: k.to_s, value: v }
+            end
+          end
+
+          def map_array(arr)
+            arr.map(&:to_h)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+require_relative '../../utils/hash'
+
+module Datadog
+  module Core
+    module Telemetry
+      module V1
+        # Describes attributes for application environment object
+        class Application
+          using Core::Utils::Hash::Refinement
+
+          ERROR_NIL_LANGUAGE_NAME_MESSAGE = ':language_name must not be nil'.freeze
+          ERROR_NIL_LANGUAGE_VERSION_MESSAGE = ':language_version must not be nil'.freeze
+          ERROR_NIL_SERVICE_NAME_MESSAGE = ':service_name must not be nil'.freeze
+          ERROR_NIL_TRACER_VERSION_MESSAGE = ':tracer_version must not be nil'.freeze
+
+          attr_reader \
+            :env,
+            :language_name,
+            :language_version,
+            :products,
+            :runtime_name,
+            :runtime_patches,
+            :runtime_version,
+            :service_name,
+            :service_version,
+            :tracer_version
+
+          # @param env [String] Service's environment
+          # @param language_name [String] 'ruby'
+          # @param language_version [String] Version of language used
+          # @param products [Telemetry::V1::Product] Contains information about specific products added to the environment
+          # @param runtime_name [String] Runtime being used
+          # @param runtime_patches [String] String of patches applied to the runtime
+          # @param runtime_version [String] Runtime version; potentially the same as :language_version
+          # @param service_name [String] Service’s name (DD_SERVICE)
+          # @param service_version [String] Service’s version (DD_VERSION)
+          # @param tracer_version [String] Version of the used tracer
+          def initialize(
+            language_name:, language_version:, service_name:, tracer_version:, env: nil, products: nil,
+            runtime_name: nil, runtime_patches: nil, runtime_version: nil, service_version: nil
+          )
+            validate(
+              language_name: language_name,
+              language_version: language_version,
+              service_name: service_name,
+              tracer_version: tracer_version
+            )
+            @env = env
+            @language_name = language_name
+            @language_version = language_version
+            @products = products
+            @runtime_name = runtime_name
+            @runtime_patches = runtime_patches
+            @runtime_version = runtime_version
+            @service_name = service_name
+            @service_version = service_version
+            @tracer_version = tracer_version
+          end
+
+          def to_h
+            hash = {
+              env: @env,
+              language_name: @language_name,
+              language_version: @language_version,
+              products: @products.to_h,
+              runtime_name: @runtime_name,
+              runtime_patches: @runtime_patches,
+              runtime_version: @runtime_version,
+              service_name: @service_name,
+              service_version: @service_version,
+              tracer_version: @tracer_version
+            }
+            hash.compact!
+            hash
+          end
+
+          private
+
+          # Validates required arguments passed to the class on initialization are not nil
+          #
+          # @!visibility private
+          def validate(language_name:, language_version:, service_name:, tracer_version:)
+            raise ArgumentError, ERROR_NIL_LANGUAGE_NAME_MESSAGE if language_name.nil?
+            raise ArgumentError, ERROR_NIL_LANGUAGE_VERSION_MESSAGE if language_version.nil?
+            raise ArgumentError, ERROR_NIL_SERVICE_NAME_MESSAGE if service_name.nil?
+            raise ArgumentError, ERROR_NIL_TRACER_VERSION_MESSAGE if tracer_version.nil?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Datadog
+  module Core
+    module Telemetry
+      module V1
+        # Describes attributes for additional payload or configuration object
+        class Configuration
+          ERROR_NIL_NAME_MESSAGE = ':name must not be nil'.freeze
+
+          attr_reader \
+            :name,
+            :value
+
+          # @param name [String] Configuration/additional payload attribute name
+          # @param value [String, Integer, Boolean] Corresponding value
+          def initialize(name:, value: nil)
+            raise ArgumentError, ERROR_NIL_NAME_MESSAGE if name.nil?
+
+            @name = name
+            @value = value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+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 \
+            :hash,
+            :name,
+            :version
+
+          # @param name [String] Module name
+          # @param version [String] Version of resolved module
+          # @param hash [String] Dependency hash, in case `version` is not available
+          def initialize(name:, version: nil, hash: nil)
+            raise ArgumentError, ERROR_NIL_NAME_MESSAGE if name.nil?
+            raise ArgumentError, 'if both :version and :hash exist, use :version only' if version && hash
+
+            @hash = hash
+            @name = name
+            @version = version
+          end
+
+          def to_h
+            hash = {
+              hash: @hash,
+              name: @name,
+              version: @version
+            }
+            hash.compact!
+            hash
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# 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,
+            :kernel_name,
+            :kernel_release,
+            :kernel_version,
+            :os_version,
+            :os
+
+          # @param container_id [String] Docker container ID
+          # @param hostname [String] uname -n
+          # @param kernel_name [String] uname -s
+          # @param kernel_release [String] uname -r
+          # @param kernel_version [String] uname -v
+          # @param os [String] uname -o
+          # @param os_version [String] Version of OS running
+          def initialize(
+            container_id: nil, hostname: nil, kernel_name: nil, kernel_release: nil, kernel_version: nil,
+            os_version: nil, os: nil
+          )
+            @container_id = container_id
+            @hostname = hostname
+            @kernel_name = kernel_name
+            @kernel_release = kernel_release
+            @kernel_version = kernel_version
+            @os = os
+            @os_version = os_version
+          end
+
+          def to_h
+            hash = {
+              container_id: @container_id,
+              hostname: @hostname,
+              kernel_name: @kernel_name,
+              kernel_release: @kernel_release,
+              kernel_version: @kernel_version,
+              os: @os,
+              os_version: @os_version,
+            }
+            hash.compact!
+            hash
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

@@ -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