hyperprobe-agent 1.2.27.pre.1

data/lib/hyperprobe/core/monitoring_engine.rb

@@ -0,0 +1,683 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'json'
+require_relative 'logger'
+
+begin
+  require 'binding_of_caller'
+rescue LoadError
+  # binding_of_caller is optional
+end
+
+module HyperProbe
+  module Core
+    class MonitoringEngine
+      DURATION_TTL_SECONDS = 60.0
+
+      LEVEL_COLORS = {
+        'ERROR' => "\e[31m",
+        'WARN'  => "\e[33m",
+        'INFO'  => "\e[32m",
+        'DEBUG' => "\e[36m"
+      }.freeze
+      COLOR_RESET = "\e[0m"
+      COLOR_BOLD = "\e[1m"
+      COLOR_GRAY = "\e[90m"
+      COLOR_MAGENTA = "\e[35m"
+
+      attr_reader :total_hits, :total_skips, :is_suspended, :is_active
+
+      def initialize(quota_manager, safety_monitor, on_capture, custom_set_trace_id = nil)
+        @quota_manager = quota_manager
+        @safety_monitor = safety_monitor
+        @on_capture = on_capture
+        @custom_set_trace_id = custom_set_trace_id
+
+        @mutex = Mutex.new
+        @active_locations = {} # [resolved_file_path, line] => Array<ActiveProbeContext>
+        @probe_map = {}        # probe_id => Probe
+        @instrumented_files = Set.new
+        @path_cache = {}
+        @duration_starts = {}  # [probe_id, correlation_id] => [start_time_monotonic, created_at_time]
+        @next_duration_cleanup = monotonic_time + DURATION_TTL_SECONDS
+
+        @global_config = {}
+        @total_hits = 0
+        @total_skips = 0
+        @is_suspended = false
+        @is_active = false
+        @closed = false
+
+        @log = Logger.get_logger('hyperprobe:inspector')
+        @targeted_tracepoints = {} # location_key => TracePoint instance
+      end
+
+      def set_global_config(config)
+        @mutex.synchronize do
+          @global_config = (config || {}).dup
+        end
+      end
+
+      def set_probes(probes)
+        @mutex.synchronize do
+          return if @closed
+
+          new_active_locations = {}
+          new_probe_map = {}
+          new_instrumented_files = Set.new
+
+          Array(probes).each do |probe|
+            probe_id = probe.respond_to?(:id) ? probe.id : probe[:id]
+            next unless probe_id
+
+            new_probe_map[probe_id] = probe
+
+            runtime_loc = probe.respond_to?(:runtime_location) ? probe.runtime_location : probe[:runtime_location]
+            runtime_line = (probe.respond_to?(:runtime_line) ? probe.runtime_line : probe[:runtime_line]).to_i
+
+            resolved_path = resolve_filepath(runtime_loc)
+            primary_key = [resolved_path, runtime_line]
+
+            new_active_locations[primary_key] ||= []
+            new_active_locations[primary_key] << { probe: probe, is_secondary: false }
+            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
+              sec_line = (probe.respond_to?(:secondary_runtime_line) ? probe.secondary_runtime_line : probe[:secondary_runtime_line]).to_i
+              if sec_line.positive?
+                sec_loc = probe.respond_to?(:secondary_runtime_location) ? probe.secondary_runtime_location : probe[:secondary_runtime_location]
+                sec_loc = runtime_loc if sec_loc.nil? || sec_loc.empty?
+                resolved_sec_path = resolve_filepath(sec_loc)
+                secondary_key = [resolved_sec_path, sec_line]
+
+                new_active_locations[secondary_key] ||= []
+                new_active_locations[secondary_key] << { probe: probe, is_secondary: true }
+                new_instrumented_files.add(resolved_sec_path)
+              end
+            end
+          end
+
+          @active_locations = new_active_locations
+          @probe_map = new_probe_map
+          @instrumented_files = new_instrumented_files
+
+          update_tracepoint_state_unlocked
+        end
+      end
+
+      def suspend
+        @mutex.synchronize do
+          return if @closed || @is_suspended
+
+          @is_suspended = true
+          disable_all_tracepoints_unlocked
+        end
+      end
+
+      def resume
+        @mutex.synchronize do
+          return if @closed || !@is_suspended
+
+          @is_suspended = false
+          update_tracepoint_state_unlocked
+        end
+      end
+
+      def get_stats
+        @mutex.synchronize do
+          cleanup_durations_unlocked(monotonic_time)
+          stats = { hits: @total_hits, skips: @total_skips }
+          @total_hits = 0
+          @total_skips = 0
+          stats
+        end
+      end
+
+      def close
+        @mutex.synchronize do
+          return if @closed
+
+          @closed = true
+          disable_all_tracepoints_unlocked
+          @active_locations.clear
+          @probe_map.clear
+          @instrumented_files.clear
+          @duration_starts.clear
+        end
+      end
+
+      private
+
+      def update_tracepoint_state_unlocked
+        if @closed || @is_suspended || @active_locations.empty?
+          disable_all_tracepoints_unlocked
+          return
+        end
+
+        # 1. Remove stale tracepoints
+        active_keys = @active_locations.keys.to_set
+        @targeted_tracepoints.delete_if do |loc_key, tp|
+          unless active_keys.include?(loc_key)
+            tp.disable rescue nil
+            true
+          end
+        end
+
+        # 2. Setup or enable targeted tracepoint for each active location
+        @active_locations.each_key do |loc_key|
+          next if @targeted_tracepoints.key?(loc_key)
+
+          enable_location_tracepoint_unlocked(loc_key)
+        end
+
+        @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
+
+          contexts = nil
+          @mutex.synchronize do
+            contexts = @active_locations[loc_key]
+          end
+
+          if contexts && !contexts.empty?
+            binding_ctx = t.binding
+            handle_hit(contexts, binding_ctx)
+          end
+        end
+
+        target_method = find_method_target(resolved_path, lineno)
+        targeted_enabled = false
+
+        if target_method
+          begin
+            tp.enable(target: target_method, target_line: lineno)
+            targeted_enabled = true
+          rescue ArgumentError, StandardError
+            # Target option not accepted by interpreter
+          end
+        end
+
+        unless targeted_enabled
+          begin
+            tp.enable
+          rescue StandardError
+            # TracePoint enable error
+          end
+        end
+
+        @targeted_tracepoints[loc_key] = tp
+      end
+
+      def disable_all_tracepoints_unlocked
+        @targeted_tracepoints.each_value do |tp|
+          tp.disable rescue nil
+        end
+        @targeted_tracepoints.clear
+        @is_active = false
+      end
+
+      def find_method_target(file_path, line_number)
+        best_match = nil
+        best_line = 0
+
+        ObjectSpace.each_object(Module) do |mod|
+          next if mod.singleton_class? || mod.name.nil?
+
+          [:instance_methods, :methods].each do |mtype|
+            methods_list = mod.send(mtype, false) rescue []
+            methods_list.each do |sym|
+              m = (mtype == :instance_methods ? mod.instance_method(sym) : mod.method(sym)) rescue nil
+              next unless m
+
+              loc = m.source_location
+              next unless loc
+
+              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
+              end
+            end
+          end
+        end
+
+        best_match
+      rescue StandardError
+        nil
+      end
+
+      def resolve_filepath(runtime_location)
+        return '' if runtime_location.nil? || runtime_location.empty?
+
+        cached = @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
+          return resolved
+        end
+
+        cwd = Dir.pwd
+        parts = runtime_location.tr('\\', '/').split('/').reject(&:empty?)
+        (0...parts.length).each do |i|
+          suffix = File.join(*parts[i..])
+          attempt = File.expand_path(suffix, cwd)
+          if File.exist?(attempt)
+            resolved = File.realpath(attempt) rescue attempt
+            @path_cache[runtime_location] = resolved
+            return resolved
+          end
+        end
+
+        fallback = File.expand_path(runtime_location, cwd)
+        @path_cache[runtime_location] = fallback
+        fallback
+      end
+
+      def handle_hit(contexts, binding_ctx)
+        start_time = monotonic_time
+        begin
+          contexts.each do |ctx|
+            probe = ctx[:probe]
+            is_secondary = ctx[:is_secondary]
+            process_single_probe_hit(probe, binding_ctx, is_secondary)
+          end
+        rescue StandardError => e
+          # Never crash application thread on probe hit
+        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)
+        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?
+          @mutex.synchronize { @total_skips += 1 }
+          return
+        end
+
+        # 2. Evaluate Condition (if any)
+        condition = probe.respond_to?(:condition) ? probe.condition : probe[:condition]
+        if condition && !condition.empty?
+          begin
+            passed = Evaluator.eval_condition(condition, binding_ctx)
+            return unless passed
+          rescue StandardError, ScriptError => e
+            report_error(probe_id, "Condition evaluation failed: #{e.class.name}: #{e.message}")
+            return
+          end
+        end
+
+        # 3. Dispatch to Probe Type Handler
+        case probe_type_num
+        when 1 # SNAPSHOT
+          handle_snapshot(probe, binding_ctx)
+        when 2 # LOG
+          handle_log(probe, binding_ctx)
+        when 3 # COUNTER
+          handle_counter(probe, binding_ctx)
+        when 4 # METRIC
+          handle_metric(probe, binding_ctx)
+        when 5 # DURATION
+          handle_duration(probe, binding_ctx, is_secondary)
+        end
+      end
+
+      def handle_snapshot(probe, binding_ctx)
+        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)
+        redact_keys = @global_config[:redact_keys] || @global_config['redact_keys']
+        redact_values = @global_config[:redact_values] || @global_config['redact_values']
+
+        serializer = Serializer.new(
+          max_depth: max_depth,
+          max_array_length: max_array_length,
+          max_object_properties: max_object_properties,
+          max_string_length: max_string_length,
+          redact_keys: redact_keys,
+          redact_values: redact_values
+        )
+
+        visited = {}
+
+        # 1. Watch Expressions
+        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.each do |expr, val|
+            watch_path = "watch[#{JSON.generate(expr)}]"
+            serialized_watches[expr] = serializer.serialize(val, watch_path, 0, visited)
+          end
+        end
+
+        # 2. Unified Stack Frames & Multi-Frame Local Variables Extraction
+        stack_frames, captured_vars = extract_stack_and_variables(
+          probe,
+          binding_ctx,
+          stack_frame_depth,
+          serializer,
+          visited
+        )
+
+        event = build_base_event(probe_id)
+        event[:stack_frames] = stack_frames
+        event[:captured_vars_json] = Serializer.safe_dump_json(captured_vars)
+        event[:watch_results_json] = Serializer.safe_dump_json(serialized_watches)
+
+        emit_event(probe, event)
+      rescue StandardError => e
+        report_error(probe_id, "Snapshot capture failed: #{e.class.name}: #{e.message}")
+      end
+
+      def handle_log(probe, binding_ctx)
+        probe_id = probe.respond_to?(:id) ? probe.id : probe[:id]
+        template = get_probe_opt(probe, :template) || ''
+        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)
+
+        # Redact values
+        if redact_values && !redact_values.empty?
+          regex = Serializer.new(redact_values: redact_values).send(:compile_regex, redact_values)
+          evaluated = evaluated.gsub(regex, '[REDACTED Value]') if regex
+        end
+
+        # Truncate string
+        if evaluated.length > max_string_length
+          head = evaluated[0...max_string_length]
+          truncated_head = head.sub(/\b\w*$/, '').rstrip
+          truncated_head = head if truncated_head.empty?
+          evaluated = "#{truncated_head}... [Truncated: +#{evaluated.length - max_string_length} more chars]"
+        end
+
+        # Stdout logging if configured
+        should_log_stdout = get_probe_opt(probe, :should_log_to_stdout)
+        if should_log_stdout
+          log_level = (get_probe_opt(probe, :log_level) || 'INFO').to_s.upcase
+          color = LEVEL_COLORS[log_level] || "\e[37m"
+          timestamp = Time.now.utc.iso8601(3)
+          out_line = "#{COLOR_GRAY}[#{timestamp}]#{COLOR_RESET} " \
+                     "#{COLOR_BOLD}#{color}[#{log_level}]#{COLOR_RESET} " \
+                     "#{COLOR_BOLD}#{COLOR_MAGENTA}[HyperProbe LOG]#{COLOR_RESET} " \
+                     "#{evaluated}\n"
+          $stdout.write(out_line) rescue nil
+        end
+
+        event = build_base_event(probe_id)
+        event[:evaluated_log] = evaluated
+        emit_event(probe, event)
+      rescue StandardError => e
+        report_error(probe_id, "Log evaluation failed: #{e.class.name}: #{e.message}")
+      end
+
+      def handle_counter(probe, _binding_ctx)
+        probe_id = probe.respond_to?(:id) ? probe.id : probe[:id]
+        event = build_base_event(probe_id)
+        event[:metric_value] = 1.0
+        emit_event(probe, event)
+      end
+
+      def handle_metric(probe, binding_ctx)
+        probe_id = probe.respond_to?(:id) ? probe.id : probe[:id]
+        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
+          report_error(probe_id, "Metric evaluation failed: #{e.class.name}: #{e.message}")
+          return
+        end
+
+        event = build_base_event(probe_id)
+        if val
+          event[:metric_value] = val
+        else
+          event[:capture_error] = "Metric evaluation failed: #{raw_val.inspect}"
+        end
+        emit_event(probe, event)
+      end
+
+      def handle_duration(probe, binding_ctx, is_secondary)
+        probe_id = probe.respond_to?(:id) ? probe.id : probe[:id]
+        corr_expr = get_probe_opt(probe, :correlation_expression)
+
+        corr_id = nil
+        begin
+          corr_id = Evaluator.evaluate_correlation(corr_expr, binding_ctx)
+        rescue StandardError, ScriptError => e
+          report_error(probe_id, "Duration correlation failed: #{e.message}")
+          return
+        end
+
+        dur_key = [probe_id, corr_id]
+
+        if !is_secondary
+          now_mono = monotonic_time
+          @mutex.synchronize do
+            cleanup_durations_unlocked(now_mono)
+            @duration_starts[dur_key] = [now_mono, now_mono]
+          end
+        else
+          now_mono = monotonic_time
+          start_entry = nil
+          @mutex.synchronize do
+            cleanup_durations_unlocked(now_mono)
+            start_entry = @duration_starts.delete(dur_key)
+          end
+          return unless start_entry
+
+          duration_ms = (now_mono - start_entry[0]) * 1000.0
+          event = build_base_event(probe_id)
+          event[:metric_value] = duration_ms
+          emit_event(probe, event)
+        end
+      end
+
+      def build_base_event(probe_id)
+        event = {
+          probe_id: probe_id,
+          timestamp_ms: (Time.now.to_f * 1000).to_i,
+          stack_frames: [],
+          captured_vars_json: '',
+          watch_results_json: '',
+          evaluated_log: '',
+          metric_value: 0.0,
+          capture_error: '',
+          trace_id: nil
+        }
+
+        probe = @probe_map[probe_id]
+        if probe && get_probe_opt(probe, :should_capture_trace_id)
+          trace_id = TraceExtractor.extract_trace_context(@custom_set_trace_id)
+          event[:trace_id] = trace_id if trace_id && !trace_id.empty?
+        end
+
+        event
+      end
+
+      def emit_event(_probe, event)
+        @mutex.synchronize { @total_hits += 1 }
+        @on_capture.call(event)
+      end
+
+      def report_error(probe_id, error_message)
+        event = build_base_event(probe_id)
+        event[:capture_error] = error_message
+        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
+
+        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]
+
+          func = loc&.label || loc&.base_label || '(anonymous)'
+          file = loc ? resolve_filepath(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)
+          end
+
+          stack_frames << {
+            function_name: func,
+            file_name: file,
+            line_number: line_no,
+            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 = {}
+          if current_b
+            current_b.local_variables.each do |var_sym|
+              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)
+              rescue StandardError, ScriptError => e
+                locals_hash[var_name] = "[Error accessing variable: #{e.message}]"
+              end
+            end
+          end
+
+          serialized_locals = locals_hash.empty? ? {} : serializer.serialize(locals_hash, "frame[#{frame_idx}].scopes[0]", 0, visited)
+
+          captured_vars << [
+            {
+              'type' => 'local',
+              'name' => 'Local',
+              'vars' => serialized_locals
+            }
+          ]
+        end
+
+        [stack_frames, captured_vars]
+      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?
+
+        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?
+
+        default_val
+      end
+
+      def get_probe_opt(probe, key)
+        if probe.respond_to?(key)
+          probe.public_send(key)
+        elsif probe.is_a?(Hash)
+          probe[key] || probe[key.to_s]
+        end
+      end
+
+      def probe_type_to_i(type)
+        case type
+        when :PROBE_TYPE_SNAPSHOT, 'PROBE_TYPE_SNAPSHOT', 1 then 1
+        when :PROBE_TYPE_LOG, 'PROBE_TYPE_LOG', 2 then 2
+        when :PROBE_TYPE_COUNTER, 'PROBE_TYPE_COUNTER', 3 then 3
+        when :PROBE_TYPE_METRIC, 'PROBE_TYPE_METRIC', 4 then 4
+        when :PROBE_TYPE_DURATION, 'PROBE_TYPE_DURATION', 5 then 5
+        else 0
+        end
+      end
+
+      def cleanup_durations_unlocked(now)
+        return if now < @next_duration_cleanup
+
+        @duration_starts.delete_if do |_key, (_start_time, created_at)|
+          now - created_at > DURATION_TTL_SECONDS
+        end
+        @next_duration_cleanup = now + DURATION_TTL_SECONDS
+      end
+
+      def monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end