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

data/lib/hyperprobe/core/monitoring_engine.rb

@@ -2,18 +2,35 @@
 
 require 'set'
 require 'json'
+require 'monitor'
+require 'debug_inspector' if RUBY_ENGINE == 'ruby'
+require 'objspace' if RUBY_ENGINE == 'ruby'
 require_relative 'logger'
-
-begin
-  require 'binding_of_caller'
-rescue LoadError
-  # binding_of_caller is optional
-end
+require_relative 'evaluator'
+require_relative 'lexical_scope'
 
 module HyperProbe
   module Core
     class MonitoringEngine
       DURATION_TTL_SECONDS = 60.0
+      MAX_DURATION_ENTRIES = 10_000
+      MAX_PROBES = 100
+      MAX_STACK_FRAMES = 16
+      MAX_CALLER_SCOPES = 256
+      MAX_INSPECTOR_STACK_DEPTH = 128
+      MAX_CALLER_ISEQS = 32
+      MAX_CALLER_ISEQ_BYTES = 16_384
+      ISEQ_TO_A = RubyVM::InstructionSequence.instance_method(:to_a) if RUBY_ENGINE == 'ruby'
+      ISEQ_EACH_CHILD = RubyVM::InstructionSequence.instance_method(:each_child) if RUBY_ENGINE == 'ruby'
+      ISEQ_MEMORY_SIZE = ObjectSpace.method(:memsize_of) if RUBY_ENGINE == 'ruby'
+      LOCAL_VARIABLES = Binding.instance_method(:local_variables)
+      LOCAL_GET = Binding.instance_method(:local_variable_get)
+      MODULE_NAME = Module.instance_method(:name)
+      SINGLETON_CLASS = Module.instance_method(:singleton_class?)
+      INSTANCE_METHODS = Module.instance_method(:instance_methods)
+      INSTANCE_METHOD = Module.instance_method(:instance_method)
+      METHODS = Kernel.instance_method(:methods)
+      METHOD = Kernel.instance_method(:method)
 
       LEVEL_COLORS = {
         'ERROR' => "\e[31m",
@@ -34,40 +51,59 @@ module HyperProbe
         @on_capture = on_capture
         @custom_set_trace_id = custom_set_trace_id
 
-        @mutex = Mutex.new
+        @mutex = Monitor.new
+        @path_mutex = Monitor.new
         @active_locations = {} # [resolved_file_path, line] => Array<ActiveProbeContext>
         @probe_map = {}        # probe_id => Probe
         @instrumented_files = Set.new
         @path_cache = {}
+        @caller_locals_cache = ObjectSpace::WeakMap.new if RUBY_ENGINE == 'ruby'
         @duration_starts = {}  # [probe_id, correlation_id] => [start_time_monotonic, created_at_time]
         @next_duration_cleanup = monotonic_time + DURATION_TTL_SECONDS
 
         @global_config = {}
+        @safe_evaluation = Evaluator.safe_evaluation_enabled?
         @total_hits = 0
         @total_skips = 0
         @is_suspended = false
         @is_active = false
         @closed = false
+        @owner_pid = Process.pid
+        @generation = -1
 
         @log = Logger.get_logger('hyperprobe:inspector')
         @targeted_tracepoints = {} # location_key => TracePoint instance
+        # JRuby's compiled LINE site is activated by CALL/RETURN interest.
+        # Share one empty activation hook rather than adding CALL to every probe.
+        @jruby_call_hook = TracePoint.new(:call) {} if RUBY_PLATFORM.include?('java')
+        @stdout_queue = SizedQueue.new(100)
+        @stdout_thread = Thread.new do
+          loop { $stdout.write(@stdout_queue.pop) }
+        rescue Exception
+          # A broken or blocked output stream must only affect the agent worker.
+        end
+        @stdout_thread.name = 'hyperprobe-stdout'
       end
 
       def set_global_config(config)
         @mutex.synchronize do
           @global_config = (config || {}).dup
+          disabled = @global_config.fetch(:disable_safe_evaluation) { @global_config['disable_safe_evaluation'] }
+          @safe_evaluation = Evaluator.safe_evaluation_enabled?(disabled)
         end
       end
 
-      def set_probes(probes)
+      def set_probes(probes, generation: nil)
         @mutex.synchronize do
           return if @closed
+          return if generation && generation <= @generation
+          @generation = generation if generation
 
           new_active_locations = {}
           new_probe_map = {}
           new_instrumented_files = Set.new
 
-          Array(probes).each do |probe|
+          Array(probes).first(MAX_PROBES).each do |probe|
             probe_id = probe.respond_to?(:id) ? probe.id : probe[:id]
             next unless probe_id
 
@@ -80,10 +116,15 @@ module HyperProbe
             primary_key = [resolved_path, runtime_line]
 
             new_active_locations[primary_key] ||= []
-            new_active_locations[primary_key] << { probe: probe, is_secondary: false }
+            probe_type = probe.respond_to?(:type) ? probe.type : probe[:type]
+            local_names = nil
+            if probe_type_to_i(probe_type) == 1
+              previous = @active_locations[primary_key]&.find { |ctx| ctx[:probe].equal?(probe) && !ctx[:is_secondary] }
+              local_names = previous ? previous[:local_names] : LexicalScope.locals_for(resolved_path, runtime_line)
+            end
+            new_active_locations[primary_key] << { probe: probe, is_secondary: false, local_names: local_names }
             new_instrumented_files.add(resolved_path)
 
-            probe_type = probe.respond_to?(:type) ? probe.type : probe[:type]
             # Duration secondary location
             is_duration = probe_type == 5 || probe_type == :PROBE_TYPE_DURATION
             if is_duration
@@ -104,6 +145,7 @@ module HyperProbe
           @active_locations = new_active_locations
           @probe_map = new_probe_map
           @instrumented_files = new_instrumented_files
+          @duration_starts.delete_if { |(id, _), _entry| !new_probe_map.key?(id) }
 
           update_tracepoint_state_unlocked
         end
@@ -138,6 +180,7 @@ module HyperProbe
       end
 
       def close
+        @stdout_thread&.kill
         @mutex.synchronize do
           return if @closed
 
@@ -147,9 +190,21 @@ module HyperProbe
           @probe_map.clear
           @instrumented_files.clear
           @duration_starts.clear
+          @caller_locals_cache = nil
         end
       end
 
+      def after_fork
+        # The child must not acquire locks or use resources owned by parent threads.
+        @closed = true
+        @is_suspended = true
+        @targeted_tracepoints.each_value { |tp| tp.disable rescue nil }
+        @jruby_call_hook&.disable
+        @is_active = false
+      rescue Exception
+        nil
+      end
+
       private
 
       def update_tracepoint_state_unlocked
@@ -158,6 +213,8 @@ module HyperProbe
           return
         end
 
+        @jruby_call_hook&.enable
+
         # 1. Remove stale tracepoints
         active_keys = @active_locations.keys.to_set
         @targeted_tracepoints.delete_if do |loc_key, tp|
@@ -177,51 +234,71 @@ module HyperProbe
         @is_active = !@targeted_tracepoints.empty?
       end
 
-      def enable_location_tracepoint_unlocked(loc_key)
-        resolved_path, lineno = loc_key
-
-        tp = TracePoint.new(:line) do |t|
-          next if @is_suspended || @closed
-
-          # Check path match
-          t_path = @path_cache[t.path] || resolve_filepath(t.path)
-          next unless t_path == resolved_path && t.lineno == lineno
+      def create_tracepoint_for_location(loc_key, resolved_path, lineno)
+        TracePoint.new(:line) do |t|
+          next if @is_suspended || @closed || @owner_pid != Process.pid
+          # Fast integer check first to minimize overhead on uninstrumented lines
+          next unless t.lineno == lineno
 
           contexts = nil
-          @mutex.synchronize do
+          # Never wait for installation or shutdown on an application thread.
+          next unless @mutex.try_enter
+          begin
+            # Installation resolves symlinks; never resolve filesystem paths here.
+            next unless t.path == resolved_path || @path_cache[t.path] == resolved_path || File.expand_path(t.path) == resolved_path
             contexts = @active_locations[loc_key]
+            if contexts && !contexts.empty?
+              handle_hit(contexts, t.binding)
+            end
+          ensure
+            @mutex.exit
           end
-
-          if contexts && !contexts.empty?
-            binding_ctx = t.binding
-            handle_hit(contexts, binding_ctx)
-          end
+        rescue SignalException, SystemExit
+          raise
+        rescue Exception
+          # Includes trap-context ThreadError; host termination remains untouched.
+          # This boundary never encloses application code.
+          nil
         end
+      end
+
+      def enable_location_tracepoint_unlocked(loc_key)
+        resolved_path, lineno = loc_key
 
         target_method = find_method_target(resolved_path, lineno)
         targeted_enabled = false
+        tp = nil
 
         if target_method
           begin
+            tp = create_tracepoint_for_location(loc_key, resolved_path, lineno)
             tp.enable(target: target_method, target_line: lineno)
             targeted_enabled = true
           rescue ArgumentError, StandardError
-            # Target option not accepted by interpreter
+            # Target option not accepted by interpreter or line is outside method instructions.
+            # Must discard and disable this TracePoint because CRuby does not allow un-targeted
+            # re-enable on a TracePoint instance once target has been attempted.
+            tp&.disable rescue nil
+            tp = nil
+            targeted_enabled = false
           end
         end
 
         unless targeted_enabled
           begin
+            tp = create_tracepoint_for_location(loc_key, resolved_path, lineno)
             tp.enable
           rescue StandardError
             # TracePoint enable error
+            tp = nil
           end
         end
 
-        @targeted_tracepoints[loc_key] = tp
+        @targeted_tracepoints[loc_key] = tp if tp
       end
 
       def disable_all_tracepoints_unlocked
+        @jruby_call_hook&.disable
         @targeted_tracepoints.each_value do |tp|
           tp.disable rescue nil
         end
@@ -229,17 +306,48 @@ module HyperProbe
         @is_active = false
       end
 
+      def method_line_range(m)
+        return nil unless defined?(RubyVM::InstructionSequence) && RubyVM::InstructionSequence.respond_to?(:of)
+
+        iseq = RubyVM::InstructionSequence.of(m) rescue nil
+        return nil unless iseq
+
+        data = iseq.to_a[4] rescue nil
+        if data.is_a?(Hash) && data[:code_location]
+          loc = data[:code_location]
+          return (loc[0]..loc[2]) if loc.is_a?(Array) && loc.length >= 3
+        end
+
+        lines = []
+        collect_lines = ->(seq) {
+          (seq.trace_points rescue []).each { |tp_info| lines << tp_info[0] }
+          (seq.each_child rescue []).each { |child| collect_lines.call(child) }
+        }
+        collect_lines.call(iseq)
+        return (lines.min..lines.max) unless lines.empty?
+
+        nil
+      rescue StandardError
+        nil
+      end
+
       def find_method_target(file_path, line_number)
+        return nil unless defined?(RubyVM::InstructionSequence)
         best_match = nil
         best_line = 0
+        deadline = monotonic_time + 0.05
 
         ObjectSpace.each_object(Module) do |mod|
-          next if mod.singleton_class? || mod.name.nil?
+          break if monotonic_time >= deadline
+          next if SINGLETON_CLASS.bind(mod).call || MODULE_NAME.bind(mod).call.nil?
 
           [:instance_methods, :methods].each do |mtype|
-            methods_list = mod.send(mtype, false) rescue []
+            implementation = mtype == :instance_methods ? INSTANCE_METHODS : METHODS
+            methods_list = implementation.bind(mod).call(false)
             methods_list.each do |sym|
-              m = (mtype == :instance_methods ? mod.instance_method(sym) : mod.method(sym)) rescue nil
+              break if monotonic_time >= deadline
+              implementation = mtype == :instance_methods ? INSTANCE_METHOD : METHOD
+              m = implementation.bind(mod).call(sym) rescue nil
               next unless m
 
               loc = m.source_location
@@ -248,10 +356,16 @@ module HyperProbe
               m_file = loc[0]
               m_line = loc[1]
 
-              if (m_file == file_path || resolve_filepath(m_file) == file_path) && m_line <= line_number && m_line > best_line
-                best_match = m
-                best_line = m_line
+              next unless m_line <= line_number && m_line > best_line
+              next unless m_file == file_path || @path_cache[m_file] == file_path || File.expand_path(m_file) == file_path
+
+              range = method_line_range(m)
+              if range
+                next unless range.cover?(line_number)
               end
+
+              best_match = m
+              best_line = m_line
             end
           end
         end
@@ -264,12 +378,12 @@ module HyperProbe
       def resolve_filepath(runtime_location)
         return '' if runtime_location.nil? || runtime_location.empty?
 
-        cached = @path_cache[runtime_location]
+        cached = @path_mutex.synchronize { @path_cache[runtime_location] }
         return cached if cached
 
         if File.exist?(runtime_location)
           resolved = File.realpath(runtime_location) rescue File.expand_path(runtime_location)
-          @path_cache[runtime_location] = resolved
+          @path_mutex.synchronize { @path_cache[runtime_location] = resolved }
           return resolved
         end
 
@@ -280,13 +394,13 @@ module HyperProbe
           attempt = File.expand_path(suffix, cwd)
           if File.exist?(attempt)
             resolved = File.realpath(attempt) rescue attempt
-            @path_cache[runtime_location] = resolved
+            @path_mutex.synchronize { @path_cache[runtime_location] = resolved }
             return resolved
           end
         end
 
         fallback = File.expand_path(runtime_location, cwd)
-        @path_cache[runtime_location] = fallback
+        @path_mutex.synchronize { @path_cache[runtime_location] = fallback }
         fallback
       end
 
@@ -296,23 +410,30 @@ module HyperProbe
           contexts.each do |ctx|
             probe = ctx[:probe]
             is_secondary = ctx[:is_secondary]
-            process_single_probe_hit(probe, binding_ctx, is_secondary)
+            process_single_probe_hit(probe, binding_ctx, is_secondary, ctx[:local_names])
+          rescue SignalException, SystemExit
+            raise
+          rescue Exception
+            # One broken probe must not prevent another probe or the host line.
+            next
           end
-        rescue StandardError => e
-          # Never crash application thread on probe hit
+        rescue SignalException, SystemExit
+          raise
+        rescue Exception
+          nil
         ensure
           elapsed_ms = (monotonic_time - start_time) * 1000.0
           @safety_monitor.report_pause_duration(elapsed_ms) rescue nil
         end
       end
 
-      def process_single_probe_hit(probe, binding_ctx, is_secondary)
+      def process_single_probe_hit(probe, binding_ctx, is_secondary, local_names = nil)
         probe_id = probe.respond_to?(:id) ? probe.id : probe[:id]
         probe_type = probe.respond_to?(:type) ? probe.type : probe[:type]
         probe_type_num = probe_type.is_a?(Integer) ? probe_type : probe_type_to_i(probe_type)
 
         # 1. Rate-limiting admission check
-        unless @quota_manager.can_evaluate?
+        unless probe_type_num == 5 || @quota_manager.can_evaluate?
           @mutex.synchronize { @total_skips += 1 }
           return
         end
@@ -321,9 +442,9 @@ module HyperProbe
         condition = probe.respond_to?(:condition) ? probe.condition : probe[:condition]
         if condition && !condition.empty?
           begin
-            passed = Evaluator.eval_condition(condition, binding_ctx)
+            passed = Evaluator.eval_condition(condition, binding_ctx, safe: @safe_evaluation)
             return unless passed
-          rescue StandardError, ScriptError => e
+          rescue StandardError, ScriptError, SecurityError => e
             report_error(probe_id, "Condition evaluation failed: #{e.class.name}: #{e.message}")
             return
           end
@@ -332,7 +453,7 @@ module HyperProbe
         # 3. Dispatch to Probe Type Handler
         case probe_type_num
         when 1 # SNAPSHOT
-          handle_snapshot(probe, binding_ctx)
+          handle_snapshot(probe, binding_ctx, local_names)
         when 2 # LOG
           handle_log(probe, binding_ctx)
         when 3 # COUNTER
@@ -344,14 +465,14 @@ module HyperProbe
         end
       end
 
-      def handle_snapshot(probe, binding_ctx)
+      def handle_snapshot(probe, binding_ctx, local_names = nil)
         probe_id = probe.respond_to?(:id) ? probe.id : probe[:id]
 
         max_depth = get_probe_positive_int(probe, :max_object_depth, 3)
         max_array_length = get_probe_positive_int(probe, :max_array_length, 3)
         max_object_properties = get_probe_positive_int(probe, :max_object_properties, 50)
         max_string_length = get_probe_positive_int(probe, :max_string_length, 1024)
-        stack_frame_depth = get_probe_positive_int(probe, :stack_frame_depth, 3)
+        stack_frame_depth = [get_probe_positive_int(probe, :stack_frame_depth, 3), MAX_STACK_FRAMES].min
         redact_keys = @global_config[:redact_keys] || @global_config['redact_keys']
         redact_values = @global_config[:redact_values] || @global_config['redact_values']
 
@@ -370,7 +491,7 @@ module HyperProbe
         watch_expressions = get_probe_opt(probe, :watch_expressions) || []
         serialized_watches = {}
         if watch_expressions && !watch_expressions.empty?
-          raw_watches = Evaluator.evaluate_watches(watch_expressions, binding_ctx)
+          raw_watches = Evaluator.evaluate_watches(watch_expressions.to_a, binding_ctx, safe: @safe_evaluation)
           raw_watches.each do |expr, val|
             watch_path = "watch[#{JSON.generate(expr)}]"
             serialized_watches[expr] = serializer.serialize(val, watch_path, 0, visited)
@@ -383,7 +504,8 @@ module HyperProbe
           binding_ctx,
           stack_frame_depth,
           serializer,
-          visited
+          visited,
+          local_names
         )
 
         event = build_base_event(probe_id)
@@ -392,8 +514,10 @@ module HyperProbe
         event[:watch_results_json] = Serializer.safe_dump_json(serialized_watches)
 
         emit_event(probe, event)
-      rescue StandardError => e
+      rescue StandardError, ScriptError, SecurityError => e
         report_error(probe_id, "Snapshot capture failed: #{e.class.name}: #{e.message}")
+      ensure
+        serializer&.finish_capture
       end
 
       def handle_log(probe, binding_ctx)
@@ -402,7 +526,7 @@ module HyperProbe
         max_string_length = get_probe_positive_int(probe, :max_string_length, 1024)
         redact_values = @global_config[:redact_values] || @global_config['redact_values']
 
-        evaluated = Evaluator.evaluate_log_template(template, binding_ctx)
+        evaluated = Evaluator.evaluate_log_template(template, binding_ctx, safe: @safe_evaluation)
 
         # Redact values
         if redact_values && !redact_values.empty?
@@ -428,13 +552,13 @@ module HyperProbe
                      "#{COLOR_BOLD}#{color}[#{log_level}]#{COLOR_RESET} " \
                      "#{COLOR_BOLD}#{COLOR_MAGENTA}[HyperProbe LOG]#{COLOR_RESET} " \
                      "#{evaluated}\n"
-          $stdout.write(out_line) rescue nil
+          @stdout_queue.push(out_line, true) rescue nil
         end
 
         event = build_base_event(probe_id)
         event[:evaluated_log] = evaluated
         emit_event(probe, event)
-      rescue StandardError => e
+      rescue StandardError, ScriptError, SecurityError => e
         report_error(probe_id, "Log evaluation failed: #{e.class.name}: #{e.message}")
       end
 
@@ -450,11 +574,9 @@ module HyperProbe
         metric_expr = get_probe_opt(probe, :metric_expression)
         return if metric_expr.nil? || metric_expr.empty?
 
-        raw_val = nil
         begin
-          raw_val = binding_ctx.eval(metric_expr)
-          val = Evaluator.coerce_metric_value(raw_val)
-        rescue StandardError, ScriptError => e
+          val = Evaluator.evaluate_metric(metric_expr, binding_ctx, safe: @safe_evaluation)
+        rescue StandardError, ScriptError, SecurityError => e
           report_error(probe_id, "Metric evaluation failed: #{e.class.name}: #{e.message}")
           return
         end
@@ -463,7 +585,7 @@ module HyperProbe
         if val
           event[:metric_value] = val
         else
-          event[:capture_error] = "Metric evaluation failed: #{raw_val.inspect}"
+          event[:capture_error] = 'Metric evaluation failed: expression must return a finite number'
         end
         emit_event(probe, event)
       end
@@ -474,8 +596,8 @@ module HyperProbe
 
         corr_id = nil
         begin
-          corr_id = Evaluator.evaluate_correlation(corr_expr, binding_ctx)
-        rescue StandardError, ScriptError => e
+          corr_id = Evaluator.evaluate_correlation(corr_expr, binding_ctx, safe: @safe_evaluation)
+        rescue StandardError, ScriptError, SecurityError => e
           report_error(probe_id, "Duration correlation failed: #{e.message}")
           return
         end
@@ -486,6 +608,10 @@ module HyperProbe
           now_mono = monotonic_time
           @mutex.synchronize do
             cleanup_durations_unlocked(now_mono)
+            if @duration_starts.size >= MAX_DURATION_ENTRIES
+              # Evict oldest entry to prevent unbounded memory growth
+              @duration_starts.shift
+            end
             @duration_starts[dur_key] = [now_mono, now_mono]
           end
         else
@@ -496,6 +622,10 @@ module HyperProbe
             start_entry = @duration_starts.delete(dur_key)
           end
           return unless start_entry
+          unless @quota_manager.can_evaluate?
+            @mutex.synchronize { @total_skips += 1 }
+            return
+          end
 
           duration_ms = (now_mono - start_entry[0]) * 1000.0
           event = build_base_event(probe_id)
@@ -537,66 +667,21 @@ module HyperProbe
         emit_event(nil, event)
       end
 
-      def extract_stack_and_variables(probe, binding_ctx, stack_frame_depth, serializer, visited)
-        sdk_path_snippet = 'hyperprobe/'
-        all_locations = caller_locations(0, 50) || []
-
-        user_locations = all_locations.reject do |loc|
-          p = (loc.respond_to?(:path) ? loc.path : loc.to_s) || ''
-          p.include?(sdk_path_snippet) ||
-            p.include?('<internal:') ||
-            p.include?('org/jruby/') ||
-            p.include?('org.jruby.') ||
-            p.include?('java/lang/') ||
-            p.include?('sun/reflect') ||
-            p.include?('jdk/internal')
-        end
-
-        # Capture caller bindings if available (via binding_of_caller)
-        user_caller_bindings = []
-        begin
-          if defined?(Binding) && binding_ctx.respond_to?(:of_caller)
-            (1..50).each do |depth|
-              b = binding_ctx.of_caller(depth) rescue nil
-              break unless b
-
-              loc = b.source_location
-              next unless loc
-
-              p = (loc[0] || '').to_s
-              next if p.include?(sdk_path_snippet) ||
-                      p.include?('<internal:') ||
-                      p.include?('org/jruby/') ||
-                      p.include?('org.jruby.') ||
-                      p.include?('java/lang/') ||
-                      p.include?('sun/reflect') ||
-                      p.include?('jdk/internal')
-
-              user_caller_bindings << b
-            end
-          end
-        rescue StandardError, ScriptError
-          # Fallback if caller binding inspection is restricted
-        end
-
+      def extract_stack_and_variables(probe, binding_ctx, stack_frame_depth, serializer, visited, local_names)
         stack_frames = []
         captured_vars = []
 
-        total_frames = [user_locations.length, stack_frame_depth].min
-        total_frames = [total_frames, 1].max
-
-        (0...total_frames).each do |frame_idx|
-          loc = user_locations[frame_idx]
+        snapshot_frames(binding_ctx, local_names, stack_frame_depth).each_with_index do |(loc, current_b, frame_local_names), frame_idx|
 
           func = loc&.label || loc&.base_label || '(anonymous)'
-          file = loc ? resolve_filepath(loc.absolute_path || loc.path || 'unknown') : 'unknown'
+          file = loc ? (loc.absolute_path || loc.path || 'unknown') : 'unknown'
           line_no = loc&.lineno || 0
 
           # If frame_idx == 0 and location is unpopulated, fallback to probe location
           if frame_idx == 0 && (file == 'unknown' || line_no == 0)
             runtime_loc = probe.respond_to?(:runtime_location) ? probe.runtime_location : probe[:runtime_location]
             line_no = (probe.respond_to?(:runtime_line) ? probe.runtime_line : probe[:runtime_line]).to_i
-            file = resolve_filepath(runtime_loc)
+            file = runtime_loc
           end
 
           stack_frames << {
@@ -606,17 +691,19 @@ module HyperProbe
             column_number: 0
           }
 
-          # Resolve frame binding (Frame 0 uses binding_ctx; Frame 1..N uses user_caller_bindings)
-          current_b = (frame_idx == 0) ? binding_ctx : user_caller_bindings[frame_idx]
-
           locals_hash = {}
+          closure_hash = {}
           if current_b
-            current_b.local_variables.each do |var_sym|
+            capture_closures = get_probe_opt(probe, :capture_closures)
+            capture_closures = @global_config[:capture_closures] if capture_closures.nil?
+            LOCAL_VARIABLES.bind(current_b).call.first(128).each do |var_sym|
+              is_local = frame_local_names && frame_local_names.include?(var_sym)
+              next unless is_local || capture_closures == true
               var_name = var_sym.to_s
-              next if var_name.start_with?('_') && var_name != '_x'
 
               begin
-                locals_hash[var_name] = current_b.local_variable_get(var_sym)
+                target = is_local ? locals_hash : closure_hash
+                target[var_name] = LOCAL_GET.bind(current_b).call(var_sym)
               rescue StandardError, ScriptError => e
                 locals_hash[var_name] = "[Error accessing variable: #{e.message}]"
               end
@@ -632,26 +719,113 @@ module HyperProbe
               'vars' => serialized_locals
             }
           ]
+          unless closure_hash.empty?
+            captured_vars.last << {
+              'type' => 'closure', 'name' => 'Closure',
+              'vars' => serializer.serialize(closure_hash, "frame[#{frame_idx}].scopes[1]", 0, visited)
+            }
+          end
         end
 
         [stack_frames, captured_vars]
       end
 
+      def snapshot_frames(binding_ctx, local_names, depth)
+        return [] unless depth.positive?
+
+        collect = proc do |locations, inspector|
+          frames = []
+          locations.first(50).each_with_index do |loc, index|
+            path = loc.path || ''
+            next if path.empty? || path.include?('hyperprobe/') || path.include?('<internal:') ||
+                    path.include?('org/jruby/') || path.include?('org.jruby.') ||
+                    path.include?('java/lang/') || path.include?('sun/reflect') || path.include?('jdk/internal')
+
+            current_b = nil
+            names = nil
+            if frames.empty?
+              current_b = binding_ctx
+              names = local_names
+            elsif inspector
+              begin
+                # Keep the inspector's original index, including native frames.
+                current_b = inspector.frame_binding(index)
+                iseq = inspector.frame_iseq(index) if current_b
+                names = caller_local_names(iseq) if iseq
+                current_b = nil unless names
+              rescue StandardError, ScriptError, SecurityError
+                current_b = nil
+              end
+            end
+            frames << [loc, current_b, names]
+            break if frames.length >= depth
+          end
+          frames.empty? ? [[nil, binding_ctx, local_names]] : frames
+        end
+
+        scan_limit = RUBY_ENGINE == 'ruby' && depth > 1 ? MAX_INSPECTOR_STACK_DEPTH + 1 : 50
+        locations = caller_locations(0, scan_limit) || []
+        if RUBY_ENGINE == 'ruby' && depth > 1 && locations.length <= MAX_INSPECTOR_STACK_DEPTH
+          begin
+            return DebugInspector.open { |inspector| collect.call(inspector.backtrace_locations, inspector) }
+          rescue StandardError, ScriptError, SecurityError
+            # An unavailable inspector must not discard the probe-hit locals.
+          end
+        end
+        collect.call(locations, nil)
+      end
+
+      def caller_local_names(iseq)
+        return @caller_locals_cache[iseq] if @caller_locals_cache.key?(iseq)
+        @caller_locals_cache = ObjectSpace::WeakMap.new if @caller_locals_cache.size >= MAX_CALLER_SCOPES
+
+        # to_a expands nested bytecode, so reject large code trees before dumping
+        # them. These admission limits are not a hard native allocation deadline.
+        pending = [iseq]
+        count = 0
+        bytes = 0
+        until pending.empty?
+          current = pending.pop
+          count += 1
+          size_before = ISEQ_MEMORY_SIZE.call(current)
+          bytes += size_before
+          return @caller_locals_cache[iseq] = nil if count > MAX_CALLER_ISEQS || bytes > MAX_CALLER_ISEQ_BYTES
+
+          ISEQ_EACH_CHILD.bind(current).call do |child|
+            pending << child
+            return @caller_locals_cache[iseq] = nil if count + pending.length > MAX_CALLER_ISEQS
+          end
+          # Enumerating children can materialize a lazily loaded binary ISeq.
+          bytes += [0, ISEQ_MEMORY_SIZE.call(current) - size_before].max
+          return @caller_locals_cache[iseq] = nil if bytes > MAX_CALLER_ISEQ_BYTES
+        end
+
+        # The compiled local table excludes enclosing variables. Weak keys avoid
+        # retaining reloaded code; only names are cached, never live bindings.
+        data = ISEQ_TO_A.bind(iseq).call
+        names = if data[0] == 'YARVInstructionSequence/SimpleDataFormat' && data[10].is_a?(Array)
+                  data[10].grep(Symbol).first(128).freeze
+                end
+        @caller_locals_cache[iseq] = names
+      end
+
       def get_probe_positive_int(probe, key, default_val)
         val = get_probe_opt(probe, key)
-        return val.to_i if val.is_a?(Numeric) && val.to_i.positive?
+        return val if val.is_a?(Integer) && val >= 0
 
         global_val = @global_config[key] || @global_config[key.to_s]
-        return global_val.to_i if global_val.is_a?(Numeric) && global_val.to_i.positive?
+        return global_val if global_val.is_a?(Integer) && global_val >= 0
 
         default_val
       end
 
       def get_probe_opt(probe, key)
         if probe.respond_to?(key)
+          presence = "has_#{key}?"
+          return nil if probe.respond_to?(presence) && !probe.public_send(presence)
           probe.public_send(key)
         elsif probe.is_a?(Hash)
-          probe[key] || probe[key.to_s]
+          probe.key?(key) ? probe[key] : probe[key.to_s]
         end
       end
 
@@ -667,7 +841,7 @@ module HyperProbe
       end
 
       def cleanup_durations_unlocked(now)
-        return if now < @next_duration_cleanup
+        return if now < @next_duration_cleanup && @duration_starts.size < MAX_DURATION_ENTRIES
 
         @duration_starts.delete_if do |_key, (_start_time, created_at)|
           now - created_at > DURATION_TTL_SECONDS