add unprotected ping

Author: AbdulRahmanAlHamali

lib/semian/activerecord_trilogy_adapter.rb

@@ -99,6 +99,15 @@ def active?
       false
     end
 
+    def unprotected_ping
+      # Call the underlying active? method without Semian protection
+      # The super here refers to the original active? from the Trilogy adapter
+      @raw_connection&.ping
+    rescue => e
+      Semian.logger&.debug("[trilogy_adapter] Unprotected ping failed: #{e.message}")
+      false
+    end
+
     def with_resource_timeout(temp_timeout)
       if @raw_connection.nil?
         prev_read_timeout = @config[:read_timeout] || 0

lib/semian/adaptive_circuit_breaker.rb

@@ -126,14 +126,28 @@ def start_ping_thread
     end
 
     def send_background_ping
-      return unless @resource&.respond_to?(:ping)
+      # Use unprotected_ping if available, otherwise fall back to ping
+      return unless @resource
+
+      ping_method = if @resource.respond_to?(:unprotected_ping)
+        :unprotected_ping
+      elsif @resource.respond_to?(:ping)
+        :ping
+      else
+        return
+      end
 
       # Send ungated ping (not affected by rejection)
       begin
-        @resource.ping
-        @pid_controller.record_ping(:success)
-      rescue
+        result = @resource.send(ping_method)
+        if result
+          @pid_controller.record_ping(:success)
+        else
+          @pid_controller.record_ping(:failure)
+        end
+      rescue => e
         @pid_controller.record_ping(:failure)
+        Semian.logger&.debug("[#{@name}] Background ping failed: #{e.message}")
       end
     end
 

lib/semian/grpc.rb

@@ -122,6 +122,28 @@ def handle_operation(operation, scope)
         @semian.send(:acquire_semian_resource, adapter: :grpc, scope: scope) { execute.call }
       end
     end
+
+    def unprotected_ping
+      # For gRPC, we'll check if the channel is in a ready state
+      # This doesn't make an actual RPC call but checks connection state
+
+      return false if @ch.nil?
+
+      # Get the channel connectivity state
+      state = @ch.connectivity_state(false)
+
+      # GRPC channel states:
+      # IDLE (0) - channel is idle
+      # CONNECTING (1) - channel is connecting
+      # READY (2) - channel is ready for work
+      # TRANSIENT_FAILURE (3) - channel has seen a failure
+      # SHUTDOWN (4) - channel has been shut down
+
+      state == 2 # GRPC::Core::ConnectivityStates::READY
+    rescue => e
+      Semian.logger&.debug("[grpc] Unprotected ping failed: #{e.message}")
+      false
+    end
   end
 end
 

lib/semian/mysql2.rb

@@ -80,6 +80,15 @@ def ping
       false
     end
 
+    def unprotected_ping
+      return false if closed?
+
+      raw_ping
+    rescue => e
+      Semian.logger&.debug("[mysql2] Unprotected ping failed: #{e.message}")
+      false
+    end
+
     def query(*args)
       if query_whitelisted?(*args)
         raw_query(*args)

lib/semian/net_http.rb

@@ -124,6 +124,33 @@ def with_resource_timeout(timeout)
       end
     end
 
+    def unprotected_ping
+      # Perform a simple HEAD request to check connectivity
+      # First ensure we're connected
+      return false unless started?
+
+      begin
+        # Create a simple HEAD request
+        req = Net::HTTP::Head.new("/")
+
+        # Temporarily save semian state and disable it
+        saved_semian_enabled = @semian_enabled
+        @semian_enabled = false
+
+        # Make the request directly without going through Semian
+        # We just need to verify we can reach the server
+        request(req)
+
+        # Any response (even error responses) means the server is reachable
+        true
+      rescue => e
+        Semian.logger&.debug("[net_http] Unprotected ping failed: #{e.message}")
+        false
+      ensure
+        @semian_enabled = saved_semian_enabled
+      end
+    end
+
     private
 
     def handle_error_responses(result)

lib/semian/redis.rb

@@ -139,6 +139,20 @@ def with_resource_timeout(temp_timeout)
       end
     end
 
+    def unprotected_ping
+      # Send a PING command directly without Semian protection
+      return false unless connected?
+
+      begin
+        # Directly call the Redis PING command bypassing Semian's io wrapper
+        raw_io { [:ping] }
+        true
+      rescue => e
+        Semian.logger&.debug("[redis] Unprotected ping failed: #{e.message}")
+        false
+      end
+    end
+
     private
 
     def resource_exceptions

lib/semian/redis/v5.rb

@@ -39,6 +39,11 @@ def semian_resource
     def semian_identifier
       _client.semian_identifier
     end
+
+    def unprotected_ping
+      # Delegate to the underlying RedisClient's unprotected_ping
+      _client.unprotected_ping
+    end
   end
 
   module RedisV5Client

lib/semian/redis_client.rb

@@ -99,6 +99,17 @@ module RedisClient
     include Semian::Adapter
     include RedisClientCommon
 
+    def unprotected_ping
+      # Send a PING command directly without Semian protection
+
+      # Use call_v to bypass the normal flow
+      result = call_v(["PING"])
+      result == "PONG"
+    rescue => e
+      Semian.logger&.debug("[redis_client] Unprotected ping failed: #{e.message}")
+      false
+    end
+
     private
 
     def resource_exceptions
@@ -129,6 +140,18 @@ module RedisClientPool
 
     define_method(:semian_resource, Semian::Adapter.instance_method(:semian_resource))
     define_method(:clear_semian_resource, Semian::Adapter.instance_method(:clear_semian_resource))
+
+    def unprotected_ping
+      # For pooled connections, use with to get a client and ping
+
+      with do |client|
+        result = client.call_v(["PING"])
+        result == "PONG"
+      end
+    rescue => e
+      Semian.logger&.debug("[redis_client_pool] Unprotected ping failed: #{e.message}")
+      false
+    end
   end
 end