datadog 2.12.1 → 2.13.0

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

@@ -7,6 +7,23 @@ module Datadog
         module API
           # An API configured with adapter and routes
           class Instance
+            # Raised when an endpoint is invoked on an API that is not the
+            # of expected API class for that endpoint.
+            class EndpointNotSupportedError < StandardError
+              attr_reader :spec, :endpoint_name
+
+              def initialize(endpoint_name, spec)
+                @spec = spec
+                @endpoint_name = endpoint_name
+
+                super(message)
+              end
+
+              def message
+                "#{endpoint_name} not supported for this API!"
+              end
+            end
+
             attr_reader \
               :adapter,
               :headers,

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

@@ -8,6 +8,23 @@ module Datadog
           # Specification for an HTTP API
           # Defines behaviors without specific configuration details.
           class Spec
+            # Raised when an endpoint is invoked on an API that did not
+            # define that endpoint.
+            class EndpointNotDefinedError < StandardError
+              attr_reader :spec, :endpoint_name
+
+              def initialize(endpoint_name, spec)
+                @spec = spec
+                @endpoint_name = endpoint_name
+
+                super(message)
+              end
+
+              def message
+                "No #{endpoint_name} endpoint is defined for API specification!"
+              end
+            end
+
             def initialize
               yield(self) if block_given?
             end

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

@@ -18,9 +18,10 @@ module Datadog
             :api_options,
             :default_adapter,
             :default_api,
-            :default_headers
+            :default_headers,
+            :logger
 
-          def initialize(api_instance_class:)
+          def initialize(api_instance_class:, logger:)
             # Global settings
             @default_adapter = nil
             @default_headers = {}
@@ -33,6 +34,7 @@ module Datadog
             @api_options = {}
 
             @api_instance_class = api_instance_class
+            @logger = logger
 
             yield(self) if block_given?
           end
@@ -86,7 +88,7 @@ module Datadog
           def to_transport(klass)
             raise NoDefaultApiError if @default_api.nil?
 
-            klass.new(to_api_instances, @default_api)
+            klass.new(to_api_instances, @default_api, logger)
           end
 
           def to_api_instances

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

@@ -29,8 +29,45 @@ module Datadog
         # Helper function that delegates to Builder.new
         # but is under HTTP namespace so that client code requires this file
         # to get the adapters configured, and not the builder directly.
-        def build(api_instance_class:, &block)
-          Builder.new(api_instance_class: api_instance_class, &block)
+        def build(api_instance_class:, agent_settings:, logger:, api_version: nil, headers: nil, &block)
+          Builder.new(api_instance_class: api_instance_class, logger: logger) do |transport|
+            transport.adapter(agent_settings)
+            transport.headers(default_headers)
+
+            # The caller must define APIs before we set the default API.
+            yield transport
+
+            # Apply any settings given by options
+            transport.default_api = api_version if api_version
+            transport.headers(headers) if headers
+          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.
+            if (container_id = Datadog::Core::Environment::Container.container_id)
+              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id
+            end
+            # TODO: inject configuration rather than reading from global here
+            unless Datadog.configuration.apm.tracing.enabled
+              # Sending this header to the agent will disable metrics computation (and billing) on the agent side
+              # by pretending it has already been done on the library side.
+              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_STATS] = 'yes'
+            end
+          end
         end
       end
     end

data/lib/datadog/di/component.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../core'
-
 module Datadog
   module DI
     # Component for dynamic instrumentation.

data/lib/datadog/di/probe_notifier_worker.rb

@@ -171,7 +171,7 @@ module Datadog
       attr_reader :last_sent
 
       def status_transport
-        @status_transport ||= DI::Transport::HTTP.diagnostics(agent_settings: agent_settings)
+        @status_transport ||= DI::Transport::HTTP.diagnostics(agent_settings: agent_settings, logger: logger)
       end
 
       def do_send_status(batch)
@@ -179,7 +179,7 @@ module Datadog
       end
 
       def snapshot_transport
-        @snapshot_transport ||= DI::Transport::HTTP.input(agent_settings: agent_settings)
+        @snapshot_transport ||= DI::Transport::HTTP.input(agent_settings: agent_settings, logger: logger)
       end
 
       def do_send_snapshot(batch)
@@ -227,20 +227,6 @@ module Datadog
           start
         end
 
-        # Determine how much longer the worker thread should sleep
-        # so as not to send in less than min send interval since the last send.
-        # Important: this method must be called when @lock is held.
-        #
-        # Returns the time remaining to sleep.
-        def set_sleep_remaining
-          now = Core::Utils::Time.get_time
-          @sleep_remaining = if last_sent
-            [last_sent + min_send_interval - now, 0].max
-          else
-            0
-          end
-        end
-
         public "add_#{event_type}"
 
         # Sends pending probe statuses or snapshots.
@@ -288,6 +274,20 @@ module Datadog
         end
       end
 
+      # Determine how much longer the worker thread should sleep
+      # so as not to send in less than min send interval since the last send.
+      # Important: this method must be called when @lock is held.
+      #
+      # Returns the time remaining to sleep.
+      def set_sleep_remaining
+        now = Core::Utils::Time.get_time
+        @sleep_remaining = if last_sent
+          [last_sent + min_send_interval - now, 0].max
+        else
+          0
+        end
+      end
+
       def maybe_send
         rv = maybe_send_status
         maybe_send_snapshot || rv

data/lib/datadog/di/transport/diagnostics.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/transport/http/api.rb

@@ -21,13 +21,13 @@ module Datadog
 
           def defaults
             Datadog::Core::Transport::HTTP::API::Map[
-              DIAGNOSTICS => Spec.new do |s|
+              DIAGNOSTICS => Diagnostics::API::Spec.new do |s|
                 s.diagnostics = Diagnostics::API::Endpoint.new(
                   '/debugger/v1/diagnostics',
                   Core::Encoding::JSONEncoder,
                 )
               end,
-              INPUT => Spec.new do |s|
+              INPUT => Input::API::Spec.new do |s|
                 s.input = Input::API::Endpoint.new(
                   '/debugger/v1/input',
                   Core::Encoding::JSONEncoder,
@@ -35,16 +35,6 @@ module Datadog
               end,
             ]
           end
-
-          class Instance < Core::Transport::HTTP::API::Instance
-            include Diagnostics::API::Instance
-            include Input::API::Instance
-          end
-
-          class Spec < Core::Transport::HTTP::API::Spec
-            include Diagnostics::API::Spec
-            include Input::API::Spec
-          end
         end
       end
     end

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

@@ -14,10 +14,11 @@ module Datadog
       module HTTP
         # Routes, encodes, and sends DI data to the trace agent via HTTP.
         class Client
-          attr_reader :api
+          attr_reader :api, :logger
 
-          def initialize(api)
+          def initialize(api, logger)
             @api = api
+            @logger = logger
           end
 
           def send_request(request, &block)
@@ -31,7 +32,7 @@ module Datadog
               "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
                 "Location: #{Array(e.backtrace).first}"
 
-            Datadog.logger.debug(message)
+            logger.debug(message)
 
             Datadog::Core::Transport::InternalErrorResponse.new(e)
           end

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