ddtrace 1.1.0 → 1.12.1

data/lib/datadog/core/runtime/metrics.rb

@@ -1,12 +1,10 @@
-# typed: true
+require_relative 'ext'
 
-require 'datadog/core/runtime/ext'
-
-require 'datadog/core/metrics/client'
-require 'datadog/core/environment/class_count'
-require 'datadog/core/environment/gc'
-require 'datadog/core/environment/thread_count'
-require 'datadog/core/environment/vm_cache'
+require_relative '../metrics/client'
+require_relative '../environment/class_count'
+require_relative '../environment/gc'
+require_relative '../environment/thread_count'
+require_relative '../environment/vm_cache'
 
 module Datadog
   module Core
@@ -57,15 +55,27 @@ module Datadog
 
           try_flush do
             if Core::Environment::VMCache.available?
-              gauge(
+              # Only on Ruby < 3.2
+              gauge_if_not_nil(
                 Core::Runtime::Ext::Metrics::METRIC_GLOBAL_CONSTANT_STATE,
                 Core::Environment::VMCache.global_constant_state
               )
 
-              # global_method_state is not available since Ruby >= 3.0,
-              # as method caching was moved to a per-class basis.
-              global_method_state = Core::Environment::VMCache.global_method_state
-              gauge(Core::Runtime::Ext::Metrics::METRIC_GLOBAL_METHOD_STATE, global_method_state) if global_method_state
+              # Only on Ruby 2.x
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_GLOBAL_METHOD_STATE,
+                Core::Environment::VMCache.global_method_state
+              )
+
+              # Only on Ruby >= 3.2
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_CONSTANT_CACHE_INVALIDATIONS,
+                Core::Environment::VMCache.constant_cache_invalidations
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_CONSTANT_CACHE_MISSES,
+                Core::Environment::VMCache.constant_cache_misses
+              )
             end
           end
         end
@@ -120,6 +130,10 @@ module Datadog
         def to_metric_name(str)
           str.downcase.gsub(/[-\s]/, '_')
         end
+
+        def gauge_if_not_nil(metric_name, metric_value)
+          gauge(metric_name, metric_value) if metric_value
+        end
       end
     end
   end

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

@@ -0,0 +1,77 @@
+require_relative 'emitter'
+require_relative 'heartbeat'
+require_relative '../utils/forking'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Telemetry entrypoint, coordinates sending telemetry events at various points in app lifecycle.
+      class Client
+        attr_reader \
+          :emitter,
+          :enabled,
+          :unsupported,
+          :worker
+
+        include Core::Utils::Forking
+
+        # @param enabled [Boolean] Determines whether telemetry events should be sent to the API
+        def initialize(enabled: true)
+          @enabled = enabled
+          @emitter = Emitter.new
+          @stopped = false
+          @unsupported = false
+          @worker = Telemetry::Heartbeat.new(enabled: @enabled) do
+            heartbeat!
+          end
+        end
+
+        def disable!
+          @enabled = false
+          @worker.enabled = false
+        end
+
+        def started!
+          return if !@enabled || forked?
+
+          res = @emitter.request(:'app-started')
+
+          if res.not_found? # Telemetry is only supported by agent versions 7.34 and up
+            Datadog.logger.debug('Agent does not support telemetry; disabling future telemetry events.')
+            disable!
+            @unsupported = true # Prevent telemetry from getting re-enabled
+          end
+
+          res
+        end
+
+        def emit_closing!
+          return if !@enabled || forked?
+
+          @emitter.request(:'app-closing')
+        end
+
+        def stop!
+          return if @stopped
+
+          @worker.stop(true, 0)
+          @stopped = true
+        end
+
+        def integrations_change!
+          return if !@enabled || forked?
+
+          @emitter.request(:'app-integrations-change')
+        end
+
+        private
+
+        def heartbeat!
+          return if !@enabled || forked?
+
+          @emitter.request(:'app-heartbeat')
+        end
+      end
+    end
+  end
+end

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 '../utils/hash'
+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
+        using Core::Utils::Hash::Refinement
+
+        # 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
+          hash = {
+            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),
+          }
+          hash.compact!
+          hash
+        end
+
+        # Forms a telemetry app-started dependencies object
+        def dependencies
+          Gem.loaded_specs.collect do |name, loaded_gem|
+            Datadog::Core::Telemetry::V1::Dependency.new(
+              # `hash` should be used when `version` is not available
+              name: name, version: loaded_gem.version.to_s, hash: nil
+            )
+          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?
+          options.compact!
+          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
+
+        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.compact.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,37 @@
+# frozen_string_literal: true
+
+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,20 @@
+# 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

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