hyperprobe-agent 1.2.27.pre.1 → 1.2.27.pre.3

data/lib/hyperprobe/core/serializer.rb

@@ -3,6 +3,7 @@
 require 'json'
 require 'time'
 require 'set'
+require 'objspace' unless RUBY_PLATFORM.include?('java')
 
 module HyperProbe
   module Core
@@ -11,413 +12,424 @@ module HyperProbe
       DEFAULT_MAX_ARRAY_LENGTH = 3
       DEFAULT_MAX_OBJECT_PROPERTIES = 50
       DEFAULT_MAX_STRING_LENGTH = 1024
-
-      def initialize(
-        max_depth: DEFAULT_MAX_DEPTH,
-        max_array_length: DEFAULT_MAX_ARRAY_LENGTH,
-        max_object_properties: DEFAULT_MAX_OBJECT_PROPERTIES,
-        max_string_length: DEFAULT_MAX_STRING_LENGTH,
-        redact_keys: nil,
-        redact_values: nil
-      )
-        @max_depth = max_depth || DEFAULT_MAX_DEPTH
-        @max_array_length = max_array_length || DEFAULT_MAX_ARRAY_LENGTH
-        @max_object_properties = max_object_properties || DEFAULT_MAX_OBJECT_PROPERTIES
-        @max_string_length = max_string_length || DEFAULT_MAX_STRING_LENGTH
+      MAX_DEPTH = 16
+      MAX_ITEMS = 128
+      MAX_STRING_BYTES = 4096
+      MAX_NODES = 512
+      MAX_BYTES = 65_536
+      MAX_PATTERNS = 16
+      MAX_PATTERN_BYTES = 256
+      HASH_STORAGE_BYTES = 131_072
+      MEMORY_SIZE = ObjectSpace.method(:memsize_of) if ObjectSpace.respond_to?(:memsize_of)
+      LEGACY_STRING_SLICE = RUBY_PLATFORM.include?('java') && RUBY_VERSION.start_with?('2.6.')
+      BUDGET_MARKER = '[Capture budget exhausted]'
+
+      # Capture implementations once, then bind them directly. Even innocuous
+      # calls such as obj.class, ==, or hash[key] can execute application code.
+      CORE = {
+        klass: Kernel.instance_method(:class),
+        kind: Kernel.instance_method(:is_a?),
+        identity: BasicObject.instance_method(:__id__),
+        equal: BasicObject.instance_method(:equal?),
+        ivars: Kernel.instance_method(:instance_variables),
+        ivar: Kernel.instance_method(:instance_variable_get),
+        class_name: Module.instance_method(:name),
+        string_size: String.instance_method(:bytesize),
+        string_slice: String.instance_method(:byteslice),
+        array_size: Array.instance_method(:length),
+        array_get: Array.instance_method(:[]),
+        hash_size: Hash.instance_method(:size),
+        hash_each: Hash.instance_method(:each_pair),
+        integer_bits: Integer.instance_method(:bit_length),
+        integer_string: Integer.instance_method(:to_s),
+        float_finite: Float.instance_method(:finite?),
+        float_nan: Float.instance_method(:nan?),
+        float_positive: Float.instance_method(:positive?),
+        time_format: Time.instance_method(:strftime),
+        time_utc: Time.instance_method(:utc?),
+        time_compare: Time.instance_method(:<=>),
+        date_format: Date.instance_method(:strftime),
+        date_compare: Date.instance_method(:<=>),
+        proc_lambda: Proc.instance_method(:lambda?),
+        method_name: Method.instance_method(:name),
+        unbound_name: UnboundMethod.instance_method(:name),
+        struct_size: Struct.instance_method(:size),
+        struct_each: Struct.instance_method(:each_pair)
+      }.freeze
+      SYMBOL_NAME = if Symbol.method_defined?(:name)
+                      Symbol.instance_method(:name)
+                    elsif RUBY_PLATFORM.include?('java')
+                      # JRuby shares the symbol's bytes; slice before encoding.
+                      Symbol.instance_method(:to_s)
+                    end
+      if Set.instance_method(:each).source_location.nil? && Set.instance_method(:size).source_location.nil?
+        SET_EACH = Set.instance_method(:each)
+        SET_SIZE = Set.instance_method(:size)
+      end
+      JAVA_SEND = Java::JavaLang::Object.instance_method(:java_send) if RUBY_PLATFORM.include?('java')
+      TIME_MIN = Time.utc(0).freeze
+      TIME_MAX = Time.utc(10_000).freeze
+      DATE_MIN = Date.new(0, 1, 1).freeze
+      DATE_MAX = Date.new(10_000, 1, 1).freeze
+
+      def initialize(max_depth: DEFAULT_MAX_DEPTH,
+                     max_array_length: DEFAULT_MAX_ARRAY_LENGTH,
+                     max_object_properties: DEFAULT_MAX_OBJECT_PROPERTIES,
+                     max_string_length: DEFAULT_MAX_STRING_LENGTH,
+                     redact_keys: nil, redact_values: nil)
+        @max_depth = limit(max_depth, DEFAULT_MAX_DEPTH, MAX_DEPTH)
+        @max_array_length = limit(max_array_length, DEFAULT_MAX_ARRAY_LENGTH, MAX_ITEMS)
+        @max_object_properties = limit(max_object_properties, DEFAULT_MAX_OBJECT_PROPERTIES, MAX_ITEMS)
+        @max_string_length = limit(max_string_length, DEFAULT_MAX_STRING_LENGTH, MAX_STRING_BYTES)
         @redact_keys_re = compile_regex(redact_keys)
         @redact_values_re = compile_regex(redact_values)
+        @capture_lock = Mutex.new
+        @capture_context = nil
       end
 
-      def serialize(obj, path = '$', depth = 0, visited = {})
-        return nil if obj.nil?
-        return obj if obj == true || obj == false
-        return serialize_number(obj) if obj.is_a?(Numeric)
-        return serialize_string(obj) if obj.is_a?(String)
-        return obj.to_s if obj.is_a?(Symbol)
-        return serialize_callable(obj) if callable?(obj)
-        return serialize_time(obj) if time_object?(obj)
-        return serialize_exception(obj) if obj.is_a?(Exception)
-        return serialize_java_throwable(obj) if java_throwable?(obj)
-        return obj.inspect if obj.is_a?(Regexp) || obj.is_a?(Range)
-
-        # Reference / Cycle check (immediate primitives like symbols/integers/floats/true/false are handled above)
-        obj_id = obj.object_id
-        if visited.key?(obj_id)
-          return "[REF - #{visited[obj_id]}]"
-        end
-
-        # Depth check
-        if depth > @max_depth
-          return summary_of(obj)
-        end
-
-        # Track visited for complex objects
-        visited[obj_id] = path
-
-        if obj.is_a?(Array)
-          serialize_array(obj, path, depth, visited)
-        elsif obj.is_a?(Set)
-          serialize_array(obj.to_a, path, depth, visited)
-        elsif obj.is_a?(Hash)
-          serialize_hash(obj, path, depth, visited)
-        elsif java_map?(obj)
-          serialize_java_map(obj, path, depth, visited)
-        elsif java_list?(obj)
-          serialize_java_list(obj, path, depth, visited)
-        elsif java_set?(obj)
-          serialize_java_set(obj, path, depth, visited)
-        elsif obj.is_a?(Struct) || (defined?(OpenStruct) && obj.is_a?(OpenStruct))
-          serialize_struct(obj, path, depth, visited)
-        elsif java_object?(obj)
-          serialize_java_pojo(obj, path, depth, visited)
-        else
-          serialize_object(obj, path, depth, visited)
+      # A supplied visited object is an identity token, never a mutable table.
+      # Keep only the active snapshot's context; a different token replaces it.
+      # Calls without a token use fresh state without disturbing that context.
+      def serialize(obj, path = '$', depth = 0, visited = nil)
+        @capture_lock.synchronize do
+          shared = !core(:equal, visited, nil)
+          if shared && @capture_context && core(:equal, visited, @capture_context[0])
+            state = @capture_context[1]
+          else
+            # Leave room for exhaustion markers while unwinding containers.
+            state = { nodes: MAX_NODES, bytes: MAX_BYTES - 4096, visited: {} }
+            @capture_context = [visited, state] if shared
+          end
+          return BUDGET_MARKER if exhausted?(state)
+          path = kind?(path, String) ? text(path, state) : '$'
+          capture(obj, path, limit(depth, 0, MAX_DEPTH), state)
         end
+      rescue SignalException, SystemExit
+        raise
+      rescue Exception # Snapshot failures must not escape into the client.
+        '[Serialization unavailable]'
       end
 
       def self.safe_dump_json(data)
-        JSON.generate(data)
-      rescue StandardError => e
-        JSON.generate({ 'error' => "JSON serialization failed: #{e.message}" })
-      end
-
-      private
-
-      def compile_regex(patterns)
-        return nil if patterns.nil? || patterns.empty?
-
-        valid = Array(patterns).map(&:to_s).map(&:strip).reject(&:empty?)
-        return nil if valid.empty?
-
-        Regexp.union(valid.map { |p| Regexp.new(p, Regexp::IGNORECASE) })
-      rescue StandardError
-        nil
+        # JSON.generate dispatches to to_json on arbitrary inputs, including
+        # singleton methods on strings/containers. Only give it fresh core data.
+        new.send(:dump_json, data)
+      rescue SignalException, SystemExit
+        raise
+      rescue Exception
+        '{"error":"JSON serialization failed"}'
       end
 
-      def serialize_number(num)
-        if num.is_a?(Float)
-          return 'NaN' if num.nan?
-          return 'Infinity' if num.infinite? && num.positive?
-          return '-Infinity' if num.infinite? && num.negative?
-        end
-        num
+      def finish_capture
+        @capture_lock.synchronize { @capture_context = nil }
       end
 
-      def serialize_string(str)
-        val = str.dup
-        if @redact_values_re && @redact_values_re.match?(val)
-          val = val.gsub(@redact_values_re, '[REDACTED Value]')
-        end
+      private
 
-        if val.length > @max_string_length
-          head = val[0...@max_string_length]
-          # Match Node.js truncated head word boundary trimming
-          truncated_head = head.sub(/\b\w*$/, '').rstrip
-          truncated_head = head if truncated_head.empty?
-          val = "#{truncated_head}... [Truncated: +#{val.length - @max_string_length} more chars]"
-        end
-        val
+      def dump_json(data)
+        # Captures have already spent their budgets. Allow bounded headroom for
+        # frame/watch wrappers and generated summaries/truncation markers, rather
+        # than erasing captured fields by applying capture limits a second time.
+        @max_depth = MAX_DEPTH * 2
+        @max_array_length = @max_object_properties = MAX_NODES * 2
+        @max_string_length = MAX_STRING_BYTES * 2
+        state = { nodes: MAX_NODES * 4, bytes: MAX_BYTES * 2, visited: {} }
+        JSON.generate(capture(data, '$', 0, state))
       end
 
-      def callable?(obj)
-        obj.is_a?(Proc) || obj.is_a?(Method) || obj.is_a?(UnboundMethod)
+      def core(name, obj, *args, &block)
+        CORE.fetch(name).bind(obj).call(*args, &block)
       end
 
-      def serialize_callable(obj)
-        name = if obj.respond_to?(:name) && obj.name
-                 ": #{obj.name}"
-               elsif obj.lambda?
-                 ': (lambda)'
-               else
-                 ''
-               end
-        "[Function#{name}]"
+      def kind?(obj, klass)
+        core(:kind, obj, klass)
       end
 
-      def time_object?(obj)
-        obj.is_a?(Time) || obj.is_a?(Date) || (defined?(DateTime) && obj.is_a?(DateTime))
+      def exact?(obj, klass)
+        core(:equal, core(:klass, obj), klass)
       end
 
-      def serialize_time(obj)
-        obj.respond_to?(:iso8601) ? obj.iso8601 : obj.to_s
+      def limit(value, default, maximum)
+        return default unless exact?(value, Integer)
+        [[value, 0].max, maximum].min
       end
 
-      def serialize_exception(obj)
-        stack = if obj.backtrace
-                  obj.backtrace.first(3).join("\n") + '...'
-                end
-        {
-          'name' => obj.class.name,
-          'message' => obj.message,
-          'stack' => stack
-        }
+      def compile_regex(patterns)
+        return nil if core(:equal, patterns, nil)
+        patterns = [patterns] if kind?(patterns, String)
+        return /\A[\s\S]*\z/ unless exact?(patterns, Array)
+        count = core(:array_size, patterns)
+        return nil if count.zero?
+        return /\A[\s\S]*\z/ if count > MAX_PATTERNS
+
+        sources = []
+        count.times do |i|
+          pattern = core(:array_get, patterns, i)
+          return /\A[\s\S]*\z/ unless kind?(pattern, String)
+          return /\A[\s\S]*\z/ if core(:string_size, pattern) > MAX_PATTERN_BYTES
+          source = core(:string_slice, pattern, 0, MAX_PATTERN_BYTES).encode('UTF-8', invalid: :replace, undef: :replace).strip
+          next if source.empty?
+
+          # Only literal alternatives with optional anchors and escaped literal
+          # punctuation. No repetition, groups, lookaround, backreferences, or
+          # character classes: bounded input alone does not prevent ReDoS.
+          return /\A[\s\S]*\z/ unless /\A\^?(?:[a-zA-Z0-9 _:@,\/-]|\\[.\^$|?*+()\[\]{}\\-])+(?:\|(?:[a-zA-Z0-9 _:@,\/-]|\\[.\^$|?*+()\[\]{}\\-])+)*\$?\z/.match?(source)
+          sources << Regexp.new(source, Regexp::IGNORECASE)
+        end
+        sources.empty? ? nil : Regexp.union(sources)
+      rescue SignalException, SystemExit
+        raise
+      rescue Exception
+        /\A[\s\S]*\z/
       end
 
-      def serialize_array(arr, path, depth, visited)
-        result = []
-        len = [arr.length, @max_array_length].min
-
-        (0...len).each do |i|
-          elem = arr[i]
-          elem_path = "#{path}[#{i}]"
-          result << serialize(elem, elem_path, depth + 1, visited)
-        rescue StandardError => e
-          result << "[Error: #{e.message}]"
-        end
+      def exhausted?(state)
+        state[:nodes] <= 0 || state[:bytes] <= 0
+      end
 
-        if arr.length > @max_array_length
-          result << "[+ #{arr.length - @max_array_length} more items truncated]"
+      def emit(value, state)
+        return BUDGET_MARKER if state[:bytes] <= 0
+        cost = value.bytesize * 6 + 8
+        if cost > state[:bytes]
+          state[:bytes] = 0
+          return BUDGET_MARKER
         end
-
-        result
+        # Account conservatively for JSON escaping and container punctuation.
+        state[:bytes] -= cost
+        value
       end
 
-      def serialize_hash(hash, path, depth, visited)
-        result = {}
-        keys = hash.keys
-        limit = @max_object_properties
-        num_to_process = [keys.length, limit].min
-
-        (0...num_to_process).each do |i|
-          key = keys[i]
-          key_str = key.to_s
-
-          if @redact_keys_re && @redact_keys_re.match?(key_str)
-            result[key_str] = '[REDACTED Key]'
-            next
-          end
+      def bounded_string(str, offset = 0)
+        size = core(:string_size, str) - offset
+        raw = core(:string_slice, str, offset, @max_string_length)
+        # Older JRuby preserves String subclasses on byteslice; normalize the
+        # already-bounded slice before calling encoding methods.
+        raw = String.new(raw) if LEGACY_STRING_SLICE
+        val = raw.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
+        [val, size > @max_string_length, size]
+      end
 
-          child_path = path == '$' ? key_str : "#{path}.#{key_str}"
-          val = hash[key]
-          result[key_str] = serialize(val, child_path, depth + 1, visited)
-        rescue StandardError => e
-          result[key_str] = "[Error accessing property: #{e.message}]"
+      def text(str, state, key: false, offset: 0)
+        val, truncated, size = bounded_string(str, offset)
+        sensitive = key && @redact_keys_re && (truncated || @redact_keys_re.match?(val))
+        if @redact_values_re
+          # A cut can split a secret. With value redaction enabled, do not expose
+          # any prefix of a string whose remaining bytes we have not examined.
+          val = truncated ? '[REDACTED Value]' : val.gsub(@redact_values_re, '[REDACTED Value]')
         end
-
-        if keys.length > limit
-          result['__probe_meta'] = "+ #{keys.length - limit} more properties truncated"
+        if val.bytesize > @max_string_length
+          val = val.byteslice(0, @max_string_length).scrub('?')
+          truncated = true
         end
-
-        result
+        val += "... [Truncated: +#{[size - @max_string_length, 0].max} more bytes]" if truncated
+        result = emit(val, state)
+        key ? [result, sensitive] : result
       end
 
-      def serialize_struct(struct_obj, path, depth, visited)
-        hash = struct_obj.to_h
-        serialize_hash(hash, path, depth, visited)
-      rescue StandardError
-        serialize_object(struct_obj, path, depth, visited)
+      def symbol_text(obj, state)
+        return emit('[Symbol]', state) unless SYMBOL_NAME
+        text(SYMBOL_NAME.bind(obj).call, state)
       end
 
-      # Java Collection & POJO Serialization for JRuby
-      def serialize_java_map(map, path, depth, visited)
-        result = {}
-        keys = (map.respond_to?(:keySet) ? map.keySet.to_a : map.keys) rescue []
-        limit = @max_object_properties
-        num_to_process = [keys.length, limit].min
-
-        (0...num_to_process).each do |i|
-          key = keys[i]
-          key_str = key.to_s
-
-          if @redact_keys_re && @redact_keys_re.match?(key_str)
-            result[key_str] = '[REDACTED Key]'
-            next
-          end
+      def summary(obj, state)
+        name = core(:class_name, core(:klass, obj))
+        name = kind?(name, String) ? text(name, state) : 'anonymous'
+        emit("[Obj: #{name}]", state)
+      end
 
-          child_path = path == '$' ? key_str : "#{path}.#{key_str}"
-          val = map.respond_to?(:get) ? map.get(key) : map[key] rescue map[key]
-          result[key_str] = serialize(val, child_path, depth + 1, visited)
-        rescue StandardError => e
-          result[key_str] = "[Error accessing property: #{e.message}]"
+      def capture(obj, path, depth, state)
+        return BUDGET_MARKER if exhausted?(state)
+        state[:nodes] -= 1
+        state[:bytes] -= 16
+        return nil if core(:equal, obj, nil)
+        return true if core(:equal, obj, true)
+        return false if core(:equal, obj, false)
+        if exact?(obj, Integer)
+          return emit('[Integer: too large]', state) if core(:integer_bits, obj) > 256
+          state[:bytes] -= 80
+          return obj
         end
-
-        if keys.length > limit
-          result['__probe_meta'] = "+ #{keys.length - limit} more properties truncated"
+        if exact?(obj, Float)
+          state[:bytes] -= 32
+          return obj if core(:float_finite, obj)
+          return emit('NaN', state) if core(:float_nan, obj)
+          return emit(core(:float_positive, obj) ? 'Infinity' : '-Infinity', state)
         end
-
-        result
-      end
-
-      def serialize_java_list(list, path, depth, visited)
-        result = []
-        size = (list.respond_to?(:size) ? list.size : list.length) rescue 0
-        len = [size, @max_array_length].min
-
-        (0...len).each do |i|
-          elem = list.respond_to?(:get) ? list.get(i) : list[i] rescue list[i]
-          elem_path = "#{path}[#{i}]"
-          result << serialize(elem, elem_path, depth + 1, visited)
-        rescue StandardError => e
-          result << "[Error: #{e.message}]"
+        return text(obj, state) if kind?(obj, String)
+        return symbol_text(obj, state) if exact?(obj, Symbol)
+        if kind?(obj, Proc)
+          return emit(core(:proc_lambda, obj) ? '[Function: (lambda)]' : '[Function]', state)
         end
-
-        if size > @max_array_length
-          result << "[+ #{size - @max_array_length} more items truncated]"
+        if kind?(obj, Method) || kind?(obj, UnboundMethod)
+          method = kind?(obj, Method) ? :method_name : :unbound_name
+          return emit("[Function: #{symbol_text(core(method, obj), state)}]", state)
         end
-
-        result
-      end
-
-      def serialize_java_set(set, path, depth, visited)
-        arr = (set.respond_to?(:toArray) ? set.toArray.to_a : set.to_a) rescue []
-        serialize_array(arr, path, depth, visited)
-      end
-
-      def serialize_java_throwable(throwable)
-        stack_elements = nil
-        if throwable.respond_to?(:getStackTrace)
-          stack_elements = (throwable.getStackTrace.to_a.first(3).map(&:toString).join("\n") + '...') rescue nil
+        if exact?(obj, Time)
+          # Formatting an astronomical year can allocate an astronomical string.
+          return summary(obj, state) unless core(:time_compare, obj, TIME_MIN) >= 0 && core(:time_compare, obj, TIME_MAX) < 0
+          format = core(:time_utc, obj) ? '%Y-%m-%dT%H:%M:%SZ' : '%Y-%m-%dT%H:%M:%S%:z'
+          return text(core(:time_format, obj, format), state)
+        end
+        if exact?(obj, Date) || exact?(obj, DateTime)
+          return summary(obj, state) unless core(:date_compare, obj, DATE_MIN) >= 0 && core(:date_compare, obj, DATE_MAX) < 0
+          format = exact?(obj, Date) ? '%Y-%m-%d' : '%Y-%m-%dT%H:%M:%S%:z'
+          return text(core(:date_format, obj, format), state)
         end
-        class_name = throwable.respond_to?(:getClass) ? throwable.getClass.getName : throwable.class.name
-        message = throwable.respond_to?(:getMessage) ? throwable.getMessage : throwable.to_s
-        {
-          'name' => class_name,
-          'message' => message || '',
-          'stack' => stack_elements
-        }
-      end
 
-      def serialize_java_pojo(obj, path, depth, visited)
-        ivars = obj.instance_variables rescue []
-        if ivars && !ivars.empty?
-          return serialize_object(obj, path, depth, visited)
+        id = core(:identity, obj)
+        return emit("[REF - #{state[:visited][id][1]}]", state) if state[:visited].key?(id)
+        if depth > @max_depth
+          return emit("[Arr: #{core(:array_size, obj)}]", state) if exact?(obj, Array)
+          return emit("[Obj: #{core(:hash_size, obj)} keys]", state) if exact?(obj, Hash)
+          return summary(obj, state)
         end
+        # Retain bounded references too: object IDs can otherwise be reused by
+        # GC between separate roots sharing the same snapshot token.
+        state[:visited][id] = [obj, path]
 
-        result = {}
-        ignored_methods = %w[getClass getDeclaringClass hashCode toString equals wait notify notifyAll]
-        getters = []
-        begin
-          getters = obj.class.instance_methods(false).select do |m|
-            name = m.to_s
-            (name.start_with?('get') && name.length > 3 || name.start_with?('is') && name.length > 2) && !ignored_methods.include?(name)
+        if exact?(obj, Array)
+          size = core(:array_size, obj)
+          return sequence(size, path, depth, state) { |i| core(:array_get, obj, i) }
+        end
+        if exact?(obj, Set)
+          return summary(obj, state) if defined?(MEMORY_SIZE) && MEMORY_SIZE.call(obj) > HASH_STORAGE_BYTES
+          result = []
+          if defined?(SET_EACH)
+            size = SET_SIZE.bind(obj).call
+            enumerate = ->(&block) { SET_EACH.bind(obj).call(&block) }
+          else
+            hash = core(:ivar, obj, :@hash)
+            return summary(obj, state) unless exact?(hash, Hash)
+            return summary(obj, state) if defined?(MEMORY_SIZE) && MEMORY_SIZE.call(hash) > HASH_STORAGE_BYTES
+            size = core(:hash_size, hash)
+            enumerate = lambda do |&block|
+              core(:hash_each, hash) { |key, _value| block.call(key) }
+            end
+          end
+          enumerate.call do |key|
+            break if result.length >= @max_array_length || exhausted?(state)
+            result << capture(key, "#{path}[#{result.length}]", depth + 1, state)
           end
-        rescue StandardError
-          getters = []
+          append_remaining(result, size, state)
+          return result
         end
-
-        limit = @max_object_properties
-        num_to_process = [getters.length, limit].min
-
-        (0...num_to_process).each do |i|
-          getter_sym = getters[i]
-          raw_name = getter_sym.to_s
-          prop_name = if raw_name.start_with?('get')
-                        raw_name[3..].sub(/^[A-Z]/, &:downcase)
-                      elsif raw_name.start_with?('is')
-                        raw_name[2..].sub(/^[A-Z]/, &:downcase)
-                      else
-                        raw_name
-                      end
-
-          if @redact_keys_re && @redact_keys_re.match?(prop_name)
-            result[prop_name] = '[REDACTED Key]'
-            next
+        if exact?(obj, Hash)
+          return summary(obj, state) if defined?(MEMORY_SIZE) && MEMORY_SIZE.call(obj) > HASH_STORAGE_BYTES
+          return properties(core(:hash_size, obj), path, depth, state) do |&block|
+            core(:hash_each, obj, &block)
           end
-
-          child_path = path == '$' ? prop_name : "#{path}.#{prop_name}"
-          val = obj.public_send(getter_sym)
-          result[prop_name] = serialize(val, child_path, depth + 1, visited)
-        rescue StandardError => e
-          result[prop_name] = "[Error accessing property: #{e.message}]"
         end
-
-        if getters.length > limit
-          result['__probe_meta'] = "+ #{getters.length - limit} more properties truncated"
+        if kind?(obj, Struct)
+          # Struct#each_pair is native, but some runtimes build all member names.
+          size = core(:struct_size, obj)
+          return summary(obj, state) if size > MAX_ITEMS
+          return properties(size, path, depth, state) { |&block| core(:struct_each, obj, &block) }
         end
+        if defined?(OpenStruct) && exact?(obj, OpenStruct)
+          table = core(:ivar, obj, :@table)
+          return capture(table, path, depth, state) if exact?(table, Hash)
+        end
+        return java_capture(obj, path, depth, state) if defined?(JAVA_SEND) && kind?(obj, Java::JavaLang::Object)
 
-        result.empty? ? summary_of(obj) : result
-      end
-
-      def java_object?(obj)
-        return false unless defined?(JRUBY_VERSION) || defined?(Java)
-        return true if defined?(java.lang.Object) && obj.is_a?(java.lang.Object)
-        return true if obj.respond_to?(:java_class)
-        false
-      rescue StandardError
-        false
-      end
-
-      def java_map?(obj)
-        return false unless defined?(JRUBY_VERSION) || defined?(Java)
-        return true if defined?(java.util.Map) && obj.is_a?(java.util.Map)
-        return true if defined?(Java::JavaUtil::Map) && obj.is_a?(Java::JavaUtil::Map)
-        false
-      rescue StandardError
-        false
-      end
-
-      def java_list?(obj)
-        return false unless defined?(JRUBY_VERSION) || defined?(Java)
-        return true if defined?(java.util.List) && obj.is_a?(java.util.List)
-        return true if defined?(Java::JavaUtil::List) && obj.is_a?(Java::JavaUtil::List)
-        false
-      rescue StandardError
-        false
+        return summary(obj, state) unless kind?(obj, Object)
+        # Even bound Exception#to_s calls a message object's to_s on CRuby and
+        # JRuby. Keep exceptions and unsupported built-in subclasses opaque.
+        if [Array, Hash, Set, Numeric, Exception, Regexp, Range, Time, Date].any? { |type| kind?(obj, type) }
+          return summary(obj, state)
+        end
+        return summary(obj, state) if defined?(OpenStruct) && kind?(obj, OpenStruct)
+        return summary(obj, state) if exhausted?(state)
+
+        # Like Node's own-property-name enumeration, this native operation
+        # materializes the full name list. Ruby has no bounded alternative.
+        # Only subsequent field reads, recursion, and output are budget-bounded.
+        names = core(:ivars, obj)
+        size = core(:array_size, names)
+        return summary(obj, state) if size.zero?
+        properties(size, path, depth, state, ivars: true) do |&block|
+          [size, @max_object_properties].min.times do |i|
+            break if exhausted?(state)
+            name = core(:array_get, names, i)
+            block.call(name, core(:ivar, obj, name))
+          end
+        end
+      rescue SignalException, SystemExit
+        raise
+      rescue Exception
+        emit('[Serialization unavailable]', state)
       end
 
-      def java_set?(obj)
-        return false unless defined?(JRUBY_VERSION) || defined?(Java)
-        return true if defined?(java.util.Set) && obj.is_a?(java.util.Set)
-        return true if defined?(Java::JavaUtil::Set) && obj.is_a?(Java::JavaUtil::Set)
-        false
-      rescue StandardError
-        false
+      def sequence(size, path, depth, state)
+        result = []
+        [size, @max_array_length].min.times do |i|
+          break if exhausted?(state)
+          result << capture(yield(i), "#{path}[#{i}]", depth + 1, state)
+        end
+        append_remaining(result, size, state)
+        result
       end
 
-      def java_throwable?(obj)
-        return false unless defined?(JRUBY_VERSION) || defined?(Java)
-        return true if defined?(java.lang.Throwable) && obj.is_a?(java.lang.Throwable)
-        return true if defined?(Java::JavaLang::Throwable) && obj.is_a?(Java::JavaLang::Throwable)
-        false
-      rescue StandardError
-        false
+      def append_remaining(result, size, state)
+        remaining = size - result.length
+        result << emit("[+ #{remaining} more items truncated]", state) if remaining > 0
       end
 
-      def serialize_object(obj, path, depth, visited)
+      def properties(size, path, depth, state, ivars: false, &enumerate)
         result = {}
-        ivars = obj.instance_variables
-        limit = @max_object_properties
-        num_to_process = [ivars.length, limit].min
-
-        (0...num_to_process).each do |i|
-          ivar_sym = ivars[i]
-          key_str = ivar_sym.to_s.sub(/^@/, '')
-
-          if @redact_keys_re && @redact_keys_re.match?(key_str)
-            result[key_str] = '[REDACTED Key]'
-            next
+        count = 0
+        enumerate.call do |key, value|
+          break if count >= @max_object_properties || exhausted?(state)
+          count += 1
+          state[:nodes] -= 1
+          if kind?(key, String)
+            name, sensitive = text(key, state, key: true)
+          elsif exact?(key, Symbol) && SYMBOL_NAME
+            name, sensitive = text(SYMBOL_NAME.bind(key).call, state, key: true, offset: ivars ? 1 : 0)
+          elsif exact?(key, Integer) && core(:integer_bits, key) <= 256
+            name, sensitive = text(core(:integer_string, key), state, key: true)
+          else
+            # Never hash, compare, inspect, or stringify application map keys.
+            name = emit("[Opaque key #{count}]", state)
+            sensitive = !!@redact_keys_re
           end
-
-          child_path = path == '$' ? key_str : "#{path}.#{key_str}"
-          val = obj.instance_variable_get(ivar_sym)
-          result[key_str] = serialize(val, child_path, depth + 1, visited)
-        rescue StandardError => e
-          result[key_str] = "[Error accessing property: #{e.message}]"
-        end
-
-        if ivars.length > limit
-          result['__probe_meta'] = "+ #{ivars.length - limit} more properties truncated"
+          child_path = path == '$' ? name : "#{path}.#{name}"
+          child_path = child_path.byteslice(0, MAX_STRING_BYTES).scrub('?')
+          result[name] = sensitive ? emit('[REDACTED Key]', state) : capture(value, child_path, depth + 1, state)
         end
-
-        # If an object has no instance variables, check if it responds to meaningful getters or to_s
-        if ivars.empty?
-          return summary_of(obj)
-        end
-
+        result['__probe_meta'] = emit("+ #{size - count} more properties truncated", state) if size > count
         result
       end
 
-      def summary_of(obj)
-        return 'null' if obj.nil?
+      def java_call(obj, method, types = [], *args)
+        JAVA_SEND.bind(obj).call(method, types, *args)
+      end
 
-        case obj
-        when String then "[Str: #{obj.length}]"
-        when Array then "[Arr: #{obj.length}]"
-        when Set then "[Set: #{obj.length}]"
-        when Hash then "[Obj: #{obj.length} keys]"
-        when Proc, Method then '[Function]'
+      def java_capture(obj, path, depth, state)
+        # getClass is final. Bound java_send bypasses Ruby singleton overrides;
+        # checking the actual Java class excludes Java/Ruby collection subclasses.
+        name = java_call(java_call(obj, :getClass), :getName)
+        case name
+        when 'java.util.ArrayList', 'java.util.LinkedList'
+          size = java_call(obj, :size)
+          sequence(size, path, depth, state) { |i| java_call(obj, :get, [Java::int], i) }
+        when 'java.util.LinkedHashMap'
+          size = java_call(obj, :size)
+          iterator = java_call(java_call(obj, :entrySet), :iterator)
+          properties(size, path, depth, state) do |&block|
+            [size, @max_object_properties].min.times do
+              break if exhausted?(state) || !java_call(iterator, :hasNext)
+              entry = java_call(iterator, :next)
+              block.call(java_call(entry, :getKey), java_call(entry, :getValue))
+            end
+          end
+        when 'java.util.LinkedHashSet'
+          size = java_call(obj, :size)
+          iterator = java_call(obj, :iterator)
+          sequence(size, path, depth, state) { java_call(iterator, :next) }
         else
-          "[Obj: #{obj.class.name}]"
+          # No POJO getters, Throwable accessors, equals, or toString. HashMap
+          # and HashSet are opaque too: sparse bucket scans have unbounded work.
+          summary(obj, state)
         end
       end
     end