pecorino 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0e0c8fa1a6bc734dc645b5b021264eda84bcadd1bec8da65c533a33cd243fb6
-  data.tar.gz: c6c053d8ed02f8e180786d4614c607087ca76b016b8acac35b35a3b3cb544391
+  metadata.gz: 392d3fe294cb751ad452716ef2b569f48f536a57464bdac39379042c29aa8242
+  data.tar.gz: 36309ce687caa5e2d32bf5e5cc7c862e264a7065cf5f211062e9ae7f51118ced
 SHA512:
-  metadata.gz: 02207b3f3d52aa635a960c3914768237a25da4b4cdd7a5ad5da222adf44e738ac987f5182392d0617c60848c745fb0cc5225e2e2392dff50b6e83f58b703d191
-  data.tar.gz: 350d04b9e366d229d87146465574632a00e5e0c88eda7cbc540b494d8ab1d3520d87092f5ae6a6b11f0dd323cc7fd15436728c9b6210fe2264be384b0e9505b4
+  metadata.gz: 14b6cadec3609d946d786330e5c912e2ae57054ba6f740d4a0dd4b82bc4660417df2bd71e8ac97fa44990b47f20f60540d82a2299c5a176da4b8c191752f46ba
+  data.tar.gz: 5059d7a546df2a1a6822a70ed73290165f7506ba6f36f41daf3779cad158781768c004aa5bd063f24452c15dcb6d5889efd16362b3e79ef51e2f88bbcaffc3e8

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.7.4
+
+- Ensure deprecated ActiveRecord::Base.connection is replaced with ActiveRecord::Base.connection_pool.with_connection. This prevents permanent connection checkout
+
 ## 0.7.3
 
 - Fix a number of YARD issues and generate both .rbi and .rbs typedefs

data/README.md

@@ -189,8 +189,10 @@ The Pecorino buckets and blocks are stateful. If you are not running tests with
 ```ruby
 setup do
   # Delete all transient records
-  ActiveRecord::Base.connection.execute("TRUNCATE TABLE pecorino_blocks")
-  ActiveRecord::Base.connection.execute("TRUNCATE TABLE pecorino_leaky_buckets")
+  ActiveRecord::Base.connection_pool.with_connection do |connection|
+    connection.execute("TRUNCATE TABLE pecorino_blocks")
+    connection.execute("TRUNCATE TABLE pecorino_leaky_buckets")
+  end
 end
 ```
 
@@ -224,8 +226,10 @@ cached_throttle.request!
 Throttles and leaky buckets are transient resources. If you are using Postgres replication, it might be prudent to set the Pecorino tables to `UNLOGGED` which will exclude them from replication - and save you bandwidth and storage on your RR. To do so, add the following statements to your migration:
 
 ```ruby
-ActiveRecord::Base.connection.execute("ALTER TABLE pecorino_leaky_buckets SET UNLOGGED")
-ActiveRecord::Base.connection.execute("ALTER TABLE pecorino_blocks SET UNLOGGED")
+ActiveRecord::Base.connection_pool.with_connection do |connection|
+  connection.execute("ALTER TABLE pecorino_leaky_buckets SET UNLOGGED")
+  connection.execute("ALTER TABLE pecorino_blocks SET UNLOGGED")
+end
 ```
 
 ## Development

data/lib/pecorino/adapters/postgres_adapter.rb

@@ -30,7 +30,7 @@ class Pecorino::Adapters::PostgresAdapter
 
     # If the return value of the query is a NULL it means no such bucket exists,
     # so we assume the bucket is empty
-    current_level = @model_class.connection.uncached { @model_class.connection.select_value(sql) } || 0.0
+    current_level = @model_class.connection_pool.with_connection { |connection| connection.uncached { connection.select_value(sql) } } || 0.0
     [current_level, capacity - current_level.abs < 0.01]
   end
 
@@ -83,7 +83,7 @@ class Pecorino::Adapters::PostgresAdapter
     # query as a repeat (since we use "select_one" for the RETURNING bit) and will not call into Postgres
     # correctly, thus the clock_timestamp() value would be frozen between calls. We don't want that here.
     # See https://stackoverflow.com/questions/73184531/why-would-postgres-clock-timestamp-freeze-inside-a-rails-unit-test
-    upserted = @model_class.connection.uncached { @model_class.connection.select_one(sql) }
+    upserted = @model_class.connection_pool.with_connection { |connection| connection.uncached { connection.select_one(sql) } }
     capped_level_after_fillup, at_capacity = upserted.fetch("level"), upserted.fetch("at_capacity")
     [capped_level_after_fillup, at_capacity]
   end
@@ -141,7 +141,7 @@ class Pecorino::Adapters::PostgresAdapter
         level AS level_after
     SQL
 
-    upserted = @model_class.connection.uncached { @model_class.connection.select_one(sql) }
+    upserted = @model_class.connection_pool.with_connection { |connection| connection.uncached { connection.select_one(sql) } }
     level_after = upserted.fetch("level_after")
     level_before = upserted.fetch("level_before")
     [level_after, level_after >= capacity, level_after != level_before]
@@ -159,19 +159,21 @@ class Pecorino::Adapters::PostgresAdapter
         blocked_until = GREATEST(EXCLUDED.blocked_until, t.blocked_until)
       RETURNING blocked_until
     SQL
-    @model_class.connection.uncached { @model_class.connection.select_value(block_set_query) }
+    @model_class.connection_pool.with_connection { |connection| connection.uncached { connection.select_value(block_set_query) } }
   end
 
   def blocked_until(key:)
     block_check_query = @model_class.sanitize_sql_array([<<~SQL, key])
       SELECT blocked_until FROM pecorino_blocks WHERE key = ? AND blocked_until >= clock_timestamp() LIMIT 1
     SQL
-    @model_class.connection.uncached { @model_class.connection.select_value(block_check_query) }
+    @model_class.connection_pool.with_connection { |connection| connection.uncached { connection.select_value(block_check_query) } }
   end
 
   def prune
-    @model_class.connection.execute("DELETE FROM pecorino_blocks WHERE blocked_until < NOW()")
-    @model_class.connection.execute("DELETE FROM pecorino_leaky_buckets WHERE may_be_deleted_after < NOW()")
+    @model_class.connection_pool.with_connection do |connection|
+      connection.execute("DELETE FROM pecorino_blocks WHERE blocked_until < NOW()")
+      connection.execute("DELETE FROM pecorino_leaky_buckets WHERE may_be_deleted_after < NOW()")
+    end
   end
 
   def create_tables(active_record_schema)

data/lib/pecorino/adapters/sqlite_adapter.rb

@@ -37,7 +37,7 @@ class Pecorino::Adapters::SqliteAdapter
 
     # If the return value of the query is a NULL it means no such bucket exists,
     # so we assume the bucket is empty
-    current_level = @model_class.connection.uncached { @model_class.connection.select_value(sql) } || 0.0
+    current_level = @model_class.connection_pool.with_connection { |connection| connection.uncached { connection.select_value(sql) } } || 0.0
     [current_level, capacity - current_level.abs < 0.01]
   end
 
@@ -91,7 +91,7 @@ class Pecorino::Adapters::SqliteAdapter
     # query as a repeat (since we use "select_one" for the RETURNING bit) and will not call into Postgres
     # correctly, thus the clock_timestamp() value would be frozen between calls. We don't want that here.
     # See https://stackoverflow.com/questions/73184531/why-would-postgres-clock-timestamp-freeze-inside-a-rails-unit-test
-    upserted = @model_class.connection.uncached { @model_class.connection.select_one(sql) }
+    upserted = @model_class.connection_pool.with_connection { |connection| connection.uncached { connection.select_one(sql) } }
     capped_level_after_fillup, one_if_did_overflow = upserted.fetch("level"), upserted.fetch("did_overflow")
     [capped_level_after_fillup, one_if_did_overflow == 1]
   end
@@ -130,7 +130,7 @@ class Pecorino::Adapters::SqliteAdapter
       -- so that it can't be deleted between our INSERT and our UPDATE
         may_be_deleted_after = EXCLUDED.may_be_deleted_after
     SQL
-    @model_class.connection.execute(insert_sql)
+    @model_class.connection_pool.with_connection { |connection| connection.execute(insert_sql) }
 
     sql = @model_class.sanitize_sql_array([<<~SQL, query_params])
       -- With SQLite MATERIALIZED has to be used so that level_post is calculated before the UPDATE takes effect
@@ -156,7 +156,7 @@ class Pecorino::Adapters::SqliteAdapter
         level AS level_after
     SQL
 
-    upserted = @model_class.connection.uncached { @model_class.connection.select_one(sql) }
+    upserted = @model_class.connection_pool.with_connection { |connection| connection.uncached { connection.select_one(sql) } }
     level_after = upserted.fetch("level_after")
     level_before = upserted.fetch("level_before")
     [level_after, level_after >= capacity, level_after != level_before]
@@ -174,7 +174,7 @@ class Pecorino::Adapters::SqliteAdapter
         blocked_until = MAX(EXCLUDED.blocked_until, t.blocked_until)
       RETURNING blocked_until;
     SQL
-    blocked_until_s = @model_class.connection.uncached { @model_class.connection.select_value(block_set_query) }
+    blocked_until_s = @model_class.connection_pool.with_connection { |connection| connection.uncached { connection.select_value(block_set_query) } }
     Time.at(blocked_until_s)
   end
 
@@ -188,14 +188,16 @@ class Pecorino::Adapters::SqliteAdapter
       WHERE
         key = :key AND blocked_until >= :now_s LIMIT 1
     SQL
-    blocked_until_s = @model_class.connection.uncached { @model_class.connection.select_value(block_check_query) }
+    blocked_until_s = @model_class.connection_pool.with_connection { |connection| connection.uncached { connection.select_value(block_check_query) } }
     blocked_until_s && Time.at(blocked_until_s)
   end
 
   def prune
     now_s = Time.now.to_f
-    @model_class.connection.execute("DELETE FROM pecorino_blocks WHERE blocked_until < ?", now_s)
-    @model_class.connection.execute("DELETE FROM pecorino_leaky_buckets WHERE may_be_deleted_after < ?", now_s)
+    @model_class.connection_pool.with_connection do |connection|
+      connection.execute("DELETE FROM pecorino_blocks WHERE blocked_until < ?", now_s)
+      connection.execute("DELETE FROM pecorino_leaky_buckets WHERE may_be_deleted_after < ?", now_s)
+    end
   end
 
   def create_tables(active_record_schema)

data/lib/pecorino/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pecorino
-  VERSION = "0.7.3"
+  VERSION = "0.7.4"
 end

data/lib/pecorino.rb

@@ -65,7 +65,7 @@ module Pecorino
   # @return [Pecorino::Adapters::BaseAdapter]
   def self.default_adapter_from_main_database
     model_class = ActiveRecord::Base
-    adapter_name = model_class.connection.adapter_name
+    adapter_name = model_class.connection_pool.with_connection(&:adapter_name)
     case adapter_name
     when /postgres/i
       Pecorino::Adapters::PostgresAdapter.new(model_class)

data/test/adapters/postgres_adapter_test.rb

@@ -23,7 +23,7 @@ class PostgresAdapterTest < ActiveSupport::TestCase
 
   def create_postgres_database_if_none
     self.class.establish_connection(encoding: "unicode", database: SEED_DB_NAME.call)
-    ActiveRecord::Base.connection.execute("SELECT 1 FROM pecorino_leaky_buckets")
+    ActiveRecord::Base.connection_pool.with_connection { |connection| connection.execute("SELECT 1 FROM pecorino_leaky_buckets") }
   rescue ActiveRecord::NoDatabaseError, ActiveRecord::ConnectionNotEstablished
     create_postgres_database
     retry
@@ -38,20 +38,24 @@ class PostgresAdapterTest < ActiveSupport::TestCase
   def create_postgres_database
     ActiveRecord::Migration.verbose = false
     self.class.establish_connection(database: "postgres")
-    ActiveRecord::Base.connection.create_database(SEED_DB_NAME.call, charset: :unicode)
+    ActiveRecord::Base.connection_pool.with_connection { |connection| connection.create_database(SEED_DB_NAME.call, charset: :unicode) }
     ActiveRecord::Base.connection.close
     self.class.establish_connection(encoding: "unicode", database: SEED_DB_NAME.call)
   end
 
   def truncate_test_tables
-    ActiveRecord::Base.connection.execute("TRUNCATE TABLE pecorino_leaky_buckets")
-    ActiveRecord::Base.connection.execute("TRUNCATE TABLE pecorino_blocks")
+    ActiveRecord::Base.connection_pool.with_connection do |connection|
+      connection.execute("TRUNCATE TABLE pecorino_leaky_buckets")
+      connection.execute("TRUNCATE TABLE pecorino_blocks")
+    end
   end
 
   def test_create_tables
     ActiveRecord::Base.transaction do
-      ActiveRecord::Base.connection.execute("DROP TABLE pecorino_leaky_buckets")
-      ActiveRecord::Base.connection.execute("DROP TABLE pecorino_blocks")
+      ActiveRecord::Base.connection_pool.with_connection do |connection|
+        connection.execute("DROP TABLE pecorino_leaky_buckets")
+        connection.execute("DROP TABLE pecorino_blocks")
+      end
       # The adapter has to be in a variable as the schema definition is scoped to the migrator, not self
       retained_adapter = create_adapter # the schema define block is run via instance_exec so it does not retain scope
       ActiveRecord::Schema.define(version: 1) do |via_definer|
@@ -64,6 +68,6 @@ class PostgresAdapterTest < ActiveSupport::TestCase
   Minitest.after_run do
     ActiveRecord::Base.connection.close
     establish_connection(database: "postgres")
-    ActiveRecord::Base.connection.drop_database(SEED_DB_NAME.call)
+    ActiveRecord::Base.connection_pool.with_connection { |connection| connection.drop_database(SEED_DB_NAME.call) }
   end
 end

data/test/adapters/sqlite_adapter_test.rb

@@ -33,8 +33,10 @@ class SqliteAdapterTest < ActiveSupport::TestCase
 
   def test_create_tables
     ActiveRecord::Base.transaction do
-      ActiveRecord::Base.connection.execute("DROP TABLE pecorino_leaky_buckets")
-      ActiveRecord::Base.connection.execute("DROP TABLE pecorino_blocks")
+      ActiveRecord::Base.connection_pool.with_connection do |connection|
+        connection.execute("DROP TABLE pecorino_leaky_buckets")
+        connection.execute("DROP TABLE pecorino_blocks")
+      end
       # The adapter has to be in a variable as the schema definition is scoped to the migrator, not self
       retained_adapter = create_adapter # the schema define block is run via instance_exec so it does not retain scope
       ActiveRecord::Schema.define(version: 1) do |via_definer|

data/test/block_test.rb

@@ -4,20 +4,24 @@ require "test_helper"
 require "base64"
 
 class BlockTest < ActiveSupport::TestCase
+  def setup
+    @adapter = Pecorino::Adapters::MemoryAdapter.new
+  end
+
   test "sets a block" do
     k = Base64.strict_encode64(Random.bytes(4))
-    assert_nil Pecorino::Block.blocked_until(key: k)
-    assert Pecorino::Block.set!(key: k, block_for: 30.minutes)
+    assert_nil Pecorino::Block.blocked_until(key: k, adapter: @adapter)
+    assert Pecorino::Block.set!(key: k, block_for: 30.minutes, adapter: @adapter)
 
-    blocked_until = Pecorino::Block.blocked_until(key: k)
+    blocked_until = Pecorino::Block.blocked_until(key: k, adapter: @adapter)
     assert_in_delta Time.now + 30.minutes, blocked_until, 10
   end
 
   test "does not return a block which has lapsed" do
     k = Base64.strict_encode64(Random.bytes(4))
-    assert_nil Pecorino::Block.blocked_until(key: k)
-    Pecorino::Block.set!(key: k, block_for: -30.minutes)
-    blocked_until = Pecorino::Block.blocked_until(key: k)
+    assert_nil Pecorino::Block.blocked_until(key: k, adapter: @adapter)
+    Pecorino::Block.set!(key: k, block_for: -30.minutes, adapter: @adapter)
+    blocked_until = Pecorino::Block.blocked_until(key: k, adapter: @adapter)
     assert_nil blocked_until
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pecorino
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Julik Tarkhanov
 bindir: exe
 cert_chain: []
-date: 2025-04-01 00:00:00.000000000 Z
+date: 2025-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord