datadog 2.38.0 → 2.39.0

data/lib/datadog/data_streams/transport/stats.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'msgpack'
-require 'zlib'
-require_relative '../../core/transport/parcel'
-require_relative '../../core/transport/request'
-require_relative '../../core/transport/transport'
+require "msgpack"
+require "zlib"
+require_relative "../../core/transport/parcel"
+require_relative "../../core/transport/request"
+require_relative "../../core/transport/transport"
 
 module Datadog
   module DataStreams
@@ -24,8 +24,8 @@ module Datadog
             # Create parcel and request
             parcel = Core::Transport::Parcel.new(
               compressed_data,
-              content_type: 'application/msgpack',
-              content_encoding: 'gzip',
+              content_type: "application/msgpack",
+              content_encoding: "gzip",
             )
             request = Request.new(parcel)
 

data/lib/datadog/data_streams.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative 'data_streams/processor'
-require_relative 'data_streams/pathway_context'
-require_relative 'data_streams/configuration'
-require_relative 'data_streams/extensions'
-require_relative 'core/utils/time'
+require_relative "data_streams/processor"
+require_relative "data_streams/pathway_context"
+require_relative "data_streams/configuration"
+require_relative "data_streams/extensions"
+require_relative "core/utils/time"
 
 module Datadog
   # Datadog Data Streams Monitoring public API.

data/lib/datadog/di/base.rb

@@ -8,11 +8,11 @@
 # are loaded, and also none of the rest of datadog library which also
 # has contrib code in other products.
 
-require_relative 'fatal_exceptions'
-require_relative 'code_tracker'
+require_relative "fatal_exceptions"
+require_relative "code_tracker"
 
 # Needed since this file can be loaded without core
-require_relative '../ruby_version'
+require_relative "../ruby_version"
 
 module Datadog
   # Namespace for Datadog dynamic instrumentation.
@@ -48,7 +48,7 @@ module Datadog
       # DI code.
       def activate_tracking
         # :script_compiled trace point was added in Ruby 2.6.
-        return unless RubyVersion.is?('>= 2.6')
+        return unless RubyVersion.is?(">= 2.6")
 
         begin
           # Activate code tracking by default because line trace points will not work

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

@@ -24,12 +24,12 @@ module Datadog
 
         # 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
@@ -45,8 +45,8 @@ module Datadog
 
         # Steep: https://github.com/soutaro/steep/issues/363
         MULTI_ARG_METHODS = { # steep:ignore IncompatibleAssignment
-          'and' => '&&',
-          'or' => '||',
+          "and" => "&&",
+          "or" => "||",
         }.freeze
 
         def compile_partial(ast)
@@ -57,29 +57,29 @@ module Datadog
             end
             op, target = ast.first
             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,7 +89,7 @@ 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
@@ -111,12 +111,12 @@ module Datadog
               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'
+            when "not"
               "!(#{compile_partial(target)})"
             when *OPERATORS.keys
               unless Array === target && target.length == 2
@@ -125,7 +125,7 @@ module Datadog
               first, second = target
               operator = OPERATORS.fetch(op)
               "(#{compile_partial(first)}) #{operator} (#{compile_partial(second)})"
-            when 'any', 'all', 'filter'
+            when "any", "all", "filter"
               "#{op}(#{compile_partial(target.first)}) { |current_item, current_key, current_value| #{compile_partial(target.last)} }"
             else
               raise DI::Error::InvalidExpression, "Unknown operation: #{op}"
@@ -151,16 +151,16 @@ 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
       end
     end

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.

data/lib/datadog/di/probe_builder.rb

@@ -5,7 +5,7 @@
 require_relative "probe"
 require_relative "capture_expression"
 require_relative "capture_limits"
-require_relative 'el'
+require_relative "el"
 
 module Datadog
   module DI
@@ -24,7 +24,7 @@ module Datadog
     module ProbeBuilder
       # Steep: https://github.com/soutaro/steep/issues/363
       PROBE_TYPES = { # steep:ignore IncompatibleAssignment
-        'LOG_PROBE' => :log,
+        "LOG_PROBE" => :log,
       }.freeze
 
       module_function
@@ -39,16 +39,16 @@ module Datadog
 
       def build_from_remote_config(config, logger:)
         # The validations here are not yet comprehensive.
-        type = config.fetch('type')
+        type = config.fetch("type")
         type_symbol = PROBE_TYPES[type] or raise ArgumentError, "Unrecognized probe type: #{type}"
-        cond = if cond_spec = config['when']
-          unless cond_spec['dsl'] && cond_spec['json']
+        cond = if cond_spec = config["when"]
+          unless cond_spec["dsl"] && cond_spec["json"]
             raise ArgumentError, "Malformed condition specification for probe: #{config}"
           end
-          compiled = EL::Compiler.new.compile(cond_spec['json'])
-          EL::Expression.new(cond_spec['dsl'], compiled)
+          compiled = EL::Compiler.new.compile(cond_spec["json"])
+          EL::Expression.new(cond_spec["dsl"], compiled)
         end
-        capture_expressions = build_capture_expressions(config['captureExpressions'])
+        capture_expressions = build_capture_expressions(config["captureExpressions"])
         capture_expressions = dedup_capture_expressions(capture_expressions, config["id"], logger)
         if !!config["captureSnapshot"] && !capture_expressions.empty?
           logger.debug do
@@ -67,7 +67,7 @@ module Datadog
           # We should not be using the template for anything - we instead
           # use +segments+ - but keep the template for debugging.
           template: config["template"],
-          template_segments: build_template_segments(config['segments']),
+          template_segments: build_template_segments(config["segments"]),
           capture_snapshot: !!config["captureSnapshot"],
           max_capture_depth: config["capture"]&.[]("maxReferenceDepth"),
           max_capture_attribute_count: config["capture"]&.[]("maxFieldCount"),
@@ -92,17 +92,17 @@ module Datadog
           unless Hash === entry
             raise ArgumentError, "captureExpressions entry must be a hash, got: #{entry.class}"
           end
-          name = entry['name']
+          name = entry["name"]
           unless String === name && CAPTURE_EXPRESSION_NAME_PATTERN.match?(name)
             raise ArgumentError, "captureExpressions entry name missing or invalid (must match #{CAPTURE_EXPRESSION_NAME_PATTERN.inspect}): #{name.inspect}"
           end
-          expr_spec = entry['expr']
-          unless Hash === expr_spec && expr_spec['dsl'] && expr_spec['json']
+          expr_spec = entry["expr"]
+          unless Hash === expr_spec && expr_spec["dsl"] && expr_spec["json"]
             raise ArgumentError, "captureExpressions entry #{name}: missing or malformed expr"
           end
-          compiled = EL::Compiler.new.compile(expr_spec['json'])
-          expr = EL::Expression.new(expr_spec['dsl'], compiled)
-          limits = build_capture_limits(entry['capture'])
+          compiled = EL::Compiler.new.compile(expr_spec["json"])
+          expr = EL::Expression.new(expr_spec["dsl"], compiled)
+          limits = build_capture_limits(entry["capture"])
           CaptureExpression.new(name: name, expr: expr, limits: limits)
         end
       end
@@ -126,10 +126,10 @@ module Datadog
           raise ArgumentError, "capture-expression entry capture must be a hash, got: #{raw.class}"
         end
         CaptureLimits.new(
-          max_reference_depth: raw['maxReferenceDepth'],
-          max_collection_size: raw['maxCollectionSize'],
-          max_length: raw['maxLength'],
-          max_field_count: raw['maxFieldCount'],
+          max_reference_depth: raw["maxReferenceDepth"],
+          max_collection_size: raw["maxCollectionSize"],
+          max_length: raw["maxLength"],
+          max_field_count: raw["maxFieldCount"],
         )
       end
 
@@ -146,10 +146,10 @@ module Datadog
       def build_template_segments(segments)
         segments&.map do |segment|
           if Hash === segment
-            if str = segment['str']
+            if str = segment["str"]
               str
-            elsif ast = segment['json']
-              unless dsl = segment['dsl']
+            elsif ast = segment["json"]
+              unless dsl = segment["dsl"]
                 raise ArgumentError, "Missing dsl for json in segment: #{segment}"
               end
               compiled = EL::Compiler.new.compile(ast)

data/lib/datadog/di/probe_file_loader/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.load_probe_file' do |app|
+        initializer "datadog.dynamic_instrumentation.load_probe_file" do |app|
           ProbeFileLoader.load_now
         end
       end

data/lib/datadog/di/probe_file_loader.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
-require_relative 'fatal_exceptions'
+require_relative "fatal_exceptions"
 
 module Datadog
   module DI
     module ProbeFileLoader
       module_function def load_now_or_later
         if Datadog::Core::Contrib::Rails::Utils.railtie_supported?
-          Datadog.logger.debug('di: loading probe_file_loader/railtie')
-          require_relative 'probe_file_loader/railtie'
+          Datadog.logger.debug("di: loading probe_file_loader/railtie")
+          require_relative "probe_file_loader/railtie"
         else
           load_now
         end
@@ -22,7 +22,7 @@ module Datadog
       module_function def load_now
         should_propagate = false
 
-        probe_file_path = DATADOG_ENV['DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE']
+        probe_file_path = DATADOG_ENV["DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE"]
         if probe_file_path.nil? || probe_file_path.empty?
           return
         end

data/lib/datadog/di/probe_manager.rb

@@ -2,7 +2,7 @@
 
 # rubocop:disable Lint/AssignmentInCondition
 
-require_relative 'fatal_exceptions'
+require_relative "fatal_exceptions"
 
 module Datadog
   module DI