wal 0.0.33 → 0.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79eda85dc0f833f81fc5c4778b7f8333559308f46111758e09977ec3dc98461c
-  data.tar.gz: 470232c05cf0dc4ee5d55448ce6b88aa57373c53f504dda3526482a3473d3dbc
+  metadata.gz: f7a8f82addc9ffce03d2f1ee6a77bac1f3ae2074a5b427a8c60ca087df2aded6
+  data.tar.gz: 75559dccba1edf1d0f1a60ebf866726705fe48166d697a1859ec6da644e963f3
 SHA512:
-  metadata.gz: e30d85d2e335ab143daa5de2962912009a340ba279ab47e4f531e6577ada0eb2cca22148f10601d75fc992bbb35cf8b081ebc02b698189d1ab4f841029367254
-  data.tar.gz: 262104fb88bd6cb51ad181f9d8bea74e25d9f9798a5f04969ec33c29d71ccd9c9fb4cd22ba2b089075c5a4458d028597c5cfabe24a5086578bd297b67598be76
+  metadata.gz: 0d0d206e647386006b07e1a89e1a5596346a50894d0260d5def25876902abcbd398c07889a03ac43c88041343e576b2793eec8a1eecdcf47ff1f025587721a38
+  data.tar.gz: 62b2dbbeadf2c8076f2dee4ad1a95491552dfb0be3af646b03ffa449dd54009cfd940020fe4dfe3b69c2c5e7a707bdafdc2959baebe109ba28d288b31a086031

data/lib/wal/logging_watcher.rb

@@ -20,17 +20,18 @@ module Wal
     def on_event(event)
       case event
       when Wal::BeginTransactionEvent
-        @start = Time.now
+        @start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         @count = 0
-        if event.estimated_size > 0
-          Wal.logger&.debug("[#{@slot}] Begin transaction=#{event.transaction_id} size=#{event.estimated_size}")
-        end
+        Wal.logger&.debug("[#{@slot}] Begin transaction=#{event.transaction_id} size=#{event.estimated_size}")
       when Wal::CommitTransactionEvent
-        if @count > 0
-          elapsed = ((Time.now - @start) * 1000.0).round(1)
-          actions = " actions=#{@actions.sort.join(",")}" unless @actions.empty?
-          tables = " tables=#{@tables.sort.join(",")}" unless @tables.empty?
-          Wal.logger&.info("[#{@slot}] Commit transaction=#{event.transaction_id} elapsed=#{elapsed} events=#{@count}#{actions}#{tables}")
+        elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start) * 1000).round(3)
+        message = "[#{@slot}] Commit transaction=#{event.transaction_id} elapsed=#{elapsed} events=#{@count}"
+        message << " actions=#{@actions.sort.join(",")}" unless @actions.empty?
+        message << " tables=#{@tables.sort.join(",")}" unless @tables.empty?
+        if @count > 1
+          Wal.logger&.info(message)
+        else
+          Wal.logger&.debug(message)
         end
         @actions.clear
         @tables.clear
@@ -40,7 +41,11 @@ module Wal
         @actions << :insert
         @tables << event.table
       when Wal::UpdateEvent
-        Wal.logger&.debug("[#{@slot}] Update transaction=#{event.transaction_id} table=#{event.table} primary_key=#{event.primary_key}")
+        if Wal.logger&.level >= Logger::DEBUG
+          message = "[#{@slot}] Update transaction=#{event.transaction_id} table=#{event.table} primary_key=#{event.primary_key}"
+          message << " changed=#{event.diff.keys.join(",")}" if event.diff && !event.diff.empty?
+          Wal.logger&.debug(message)
+        end
         @count += 1
         @actions << :update
         @tables << event.table

data/lib/wal/runner.rb

@@ -32,30 +32,38 @@ module Wal
         Thread.new(slot, watcher, temporary, publications) do |replication_slot, watcher, use_temporary_slot, publications|
           retries = 0
           replication_slot = "#{replication_slot}_#{SecureRandom.alphanumeric(4)}" if use_temporary_slot
-          puts "Watcher started for #{replication_slot} slot (#{publications.join(", ")})"
+          puts "[#{replication_slot}] Watcher started for #{replication_slot} slot (#{publications.join(", ")})"
 
           begin
+            Wal.hooks[:on_slot_start]&.call(slot, config)
+
             replicator_class
               .new(db_config:, **replicator_params, replication_slot:, use_temporary_slot:)
               .replicate_forever(Wal::LoggingWatcher.new(replication_slot, watcher), publications:)
+
+            Wal.hooks[:on_slot_finish]&.call(slot, config)
+
             if auto_restart
               backoff_time = backoff_exponent ? (backoff * retries) ** backoff_exponent : backoff
-              puts "Watcher finished for #{replication_slot}, auto restarting in #{backoff_time.floor(2)}..."
+              puts "[#{replication_slot}] Watcher finished for #{replication_slot}, auto restarting in #{backoff_time.floor(2)}..."
               sleep backoff_time
-              puts "Restarting #{replication_slot}"
+              puts "[#{replication_slot}] Restarting"
               redo
             end
           rescue ArgumentError
             raise
           rescue StandardError => err
+            Wal.hooks[:on_slot_error]&.call(err, slot, config)
+
+            Wal.logger&.error("[#{replication_slot}] Error #{err}")
+            Wal.logger&.error([err.message, *err.backtrace].join("\n"))
+
             if retries < max_retries
-              Wal.logger&.error("[#{replication_slot}] Error #{err}")
-              Wal.logger&.error([err.message, *err.backtrace].join("\n"))
               retries += 1
               backoff_time = backoff_exponent ? (backoff * retries) ** backoff_exponent : backoff
-              puts "Restarting #{replication_slot} in #{backoff_time.floor(2)}s..."
+              puts "#{replication_slot}] Restarting #{replication_slot} in #{backoff_time.floor(2)}s..."
               sleep backoff_time
-              puts "Restarting #{replication_slot}"
+              puts "#{replication_slot}] Restarting #{replication_slot}"
               retry
             end
             raise
@@ -105,12 +113,12 @@ module Wal
     end
 
     def run_forked_workers(workers_slots)
-      Wal.fork_hooks[:before_fork]&.call
+      Wal.hooks[:before_fork]&.call(workers_slots)
 
       workers_slots.each do |worker_name, slot_configs|
         pid = fork_worker(worker_name, slot_configs)
         @child_pids << pid
-        puts "Spawned worker '#{worker_name}' with PID #{pid}"
+        puts "[#{worker_name}] Spawned worker '#{worker_name}' with PID #{pid}"
       end
 
       @ping_thread = start_ping_thread
@@ -122,7 +130,7 @@ module Wal
 
     def fork_worker(worker_name, slot_configs)
       Process.fork do
-        Wal.fork_hooks[:after_fork]&.call
+        Wal.hooks[:after_fork]&.call(worker_name, slot_configs)
         puts "[#{worker_name}] Starting worker process (PID: #{Process.pid})"
         worker = Worker.new(name: worker_name, slot_configs: slot_configs, db_config: db_config)
         worker.run

data/lib/wal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wal
-  VERSION = "0.0.33"
+  VERSION = "0.0.34"
 end

data/lib/wal.rb

@@ -16,22 +16,30 @@ require_relative "wal/version"
 module Wal
   class << self
     attr_accessor :logger
-    attr_accessor :fork_hooks
+    attr_accessor :hooks
 
     def logger
       @logger ||= Logger.new($stdout, level: :info)
     end
 
-    def fork_hooks
-      @fork_hooks ||= {}
+    def hooks
+      @hooks ||= {}
+    end
+
+    def on_slot_finished(&block)
+      hooks[:on_slot_finished] = block
+    end
+
+    def on_slot_error(&block)
+      hooks[:on_slot_error] = block
     end
 
     def before_fork(&block)
-      fork_hooks[:before_fork] = block
+      hooks[:before_fork] = block
     end
 
     def after_fork(&block)
-      fork_hooks[:after_fork] = block
+      hooks[:after_fork] = block
     end
   end
 

data/rbi/wal.rbi

@@ -7,17 +7,26 @@ module Wal
       UpdateEvent,
       DeleteEvent,
     ) }
-  VERSION = "0.0.33"
+  VERSION = "0.0.34"
 
   class << self
     sig { returns(T.class_of(Logger)) }
     attr_accessor :logger
 
-    sig { params(block: T.proc.void).void }
+    sig { params(block: T.proc.params(worker_name: T.untyped).void).void }
     def before_fork(&block); end
 
-    sig { params(block: T.proc.void).void }
+    sig { params(block: T.proc.params(worker_name: String, slot_configs: T.untyped).void).void }
     def after_fork(&block); end
+
+    sig { params(block: T.proc.params(slot: String, config: T.untyped).void).void }
+    def on_slot_start(&block); end
+
+    sig { params(block: T.proc.params(error: StandardError, slot: String, config: T.untyped).void).void }
+    def on_slot_error(&block); end
+
+    sig { params(block: T.proc.params(slot: String, config: T.untyped).void).void }
+    def on_slot_finish(&block); end
   end
 
   sig { params(block: T.proc.params(config: T.class_of(Wal)).void).void }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: wal
 version: !ruby/object:Gem::Version
-  version: 0.0.33
+  version: 0.0.34
 platform: ruby
 authors:
 - Rodrigo Navarro
 bindir: exe
 cert_chain: []
-date: 2026-02-09 00:00:00.000000000 Z
+date: 2026-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg