wal 0.0.35 → 0.0.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 788875361db2a62f50b4034f91cef70aea8c6ac90913fcd6ca64da413ed6a8fe
-  data.tar.gz: e5fa8e4591a2d6c0caf8d9b5f6b1c8e51c0a73e172bc6c57c5ce8d76365806fc
+  metadata.gz: 87f882233ec5ff20290d81d462f21298948f55769af90df9c402a7ba5cc7c97d
+  data.tar.gz: 575345ed49b77a79ed63ae7a2adcfcd21f1662dda4349bebd66863456b642899
 SHA512:
-  metadata.gz: de10acf825cd27a32b3d86fa044c8fcad1602f4484ee7844623c83afe326cfc70c367f92b2f7cac6f0eb6aaa6c00098f9a7b7ee2f37d985357f07bb0ae41a9b4
-  data.tar.gz: 303a33da27ef0fc779f98e3521d919aacdcbd9a011b49354a1a1d089fe83026e1a66cc1a9ee9edb219188ab02df5e0d6a5414ad72dd3cdc471cb3f88bc4cbbbc
+  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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wal
-  VERSION = "0.0.35"
+  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

@@ -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.35
+  version: 0.0.36
 platform: ruby
 authors:
 - Rodrigo Navarro
 bindir: exe
 cert_chain: []
-date: 2026-02-12 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: []