ddtrace 1.0.0 → 1.10.1

data/lib/datadog/core/telemetry/collector.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require 'etc'
+
+require_relative '../configuration/agent_settings_resolver'
+require_relative '../environment/ext'
+require_relative '../environment/platform'
+require_relative 'v1/application'
+require_relative 'v1/dependency'
+require_relative 'v1/host'
+require_relative 'v1/integration'
+require_relative 'v1/product'
+require_relative '../../../ddtrace/transport/ext'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Module defining methods for collecting metadata for telemetry
+      module Collector
+        include Datadog::Core::Configuration
+
+        # Forms a hash of configuration key value pairs to be sent in the additional payload
+        def additional_payload
+          additional_payload_variables
+        end
+
+        # Forms a telemetry application object
+        def application
+          Telemetry::V1::Application.new(
+            env: env,
+            language_name: Datadog::Core::Environment::Ext::LANG,
+            language_version: Datadog::Core::Environment::Ext::LANG_VERSION,
+            products: products,
+            runtime_name: Datadog::Core::Environment::Ext::RUBY_ENGINE,
+            runtime_version: Datadog::Core::Environment::Ext::ENGINE_VERSION,
+            service_name: service_name,
+            service_version: service_version,
+            tracer_version: library_version
+          )
+        end
+
+        # Forms a hash of standard key value pairs to be sent in the app-started event configuration
+        def configurations
+          configurations = {
+            DD_AGENT_HOST: Datadog.configuration.agent.host,
+            DD_AGENT_TRANSPORT: agent_transport,
+            DD_TRACE_SAMPLE_RATE: format_configuration_value(Datadog.configuration.tracing.sampling.default_rate),
+          }
+          compact_hash(configurations)
+        end
+
+        # Forms a telemetry app-started dependencies object
+        def dependencies
+          Gem.loaded_specs.collect do |name, loaded_gem|
+            Datadog::Core::Telemetry::V1::Dependency.new(
+              name: name, version: loaded_gem.version.to_s, hash: loaded_gem.hash.to_s
+            )
+          end
+        end
+
+        # Forms a telemetry host object
+        def host
+          Telemetry::V1::Host.new(
+            container_id: Core::Environment::Container.container_id,
+            hostname: Core::Environment::Platform.hostname,
+            kernel_name: Core::Environment::Platform.kernel_name,
+            kernel_release: Core::Environment::Platform.kernel_release,
+            kernel_version: Core::Environment::Platform.kernel_version
+          )
+        end
+
+        # Forms a telemetry app-started integrations object
+        def integrations
+          Datadog.registry.map do |integration|
+            is_instrumented = instrumented?(integration)
+            is_enabled = is_instrumented && patched?(integration)
+            Telemetry::V1::Integration.new(
+              name: integration.name.to_s,
+              enabled: is_enabled,
+              version: integration_version(integration),
+              compatible: integration_compatible?(integration),
+              error: (patch_error(integration) if is_instrumented && !is_enabled),
+              auto_enabled: is_enabled ? integration_auto_instrument?(integration) : nil
+            )
+          end
+        end
+
+        # Returns the runtime ID of the current process
+        def runtime_id
+          Datadog::Core::Environment::Identity.id
+        end
+
+        # Returns the current as a UNIX timestamp in seconds
+        def tracer_time
+          Time.now.to_i
+        end
+
+        private
+
+        TARGET_OPTIONS = [
+          'ci.enabled',
+          'logger.level',
+          'profiling.advanced.code_provenance_enabled',
+          'profiling.advanced.endpoint.collection.enabled',
+          'profiling.enabled',
+          'runtime_metrics.enabled',
+          'tracing.analytics.enabled',
+          'tracing.distributed_tracing.propagation_inject_style',
+          'tracing.distributed_tracing.propagation_extract_style',
+          'tracing.enabled',
+          'tracing.log_injection',
+          'tracing.partial_flush.enabled',
+          'tracing.partial_flush.min_spans_threshold',
+          'tracing.priority_sampling',
+          'tracing.report_hostname',
+          'tracing.sampling.default_rate',
+          'tracing.sampling.rate_limit'
+        ].freeze
+
+        def additional_payload_variables
+          # Whitelist of configuration options to send in additional payload object
+          configuration = Datadog.configuration
+          options = TARGET_OPTIONS.each_with_object({}) do |option, hash|
+            split_option = option.split('.')
+            hash[option] = format_configuration_value(configuration.dig(*split_option))
+          end
+
+          # Add some more custom additional payload values here
+          options['tracing.auto_instrument.enabled'] = !defined?(Datadog::AutoInstrument::LOADED).nil?
+          options['tracing.writer_options.buffer_size'] =
+            format_configuration_value(configuration.tracing.writer_options[:buffer_size])
+          options['tracing.writer_options.flush_interval'] =
+            format_configuration_value(configuration.tracing.writer_options[:flush_interval])
+          options['logger.instance'] = configuration.logger.instance.class.to_s
+          options['appsec.enabled'] = configuration.dig('appsec', 'enabled') if configuration.respond_to?('appsec')
+          options['tracing.opentelemetry.enabled'] = !defined?(Datadog::OpenTelemetry::LOADED).nil?
+          compact_hash(options)
+        end
+
+        def format_configuration_value(value)
+          # TODO: Add float if telemetry starts accepting it
+          case value
+          when Integer, String, true, false, nil
+            value
+          else
+            value.to_s
+          end
+        end
+
+        # Manual implementation of hash.compact used because it is unsupported by older Ruby versions (<2.4)
+        def compact_hash(hash)
+          hash.delete_if { |_k, v| v.nil? }
+        end
+
+        def env
+          Datadog.configuration.env
+        end
+
+        def service_name
+          Datadog.configuration.service
+        end
+
+        def service_version
+          Datadog.configuration.version
+        end
+
+        def library_version
+          Core::Environment::Identity.tracer_version
+        end
+
+        def products
+          Telemetry::V1::Product.new(profiler: profiler, appsec: appsec)
+        end
+
+        def profiler
+          { version: library_version }
+        end
+
+        def appsec
+          { version: library_version }
+        end
+
+        def agent_transport
+          adapter = Core::Configuration::AgentSettingsResolver.call(Datadog.configuration).adapter
+          if adapter == Datadog::Transport::Ext::UnixSocket::ADAPTER
+            'UDS'
+          else
+            'TCP'
+          end
+        end
+
+        def instrumented_integrations
+          Datadog.configuration.tracing.instrumented_integrations
+        end
+
+        def instrumented?(integration)
+          instrumented_integrations.include?(integration.name)
+        end
+
+        def patched?(integration)
+          !!integration.klass.patcher.patch_successful
+        end
+
+        def integration_auto_instrument?(integration)
+          integration.klass.auto_instrument?
+        end
+
+        def integration_compatible?(integration)
+          integration.klass.class.compatible?
+        end
+
+        def integration_version(integration)
+          integration.klass.class.version ? integration.klass.class.version.to_s : nil
+        end
+
+        def patch_error(integration)
+          patch_error_result = integration.klass.patcher.patch_error_result
+          if patch_error_result.nil? # if no error occurred during patching, but integration is still not instrumented
+            desc = "Available?: #{integration.klass.class.available?}"
+            desc += ", Loaded? #{integration.klass.class.loaded?}"
+            desc += ", Compatible? #{integration.klass.class.compatible?}"
+            desc += ", Patchable? #{integration.klass.class.patchable?}"
+            desc
+          else
+            patch_error_result.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/emitter.rb

@@ -0,0 +1,46 @@
+require_relative 'event'
+require_relative 'http/transport'
+require_relative '../utils/sequence'
+require_relative '../utils/forking'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Class that emits telemetry events
+      class Emitter
+        attr_reader :http_transport
+
+        extend Core::Utils::Forking
+
+        # @param sequence [Datadog::Core::Utils::Sequence] Sequence object that stores and increments a counter
+        # @param http_transport [Datadog::Core::Telemetry::Http::Transport] Transport object that can be used to send
+        #   telemetry requests via the agent
+        def initialize(http_transport: Datadog::Core::Telemetry::Http::Transport.new)
+          @http_transport = http_transport
+        end
+
+        # Retrieves and emits a TelemetryRequest object based on the request type specified
+        # @param request_type [String] the type of telemetry request to collect data for
+        def request(request_type)
+          begin
+            request = Datadog::Core::Telemetry::Event.new.telemetry_request(
+              request_type: request_type,
+              seq_id: self.class.sequence.next
+            ).to_h
+            @http_transport.request(request_type: request_type.to_s, payload: request.to_json)
+          rescue StandardError => e
+            Datadog.logger.debug("Unable to send telemetry request for event `#{request_type}`: #{e}")
+            Telemetry::Http::InternalErrorResponse.new(e)
+          end
+        end
+
+        # Initializes a Sequence object to track seq_id if not already initialized; else returns stored
+        # Sequence object
+        def self.sequence
+          after_fork! { @sequence = Datadog::Core::Utils::Sequence.new(1) }
+          @sequence ||= Datadog::Core::Utils::Sequence.new(1)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/event.rb

@@ -0,0 +1,67 @@
+require_relative 'collector'
+require_relative 'v1/app_event'
+require_relative 'v1/telemetry_request'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Class defining methods to construct a Telemetry event
+      class Event
+        include Telemetry::Collector
+
+        API_VERSION = 'v1'.freeze
+
+        attr_reader \
+          :api_version
+
+        def initialize
+          @api_version = API_VERSION
+        end
+
+        # Forms a TelemetryRequest object based on the event request_type
+        # @param request_type [String] the type of telemetry request to collect data for
+        # @param seq_id [Integer] the ID of the request; incremented each time a telemetry request is sent to the API
+        def telemetry_request(request_type:, seq_id:)
+          Telemetry::V1::TelemetryRequest.new(
+            api_version: @api_version,
+            application: application,
+            host: host,
+            payload: payload(request_type),
+            request_type: request_type,
+            runtime_id: runtime_id,
+            seq_id: seq_id,
+            tracer_time: tracer_time,
+          )
+        end
+
+        private
+
+        def payload(request_type)
+          case request_type
+          when :'app-started'
+            app_started
+          when :'app-closing', :'app-heartbeat'
+            {}
+          when :'app-integrations-change'
+            app_integrations_change
+          else
+            raise ArgumentError, "Request type invalid, received request_type: #{@request_type}"
+          end
+        end
+
+        def app_started
+          Telemetry::V1::AppEvent.new(
+            dependencies: dependencies,
+            integrations: integrations,
+            configuration: configurations,
+            additional_payload: additional_payload
+          )
+        end
+
+        def app_integrations_change
+          Telemetry::V1::AppEvent.new(integrations: integrations)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Datadog
+  module Core
+    module Telemetry
+      module Ext
+        ENV_ENABLED = 'DD_INSTRUMENTATION_TELEMETRY_ENABLED'.freeze
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/heartbeat.rb

@@ -0,0 +1,35 @@
+require_relative '../worker'
+require_relative '../workers/polling'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Periodically (every DEFAULT_INTERVAL_SECONDS) sends a heartbeat event to the telemetry API.
+      class Heartbeat < Core::Worker
+        include Core::Workers::Polling
+
+        DEFAULT_INTERVAL_SECONDS = 60
+
+        def initialize(enabled: true, interval: DEFAULT_INTERVAL_SECONDS, &block)
+          # Workers::Polling settings
+          self.enabled = enabled
+          # Workers::IntervalLoop settings
+          self.loop_base_interval = interval
+          self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_STOP
+          super(&block)
+          start
+        end
+
+        def loop_wait_before_first_iteration?
+          true
+        end
+
+        private
+
+        def start
+          perform
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/http/adapters/net.rb

@@ -0,0 +1,111 @@
+require_relative '../response'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Http
+        module Adapters
+          # Class defining methods to make http requests via NET
+          class Net
+            attr_reader \
+              :hostname,
+              :port,
+              :timeout,
+              :ssl
+
+            DEFAULT_TIMEOUT = 30
+
+            def initialize(hostname:, port: nil, timeout: DEFAULT_TIMEOUT, ssl: true)
+              @hostname = hostname
+              @port = port
+              @timeout = timeout
+              @ssl = ssl.nil? ? true : ssl
+            end
+
+            def open(&block)
+              req = ::Net::HTTP.new(@hostname, @port)
+
+              req.use_ssl = @ssl
+              req.open_timeout = req.read_timeout = @timeout
+
+              req.start(&block)
+            end
+
+            def post(env)
+              begin
+                post = ::Net::HTTP::Post.new(env.path, env.headers)
+                post.body = env.body
+
+                http_response = open do |http|
+                  http.request(post)
+                end
+
+                Response.new(http_response)
+              rescue StandardError => e
+                Datadog.logger.debug("Unable to send telemetry event to agent: #{e}")
+                Telemetry::Http::InternalErrorResponse.new(e)
+              end
+            end
+
+            # Data structure for an HTTP Response
+            class Response
+              include Datadog::Core::Telemetry::Http::Response
+
+              attr_reader :http_response
+
+              def initialize(http_response)
+                @http_response = http_response
+              end
+
+              def payload
+                return super if http_response.nil?
+
+                http_response.body
+              end
+
+              def code
+                return super if http_response.nil?
+
+                http_response.code.to_i
+              end
+
+              def ok?
+                return super if http_response.nil?
+
+                code.between?(200, 299)
+              end
+
+              def unsupported?
+                return super if http_response.nil?
+
+                code == 415
+              end
+
+              def not_found?
+                return super if http_response.nil?
+
+                code == 404
+              end
+
+              def client_error?
+                return super if http_response.nil?
+
+                code.between?(400, 499)
+              end
+
+              def server_error?
+                return super if http_response.nil?
+
+                code.between?(500, 599)
+              end
+
+              def inspect
+                "#{super}, http_response:#{http_response}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,20 @@
+module Datadog
+  module Core
+    module Telemetry
+      module Http
+        module Ext
+          HEADER_DD_API_KEY = 'DD-API-KEY'.freeze
+          HEADER_CONTENT_TYPE = 'Content-Type'.freeze
+          HEADER_CONTENT_LENGTH = 'Content-Length'.freeze
+          HEADER_DD_TELEMETRY_API_VERSION = 'DD-Telemetry-API-Version'.freeze
+          HEADER_DD_TELEMETRY_REQUEST_TYPE = 'DD-Telemetry-Request-Type'.freeze
+
+          CONTENT_TYPE_APPLICATION_JSON = 'application/json'.freeze
+          API_VERSION = 'v1'.freeze
+
+          AGENT_ENDPOINT = '/telemetry/proxy/api/v2/apmtelemetry'.freeze
+        end
+      end
+    end
+  end
+end

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,51 @@
+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
+        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