datadog 2.12.2 → 2.13.0

data/lib/datadog/di/transport/http/diagnostics.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../../../core/transport/http/api/instance'
+require_relative '../../../core/transport/http/api/spec'
 require_relative 'client'
 
 module Datadog
@@ -16,52 +18,24 @@ module Datadog
           end
 
           module API
-            module Instance
+            class Instance < Core::Transport::HTTP::API::Instance
               def send_diagnostics(env)
-                raise DiagnosticsNotSupportedError, spec unless spec.is_a?(Diagnostics::API::Spec)
+                raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new('diagnostics', self) unless spec.is_a?(Diagnostics::API::Spec)
 
                 spec.send_diagnostics(env) do |request_env|
                   call(request_env)
                 end
               end
-
-              class DiagnosticsNotSupportedError < StandardError
-                attr_reader :spec
-
-                def initialize(spec)
-                  super
-
-                  @spec = spec
-                end
-
-                def message
-                  'Diagnostics not supported for this API!'
-                end
-              end
             end
 
-            module Spec
+            class Spec < Core::Transport::HTTP::API::Spec
               attr_accessor :diagnostics
 
               def send_diagnostics(env, &block)
-                raise NoDiagnosticsEndpointDefinedError, self if diagnostics.nil?
+                raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('diagnostics', self) if diagnostics.nil?
 
                 diagnostics.call(env, &block)
               end
-
-              class NoDiagnosticsEndpointDefinedError < StandardError
-                attr_reader :spec
-
-                def initialize(spec)
-                  super
-
-                  @spec = spec
-                end
-
-                def message
-                  'No diagnostics endpoint is defined for API specification!'
-                end
-              end
             end
 
             # Endpoint for negotiation
@@ -79,7 +53,7 @@ module Datadog
                 )
                 env.form = {'event' => event_payload}
 
-                super(env, &block)
+                super
               end
             end
           end

data/lib/datadog/di/transport/http/input.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../../../core/transport/http/api/instance'
+require_relative '../../../core/transport/http/api/spec'
 require_relative 'client'
 
 module Datadog
@@ -16,52 +18,24 @@ module Datadog
           end
 
           module API
-            module Instance
+            class Instance < Core::Transport::HTTP::API::Instance
               def send_input(env)
-                raise InputNotSupportedError, spec unless spec.is_a?(Input::API::Spec)
+                raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new('input', self) unless spec.is_a?(Input::API::Spec)
 
                 spec.send_input(env) do |request_env|
                   call(request_env)
                 end
               end
-
-              class InputNotSupportedError < StandardError
-                attr_reader :spec
-
-                def initialize(spec)
-                  super
-
-                  @spec = spec
-                end
-
-                def message
-                  'Input not supported for this API!'
-                end
-              end
             end
 
-            module Spec
+            class Spec < Core::Transport::HTTP::API::Spec
               attr_accessor :input
 
               def send_input(env, &block)
-                raise NoInputEndpointDefinedError, self if input.nil?
+                raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('input', self) if input.nil?
 
                 input.call(env, &block)
               end
-
-              class NoInputEndpointDefinedError < StandardError
-                attr_reader :spec
-
-                def initialize(spec)
-                  super
-
-                  @spec = spec
-                end
-
-                def message
-                  'No input endpoint is defined for API specification!'
-                end
-              end
             end
 
             # Endpoint for negotiation
@@ -81,7 +55,7 @@ module Datadog
                 env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
                 env.body = env.request.parcel.data
 
-                super(env, &block)
+                super
               end
             end
           end

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

@@ -18,86 +18,44 @@ module Datadog
       module HTTP
         module_function
 
-        # Builds a new Transport::HTTP::Client
-        def new(klass, &block)
-          Core::Transport::HTTP.build(
-            api_instance_class: API::Instance, &block
-          ).to_transport(klass)
-        end
-
         # Builds a new Transport::HTTP::Client with default settings
         # Pass a block to override any settings.
         def diagnostics(
           agent_settings:,
-          **options
+          logger:,
+          api_version: nil,
+          headers: nil
         )
-          new(DI::Transport::Diagnostics::Transport) do |transport|
-            transport.adapter(agent_settings)
-            transport.headers default_headers
-
+          Core::Transport::HTTP.build(api_instance_class: Diagnostics::API::Instance,
+            logger: logger,
+            agent_settings: agent_settings, api_version: api_version, headers: headers) do |transport|
             apis = API.defaults
 
             transport.api API::DIAGNOSTICS, apis[API::DIAGNOSTICS]
 
-            # 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
-
             # Call block to apply any customization, if provided
             yield(transport) if block_given?
-          end
+          end.to_transport(DI::Transport::Diagnostics::Transport)
         end
 
         # Builds a new Transport::HTTP::Client with default settings
         # Pass a block to override any settings.
         def input(
           agent_settings:,
-          **options
+          logger:,
+          api_version: nil,
+          headers: nil
         )
-          new(DI::Transport::Input::Transport) do |transport|
-            transport.adapter(agent_settings)
-            transport.headers default_headers
-
+          Core::Transport::HTTP.build(api_instance_class: Input::API::Instance,
+            logger: logger,
+            agent_settings: agent_settings, api_version: api_version, headers: headers) do |transport|
             apis = API.defaults
 
             transport.api API::INPUT, apis[API::INPUT]
 
-            # 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
-
             # 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_LANG_INTERPRETER_VENDOR => Core::Environment::Ext::LANG_ENGINE,
-            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?
-            # Pretend that stats computation are already done by the client
-            if Datadog.configuration.appsec.standalone.enabled
-              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_STATS] = 'yes'
-            end
-          end
-        end
-
-        def default_adapter
-          Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
+          end.to_transport(DI::Transport::Input::Transport)
         end
       end
     end

data/lib/datadog/di/transport/input.rb

@@ -15,12 +15,13 @@ module Datadog
         end
 
         class Transport
-          attr_reader :client, :apis, :default_api, :current_api_id
+          attr_reader :client, :apis, :default_api, :current_api_id, :logger
 
-          def initialize(apis, default_api)
+          def initialize(apis, default_api, logger)
             @apis = apis
+            @logger = logger
 
-            @client = HTTP::Client.new(current_api)
+            @client = HTTP::Client.new(current_api, logger)
           end
 
           def current_api

data/lib/datadog/di/utils.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+# standard gets itself into an infinite loop over this
+# rubocop:disable Layout/SpaceAfterNot
+
 module Datadog
   module DI
     module Utils
@@ -135,3 +138,5 @@ module Datadog
     end
   end
 end
+
+# rubocop:enable Layout/SpaceAfterNot

data/lib/datadog/kit/appsec/events.rb

@@ -30,11 +30,14 @@ module Datadog
             set_trace_and_span_context('track_login_success', trace, span) do |active_trace, active_span|
               user_options = user.dup
               user_id = user_options.delete(:id)
+              user_login = user_options[:login] || others[:'usr.login'] || user_id
 
               raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
 
+              others[:'usr.login'] = user_login
               track(LOGIN_SUCCESS_EVENT, active_trace, active_span, **others)
 
+              user_options[:login] = user_login
               Kit::Identity.set_user(active_trace, active_span, id: user_id, **user_options)
             end
           end
@@ -55,6 +58,7 @@ module Datadog
           #   event information to attach to the trace.
           def track_login_failure(trace = nil, span = nil, user_exists:, user_id: nil, **others)
             set_trace_and_span_context('track_login_failure', trace, span) do |active_trace, active_span|
+              others[:'usr.login'] = user_id if user_id && !others.key?(:'usr.login')
               track(LOGIN_FAILURE_EVENT, active_trace, active_span, **others)
 
               active_span.set_tag('appsec.events.users.login.failure.usr.id', user_id) if user_id
@@ -80,11 +84,14 @@ module Datadog
             set_trace_and_span_context('track_signup', trace, span) do |active_trace, active_span|
               user_options = user.dup
               user_id = user_options.delete(:id)
+              user_login = user_options[:login] || others[:'usr.login'] || user_id
 
               raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
 
+              others[:'usr.login'] = user_login
               track(SIGNUP_EVENT, active_trace, active_span, **others)
 
+              user_options[:login] = user_login
               Kit::Identity.set_user(trace, id: user_id, **user_options)
             end
           end
@@ -131,6 +138,8 @@ module Datadog
                 active_trace.keep!
               end
             end
+
+            ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', event)
           end
 
           private

data/lib/datadog/kit/identity.rb

@@ -33,6 +33,7 @@ module Datadog
         # @param others [Hash<Symbol, String>] Additional free-form
         #   user information to attach to the trace.
         #
+        # rubocop:disable Metrics/AbcSize
         # rubocop:disable Metrics/CyclomaticComplexity
         # rubocop:disable Metrics/PerceivedComplexity
         def set_user(
@@ -67,11 +68,14 @@ module Datadog
             end
 
             if Datadog::AppSec.active_context
-              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id)
+              active_span.set_tag('_dd.appsec.user.collection_mode', 'sdk')
+
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id, others[:login])
               ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
         # rubocop:enable Metrics/PerceivedComplexity
         # rubocop:enable Metrics/CyclomaticComplexity
 

data/lib/datadog/opentelemetry/api/baggage.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'trace/span'
+require_relative '../../tracing/trace_operation'
+require_relative '../trace'
+
+module Datadog
+  module OpenTelemetry
+    module API
+      # The Baggage module provides an implementation of the OpenTelemetry Baggage API.
+      #
+      # Baggage is a set of name/value pairs describing user-defined properties that can be
+      # propagated through a distributed trace. This implementation follows the W3C Baggage
+      # specification and the OpenTelemetry Baggage API.
+      #
+      # @see https://www.w3.org/TR/baggage/
+      # @see https://opentelemetry.io/docs/specs/otel/baggage/api/
+      module Baggage
+        def initialize(trace: nil)
+          @trace = trace
+        end
+
+        # Returns a new context with empty baggage
+        #
+        # @param [optional Context] context Context to clear baggage from. Defaults
+        # to ::OpenTelemetry::Context.current
+        # @return [Context]
+        def clear(context: ::OpenTelemetry::Context.current)
+          context.ensure_trace.baggage.clear
+          context
+        end
+
+        # Returns the corresponding value for key
+        #
+        # @param [String] key The lookup key
+        # @param [optional Context] context The context from which to retrieve
+        # the key. Defaults to ::OpenTelemetry::Context.current
+        # @return [String, nil]
+        def value(key, context: ::OpenTelemetry::Context.current)
+          trace = context.ensure_trace
+          return nil if trace.nil?
+
+          trace.baggage && trace.baggage[key]
+        end
+
+        # Returns all baggage values
+        #
+        # @param [optional Context] context The context from which to retrieve
+        # the baggage. Defaults to ::OpenTelemetry::Context.current
+        # @return [Hash<String, String>]
+        def values(context: ::OpenTelemetry::Context.current)
+          trace = context.ensure_trace
+          return {} if trace.nil?
+
+          trace.baggage ? trace.baggage.dup : {}
+        end
+
+        # Returns a new context with new key-value pair
+        #
+        # @param [String] key The key to store this value under
+        # @param [String] value String value to be stored under key
+        # @param [optional String] metadata This is here to store properties
+        # received from other W3C Baggage implementations but is not exposed in
+        # OpenTelemetry. This is considered private API and not for use by
+        # end-users.
+        # @param [optional Context] context The context to update with new
+        # value. Defaults to ::OpenTelemetry::Context.current
+        # @return [Context]
+        def set_value(key, value, metadata: nil, context: ::OpenTelemetry::Context.current)
+          # Delegate to the context to set the value because an active trace is not guaranteed
+          # set_values handles this logic
+          context.set_values({ ::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY) => { key => value } })
+        end
+
+        # Returns a new context with value at key removed
+        #
+        # @param [String] key The key to remove
+        # @param [optional Context] context The context to remove baggage
+        # from. Defaults to ::OpenTelemetry::Context.current
+        # @return [Context]
+        def remove_value(key, context: ::OpenTelemetry::Context.current)
+          # Delegate to the context to remove the value because an active trace is not guaranteed
+          # set_values handles this logic
+          context.set_values({ Context::BAGGAGE_REMOVE_KEY => key })
+        end
+        ::OpenTelemetry::Baggage.singleton_class.prepend(self)
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/api/baggage.rbs

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module API
+      module Baggage
+        def initialize: (?trace: Datadog::Tracing::TraceOperation?) -> void
+
+        # Returns a new context with empty baggage
+        def clear: (?context: OpenTelemetry::Context) -> OpenTelemetry::Context
+
+        # Returns the corresponding value for key
+        def value: (String key, ?context: OpenTelemetry::Context) -> String?
+
+        # Returns all baggage values
+        def values: (?context: OpenTelemetry::Context) -> Hash[String, String]
+
+        # Returns a new context with key-value pair
+        def set_value: (String key, String value, ?metadata: String?, ?context: OpenTelemetry::Context) -> OpenTelemetry::Context
+
+        # Returns a new context with value at key removed
+        def remove_value: (String key, ?context: OpenTelemetry::Context) -> OpenTelemetry::Context
+      end
+    end
+  end
+end 

data/lib/datadog/opentelemetry/api/context.rb

@@ -21,11 +21,13 @@ module Datadog
       module Context
         CURRENT_SPAN_KEY = ::OpenTelemetry::Trace.const_get(:CURRENT_SPAN_KEY)
         private_constant :CURRENT_SPAN_KEY
+        BAGGAGE_REMOVE_KEY = Object.new # sentinel object to indicate the deletion of a value in baggage
 
-        def initialize(entries, trace: nil)
+        def initialize(entries, trace: nil, baggage: nil)
           @trace = trace || ::Datadog::Tracing.send(:tracer).send(:start_trace)
           @trace.otel_values.merge!(entries) if entries
           @trace.otel_context ||= self
+          @trace.baggage = baggage if baggage
         end
 
         # Because Context can be reused, we have to make sure we have
@@ -79,8 +81,20 @@ module Datadog
           end
 
           existing_values = @trace && @trace.otel_values || {}
+          existing_baggage = @trace && @trace.baggage || {}
 
-          ::OpenTelemetry::Context.new(existing_values.merge(values), trace: trace)
+          # Retrieve the baggage removal sentinel and remove it from the values hash
+          existing_baggage.delete(values[BAGGAGE_REMOVE_KEY]) if values.key?(BAGGAGE_REMOVE_KEY)
+
+          # If the values hash contains a BAGGAGE_KEY, merge its contents with existing baggage
+          # Otherwise, keep the existing baggage unchanged
+          new_baggage = if values.key?(::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY))
+                          existing_baggage.merge(values[::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY)])
+                        else
+                          existing_baggage
+                        end
+
+          ::OpenTelemetry::Context.new(existing_values.merge(values), trace: trace, baggage: new_baggage)
         end
 
         # The Datadog {TraceOperation} associated with this {Context}.

data/lib/datadog/opentelemetry/sdk/trace/span.rb

@@ -45,7 +45,7 @@ module Datadog
         def add_attributes(attributes)
           res = super
           # Attributes can get dropped or their values truncated by `super`
-          attributes.each { |key, _| datadog_set_attribute(key) }
+          attributes.each_key { |key| datadog_set_attribute(key) }
           res
         end
 

data/lib/datadog/opentelemetry.rb

@@ -13,6 +13,7 @@ require_relative 'tracing'
 require_relative 'tracing/contrib'
 
 require_relative 'opentelemetry/api/context'
+require_relative 'opentelemetry/api/baggage'
 
 # DEV: Should this be a Contrib integration, that depends on the `opentelemetry-sdk`
 # DEV: and checks for compatibility?
@@ -29,7 +30,7 @@ module Datadog
 
     # Use `Datadog.logger` as the default logger
     def logger
-      @logger ||= ::Datadog.logger
+      ::Datadog.logger
     end
 
     ::OpenTelemetry.singleton_class.prepend(self)

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

@@ -60,7 +60,7 @@ module Datadog
 
         def inspect
           # Compose Ruby's default inspect with our custom inspect for the native parts
-          result = super()
+          result = super
           result[-1] = "#{self.class._native_inspect(self)}>"
           result
         end

data/lib/datadog/profiling.rb

@@ -78,8 +78,11 @@ module Datadog
     end
 
     private_class_method def self.replace_noop_allocation_count
-      def self.allocation_count # rubocop:disable Lint/NestedMethodDefinition (On purpose!)
-        Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
+      class << self
+        remove_method :allocation_count
+        def allocation_count
+          Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
+        end
       end
     end
 

data/lib/datadog/tracing/component.rb

@@ -6,6 +6,7 @@ require_relative 'sync_writer'
 require_relative 'sampling/span/rule_parser'
 require_relative 'sampling/span/sampler'
 require_relative 'diagnostics/environment_logger'
+require_relative 'contrib/component'
 
 module Datadog
   module Tracing
@@ -74,18 +75,11 @@ module Datadog
           return sampler
         end
 
-        # AppSec events are sent to the backend using traces.
-        # Standalone ASM billing means that we don't want to charge clients for APM traces,
-        # so we want to send the minimum amount of traces possible (idealy only traces that contains security events),
-        # but for features such as API Security, we need to send at least one trace per minute,
-        # to keep the service alive on the backend side.
-        if settings.appsec.standalone.enabled
-          post_sampler = Tracing::Sampling::RuleSampler.new(
-            [Tracing::Sampling::SimpleRule.new(sample_rate: 1.0)],
-            rate_limiter: Datadog::Core::TokenBucket.new(1.0 / 60, 1.0),
-            default_sample_rate: 1.0 / 60
-          )
-        end
+        # APM Disablement means that we don't want to send traces that only contains APM data.
+        # Other products can then put the sampling priority to MANUAL_KEEP if they want to keep traces.
+        # (e.g.: AppSec will MANUAL_KEEP traces with AppSec events) and clients will be billed only for those traces.
+        # But to keep the service alive on the backend side, we need to send one trace per minute.
+        post_sampler = build_rate_limit_post_sampler(seconds: 60) unless settings.apm.tracing.enabled
 
         # Sampling rules are provided
         if (rules = settings.tracing.sampling.rules)
@@ -197,6 +191,15 @@ module Datadog
         end
       end
 
+      # Build a post-sampler that limits the rate of traces to one per `seconds`.
+      # E.g.: `build_rate_limit_post_sampler(seconds: 60)` will limit the rate to one trace per minute.
+      def build_rate_limit_post_sampler(seconds:)
+        Tracing::Sampling::RuleSampler.new(
+          rate_limiter: Datadog::Core::TokenBucket.new(1.0 / seconds, 1.0),
+          default_sample_rate: 1.0
+        )
+      end
+
       def build_test_mode_trace_flush(settings)
         # If context flush behavior is provided, use it instead.
         settings.tracing.test_mode.trace_flush || build_trace_flush(settings)

data/lib/datadog/tracing/configuration/ext.rb

@@ -12,6 +12,7 @@ module Datadog
         ENV_OTEL_TRACES_EXPORTER = 'OTEL_TRACES_EXPORTER'
         ENV_HEADER_TAGS = 'DD_TRACE_HEADER_TAGS'
         ENV_TRACE_ID_128_BIT_GENERATION_ENABLED = 'DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED'
+        ENV_NATIVE_SPAN_EVENTS = 'DD_TRACE_NATIVE_SPAN_EVENTS'
 
         # @public_api
         module SpanAttributeSchema
@@ -41,8 +42,13 @@ module Datadog
           # W3C Trace Context
           PROPAGATION_STYLE_TRACE_CONTEXT = 'tracecontext'
 
+          # W3C Baggage
+          # @see https://www.w3.org/TR/baggage/
+          PROPAGATION_STYLE_BAGGAGE = 'baggage'
+
           PROPAGATION_STYLE_SUPPORTED = [PROPAGATION_STYLE_DATADOG, PROPAGATION_STYLE_B3_MULTI_HEADER,
-                                         PROPAGATION_STYLE_B3_SINGLE_HEADER, PROPAGATION_STYLE_TRACE_CONTEXT].freeze
+                                         PROPAGATION_STYLE_B3_SINGLE_HEADER, PROPAGATION_STYLE_TRACE_CONTEXT,
+                                         PROPAGATION_STYLE_BAGGAGE].freeze
 
           # Sets both extract and inject propagation style tho the provided value.
           # Has lower precedence than `DD_TRACE_PROPAGATION_STYLE_INJECT` or