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

data/lib/hyperprobe/core/safe_ast_validator.rb

@@ -4,85 +4,164 @@ require 'ripper'
 
 module HyperProbe
   module Core
+    # This is deliberately a small expression language, not read-only Ruby.
+    # Compile the entire tree before executing even a short-circuited branch.
     class SafeASTValidator
       MAX_EXPRESSION_LENGTH = 256
-      CACHE_CAPACITY = 200
-
-      FORBIDDEN_OPERATORS = %w[
-        = += -= *= /= %= << >> |= &= ^=
-      ].freeze
-
-      FORBIDDEN_IDENTIFIERS = %w[
-        system exec spawn fork exit exit! abort
-        eval instance_eval class_eval module_eval
-        send __send__ public_send define_method
-        const_set const_get instance_variable_set remove_instance_variable
-        delete delete! delete_all destroy destroy!
-        update update! update_all save save! create create!
-        truncate drop clear write require load
-      ].freeze
-
-      FORBIDDEN_CONSTANTS = %w[
-        File Dir IO FileUtils Socket TCPSocket UDPSocket Net
-        Process Kernel ObjectSpace GC System
-      ].freeze
-
-      @cache = {}
-      @cache_mutex = Mutex.new
+      MAX_NODES = 128
+      MAX_DEPTH = 32
+      BINARY_OPERATORS = %i[+ - * / % == != < <= > >= && || and or].freeze
+      UNARY_OPERATORS = %i[+@ -@ ! not].freeze
+      CLASS = Object.instance_method(:class)
+      IDENTITY = BasicObject.instance_method(:equal?)
+      STRING_SIZE = String.instance_method(:bytesize)
+      STRING_SLICE = String.instance_method(:byteslice)
 
       class << self
         def validate!(expression)
-          return if expression.nil? || expression.strip.empty?
+          parse!(expression)
+          nil
+        end
 
-          clean_expr = expression.strip
-          if clean_expr.length > MAX_EXPRESSION_LENGTH
-            raise SecurityError, "Expression is too long (max #{MAX_EXPRESSION_LENGTH} characters)."
+        # Copy through a builtin, never dup/clone/to_str hooks on application data.
+        def source(expression, limit = MAX_EXPRESSION_LENGTH)
+          unless IDENTITY.bind(CLASS.bind(expression).call).call(String)
+            raise SecurityError, 'Expression must be an exact builtin String'
           end
-
-          @cache_mutex.synchronize do
-            return if @cache[clean_expr]
+          if STRING_SIZE.bind(expression).call > limit
+            raise SecurityError, "Expression is too long (max #{limit} bytes)"
           end
 
-          tokens = Ripper.lex(clean_expr)
-
-          tokens.each_with_index do |tok, idx|
-            _pos, type, text, _state = tok
+          copy = STRING_SLICE.bind(expression).call(0, limit + 1)
+          raise SecurityError, "Expression is too long (max #{limit} bytes)" if copy.bytesize > limit
+          copy
+        end
 
-            # 1. Reject Shell Backtick / Command Execution (`...` or %x{...})
-            if type == :on_backtick || type == :on_xstring_beg
-              raise SecurityError, 'Shell command execution is strictly forbidden in probe expressions.'
+        def parse!(expression)
+          return [:literal, nil] if IDENTITY.bind(expression).call(nil)
+
+          text = source(expression)
+          return [:literal, nil] if text.strip.empty?
+
+          tree = Ripper.sexp(text)
+          raise ArgumentError, 'Invalid expression syntax' unless tree
+
+          # Only ordinary quoted strings are supported. Decode their contents
+          # ourselves; Ripper returns escaped source, not evaluated strings.
+          strings = {}
+          quote = nil
+          Ripper.lex(text).each do |position, type, token, _state|
+            case type
+            when :on_tstring_beg
+              reject!('string syntax') unless ["'", '"'].include?(token)
+              quote = token
+            when :on_tstring_content
+              strings[position] = decode_string(token, quote)
+            when :on_tstring_end
+              quote = nil
+            when :on_embexpr_beg, :on_embvar, :on_heredoc_beg
+              reject!('string interpolation or heredoc')
             end
+          end
 
-            # 2. Reject Mutating Operators and Assignments (=, +=, -=, <<, etc.)
-            if type == :on_op && FORBIDDEN_OPERATORS.include?(text)
-              raise SecurityError, "Assignments and state mutations ('#{text}') are strictly forbidden in probe expressions."
-            end
+          compile(tree, strings, [0], 0)
+        end
 
-            # 3. Reject Forbidden System, File, and Metaprogramming Identifiers
-            if (type == :on_ident || type == :on_kw) && FORBIDDEN_IDENTIFIERS.include?(text)
-              raise SecurityError, "Method or function invocation '#{text}()' is strictly forbidden during probe evaluation."
-            end
+        # Kept for callers that used to clear the lexical validator's cache.
+        # Parsing is bounded and no user-controlled expressions are retained.
+        def reset_cache!; end
 
-            # 4. Reject Dangerous Class Invocations (File.delete, Net::HTTP, etc.)
-            if type == :on_const && FORBIDDEN_CONSTANTS.include?(text)
-              # Check if followed by a method call like File.read or Net::HTTP.get
-              next_tokens = tokens[(idx + 1)..]
-              has_method_call = next_tokens&.any? { |t| t[1] == :on_period || t[1] == :on_op && t[2] == '::' }
-              if has_method_call
-                raise SecurityError, "Access to system constant '#{text}' is strictly forbidden in probe expressions."
-              end
-            end
-          end
+        private
+
+        def reject!(feature)
+          raise SecurityError, "Unsupported #{feature}: forbidden in probe expressions"
+        end
 
-          @cache_mutex.synchronize do
-            @cache.shift if @cache.size >= CACHE_CAPACITY
-            @cache[clean_expr] = true
+        def decode_string(text, quote)
+          reject!('string syntax') unless quote
+          text.gsub(/\\(.)/m) do
+            char = Regexp.last_match(1)
+            if quote == "'"
+              ["'", '\\'].include?(char) ? char : "\\#{char}"
+            else
+              escapes = { 'n' => "\n", 'r' => "\r", 't' => "\t", '\\' => '\\', '"' => '"', "'" => "'", '#' => '#' }
+              reject!('string escape') unless escapes.key?(char)
+              escapes[char]
+            end
           end
         end
 
-        def reset_cache!
-          @cache_mutex.synchronize do
-            @cache.clear
+        def compile(node, strings, budget, depth)
+          budget[0] += 1
+          reject!('expression complexity') if budget[0] > MAX_NODES || depth > MAX_DEPTH
+          child = ->(value) { compile(value, strings, budget, depth + 1) }
+
+          case node[0]
+          when :program, :paren
+            reject!('multiple statements') unless node[1]&.length == 1
+            child.call(node[1][0])
+          when :vcall, :var_ref
+            token = node[1]
+            if token[0] == :@ident
+              [:local, token[1]]
+            elsif token[0] == :@kw && %w[true false nil].include?(token[1])
+              [:literal, { 'true' => true, 'false' => false, 'nil' => nil }[token[1]]]
+            else
+              reject!('variable or constant access')
+            end
+          when :@int
+            [:literal, Integer(node[1])]
+          when :@float
+            [:literal, Float(node[1])]
+          when :string_literal
+            content = node[1]
+            reject!('string syntax') unless content[0] == :string_content
+            value = content.drop(1).map do |part|
+              reject!('string interpolation') unless part[0] == :@tstring_content
+              strings.fetch(part[2])
+            end.join
+            [:literal, value]
+          when :symbol_literal
+            symbol = node[1]
+            reject!('symbol syntax') unless symbol[0] == :symbol && %i[@ident @op @kw].include?(symbol[1][0])
+            [:literal, symbol[1][1].to_sym]
+          when :@label
+            [:literal, node[1][0...-1].to_sym]
+          when :array
+            [:array, (node[1] || []).map { |item| child.call(item) }]
+          when :hash
+            pairs = node[1]
+            reject!('hash syntax') if pairs && pairs[0] != :assoclist_from_args
+            [:hash, (pairs ? pairs[1] : []).map do |pair|
+              reject!('hash expansion') unless pair[0] == :assoc_new
+              [child.call(pair[1]), child.call(pair[2])]
+            end]
+          when :aref
+            args = node[2]
+            unless args && args[0] == :args_add_block && args[2] == false && args[1].length == 1
+              reject!('subscript arguments')
+            end
+            [:lookup, child.call(node[1]), child.call(args[1][0])]
+          when :call
+            unless (node[2][0] == :@period || node[2] == :'.') && node[3][0] == :@ident && %w[length size].include?(node[3][1])
+              reject!('method call')
+            end
+            [:length, child.call(node[1])]
+          when :method_add_arg
+            unless node[1][0] == :call && node[2] == [:arg_paren, nil]
+              reject!('method arguments or function call')
+            end
+            child.call(node[1])
+          when :binary
+            reject!('operator') unless BINARY_OPERATORS.include?(node[2])
+            [:binary, node[2], child.call(node[1]), child.call(node[3])]
+          when :unary
+            reject!('unary operator') unless UNARY_OPERATORS.include?(node[1])
+            [:unary, node[1], child.call(node[2])]
+          when :ifop
+            [:conditional, child.call(node[1]), child.call(node[2]), child.call(node[3])]
+          else
+            reject!("syntax #{node[0]}")
           end
         end
       end

data/lib/hyperprobe/core/safety.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'monitor'
+require 'java' if RUBY_ENGINE == 'jruby'
+
 module HyperProbe
   module Core
     module AgentHealth
@@ -16,14 +19,20 @@ module HyperProbe
       SEVERE_LAG_WINDOW_SIZE = 5
       SEVERE_LAG_RED_BREACHES = 3
       SEVERE_LAG_MULTIPLIER = 4.0
+      HEAP_SAMPLE_INTERVAL_MS = 5000.0
+      HEAP_YELLOW_FRACTION = 0.15
+      HEAP_RED_FRACTION = 0.05
 
       attr_reader :health, :last_thread_lag_ms, :cumulative_pause_time, :max_lag_ms, :pause_budget_ms
 
-      def initialize(on_state_change, max_lag_ms: 50.0, pause_budget_ms: 15.0, is_ephemeral_lambda: false)
+      def initialize(on_state_change, max_lag_ms: 50.0, pause_budget_ms: 15.0, is_ephemeral_lambda: false,
+                     heap_runtime: (RUBY_ENGINE == 'jruby' ? Java::JavaLang::Runtime.get_runtime : nil))
         @on_state_change = on_state_change
         @max_lag_ms = max_lag_ms.to_f
         @pause_budget_ms = pause_budget_ms.to_f
         @is_ephemeral_lambda = is_ephemeral_lambda
+        @heap_runtime = heap_runtime
+        @heap_available_fraction = 1.0
 
         @health = AgentHealth::GREEN
         @last_heartbeat = monotonic_ms
@@ -33,40 +42,61 @@ module HyperProbe
         @last_window_reset = monotonic_ms
 
         @mutex = Mutex.new
-        @notification_mutex = Mutex.new
+        @notification_mutex = Monitor.new
+        @transition_generation = 0
         @running = false
         @thread = nil
       end
 
       def start
         @mutex.synchronize do
-          return if @running
+          return if @running && @thread&.alive?
 
           @running = true
           @last_heartbeat = monotonic_ms
           @last_window_reset = monotonic_ms
+          @last_heap_sample = @last_window_reset
 
           @thread = Thread.new { monitor_loop }
           @thread.name = 'hyperprobe-safety' if @thread.respond_to?(:name=)
         end
       end
 
-      def stop
+      def after_fork
         @mutex.synchronize do
           @running = false
+          @thread = nil
         end
-        @thread&.wakeup if @thread&.alive?
-        @thread&.join(1.0) rescue nil
-        @thread = nil
+        start
+      end
+
+      def stop
+        thread = @mutex.synchronize do
+          @running = false
+          current = @thread
+          @thread = nil
+          current
+        end
+        return if !thread || thread == Thread.current
+
+        thread.kill
+        thread.join(0.1)
+      rescue Exception
+        # Stop is agent-owned cleanup, including when called from a trap.
       end
 
       def report_pause_duration(ms)
         callback_info = nil
-        @mutex.synchronize do
+        return unless @mutex.try_lock
+        begin
           @cumulative_pause_time += ms.to_f
           callback_info = evaluate_health_locked
+          # A live monitor delivers transitions off the application thread.
+          @pending_notification = callback_info if @running && callback_info
+        ensure
+          @mutex.unlock
         end
-        trigger_callback(callback_info) if callback_info
+        trigger_callback(callback_info) if callback_info && !@running
       end
 
       def record_thread_lag(thread_lag_ms)
@@ -82,6 +112,16 @@ module HyperProbe
         @mutex.synchronize { @health }
       end
 
+      def with_health(expected)
+        @notification_mutex.synchronize do
+          return unless @mutex.synchronize { @health == expected }
+
+          yield
+        end
+      rescue Exception
+        # Serialize cooldown actions with transition delivery, not state updates.
+      end
+
       private
 
       def monitor_loop
@@ -97,17 +137,25 @@ module HyperProbe
             thread_lag_ms = [0.0, now - wait_started - (SAMPLE_INTERVAL_SECONDS * 1000.0)].max
             record_thread_lag_locked(thread_lag_ms)
 
+            if @heap_runtime && !@is_ephemeral_lambda && now - @last_heap_sample >= HEAP_SAMPLE_INTERVAL_MS
+              sample_heap_locked
+              @last_heap_sample = now
+            end
+
             # Reset pause budget window every second
             if now - @last_window_reset > 1000.0
               @cumulative_pause_time = 0.0
               @last_window_reset = now
             end
 
-            callback_info = evaluate_health_locked
+            callback_info = evaluate_health_locked || @pending_notification
+            @pending_notification = nil
           end
 
           trigger_callback(callback_info) if callback_info
         end
+      rescue Exception
+        @running = false
       end
 
       def record_thread_lag_locked(lag_ms)
@@ -117,6 +165,17 @@ module HyperProbe
         @thread_lag_samples.shift while @thread_lag_samples.length > LAG_WINDOW_SIZE
       end
 
+      def sample_heap_locked
+        maximum = @heap_runtime.max_memory.to_f
+        return unless maximum.positive?
+
+        committed = @heap_runtime.total_memory
+        free = @heap_runtime.free_memory
+        @heap_available_fraction = (free + maximum - committed) / maximum
+      rescue Exception
+        # Preserve the last heap health and retry at the next sample.
+      end
+
       def evaluate_health_locked
         prev_health = @health
         reason = nil
@@ -125,7 +184,8 @@ module HyperProbe
           @health = AgentHealth::GREEN
           return nil if prev_health == AgentHealth::GREEN
 
-          return [@health, 'System stabilized in Lambda mode.']
+          @transition_generation += 1
+          return [@health, 'System stabilized in Lambda mode.', @transition_generation]
         end
 
         recent_lags = @thread_lag_samples.dup
@@ -134,7 +194,18 @@ module HyperProbe
         severe_window = recent_lags.last(SEVERE_LAG_WINDOW_SIZE)
         severe_lag_breaches = severe_window.count { |lag| lag > severe_lag_ms }
 
-        if severe_lag_breaches >= SEVERE_LAG_RED_BREACHES
+        if @heap_runtime
+          if @heap_available_fraction < HEAP_RED_FRACTION
+            @health = AgentHealth::RED
+            reason = "JVM heap headroom (#{(@heap_available_fraction * 100).round(1)}%) below 5% of maximum heap"
+          elsif @heap_available_fraction < HEAP_YELLOW_FRACTION
+            @health = AgentHealth::YELLOW
+            reason = "JVM heap headroom (#{(@heap_available_fraction * 100).round(1)}%) below 15% of maximum heap"
+          else
+            @health = AgentHealth::GREEN
+            reason = 'JVM heap headroom stabilized.' if prev_health != AgentHealth::GREEN
+          end
+        elsif severe_lag_breaches >= SEVERE_LAG_RED_BREACHES
           @health = AgentHealth::RED
           reason = "Severe Execution Thread Lag exceeded #{severe_lag_ms.round(1)}ms in #{severe_lag_breaches}/#{SEVERE_LAG_WINDOW_SIZE} recent readings"
         elsif lag_breaches >= LAG_RED_BREACHES
@@ -159,15 +230,21 @@ module HyperProbe
 
         return unless @health != prev_health
 
-        [@health, reason]
+        @transition_generation += 1
+        [@health, reason, @transition_generation]
       end
 
       def trigger_callback(callback_info)
-        health, reason = callback_info
+        health, reason, generation = callback_info
         @notification_mutex.synchronize do
+          # State transitions release @mutex before acquiring the delivery lock.
+          # Recheck here so a delayed notification cannot undo a newer one.
+          current = @mutex.synchronize { generation == @transition_generation && health == @health }
+          return unless current
+
           @on_state_change&.call(health, reason)
         end
-      rescue StandardError
+      rescue Exception
         # Never crash application thread or safety monitor on callback error
       end