hyperprobe-agent 1.2.27.pre.1

data/lib/hyperprobe/core/broker.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'socket'
+require_relative '../protos'
+
+if RUBY_PLATFORM !~ /java/
+  begin
+    require 'grpc'
+  rescue LoadError
+    # Handled gracefully if grpc gem is absent
+  end
+else
+  require 'java'
+end
+
+module HyperProbe
+  module Core
+    class BrokerClient
+      attr_reader :agent_id, :service_id, :environment, :commit_sha, :agent_version, :stub
+
+      def initialize(
+        broker_url:,
+        service_id:,
+        environment:,
+        commit_sha:,
+        agent_id: nil,
+        agent_version: '1.0.0',
+        rpc_timeout_sec: 10.0,
+        enable_keep_alive: true
+      )
+        @service_id = service_id.to_s
+        @environment = environment.to_s
+        @commit_sha = commit_sha.to_s
+        @agent_id = agent_id || SecureRandom.uuid
+        @agent_version = agent_version.to_s
+        @rpc_timeout_sec = rpc_timeout_sec.to_f
+        @hostname = ENV['HOSTNAME'] || Socket.gethostname rescue 'unknown'
+        @is_jruby = RUBY_PLATFORM =~ /java/
+        @log = Logger.get_logger('hyperprobe:broker')
+
+        if @is_jruby
+          init_jruby_client(broker_url)
+        else
+          init_cruby_client(broker_url, enable_keep_alive)
+        end
+      end
+
+      def get_probes(timeout_sec = nil)
+        req = Hyperprobe::Agent::V1::GetProbesRequest.new(
+          agent_id: @agent_id,
+          service_id: @service_id,
+          environment: @environment,
+          commit_sha: @commit_sha,
+          language: @is_jruby ? 'jruby' : 'ruby',
+          agent_version: @agent_version,
+          hostname: @hostname
+        )
+
+        if @is_jruby
+          call_jruby_rpc('/hyperprobe.agent.v1.AgentBroker/GetProbes', req, Hyperprobe::Agent::V1::GetProbesResponse, timeout_sec)
+        else
+          deadline = calculate_deadline(timeout_sec || @rpc_timeout_sec)
+          metadata = { 'x-hp-service-id' => @service_id }
+          @stub.get_probes(req, metadata: metadata, deadline: deadline)
+        end
+      end
+
+      def report_telemetry(events, timeout_sec = nil)
+        return [] if events.nil? || events.empty?
+
+        proto_events = events.map { |evt| build_telemetry_event_proto(evt) }
+        batch = Hyperprobe::Agent::V1::TelemetryBatch.new(
+          agent_id: @agent_id,
+          events: proto_events
+        )
+
+        if @is_jruby
+          response = call_jruby_rpc('/hyperprobe.agent.v1.AgentBroker/ReportTelemetry', batch, Hyperprobe::Agent::V1::TelemetryResponse, timeout_sec)
+          response.finished_probe_ids.to_a
+        else
+          deadline = calculate_deadline(timeout_sec || @rpc_timeout_sec)
+          metadata = { 'x-hp-service-id' => @service_id }
+          response = @stub.report_telemetry(batch, metadata: metadata, deadline: deadline)
+          response.finished_probe_ids.to_a
+        end
+      end
+
+      def estimate_event_size(event)
+        proto = build_telemetry_event_proto(event)
+        proto.to_proto.bytesize
+      rescue StandardError
+        JSON.generate(event).bytesize rescue 512
+      end
+
+      def shutdown
+        # No-op / cleanup
+      end
+
+      private
+
+      def init_cruby_client(broker_url, enable_keep_alive)
+        target, creds, channel_args = parse_broker_url(broker_url, enable_keep_alive)
+        @stub = Hyperprobe::Agent::V1::AgentBroker::Stub.new(
+          target,
+          creds,
+          channel_args: channel_args
+        )
+      end
+
+      def init_jruby_client(broker_url)
+        raw_url = broker_url.to_s.strip
+        if raw_url.start_with?('http://', 'https://')
+          @base_url = raw_url
+        else
+          @base_url = "http://#{raw_url}"
+        end
+
+        timeout_ms = (@rpc_timeout_sec * 1000).to_i
+        @http_client = java.net.http.HttpClient.newBuilder
+                         .version(java.net.http.HttpClient::Version::HTTP_2)
+                         .connectTimeout(java.time.Duration.ofMillis(timeout_ms))
+                         .build
+      end
+
+      def call_jruby_rpc(method_path, request_proto, response_class, timeout_sec)
+        raw_bytes = request_proto.to_proto
+        framed = "\x00" + [raw_bytes.bytesize].pack('N') + raw_bytes
+
+        uri = java.net.URI.create("#{@base_url}#{method_path}")
+        body_publisher = java.net.http.HttpRequest::BodyPublishers.ofByteArray(framed.to_java_bytes)
+
+        req_builder = java.net.http.HttpRequest.newBuilder(uri)
+                        .version(java.net.http.HttpClient::Version::HTTP_2)
+                        .header('Content-Type', 'application/grpc')
+                        .header('TE', 'trailers')
+                        .header('x-hp-service-id', @service_id)
+                        .POST(body_publisher)
+
+        effective_timeout = timeout_sec || @rpc_timeout_sec
+        if effective_timeout && effective_timeout.positive?
+          req_builder.timeout(java.time.Duration.ofMillis((effective_timeout * 1000).to_i))
+        end
+
+        http_response = @http_client.send(req_builder.build, java.net.http.HttpResponse::BodyHandlers.ofByteArray)
+        response_bytes = String.from_java_bytes(http_response.body)
+
+        # Strip 5-byte gRPC prefix header (1 byte compression flag + 4 bytes length)
+        proto_payload = response_bytes.length >= 5 ? response_bytes[5..-1] : ''
+        response_class.decode(proto_payload)
+      end
+
+      def build_telemetry_event_proto(evt)
+        return evt if evt.is_a?(Hyperprobe::Agent::V1::TelemetryEvent)
+
+        stack_frames = Array(evt[:stack_frames]).map do |frame|
+          Hyperprobe::Agent::V1::StackFrame.new(
+            function_name: frame[:function_name].to_s,
+            file_name: frame[:file_name].to_s,
+            line_number: frame[:line_number].to_i,
+            column_number: frame[:column_number].to_i,
+            class_name: frame[:class_name] ? frame[:class_name].to_s : nil
+          )
+        end
+
+        proto_params = {
+          probe_id: evt[:probe_id].to_s,
+          timestamp_ms: (evt[:timestamp_ms] || (Time.now.to_f * 1000)).to_i,
+          stack_frames: stack_frames,
+          captured_vars_json: evt[:captured_vars_json].to_s,
+          watch_results_json: evt[:watch_results_json].to_s,
+          evaluated_log: evt[:evaluated_log].to_s,
+          metric_value: evt[:metric_value].to_f,
+          capture_error: evt[:capture_error].to_s
+        }
+
+        proto_params[:trace_id] = evt[:trace_id].to_s if evt[:trace_id] && !evt[:trace_id].to_s.empty?
+
+        Hyperprobe::Agent::V1::TelemetryEvent.new(proto_params)
+      end
+
+      def calculate_deadline(timeout_sec)
+        return nil unless timeout_sec && timeout_sec.positive?
+
+        Time.now + timeout_sec
+      end
+
+      def parse_broker_url(url, enable_keep_alive)
+        raw_url = url.to_s.strip
+        channel_args = {}
+
+        if enable_keep_alive
+          channel_args['grpc.keepalive_time_ms'] = 60_000
+          channel_args['grpc.keepalive_timeout_ms'] = 20_000
+          channel_args['grpc.keepalive_permit_without_calls'] = 1
+        end
+
+        if raw_url.start_with?('https://')
+          target = raw_url.sub('https://', '')
+          creds = GRPC::Core::ChannelCredentials.new
+          [target, creds, channel_args]
+        elsif raw_url.start_with?('http://')
+          target = raw_url.sub('http://', '')
+          creds = :this_channel_is_insecure
+          [target, creds, channel_args]
+        else
+          creds = :this_channel_is_insecure
+          [raw_url, creds, channel_args]
+        end
+      end
+    end
+  end
+end

data/lib/hyperprobe/core/evaluator.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative 'safe_ast_validator'
+
+module HyperProbe
+  module Core
+    class Evaluator
+      PLACEHOLDER_REGEX = /\$?\{([^}]+)\}|\#\{([^}]+)\}/.freeze
+      JS_FLOAT_PREFIX_RE = /^\s*([+-]?(?:(?:[0-9]+\.?[0-9]*)|(?:\.[0-9]+))(?:[eE][+-]?[0-9]+)?)/.freeze
+
+      class << self
+        def eval_condition(condition, binding_ctx)
+          return true if condition.nil? || condition.strip.empty?
+
+          clean_cond = condition.strip
+          SafeASTValidator.validate!(clean_cond)
+          result = binding_ctx.eval(clean_cond)
+          !!result
+        end
+
+        def evaluate_watches(watch_expressions, binding_ctx)
+          results = {}
+          return results if watch_expressions.nil? || watch_expressions.empty?
+
+          watch_expressions.each do |expr|
+            clean_expr = expr.strip
+            next if clean_expr.empty?
+
+            begin
+              SafeASTValidator.validate!(clean_expr)
+              results[expr] = binding_ctx.eval(clean_expr)
+            rescue StandardError, ScriptError, SecurityError => e
+              results[expr] = "Error: #{e.class.name}: #{e.message}"
+            end
+          end
+          results
+        end
+
+        def evaluate_log_template(template, binding_ctx)
+          return '' if template.nil? || template.empty?
+
+          template.gsub(PLACEHOLDER_REGEX) do |_match|
+            expr = (Regexp.last_match(1) || Regexp.last_match(2)).strip
+            begin
+              SafeASTValidator.validate!(expr)
+              val = binding_ctx.eval(expr)
+              val.is_a?(String) ? val : val.inspect
+            rescue StandardError, ScriptError, SecurityError => e
+              "<Error: #{e.class.name}: #{e.message}>"
+            end
+          end
+        end
+
+        def evaluate_metric(metric_expression, binding_ctx)
+          return nil if metric_expression.nil? || metric_expression.strip.empty?
+
+          clean_expr = metric_expression.strip
+          SafeASTValidator.validate!(clean_expr)
+          raw_val = binding_ctx.eval(clean_expr)
+          coerce_metric_value(raw_val)
+        end
+
+        def evaluate_correlation(correlation_expression, binding_ctx)
+          return 'static-singleton' if correlation_expression.nil? || correlation_expression.strip.empty?
+
+          clean_expr = correlation_expression.strip
+          SafeASTValidator.validate!(clean_expr)
+          raw_val = binding_ctx.eval(clean_expr)
+          normalize_correlation_value(raw_val)
+        end
+
+        def coerce_metric_value(value)
+          return nil if value == true || value == false
+          return nil if value.nil?
+
+          if value.is_a?(Numeric)
+            float_val = value.to_f
+            return float_val if float_val.finite?
+
+            return nil
+          end
+
+          if value.is_a?(String)
+            match = JS_FLOAT_PREFIX_RE.match(value)
+            if match
+              float_val = match[1].to_f
+              return float_val if float_val.finite?
+            end
+          end
+
+          nil
+        end
+
+        def normalize_correlation_value(value)
+          return 'static-singleton' if value.nil?
+
+          if value == true || value == false
+            type_name = value ? 'true' : 'false'
+            raise TypeError, "Correlation expression must evaluate to a string or number, got boolean (#{type_name})"
+          end
+
+          if value.is_a?(String)
+            if value.start_with?('Error: ')
+              raise StandardError, value
+            end
+
+            return value
+          end
+
+          if value.is_a?(Integer)
+            return value.to_s
+          end
+
+          if value.is_a?(Float)
+            return 'NaN' if value.nan?
+            return 'Infinity' if value.infinite? && value.positive?
+            return '-Infinity' if value.infinite? && value.negative?
+            return value.to_i.to_s if (value % 1.0).zero?
+
+            return value.to_s
+          end
+
+          raise TypeError, "Correlation expression must evaluate to a string or number, got #{value.class.name}"
+        end
+      end
+    end
+  end
+end

data/lib/hyperprobe/core/logger.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module HyperProbe
+  module Core
+    class Logger
+      COLOR_CODES = [32, 33, 34, 35, 36, 31, 92, 93, 94, 95, 96, 91].freeze # Vibrant ANSI colors
+      DISABLED_COLOR_VALUES = %w[0 false no off].freeze
+      SELECTOR_SEPARATOR = /[\s,]+/.freeze
+
+      @logger_cache = {}
+      @cache_mutex = Mutex.new
+
+      class << self
+        def get_logger(namespace = 'hyperprobe:agent')
+          @cache_mutex.synchronize do
+            @logger_cache[namespace.to_s] ||= new(namespace.to_s)
+          end
+        end
+
+        def is_namespace_enabled?(namespace, debug_value = nil)
+          val = debug_value.nil? ? ENV['DEBUG'] : debug_value
+          return false if val.nil? || val.strip.empty?
+
+          enabled_patterns, skipped_patterns = parse_selectors(val)
+
+          # Check exclusions first
+          return false if skipped_patterns.any? { |p| p.match?(namespace) }
+
+          # Check inclusions
+          enabled_patterns.any? { |p| p.match?(namespace) }
+        end
+
+        def parse_selectors(value)
+          enabled = []
+          skipped = []
+
+          (value || '').split(SELECTOR_SEPARATOR).each do |selector|
+            clean = selector.strip
+            next if clean.empty?
+
+            is_skip = clean.start_with?('-')
+            raw_pattern = is_skip ? clean[1..-1] : clean
+            next if raw_pattern.nil? || raw_pattern.empty?
+
+            regex = compile_selector(raw_pattern)
+            if is_skip
+              skipped << regex
+            else
+              enabled << regex
+            end
+          end
+
+          [enabled, skipped]
+        end
+
+        def compile_selector(pattern)
+          regex_str = '^' + Regexp.escape(pattern).gsub('\\*', '.*?') + '$'
+          Regexp.new(regex_str, Regexp::IGNORECASE)
+        end
+
+        def reset_cache!
+          @cache_mutex.synchronize do
+            @logger_cache.clear
+          end
+        end
+      end
+
+      attr_reader :namespace, :enabled, :color
+
+      def initialize(namespace = 'hyperprobe:agent')
+        @namespace = namespace.to_s
+        @enabled = self.class.is_namespace_enabled?(@namespace)
+        @color = select_namespace_color(@namespace)
+        @last_log_time_ms = monotonic_ms
+        @mutex = Mutex.new
+      end
+
+      def debug_enabled?
+        @enabled
+      end
+
+      alias is_debug_enabled debug_enabled?
+
+      def debug(message)
+        return unless @enabled
+
+        write_log(message, $stdout)
+      end
+
+      def info(message)
+        if @enabled
+          write_log(message, $stdout)
+        end
+      end
+
+      def warn(message)
+        timestamp = Time.now.utc.strftime('%Y-%m-%d %H:%M:%S.%L')
+        formatted = "#{timestamp} \e[33m[HyperProbe WARN]\e[0m [#{@namespace}] #{message}"
+        $stdout.puts(formatted)
+        $stdout.flush rescue nil
+      end
+
+      def error(message, exception = nil)
+        timestamp = Time.now.utc.strftime('%Y-%m-%d %H:%M:%S.%L')
+        formatted = "#{timestamp} \e[31m[HyperProbe ERROR]\e[0m [#{@namespace}] #{message}"
+        $stderr.puts(formatted)
+        if exception
+          $stderr.puts("  #{exception.class}: #{exception.message}")
+          $stderr.puts(exception.backtrace.first(5).map { |l| "    at #{l}" }.join("\n")) if exception.backtrace
+        end
+        $stderr.flush rescue nil
+      end
+
+      def force_info(message)
+        timestamp = Time.now.utc.strftime('%Y-%m-%d %H:%M:%S.%L')
+        formatted = "#{timestamp} \e[34mHyperProbe\e[0m -- [#{@namespace}] #{message}"
+        $stdout.puts(formatted)
+        $stdout.flush rescue nil
+      end
+
+      alias forceInfo force_info
+
+      def force_error(message, exception = nil)
+        error(message, exception)
+      end
+
+      alias forceError force_error
+
+      private
+
+      def write_log(message, stream)
+        now = monotonic_ms
+        delta_str = ''
+
+        @mutex.synchronize do
+          delta = now - @last_log_time_ms
+          delta_str = " \e[#{@color}m+#{delta}ms\e[0m" if delta > 0
+          @last_log_time_ms = now
+        end
+
+        prefix = if colors_enabled?(stream)
+                   "\e[1m\e[#{@color}m#{@namespace}\e[0m"
+                 else
+                   @namespace
+                 end
+
+        stream.puts("  #{prefix} \e[90m#{message}\e[0m#{delta_str}")
+        stream.flush rescue nil
+      end
+
+      def select_namespace_color(ns)
+        hash_val = 0
+        ns.each_char.with_index do |char, idx|
+          hash_val += (idx + 1) * char.ord
+        end
+        COLOR_CODES[hash_val % COLOR_CODES.length]
+      end
+
+      def colors_enabled?(stream)
+        configured = ENV['DEBUG_COLORS']
+        if configured
+          return !DISABLED_COLOR_VALUES.include?(configured.strip.downcase)
+        end
+
+        stream.respond_to?(:tty?) && stream.tty?
+      rescue StandardError
+        false
+      end
+
+      def monotonic_ms
+        Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+      end
+    end
+  end
+end