active_record_postgres_recovery 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 118ac55f7530ffc31fccd078108f058f26f89bf4c4246e38a84b31fd3e48f003
+  data.tar.gz: 27891803b4db3439ee951d1422c1e60bc0ec5dc5dd75aeb40280bbe8b59e6432
+SHA512:
+  metadata.gz: eaf635b5582d4de246f5c121a91e18033c0714b77f94e4900641bb67c5a6b3d040fae9e6354a20f3c0f0e6bb4ed9b24114e59b02bf4288ee520b9b7f3d1ad032
+  data.tar.gz: 17126675891167aca2d5fee6f8bfd21c93dfa22573af935bc450852545cebe16538e7f3da53c8e3597fc6be32b7b08103e7ebb546ee75583921c5bf5c113c18f

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hassan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+# ActiveRecordPostgresRecovery
+
+Safe PostgreSQL connection recovery for Rails apps using ActiveRecord.
+
+This gem handles a narrow production failure mode: Rails still has a stale or invalid PostgreSQL connection after a deploy, AWS RDS PostgreSQL failover, restart, or network interruption. It can retry safe read queries, clear affected ActiveRecord connection pools, and emit structured recovery events to your observability stack.
+
+It does not hide database outages and it does not retry writes.
+
+## Installation
+
+Add this line to your Rails app Gemfile:
+
+```ruby
+gem 'active_record_postgres_recovery'
+```
+
+Then run:
+
+```sh
+bundle install
+```
+
+## Configuration
+
+Create `config/initializers/active_record_postgres_recovery.rb`:
+
+```ruby
+ActiveRecordPostgresRecovery.configure do |config|
+  config.enabled = true
+  config.retry_read_queries = true
+  config.max_retries = 1
+  config.roles = %i[writing reading]
+  config.failover_clear_roles = %i[writing]
+
+  config.reporter = lambda do |event|
+    Bugsnag.notify(event.matched_error) do |report|
+      report.severity = 'warning'
+      report.add_metadata(:active_record_postgres_recovery, event.to_h)
+    end
+  end
+end
+```
+
+The reporter is optional. Without one, recovery still runs but events are not sent anywhere. If the reporter itself raises, the gem logs a warning and continues without masking the database recovery path.
+
+For production rollouts, prefer environment-backed switches so recovery can be disabled without a deploy:
+
+```ruby
+ActiveRecordPostgresRecovery.configure do |config|
+  config.enabled = ENV.fetch('ACTIVE_RECORD_POSTGRES_RECOVERY_ENABLED', true)
+  config.retry_read_queries = ENV.fetch('ACTIVE_RECORD_POSTGRES_RECOVERY_RETRY_READS', true)
+  config.max_retries = ENV.fetch('ACTIVE_RECORD_POSTGRES_RECOVERY_MAX_RETRIES', 1)
+
+  config.reporter = lambda do |event|
+    Rails.logger.warn(
+      event: 'active_record_postgres_recovery',
+      recovery: event.to_h
+    )
+  end
+end
+```
+
+### Options
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `enabled` | `true` | Enables recovery handling. When false, matching database errors are re-raised without recovery logic. |
+| `reporter` | `nil` | Callable that receives a `RecoveryEvent`. Use this to send recovery data to Bugsnag, Datadog, logs, or metrics. |
+| `roles` | `%i[writing reading]` | ActiveRecord roles whose pools are fully cleared for normal stale connection errors. |
+| `failover_clear_roles` | `%i[writing]` | ActiveRecord roles cleared when a read-only transaction error indicates a bad failover/write connection. |
+| `retry_read_queries` | `true` | Enables one or more retries for safe read queries outside transactions. |
+| `max_retries` | `1` | Maximum retry attempts for retryable read queries. Writes are still never retried. |
+| `error_patterns` | PostgreSQL stale connection patterns | Regex list used to decide whether an exception is handled by this gem. |
+
+You can append app-specific PostgreSQL errors if needed:
+
+```ruby
+ActiveRecordPostgresRecovery.configure do |config|
+  config.error_patterns += [
+    /server closed the connection unexpectedly/i
+  ]
+end
+```
+
+### Recovery Events
+
+The reporter receives an event with these attributes:
+
+| Attribute | Description |
+| --- | --- |
+| `outcome` | `:attempted` when recovery was attempted and the original error is re-raised, or `:recovered` after a retry succeeds. |
+| `source` | Source of the recovery event, for example `ActiveRecord` or `Sidekiq`. |
+| `context` | Query name or job context. |
+| `error` | Original exception. |
+| `matched_error` | Exception in the cause chain that matched `error_patterns`. |
+| `retrying` | Whether the operation was retrying. |
+| `clear_action` | Hash describing which connection pools were cleared before the retry or re-raise. |
+
+Use `event.to_h` for structured metadata safe to attach to observability tools.
+
+## Sidekiq
+
+If you want Sidekiq jobs to clear stale ActiveRecord connections before Sidekiq retries the job:
+
+```ruby
+require 'active_record_postgres_recovery/sidekiq_middleware'
+
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add ActiveRecordPostgresRecovery::SidekiqMiddleware
+  end
+end
+```
+
+## Safety Rules
+
+The adapter patch is intentionally conservative:
+
+- A non-transactional read query may clear the configured pools, reconnect, and retry.
+- Write queries are not retried automatically.
+- Queries inside an open transaction are not retried automatically.
+- Matching write or transaction failures clear the configured pools, report the event, and re-raise.
+- Read-only transaction errors clear the configured failover roles to force ActiveRecord away from a bad primary connection.
+
+## Supported Scope
+
+This gem is PostgreSQL-only and currently targets ActiveRecord 7.x.
+
+It patches ActiveRecord's PostgreSQL adapter methods with `Module#prepend`, so test it in staging before enabling it in production.

data/lib/active_record_postgres_recovery/configuration.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ActiveRecordPostgresRecovery
+  class Configuration
+    BOOLEAN_FALSE_VALUES = [false, nil, 'false', 'FALSE', '0', 0, 'no', 'NO', 'off', 'OFF'].freeze
+
+    attr_accessor :reporter, :error_patterns
+    attr_reader :enabled, :roles, :failover_clear_roles, :retry_read_queries, :max_retries
+
+    def initialize
+      self.enabled = true
+      @reporter = nil
+      self.roles = %i[writing reading]
+      self.failover_clear_roles = %i[writing]
+      self.retry_read_queries = true
+      self.max_retries = 1
+      @error_patterns = [
+        /PQconsumeInput\(\).*terminating connection due to administrator command.*SSL connection has been closed unexpectedly/im,
+        /PQsocket\(\) can't get socket descriptor/i,
+        /read-only transaction/i
+      ]
+    end
+
+    def enabled=(value)
+      @enabled = boolean(value)
+    end
+
+    def enabled?
+      enabled
+    end
+
+    def retry_read_queries=(value)
+      @retry_read_queries = boolean(value)
+    end
+
+    def retry_read_queries?
+      retry_read_queries
+    end
+
+    def max_retries=(value)
+      @max_retries = [Integer(value), 0].max
+    rescue ArgumentError, TypeError
+      raise ArgumentError, 'max_retries must be an integer greater than or equal to 0'
+    end
+
+    def roles=(value)
+      @roles = normalize_roles(value)
+    end
+
+    def failover_clear_roles=(value)
+      @failover_clear_roles = normalize_roles(value)
+    end
+
+    private
+
+    def boolean(value)
+      !BOOLEAN_FALSE_VALUES.include?(value)
+    end
+
+    def normalize_roles(value)
+      Array(value).map(&:to_sym)
+    end
+  end
+end

data/lib/active_record_postgres_recovery/handler.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'pg'
+require_relative 'recovery_event'
+
+module ActiveRecordPostgresRecovery
+  module Handler
+    DB_CONNECTIVITY_ERROR_CLASSES = [PG::ConnectionBad, ActiveRecord::ConnectionNotEstablished].freeze
+    READ_ONLY_TRANSACTION_MESSAGE = /read-only transaction/i
+    RECOVERY_REPORTED_IVAR = :@active_record_postgres_recovery_reported
+
+    module_function
+
+    def db_connectivity_error?(error)
+      !matching_error(error).nil?
+    end
+
+    def clear_active_connections!
+      roles = ActiveRecordPostgresRecovery.configuration.roles
+      handler = ActiveRecord::Base.connection_handler
+      roles.each { |role| handler.clear_active_connections!(role) }
+      build_clear_action(strategy: 'active', performed: true, roles: roles)
+    end
+
+    def clear_all_connections!(roles: ActiveRecordPostgresRecovery.configuration.roles)
+      handler = ActiveRecord::Base.connection_handler
+      roles.each { |role| handler.clear_all_connections!(role) }
+      build_clear_action(strategy: 'all', performed: true, roles: roles)
+    end
+
+    def clear_failover_connections!
+      roles = ActiveRecordPostgresRecovery.configuration.failover_clear_roles
+      build_clear_action(strategy: 'failover_all', performed: true, roles: roles).tap do
+        clear_all_connections!(roles: roles)
+      end
+    end
+
+    def read_only_transaction_error?(error)
+      !find_error_in_chain(error) { |current| current.message.to_s.match?(READ_ONLY_TRANSACTION_MESSAGE) }.nil?
+    end
+
+    def report_attempted_recovery(context:, error:, source:, retrying: false, clear_action: nil)
+      report_recovery(context: context, error: error, source: source, outcome: :attempted, retrying: retrying, clear_action: clear_action)
+    end
+
+    def report_successful_recovery(context:, error:, source:, clear_action: nil)
+      report_recovery(context: context, error: error, source: source, outcome: :recovered, retrying: true, clear_action: clear_action)
+    end
+
+    def report_recovery(context:, error:, source:, outcome:, retrying: false, clear_action: nil)
+      return if recovery_reported?(error)
+
+      matched_error = matching_error(error) || error
+      clear_action ||= build_clear_action(strategy: nil, performed: false, roles: [])
+
+      ActiveRecordPostgresRecovery.report(
+        RecoveryEvent.new(
+          outcome: outcome,
+          source: source,
+          context: context,
+          error: error,
+          matched_error: matched_error,
+          retrying: retrying,
+          clear_action: clear_action
+        )
+      )
+
+      mark_recovery_reported!(error)
+    end
+
+    def matching_error(error)
+      find_error_in_chain(error) { |current| connection_error?(current) }
+    end
+    private_class_method :matching_error
+
+    def connection_error?(error)
+      DB_CONNECTIVITY_ERROR_CLASSES.any? { |klass| error.is_a?(klass) } || connection_error_message?(error.message)
+    end
+    private_class_method :connection_error?
+
+    def connection_error_message?(message)
+      ActiveRecordPostgresRecovery.configuration.error_patterns.any? { |pattern| message.to_s.match?(pattern) }
+    end
+    private_class_method :connection_error_message?
+
+    def find_error_in_chain(error)
+      current = error
+
+      while current
+        return current if yield(current)
+
+        current = current.cause
+      end
+
+      nil
+    end
+    private_class_method :find_error_in_chain
+
+    def build_clear_action(strategy:, performed:, roles:, skipped_reason: nil)
+      {
+        strategy: strategy,
+        performed: performed,
+        roles: roles,
+        skipped_reason: skipped_reason
+      }
+    end
+    private_class_method :build_clear_action
+
+    def recovery_reported?(error)
+      error.instance_variable_defined?(RECOVERY_REPORTED_IVAR) &&
+        error.instance_variable_get(RECOVERY_REPORTED_IVAR)
+    end
+    private_class_method :recovery_reported?
+
+    def mark_recovery_reported!(error)
+      error.instance_variable_set(RECOVERY_REPORTED_IVAR, true)
+    rescue FrozenError
+      nil
+    end
+    private_class_method :mark_recovery_reported!
+  end
+end

data/lib/active_record_postgres_recovery/postgresql_adapter_patch.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/postgresql_adapter'
+require_relative 'handler'
+
+module ActiveRecordPostgresRecovery
+  module PostgresqlAdapterPatch
+    SOURCE = 'ActiveRecord'
+    QUERY_EXCEPTIONS = [ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotEstablished, PG::ConnectionBad].freeze
+    RECONNECT_EXCEPTIONS = [ActiveRecord::ConnectionNotEstablished, PG::ConnectionBad].freeze
+
+    def execute_and_clear(sql, name, binds, prepare: false, async: false, &block)
+      active_record_postgres_recovery_with_retry(sql, active_record_postgres_recovery_context(name)) do
+        super
+      end
+    end
+
+    def query(sql, name = nil)
+      active_record_postgres_recovery_with_retry(sql, active_record_postgres_recovery_context(name)) do
+        super
+      end
+    end
+
+    def execute(sql, name = nil)
+      active_record_postgres_recovery_with_retry(sql, active_record_postgres_recovery_context(name)) do
+        super
+      end
+    end
+
+    private
+
+    def active_record_postgres_recovery_with_retry(sql, context)
+      retry_count = 0
+      recovery_error = nil
+      recovery_clear_action = nil
+
+      begin
+        result = yield
+      rescue *QUERY_EXCEPTIONS => e
+        raise unless ActiveRecordPostgresRecovery.configuration.enabled?
+        raise unless Handler.db_connectivity_error?(e)
+
+        if active_record_postgres_recovery_retryable_query?(sql, retry_count)
+          retry_count += 1
+          recovery_error = e
+          recovery_clear_action ||= active_record_postgres_recovery_clear_connections!(e)
+          active_record_postgres_recovery_reconnect!(context, clear_action: recovery_clear_action)
+          retry
+        end
+
+        active_record_postgres_recovery_report_attempted!(
+          context,
+          recovery_error || e,
+          retrying: retry_count.positive?,
+          clear_action: recovery_clear_action
+        )
+        raise
+      end
+
+      active_record_postgres_recovery_report_successful(context, recovery_error, recovery_clear_action) if recovery_error
+
+      result
+    end
+
+    def active_record_postgres_recovery_reconnect!(context, clear_action: nil)
+      reconnect!
+    rescue *RECONNECT_EXCEPTIONS => e
+      raise unless Handler.db_connectivity_error?(e)
+
+      active_record_postgres_recovery_report_attempted!(context, e, retrying: true, clear_action: clear_action)
+      raise
+    end
+
+    def active_record_postgres_recovery_report_attempted!(context, error, retrying:, clear_action: nil)
+      clear_action ||= active_record_postgres_recovery_clear_connections!(error)
+
+      Handler.report_attempted_recovery(
+        context: context,
+        error: error,
+        retrying: retrying,
+        source: SOURCE,
+        clear_action: clear_action
+      )
+    end
+
+    def active_record_postgres_recovery_report_successful(context, error, clear_action)
+      Handler.report_successful_recovery(context: context, error: error, source: SOURCE, clear_action: clear_action)
+    end
+
+    def active_record_postgres_recovery_retryable_query?(sql, retry_count)
+      ActiveRecordPostgresRecovery.configuration.retry_read_queries? &&
+        retry_count < ActiveRecordPostgresRecovery.configuration.max_retries &&
+        !transaction_open? &&
+        !write_query?(sql)
+    rescue StandardError
+      false
+    end
+
+    def active_record_postgres_recovery_context(name)
+      "SQL #{name.respond_to?(:presence) ? name.presence : name || 'SQL'}"
+    end
+
+    def active_record_postgres_recovery_clear_connections!(error)
+      if Handler.read_only_transaction_error?(error)
+        Handler.clear_failover_connections!
+      else
+        Handler.clear_all_connections!
+      end
+    end
+  end
+end

data/lib/active_record_postgres_recovery/railtie.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+require_relative 'postgresql_adapter_patch'
+
+module ActiveRecordPostgresRecovery
+  class Railtie < Rails::Railtie
+    initializer 'active_record_postgres_recovery.patch_postgresql_adapter' do
+      ActiveSupport.on_load(:active_record) do
+        adapter = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+        next if adapter.ancestors.include?(ActiveRecordPostgresRecovery::PostgresqlAdapterPatch)
+
+        adapter.prepend(ActiveRecordPostgresRecovery::PostgresqlAdapterPatch)
+      end
+    end
+  end
+end

data/lib/active_record_postgres_recovery/recovery_event.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveRecordPostgresRecovery
+  RecoveryEvent = Struct.new(
+    :outcome,
+    :source,
+    :context,
+    :error,
+    :matched_error,
+    :retrying,
+    :clear_action,
+    keyword_init: true
+  ) do
+    def to_h
+      {
+        outcome: outcome,
+        source: source,
+        context: context,
+        retrying: retrying,
+        clear_strategy: clear_action[:strategy],
+        clear_performed: clear_action[:performed],
+        cleared_roles: clear_action[:roles],
+        clear_skipped_reason: clear_action[:skipped_reason],
+        matched_error_class: matched_error.class.name,
+        matched_error_message: matched_error.message.to_s.lines.first.to_s.strip
+      }
+    end
+  end
+end

data/lib/active_record_postgres_recovery/sidekiq_middleware.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'handler'
+
+module ActiveRecordPostgresRecovery
+  class SidekiqMiddleware
+    SOURCE = 'Sidekiq'
+
+    def call(worker, job, queue)
+      yield
+    rescue StandardError => e
+      raise unless ActiveRecordPostgresRecovery.configuration.enabled?
+      raise unless Handler.db_connectivity_error?(e)
+
+      clear_action = if Handler.read_only_transaction_error?(e)
+                       Handler.clear_failover_connections!
+                     else
+                       Handler.clear_all_connections!
+                     end
+      Handler.report_attempted_recovery(
+        context: sidekiq_context(worker, job, queue),
+        error: e,
+        source: SOURCE,
+        clear_action: clear_action
+      )
+      raise
+    end
+
+    private
+
+    def sidekiq_context(worker, job, queue)
+      "Sidekiq #{worker.class.name} jid=#{job['jid']} queue=#{queue}"
+    end
+  end
+end

data/lib/active_record_postgres_recovery/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveRecordPostgresRecovery
+  VERSION = '0.1.0'
+end

data/lib/active_record_postgres_recovery.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'active_record_postgres_recovery/version'
+require_relative 'active_record_postgres_recovery/configuration'
+
+module ActiveRecordPostgresRecovery
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def report(event)
+      configuration.reporter&.call(event)
+    rescue StandardError => e
+      report_reporter_failure(e, event)
+      nil
+    end
+
+    private
+
+    def report_reporter_failure(error, event)
+      message = "[active_record_postgres_recovery] reporter failed with #{error.class}: #{error.message} while reporting #{event.outcome} from #{event.source}"
+
+      if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+        Rails.logger.warn(message)
+      else
+        warn(message)
+      end
+    end
+  end
+end
+
+require_relative 'active_record_postgres_recovery/railtie' if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: active_record_postgres_recovery
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hassan
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: Retries safe read queries after stale PostgreSQL connection failures,
+  clears ActiveRecord connection pools, and exposes recovery events for observability.
+email:
+- m.hassanror@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/active_record_postgres_recovery.rb
+- lib/active_record_postgres_recovery/configuration.rb
+- lib/active_record_postgres_recovery/handler.rb
+- lib/active_record_postgres_recovery/postgresql_adapter_patch.rb
+- lib/active_record_postgres_recovery/railtie.rb
+- lib/active_record_postgres_recovery/recovery_event.rb
+- lib/active_record_postgres_recovery/sidekiq_middleware.rb
+- lib/active_record_postgres_recovery/version.rb
+homepage: https://github.com/your-github/active_record_postgres_recovery
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/your-github/active_record_postgres_recovery
+  source_code_uri: https://github.com/your-github/active_record_postgres_recovery
+  changelog_uri: https://github.com/your-github/active_record_postgres_recovery/releases
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Safe PostgreSQL connection recovery for Rails ActiveRecord apps.
+test_files: []