active_record_proxy_adapters 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5312effcf68a3305eb5e7804440112433f5b6837d6b71e7d122145eac4741619
-  data.tar.gz: 50586657daa02e76dfffebbe1faf8df5093198471faf847cec97cd16634c0c17
+  metadata.gz: efb046fb2816644ce048912c4c2666ae00f90fd728800f867cbe79bab99a59f3
+  data.tar.gz: 3d193415b9063dcfb5633c8e1493c20742f8cfbf06bc0baa7efccb291c727b49
 SHA512:
-  metadata.gz: 707b80a3618328639126d13f3f76bb8123105019b3e30c75f15c66a66a88d49aa5de4301fe70b25ff5356ef37e54ebff896f4cab0160cadbb79d08ae9cf0dc4e
-  data.tar.gz: 6b84984e33cf87abe9a12f5553bccffc32e2a9563a0c859c488cdae4be4c3a019ffce01242648620c67bb85a16dc61d982f0be8ecba83943f01c718e067743dc
+  metadata.gz: 8faf6efe63b55a9f00bbd4664f862abd3f0dd729f22b4e59306515a5dcd0fefbd42077cfaafc39f33f75d23eedd11a861e9284ba38c15868c69f72956d3acbbb
+  data.tar.gz: 91717a29aca4d6c41c71436527adb72cac844a4d19a2707eb5111d4f5f8b42b3c017990bdcc77972b48a7fa32082b02f74328a4c86b4f87cebc776b1d1641a17

data/CHANGELOG.md

@@ -1,26 +1,37 @@
 ## [Unreleased]
 
+- Handle PendingMigrationConnection introduced by Rails 7.2 and backported to Rails 7.1
+- Stick to same connection throughout request span
+
+## [0.2.1] - 2025-01-02
+
+- Fix replica connection pool getter when specific connection name is not found https://github.com/Nasdaq/active_record_proxy_adapters/commit/847e150dd21c5bc619745ee1d9d8fcaa9b8f2eea
+
 ## [0.2.0] - 2024-12-24
 
-- Add custom log subscriber to tag queries based on the adapter being used (68b8c1f4191388eb957bf12e0f84289da667e940)
+- Add custom log subscriber to tag queries based on the adapter being used https://github.com/Nasdaq/active_record_proxy_adapters/commit/68b8c1f4191388eb957bf12e0f84289da667e940
+
+## [0.1.4] - 2025-01-02
+
+- Fix replica connection pool getter when specific connection name is not found https://github.com/Nasdaq/active_record_proxy_adapters/commit/88b32a282b54d420e652f638656dbcf063ac8796
 
 ## [0.1.3] - 2024-12-24
 
-- Fix replica connection pool getter when database configurations have multiple replicas (ea5a33997da45ac073f166b3fbd2d12426053cd6)
-- Retrieve replica pool without checking out a connection (6470ef58e851082ae1f7a860ecdb5b451ef903c8)
+- Fix replica connection pool getter when database configurations have multiple replicas https://github.com/Nasdaq/active_record_proxy_adapters/commit/ea5a33997da45ac073f166b3fbd2d12426053cd6
+- Retrieve replica pool without checking out a connection https://github.com/Nasdaq/active_record_proxy_adapters/commit/6470ef58e851082ae1f7a860ecdb5b451ef903c8
 
 ## [0.1.2] - 2024-12-16
 
-- Fix CTE regex matcher (4b1d10bfd952fb1f5b102de8cc1a5bd05d25f5e9)
+- Fix CTE regex matcher https://github.com/Nasdaq/active_record_proxy_adapters/commit/4b1d10bfd952fb1f5b102de8cc1a5bd05d25f5e9
 
 ## [0.1.1] - 2024-11-27
 
-- Enable RubyGems MFA (2a71b1f4354fb966cc0aa68231ca5837814e07ee)
+- Enable RubyGems MFA https://github.com/Nasdaq/active_record_proxy_adapters/commit/2a71b1f4354fb966cc0aa68231ca5837814e07ee
 
 ## [0.1.0] - 2024-11-19
 
-- Add PostgreSQLProxyAdapter (2b3bb9f7359139519b32af3018ceb07fed8c6b33)
+- Add PostgreSQLProxyAdapter https://github.com/Nasdaq/active_record_proxy_adapters/commit/2b3bb9f7359139519b32af3018ceb07fed8c6b33
 
 ## [0.1.0.rc2] - 2024-10-28
 
-- Add PostgreSQLProxyAdapter (2b3bb9f7359139519b32af3018ceb07fed8c6b33)
+- Add PostgreSQLProxyAdapter https://github.com/Nasdaq/active_record_proxy_adapters/commit/2b3bb9f7359139519b32af3018ceb07fed8c6b33

data/Dockerfile

@@ -8,7 +8,7 @@ RUN apk --update add \
     build-base \
     git \
     postgresql-dev \
-    postgresql-client
+    postgresql17-client
 RUN gem install bundler -v 2.5.13
 
 COPY . /app

data/README.md

@@ -1,7 +1,24 @@
 # ActiveRecordProxyAdapters
 
+[![Run Test Suite](https://github.com/Nasdaq/active_record_proxy_adapters/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/Nasdaq/active_record_proxy_adapters/actions/workflows/test.yml)
+
 A set of ActiveRecord adapters that leverage Rails native multiple database setup to allow automatic connection switching from _one_ primary pool to _one_ replica pool at the database statement level.
 
+## Why do I need this?
+
+Maybe you don't. Rails already provides, since version 6.0, a [Rack middleware](https://guides.rubyonrails.org/active_record_multiple_databases.html#activating-automatic-role-switching) that switches between primary and replica automatically based on the HTTP request (`GET` and `HEAD` requests go the primary, everything else goes to the replica).
+
+The caveat is: you are not allowed do any writes in any `GET` or `HEAD` requests (including controller callbacks).
+Which means, for example, your `devise` callbacks that save user metadata will now crash.
+So will your `ahoy-matey` callbacks.
+
+You will then start wrapping those callbacks in `ApplicationRecord.connected_to(role :reading) {}` blocks as a workaround and, many months later, you have dozens of those (we had nearly 40 when we decided to build this gem).
+
+By the way, that middleware only works at HTTP request layer (well, duh! it's a Rack middleware).
+So not good for background jobs, cron jobs or anything that happens outside the scope of an HTTP request. And, if your application needs a replica at this point, for sure you would benefit from automatic connection switching in background jobs too, wouldn't you?
+
+This gem is heavily inspired by [Makara](https://github.com/instacart/makara), a fantastic gem built by the Instacart folks, which is [no longer maintained](https://github.com/instacart/makara/issues/393), but we took a slightly different, slimmer approach. We don't support load balancing replicas, and that is by design. We believe that should be done outside the scope of the application (using tools like `Pgpool-II`, `pgcat` or RDS Proxy).
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -31,6 +48,15 @@ development:
     # your replica credentials here
 ```
 
+```ruby
+# app/models/application_record.rb
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  connects_to database: { writing: :primary, reading: :primary_replica }
+end
+```
+
 ### Off Rails
 
 ```ruby
@@ -62,7 +88,7 @@ class ApplicationRecord << ActiveRecord::Base
 end
 ```
 
-### Configuration
+## Configuration
 
 The gem comes preconfigured out of the box. However, if default configuration does not suit your needs, you can modify them by using a `.configure` block:
 
@@ -77,7 +103,40 @@ ActiveRecordProxyAdapters.configure do |config|
 end
 ```
 
-### How it works
+## Logging
+
+```ruby
+# config/initializers/active_record_proxy_adapters.rb
+require "active_record_proxy_adapters/log_subscriber"
+
+ActiveRecordProxyAdapters.configure do |config|
+  config.log_subscriber_primary_prefix = "My primary tag" # defaults to "#{adapter_name} Primary", i.e "PostgreSQL Primary"
+  config.log_subscriber_replica_prefix = "My replica tag" # defaults to "#{adapter_name} Replica", i.e "PostgreSQL Replica"
+end
+
+# You may want to remove duplicate logs
+ActiveRecord::LogSubscriber.detach_from :active_record
+```
+
+### Example:
+
+```ruby
+irb(main):001> User.count ; User.create(name: 'John Doe', email: 'john.doe@example.com') ; 3.times { User.count ; sleep(1) }
+```
+yields
+
+```
+D, [2024-12-24T17:18:49.151235 #328] DEBUG -- :   [My replica tag] User Count (0.5ms)  SELECT COUNT(*) FROM "users"
+D, [2024-12-24T17:18:49.156633 #328] DEBUG -- :   [My primary tag] TRANSACTION (0.1ms)  BEGIN
+D, [2024-12-24T17:18:49.157323 #328] DEBUG -- :   [My primary tag] User Create (0.4ms)  INSERT INTO "users" ("name", "email", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "John Doe"], ["email", "john.doe@example.com"], ["created_at", "2024-12-24 17:18:49.156063"], ["updated_at", "2024-12-24 17:18:49.156063"]]
+D, [2024-12-24T17:18:49.158305 #328] DEBUG -- :   [My primary tag] TRANSACTION (0.7ms)  COMMIT
+D, [2024-12-24T17:18:49.159079 #328] DEBUG -- :   [My primary tag] User Count (0.3ms)  SELECT COUNT(*) FROM "users"
+D, [2024-12-24T17:18:50.166105 #328] DEBUG -- :   [My primary tag] User Count (1.9ms)  SELECT COUNT(*) FROM "users"
+D, [2024-12-24T17:18:51.169911 #328] DEBUG -- :   [My replica tag] User Count (0.9ms)  SELECT COUNT(*) FROM "users"
+=> 3
+```
+
+## How it works
 
 The proxy will analyze each SQL string, using pattern matching, to decide the appropriate connection for it (i.e. if it should go to the primary or replica).
 
@@ -89,10 +148,175 @@ The proxy will analyze each SQL string, using pattern matching, to decide the ap
 - All sequence methods (e.g `nextval`) go the primary
 - Everything else goes to the replica
 
-#### TL;DR
+### TL;DR
 
 All `SELECT` queries go to the _replica_, everything else goes to _primary_.
 
+## Stickiness context
+
+Similar to Rails' built-in [automatic role switching](https://guides.rubyonrails.org/active_record_multiple_databases.html#activating-automatic-role-switching) Rack middleware, the proxy guarantes read-your-own-writes consistency by keeping a contextual timestamp for each Adapter Instance (a.k.a what you get when you call `Model.connection`).
+
+Until `config.proxy_delay` time has been reached, all subsequent read requests _only for that connection_ will be rerouted to the primary. Once that has been reached, all following read requests will go the replica.
+
+Although the gem comes configured out of the box with `config.proxy_delay = 2.seconds`, it is your responsibility to find the proper number to use here, as that is very particular to each application and may be affected by many different factors (i.e. hardware, workload, availability, fault-tolerance, etc.). **Do not use this gem** if you don't have any replication delay metrics avaiable in your production APM. And make sure you have the proper alerts setup in case there's a spike in replication delay.
+
+One strategy you can use to quickly disable the proxy is set your adapter using an environment variable:
+
+```yaml
+# config/database.yml
+production:
+  primary:
+    adapter: <%= ENV.fetch("PRIMARY_DATABASE_ADAPTER", "postgresql") %>
+  primary_replica:
+    adapter: postgresql
+    replica: true
+```
+Then set `PRIMARY_DATABASE_ADAPTER=postgresql_proxy` to enable the proxy.
+That way you can redeploy your application disabling the proxy completely, without any code change.
+
+### Sticking to the primary database manually
+
+The proxy respects ActiveRecord's `#connected_to_stack` and will use it if present.
+You can use that to force connection to the primary or replica and bypass the proxy entirely.
+
+```ruby
+User.create(name: 'John Doe', email: 'john.doe@example.com')
+last_user = User.last # This would normally go to the primary to adhere to read-your-own-writes consistency
+last_user = ApplicationRecord.connected_to(role: :reading) { User.last } # but I can override it with this block
+```
+
+This is useful when picking up a background job that could be impacted by replication delay.
+
+```ruby
+# app/models/application_record.rb
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  connects_to database: { writing: :primary, reading: :primary_replica }
+end
+
+# app/models/user.rb
+class User < ApplicationRecord
+  validates :name, :email, presence: true
+
+  after_commit :say_hello, on: :create
+
+  private
+
+  def say_hello
+    SayHelloJob.perform_later(id) # new row may not be replicated yet
+  end
+end
+
+# app/jobs/say_hello_job.rb
+class SayHelloJob < ApplicationJob
+  def perform(user_id)
+    # so we manually reroute it to the primary
+    user = ApplicationRecord.connected_to(role: :writing) { User.find(user_id) }
+
+    UserMailer.welcome(user).deliver_now
+  end
+end
+```
+
+### Thread safety
+
+Since Rails already leases exactly one connection per thread from the pool and the adapter operates on that premise, it is safe to use it in multi-threaded servers such as Puma.
+
+As long as you're not writing thread unsafe code that handles connections from the pool directly, or you don't have any other gem depenencies that write thread unsafe pool operations, you're all set.
+
+There is, however, an open bug in `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter` for Rails versions 7.1 and greater that can cause random race conditions, but it's not caused by this gem (More info [here](https://github.com/rails/rails/issues/51780)).
+Rails 7.0 works as expected.
+
+Multi-threaded queries example:
+```ruby
+# app/models/application_record.rb
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  connects_to database: { writing: :primary, reading: :primary_replica }
+end
+
+# app/models/portal.rb
+class Portal < ApplicationRecord
+end
+
+# in rails console -e test
+ActiveRecord::Base.logger.formatter = proc do |_severity, _time, _progname, msg|
+  "[#{Time.current.iso8601} THREAD #{Thread.current[:name]}] #{msg}\n"
+end
+
+def read_your_own_writes
+  proc do
+    Portal.all.count # should go to the replica
+    FactoryBot.create(:portal)
+
+    5.times do
+      Portal.all.count # first one goes the primary, last 3 should go to the replica
+      sleep(3)
+    end
+  end
+end
+
+def use_replica
+  proc do
+    5.times do
+      Portal.all.count # should always go the replica
+      sleep(1.5)
+    end
+  end
+end
+
+def executor
+  Rails.application.executor
+end
+
+def test_multithread_queries
+  ActiveRecordProxyAdapters.configure do |config|
+    config.proxy_delay = 2.seconds
+    config.checkout_timeout = 2.seconds
+  end
+
+  t1 = Thread.new do
+    Thread.current[:name] = "USE REPLICA"
+    executor.wrap { ActiveRecord::Base.uncached { use_replica.call } }
+  end
+
+  t2 = Thread.new do
+    Thread.current[:name] = "READ YOUR OWN WRITES"
+    executor.wrap { ActiveRecord::Base.uncached { read_your_own_writes.call } }
+  end
+
+  [t1, t2].each(&:join)
+end
+```
+
+Yields:
+```bash
+irb(main):051:0> test_multithread_queries
+[2024-12-24T13:52:40-05:00 THREAD USE REPLICA]   [PostgreSQL Replica] Portal Count (1.4ms)  SELECT COUNT(*) FROM "portals"
+[2024-12-24T13:52:40-05:00 THREAD READ YOUR OWN WRITES]   [PostgreSQL Replica] Portal Count (0.4ms)  SELECT COUNT(*) FROM "portals"
+[2024-12-24T13:52:40-05:00 THREAD READ YOUR OWN WRITES]   [PostgreSQLProxy Primary] TRANSACTION (0.5ms)  BEGIN
+[2024-12-24T13:52:40-05:00 THREAD READ YOUR OWN WRITES]   [PostgreSQLProxy Primary] Portal Exists? (1.2ms)  SELECT 1 AS one FROM "portals" WHERE "portals"."id" IS NOT NULL AND "portals"."slug" = $1 LIMIT $2  [["slug", "portal-e065948fbbee73d3b2c576b48c2b37e021115158edc6a92390d613640460e1d4"], ["LIMIT", 1]]
+[2024-12-24T13:52:40-05:00 THREAD READ YOUR OWN WRITES]   [PostgreSQLProxy Primary] Portal Exists? (0.4ms)  SELECT 1 AS one FROM "portals" WHERE "portals"."name" = $1 LIMIT $2  [["name", "Portal-e065948fbbee73d3b2c576b48c2b37e021115158edc6a92390d613640460e1d4"], ["LIMIT", 1]]
+[2024-12-24T13:52:40-05:00 THREAD READ YOUR OWN WRITES]   [PostgreSQLProxy Primary] Portal Create (0.8ms)  INSERT INTO "portals" ("name", "slug", "logo", "created_at", "updated_at", "visible") VALUES ($1, $2, $3, $4, $5, $6) RETURNING "id"  [["name", "Portal-e065948fbbee73d3b2c576b48c2b37e021115158edc6a92390d613640460e1d4"], ["slug", "portal-e065948fbbee73d3b2c576b48c2b37e021115158edc6a92390d613640460e1d4"], ["logo", nil], ["created_at", "2024-12-24 18:52:40.428383"], ["updated_at", "2024-12-24 18:52:40.428383"], ["visible", true]]
+[2024-12-24T13:52:40-05:00 THREAD READ YOUR OWN WRITES]   [PostgreSQLProxy Primary] TRANSACTION (0.7ms)  COMMIT
+[2024-12-24T13:52:40-05:00 THREAD READ YOUR OWN WRITES]   [PostgreSQLProxy Primary] Portal Count (0.6ms)  SELECT COUNT(*) FROM "portals"
+[2024-12-24T13:52:41-05:00 THREAD USE REPLICA]   [PostgreSQL Replica] Portal Count (4.4ms)  SELECT COUNT(*) FROM "portals"
+[2024-12-24T13:52:43-05:00 THREAD USE REPLICA]   [PostgreSQL Replica] Portal Count (3.3ms)  SELECT COUNT(*) FROM "portals"
+[2024-12-24T13:52:43-05:00 THREAD READ YOUR OWN WRITES]   [PostgreSQL Replica] Portal Count (2.8ms)  SELECT COUNT(*) FROM "portals"
+[2024-12-24T13:52:44-05:00 THREAD USE REPLICA]   [PostgreSQL Replica] Portal Count (18.0ms)  SELECT COUNT(*) FROM "portals"
+[2024-12-24T13:52:46-05:00 THREAD USE REPLICA]   [PostgreSQL Replica] Portal Count (0.9ms)  SELECT COUNT(*) FROM "portals"
+[2024-12-24T13:52:46-05:00 THREAD READ YOUR OWN WRITES]   [PostgreSQL Replica] Portal Count (2.3ms)  SELECT COUNT(*) FROM "portals"
+[2024-12-24T13:52:49-05:00 THREAD READ YOUR OWN WRITES]   [PostgreSQL Replica] Portal Count (7.2ms)  SELECT COUNT(*) FROM "portals"
+[2024-12-24T13:52:52-05:00 THREAD READ YOUR OWN WRITES]   [PostgreSQL Replica] Portal Count (3.7ms)  SELECT COUNT(*) FROM "portals"
+=> [#<Thread:0x00007fffdd6c9348 (irb):38 dead>, #<Thread:0x00007fffdd6c9230 (irb):43 dead>]
+```
+
+## Building your own proxy
+
+TODO: update instructions
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/db/postgresql_structure.sql

@@ -1,6 +1,7 @@
 SET statement_timeout = 0;
 SET lock_timeout = 0;
 SET idle_in_transaction_session_timeout = 0;
+SET transaction_timeout = 0;
 SET client_encoding = 'UTF8';
 SET standard_conforming_strings = on;
 SELECT pg_catalog.set_config('search_path', '', false);
@@ -9,16 +10,18 @@ SET xmloption = content;
 SET client_min_messages = warning;
 SET row_security = off;
 
---
--- Name: public; Type: SCHEMA; Schema: -; Owner: -
---
+SET default_tablespace = '';
 
--- *not* creating schema, since initdb creates it
+SET default_table_access_method = heap;
 
+--
+-- Name: schema_migrations; Type: TABLE; Schema: public; Owner: -
+--
 
-SET default_tablespace = '';
+CREATE TABLE public.schema_migrations (
+    version character varying(255) NOT NULL
+);
 
-SET default_table_access_method = heap;
 
 --
 -- Name: users; Type: TABLE; Schema: public; Owner: -
@@ -68,6 +71,13 @@ ALTER TABLE ONLY public.users
     ADD CONSTRAINT users_pkey PRIMARY KEY (id);
 
 
+--
+-- Name: unique_schema_migrations; Type: INDEX; Schema: public; Owner: -
+--
+
+CREATE UNIQUE INDEX unique_schema_migrations ON public.schema_migrations USING btree (version);
+
+
 --
 -- PostgreSQL database dump complete
 --

data/lib/active_record_proxy_adapters/primary_replica_proxy.rb

@@ -62,7 +62,7 @@ module ActiveRecordProxyAdapters
 
     attr_reader :primary_connection, :last_write_at, :active_record_context
 
-    delegate :connection_handler, :connected_to_stack, to: :connection_class
+    delegate :connection_handler, to: :connection_class
     delegate :reading_role, :writing_role, to: :active_record_context
 
     def replica_pool_unavailable?
@@ -70,9 +70,18 @@ module ActiveRecordProxyAdapters
     end
 
     def replica_pool
+      # use default handler if the connection pool for specific class is not found
+      specific_replica_pool || default_replica_pool
+    end
+
+    def specific_replica_pool
       connection_handler.retrieve_connection_pool(connection_class.name, role: reading_role)
     end
 
+    def default_replica_pool
+      connection_handler.retrieve_connection_pool(ActiveRecord::Base.name, role: reading_role)
+    end
+
     def connection_class
       active_record_context.connection_class_for(primary_connection)
     end
@@ -111,11 +120,25 @@ module ActiveRecordProxyAdapters
       [reading_role, writing_role].include?(role) ? role : nil
     end
 
+    def connected_to_stack
+      return connection_class.connected_to_stack if connection_class.respond_to?(:connected_to_stack)
+
+      # handle Rails 7.2+ pending migrations Connection
+      return [{ role: writing_role }] if pending_migration_connection?
+
+      []
+    end
+
+    def pending_migration_connection?
+      active_record_context.active_record_v7_1_or_greater? &&
+        connection_class.name == "ActiveRecord::PendingMigrationConnection"
+    end
+
     def connection_for(role, sql_string)
       connection = primary_connection if role == writing_role || replica_pool_unavailable?
       connection ||= checkout_replica_connection
 
-      result = yield(connection)
+      result = connected_to(role:) { yield connection }
 
       update_primary_latest_write_timestamp if !replica_connection?(connection) && write_statement?(sql_string)
 
@@ -124,6 +147,12 @@ module ActiveRecordProxyAdapters
       replica_connection?(connection) && replica_pool.checkin(connection)
     end
 
+    def connected_to(role:, &block)
+      return block.call unless connection_class.respond_to?(:connected_to)
+
+      connection_class.connected_to(role:, &block)
+    end
+
     def replica_connection?(connection)
       connection && connection != primary_connection
     end

data/lib/active_record_proxy_adapters/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordProxyAdapters
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

data/postgres_primary.dockerfile

@@ -1,4 +1,4 @@
-FROM docker.io/postgres:14-alpine
+FROM docker.io/postgres:17-alpine
 
 ARG REPLICA_USER=replicator
 ARG REPLICA_PASSWORD=replicator

data/postgres_replica.dockerfile

@@ -1,4 +1,4 @@
-FROM docker.io/postgres:14-alpine
+FROM docker.io/postgres:17-alpine
 
 ENV PRIMARY_DATABASE_HOST=localhost
 ENV PRIMARY_DATABASE_PORT=5432

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record_proxy_adapters
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Matt Cruz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-24 00:00:00.000000000 Z
+date: 2025-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord