ddtrace 1.10.1 → 1.11.0

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative '../negotiation'
+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 agent feature negotiation
+        module Negotiation
+          # Response from HTTP transport for agent feature negotiation
+          class Response
+            include Datadog::Transport::HTTP::Response
+            include Core::Transport::Negotiation::Response
+
+            def initialize(http_response, options = {})
+              super(http_response)
+
+              # TODO: transform endpoint hash in a better object for negotiation
+              # TODO: transform config in a better object, notably config has max_request_bytes
+              @version = options[:version]
+              @endpoints = options[:endpoints]
+              @config = options[:config]
+            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
+          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::Transport::HTTP::API::Endpoint
+              def initialize(path)
+                super(:get, path)
+              end
+
+              def call(env, &block)
+                # Query for response
+                http_response = super(env, &block)
+
+                # Process the response
+                body = JSON.parse(http_response.payload, symbolize_names: true) if http_response.ok?
+
+                # TODO: there should be more processing here to ensure a proper response_options
+                response_options = body.is_a?(Hash) ? body : {}
+
+                # Build and return a trace response
+                Negotiation::Response.new(http_response, response_options)
+              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
+  end
+end

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+require_relative '../environment/container'
+require_relative '../environment/ext'
+require_relative '../../../ddtrace/transport/ext'
+require_relative '../../../ddtrace/transport/http/adapters/net'
+require_relative '../../../ddtrace/transport/http/adapters/test'
+require_relative '../../../ddtrace/transport/http/adapters/unix_socket'
+
+# TODO: Improve negotiation to allow per endpoint selection
+#
+# Since endpoint negotiation happens at the `API::Spec` level there can not be
+# a mix of enpoints at various versions or versionless without describing all
+# the possible combinations as specs. See http/api.
+#
+# Below should be:
+# require_relative '../../../ddtrace/transport/http/api'
+require_relative 'http/api'
+
+# TODO: Decouple transport/http/builder
+#
+# See http/builder
+#
+# Below should be:
+# require_relative '../../../ddtrace/transport/http/builder'
+require_relative 'http/builder'
+
+# TODO: Decouple transport/http
+#
+# Because a new transport is required for every (API, Client, Transport)
+# triplet and endpoints cannot be negotiated independently, there can not be a
+# single `default` transport, but only endpoint-specific ones.
+
+module Datadog
+  module Core
+    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,
+        )
+
+        module_function
+
+        # Builds a new Transport::HTTP::Client
+        def new(klass, &block)
+          Builder.new(&block).to_transport(klass)
+        end
+
+        # 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
+        )
+          new(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
+
+            if agent_settings.deprecated_for_removal_transport_configuration_proc
+              agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
+            end
+
+            # Call block to apply any customization, if provided
+            yield(transport) if block_given?
+          end
+        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
+        )
+          new(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
+
+            if agent_settings.deprecated_for_removal_transport_configuration_proc
+              agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
+            end
+
+            # Call block to apply any customization, if provided
+            yield(transport) if block_given?
+          end
+        end
+
+        def default_headers
+          {
+            Datadog::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => '1',
+            Datadog::Transport::Ext::HTTP::HEADER_META_LANG => Datadog::Core::Environment::Ext::LANG,
+            Datadog::Transport::Ext::HTTP::HEADER_META_LANG_VERSION => Datadog::Core::Environment::Ext::LANG_VERSION,
+            Datadog::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER =>
+              Datadog::Core::Environment::Ext::LANG_INTERPRETER,
+            Datadog::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION => Datadog::Core::Environment::Ext::TRACER_VERSION
+          }.tap do |headers|
+            # Add container ID, if present.
+            container_id = Datadog::Core::Environment::Container.container_id
+            headers[Datadog::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+          end
+        end
+
+        def default_adapter
+          Datadog::Transport::Ext::HTTP::ADAPTER
+        end
+
+        def default_hostname(logger: Datadog.logger)
+          logger.warn(
+            'Deprecated for removal: Using #default_hostname for configuration is deprecated and will ' \
+            'be removed on a future ddtrace release.'
+          )
+
+          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.hostname
+        end
+
+        def default_port(logger: Datadog.logger)
+          logger.warn(
+            'Deprecated for removal: Using #default_hostname for configuration is deprecated and will ' \
+            'be removed on a future ddtrace release.'
+          )
+
+          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.port
+        end
+
+        def default_url(logger: Datadog.logger)
+          logger.warn(
+            'Deprecated for removal: Using #default_url for configuration is deprecated and will ' \
+            'be removed on a future ddtrace release.'
+          )
+
+          nil
+        end
+
+        # Add adapters to registry
+        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Net, Datadog::Transport::Ext::HTTP::ADAPTER)
+        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::Test, Datadog::Transport::Ext::Test::ADAPTER)
+        Builder::REGISTRY.set(Datadog::Transport::HTTP::Adapters::UnixSocket, Datadog::Transport::Ext::UnixSocket::ADAPTER)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../../ddtrace/transport/request'
+
+# TODO: Resolve conceptual conundrum
+#
+# It seems that through naming of `Transport::Traces::Transport` the transport
+# is specific to traces, which kind of matches the almost-generic-but-not-quite
+# implementation.
+#
+# This may be why `Transport::Traces::Transport` negotiates only considering
+# the `/vX/traces` path, but here we don't negotiate since we are at the root.
+#
+# In turn this means that API::Spec cannot describe multiple roots, or even
+# endpoints that happen to differ in version.
+#
+# Concepts such as Spec, API, Endpoint, and Transport should be clarified
+# before attempting further refactoring here, to attempt to resolve whether a
+# Transport - via its negotiated Spec - describes a function (implemented as
+# one or more endpoints) or whether the Spec describes the API towards the
+# agent as a whole, morphing through negotiation into the best available
+# version for each endpoint.
+
+module Datadog
+  module Core
+    module Transport
+      module Negotiation
+        # Negotiation request
+        class Request < Datadog::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
+            request = Request.new
+
+            @client.send_info_payload(request)
+          end
+
+          def current_api
+            @apis[HTTP::API::ROOT]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/compression.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'stringio'
 require 'zlib'
 

data/lib/datadog/core/utils/hash.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # Refinements for {Hash}.
+      module Hash
+        # This refinement ensures modern rubies are allowed to use newer,
+        # simpler, and more performant APIs.
+        module Refinement
+          # Introduced in Ruby 2.4
+          unless ::Hash.method_defined?(:compact)
+            refine ::Hash do
+              def compact
+                reject { |_k, v| v.nil? }
+              end
+            end
+          end
+
+          # Introduced in Ruby 2.4
+          unless ::Hash.method_defined?(:compact!)
+            refine ::Hash do
+              def compact!
+                reject! { |_k, v| v.nil? }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/object_set.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'sequence'
 
 module Datadog

data/lib/datadog/core/utils/safe_dup.rb

@@ -16,8 +16,26 @@ module Datadog
           using RefineNil
         end
 
-        def self.frozen_or_dup(v)
-          v.frozen? ? v : v.dup
+        # String#+@ was introduced in Ruby 2.3
+        if String.method_defined?(:+@) && String.method_defined?(:-@)
+          def self.frozen_or_dup(v)
+            # If the string is not frozen, the +(-v) will:
+            # - first create a frozen deduplicated copy with -v
+            # - then it will dup it more efficiently with +v
+            v.frozen? ? v : +(-v)
+          end
+
+          def self.frozen_dup(v)
+            -v if v
+          end
+        else
+          def self.frozen_or_dup(v)
+            v.frozen? ? v : v.dup
+          end
+
+          def self.frozen_dup(v)
+            v.frozen? ? v : v.dup.freeze
+          end
         end
       end
     end

data/lib/datadog/core/utils/sequence.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Utils

data/lib/datadog/core/utils/time.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Utils

data/lib/datadog/core/worker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     # Base class for work tasks

data/lib/datadog/core/workers/async.rb

@@ -11,6 +11,10 @@ module Datadog
           FORK_POLICY_RESTART = :restart
           SHUTDOWN_TIMEOUT = 1
 
+          # This single shared mutex is used to avoid concurrency issues during the
+          # initialization of per-instance lazy-initialized mutexes.
+          MUTEX_INIT = Mutex.new
+
           def self.included(base)
             base.prepend(PrependedMethods)
           end
@@ -86,7 +90,7 @@ module Datadog
             :result
 
           def mutex
-            @mutex ||= Mutex.new
+            @mutex || MUTEX_INIT.synchronize { @mutex ||= Mutex.new }
           end
 
           def after_fork
@@ -99,7 +103,7 @@ module Datadog
             :pid
 
           def mutex_after_fork
-            @mutex_after_fork ||= Mutex.new
+            @mutex_after_fork || MUTEX_INIT.synchronize { @mutex_after_fork ||= Mutex.new }
           end
 
           def worker

data/lib/datadog/core/workers/interval_loop.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Workers
@@ -8,6 +10,10 @@ module Datadog
         BACK_OFF_MAX = 5
         BASE_INTERVAL = 1
 
+        # This single shared mutex is used to avoid concurrency issues during the
+        # initialization of per-instance lazy-initialized mutexes.
+        MUTEX_INIT = Mutex.new
+
         def self.included(base)
           base.prepend(PrependedMethods)
         end
@@ -80,7 +86,7 @@ module Datadog
           :loop_base_interval
 
         def mutex
-          @mutex ||= Mutex.new
+          @mutex || MUTEX_INIT.synchronize { @mutex ||= Mutex.new }
         end
 
         private

data/lib/datadog/core/workers/queue.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Workers

data/lib/datadog/core/workers/runtime_metrics.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../runtime/metrics'
 
 require_relative '../worker'

data/lib/datadog/kit.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   # Datadog::Kit holds public-facing APIs for higher level user-facing
   # features, these features not belonging to a specific product. Contrary to

data/lib/datadog/opentracer/binary_propagator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module OpenTracer
     # OpenTracing propagator for Datadog::OpenTracer::Tracer

data/lib/datadog/opentracer/carrier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module OpenTracer
     # @public_api

data/lib/datadog/opentracer/global_tracer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module OpenTracer
     # Patch for OpenTracing module

data/lib/datadog/opentracer/propagator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module OpenTracer
     # OpenTracing propagator for Datadog::OpenTracer::Tracer

data/lib/datadog/opentracer/scope.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module OpenTracer
     # OpenTracing adapter for scope

data/lib/datadog/opentracer/scope_manager.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module OpenTracer
     # @public_api

data/lib/datadog/opentracer/span_context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module OpenTracer
     # OpenTracing adapter for SpanContext

data/lib/datadog/opentracer/span_context_factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module OpenTracer
     # Creates new Datadog::OpenTracer::SpanContext

data/lib/datadog/opentracer/thread_local_scope.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module OpenTracer
     # OpenTracing adapter for thread local scopes

data/lib/datadog/opentracer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'opentracing'
 require 'opentracing/carrier'
 require_relative 'tracing'

data/lib/datadog/profiling/backtrace_location.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Profiling
     # Entity class used to represent an entry in a stack trace.

data/lib/datadog/profiling/buffer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../core/buffer/thread_safe'
 require_relative '../core/utils/object_set'
 require_relative '../core/utils/string_table'

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -17,17 +17,33 @@ module Datadog
           recorder:,
           max_frames:,
           tracer:,
+          endpoint_collection_enabled:,
           gc_profiling_enabled:,
           allocation_counting_enabled:,
-          thread_context_collector: ThreadContext.new(recorder: recorder, max_frames: max_frames, tracer: tracer),
-          idle_sampling_helper: IdleSamplingHelper.new
+          thread_context_collector: ThreadContext.new(
+            recorder: recorder,
+            max_frames: max_frames,
+            tracer: tracer,
+            endpoint_collection_enabled: endpoint_collection_enabled,
+          ),
+          idle_sampling_helper: IdleSamplingHelper.new,
+          # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
+          # profiler overhead!
+          dynamic_sampling_rate_enabled: true
         )
+          unless dynamic_sampling_rate_enabled
+            Datadog.logger.warn(
+              'Profiling dynamic sampling rate disabled. This should only be used for testing, and will increase overhead!'
+            )
+          end
+
           self.class._native_initialize(
             self,
             thread_context_collector,
             gc_profiling_enabled,
             idle_sampling_helper,
-            allocation_counting_enabled
+            allocation_counting_enabled,
+            dynamic_sampling_rate_enabled,
           )
           @worker_thread = nil
           @failure_exception = nil

data/lib/datadog/profiling/collectors/dynamic_sampling_rate.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Profiling
     module Collectors