datadog 2.12.0 → 2.22.0

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,55 +18,26 @@ 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
             class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
               HEADER_CONTENT_TYPE = 'Content-Type'
 
@@ -80,8 +53,18 @@ module Datadog
                 # Encode body & type
                 env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
                 env.body = env.request.parcel.data
-
-                super(env, &block)
+                env.query = {
+                  # DEV: In theory we could serialize the tags here
+                  # rather than requiring them to be pre-serialized.
+                  # In practice the tags should be relatively static
+                  # (they would change when process forks, and hostname
+                  # could change at any time but probably we should ignore
+                  # those changes), therefore serializing the tags
+                  # every time would be wasteful.
+                  ddtags: env.request.serialized_tags,
+                }
+
+                super
               end
             end
           end

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

@@ -1,18 +1,9 @@
 # frozen_string_literal: true
 
-require 'uri'
-
-require_relative '../../core/environment/container'
-require_relative '../../core/environment/ext'
-require_relative '../../core/transport/ext'
-require_relative '../../core/transport/http/adapters/net'
-require_relative '../../core/transport/http/adapters/test'
-require_relative '../../core/transport/http/adapters/unix_socket'
 require_relative 'diagnostics'
 require_relative 'input'
 require_relative 'http/api'
-require_relative '../../core/transport/http/builder'
-require_relative '../../../datadog/version'
+require_relative '../../core/transport/http'
 
 module Datadog
   module DI
@@ -21,98 +12,45 @@ module Datadog
       module HTTP
         module_function
 
-        # Builds a new Transport::HTTP::Client
-        def new(klass, &block)
-          Core::Transport::HTTP::Builder.new(
-            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.to_transport(DI::Transport::Input::Transport)
         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
-
-        # Add adapters to registry
-        Datadog::Core::Transport::HTTP::Builder::REGISTRY.set(
-          Datadog::Core::Transport::HTTP::Adapters::Net,
-          Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-        )
-        Datadog::Core::Transport::HTTP::Builder::REGISTRY.set(Datadog::Core::Transport::HTTP::Adapters::Test, Datadog::Core::Transport::Ext::Test::ADAPTER)
-        Datadog::Core::Transport::HTTP::Builder::REGISTRY.set(
-          Datadog::Core::Transport::HTTP::Adapters::UnixSocket,
-          Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
-        )
       end
     end
   end

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

@@ -12,25 +12,34 @@ module Datadog
         end
 
         class Request < Datadog::Core::Transport::Request
+          attr_reader :serialized_tags
+
+          def initialize(parcel, serialized_tags)
+            super(parcel)
+
+            @serialized_tags = serialized_tags
+          end
         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: logger)
           end
 
           def current_api
             @apis[HTTP::API::INPUT]
           end
 
-          def send_input(payload)
+          def send_input(payload, tags)
             json = JSON.dump(payload)
             parcel = EncodedParcel.new(json)
-            request = Request.new(parcel)
+            serialized_tags = Core::TagBuilder.serialize_tags(tags)
+            request = Request.new(parcel, serialized_tags)
 
             response = @client.send_input_payload(request)
             unless response.ok?

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/di.rb

@@ -1,24 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'di/logger'
-require_relative 'di/base'
-require_relative 'di/error'
-require_relative 'di/code_tracker'
-require_relative 'di/component'
 require_relative 'di/configuration'
 require_relative 'di/extensions'
-require_relative 'di/instrumenter'
-require_relative 'di/probe'
-require_relative 'di/probe_builder'
-require_relative 'di/probe_manager'
-require_relative 'di/probe_notification_builder'
-require_relative 'di/probe_notifier_worker'
-require_relative 'di/redactor'
 require_relative 'di/remote'
-require_relative 'di/serializer'
-#require_relative 'di/transport'
-require_relative 'di/transport/http'
-require_relative 'di/utils'
 
 module Datadog
   # Namespace for Datadog dynamic instrumentation.
@@ -35,7 +19,6 @@ module Datadog
     Extensions.activate!
 
     class << self
-
       # This method is called from DI Remote handler to issue DI operations
       # to the probe manager (add or remove probes).
       #
@@ -51,20 +34,3 @@ module Datadog
     end
   end
 end
-
-if %w(1 true).include?(ENV['DD_DYNAMIC_INSTRUMENTATION_ENABLED']) # steep:ignore
-  # For initial release of Dynamic Instrumentation, activate code tracking
-  # only if DI is explicitly requested in the environment.
-  # Code tracking is required for line probes to work; see the comments
-  # above for the implementation of the method.
-  #
-  # If DI is enabled programmatically, the application can (and must,
-  # for line probes to work) activate tracking in an initializer.
-  # We seem to have Datadog.logger here already
-  Datadog.logger.debug("di: activating code tracking")
-  Datadog::DI.activate_tracking
-end
-
-require_relative 'di/contrib'
-
-Datadog::DI::Contrib.load_now_or_later

data/lib/datadog/error_tracking/collector.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module ErrorTracking
+    # The Collector is in charge, for a SpanOperation of storing the span events
+    # created when an error is handled. Each SpanOperation has a Collector as soon
+    # as a span event is created and the Collector has the same life time as the SpanOp.
+    #
+    # If an error is handled then rethrown, the SpanEvent corresponding to the error
+    # will be deleted. That is why we do not add directly the SpanEvent to the SpanOp.
+    #
+    # @api private
+    class Collector
+      SPAN_EVENTS_LIMIT = 100
+      LOCK = Mutex.new
+      # Proc called when the span_operation :after_stop event is published
+      def self.after_stop
+        @after_stop ||= proc do |span_op, error|
+          # if this proc is called, we are sure that span_op has a collector
+          collector = span_op.get_collector_or_initialize
+          # if an error exited the scope of the span, we delete the corresponding SpanEvent.
+          collector.on_error(span_op, error) if error
+
+          span_events = collector.span_events
+          span_op.span_events.concat(span_events)
+        end
+      end
+
+      def initialize
+        @span_event_per_error = {}
+      end
+
+      def add_span_event(span_op, span_event, error)
+        # When this is the first time we add a span event for a span,
+        # we suscribe to the :after_stop event
+        if @span_event_per_error.empty?
+          events = span_op.send(:events)
+          events.after_stop.subscribe(&self.class.after_stop)
+
+          # This tag is used by the Error Tracking product to report
+          # the error in Error Tracking
+          span_op.set_tag(Ext::SPAN_EVENTS_HAS_EXCEPTION, true)
+        end
+        # Set a limit to the number of span event we can store per SpanOp
+        # If an error has been handled several times in the same span we can still
+        # modify the event (even if the capacity is reached) in order to report
+        # the information of the last rescue
+        if @span_event_per_error.key?(error) || @span_event_per_error.length < SPAN_EVENTS_LIMIT
+          @span_event_per_error[error] = span_event
+        end
+      end
+
+      if RUBY_VERSION >= Ext::RUBY_VERSION_WITH_RESCUE_EVENT
+        # Starting from ruby3.3, as we are listening to :rescue event,
+        # we just want to remove the span event if the error was
+        # previously handled
+        def on_error(_span_op, error)
+          @span_event_per_error.delete(error)
+        end
+      else
+        # Up to ruby3.2, we are listening to :raise event. We need to ensure
+        # that an error exiting the scope of a span is not handled in a parent span.
+        # This function will propagate the span event to the parent span. If the
+        # error is not handled in the parent span, it will be deleted by design.
+        def on_error(span_op, error)
+          return unless @span_event_per_error.key?(error)
+
+          unless span_op.root?
+            parent = span_op.send(:parent)
+            LOCK.synchronize do
+              parent_collector = parent.get_collector_or_initialize { Collector.new }
+              parent_collector.add_span_event(parent, @span_event_per_error[error], error)
+            end
+          end
+
+          @span_event_per_error.delete(error)
+        end
+      end
+
+      def span_events
+        @span_event_per_error.values
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking/component.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'collector'
+require_relative 'filters'
+
+module Datadog
+  module ErrorTracking
+    # Component for Error Tracking.
+    #
+    # Only one instance of the Component should ever be active.
+    #
+    # The component instance records every handled exceptions from the configured scopes
+    # (user, third_party packages, specified files or everything).
+    class Component
+      LOCK = Mutex.new
+
+      class << self
+        def build(settings, tracer, logger)
+          return if !settings.respond_to?(:error_tracking) || (settings.error_tracking.handled_errors.nil? &&
+            settings.error_tracking.handled_errors_include.empty?)
+
+          return unless environment_supported?(logger)
+
+          new(
+            tracer: tracer,
+            handled_errors: settings.error_tracking.handled_errors,
+            handled_errors_include: settings.error_tracking.handled_errors_include,
+          ).tap(&:start)
+        end
+
+        def environment_supported?(logger)
+          if RUBY_ENGINE != 'ruby'
+            logger.warn("error tracking: cannot enable error tracking: MRI is required, but running on #{RUBY_ENGINE}")
+            false
+          elsif RUBY_VERSION < '2.7'
+            logger.warn(
+              "error tracking: cannot enable error tracking: Ruby 2.7+ is required, but running
+              on #{RUBY_VERSION}"
+            )
+            false
+          else
+            true
+          end
+        end
+      end
+
+      def initialize(tracer:, handled_errors:, handled_errors_include:)
+        @tracer = tracer
+
+        # Hash containing the paths to the instrumented files
+        @instrumented_files = Set.new unless handled_errors_include.empty?
+        # Array containing file paths, file names and gems names to instrument.
+        # This is coming from the DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE env variable
+        @handled_errors_include = handled_errors_include
+
+        # Filter function is used to filter out the exception
+        # we do not want to report. For instance exception from gems.
+        @filter_function = Filters.generate_filter(handled_errors, @instrumented_files)
+
+        # :rescue event was added in Ruby 3.3
+        #
+        # Before Ruby3.3 the TracePoint listen for :raise events.
+        # If an error is not handled, we will delete the according
+        # span event in the collector.
+        event = (RUBY_VERSION >= '3.3') ? :rescue : :raise
+
+        # This TracePoint is in charge of capturing the handled exceptions
+        # and of adding the corresponding span events to the collector
+        @handled_exc_tracker = create_exc_tracker_trace_point(event)
+
+        if @instrumented_files
+          # The only thing we know about the handled errors is the path of the file
+          # in which the error was rescued. Therefore, we need to retrieve the path
+          # of the files the user want to instrument. This TracePoint is used for that
+          # purpose
+          @include_path_getter = create_script_compiled_trace_point
+        end
+      end
+
+      def create_exc_tracker_trace_point(event)
+        TracePoint.new(event) do |tp|
+          active_span = @tracer.active_span
+          if active_span
+            raised_exception = tp.raised_exception
+            # Note that in 3.2, this will give the path of where the error was raised
+            # which may cause the handled_error_include env variable to malfunction.
+            rescue_file_path = tp.path
+            if @filter_function.call(rescue_file_path)
+              span_event = generate_span_event(raised_exception)
+              LOCK.synchronize do
+                collector = active_span.get_collector_or_initialize { Collector.new }
+                collector.add_span_event(active_span, span_event, raised_exception)
+              end
+            end
+          end
+        end
+      end
+
+      def create_script_compiled_trace_point
+        TracePoint.new(:script_compiled) do |tp|
+          next if tp.eval_script
+
+          path = tp.instruction_sequence.path
+          next if path.nil?
+
+          @handled_errors_include.each do |file_to_instr|
+            # The user can provide either
+            # - absolute_path starting with '/'. In that case the path of the file
+            #   should begin with file_to_instr
+            # - a relative_path starting with './'. In that case, we extend the path
+            #   and it is the same as above
+            # - otherwise we just check if the name provided is in the path and is
+            #   either the name of a folder or of a ruby file.
+            regex =
+              if file_to_instr.start_with?('/')
+                %r{\A#{Regexp.escape(file_to_instr)}(?:/|\.rb\z|\z)}
+              elsif file_to_instr.start_with?('./')
+                abs_path = File.expand_path(file_to_instr)
+                %r{\A#{Regexp.escape(abs_path)}(?:/|\.rb\z|\z)}
+              else
+                %r{/#{Regexp.escape(file_to_instr)}(?:/|\.rb\z|\z)}
+              end
+
+            add_instrumented_file(path) if path.match?(regex)
+          end
+        end
+      end
+
+      # Starts the TracePoints.
+      #
+      # Enables the script_compiled TracePoint if handled_errors_include is not empty.
+      def start
+        @handled_exc_tracker.enable
+        @include_path_getter&.enable
+      end
+
+      # Shuts down error tracker.
+      #
+      # Disables the TracePoints.
+      def shutdown!
+        @handled_exc_tracker.disable
+        @include_path_getter&.disable
+      end
+
+      private
+
+      # Generates a span event from the exception info.
+      #
+      # The event follows the otel semantics.
+      # https://opentelemetry.io/docs/specs/otel/trace/exceptions/
+      def generate_span_event(exception)
+        formatted_exception = Datadog::Core::Error.build_from(exception)
+        attributes = {
+          'exception.type' => formatted_exception.type,
+          'exception.message' => formatted_exception.message,
+          'exception.stacktrace' => formatted_exception.backtrace
+        }
+        Datadog::Tracing::SpanEvent.new('exception', attributes: attributes)
+      end
+
+      def add_instrumented_file(file_path)
+        @instrumented_files&.add(file_path)
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking/configuration/settings.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../ext'
+
+module Datadog
+  module ErrorTracking
+    module Configuration
+      # Settings
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            # Error Tracking specific configurations.
+            # @public_api
+            settings :error_tracking do
+              # Enable automatic reporting of handled errors and defines the scope
+              # for which to report errors: user code, gems, or both. Possible
+              # values are: all | user | third_party.
+              #
+              # @default 'DD_ERROR_TRACKING_HANDLED_ERRORS' environment variable, otherwise `nil`
+              # @return [String, nil]
+              option :handled_errors do |o|
+                o.type :string, nilable: true
+                o.default Ext::DEFAULT_HANDLED_ERRORS
+                o.env Ext::ENV_HANDLED_ERRORS
+                o.setter do |value|
+                  next value if Ext::VALID_HANDLED_ERRORS.include?(value)
+
+                  unless value.nil?
+                    Datadog.logger.warn(
+                      "Invalid handled errors scope: #{value}. " \
+                      "Supported values are: #{Ext::VALID_HANDLED_ERRORS.join(" | ")}. " \
+                      'Deactivating the feature.'
+                    )
+                  end
+
+                  Ext::DEFAULT_HANDLED_ERRORS
+                end
+              end
+
+              # Enable automatic reporting of handled errors and specify what files should be
+              # instrumented. The value is a list of comma separated paths, filenames or gem names.
+              # The paths can be absolute, starting with '/' or relative to directory in which the program
+              # is launched, starting with './'.
+              #
+              # @default 'DD_ERROR_TRACKING_HANDLED_ERRORS_MODULES' environment variable, otherwise `nil`
+              # @return [String, nil]
+              option :handled_errors_include do |o|
+                o.type :array
+                o.default []
+                o.env Ext::ENV_HANDLED_ERRORS_INCLUDE
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/error_tracking/configuration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Datadog
+  module ErrorTracking
+    # Configuration for ErrorTracking
+    module Configuration
+    end
+  end
+end
+
+require_relative 'configuration/settings'

data/lib/datadog/error_tracking/ext.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Datadog
+  module ErrorTracking
+    # Error Tracking constants
+    module Ext
+      ENV_HANDLED_ERRORS = 'DD_ERROR_TRACKING_HANDLED_ERRORS'
+      ENV_HANDLED_ERRORS_INCLUDE = 'DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE'
+      HANDLED_ERRORS_ALL = 'all'
+      HANDLED_ERRORS_USER = 'user'
+      HANDLED_ERRORS_THIRD_PARTY = 'third_party'
+      DEFAULT_HANDLED_ERRORS = nil
+      VALID_HANDLED_ERRORS = [HANDLED_ERRORS_ALL, HANDLED_ERRORS_USER, HANDLED_ERRORS_THIRD_PARTY].freeze
+      SPAN_EVENTS_HAS_EXCEPTION = '_dd.span_events.has_exception'
+      RUBY_VERSION_WITH_RESCUE_EVENT = '3.3'
+    end
+  end
+end