semian 0.26.6 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c745b1aaf79e752138bf6cbfcff3e218022dfbaac8b3f6adba3dd9bd4091bbee
-  data.tar.gz: 03e8d192ffd5e7b86aadb3b87ad9846e4d0cc18724d67a14e72c35949a11e3f6
+  metadata.gz: cc25bcc8e0291e3f53d1ecb6ac19e56b375ce0c16974d16c20b9a847b6d2104d
+  data.tar.gz: 8c4ab8f6259e8118fa94801b28392738a05403d346941738f68bea258bc41f37
 SHA512:
-  metadata.gz: afa858cd11acdf8047f6dd38850419927915ff87b6dfeabd820ffa888b269aafc67415cce0a85543e3d49562b733a01ea8b22fd46c6b5fc24374236a333cf0ef
-  data.tar.gz: 9a087827f9abaefa6bdcdda853b3423e9a19fe9e0b6a35c2cea8650266857713ffeea39136560a6ed1f763940ff9f28868bcbb9e95aa84cac91764229cb2dfdb
+  metadata.gz: 4f0936f08aa93d042241bece483742cc03d9e50ebaf27a363aec1973026d989ee3c6c6067de13f9016a46b5a227fb40ac2136746c8da25d33895f5a4312da510
+  data.tar.gz: 6cada0bbab474810b4bc12617e2d6e323034e6b088cebfa0d41352f0f1c8e522b4fc37d2e9dde77328c1ac5a7fc76e34e76b94f313313da9363049a72fb83859

data/README.md

@@ -73,6 +73,7 @@ version is the version of the public gem with the same name:
 - [`semian/redis`][redis-semian-adapter] (~> 3.2.1)
 - [`semian/net_http`][nethttp-semian-adapter]
 - [`semian/activerecord_trilogy_adapter`][activerecord-trilogy-semian-adapter]
+- [`semian/activerecord_postgresql_adapter`][activerecord-postgresql-semian-adapter]
 - [`semian-postgres`][postgres-semian-adapter]
 
 ### Creating Adapters
@@ -154,6 +155,33 @@ client = Redis.new(semian: {
 })
 ```
 
+##### Redis Out-of-Memory Errors
+
+By default, Redis Out-of-Memory (OOM) errors will open the circuit breaker. This can be
+problematic because it prevents read operations and commands that could free up memory
+(like `DEL`, `LPOP`, etc.) from executing, hindering Redis recovery.
+
+To allow OOM errors to fail fast without opening the circuit, set `open_circuit_on_oom: false`:
+
+```ruby
+client = Redis.new(semian: {
+  name: "inventory",
+  open_circuit_on_oom: false  # OOM errors won't open the circuit
+})
+```
+
+This also works with `RedisClient`:
+
+```ruby
+client = RedisClient.config(
+  host: "localhost",
+  semian: {
+    name: "inventory",
+    open_circuit_on_oom: false
+  }
+).new_client
+```
+
 #### Configuration Validation
 
 Semian now provides a flag to specify log-based and exception-based configuration validation. To
@@ -1027,6 +1055,7 @@ $ bundle install
 [postgres-semian-adapter]: https://github.com/mschoenlaub/semian-postgres
 [redis-semian-adapter]: lib/semian/redis.rb
 [activerecord-trilogy-semian-adapter]: lib/semian/activerecord_trilogy_adapter.rb
+[activerecord-postgres-semian-adapter]: lib/semian/activerecord_postgres_adapter.rb
 [semian-adapter]: lib/semian/adapter.rb
 [nethttp-semian-adapter]: lib/semian/net_http.rb
 [nethttp-default-errors]: lib/semian/net_http.rb#L35-L45

data/lib/semian/activerecord_adapter.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "semian/adapter"
+require "active_record"
+
+module Semian
+  module ActiveRecordAdapter
+    QUERY_ALLOWLIST = %r{\A(?:/\*.*?\*/)?\s*(ROLLBACK|COMMIT|RELEASE\s+SAVEPOINT)}i
+
+    module ClassMethods
+      def query_allowlisted?(sql, *)
+        # COMMIT, ROLLBACK
+        tx_command_statement = sql.end_with?("T", "K")
+
+        # RELEASE SAVEPOINT. Nesting past _3 levels won't get bypassed.
+        # Active Record does not send trailing spaces or `;`, so we are in the realm of hand crafted queries here.
+        savepoint_statement = sql.end_with?("_1", "_2")
+        unclear = sql.end_with?(" ", ";")
+
+        if !tx_command_statement && !savepoint_statement && !unclear
+          false
+        else
+          QUERY_ALLOWLIST.match?(sql)
+        end
+      rescue ArgumentError
+        return false unless sql.valid_encoding?
+
+        raise
+      end
+    end
+
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          attr_reader(:raw_semian_options, :semian_identifier)
+        end
+      end
+    end
+
+    def initialize(*options)
+      *, config = options
+      config = config.dup
+      @raw_semian_options = config.delete(:semian)
+      @semian_identifier = begin
+        name = semian_options && semian_options[:name]
+        unless name
+          host = config[:host] || "localhost"
+          port = config[:port] || semian_adapter_default_port
+          name = "#{host}:#{port}"
+        end
+        :"#{semian_adapter_identifier_prefix}_#{name}"
+      end
+      super
+    end
+
+    if ActiveRecord.version >= Gem::Version.new("8.2.a")
+      def execute_intent(intent)
+        return super if self.class.query_allowlisted?(intent.processed_sql)
+
+        acquire_semian_resource(adapter: semian_adapter_name, scope: :query) do
+          super
+        end
+      end
+    else
+      def raw_execute(sql, *args, **kwargs, &block)
+        if self.class.query_allowlisted?(sql)
+          super
+        else
+          acquire_semian_resource(adapter: semian_adapter_name, scope: :query) do
+            super(sql, *args, **kwargs, &block)
+          end
+        end
+      end
+    end
+
+    def active?
+      acquire_semian_resource(adapter: semian_adapter_name, scope: :ping) do
+        super
+      end
+    rescue resource_busy_error_class, circuit_open_error_class
+      false
+    end
+
+    def with_resource_timeout
+      raise NotImplementedError, "#{self.class} must implement a `with_resource_timeout` method"
+    end
+
+    private
+
+    def resource_exceptions
+      [
+        ActiveRecord::AdapterTimeout,
+        ActiveRecord::ConnectionFailed,
+        ActiveRecord::ConnectionNotEstablished,
+      ]
+    end
+
+    def resource_busy_error_class
+      self.class::ResourceBusyError
+    end
+
+    def circuit_open_error_class
+      self.class::CircuitOpenError
+    end
+
+    def connect(*args)
+      acquire_semian_resource(adapter: semian_adapter_name, scope: :connection) do
+        super
+      end
+    end
+
+    def semian_adapter_name
+      raise NotImplementedError, "#{self.class} must implement an `semian_adapter_name` method"
+    end
+
+    def semian_adapter_default_port
+      raise NotImplementedError, "#{self.class} must implement an `semian_adapter_default_port` method"
+    end
+
+    def semian_adapter_identifier_prefix
+      raise NotImplementedError, "#{self.class} must implement an `semian_adapter_identifier_prefix` method"
+    end
+  end
+end

data/lib/semian/activerecord_postgresql_adapter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "semian/activerecord_adapter"
+require "active_record/connection_adapters/postgresql_adapter"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      ActiveRecord::ActiveRecordError.include(::Semian::AdapterError)
+
+      class SemianError < ConnectionNotEstablished
+        def initialize(semian_identifier, *args)
+          super(*args)
+          @semian_identifier = semian_identifier
+        end
+      end
+
+      ResourceBusyError = Class.new(SemianError)
+      CircuitOpenError = Class.new(SemianError)
+    end
+  end
+end
+
+module Semian
+  module ActiveRecordPostgreSQLAdapter
+    include Semian::Adapter
+    include Semian::ActiveRecordAdapter
+
+    class << self
+      def prepended(base)
+        base.extend(Semian::ActiveRecordAdapter::ClassMethods)
+      end
+    end
+
+    def with_resource_timeout(_temp_timeout)
+      # Resource timeouts aren't possible with PostgreSQL because there is no
+      # IO level timeout configuration, so we just yield.
+      yield
+    end
+
+    private
+
+    def semian_adapter_name = :postgresql_adapter
+
+    def semian_adapter_default_port = 5432
+
+    def semian_adapter_identifier_prefix = :postgresql
+  end
+end
+
+ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(Semian::ActiveRecordPostgreSQLAdapter)

data/lib/semian/activerecord_trilogy_adapter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require "semian/adapter"
-require "active_record"
+require "semian/activerecord_adapter"
 require "active_record/connection_adapters/trilogy_adapter"
 
 module ActiveRecord
@@ -25,84 +24,18 @@ end
 module Semian
   module ActiveRecordTrilogyAdapter
     include Semian::Adapter
+    include Semian::ActiveRecordAdapter
 
-    ResourceBusyError = ::ActiveRecord::ConnectionAdapters::TrilogyAdapter::ResourceBusyError
-    CircuitOpenError = ::ActiveRecord::ConnectionAdapters::TrilogyAdapter::CircuitOpenError
-
-    QUERY_ALLOWLIST = %r{\A(?:/\*.*?\*/)?\s*(ROLLBACK|COMMIT|RELEASE\s+SAVEPOINT)}i
-
-    # The common case here is NOT to have transaction management statements, therefore
-    # we are exploiting the fact that Active Record will use COMMIT/ROLLBACK as
-    # the suffix of the command string and
-    # name savepoints by level of nesting as `active_record_1` ... n.
-    #
-    # Since looking at the last characters in a string using `end_with?` is a LOT cheaper than
-    # running a regex, we are returning early if the last characters of
-    # the SQL statements are NOT the last characters of the known transaction
-    # control statements.
     class << self
-      def query_allowlisted?(sql, *)
-        # COMMIT, ROLLBACK
-        tx_command_statement = sql.end_with?("T") || sql.end_with?("K")
-
-        # RELEASE SAVEPOINT. Nesting past _3 levels won't get bypassed.
-        # Active Record does not send trailing spaces or `;`, so we are in the realm of hand crafted queries here.
-        savepoint_statement = sql.end_with?("_1") || sql.end_with?("_2")
-        unclear = sql.end_with?(" ") || sql.end_with?(";")
-
-        if !tx_command_statement && !savepoint_statement && !unclear
-          false
-        else
-          QUERY_ALLOWLIST.match?(sql)
-        end
-      rescue ArgumentError
-        return false unless sql.valid_encoding?
-
-        raise
+      def prepended(base)
+        base.extend(Semian::ActiveRecordAdapter::ClassMethods)
       end
     end
 
-    attr_reader :raw_semian_options, :semian_identifier
-
-    def initialize(*options)
-      *, config = options
-      config = config.dup
-      @raw_semian_options = config.delete(:semian)
-      @semian_identifier = begin
-        name = semian_options && semian_options[:name]
-        unless name
-          host = config[:host] || "localhost"
-          port = config[:port] || 3306
-          name = "#{host}:#{port}"
-        end
-        :"mysql_#{name}"
-      end
-      super
-    end
-
-    def raw_execute(sql, *)
-      if Semian::ActiveRecordTrilogyAdapter.query_allowlisted?(sql)
-        super
-      else
-        acquire_semian_resource(adapter: :trilogy_adapter, scope: :query) do
-          super
-        end
-      end
-    end
-    ruby2_keywords :raw_execute
-
-    def active?
-      acquire_semian_resource(adapter: :trilogy_adapter, scope: :ping) do
-        super
-      end
-    rescue ResourceBusyError, CircuitOpenError
-      false
-    end
-
     def with_resource_timeout(temp_timeout)
       if @raw_connection.nil?
         prev_read_timeout = @config[:read_timeout] || 0
-        @config.merge!(read_timeout: temp_timeout) # Create new client with temp_timeout for read timeout
+        @config.merge!(read_timeout: temp_timeout)
       else
         prev_read_timeout = @raw_connection.read_timeout
         @raw_connection.read_timeout = temp_timeout
@@ -115,19 +48,11 @@ module Semian
 
     private
 
-    def resource_exceptions
-      [
-        ActiveRecord::AdapterTimeout,
-        ActiveRecord::ConnectionFailed,
-        ActiveRecord::ConnectionNotEstablished,
-      ]
-    end
+    def semian_adapter_name = :trilogy_adapter
 
-    def connect(*args)
-      acquire_semian_resource(adapter: :trilogy_adapter, scope: :connection) do
-        super
-      end
-    end
+    def semian_adapter_default_port = 3306
+
+    def semian_adapter_identifier_prefix = :mysql
   end
 end
 

data/lib/semian/redis/v5.rb

@@ -5,6 +5,16 @@ require "semian/redis_client"
 class Redis
   BaseConnectionError.include(::Semian::AdapterError)
   OutOfMemoryError.include(::Semian::AdapterError)
+  OutOfMemoryError.class_eval do
+    attr_accessor :semian_open_circuit_on_oom
+
+    # By default, OOM errors open circuits (backward compatible behavior).
+    # Set `open_circuit_on_oom: false` to disable this if you want reads/deletes
+    # to continue working when Redis is OOM, allowing it to recover.
+    def marks_semian_circuits?
+      @semian_open_circuit_on_oom != false
+    end
+  end
 
   class ReadOnlyError < Redis::BaseConnectionError
     # A ReadOnlyError is a fast failure and we don't want to track these errors so that we can reconnect
@@ -47,6 +57,9 @@ module Semian
       if redis_error < ::Semian::AdapterError
         redis_error = redis_error.new(error.message)
         redis_error.semian_identifier = error.semian_identifier
+        if error.respond_to?(:semian_open_circuit_on_oom) && redis_error.respond_to?(:semian_open_circuit_on_oom=)
+          redis_error.semian_open_circuit_on_oom = error.semian_open_circuit_on_oom
+        end
       end
       raise redis_error, error.message, error.backtrace
     end

data/lib/semian/redis.rb

@@ -23,6 +23,15 @@ class Redis
 
   class OutOfMemoryError < Redis::CommandError
     include ::Semian::AdapterError
+
+    attr_accessor :semian_open_circuit_on_oom
+
+    # By default, OOM errors open circuits (backward compatible behavior).
+    # Set `open_circuit_on_oom: false` to disable this if you want reads/deletes
+    # to continue working when Redis is OOM, allowing it to recover.
+    def marks_semian_circuits?
+      @semian_open_circuit_on_oom != false
+    end
   end
 
   class ConnectionError < Redis::BaseConnectionError
@@ -159,7 +168,9 @@ module Semian
       return unless reply.is_a?(::Redis::CommandError)
       return unless reply.message =~ /OOM command not allowed when used memory > 'maxmemory'/
 
-      raise ::Redis::OutOfMemoryError, reply.message
+      error = ::Redis::OutOfMemoryError.new(reply.message)
+      error.semian_open_circuit_on_oom = semian_options&.fetch(:open_circuit_on_oom, true)
+      raise error
     end
 
     def dns_resolve_failure?(e)

data/lib/semian/redis_client.rb

@@ -13,6 +13,17 @@ class RedisClient
   end
 
   OutOfMemoryError.include(::Semian::AdapterError)
+  OutOfMemoryError.class_eval do
+    attr_accessor :semian_open_circuit_on_oom
+
+    # By default, OOM errors open circuits (backward compatible behavior).
+    # Set `open_circuit_on_oom: false` to disable this if you want reads/dequeues
+    # to continue working when Redis is OOM, allowing it to recover.
+    # This is considered a fast failure.
+    def marks_semian_circuits?
+      @semian_open_circuit_on_oom != false
+    end
+  end
 
   class ReadOnlyError < RedisClient::ConnectionError
     # A ReadOnlyError is a fast failure and we don't want to track these errors so that we can reconnect
@@ -110,6 +121,10 @@ module Semian
         super do |connection|
           acquire_semian_resource(adapter: :redis_client, scope: :query) do
             yield connection
+          rescue ::RedisClient::OutOfMemoryError => error
+            error.semian_identifier = semian_identifier
+            error.semian_open_circuit_on_oom = semian_options&.fetch(:open_circuit_on_oom, true)
+            raise
           end
         end
       else

data/lib/semian/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Semian
-  VERSION = "0.26.6"
+  VERSION = "0.27.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: semian
 version: !ruby/object:Gem::Version
-  version: 0.26.6
+  version: 0.27.0
 platform: ruby
 authors:
 - Scott Francis
@@ -47,6 +47,8 @@ files:
 - ext/semian/tickets.h
 - ext/semian/types.h
 - lib/semian.rb
+- lib/semian/activerecord_adapter.rb
+- lib/semian/activerecord_postgresql_adapter.rb
 - lib/semian/activerecord_trilogy_adapter.rb
 - lib/semian/adapter.rb
 - lib/semian/circuit_breaker.rb
@@ -92,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.4
 specification_version: 4
 summary: Bulkheading for Ruby with SysV semaphores
 test_files: []