datadog 2.38.0 → 2.40.0

data/lib/datadog/di/boot.rb

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
-require_relative 'logger'
-require_relative 'base'
-require_relative 'error'
-require_relative 'code_tracker'
-require_relative 'component'
-require_relative 'context'
-require_relative 'capture_limits'
-require_relative 'capture_expression'
-require_relative 'capture_expression_evaluator'
-require_relative 'instrumenter'
-require_relative 'probe'
-require_relative 'probe_builder'
-require_relative 'probe_manager'
-require_relative 'probe_notification_builder'
-require_relative 'probe_notifier_worker'
-require_relative 'probe_repository'
-require_relative 'redactor'
-require_relative 'serializer'
-require_relative 'transport/http'
-require_relative 'utils'
+require_relative "logger"
+require_relative "base"
+require_relative "error"
+require_relative "code_tracker"
+require_relative "component"
+require_relative "context"
+require_relative "capture_limits"
+require_relative "capture_expression"
+require_relative "capture_expression_evaluator"
+require_relative "instrumenter"
+require_relative "probe"
+require_relative "probe_builder"
+require_relative "probe_manager"
+require_relative "probe_notification_builder"
+require_relative "probe_notifier_worker"
+require_relative "probe_repository"
+require_relative "redactor"
+require_relative "serializer"
+require_relative "transport/http"
+require_relative "utils"
 
-if %w[1 true yes].include?(Datadog::DATADOG_ENV['DD_DYNAMIC_INSTRUMENTATION_ENABLED'])
+if %w[1 true yes].include?(Datadog::DATADOG_ENV["DD_DYNAMIC_INSTRUMENTATION_ENABLED"])
 
   # For initial release of Dynamic Instrumentation, activate code tracking
   # only if DI is explicitly requested in the environment.
@@ -35,13 +35,13 @@ if %w[1 true yes].include?(Datadog::DATADOG_ENV['DD_DYNAMIC_INSTRUMENTATION_ENAB
   Datadog::DI.activate_tracking
 end
 
-require_relative 'contrib'
+require_relative "contrib"
 
 Datadog::DI::Contrib.load_now_or_later
 
-if %w[1 true yes].include?(Datadog::DATADOG_ENV['DD_DYNAMIC_INSTRUMENTATION_ENABLED'])
-  if Datadog::DATADOG_ENV['DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE']
-    require_relative 'probe_file_loader'
+if %w[1 true yes].include?(Datadog::DATADOG_ENV["DD_DYNAMIC_INSTRUMENTATION_ENABLED"])
+  if Datadog::DATADOG_ENV["DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE"]
+    require_relative "probe_file_loader"
     Datadog::DI::ProbeFileLoader.load_now_or_later
   end
 end

data/lib/datadog/di/code_tracker.rb

@@ -2,8 +2,8 @@
 
 # rubocop:disable Lint/AssignmentInCondition
 
-require_relative 'error'
-require_relative 'fatal_exceptions'
+require_relative "error"
+require_relative "fatal_exceptions"
 
 module Datadog
   module DI
@@ -275,8 +275,8 @@ module Datadog
               if inexact.any?
                 return inexact.first
               end
-              break unless working_suffix.include?('/')
-              working_suffix.sub!(%r{.*/+}, '')
+              break unless working_suffix.include?("/")
+              working_suffix.sub!(%r{.*/+}, "")
             end
           end
           nil
@@ -393,8 +393,8 @@ module Datadog
             matches = paths.select { |p| Utils.path_matches_suffix?(p, working_suffix, case_insensitive: case_insensitive) }
             raise Error::MultiplePathsMatch, "Multiple paths matched requested suffix" if matches.length > 1
             return matches.first if matches.any?
-            break unless working_suffix.include?('/')
-            working_suffix.sub!(%r{.*/+}, '')
+            break unless working_suffix.include?("/")
+            working_suffix.sub!(%r{.*/+}, "")
           end
         end
         nil

data/lib/datadog/di/component.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'fatal_exceptions'
+require_relative "fatal_exceptions"
 
 module Datadog
   module DI
@@ -123,6 +123,14 @@ module Datadog
         @lifecycle_mutex.synchronize do
           return if @started
 
+          # DI.activate_tracking creates the global code tracker lazily. When DI
+          # is enabled after boot via remote configuration (in-product
+          # enablement), this component and its instrumenter were built with a
+          # nil tracker; adopt the now-current global tracker so line probes
+          # can be targeted.
+          @code_tracker = DI.code_tracker
+          instrumenter.code_tracker = @code_tracker
+
           probe_notifier_worker.start
           probe_manager.reopen
           @started = true
@@ -190,14 +198,14 @@ module Datadog
         Datadog::DI.reraise_if_fatal(exc)
         begin
           probe = Struct.new(:id).new(
-            probe_spec['id'],
+            probe_spec["id"],
           )
           payload = probe_notification_builder.build_errored(probe, exc)
           probe_notifier_worker.add_status(payload)
         rescue Exception => nested_exc # standard:disable Lint/RescueException
           Datadog::DI.reraise_if_fatal(nested_exc)
           logger.debug { "di: failed to build error notification: #{nested_exc.class}: #{nested_exc.message}" }
-          telemetry&.report(nested_exc, description: 'Error building probe error notification')
+          telemetry&.report(nested_exc, description: "Error building probe error notification")
           raise
         end
 

data/lib/datadog/di/configuration.rb

@@ -137,7 +137,7 @@ module Datadog
               option :max_time_to_serialize_ms do |o|
                 o.type :int
                 o.default 200
-                o.env 'DD_DYNAMIC_INSTRUMENTATION_MAX_TIME_TO_SERIALIZE'
+                o.env "DD_DYNAMIC_INSTRUMENTATION_MAX_TIME_TO_SERIALIZE"
               end
 
               # Settings in the 'internal' group are for internal Datadog
@@ -229,7 +229,7 @@ module Datadog
                   # dedicated environment variable in the future but
                   # will likely need a way to turn on remote config
                   # debugging (since DI uses RC for configuration).
-                  o.env 'DD_TRACE_DEBUG'
+                  o.env "DD_TRACE_DEBUG"
                 end
 
                 # If the CPU time consumed by the thread performing instrumentation

data/lib/datadog/di/contrib/railtie.rb

@@ -6,7 +6,7 @@ module Datadog
       # Railtie class initializes dynamic instrumentation contrib code
       # in Rails environments.
       class Railtie < Rails::Railtie
-        initializer 'datadog.dynamic_instrumentation.initialize' do |app|
+        initializer "datadog.dynamic_instrumentation.initialize" do |app|
           Contrib.load_now
         end
       end

data/lib/datadog/di/contrib.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require_relative '../core/contrib/rails/utils'
+require_relative "../core/contrib/rails/utils"
 
 module Datadog
   module DI
     module Contrib
       module_function def load_now_or_later
         if Datadog::Core::Contrib::Rails::Utils.railtie_supported?
-          Datadog.logger.debug('di: loading contrib/railtie')
-          require_relative 'contrib/railtie'
+          Datadog.logger.debug("di: loading contrib/railtie")
+          require_relative "contrib/railtie"
         else
           load_now
         end
@@ -19,8 +19,8 @@ module Datadog
       # dependencies are loaded (or potentially loaded).
       module_function def load_now
         if defined?(ActiveRecord::Base)
-          Datadog.logger.debug('di: loading contrib/active_record')
-          require_relative 'contrib/active_record'
+          Datadog.logger.debug("di: loading contrib/active_record")
+          require_relative "contrib/active_record"
         end
       end
     end

data/lib/datadog/di/el/compiler.rb

@@ -16,20 +16,31 @@ module Datadog
       #
       # @api private
       class Compiler
+        # Compiles +ast+ into eval'able Ruby source.
+        #
+        # Returns the compiled source and companion compiled Regexp
+        # objects.
+        #
+        # @param ast [untyped] expression AST from the probe definition.
+        # @return [Array(String, Array<Regexp>)] the compiled Ruby source and
+        #   the precompiled Regexps, indexed in the order the compiled code
+        #   references them.
         def compile(ast)
-          compile_partial(ast)
+          regexps = []
+          code = compile_partial(ast, regexps)
+          [code, regexps]
         end
 
         private
 
         # Steep: https://github.com/soutaro/steep/issues/363
         OPERATORS = { # steep:ignore IncompatibleAssignment
-          'eq' => '==',
-          'ne' => '!=',
-          'ge' => '>=',
-          'gt' => '>',
-          'le' => '<=',
-          'lt' => '<',
+          "eq" => "==",
+          "ne" => "!=",
+          "ge" => ">=",
+          "gt" => ">",
+          "le" => "<=",
+          "lt" => "<",
         }.freeze
 
         # Steep: https://github.com/soutaro/steep/issues/363
@@ -37,49 +48,58 @@ module Datadog
           len isEmpty isUndefined
         ].freeze # steep:ignore IncompatibleAssignment
 
+        # `matches` is also a two-argument method but is special-cased in
+        # #compile_partial so that regular expressions can be precompiled
+        # once, so it is not listed here.
+        #
         # Steep: https://github.com/soutaro/steep/issues/363
         TWO_ARG_METHODS = %w[
-          startsWith endsWith contains matches
+          startsWith endsWith contains
           getmember index instanceof
         ].freeze # steep:ignore IncompatibleAssignment
 
         # Steep: https://github.com/soutaro/steep/issues/363
         MULTI_ARG_METHODS = { # steep:ignore IncompatibleAssignment
-          'and' => '&&',
-          'or' => '||',
+          "and" => "&&",
+          "or" => "||",
         }.freeze
 
-        def compile_partial(ast)
+        # @param ast [untyped] AST node to compile.
+        # @param regexps [Array<Regexp>] output array that collects the
+        #   companion precompiled Regexp objects.
+        # @return [String] compiled Ruby source for +ast+.
+        def compile_partial(ast, regexps)
           case ast
           when Hash
-            if ast.length != 1
+            entry = ast.first
+            if ast.length != 1 || entry.nil?
               raise DI::Error::InvalidExpression, "Expected hash of length 1: #{ast}"
             end
-            op, target = ast.first
+            op, target = entry
             case op
-            when 'ref'
+            when "ref"
               unless String === target
                 raise DI::Error::InvalidExpression, "Bad ref value type: #{target.class}: #{target}"
               end
               case target
-              when '@it'
-                'current_item'
-              when '@key'
-                'current_key'
-              when '@value'
-                'current_value'
-              when '@return'
+              when "@it"
+                "current_item"
+              when "@key"
+                "current_key"
+              when "@value"
+                "current_value"
+              when "@return"
                 # For @return, @duration and @exception we shadow
                 # instance variables.
                 "context.return_value"
-              when '@duration'
+              when "@duration"
                 # There is no way to explicitly format the duration.
                 # TODO come up with better formatting?
                 # We could format to a string here but what if customer
                 # has @duration as part of an expression and wants
                 # to retain it as a number?
                 "(context.duration && context.duration * 1000)"
-              when '@exception'
+              when "@exception"
                 "context.exception"
               else
                 # Ruby technically allows all kinds of symbols in variable
@@ -89,44 +109,60 @@ module Datadog
                 unless target =~ %r{\A(@?)([a-zA-Z0-9_]+)\z}
                   raise DI::Error::BadVariableName, "Bad variable name: #{target}"
                 end
-                method_name = (($1 == '@') ? 'iref' : 'ref')
+                method_name = (($1 == "@") ? "iref" : "ref")
                 "#{method_name}('#{target}')"
               end
             when *SINGLE_ARG_METHODS
               method_name = op.gsub(/[A-Z]/) { |m| "_#{m.downcase}" }
-              "#{method_name}(#{compile_partial(target)}, '#{var_name_maybe(target)}')"
+              "#{method_name}(#{compile_partial(target, regexps)}, '#{var_name_maybe(target)}')"
+            when "matches"
+              unless Array === target && target.length == 2
+                raise DI::Error::InvalidExpression, "Improper matches syntax"
+              end
+              first, second = target
+              if String === second
+                # Match against a literal regular expression (string).
+                index = precompile_regexp(second, regexps)
+                "matches_compiled(#{compile_partial(first, regexps)}, #{index})"
+              else
+                # Match against a (complex) expression.
+                "matches(#{compile_partial(first, regexps)}, (#{compile_partial(second, regexps)}))"
+              end
             when *TWO_ARG_METHODS
               method_name = op.gsub(/[A-Z]/) { |m| "_#{m.downcase}" }
               unless Array === target && target.length == 2
                 raise DI::Error::InvalidExpression, "Improper #{op} syntax"
               end
               first, second = target
-              "#{method_name}(#{compile_partial(first)}, (#{compile_partial(second)}))"
+              "#{method_name}(#{compile_partial(first, regexps)}, (#{compile_partial(second, regexps)}))"
             when *MULTI_ARG_METHODS.keys
               unless Array === target && target.length >= 1
                 raise DI::Error::InvalidExpression, "Improper #{op} syntax"
               end
               compiled_targets = target.map do |item|
-                "(#{compile_partial(item)})"
+                "(#{compile_partial(item, regexps)})"
               end
               compiled_op = MULTI_ARG_METHODS[op]
               "(#{compiled_targets.join(" #{compiled_op} ")})"
-            when 'substring'
+            when "substring"
               unless Array === target && target.length == 3
                 raise DI::Error::InvalidExpression, "Improper #{op} syntax"
               end
-              "#{op}(#{target.map { |arg| "(#{compile_partial(arg)})" }.join(", ")})"
-            when 'not'
-              "!(#{compile_partial(target)})"
+              "#{op}(#{target.map { |arg| "(#{compile_partial(arg, regexps)})" }.join(", ")})"
+            when "not"
+              "!(#{compile_partial(target, regexps)})"
             when *OPERATORS.keys
               unless Array === target && target.length == 2
                 raise DI::Error::InvalidExpression, "Improper #{op} syntax"
               end
               first, second = target
               operator = OPERATORS.fetch(op)
-              "(#{compile_partial(first)}) #{operator} (#{compile_partial(second)})"
-            when 'any', 'all', 'filter'
-              "#{op}(#{compile_partial(target.first)}) { |current_item, current_key, current_value| #{compile_partial(target.last)} }"
+              "(#{compile_partial(first, regexps)}) #{operator} (#{compile_partial(second, regexps)})"
+            when "any", "all", "filter"
+              unless Array === target && target.length == 2
+                raise DI::Error::InvalidExpression, "Improper #{op} syntax"
+              end
+              "#{op}(#{compile_partial(target.first, regexps)}) { |current_item, current_key, current_value| #{compile_partial(target.last, regexps)} }"
             else
               raise DI::Error::InvalidExpression, "Unknown operation: #{op}"
             end
@@ -151,16 +187,33 @@ module Datadog
         # WARNING: the result of this method is included in eval'd code,
         # it must be sanitized to avoid injection.
         def var_name_maybe(target)
-          if Hash === target && target.length == 1 && target.keys.first == 'ref' &&
+          if Hash === target && target.length == 1 && target.keys.first == "ref" &&
               String === (value = target.values.first)
             escape(value)
           else
-            '(expression)'
+            "(expression)"
           end
         end
 
         def escape(needle)
-          needle.gsub("\\") { "\\\\" }.gsub('"') { "\\\"" }.gsub('#') { "\\#" }
+          needle.gsub("\\") { "\\\\" }.gsub('"') { "\\\"" }.gsub("#") { "\\#" }
+        end
+
+        # Compile a literal regular expression +regexp_str+ at
+        # instrumentation time. Append it to +regexps+, returning its index for
+        # Evaluator#matches_compiled to look up.
+        #
+        # @param regexp_str [String] regular expression source.
+        # @param regexps [Array<Regexp>] output array to append the compiled
+        #   regexp to.
+        # @return [Integer] index into +regexps+.
+        # @raise [DI::Error::InvalidExpression] if +needle+ is not a valid regexp.
+        def precompile_regexp(regexp_str, regexps)
+          index = regexps.length
+          regexps << Evaluator.compile_regexp(regexp_str)
+          index
+        rescue RegexpError => exc
+          raise DI::Error::InvalidExpression, "Invalid regular expression in matches: #{exc.class}: #{exc.message}"
         end
       end
     end

data/lib/datadog/di/el/evaluator.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require_relative "../../ruby_version"
+
+require "timeout" if Datadog::RubyVersion.is?("< 3.2")
+
 module Datadog
   module DI
     module EL
@@ -7,6 +11,20 @@ module Datadog
       #
       # @api private
       class Evaluator
+        # Maximum wall-clock time allowed for evaluating a single `matches`
+        # operator.
+        MATCHES_TIMEOUT_SECONDS = 0.5
+
+        # @param regexps [Array<Regexp>] Regexps precompiled from literal
+        #   `matches` patterns, looked up by index by #matches_compiled.
+        #    Empty when the expression has no `matches` pattern with
+        #    a direct regular expression argument.
+        def initialize(regexps = [])
+          @regexps = regexps
+        end
+
+        attr_reader :regexps
+
         def ref(var)
           @context.fetch(var)
         end
@@ -48,10 +66,72 @@ module Datadog
           end
         end
 
+        # Build a Regexp from a pattern string. On Ruby 3.2+ the per-match
+        # timeout (MATCHES_TIMEOUT_SECONDS) is baked into the compiled
+        # Regexp via the in-engine `timeout:` keyword, which interrupts the
+        # matcher at every backtrack step and reliably bounds matcher
+        # runtime regardless of pattern shape. On older Rubies the Regexp
+        # carries no timeout; the bound is applied at match time by
+        # #bounded_match? instead.
+        #
+        # @param needle [String] regexp source.
+        # @return [Regexp] compiled regexp, with baked-in timeout on Ruby 3.2+.
+        if Datadog::RubyVersion.is?(">= 3.2")
+          def self.compile_regexp(needle)
+            Regexp.new(needle, timeout: MATCHES_TIMEOUT_SECONDS)
+          end
+        else
+          def self.compile_regexp(needle)
+            Regexp.compile(needle)
+          end
+        end
+
+        # Match +haystack+ against a regexp whose needle is computed at
+        # evaluation time, so the Regexp cannot be precompiled. Literal needles are
+        # precompiled by the Compiler and dispatched to #matches_compiled.
+        #
+        # @param haystack [String] string to match against.
+        # @param needle [String] regexp source.
+        # @return [Boolean] whether the haystack matches the regexp.
+        # @raise [Regexp::TimeoutError] (Ruby 3.2+) regexp engine exceeded MATCHES_TIMEOUT_SECONDS.
+        # @raise [Timeout::Error] (Ruby < 3.2) Timeout.timeout fired.
         def matches(haystack, needle)
-          re = Regexp.compile(needle)
-          !!(haystack =~ re)
+          bounded_match?(Evaluator.compile_regexp(needle), haystack)
+        end
+
+        # Match +haystack+ against a Regexp precompiled at expression-compile
+        # time, looked up by index in +regexps+.
+        #
+        # @param haystack [String] string to match against.
+        # @param index [Integer] position of the precompiled Regexp in +regexps+.
+        # @return [Boolean] whether the haystack matches the regexp.
+        # @raise [Regexp::TimeoutError] (Ruby 3.2+) regexp engine exceeded MATCHES_TIMEOUT_SECONDS.
+        # @raise [Timeout::Error] (Ruby < 3.2) Timeout.timeout fired.
+        def matches_compiled(haystack, index)
+          bounded_match?(regexps.fetch(index), haystack)
+        end
+
+        # Match +haystack+ against +re+, bounded at MATCHES_TIMEOUT_SECONDS
+        # wall-clock.
+        #
+        # @param re [Regexp] regexp to match against.
+        # @param haystack [String] string to match against.
+        # @return [Boolean] whether the haystack matches the regexp.
+        if Datadog::RubyVersion.is?(">= 3.2")
+          def bounded_match?(re, haystack)
+            # Uses Regexp#match? rather than =~ so that the
+            # thread-local match data ($~, $1, ...) is not mutated as a side
+            # effect of DI expression evaluation.
+            re.match?(haystack)
+          end
+        else
+          def bounded_match?(re, haystack)
+            Timeout.timeout(MATCHES_TIMEOUT_SECONDS) do
+              re.match?(haystack)
+            end
+          end
         end
+        private :bounded_match?
 
         def getmember(object, field)
           object.instance_variable_get("@#{field}")

data/lib/datadog/di/el/expression.rb

@@ -7,7 +7,12 @@ module Datadog
       #
       # @api private
       class Expression
-        def initialize(dsl_expr, compiled_expr)
+        # @param dsl_expr [String] human-readable DSL form, kept for debugging.
+        # @param compiled_expr [String] Ruby source produced by Compiler#compile.
+        # @param regexps [Array<Regexp>] precompiled `matches` regexps (see
+        #   Compiler#precompile_regexp), the second element returned by
+        #   Compiler#compile.
+        def initialize(dsl_expr, compiled_expr, regexps = [])
           unless String === compiled_expr
             raise ArgumentError, "compiled_expr must be a string"
           end
@@ -23,7 +28,10 @@ module Datadog
               end
             RUBY
           end
-          @evaluator = cls.new
+          # cls inherits Evaluator#initialize(regexps), but Steep types
+          # Class#new as () -> untyped and cannot see that initializer
+          # through this dynamically created subclass.
+          @evaluator = cls.new(regexps) # steep:ignore UnexpectedPositionalArgument
         end
 
         attr_reader :dsl_expr

data/lib/datadog/di/el.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'el/expression'
-require_relative 'el/compiler'
-require_relative 'el/evaluator'
+require_relative "el/expression"
+require_relative "el/compiler"
+require_relative "el/evaluator"

data/lib/datadog/di/instrumenter.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative '../core/utils/time'
-require_relative '../ruby_version'
-require_relative 'fatal_exceptions'
-require_relative 'capture_expression_evaluator'
+require_relative "../core/utils/time"
+require_relative "../ruby_version"
+require_relative "fatal_exceptions"
+require_relative "capture_expression_evaluator"
 
 # rubocop:disable Lint/AssignmentInCondition
 # rubocop:disable Style/AndOr
@@ -85,6 +85,12 @@ module Datadog
       attr_reader :telemetry
       attr_reader :code_tracker
 
+      # The code tracker is a global singleton created lazily by
+      # DI.activate_tracking. When DI is enabled after boot via remote
+      # configuration this instrumenter was already built with a nil tracker;
+      # Component#start! assigns the now-current tracker here.
+      attr_writer :code_tracker
+
       def capture_expression_evaluator
         @capture_expression_evaluator ||= CaptureExpressionEvaluator.new(
           settings: settings, serializer: serializer, logger: logger, telemetry: telemetry,
@@ -186,7 +192,7 @@ module Datadog
           # invokes it with yield, which does not dispatch Proc#call, so a
           # user probe on Proc#call cannot intercept the trampoline, and no
           # Proc is allocated for the block.
-          if RubyVersion.is?('>= 3')
+          if RubyVersion.is?(">= 3")
             define_method(method_name) do |*args, **kwargs, &target_block| # steep:ignore NoMethod
               # steep:ignore FallbackAny below: Steep cannot narrow the
               # **kwargs parameter inside this define_method block, so it
@@ -694,7 +700,7 @@ module Datadog
       #
       # Defined only on Ruby < 3; the Ruby 3+ wrapper captures keyword
       # arguments directly and never calls this.
-      if RubyVersion.is?('< 3')
+      if RubyVersion.is?("< 3")
         def kwargs_from_splat(args)
           last = args.last
           if DI.hash?(last)
@@ -860,8 +866,8 @@ module Datadog
                 Utils.path_matches_suffix?(path, working_suffix, case_insensitive: case_insensitive)
               end
               break if found
-              break unless working_suffix.include?('/')
-              working_suffix.sub!(%r{.*/+}, '')
+              break unless working_suffix.include?("/")
+              working_suffix.sub!(%r{.*/+}, "")
             end
             break if found
           end
@@ -875,7 +881,11 @@ module Datadog
         has_per_method = code_tracker&.send(:instance_variable_defined?, :@per_method_registry) &&
           code_tracker.send(:per_method_registry).key?(loaded_path)
 
-        if has_per_method
+        if code_tracker.nil?
+          raise Error::DITargetNotInRegistry,
+            "File #{loaded_path} is loaded but code tracking is not active; " \
+            "line probes cannot be targeted."
+        elsif has_per_method
           raise Error::DITargetNotInRegistry,
             "File #{loaded_path} is loaded and has per-method iseqs, " \
             "but none cover line #{line_no}. " \

data/lib/datadog/di/logger.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'forwardable'
+require "forwardable"
 
 module Datadog
   module DI

data/lib/datadog/di/preload.rb

@@ -4,7 +4,7 @@
 # enable dynamic instrumentation for third-party libraries used by the
 # application.
 
-require_relative 'base'
+require_relative "base"
 
 # Code tracking is required for line probes to work; see the comments
 # on the activate_tracking methods in di.rb for further details.