datadog 2.4.0 → 2.44.0

data/lib/datadog/core/remote/transport/http/negotiation.rb

@@ -1,27 +1,10 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
-require_relative '../negotiation'
-require_relative 'client'
-require_relative '../../../transport/http/response'
-require_relative '../../../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 '../../../../datadog/core/transport/http/api/instance'
-require_relative 'api/instance'
-# Below should be:
-# require_relative '../../../../datadog/core/transport/http/api/spec'
-require_relative 'api/spec'
+require_relative "../../../transport/http/client"
+require_relative "../../../transport/http/response"
+require_relative "../../../transport/http/api/endpoint"
 
 module Datadog
   module Core
@@ -33,7 +16,6 @@ module Datadog
             # Response from HTTP transport for agent feature negotiation
             class Response
               include Datadog::Core::Transport::HTTP::Response
-              include Core::Remote::Transport::Negotiation::Response
 
               def initialize(http_response, options = {})
                 super(http_response)
@@ -43,75 +25,25 @@ module Datadog
                 @version = options[:version]
                 @endpoints = options[:endpoints]
                 @config = options[:config]
+                @span_events = options[:span_events]
               end
-            end
 
-            # Extensions for HTTP client
-            module Client
-              def send_info_payload(request)
-                send_request(request) do |api, env|
-                  api.send_info(env)
-                end
-              end
+              # @!attribute [r] version
+              #   The version of the agent.
+              #   @return [String]
+              # @!attribute [r] endpoints
+              #   The HTTP endpoints the agent supports.
+              #   @return [Array<String>]
+              # @!attribute [r] config
+              #   The agent configuration. These are configured by the user when starting the agent, as well as any defaults.
+              #   @return [Hash]
+              # @!attribute [r] span_events
+              #   Whether the agent supports the top-level span events field in flushed spans.
+              #   @return [Boolean,nil]
+              attr_reader :version, :endpoints, :config, :span_events
             end
 
             module API
-              # Extensions for HTTP API Spec
-              module Spec
-                attr_reader :info
-
-                def info=(endpoint)
-                  @info = endpoint
-                end
-
-                def send_info(env, &block)
-                  raise NoNegotiationEndpointDefinedError, self if info.nil?
-
-                  info.call(env, &block)
-                end
-
-                # Raised when traces sent but no traces endpoint is defined
-                class NoNegotiationEndpointDefinedError < StandardError
-                  attr_reader :spec
-
-                  def initialize(spec)
-                    super()
-
-                    @spec = spec
-                  end
-
-                  def message
-                    'No info endpoint is defined for API specification!'
-                  end
-                end
-              end
-
-              # Extensions for HTTP API Instance
-              module Instance
-                def send_info(env)
-                  raise NegotiationNotSupportedError, spec unless spec.is_a?(Negotiation::API::Spec)
-
-                  spec.send_info(env) do |request_env|
-                    call(request_env)
-                  end
-                end
-
-                # Raised when traces sent to API that does not support traces
-                class NegotiationNotSupportedError < StandardError
-                  attr_reader :spec
-
-                  def initialize(spec)
-                    super()
-
-                    @spec = spec
-                  end
-
-                  def message
-                    'Info not supported for this API!'
-                  end
-                end
-              end
-
               # Endpoint for negotiation
               class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
                 def initialize(path)
@@ -120,7 +52,7 @@ module Datadog
 
                 def call(env, &block)
                   # Query for response
-                  http_response = super(env, &block)
+                  http_response = super
 
                   # Process the response
                   body = JSON.parse(http_response.payload, symbolize_names: true) if http_response.ok?
@@ -133,11 +65,6 @@ module Datadog
                 end
               end
             end
-
-            # Add negotiation behavior to transport components
-            HTTP::Client.include(Negotiation::Client)
-            HTTP::API::Spec.include(Negotiation::API::Spec)
-            HTTP::API::Instance.include(Negotiation::API::Instance)
           end
         end
       end

data/lib/datadog/core/remote/transport/http.rb

@@ -1,31 +1,11 @@
 # frozen_string_literal: true
 
-require 'uri'
-
-require_relative '../../environment/container'
-require_relative '../../environment/ext'
-require_relative '../../transport/ext'
-require_relative '../../transport/http/adapters/net'
-require_relative '../../transport/http/adapters/unix_socket'
-require_relative '../../transport/http/adapters/test'
-
-# TODO: Improve negotiation to allow per endpoint selection
-#
-# Since endpoint negotiation happens at the `API::Spec` level there can not be
-# a mix of endpoints at various versions or versionless without describing all
-# the possible combinations as specs. See http/api.
-#
-# Below should be:
-# require_relative '../../transport/http/api'
-require_relative 'http/api'
-
-# TODO: Decouple transport/http/builder
-#
-# See http/builder
-#
-# Below should be:
-# require_relative '../../transport/http/builder'
-require_relative 'http/builder'
+require_relative "../../environment/container"
+require_relative "../../environment/ext"
+require_relative "../../transport/ext"
+require_relative "../../transport/http"
+require_relative "config"
+require_relative "negotiation"
 
 # TODO: Decouple transport/http
 #
@@ -39,107 +19,54 @@ module Datadog
       module Transport
         # Namespace for HTTP transport components
         module HTTP
-          # NOTE: Due to... legacy reasons... This class likes having a default `AgentSettings` instance to fall back to.
-          # Because we generate this instance with an empty instance of `Settings`, the resulting `AgentSettings` below
-          # represents only settings specified via environment variables + the usual defaults.
-          #
-          # DO NOT USE THIS IN NEW CODE, as it ignores any settings specified by users via `Datadog.configure`.
-          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS = Datadog::Core::Configuration::AgentSettingsResolver.call(
-            Datadog::Core::Configuration::Settings.new,
-            logger: nil,
+          ROOT = Negotiation::API::Endpoint.new(
+            "/info",
           )
 
-          module_function
+          V7 = Config::API::Endpoint.new(
+            "/v0.7/config",
+            Core::Encoding::JSONEncoder,
+          )
 
-          # Builds a new Transport::HTTP::Client
-          def new(klass, &block)
-            Builder.new(&block).to_transport(klass)
-          end
+          module_function
 
           # Builds a new Transport::HTTP::Client with default settings
           # Pass a block to override any settings.
           def root(
-            agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
-            **options
+            agent_settings:,
+            logger:,
+            headers: nil
           )
-            new(Core::Remote::Transport::Negotiation::Transport) do |transport|
-              transport.adapter(agent_settings)
-              transport.headers(default_headers)
-
-              apis = API.defaults
-
-              transport.api API::ROOT, apis[API::ROOT]
-
-              # Apply any settings given by options
-              unless options.empty?
-                transport.default_api = options[:api_version] if options.key?(:api_version)
-                transport.headers options[:headers] if options.key?(:headers)
-              end
+            Core::Transport::HTTP.build(
+              agent_settings: agent_settings,
+              logger: logger,
+              headers: headers
+            ) do |transport|
+              transport.api "root", ROOT
 
               # Call block to apply any customization, if provided
               yield(transport) if block_given?
-            end
+            end.to_transport(Core::Remote::Transport::Negotiation::Transport)
           end
 
           # Builds a new Transport::HTTP::Client with default settings
           # Pass a block to override any settings.
           def v7(
-            agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
-            **options
+            agent_settings:,
+            logger:,
+            headers: nil
           )
-            new(Core::Remote::Transport::Config::Transport) do |transport|
-              transport.adapter(agent_settings)
-              transport.headers default_headers
-
-              apis = API.defaults
-
-              transport.api API::V7, apis[API::V7]
-
-              # Apply any settings given by options
-              unless options.empty?
-                transport.default_api = options[:api_version] if options.key?(:api_version)
-                transport.headers options[:headers] if options.key?(:headers)
-              end
+            Core::Transport::HTTP.build(
+              agent_settings: agent_settings,
+              logger: logger,
+              headers: headers
+            ) do |transport|
+              transport.api "v7", V7
 
               # Call block to apply any customization, if provided
               yield(transport) if block_given?
-            end
-          end
-
-          def default_headers
-            {
-              Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => '1',
-              Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG => Datadog::Core::Environment::Ext::LANG,
-              Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_VERSION =>
-                Datadog::Core::Environment::Ext::LANG_VERSION,
-              Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER =>
-                Datadog::Core::Environment::Ext::LANG_INTERPRETER,
-              Datadog::Core::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION =>
-                Datadog::Core::Environment::Ext::GEM_DATADOG_VERSION
-            }.tap do |headers|
-              # Add container ID, if present.
-              container_id = Datadog::Core::Environment::Container.container_id
-              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
-            end
+            end.to_transport(Core::Remote::Transport::Config::Transport)
           end
-
-          def default_adapter
-            Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-          end
-
-          # Add adapters to registry
-          Builder::REGISTRY.set(
-            Datadog::Core::Transport::HTTP::Adapters::Net,
-            Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-          )
-          Builder::REGISTRY.set(
-            Datadog::Core::Transport::HTTP::Adapters::Test,
-            Datadog::Core::Transport::Ext::Test::ADAPTER
-          )
-          Builder::REGISTRY.set(
-            Datadog::Core::Transport::HTTP::Adapters::UnixSocket,
-            Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER
-          )
         end
       end
     end

data/lib/datadog/core/remote/transport/negotiation.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/transport/request'
+require_relative "../../../core/transport/request"
+require_relative "../../../core/transport/transport"
+require_relative "http/negotiation"
 
 # TODO: Resolve conceptual conundrum
 #
@@ -30,29 +32,15 @@ module Datadog
           class Request < Datadog::Core::Transport::Request
           end
 
-          # Negotiation response
-          module Response
-            attr_reader :version, :endpoints, :config
-          end
-
           # Negotiation 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
-
-            def send_info
+          class Transport < Core::Transport::Transport
+            # TODO steep is complaining about this method, I tried to make
+            # it work but between module inclusions and steep diagnostics
+            # I don't understand what the problem is or what the steep wants.
+            def send_info # steep:ignore
               request = Request.new
 
-              @client.send_info_payload(request)
-            end
-
-            def current_api
-              @apis[HTTP::API::ROOT]
+              @client.send_request(:info, request)
             end
           end
         end

data/lib/datadog/core/remote/worker.rb

@@ -5,7 +5,7 @@ module Datadog
     module Remote
       # Worker executes a block every interval on a separate Thread
       class Worker
-        def initialize(interval:, &block)
+        def initialize(interval:, logger:, &block)
           @mutex = Mutex.new
           @thr = nil
 
@@ -14,72 +14,71 @@ module Datadog
           @stopped = false
 
           @interval = interval
-          raise ArgumentError, 'can not initialize a worker without a block' unless block
+          @logger = logger
+          raise ArgumentError, "can not initialize a worker without a block" unless block
 
           @block = block
         end
 
-        def start
-          Datadog.logger.debug { 'remote worker starting' }
+        attr_reader :logger
 
-          acquire_lock
+        def start
+          logger.debug { "remote worker starting (pid: #{Process.pid})" }
 
-          if @stopped
-            Datadog.logger.debug('remote worker: refusing to restart after previous stop')
-            return
-          end
+          @mutex.synchronize do
+            if @stopped
+              logger.debug("remote worker: refusing to restart after previous stop")
+              return
+            end
 
-          return if @starting || @started
+            return if @starting || @started
 
-          @starting = true
+            @starting = true
 
-          thread = Thread.new { poll(@interval) }
-          thread.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
-          thread.thread_variable_set(:fork_safe, true)
-          @thr = thread
+            thread = Thread.new { poll(@interval) }
+            thread.name = self.class.name
+            thread.thread_variable_set(:fork_safe, true)
+            @thr = thread
 
-          @started = true
-          @starting = false
+            @started = true
+            @starting = false
+          end
 
-          Datadog.logger.debug { 'remote worker started' }
-        ensure
-          release_lock
+          logger.debug { "remote worker started" }
         end
 
         def stop
-          Datadog.logger.debug { 'remote worker stopping' }
+          logger.debug { "remote worker stopping (pid: #{Process.pid})" }
 
-          acquire_lock
+          @mutex.synchronize do
+            thread = @thr
 
-          thread = @thr
+            if thread
+              thread.kill
+              thread.join
+            end
 
-          if thread
-            thread.kill
-            thread.join
+            @started = false
+            @thr = nil
+            @stopped = true
           end
 
-          @started = false
-          @thr = nil
-          @stopped = true
-
-          Datadog.logger.debug { 'remote worker stopped' }
-        ensure
-          release_lock
+          logger.debug { "remote worker stopped" }
         end
 
         def started?
           @started
         end
 
-        private
-
-        def acquire_lock
-          @mutex.lock
+        # Child-only: discard inherited synchronization without starting a thread.
+        def after_fork
+          @mutex = Mutex.new
+          @thr = nil
+          @starting = false
+          @started = false
         end
 
-        def release_lock
-          @mutex.unlock
-        end
+        private
 
         def poll(interval)
           loop do
@@ -92,7 +91,7 @@ module Datadog
         end
 
         def call
-          Datadog.logger.debug { 'remote worker perform' }
+          logger.debug { "remote worker perform" }
 
           @block.call
         end

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

@@ -5,34 +5,34 @@ module Datadog
     module Runtime
       # @public_api
       module Ext
-        TAG_ID = 'runtime-id'
-        TAG_LANG = 'language'
-        TAG_PROCESS_ID = 'process_id'
+        TAG_ID = "runtime-id"
+        TAG_LANG = "language"
+        TAG_PROCESS_ID = "process_id"
 
         # Metrics
         # @public_api
         module Metrics
-          ENV_ENABLED = 'DD_RUNTIME_METRICS_ENABLED'
-          ENV_OTEL_METRICS_EXPORTER = 'OTEL_METRICS_EXPORTER'
+          ENV_ENABLED = "DD_RUNTIME_METRICS_ENABLED"
 
-          METRIC_CLASS_COUNT = 'runtime.ruby.class_count'
-          METRIC_GC_PREFIX = 'runtime.ruby.gc'
-          METRIC_THREAD_COUNT = 'runtime.ruby.thread_count'
-          METRIC_GLOBAL_CONSTANT_STATE = 'runtime.ruby.global_constant_state'
-          METRIC_GLOBAL_METHOD_STATE = 'runtime.ruby.global_method_state'
-          METRIC_CONSTANT_CACHE_INVALIDATIONS = 'runtime.ruby.constant_cache_invalidations'
-          METRIC_CONSTANT_CACHE_MISSES = 'runtime.ruby.constant_cache_misses'
-          METRIC_YJIT_CODE_GC_COUNT = 'runtime.ruby.yjit.code_gc_count'
-          METRIC_YJIT_CODE_REGION_SIZE = 'runtime.ruby.yjit.code_region_size'
-          METRIC_YJIT_FREED_CODE_SIZE = 'runtime.ruby.yjit.freed_code_size'
-          METRIC_YJIT_FREED_PAGE_COUNT = 'runtime.ruby.yjit.freed_page_count'
-          METRIC_YJIT_INLINE_CODE_SIZE = 'runtime.ruby.yjit.inline_code_size'
-          METRIC_YJIT_LIVE_PAGE_COUNT = 'runtime.ruby.yjit.live_page_count'
-          METRIC_YJIT_OBJECT_SHAPE_COUNT = 'runtime.ruby.yjit.object_shape_count'
-          METRIC_YJIT_OUTLINED_CODE_SIZE = 'runtime.ruby.yjit.outlined_code_size'
-          METRIC_YJIT_YJIT_ALLOC_SIZE = 'runtime.ruby.yjit.yjit_alloc_size'
+          METRIC_CLASS_COUNT = "runtime.ruby.class_count"
+          METRIC_GC_PREFIX = "runtime.ruby.gc"
+          METRIC_THREAD_COUNT = "runtime.ruby.thread_count"
+          METRIC_GLOBAL_CONSTANT_STATE = "runtime.ruby.global_constant_state"
+          METRIC_GLOBAL_METHOD_STATE = "runtime.ruby.global_method_state"
+          METRIC_CONSTANT_CACHE_INVALIDATIONS = "runtime.ruby.constant_cache_invalidations"
+          METRIC_CONSTANT_CACHE_MISSES = "runtime.ruby.constant_cache_misses"
+          METRIC_YJIT_CODE_GC_COUNT = "runtime.ruby.yjit.code_gc_count"
+          METRIC_YJIT_CODE_REGION_SIZE = "runtime.ruby.yjit.code_region_size"
+          METRIC_YJIT_FREED_CODE_SIZE = "runtime.ruby.yjit.freed_code_size"
+          METRIC_YJIT_FREED_PAGE_COUNT = "runtime.ruby.yjit.freed_page_count"
+          METRIC_YJIT_INLINE_CODE_SIZE = "runtime.ruby.yjit.inline_code_size"
+          METRIC_YJIT_LIVE_PAGE_COUNT = "runtime.ruby.yjit.live_page_count"
+          METRIC_YJIT_OBJECT_SHAPE_COUNT = "runtime.ruby.yjit.object_shape_count"
+          METRIC_YJIT_OUTLINED_CODE_SIZE = "runtime.ruby.yjit.outlined_code_size"
+          METRIC_YJIT_YJIT_ALLOC_SIZE = "runtime.ruby.yjit.yjit_alloc_size"
+          METRIC_YJIT_RATIO_IN_YJIT = "runtime.ruby.yjit.ratio_in_yjit"
 
-          TAG_SERVICE = 'service'
+          TAG_SERVICE = "service"
         end
       end
     end

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

@@ -1,26 +1,32 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
+require_relative "ext"
 
-require_relative '../metrics/client'
-require_relative '../environment/class_count'
-require_relative '../environment/gc'
-require_relative '../environment/thread_count'
-require_relative '../environment/vm_cache'
-require_relative '../environment/yjit'
+require_relative "../metrics/client"
+require_relative "../environment/class_count"
+require_relative "../environment/gc"
+require_relative "../environment/thread_count"
+require_relative "../environment/vm_cache"
+require_relative "../environment/yjit"
+require_relative "../environment/process"
 
 module Datadog
   module Core
     module Runtime
       # For generating runtime metrics
       class Metrics < Core::Metrics::Client
-        def initialize(**options)
+        def initialize(telemetry:, **options)
           super
 
           # Initialize service list
           @services = Set.new(options.fetch(:services, []))
           @service_tags = nil
           compile_service_tags!
+
+          # Initialize the collection of runtime-id
+          @runtime_id_enabled = options.fetch(:experimental_runtime_id_enabled, false)
+
+          @process_tags_enabled = options.fetch(:experimental_propagate_process_tags_enabled)
         end
 
         # Associate service with runtime metrics
@@ -93,8 +99,8 @@ module Datadog
 
         def try_flush
           yield
-        rescue StandardError => e
-          Datadog.logger.warn("Error while sending runtime metric. Cause: #{e.class.name} #{e.message}")
+        rescue => e
+          Datadog.logger.warn("Error while sending runtime metric. Cause: #{e.class}: #{e.message}")
         end
 
         def default_metric_options
@@ -105,6 +111,14 @@ module Datadog
 
             # Add services dynamically because they might change during runtime.
             options[:tags].concat(service_tags) unless service_tags.nil?
+
+            # Add runtime-id dynamically because it might change during runtime.
+            options[:tags].concat(["runtime-id:#{Core::Environment::Identity.id}"]) if @runtime_id_enabled
+
+            # Add process tags when enabled
+            if @process_tags_enabled
+              options[:tags].concat(Core::Environment::Process.tags)
+            end
           end
         end
 
@@ -112,7 +126,9 @@ module Datadog
 
         attr_reader \
           :service_tags,
-          :services
+          :services,
+          :runtime_id_enabled,
+          :process_tags_enabled
 
         def compile_service_tags!
           @service_tags = services.to_a.collect do |service|
@@ -133,14 +149,14 @@ module Datadog
         end
 
         def to_metric_name(str)
-          str.downcase.gsub(/[-\s]/, '_')
+          str.downcase.gsub(/[-\s]/, "_")
         end
 
         def gauge_if_not_nil(metric_name, metric_value)
           gauge(metric_name, metric_value) if metric_value
         end
 
-        # rubocop:disable Metrics/MethodLength
+        # standard:disable Metrics/MethodLength
         def flush_yjit_stats
           # Only on Ruby >= 3.2
           try_flush do
@@ -181,10 +197,14 @@ module Datadog
                 Core::Runtime::Ext::Metrics::METRIC_YJIT_YJIT_ALLOC_SIZE,
                 Core::Environment::YJIT.yjit_alloc_size
               )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_RATIO_IN_YJIT,
+                Core::Environment::YJIT.ratio_in_yjit
+              )
             end
           end
         end
-        # rubocop:enable Metrics/MethodLength
+        # standard:enable Metrics/MethodLength
       end
     end
   end