datadog 2.36.0 → 2.40.0

data/lib/datadog/symbol_database/extractor.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require_relative 'scope'
-require_relative 'symbol'
-require_relative 'file_hash'
-require_relative '../core/utils/enumerable_compat'
+require_relative "scope"
+require_relative "symbol"
+require_relative "file_hash"
+require_relative "../core/utils/enumerable_compat"
+require_relative "../di/fatal_exceptions"
 
 module Datadog
   module SymbolDatabase
@@ -67,7 +68,7 @@ module Datadog
       # PostgreSQL signed INT_MAX (2^31 - 1). Means "entire file" or "unknown end."
       UNKNOWN_MAX_LINE = 2147483647
 
-      EXCLUDED_COMMON_MODULES = ['Kernel', 'PP::', 'JSON::', 'Enumerable', 'Comparable'].freeze
+      EXCLUDED_COMMON_MODULES = ["Kernel", "PP::", "JSON::", "Enumerable", "Comparable"].freeze
 
       # RubyVM::InstructionSequence#trace_points event types included when
       # computing targetable lines on METHOD scopes.
@@ -89,6 +90,26 @@ module Datadog
       # so we bind the original Module#name to get the real module name safely.
       MODULE_NAME = Module.instance_method(:name)
 
+      # Cached UnboundMethods for the remaining class/module/object introspection
+      # used during extraction. Like MODULE_NAME, these bind the original
+      # implementations and are dispatched explicitly so that application code
+      # which overrides any of them (per-class, on a subclass, or in a singleton
+      # class) can neither intercept extraction nor be executed as a side effect
+      # of it. KERNEL_CLASS recovers an object's real class without calling a
+      # possibly-overridden #class.
+      CLASS_SUPERCLASS = Class.instance_method(:superclass)
+      MODULE_INCLUDED_MODULES = Module.instance_method(:included_modules)
+      MODULE_ANCESTORS = Module.instance_method(:ancestors)
+      MODULE_CLASS_VARIABLES = Module.instance_method(:class_variables)
+      MODULE_CONSTANTS = Module.instance_method(:constants)
+      MODULE_AUTOLOAD_P = Module.instance_method(:autoload?)
+      MODULE_CONST_GET = Module.instance_method(:const_get)
+      MODULE_CONST_DEFINED = Module.instance_method(:const_defined?)
+      KERNEL_CLASS = ::Kernel.instance_method(:class)
+      private_constant :CLASS_SUPERCLASS, :MODULE_INCLUDED_MODULES, :MODULE_ANCESTORS,
+        :MODULE_CLASS_VARIABLES, :MODULE_CONSTANTS, :MODULE_AUTOLOAD_P, :MODULE_CONST_GET,
+        :MODULE_CONST_DEFINED, :KERNEL_CLASS
+
       # @param logger [Logger] Logger instance (SymbolDatabase::Logger facade or compatible)
       # @param settings [Configuration::Settings] Tracer settings
       def initialize(logger:, settings:)
@@ -109,7 +130,7 @@ module Datadog
       # @param mod [Module, Class] The module or class to extract from
       # @return [Scope, nil] FILE scope wrapping extracted scope, or nil if filtered out
       def extract(mod)
-        return nil unless mod.is_a?(Module)
+        return nil unless Module === mod
         mod_name = safe_mod_name(mod)
         return nil unless mod_name
 
@@ -118,15 +139,16 @@ module Datadog
         source_file = find_source_file(mod)
         return nil unless source_file
 
-        inner_scope = if mod.is_a?(Class)
+        inner_scope = if Class === mod
           extract_class_scope(mod)
         else
           extract_module_scope(mod)
         end
 
         wrap_in_file_scope(source_file, [inner_scope])
-      rescue => e
-        @logger.debug { "symdb: failed to extract #{mod_name || '<unknown>'}: #{e.class}: #{e.message}" }
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
+        @logger.debug { "symdb: failed to extract #{mod_name || "<unknown>"}: #{e.class}: #{e.message}" }
         nil
       end
 
@@ -174,7 +196,7 @@ module Datadog
           # returns [key, value] on a non-empty hash and nil when empty, so the
           # `while (pair = ...)` form is the drain. Indexing pair[0]/pair[1] rather
           # than destructuring avoids introducing names into method scope that would
-          # then shadow the else-branch's block parameters on Ruby 2.5/2.6.
+          # then shadow the else-branch's block parameters.
           while (pair = index.shift)
             scope = build_file_scope(pair[0], pair[1])
             yield scope if scope
@@ -190,7 +212,8 @@ module Datadog
           end
           result
         end
-      rescue => e
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
         @logger.debug { "symdb: error in extract_all: #{e.class}: #{e.message}" }
         block_given? ? nil : []
       end
@@ -204,7 +227,8 @@ module Datadog
       # @return [String, nil] Module name or nil
       def safe_mod_name(mod)
         MODULE_NAME.bind(mod).call
-      rescue => e
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
         @logger.debug { "symdb: safe_mod_name failed: #{e.class}: #{e.message}" }
         nil
       end
@@ -228,33 +252,23 @@ module Datadog
       #    subclass with its own binding resolves through the binding, an
       #    inherited autoload triggers nothing.
       #
-      # Ruby 2.7+ adds an inherit parameter to Module#autoload? —
-      # `current.autoload?(sym, false)` cleanly asks "is there an autoload
-      # registered directly on this namespace?". On Ruby 2.5 and 2.6 that
-      # parameter doesn't exist (per Ruby 2.7.0 NEWS), so the fallback
-      # branch uses `current.autoload?(sym)` which also reports inherited
-      # autoloads. The consequence on 2.5/2.6: a subclass binding whose
-      # name collides with an ancestor's pending autoload is conservatively
-      # treated as stale and dropped from extraction. The minimum supported
-      # Ruby is 2.5 per lib/datadog/version.rb, so this fallback ships.
+      # Uses `current.autoload?(sym, false)` (the inherit=false form, added
+      # in Ruby 2.7) so the question is strictly "is there an autoload
+      # registered directly on this namespace?" and ancestors' pending
+      # autoloads at the same name do not affect the result.
       # @param mod_name [String]
       # @param mod [Module]
       # @return [Boolean]
       def resolves_to_same_module?(mod_name, mod)
         current = Object
-        mod_name.split('::').each do |seg|
+        mod_name.split("::").each do |seg|
           sym = seg.to_sym
-          pending_autoload = if RubyVersion.is?('>= 2.7')
-            current.autoload?(sym, false)
-          else
-            current.autoload?(sym)
-          end
-          return false if pending_autoload
-          return false unless current.const_defined?(sym, false)
-          current = current.const_get(sym, false)
+          return false if MODULE_AUTOLOAD_P.bind(current).call(sym, false)
+          return false unless MODULE_CONST_DEFINED.bind(current).call(sym, false)
+          current = MODULE_CONST_GET.bind(current).call(sym, false)
         end
         current.equal?(mod)
-      rescue NameError, ArgumentError
+      rescue NameError, ArgumentError, TypeError
         # Expected "no" outcome for stale/detached classes — the whole point
         # of this predicate. Per the rescue convention in this file's header
         # comment: inner per-item rescues are expected failures, no logging.
@@ -273,7 +287,7 @@ module Datadog
         # Matches Python: packages.is_user_code() excludes ddtrace.*
         # Note: bare 'Datadog' must be checked separately — start_with?('Datadog::')
         # doesn't match the root module itself.
-        return false if mod_name == 'Datadog' || mod_name.start_with?('Datadog::')
+        return false if mod_name == "Datadog" || mod_name.start_with?("Datadog::")
 
         # Exclude Ruby root classes. These are never user code, but
         # find_source_file can return a user-code path for them via
@@ -295,24 +309,24 @@ module Datadog
       def user_code_path?(path)
         # Only absolute paths are real source files. Pseudo-paths like '<main>',
         # '<internal:...>', '(eval)' are not user code.
-        return false unless path.start_with?('/')
+        return false unless path.start_with?("/")
         # Only .rb files are Ruby source. Excludes the Ruby binary
         # (/usr/local/bin/ruby), C extensions (.so/.bundle), and other
         # non-source files that appear in method source_location.
-        return false unless path.end_with?('.rb')
+        return false unless path.end_with?(".rb")
         # Exclude gem paths
-        return false if path.include?('/gems/')
+        return false if path.include?("/gems/")
         # Exclude Ruby stdlib
-        return false if path.include?('/ruby/')
-        return false if path.start_with?('<internal:')
-        return false if path.include?('(eval)')
+        return false if path.include?("/ruby/")
+        return false if path.start_with?("<internal:")
+        return false if path.include?("(eval)")
         # Exclude test code (not application code)
-        return false if path.include?('/spec/')
-        return false if path.include?('/test/')
+        return false if path.include?("/spec/")
+        return false if path.include?("/test/")
         # Exclude Datadog's own library code (e.g., monkey-patched methods from tracing contrib).
         # Without this, stdlib classes like Net::HTTP appear as user code when dd-trace-rb
         # instruments them, because the patched method source points to lib/datadog/tracing/contrib/.
-        return false if path.include?('/lib/datadog/')
+        return false if path.include?("/lib/datadog/")
 
         true
       end
@@ -324,15 +338,10 @@ module Datadog
       # AR models get filtered out as gem code.
       #
       # For namespace-only modules (no instance or singleton methods), falls back to
-      # Module#const_source_location (Ruby 2.7+) to locate the module via its constants.
+      # Module#const_source_location to locate the module via its constants.
       # This handles patterns like `module ApplicationCable; class Channel...; end; end`
       # where the namespace module itself has no methods but defines user-code classes.
       #
-      # On Ruby 2.6 (where const_source_location is unavailable), namespace-only modules
-      # and classes whose only methods are generated (e.g., AR models with only associations)
-      # may not be found — the extraction silently omits them. This is a graceful degradation:
-      # fewer symbols uploaded, no errors.
-      #
       # @param mod [Module] The module
       # @return [String, nil] Source file path or nil
       def find_source_file(mod)
@@ -362,18 +371,19 @@ module Datadog
           fallback ||= path # steep:ignore
         end
 
-        # Try const_source_location (Ruby 2.7+) to find where this class/module is declared.
+        # Use const_source_location to find where this class/module is declared.
         # This handles two cases:
         #   1. Classes with no user-defined methods (e.g. AR models with only associations) whose
         #      generated methods point to gem code — we find the `class Foo` declaration instead.
         #   2. Namespace-only modules (`module Foo; class Bar; end; end`) with no methods at all.
-        if Module.method_defined?(:const_source_location) && mod.name
+        mod_name = safe_mod_name(mod)
+        if mod_name
           # Look up the class/module by its last name component in its enclosing namespace.
-          parts = mod.name.split('::')
+          parts = mod_name.split("::")
           const_name = parts.last
           namespace = if parts.length > 1
             begin
-              Object.const_get(parts[0..-2].join('::')) # steep:ignore
+              MODULE_CONST_GET.bind(Object).call(parts[0..-2].join("::")) # steep:ignore
             rescue NameError
               nil
             end
@@ -384,7 +394,8 @@ module Datadog
           if namespace
             location = begin
               namespace.const_source_location(const_name)
-            rescue => e
+            rescue Exception => e # standard:disable Lint/RescueException
+              Datadog::DI.reraise_if_fatal(e)
               @logger.debug { "symdb: const_source_location(#{const_name}) failed: #{e.class}: #{e.message}" }
               nil
             end
@@ -397,10 +408,11 @@ module Datadog
           end
 
           # Also scan constants defined by mod itself (namespace-only modules).
-          mod.constants(false).each do |child_const_name|
+          MODULE_CONSTANTS.bind(mod).call(false).each do |child_const_name|
             location = begin
               mod.const_source_location(child_const_name)
-            rescue => e
+            rescue Exception => e # standard:disable Lint/RescueException
+              Datadog::DI.reraise_if_fatal(e)
               @logger.debug { "symdb: const_source_location(#{child_const_name}) failed: #{e.class}: #{e.message}" }
               nil
             end
@@ -416,8 +428,9 @@ module Datadog
         end
 
         fallback
-      rescue => e
-        @logger.debug { "symdb: error finding source file for #{safe_mod_name(mod) || '<unknown>'}: #{e.class}: #{e.message}" }
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
+        @logger.debug { "symdb: error finding source file for #{safe_mod_name(mod) || "<unknown>"}: #{e.class}: #{e.message}" }
         nil
       end
 
@@ -434,7 +447,7 @@ module Datadog
         lang[:file_hash] = file_hash if file_hash
 
         Scope.new(
-          scope_type: 'FILE',
+          scope_type: "FILE",
           name: file_path,
           source_file: file_path,
           start_line: UNKNOWN_MIN_LINE,
@@ -452,8 +465,8 @@ module Datadog
         source_file = find_source_file(mod)
 
         Scope.new(
-          scope_type: 'MODULE',
-          name: mod.name,
+          scope_type: "MODULE",
+          name: safe_mod_name(mod),
           source_file: source_file,
           start_line: UNKNOWN_MIN_LINE,
           end_line: UNKNOWN_MAX_LINE,
@@ -470,8 +483,8 @@ module Datadog
         source_file = find_source_file(klass)
 
         Scope.new(
-          scope_type: 'CLASS',
-          name: klass.name,
+          scope_type: "CLASS",
+          name: safe_mod_name(klass),
           source_file: source_file,
           start_line: start_line,
           end_line: end_line,
@@ -502,8 +515,9 @@ module Datadog
         return [UNKNOWN_MIN_LINE, UNKNOWN_MAX_LINE] if starts.empty?
 
         [starts.min, ends.max]
-      rescue => e
-        @logger.debug { "symdb: error calculating line range for #{klass.name}: #{e.class}: #{e.message}" }
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
+        @logger.debug { "symdb: error calculating line range for #{safe_mod_name(klass)}: #{e.class}: #{e.message}" }
         [UNKNOWN_MIN_LINE, UNKNOWN_MAX_LINE]
       end
 
@@ -517,8 +531,9 @@ module Datadog
         # Emitted as an array named super_classes — consistent with Java, .NET, and Python.
         # Array allows for multiple entries if future Ruby versions or mixins expand the chain.
         # Anonymous superclasses (class Foo < Class.new { ... }) have nil name; compact to skip.
-        if klass.superclass && klass.superclass != Object && klass.superclass != BasicObject
-          super_name = klass.superclass.name # steep:ignore
+        superclass = CLASS_SUPERCLASS.bind(klass).call
+        if superclass && !superclass.equal?(Object) && !superclass.equal?(BasicObject)
+          super_name = safe_mod_name(superclass)
           specifics[:super_classes] = [super_name] if super_name
         end
 
@@ -526,7 +541,7 @@ module Datadog
         # included_modules returns the entire ancestor chain's mixins, not only directly
         # included ones. This is intentional: the field reports "modules this class
         # responds to," which is what the consumer (UI navigation, probe context) needs.
-        included = klass.included_modules.map(&:name).reject do |name|
+        included = MODULE_INCLUDED_MODULES.bind(klass).call.map { |m| safe_mod_name(m) }.reject do |name|
           name.nil? || EXCLUDED_COMMON_MODULES.any? { |prefix| name.start_with?(prefix) }
         end
         specifics[:included_modules] = included unless included.empty?
@@ -537,16 +552,17 @@ module Datadog
         # Single-pass collection avoids the intermediate arrays from take_while.map.compact.
         # Test coverage: spec/datadog/symbol_database/extractor_spec.rb tests prepend behavior.
         prepended = []
-        klass.ancestors.each do |a|
-          break if a == klass
-          name = a.name
+        MODULE_ANCESTORS.bind(klass).call.each do |a|
+          break if a.equal?(klass)
+          name = safe_mod_name(a)
           prepended << name if name
         end
         specifics[:prepended_modules] = prepended unless prepended.empty?
 
         specifics
-      rescue => e
-        @logger.debug { "symdb: error building language specifics for #{klass.name}: #{e.class}: #{e.message}" }
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
+        @logger.debug { "symdb: error building language specifics for #{safe_mod_name(klass)}: #{e.class}: #{e.message}" }
         {}
       end
 
@@ -568,8 +584,9 @@ module Datadog
         end
 
         scopes
-      rescue => e
-        @logger.debug { "symdb: failed to extract methods from #{klass.name}: #{e.class}: #{e.message}" }
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
+        @logger.debug { "symdb: failed to extract methods from #{safe_mod_name(klass)}: #{e.class}: #{e.message}" }
         []
       end
 
@@ -590,7 +607,7 @@ module Datadog
         targetable_lines, end_line = extract_targetable_lines(method, line)
 
         Scope.new(
-          scope_type: 'METHOD',
+          scope_type: "METHOD",
           name: method_name.to_s,
           source_file: source_file,
           start_line: line,
@@ -603,8 +620,9 @@ module Datadog
           },
           symbols: extract_method_parameters(method)
         )
-      rescue => e
-        @logger.debug { "symdb: failed to extract method #{klass.name}##{method_name}: #{e.class}: #{e.message}" }
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
+        @logger.debug { "symdb: failed to extract method #{safe_mod_name(klass)}##{method_name}: #{e.class}: #{e.message}" }
         nil
       end
 
@@ -614,11 +632,11 @@ module Datadog
       # @return [String] 'public', 'private', or 'protected'
       def method_visibility(klass, method_name)
         if klass.private_instance_methods(false).include?(method_name)
-          'private'
+          "private"
         elsif klass.protected_instance_methods(false).include?(method_name)
-          'protected'
+          "protected"
         else
-          'public'
+          "public"
         end
       end
 
@@ -644,7 +662,7 @@ module Datadog
         end_line = lines.max || start_line
         ranges = build_targetable_ranges(lines)
         result = ranges.empty? ? nil : ranges
-        @logger.debug { "symdb: #{method.name} targetable lines: #{result ? "#{ranges.size} range(s), lines #{lines.first}..#{lines.last}" : 'none (no matching events)'}" }
+        @logger.debug { "symdb: #{method.name} targetable lines: #{result ? "#{ranges.size} range(s), lines #{lines.first}..#{lines.last}" : "none (no matching events)"}" }
         [result, end_line]
       end
 
@@ -681,9 +699,10 @@ module Datadog
       def extract_method_parameters(method)
         method_name = begin
           method.name.to_s
-        rescue => e
+        rescue Exception => e # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(e)
           @logger.debug { "symdb: method.name failed: #{e.class}: #{e.message}" }
-          'unknown'
+          "unknown"
         end
         params = method.parameters
 
@@ -698,12 +717,13 @@ module Datadog
           next if param_name.nil?
 
           Symbol.new(
-            symbol_type: 'ARG',
+            symbol_type: "ARG",
             name: param_name.to_s,
             line: UNKNOWN_MIN_LINE,  # Parameters available in entire method
           )
         end
-      rescue => e
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
         @logger.debug { "symdb: failed to extract parameters from #{method_name}: #{e.class}: #{e.message}" }
         []
       end
@@ -743,11 +763,7 @@ module Datadog
         ObjectSpace.each_object(Module) do |mod|
           # Singleton classes (per-object metaclasses) are never user-code classes.
           # They're not const-referenced, DI cannot instrument methods on a singular
-          # object instance, and on Ruby 2.6 specifically, Module#name on unnamed
-          # singleton classes with long ancestor chains (e.g. through monkey-patches
-          # prepended into Kernel, common in dd-trace-rb test processes) is O(ancestors)
-          # — measured ~20ms per call, which dominates extract_all on heavily-loaded
-          # processes. Ruby 2.7+ optimized this path; the skip is a no-op there.
+          # object instance, so skipping them is both correct and cheap.
           next if MODULE_SINGLETON_CLASS_PRED.bind(mod).call
 
           seen += 1
@@ -772,8 +788,9 @@ module Datadog
           file_to_names.each do |file_path, method_names|
             (index[file_path] ||= []) << [mod_name, mod, method_names]
           end
-        rescue => e
-          @logger.debug { "symdb: error indexing #{mod_name || '<unknown>'}: #{e.class}: #{e.message}" }
+        rescue Exception => e # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(e)
+          @logger.debug { "symdb: error indexing #{mod_name || "<unknown>"}: #{e.class}: #{e.message}" }
         end
 
         index
@@ -797,13 +814,15 @@ module Datadog
             next unless user_code_path?(loc[0])
 
             result[loc[0]] << method_name
-          rescue => e
+          rescue Exception => e # standard:disable Lint/RescueException
+            Datadog::DI.reraise_if_fatal(e)
             @logger.debug { "symdb: error indexing method #{method_name}: #{e.class}: #{e.message}" }
           end
         end
 
         result
-      rescue => e
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
         @logger.debug { "symdb: error indexing methods: #{e.class}: #{e.message}" }
         {}
       end
@@ -821,12 +840,12 @@ module Datadog
         return nil if entries.empty?
 
         root = {
-          name: file_path, type: 'FILE', children: {},
+          name: file_path, type: "FILE", children: {},
           methods: [], mod: nil, source_file: file_path, fqn: nil,
         }
 
         # Sort by FQN depth so parent namespaces are placed before children.
-        sorted = entries.sort_by { |(mod_name, _, _)| mod_name.count(':') }
+        sorted = entries.sort_by { |(mod_name, _, _)| mod_name.count(":") }
 
         sorted.each do |mod_name, mod, method_names|
           # Resolve UnboundMethods for this (mod, file) just-in-time. These objects
@@ -844,7 +863,8 @@ module Datadog
             loc = method.source_location
             next nil unless loc && loc[0] == file_path
             {name: name, method: method, type: :instance}
-          rescue => e
+          rescue Exception => e # standard:disable Lint/RescueException
+            Datadog::DI.reraise_if_fatal(e)
             @logger.debug { "symdb: error resolving #{mod_name}##{name}: #{e.class}: #{e.message}" }
             nil
           end
@@ -855,9 +875,10 @@ module Datadog
           # the module no longer lives in.
           next if method_names.any? && method_infos.empty?
 
-          parts = mod_name.split('::')
+          parts = mod_name.split("::")
           place_in_tree(root, parts, mod, mod_name, method_infos, file_path)
-        rescue => e
+        rescue Exception => e # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(e)
           @logger.debug { "symdb: error placing #{mod_name} in tree: #{e.class}: #{e.message}" }
         end
 
@@ -880,7 +901,7 @@ module Datadog
 
         # Create/find intermediate nodes for each namespace segment except the last
         name_parts[0..-2].each_with_index do |part, idx| # steep:ignore
-          fqn = name_parts[0..idx].join('::') # steep:ignore
+          fqn = name_parts[0..idx].join("::") # steep:ignore
           current[:children][part] ||= {
             name: fqn, type: resolve_scope_type(fqn),
             children: {}, methods: [], mod: nil,
@@ -895,12 +916,12 @@ module Datadog
         if leaf
           # Node exists (was created as intermediate or from another entry).
           # Update type and mod — the actual module object is authoritative.
-          leaf[:type] = mod.is_a?(Class) ? 'CLASS' : 'MODULE'
+          leaf[:type] = (Class === mod) ? "CLASS" : "MODULE"
           leaf[:mod] = mod
         else
           leaf = {
             name: mod_name,
-            type: mod.is_a?(Class) ? 'CLASS' : 'MODULE',
+            type: (Class === mod) ? "CLASS" : "MODULE",
             children: {}, methods: [],
             mod: mod, source_file: file_path,
             fqn: mod_name
@@ -917,11 +938,23 @@ module Datadog
       # @param fqn [String] Fully-qualified name (e.g. "Authentication::Strategies")
       # @return [String] 'CLASS' or 'MODULE'
       def resolve_scope_type(fqn)
-        const = Object.const_get(fqn)
-        const.is_a?(Class) ? 'CLASS' : 'MODULE'
-      rescue => e
+        current = Object
+        fqn.split("::").each do |seg|
+          sym = seg.to_sym
+          pending_autoload = if RubyVersion.is?(">= 2.7")
+            MODULE_AUTOLOAD_P.bind(current).call(sym, false)
+          else
+            MODULE_AUTOLOAD_P.bind(current).call(sym)
+          end
+          return "MODULE" if pending_autoload
+          return "MODULE" unless MODULE_CONST_DEFINED.bind(current).call(sym, false)
+          current = MODULE_CONST_GET.bind(current).call(sym, false)
+        end
+        (Class === current) ? "CLASS" : "MODULE"
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
         @logger.debug { "symdb: resolve_scope_type(#{fqn}) failed: #{e.class}: #{e.message}, defaulting to MODULE" }
-        'MODULE'
+        "MODULE"
       end
 
       # Convert a single file tree (built by build_file_scope) to a FILE Scope.
@@ -934,7 +967,7 @@ module Datadog
         lang[:file_hash] = file_hash if file_hash
 
         Scope.new(
-          scope_type: 'FILE',
+          scope_type: "FILE",
           name: file_path,
           source_file: file_path,
           start_line: UNKNOWN_MIN_LINE,
@@ -968,7 +1001,7 @@ module Datadog
         symbols = node[:mod] ? extract_scope_symbols(node[:mod]) : []
 
         # Build language specifics
-        lang = if node[:type] == 'CLASS' && node[:mod]
+        lang = if node[:type] == "CLASS" && node[:mod]
           build_class_language_specifics(node[:mod])
         else
           {}
@@ -1001,21 +1034,22 @@ module Datadog
         targetable_lines, end_line = extract_targetable_lines(method, line)
 
         Scope.new(
-          scope_type: 'METHOD',
+          scope_type: "METHOD",
           name: method_name.to_s,
           source_file: source_file,
           start_line: line,
           end_line: end_line,
           targetable_lines: targetable_lines,
           language_specifics: {
-            visibility: klass ? method_visibility(klass, method_name) : 'public', # steep:ignore
-            method_type: 'instance',
+            visibility: klass ? method_visibility(klass, method_name) : "public", # steep:ignore
+            method_type: "instance",
             arity: method.arity
           },
           symbols: extract_method_parameters(method)
         )
-      rescue => e
-        klass_name = klass ? (safe_mod_name(klass) || '<unknown>') : '<unknown>'
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
+        klass_name = klass ? (safe_mod_name(klass) || "<unknown>") : "<unknown>"
         @logger.debug { "symdb: failed to build method scope #{klass_name}##{method_name}: #{e.class}: #{e.message}" }
         nil
       end
@@ -1028,10 +1062,10 @@ module Datadog
         symbols = []
 
         # Class variables (only for classes)
-        if mod.is_a?(Class)
-          mod.class_variables(false).each do |var_name|
+        if Class === mod
+          MODULE_CLASS_VARIABLES.bind(mod).call(false).each do |var_name|
             symbols << Symbol.new(
-              symbol_type: 'STATIC_FIELD',
+              symbol_type: "STATIC_FIELD",
               name: var_name.to_s,
               line: UNKNOWN_MIN_LINE
             )
@@ -1040,31 +1074,34 @@ module Datadog
 
         # Constants (excluding nested modules/classes).
         # Skip autoloaded constants to avoid triggering loading as a side effect.
-        mod.constants(false).each do |const_name|
-          next if mod.autoload?(const_name)
-          const_value = mod.const_get(const_name)
-          next if const_value.is_a?(Module)
+        MODULE_CONSTANTS.bind(mod).call(false).each do |const_name|
+          next if MODULE_AUTOLOAD_P.bind(mod).call(const_name)
+          const_value = MODULE_CONST_GET.bind(mod).call(const_name)
+          next if Module === const_value
 
           symbols << Symbol.new(
-            symbol_type: 'STATIC_FIELD',
+            symbol_type: "STATIC_FIELD",
             name: const_name.to_s,
             line: UNKNOWN_MIN_LINE,
-            type: const_value.class.name
+            type: safe_mod_name(KERNEL_CLASS.bind(const_value).call)
           )
-        rescue NameError, LoadError, NoMethodError => e # standard:disable Lint/ShadowedException
-          # Expected: constant removed/undefined, autoload failure, or const value missing
-          # #class. Logged separately from unexpected errors so the latter stand out in triage.
-          # Lint/ShadowedException disabled: NameError/NoMethodError do descend from
-          # StandardError, but Ruby's rescue-clause-order semantics ensure the bare rescue
-          # below only catches exceptions not matched here.
+        rescue NameError, LoadError, NoMethodError, TypeError => e # standard:disable Lint/ShadowedException
+          # Expected: constant removed/undefined (NameError), autoload failure (LoadError),
+          # or a value whose class cannot be read (NoMethodError/TypeError). Skipping one
+          # constant here keeps the rest of the module's symbols. Logged separately from
+          # unexpected errors so the latter stand out in triage. Lint/ShadowedException
+          # disabled: these descend from StandardError, but Ruby's rescue-clause-order
+          # semantics ensure the catch-all rescue below only catches exceptions not matched here.
           @logger.debug { "symdb: skipping module constant #{const_name}: #{e.class}: #{e.message}" }
-        rescue => e
+        rescue Exception => e # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(e)
           @logger.debug { "symdb: unexpected error reading module constant #{const_name}: #{e.class}: #{e.message}" }
         end
 
         symbols
-      rescue => e
-        mod_name = safe_mod_name(mod) || '<unknown>'
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
+        mod_name = safe_mod_name(mod) || "<unknown>"
         @logger.debug { "symdb: failed to extract symbols from #{mod_name}: #{e.class}: #{e.message}" }
         []
       end