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

data/lib/hyperprobe/core/broker.rb

@@ -2,17 +2,14 @@
 
 require 'securerandom'
 require 'socket'
-require_relative '../protos'
+require 'json'
 
 if RUBY_PLATFORM !~ /java/
-  begin
-    require 'grpc'
-  rescue LoadError
-    # Handled gracefully if grpc gem is absent
-  end
+  require 'grpc'
 else
-  require 'java'
+  require_relative 'transports/java_grpc'
 end
+require_relative '../protos'
 
 module HyperProbe
   module Core
@@ -34,19 +31,24 @@ module HyperProbe
         @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
+        @rpc_timeout_sec = valid_timeout(rpc_timeout_sec)
         @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)
+          @transport = Transports::JavaGrpc.new(broker_url, @service_id, enable_keep_alive)
         else
-          init_cruby_client(broker_url, enable_keep_alive)
+          @calls_mutex = Mutex.new
+          @active_calls = []
+          @closed = false
+          target, creds, channel_args = parse_broker_url(broker_url, enable_keep_alive)
+          @channel = GRPC::Core::Channel.new(target, channel_args, creds)
+          @stub = Hyperprobe::Agent::V1::AgentBroker::Stub.new(target, creds, channel_override: @channel)
         end
       end
 
       def get_probes(timeout_sec = nil)
+        deadline = calculate_deadline(timeout_sec || @rpc_timeout_sec)
         req = Hyperprobe::Agent::V1::GetProbesRequest.new(
           agent_id: @agent_id,
           service_id: @service_id,
@@ -58,96 +60,66 @@ module HyperProbe
         )
 
         if @is_jruby
-          call_jruby_rpc('/hyperprobe.agent.v1.AgentBroker/GetProbes', req, Hyperprobe::Agent::V1::GetProbesResponse, timeout_sec)
+          call_jruby_rpc('hyperprobe.agent.v1.AgentBroker/GetProbes', req, Hyperprobe::Agent::V1::GetProbesResponse, deadline)
         else
-          deadline = calculate_deadline(timeout_sec || @rpc_timeout_sec)
-          metadata = { 'x-hp-service-id' => @service_id }
-          @stub.get_probes(req, metadata: metadata, deadline: deadline)
+          call_cruby_rpc(:get_probes, req, deadline)
         end
       end
 
       def report_telemetry(events, timeout_sec = nil)
         return [] if events.nil? || events.empty?
 
+        deadline = calculate_deadline(timeout_sec || @rpc_timeout_sec)
         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
+        batch = Hyperprobe::Agent::V1::TelemetryBatch.new(agent_id: @agent_id, events: proto_events)
+
+        response = if @is_jruby
+                     call_jruby_rpc('hyperprobe.agent.v1.AgentBroker/ReportTelemetry', batch, Hyperprobe::Agent::V1::TelemetryResponse, deadline)
+                   else
+                     call_cruby_rpc(:report_telemetry, batch, deadline)
+                   end
+        response.finished_probe_ids.to_a
       end
 
       def estimate_event_size(event)
         proto = build_telemetry_event_proto(event)
-        proto.to_proto.bytesize
+        proto.respond_to?(:serialized_size) ? proto.serialized_size : 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
+        if @is_jruby
+          @transport.shutdown
         else
-          @base_url = "http://#{raw_url}"
+          calls = @calls_mutex.synchronize do
+            @closed = true
+            @active_calls.dup
+          end
+          # Closing a C-core channel alone does not cancel outstanding Ruby operations.
+          calls.each(&:cancel)
+          @channel.close
         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)
+      private
 
-        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)
+      def call_cruby_rpc(method, request, deadline)
+        operation = @stub.public_send(method, request, metadata: { 'x-hp-service-id' => @service_id },
+                                      deadline: deadline, return_op: true)
+        @calls_mutex.synchronize do
+          raise IOError, 'Broker transport is shut down' if @closed
 
-        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))
+          @active_calls << operation
         end
+        operation.execute
+      ensure
+        @calls_mutex.synchronize { @active_calls.delete(operation) }
+      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)
+      def call_jruby_rpc(method_path, request_proto, response_class, deadline)
+        payload = request_proto.to_proto
+        response_class.decode(@transport.call(method_path, payload, deadline))
       end
 
       def build_telemetry_event_proto(evt)
@@ -180,15 +152,20 @@ module HyperProbe
       end
 
       def calculate_deadline(timeout_sec)
-        return nil unless timeout_sec && timeout_sec.positive?
+        now = @is_jruby ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : Time.now
+        now + valid_timeout(timeout_sec)
+      end
+
+      def valid_timeout(value)
+        timeout = Float(value)
+        raise ArgumentError, 'RPC timeout must be finite and positive' unless timeout.finite? && timeout.positive?
 
-        Time.now + timeout_sec
+        timeout
       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
@@ -196,16 +173,9 @@ module HyperProbe
         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]
+          [raw_url.sub('https://', ''), GRPC::Core::ChannelCredentials.new, channel_args]
         else
-          creds = :this_channel_is_insecure
-          [raw_url, creds, channel_args]
+          [raw_url.sub(/\Ahttp:\/\//, ''), :this_channel_is_insecure, channel_args]
         end
       end
     end