datadog 2.28.0 → 2.41.0

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

@@ -1,22 +1,19 @@
 # frozen_string_literal: true
 
-require_relative '../../core/chunker'
-require_relative '../../core/encoding'
-require_relative '../../core/tag_builder'
-require_relative '../../core/transport/parcel'
-require_relative '../../core/transport/request'
-require_relative '../../core/transport/transport'
-require_relative '../error'
-require_relative 'http/input'
+require_relative "../../core/chunker"
+require_relative "../../core/encoding"
+require_relative "../../core/tag_builder"
+require_relative "../../core/transport/parcel"
+require_relative "../../core/transport/request"
+require_relative "../../core/transport/transport"
+require_relative "../error"
+require_relative "../fatal_exceptions"
+require_relative "http/input"
 
 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
 
@@ -28,6 +25,13 @@ module Datadog
         end
 
         class Transport < Core::Transport::Transport
+          attr_reader :telemetry
+
+          def initialize(apis, default_api, logger:, telemetry: nil)
+            super(apis, default_api, logger: logger)
+            @telemetry = telemetry
+          end
+
           # The limit on an individual snapshot payload, aka "log line",
           # is 1 MB.
           #
@@ -47,23 +51,54 @@ module Datadog
           # max chunk size, it will still get sent out.
           DEFAULT_CHUNK_SIZE = 2 * 1024 * 1024
 
-          def send_input(payload, tags)
-            # Tags are the same for all chunks, serialize them one time.
+          # Sends snapshot payloads to the agent.
+          #
+          # Each snapshot is serialized individually. If serialization fails
+          # for a snapshot (e.g., due to binary data from custom serializers),
+          # the on_serialization_error callback is invoked with the probe ID
+          # and exception, allowing the caller to disable the affected probe.
+          # Successfully serialized snapshots are still sent.
+          #
+          # Large snapshots (> 1MB) are dropped. Batches are split into chunks
+          # of ~2MB each to avoid large network requests.
+          #
+          # @param payload [Array<Hash>] Array of snapshot payloads
+          # @param tags [Hash] Tags to send with the snapshots
+          # @param on_serialization_error [Proc] Called with (probe_id, exception)
+          #   when a snapshot fails to serialize.
+          def send_input(payload, tags, on_serialization_error:)
             serialized_tags = Core::TagBuilder.serialize_tags(tags)
 
-            encoder = Core::Encoding::JSONEncoder
-            encoded_snapshots = Core::Utils::Array.filter_map(payload) do |snapshot|
+            # Serialize each snapshot individually to isolate failures
+            encoded_snapshots = []
+            payload.each do |snapshot|
               encoded = encoder.encode(snapshot)
               if encoded.length > MAX_SERIALIZED_SNAPSHOT_SIZE
-                # Drop the snapshot.
-                # TODO report via telemetry metric?
                 logger.debug { "di: dropping too big snapshot" }
-                nil
-              else
-                encoded
+                next
+              end
+              encoded_snapshots << encoded
+            rescue Exception => exc # standard:disable Lint/RescueException
+              Datadog::DI.reraise_if_fatal(exc)
+              # Serialization failed for this snapshot - report via callback
+              # This catches JSON::GeneratorError, Encoding errors, TypeError, etc.
+              probe_id = snapshot.dig(:debugger, :snapshot, :probe, :id)
+              logger.debug { "di: JSON encoding failed for snapshot (probe #{probe_id}): #{exc.class}: #{exc.message}" }
+              telemetry&.report(exc, description: "JSON encoding failed for snapshot")
+
+              if probe_id
+                begin
+                  on_serialization_error.call(probe_id, exc)
+                rescue Exception => callback_exc # standard:disable Lint/RescueException
+                  Datadog::DI.reraise_if_fatal(callback_exc)
+                  logger.debug { "di: error in serialization error callback for probe #{probe_id}: #{callback_exc.class}: #{callback_exc.message}" }
+                  telemetry&.report(callback_exc, description: "Error in serialization error callback")
+                end
               end
             end
 
+            return payload if encoded_snapshots.empty?
+
             Datadog::Core::Chunker.chunk_by_size(
               encoded_snapshots, DEFAULT_CHUNK_SIZE,
             ).each do |chunk|
@@ -77,8 +112,10 @@ module Datadog
               # subsequent chunks are attempted to be sent.
               begin
                 send_input_chunk(chunked_payload, serialized_tags)
-              rescue => exc
-                logger.debug { "di: failed to send snapshot chunk: #{exc.class}: #{exc} (at #{exc.backtrace.first})" }
+              rescue Exception => exc # standard:disable Lint/RescueException
+                Datadog::DI.reraise_if_fatal(exc)
+                logger.debug { "di: failed to send snapshot chunk: #{exc.class}: #{exc.message} (at #{exc.backtrace&.first})" }
+                telemetry&.report(exc, description: "Error sending snapshot chunk")
               end
             end
 
@@ -86,7 +123,7 @@ module Datadog
           end
 
           def send_input_chunk(chunked_payload, serialized_tags)
-            parcel = EncodedParcel.new(chunked_payload)
+            parcel = Core::Transport::Parcel.new(chunked_payload, content_type: encoder.content_type)
             request = Request.new(parcel, serialized_tags)
 
             client.send_request(:input, request).tap do |response|
@@ -96,6 +133,10 @@ module Datadog
               end
             end
           end
+
+          def encoder
+            Core::Encoding::JSONEncoder
+          end
         end
       end
     end

data/lib/datadog/di/utils.rb

@@ -82,15 +82,31 @@ module Datadog
       # we just strip leading directory components from the "probe path"
       # until we get a match via a "suffix of the suffix".
 
+      # Returns +path+ with Windows-style backslash separators translated to
+      # forward slashes (DEBUG-5111). Used to normalize probe source paths
+      # that originate from IDE tooling running on Windows.
+      module_function def normalize_windows_separators(path)
+        path.tr("\\", "/")
+      end
+
       # 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.
+      # Backslash separators in +suffix+ are translated to forward slashes
+      # (DEBUG-5111) so paths typed by IDE tooling on Windows can match.
+      # Case-insensitive matching (DEBUG-5107) is opt-in via
+      # +case_insensitive: true+; callers that orchestrate matching against a
+      # set of known paths perform case-sensitive comparisons first and only
+      # fall back to case-insensitive when no case-sensitive match is found
+      # (see the design comment above, steps 5-8).
+      #
+      # If suffix is an absolute path (i.e., it starts with a slash, possibly
+      # after backslash normalization), 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)
+      module_function def path_matches_suffix?(path, suffix, case_insensitive: false)
         if path.nil?
           raise ArgumentError, "nil path passed"
         end
@@ -98,18 +114,19 @@ module Datadog
           raise ArgumentError, "nil suffix passed"
         end
 
-        if suffix.start_with?('/')
+        suffix = normalize_windows_separators(suffix)
+        if case_insensitive
+          path = path.downcase
+          suffix = suffix.downcase
+        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]
@@ -125,15 +142,26 @@ module Datadog
       # +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+.
+      #
+      # Matching is attempted case-sensitively first (steps 5-6 in the design
+      # comment above) and only falls back to case-insensitive (steps 7-8)
+      # when no case-sensitive match is found.
       module_function def path_can_match_spec?(path, spec)
-        return true if path_matches_suffix?(path, spec)
+        # Normalize Windows-style backslash separators (DEBUG-5111) so the
+        # suffix-shortening loop's "/+" regex can strip leading components.
+        spec = normalize_windows_separators(spec)
 
-        spec = spec.dup
-        loop do
-          return false unless spec.include?('/')
-          spec.sub!(%r{.*/+}, '')
-          return true if path_matches_suffix?(path, spec)
+        [false, true].each do |case_insensitive|
+          working_spec = spec.dup
+          return true if path_matches_suffix?(path, working_spec, case_insensitive: case_insensitive)
+
+          loop do
+            break unless working_spec.include?("/")
+            working_spec.sub!(%r{.*/+}, "")
+            return true if path_matches_suffix?(path, working_spec, case_insensitive: case_insensitive)
+          end
         end
+        false
       end
     end
   end

data/lib/datadog/di.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'di/configuration'
-require_relative 'di/extensions'
-require_relative 'di/remote'
+require_relative "di/configuration"
+require_relative "di/extensions"
+require_relative "di/remote"
 
 module Datadog
   # Namespace for Datadog dynamic instrumentation.
@@ -11,11 +11,155 @@ module Datadog
   module DI
     INSTRUMENTED_COUNTERS_LOCK = Mutex.new
 
+    # Captured at load time from Exception itself (not a subclass).
+    # Used to bypass subclass overrides of backtrace_locations.
+    #
+    # This does NOT protect against monkeypatching Exception#backtrace_locations
+    # before dd-trace-rb loads — in that case we'd capture the monkeypatch.
+    # The practical threat model is customer subclasses overriding the method:
+    #
+    #   class MyError < StandardError
+    #     def backtrace_locations; []; end
+    #   end
+    #
+    # The UnboundMethod bypasses subclass overrides: bind(exception).call
+    # always dispatches to the original Exception implementation.
+    #
+    # Note: if the subclass overrides #backtrace (not #backtrace_locations),
+    # MRI's setup_exception skips storing the VM backtrace entirely — both
+    # @bt and @bt_locations stay nil. In that case this UnboundMethod also
+    # returns nil. See EXCEPTION_BACKTRACE comment for details.
+    EXCEPTION_BACKTRACE_LOCATIONS = Exception.instance_method(:backtrace_locations)
+
+    # Same UnboundMethod trick for Exception#backtrace (Array<String>).
+    # Used as a fallback when backtrace_locations returns nil — which happens
+    # when someone calls Exception#set_backtrace with an Array<String>.
+    #
+    # set_backtrace accepts Array<String> or nil. When called with strings,
+    # it replaces the VM-level backtrace: backtrace returns the new strings,
+    # but backtrace_locations returns nil because the VM cannot reconstruct
+    # Location objects from formatted strings. This occurs in exception
+    # wrapping patterns where a library catches an exception, creates a new
+    # one, and copies the original's string backtrace onto it via
+    # set_backtrace before re-raising.
+    #
+    # Ruby 3.4+ also allows set_backtrace(Array<Location>), which preserves
+    # backtrace_locations — but older Rubies and most existing code use
+    # the string form.
+    #
+    # Like EXCEPTION_BACKTRACE_LOCATIONS, this UnboundMethod bypasses
+    # subclass overrides of #backtrace: bind(exception).call dispatches
+    # to Exception#backtrace regardless of what the subclass defines.
+    #
+    # However, when a subclass overrides #backtrace, MRI's setup_exception
+    # (eval.c) calls the override via rb_get_backtrace during raise. If it
+    # gets a non-nil result, it skips storing the VM backtrace in @bt and
+    # @bt_locations entirely. So the UnboundMethod bypasses the override
+    # at dispatch but reads nil from @bt because the data was never stored.
+    #
+    # This constant is used as a fallback when backtrace_locations returns
+    # nil. In the common set_backtrace-with-strings case, no subclass
+    # override is involved and the fallback works. The only unrecoverable
+    # case: a subclass overrides #backtrace, the exception is raised
+    # normally, and set_backtrace is never called. Both @bt and
+    # @bt_locations are nil — DI reports an empty stacktrace (type and
+    # message are still reported).
+    EXCEPTION_BACKTRACE = Exception.instance_method(:backtrace)
+
     class << self
       def enabled?
         Datadog.configuration.dynamic_instrumentation.enabled
       end
 
+      # Returns a human-readable reason why dynamic instrumentation cannot run
+      # under the given settings, or nil if all build-time preconditions are met.
+      #
+      # Single source of truth for the preconditions checked in
+      # {Component.build} and reported back by {Remote.handle_rc_enablement}
+      # when an implicit enablement signal arrives but the component was not
+      # built at startup. Checks are ordered from most-actionable to
+      # platform-constraint so the most useful reason wins.
+      #
+      # The settings argument is optional so the helper can be called from
+      # contexts that don't have settings in scope (e.g. the RC handler).
+      #
+      # @param settings [Datadog::Core::Configuration::Settings]
+      # @return [String, nil] reason string or nil when supported
+      def unsupported_reason(settings = Datadog.configuration)
+        # Symmetric to the respond_to?(:remote) guard below: in unusual
+        # configurations (test doubles, partial Settings) the DI namespace
+        # may be absent. Returning a reason here lets callers — most
+        # importantly Remote.handle_rc_enablement — emit the customer-facing
+        # warn instead of raising NoMethodError on the unguarded access at
+        # line 92 (`settings.dynamic_instrumentation.internal.development`).
+        unless settings.respond_to?(:dynamic_instrumentation)
+          return "dynamic instrumentation settings are not available"
+        end
+        unless settings.respond_to?(:remote) && settings.remote.enabled
+          return "Remote Configuration is not enabled. See https://docs.datadoghq.com/agent/remote_config"
+        end
+        unless settings.dynamic_instrumentation.internal.development
+          if Datadog::Core::Environment::Execution.development?
+            return "development environment detected"
+          end
+        end
+        if (reason = unsupported_platform_reason)
+          return reason
+        end
+        unless respond_to?(:exception_message)
+          return "C extension is not available"
+        end
+        nil
+      end
+
+      # Whether the current Ruby runtime can run dynamic instrumentation:
+      # MRI (CRuby) on Ruby 2.6 or later.
+      #
+      # @return [Boolean]
+      def supported_runtime?
+        unsupported_platform_reason.nil?
+      end
+
+      # Reason the current Ruby runtime cannot run dynamic instrumentation, or
+      # nil when the platform is supported. Single source of truth for the
+      # minimum-runtime definition, shared by {unsupported_reason} (which layers
+      # the settings and C-extension checks on top) and {supported_runtime?}.
+      #
+      # @return [String, nil]
+      private def unsupported_platform_reason
+        if RUBY_ENGINE != "ruby"
+          "MRI is required, but running on #{RUBY_ENGINE}"
+        elsif Datadog::RubyVersion.is?("< 2.6")
+          "Ruby 2.6+ is required, but running on #{RUBY_VERSION}"
+        end
+      end
+
+      # Returns iseqs that correspond to loaded files (filtering out eval'd code).
+      #
+      # There are several types of iseqs returned by +all_iseqs+:
+      #
+      # 1. Eval'd code — these have a nil +absolute_path+ and are filtered out here.
+      # 2. Whole-file iseqs — have +absolute_path+ set and +first_lineno+ of 0.
+      #    Only available for a subset of loaded files (the full-file iseq may be
+      #    garbage collected after loading completes). Easiest to work with since
+      #    we just match the file path to the probe specification.
+      # 3. Per-method iseqs — have +absolute_path+ set and +first_lineno+ > 0.
+      #    Often the only iseqs available for third-party code. Require identifying
+      #    the correct iseq containing the target line, which may involve examining
+      #    the iseq's +trace_points+ since +define_method+ can create nested,
+      #    non-contiguous line ranges.
+      #
+      # Note: the same line of code can appear in multiple iseqs (e.g. when
+      # +define_method+ is used inside a method). DI treats this as an error
+      # since a probe must resolve to exactly one code location.
+      #
+      # @return [Array<RubyVM::InstructionSequence>] iseqs with non-nil +absolute_path+
+      def file_iseqs
+        all_iseqs.select do |iseq|
+          iseq.absolute_path
+        end
+      end
+
       # This method is called from DI Remote handler to issue DI operations
       # to the probe manager (add or remove probes).
       #

data/lib/datadog/error_tracking/collector.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
+require_relative "ext"
+require_relative "../ruby_version"
 
 module Datadog
   module ErrorTracking
@@ -52,7 +53,7 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION >= Ext::RUBY_VERSION_WITH_RESCUE_EVENT
+      if RubyVersion.is?(">= #{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

data/lib/datadog/error_tracking/component.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'set'
-require_relative 'collector'
-require_relative 'filters'
+require "set"
+require_relative "collector"
+require_relative "filters"
 
 module Datadog
   module ErrorTracking
@@ -30,10 +30,10 @@ module Datadog
         end
 
         def environment_supported?(logger)
-          if RUBY_ENGINE != 'ruby'
+          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'
+          elsif RubyVersion.is?("< 2.7")
             logger.warn(
               "error tracking: cannot enable error tracking: Ruby 2.7+ is required, but running
               on #{RUBY_VERSION}"
@@ -63,7 +63,7 @@ module Datadog
         # 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
+        event = RubyVersion.is?(">= 3.3") ? :rescue : :raise
 
         # This TracePoint is in charge of capturing the handled exceptions
         # and of adding the corresponding span events to the collector
@@ -113,9 +113,9 @@ module Datadog
             # - 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?('/')
+              if file_to_instr.start_with?("/")
                 %r{\A#{Regexp.escape(file_to_instr)}(?:/|\.rb\z|\z)}
-              elsif file_to_instr.start_with?('./')
+              elsif file_to_instr.start_with?("./")
                 abs_path = File.expand_path(file_to_instr)
                 %r{\A#{Regexp.escape(abs_path)}(?:/|\.rb\z|\z)}
               else
@@ -152,11 +152,11 @@ module Datadog
       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
+          "exception.type" => formatted_exception.type,
+          "exception.message" => formatted_exception.message,
+          "exception.stacktrace" => formatted_exception.backtrace,
         }
-        Datadog::Tracing::SpanEvent.new('exception', attributes: attributes)
+        Datadog::Tracing::SpanEvent.new("exception", attributes: attributes)
       end
 
       def add_instrumented_file(file_path)

data/lib/datadog/error_tracking/configuration.rb

@@ -1,11 +1,64 @@
 # frozen_string_literal: true
 
+require_relative "ext"
+
 module Datadog
   module ErrorTracking
     # Configuration for 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
-
-require_relative 'configuration/settings'

data/lib/datadog/error_tracking/ext.rb

@@ -4,15 +4,15 @@ 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'
+      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'
+      SPAN_EVENTS_HAS_EXCEPTION = "_dd.span_events.has_exception"
+      RUBY_VERSION_WITH_RESCUE_EVENT = "3.3"
     end
   end
 end

data/lib/datadog/error_tracking/extensions.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'configuration'
-require_relative '../core/configuration'
+require_relative "configuration"
+require_relative "../core/configuration"
 
 module Datadog
   module ErrorTracking

data/lib/datadog/error_tracking/filters.rb

@@ -32,7 +32,7 @@ module Datadog
       end
 
       def datadog_code?(file_path)
-        file_path.include?('lib/datadog/')
+        file_path.include?("lib/datadog/")
       end
 
       def third_party_code?(file_path)
@@ -48,9 +48,9 @@ module Datadog
       def generate_filter(to_instrument_scope, handled_errors_include = nil)
         case to_instrument_scope
         # If DD_ERROR_TRACKING_HANDLED_ERRORS is set
-        when 'all'
+        when "all"
           proc { |file_path| !datadog_code?(file_path) }
-        when 'user'
+        when "user"
           # If DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE is set
           if handled_errors_include
             proc { |file_path|
@@ -59,7 +59,7 @@ module Datadog
           else
             proc { |file_path| user_code?(file_path) }
           end
-        when 'third_party'
+        when "third_party"
           if handled_errors_include
             proc { |file_path|
               third_party_code?(file_path) || file_included?(file_path, handled_errors_include)

data/lib/datadog/error_tracking.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'error_tracking/collector'
-require_relative 'error_tracking/component'
-require_relative 'error_tracking/configuration'
-require_relative 'error_tracking/ext'
-require_relative 'error_tracking/extensions'
-require_relative 'error_tracking/filters'
+require_relative "error_tracking/collector"
+require_relative "error_tracking/component"
+require_relative "error_tracking/configuration"
+require_relative "error_tracking/ext"
+require_relative "error_tracking/extensions"
+require_relative "error_tracking/filters"
 
 module Datadog
   # Namespace for Datadog ErrorTracking.