cw-datadog 2.23.0.2

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/transport/http/api/instance'
+require_relative '../../../core/transport/http/api/spec'
+require_relative 'client'
+
+module Datadog
+  module DI
+    module Transport
+      module HTTP
+        module Input
+          module Client
+            def send_input_payload(request)
+              send_request(request) do |api, env|
+                api.send_input(env)
+              end
+            end
+          end
+
+          module API
+            class Instance < Core::Transport::HTTP::API::Instance
+              def send_input(env)
+                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
+            end
+
+            class Spec < Core::Transport::HTTP::API::Spec
+              attr_accessor :input
+
+              def send_input(env, &block)
+                raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('input', self) if input.nil?
+
+                input.call(env, &block)
+              end
+            end
+
+            class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
+              HEADER_CONTENT_TYPE = 'Content-Type'
+
+              attr_reader \
+                :encoder
+
+              def initialize(path, encoder)
+                super(:post, path)
+                @encoder = encoder
+              end
+
+              def call(env, &block)
+                # Encode body & type
+                env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
+                env.body = env.request.parcel.data
+                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
+        end
+
+        HTTP::Client.include(Input::Client)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'diagnostics'
+require_relative 'input'
+require_relative 'http/api'
+require_relative '../../core/transport/http'
+
+module Datadog
+  module DI
+    module Transport
+      # Namespace for HTTP transport components
+      module HTTP
+        module_function
+
+        # Builds a new Transport::HTTP::Client with default settings
+        # Pass a block to override any settings.
+        def diagnostics(
+          agent_settings:,
+          logger:,
+          api_version: nil,
+          headers: nil
+        )
+          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]
+
+            # Call block to apply any customization, if provided
+            yield(transport) if block_given?
+          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:,
+          logger:,
+          api_version: nil,
+          headers: nil
+        )
+          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]
+
+            # Call block to apply any customization, if provided
+            yield(transport) if block_given?
+          end.to_transport(DI::Transport::Input::Transport)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative '../../core/transport/parcel'
+require_relative 'http/client'
+
+module Datadog
+  module DI
+    module Transport
+      module Input
+        class EncodedParcel
+          include Datadog::Core::Transport::Parcel
+        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, :logger
+
+          def initialize(apis, default_api, logger:)
+            @apis = apis
+            @logger = logger
+
+            @client = HTTP::Client.new(current_api, logger: logger)
+          end
+
+          def current_api
+            @apis[HTTP::API::INPUT]
+          end
+
+          def send_input(payload, tags)
+            json = JSON.dump(payload)
+            parcel = EncodedParcel.new(json)
+            serialized_tags = Core::TagBuilder.serialize_tags(tags)
+            request = Request.new(parcel, serialized_tags)
+
+            response = @client.send_input_payload(request)
+            unless response.ok?
+              # TODO Datadog::Core::Transport::InternalErrorResponse
+              # does not have +code+ method, what is the actual API of
+              # these response objects?
+              raise Error::AgentCommunicationError, "send_input failed: #{begin
+                response.code
+              rescue
+                "???"
+              end}: #{response.payload}"
+            end
+          rescue Error::AgentCommunicationError
+            raise
+          # Datadog::Core::Transport does not perform any exception mapping,
+          # therefore we could have any exception here from failure to parse
+          # agent URI for example.
+          # If we ever implement retries for network errors, we should distinguish
+          # actual network errors from non-network errors that are raised by
+          # transport code.
+          rescue => exc
+            raise Error::AgentCommunicationError, "send_input failed: #{exc.class}: #{exc}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/di/utils.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# standard gets itself into an infinite loop over this
+# rubocop:disable Layout/SpaceAfterNot
+
+module Datadog
+  module DI
+    module Utils
+      # General path matching considerations
+      # ------------------------------------
+      #
+      # The following use cases must be supported:
+      # 1. The "probe path" is relative path to the file from source code
+      #    repository root. The project is deployed from the repository root,
+      #    such that that same relative path exists at runtime from the
+      #    root of the application.
+      # 2. The "probe path" is a relative path to the file in a monorepo
+      #    where the project being deployed is in a subdirectory.
+      #    This the "probe path" contains additional directory components
+      #    in the beginning that do not exist in the runtime environment.
+      # 3. The "probe path" is an absolute path to the file on the customer's
+      #    development system. As specified this path definitely does not
+      #    exist at runtime, and can start with a prefix that is unknown
+      #    to any both UI and tracer code.
+      # 4. Same as (3), but the customer is using a Windows computer for
+      #    development and has the path specified in the wrong case
+      #    (which works fine on their development machine).
+      # 5. The "probe path" is the basename or any suffix of the path to
+      #    the desired file, typed manually by the customer into the UI.
+      #
+      # A related concern is that if multiple runtime paths match the path
+      # specification in the probe, the tracer must return an error to the
+      # backend/UI rather than instrumenting any of the matching paths.
+      #
+      # The logic for path matching should therefore, generally, be as follows:
+      # 1. If the "probe path" is absolute, see if it exists at runtime.
+      #    If so, take it as the desired path and finish.
+      # 2. Attempt to identify the application root, by checking if the current
+      #    working directory contains a file called Gemfile. If yes, assume
+      #    the current working directory is the application root, otherwise
+      #    consider the application root to be unknown.
+      # 3. If the application root is known and the "probe path" is relative,
+      #    concatenate the "probe path" to the application root and check
+      #    if the resulting path exists at runtime. If so, take it as the
+      #    desired path and finish.
+      # 4. If the "probe path" is relative, go through the known file paths,
+      #    filter these paths down to those whose suffix is the "probe path",
+      #    and check how many we are left with. If exactly one, assume this
+      #    is the desired path and finish. If more than one, return an error
+      #    "multiple matching paths".
+      # 5. If the application root is known, for each suffix of the "probe path",
+      #    see if that relative paths concatenated to the application root
+      #    results in a known file. If a known file is found, assume this
+      #    is the wanted file and finish.
+      # 6. For each suffix of the "probe path", filter the set of known paths
+      #    down to those that end in the suffix. If exactly one path remains
+      #    for a given suffix, assume this is the wanted path and finish.
+      #    If more than one path remains for a given suffix, return the error
+      #    "multiple matching paths".
+      # 7. Repeat step 5 but perform case-insensitive comparison.
+      # 8. Repeat step 6 but perform case-insensitive comparison.
+      #
+      # Note that we do not look for "probe paths" under the current working
+      # directory at runtime if the current working directory does not contain
+      # a Gemfile, to avoid finding files from potentially undesired bases.
+      #
+      # What "known file"/"known path" means also differs based on the
+      # operation being performed:
+      # - If the operation is "install a probe", "known file/path" can
+      #   include files on the filesystem that have not been loaded as
+      #   well as paths from the code tracker.
+      # - If the operation is "check if any pending probes match the file
+      #   that was just loaded", we would only consider the path that was
+      #   just loaded and not check the filesystem.
+      #
+      # Filesystem inquiries are obviously quite expensive and should be
+      # cached. For the vast majority of applications it should be safe to
+      # indefinitely cache whether a particular filesystem paths exists
+      # in both positive and negative.
+      #
+      # As a "quick fix", currently after performing the suffix matching
+      # we just strip leading directory components from the "probe path"
+      # until we get a match via a "suffix of the suffix".
+
+      # Returns whether the provided +path+ matches the user-designated
+      # file suffix (of a line probe).
+      #
+      # If suffix is an absolute path (i.e., it starts with a slash), the path
+      # must be identical for it to match.
+      #
+      # If suffix is not an absolute path, the path matches if its suffix is
+      # the provided suffix, at a path component boundary.
+      module_function def path_matches_suffix?(path, suffix)
+        if path.nil?
+          raise ArgumentError, "nil path passed"
+        end
+        if suffix.nil?
+          raise ArgumentError, "nil suffix passed"
+        end
+
+        if suffix.start_with?('/')
+          path == suffix
+        else
+          # Exact match is not possible here, meaning any matching path
+          # has to be longer than the suffix. Require full component matches,
+          # meaning either the first character of the suffix is a slash
+          # or the previous character in the path is a slash.
+          # For now only check for forward slashes for Unix-like OSes;
+          # backslash is a legitimate character of a file name in Unix
+          # therefore simply permitting forward or back slash is not
+          # sufficient, we need to perform an OS check to know which
+          # path separator to use.
+          !!
+          if path.length > suffix.length && path.end_with?(suffix)
+            previous_char = path[path.length - suffix.length - 1]
+            previous_char == "/" || suffix[0] == "/"
+          end
+
+          # Alternative implementation using a regular expression:
+          # !!(path =~ %r,(/|\A)#{Regexp.quote(suffix)}\z,)
+        end
+      end
+
+      # Returns whether the provided +path+ matches the "probe path" in
+      # +spec+. Attempts all of the fuzzy matches by stripping directories
+      # from the front of +spec+. Does not consider othr known paths to
+      # identify the case of (potentially) multiple matching paths for +spec+.
+      module_function def path_can_match_spec?(path, spec)
+        return true if path_matches_suffix?(path, spec)
+
+        spec = spec.dup
+        loop do
+          return false unless spec.include?('/')
+          spec.sub!(%r{.*/+}, '')
+          return true if path_matches_suffix?(path, spec)
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Layout/SpaceAfterNot

data/lib/datadog/di.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'di/configuration'
+require_relative 'di/extensions'
+require_relative 'di/remote'
+
+module Datadog
+  # Namespace for Datadog dynamic instrumentation.
+  #
+  # @api private
+  module DI
+    class << self
+      def enabled?
+        Datadog.configuration.dynamic_instrumentation.enabled
+      end
+    end
+
+    # Expose DI to global shared objects
+    Extensions.activate!
+
+    class << self
+      # This method is called from DI Remote handler to issue DI operations
+      # to the probe manager (add or remove probes).
+      #
+      # When DI Remote is executing, Datadog.components should be initialized
+      # and we should be able to reference it to get to the DI component.
+      #
+      # Given that we need the current_component anyway for code tracker,
+      # perhaps we should delete the +component+ method and just use
+      # +current_component+ in all cases.
+      def component
+        Datadog.send(:components).dynamic_instrumentation
+      end
+    end
+  end
+end

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