pgtk 0.24.4 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5eb38e8d785a444233248ed07fe7ba2316b947b1b3a779f7738145cff4d56306
-  data.tar.gz: 8870ff5a0a87c911439618b6d26c9e42a9bb37edcf14182b4067d208774794a9
+  metadata.gz: 5b7cf162ce55193a057e281c59e4ade55ba6dccee8e2076e7ebf6cc5ebd8b3d6
+  data.tar.gz: f84661c917982464a21be179bccd34e7ae0b8d3f234562dcf026e3f5aebe4793
 SHA512:
-  metadata.gz: 15991d0bd081e1b4a35da843c346e2da28196f0fa682a5088de811f37cb027bb57134fc92444ffdd3c6aa29587ff974085d6cb02cf3852a6e23419efd9a8fb94
-  data.tar.gz: 5fcb874e760ad74bca1c04aa2291c444139dbb441b84ac60dfc5352ae81c1174db7d3e8884aed413919cdb0d5863bf6c0120642f44250481380a5b065319bd0d
+  metadata.gz: 855c4d94c5ff429abe22d4593076f459df95f9cf3612157c149e929243f79e2d49bf9d56183d2c0da074e8abb30e73bff12722dbd1e57e04c3385abd8ca9314c
+  data.tar.gz: 7d9f3cfc61dfda380a6bdb63f3451ba8f09cf798796a8786fe6a0ce251e25174faf1cf21d1e4619cfed6bea95041a1072f9c62c9a60e3c825a229795d115cd6b

data/README.md

@@ -228,6 +228,9 @@ stash = Pgtk::Stash.new(
   cap: 10_000,          # Maximum cached query results (default: 10,000)
   cap_interval: 60,     # Seconds between cache size enforcement (default: 60)
   refill_interval: 16,  # Seconds between stale query refilling (default: 16)
+  refill_delay: 0.5,    # Seconds to wait before refilling the cache (default: 0)
+  retire: 60,           # Maximum age in seconds to keep a query in cache (default: 15 min)
+  retire_interval: 5.5, # How often to retire (default: 60)
   threads: 4,           # Worker threads for background refilling (default: 4)
   max_queue_length: 128 # Maximum refilling tasks in queue (default: 128)
 )

data/lib/pgtk/stash.rb

@@ -41,54 +41,54 @@ class Pgtk::Stash
 
   # Initialize a new Stash with query caching.
   #
+  # Set any of the intervals to nil to disable the cron.
+  #
   # @param [Object] pool The underlying connection pool that executes actual database queries
   # @param [Hash] stash Internal cache structure containing queries and tables hashes for sharing state
   #   across transactions
-  # @param [Integer] refill_interval Interval in seconds between background tasks that recalculate stale
+  # @param [Float] refill_interval Interval in seconds between background tasks that recalculate stale
   #   cached queries
+  # @param [Float] refill_delay A pause in seconds we take before making a refill
   # @param [Integer] max_queue_length Maximum number of refilling tasks allowed in the thread pool queue
   #   before new tasks are skipped
   # @param [Integer] threads Number of worker threads in the background thread pool for cache refilling
   #   operations
   # @param [Integer] cap Maximum number of cached query results to retain; oldest queries are evicted when
   #   this limit is exceeded
-  # @param [Integer] cap_interval Interval in seconds between background tasks that enforce the cache size
+  # @param [Float] cap_interval Interval in seconds between background tasks that enforce the cache size
   #   cap by removing old queries
   # @param [Integer] retire Maximum age in seconds to keep a query in cache after its latest usage
-  # @param [Integer] retire_interval Interval in seconds between background tasks that remove
+  # @param [Float] retire_interval Interval in seconds between background tasks that remove
   #   retired queries
   # @param [Loog] loog Logger instance for debugging and monitoring cache operations (default: null logger)
   # @param [Concurrent::ReentrantReadWriteLock] entrance Read-write lock for thread-safe cache access
   #   shared across instances
-  # @param [Concurrent::AtomicBoolean] launched Atomic boolean flag tracking whether background tasks have
-  #   been started to prevent multiple launches
   def initialize(
     pool,
     stash: { queries: {}, tables: {} },
+    loog: Loog::NULL,
+    entrance: Concurrent::ReentrantReadWriteLock.new,
     refill_interval: 16,
+    refill_delay: 0,
     max_queue_length: 128,
     threads: 4,
     cap: 10_000,
     cap_interval: 60,
     retire: 15 * 60,
-    retire_interval: 60,
-    loog: Loog::NULL,
-    entrance: Concurrent::ReentrantReadWriteLock.new,
-    launched: Concurrent::AtomicBoolean.new(false)
+    retire_interval: 60
   )
     @pool = pool
     @stash = stash
-    @launched = launched
+    @loog = loog
     @entrance = entrance
     @refill_interval = refill_interval
+    @refill_delay = refill_delay
     @max_queue_length = max_queue_length
     @threads = threads
     @cap = cap
     @cap_interval = cap_interval
     @retire = retire
     @retire_interval = retire_interval
-    @loog = loog
-    @tpool = Concurrent::FixedThreadPool.new(@threads)
   end
 
   # Start the connection pool and launch background cache management tasks.
@@ -99,8 +99,8 @@ class Pgtk::Stash
   #
   # @return [void]
   def start!
-    launch!
     @pool.start!
+    launch!
   end
 
   # Get the PostgreSQL server version.
@@ -132,19 +132,41 @@ class Pgtk::Stash
       [
         'Pgtk::Stash (',
         [
-          "refill_interval=#{@refill_interval}s",
-          "max_queue_length=#{@max_queue_length}",
           "threads=#{@threads}",
-          "cap=#{@cap}",
-          "cap_interval=#{@cap_interval}s",
-          "retire=#{@retire}",
-          "retire_interval=#{@retire_interval}s"
-        ].join(', '),
+          "max_queue_length=#{@max_queue_length}",
+          if @refill_interval
+            [
+              "refill_interval=#{@refill_interval}s",
+              "refill_delay=#{@refill_delay}s"
+            ]
+          else
+            'no refilling'
+          end,
+          if @cap_interval
+            [
+              "cap_interval=#{@cap_interval}s",
+              "cap=#{@cap}"
+            ]
+          else
+            'no capping'
+          end,
+          if @retire_interval
+            [
+              "retire_interval=#{@retire_interval}s",
+              "retire=#{@retire}"
+            ]
+          else
+            'no retirement'
+          end
+        ].flatten.join(', '),
         '):'
       ].join,
-      "  #{'not ' if @launched.false?}launched",
+      if @tpool
+        "  #{@tpool.queue_length} tasks in the thread pool"
+      else
+        '  Not launched yet'
+      end,
       "  #{stash_size} queries cached (#{stash_size > @cap ? 'above' : 'below'} the cap)",
-      "  #{@tpool.queue_length} tasks in the thread pool",
       "  #{@stash[:tables].count} tables in cache",
       "  #{qq.sum { |a| a[:s] }} stale queries in cache:",
       qq.select { |a| a[:s].positive? }.sort_by { -_1[:p] }.take(8).map do |a|
@@ -177,7 +199,7 @@ class Pgtk::Stash
         tables.each do |t|
           @stash[:tables][t]&.each do |q|
             @stash[:queries][q]&.each_key do |key|
-              @stash[:queries][q][key][:stale] = true
+              @stash[:queries][q][key][:stale] = Time.now
             end
           end
         end
@@ -222,12 +244,8 @@ class Pgtk::Stash
       yield Pgtk::Stash.new(
         t,
         stash: @stash,
-        refill_interval: @refill_interval,
-        max_queue_length: @max_queue_length,
-        threads: @threads,
         loog: @loog,
-        entrance: @entrance,
-        launched: @launched
+        entrance: @entrance
       )
     end
   end
@@ -252,28 +270,33 @@ class Pgtk::Stash
   # @return [nil]
   # @raise [RuntimeError] if background tasks have already been launched on this cache instance
   def launch!
-    raise 'Cannot launch multiple times on same cache data' unless @launched.make_true
-    Concurrent::TimerTask.execute(execution_interval: @cap_interval, executor: @tpool) do
-      loop do
-        break if stash_size <= @cap
-        @entrance.with_write_lock do
-          @stash[:queries].each_key do |q|
-            m = @stash[:queries][q].values.map { |h| h[:used] }.min
-            next unless m
-            @stash[:queries][q].delete_if { |_, h| h[:used] == m }
-            @stash[:queries].delete_if { |_, kk| kk.empty? }
+    @tpool = Concurrent::FixedThreadPool.new(@threads)
+    if @cap_interval
+      Concurrent::TimerTask.execute(execution_interval: @cap_interval, executor: @tpool) do
+        loop do
+          break if stash_size <= @cap
+          @entrance.with_write_lock do
+            @stash[:queries].each_key do |q|
+              m = @stash[:queries][q].values.map { |h| h[:used] }.min
+              next unless m
+              @stash[:queries][q].delete_if { |_, h| h[:used] == m }
+              @stash[:queries].delete_if { |_, kk| kk.empty? }
+            end
           end
         end
       end
     end
-    Concurrent::TimerTask.execute(execution_interval: @retire_interval, executor: @tpool) do
-      @entrance.with_write_lock do
-        @stash[:queries].each_key do |q|
-          @stash[:queries][q].delete_if { |_, h| h[:used] < Time.now - @retire }
-          @stash[:queries].delete_if { |_, kk| kk.empty? }
+    if @retire_interval
+      Concurrent::TimerTask.execute(execution_interval: @retire_interval, executor: @tpool) do
+        @entrance.with_write_lock do
+          @stash[:queries].each_key do |q|
+            @stash[:queries][q].delete_if { |_, h| h[:used] < Time.now - @retire }
+            @stash[:queries].delete_if { |_, kk| kk.empty? }
+          end
         end
       end
     end
+    return unless @refill_interval
     Concurrent::TimerTask.execute(execution_interval: @refill_interval, executor: @tpool) do
       @stash[:queries]
         .map { |k, v| [k, v.values.sum { |vv| vv[:popularity] }, v.values.any? { |vv| vv[:stale] }] }
@@ -283,19 +306,19 @@ class Pgtk::Stash
         q = a[0]
         @stash[:queries][q].each_key do |k|
           next unless @stash[:queries][q][k][:stale]
+          next if @stash[:queries][q][k][:stale] > Time.now - @refill_delay
           next if @tpool.queue_length >= @max_queue_length
           @tpool.post do
             h = @stash[:queries][q][k]
             ret = @pool.exec(q, h[:params], h[:result])
             @entrance.with_write_lock do
               h = @stash[:queries][q][k]
-              h[:stale] = false
+              h.delete(:stale)
               h[:ret] = ret
             end
           end
         end
       end
     end
-    nil
   end
 end

data/lib/pgtk/version.rb

@@ -11,5 +11,5 @@ require_relative '../pgtk'
 # License:: MIT
 module Pgtk
   # Current version of the library.
-  VERSION = '0.24.4'
+  VERSION = '0.26.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgtk
 version: !ruby/object:Gem::Version
-  version: 0.24.4
+  version: 0.26.0
 platform: ruby
 authors:
 - Yegor Bugayenko