wal 0.0.34 → 0.0.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7a8f82addc9ffce03d2f1ee6a77bac1f3ae2074a5b427a8c60ca087df2aded6
-  data.tar.gz: 75559dccba1edf1d0f1a60ebf866726705fe48166d697a1859ec6da644e963f3
+  metadata.gz: 87f882233ec5ff20290d81d462f21298948f55769af90df9c402a7ba5cc7c97d
+  data.tar.gz: 575345ed49b77a79ed63ae7a2adcfcd21f1662dda4349bebd66863456b642899
 SHA512:
-  metadata.gz: 0d0d206e647386006b07e1a89e1a5596346a50894d0260d5def25876902abcbd398c07889a03ac43c88041343e576b2793eec8a1eecdcf47ff1f025587721a38
-  data.tar.gz: 62b2dbbeadf2c8076f2dee4ad1a95491552dfb0be3af646b03ffa449dd54009cfd940020fe4dfe3b69c2c5e7a707bdafdc2959baebe109ba28d288b31a086031
+  metadata.gz: 9b9c6e581d9594eb14a8747c67a5d7cf2dfaae90693524f1bc6e32abeedce15bce53cb15911c5ffb06a84399d7d9d9fb3a3c01039a2367aa16b759dd6ffe596e
+  data.tar.gz: bef2b751b85119037d4a0eb46aca01841b6dc45c168da4ff74e7bb4b2b39bba682301cf41e4856e9ee845a25909da8709c943dd037d74e29c967e1e97c9dff18

data/flake.lock

@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1792506237,
+        "narHash": "sha256-Q/8KLB6jNfpaUN1HAedE/u/Et9feE/zYSsutBLKrCFk=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "5adc50831c259f87faeb09ddf930d43597197473",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

data/flake.nix

@@ -0,0 +1,25 @@
+{
+  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+
+  outputs =
+    { nixpkgs, ... }:
+    let
+      forAllSystems = nixpkgs.lib.genAttrs nixpkgs.lib.systems.flakeExposed;
+    in
+    {
+      devShells = forAllSystems (
+        system:
+        let
+          pkgs = nixpkgs.legacyPackages.${system};
+        in
+        {
+          default = pkgs.mkShell {
+            packages = with pkgs; [
+              ruby_3_4
+              libpq
+            ];
+          };
+        }
+      );
+    };
+}

data/lib/wal/logging_watcher.rb

@@ -22,19 +22,13 @@ module Wal
       when Wal::BeginTransactionEvent
         @start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         @count = 0
-        Wal.logger&.debug("[#{@slot}] Begin transaction=#{event.transaction_id} size=#{event.estimated_size}")
-      when Wal::CommitTransactionEvent
-        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
+        Wal.logger&.debug("[#{@slot}] Begin transaction=#{event.transaction_id} size=#{event.estimated_size}")
+        @transaction_open = true
+        Wal.hooks[:on_transaction_start]&.call(event, @slot, @watcher)
+      when Wal::CommitTransactionEvent
+        # Logged after the watcher handles it, so the elapsed time covers its commit processing
       when Wal::InsertEvent
         Wal.logger&.debug("[#{@slot}] Insert transaction=#{event.transaction_id} table=#{event.table} primary_key=#{event.primary_key}")
         @count += 1
@@ -57,7 +51,38 @@ module Wal
       else
         @count += 1
       end
+
       @watcher.on_event(event)
+
+      if event.is_a?(Wal::CommitTransactionEvent)
+        log_commit(event)
+        finish_transaction(event)
+      end
+    rescue Exception
+      # The commit will never arrive for this transaction, but the finish hook still has to pair with the start one
+      finish_transaction(nil)
+      raise
+    end
+
+    private
+
+    def log_commit(event)
+      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
+    end
+
+    def finish_transaction(event)
+      return unless @transaction_open
+
+      @transaction_open = false
+      Wal.hooks[:on_transaction_finish]&.call(event, @slot, @watcher)
     end
   end
 end

data/lib/wal/streaming_watcher.rb

@@ -32,33 +32,45 @@ module Wal
     def on_event(event)
       case event
       when BeginTransactionEvent
-        @queue = SizedQueue.new(queue_size(event))
-
+        @event_queue = SizedQueue.new(queue_size(event))
         event_stream = Enumerator.new do |y|
-          while (item = @queue.pop)
-            case item
-            when CommitTransactionEvent
-              y << item
-              break
-            else
-              y << item
-            end
+          while (item = @event_queue.pop)
+            y << item
+            break if item.is_a?(CommitTransactionEvent)
           end
         end
-        @worker = Thread.new { on_transaction_events(event_stream) }
-
-        @queue << event
+        ensure_worker
+        @transaction_queue << event_stream
+        @event_queue << event
 
       when CommitTransactionEvent
-        @queue << event
-        @worker.join
-
-        # We are cleaning this up to hint to Ruby GC that this can be freed before the next begin transaction arrives
-        @queue.clear
-        @queue = nil
+        @event_queue << event
+        result = @completion_queue.pop
+        @event_queue.clear
+        raise result if result.is_a? Exception
 
       else
-        @queue << event
+        @event_queue << event
+      end
+    end
+
+    private
+
+    def ensure_worker
+      return if @worker&.alive?
+
+      @transaction_queue = Queue.new
+      @completion_queue = Queue.new
+
+      @worker = Thread.new do
+        while (event_stream = @transaction_queue.pop)
+          begin
+            on_transaction_events(event_stream)
+            @completion_queue << :done
+          rescue Exception => e
+            @completion_queue << e
+          end
+        end
       end
     end
   end

data/lib/wal/version.rb

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

data/lib/wal.rb

@@ -26,14 +26,29 @@ module Wal
       @hooks ||= {}
     end
 
-    def on_slot_finished(&block)
-      hooks[:on_slot_finished] = block
+    def on_slot_start(&block)
+      hooks[:on_slot_start] = block
+    end
+
+    def on_slot_finish(&block)
+      hooks[:on_slot_finish] = block
     end
 
     def on_slot_error(&block)
       hooks[:on_slot_error] = block
     end
 
+    # Called before the watcher receives each `BeginTransactionEvent`.
+    def on_transaction_start(&block)
+      hooks[:on_transaction_start] = block
+    end
+
+    # Called after the watcher handles each `CommitTransactionEvent`, so every bit of the transaction processing runs
+    # between the start and finish hooks. When processing raises mid-transaction it is still called, with a `nil` event.
+    def on_transaction_finish(&block)
+      hooks[:on_transaction_finish] = block
+    end
+
     def before_fork(&block)
       hooks[:before_fork] = block
     end

data/rbi/wal.rbi

@@ -7,7 +7,7 @@ module Wal
       UpdateEvent,
       DeleteEvent,
     ) }
-  VERSION = "0.0.34"
+  VERSION = "0.0.35"
 
   class << self
     sig { returns(T.class_of(Logger)) }
@@ -27,6 +27,12 @@ module Wal
 
     sig { params(block: T.proc.params(slot: String, config: T.untyped).void).void }
     def on_slot_finish(&block); end
+
+    sig { params(block: T.proc.params(event: Wal::BeginTransactionEvent, slot: String, watcher: Wal::Watcher).void).void }
+    def on_transaction_start(&block); end
+
+    sig { params(block: T.proc.params(event: T.nilable(Wal::CommitTransactionEvent), slot: String, watcher: Wal::Watcher).void).void }
+    def on_transaction_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.34
+  version: 0.0.36
 platform: ruby
 authors:
 - Rodrigo Navarro
 bindir: exe
 cert_chain: []
-date: 2026-02-11 00:00:00.000000000 Z
+date: 1980-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -91,6 +91,8 @@ files:
 - README.md
 - Rakefile
 - exe/wal
+- flake.lock
+- flake.nix
 - lib/wal.rb
 - lib/wal/active_record_context_extension.rb
 - lib/wal/generators/migration.rb
@@ -125,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Hook up into Postgres WAL log
 test_files: []