[wip]: Speed up shutdown by brutally killing snapshot processes #3756

magnetised · 2026-01-21T17:02:05Z

No description provided.

codecov · 2026-01-21T17:05:28Z

❌ 55 Tests Failed:

Tests completed	Failed	Passed	Skipped
2124	55	2069	0

View the top 3 failed test(s) by shortest run time

Elixir.Electric.ShapeCacheTest::test await_snapshot_start/4 handles buffering multiple callers correctly

Stack Traces | 0s run time

9) test await_snapshot_start/4 handles buffering multiple callers correctly (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:689
     ** (EXIT from #PID<0.18463.0>) exited in: GenServer.call(#PID<0.18508.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test await_snapshot_start/4 handles buffering multiple callers correctly", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started

Elixir.Electric.ShapeCacheTest::test await_snapshot_start/4 propagates error in snapshot creation to listeners

Stack Traces | 0s run time

31) test await_snapshot_start/4 propagates error in snapshot creation to listeners (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:817
     ** (EXIT from #PID<0.10693.0>) exited in: GenServer.call(#PID<0.10829.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test await_snapshot_start/4 propagates error in snapshot creation to listeners", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started

Elixir.Electric.ShapeCacheTest::test await_snapshot_start/4 should stop awaiting if shape process dies unexpectedly

Stack Traces | 0s run time

2) test await_snapshot_start/4 should stop awaiting if shape process dies unexpectedly (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:845
     ** (EXIT from #PID<0.18943.0>) exited in: GenServer.call(#PID<0.18988.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test await_snapshot_start/4 should stop awaiting if shape process dies unexpectedly", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started

Elixir.Electric.ShapeCacheTest::test after restart waits until publication filters are restored

Stack Traces | 0.0223s run time

11) test after restart waits until publication filters are restored (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:987
     ** (exit) exited in: GenServer.call(#PID<0.18401.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test after restart waits until publication filters are restored", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: :started = ShapeCache.await_snapshot_start(shape_handle1, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:990: (test)

Elixir.Electric.ShapeCacheTest::test await_snapshot_start/4 returns :started for snapshots that have started

Stack Traces | 0.0225s run time

3) test await_snapshot_start/4 returns :started for snapshots that have started (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:660
     ** (exit) exited in: GenServer.call(#PID<0.18933.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test await_snapshot_start/4 returns :started for snapshots that have started", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: assert ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id) == :started
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:668: (test)

Elixir.Electric.ShapeCacheTest::test after restart restores shapes with subqueries and their materializers

Stack Traces | 0.0343s run time

17) test after restart restores shapes with subqueries and their materializers (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:1042
     ** (exit) exited in: GenServer.call(#PID<0.16243.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: GenServer.call({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test after restart restores shapes with subqueries and their materializers", {Electric.Shapes.Consumer.Materializer, "86050472-1769095446907758"}}}, :subscribe, 5000)
             ** (EXIT) shutdown
     code: :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:1046: (test)

Elixir.Electric.Shapes.ConsumerTest::test transaction handling with real storage should hibernate not suspend if has dependencies

Stack Traces | 0.0349s run time

6) test transaction handling with real storage should hibernate not suspend if has dependencies (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:859
     ** (exit) exited in: GenServer.call(#PID<0.15304.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: GenServer.call({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test transaction handling with real storage should hibernate not suspend if has dependencies", {Electric.Shapes.Consumer.Materializer, "26585834-1769095446094669"}}}, :subscribe, 5000)
             ** (EXIT) shutdown
     code: :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       .../electric/shapes/consumer_test.exs:868: (test)

Elixir.Electric.ShapeCacheTest::test has_shape?/2 returns true for known shape handle

Stack Traces | 0.0357s run time

10) test has_shape?/2 returns true for known shape handle (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:619
     ** (exit) exited in: GenServer.call(#PID<0.18456.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test has_shape?/2 returns true for known shape handle", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: assert :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:627: (test)

Elixir.Electric.ShapeCacheTest::test after restart restores latest offset

Stack Traces | 0.0422s run time

19) test after restart restores latest offset (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:1012
     ** (exit) exited in: GenServer.call(#PID<0.16087.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test after restart restores latest offset", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:1015: (test)

Elixir.Electric.ShapeCacheTest::test after restart restores shapes with subqueries and their materializers when backup missing

Stack Traces | 0.0442s run time

5) test after restart restores shapes with subqueries and their materializers when backup missing (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:1063
     ** (exit) exited in: GenServer.call(#PID<0.18801.0>, :await_snapshot_start, 45000)
         ** (EXIT) shutdown: :cleanup
     code: :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:1067: (test)

Elixir.Electric.Shapes.ConsumerTest::test event handling doesn't append to log when change is irrelevant for active shapes

Stack Traces | 0.0453s run time

4) test event handling doesn't append to log when change is irrelevant for active shapes (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:286
     ** (exit) exited in: GenServer.call(#PID<0.15661.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test event handling doesn't append to log when change is irrelevant for active shapes", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       .../electric/shapes/consumer_test.exs:180: anonymous fn/3 in Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       (stdlib 7.1) maps.erl:894: :maps.fold_1/4
       .../electric/shapes/consumer_test.exs:162: Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       Electric.Shapes.ConsumerTest.__ex_unit_describe_0/1

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 shape initialization triggers table prep and snapshot creation only once even with queued requests

Stack Traces | 0.0459s run time

18) test get_or_create_shape_handle/2 shape initialization triggers table prep and snapshot creation only once even with queued requests (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:220
     ** (exit) exited in: GenServer.call(#PID<0.16164.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test get_or_create_shape_handle/2 shape initialization triggers table prep and snapshot creation only once even with queued requests", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: assert :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:259: (test)

Elixir.Electric.Shapes.ConsumerTest::test event handling notifies listeners of new changes

Stack Traces | 0.0478s run time

20) test event handling notifies listeners of new changes (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:394
     ** (exit) exited in: GenServer.call(#PID<0.12267.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test event handling notifies listeners of new changes", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       .../electric/shapes/consumer_test.exs:180: anonymous fn/3 in Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       (stdlib 7.1) maps.erl:894: :maps.fold_1/4
       .../electric/shapes/consumer_test.exs:162: Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       Electric.Shapes.ConsumerTest.__ex_unit_describe_0/1

Elixir.Electric.Shapes.ConsumerTest::test transaction handling with real storage should correctly normalize a flush boundary to txn

Stack Traces | 0.0574s run time

12) test transaction handling with real storage should correctly normalize a flush boundary to txn (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:757
     ** (exit) exited in: GenServer.call(#PID<0.14315.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test transaction handling with real storage should correctly normalize a flush boundary to txn", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       .../electric/shapes/consumer_test.exs:763: (test)

Elixir.Electric.ShapeCacheTest::test list_shapes/1 lists the shape as active once there is a snapshot

Stack Traces | 0.0577s run time

20) test list_shapes/1 lists the shape as active once there is a snapshot (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:531
     ** (exit) exited in: GenServer.call(#PID<0.16010.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test list_shapes/1 lists the shape as active once there is a snapshot", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: assert :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:544: (test)

Elixir.Electric.Shapes.ConsumerTest::test transaction handling with real storage should notify txns skipped because of xmin/xip as flushed

Stack Traces | 0.0628s run time

16) test transaction handling with real storage should notify txns skipped because of xmin/xip as flushed (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:787
     ** (exit) exited in: GenServer.call(#PID<0.12874.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test transaction handling with real storage should notify txns skipped because of xmin/xip as flushed", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       .../electric/shapes/consumer_test.exs:795: (test)

Elixir.Electric.ShapeCleanerTest::test remove_shape_async/2 cleans up shape data and rotates the shape handle

Stack Traces | 0.0639s run time

7) test remove_shape_async/2 cleans up shape data and rotates the shape handle (Electric.ShapeCleanerTest)
     test/electric/shape_cleaner_test.exs:107
     ** (exit) exited in: GenServer.call(#PID<0.16834.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCleanerTest test remove_shape_async/2 cleans up shape data and rotates the shape handle", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: assert :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cleaner_test.exs:120: (test)

Elixir.Electric.Shapes.ConsumerTest::test transaction handling with real storage should terminate after :hibernate_after ms

Stack Traces | 0.0639s run time

9) test transaction handling with real storage should terminate after :hibernate_after ms (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:824
     ** (exit) exited in: GenServer.call(#PID<0.14792.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test transaction handling with real storage should terminate after :hibernate_after ms", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       .../electric/shapes/consumer_test.exs:831: (test)

Elixir.Electric.ShapeCleanerTest::test remove_shapes_for_relations/2 cleans up shape data for relevant shapes

Stack Traces | 0.0647s run time

5) test remove_shapes_for_relations/2 cleans up shape data for relevant shapes (Electric.ShapeCleanerTest)
     test/electric/shape_cleaner_test.exs:225
     ** (exit) exited in: GenServer.call(#PID<0.17158.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCleanerTest test remove_shapes_for_relations/2 cleans up shape data for relevant shapes", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: assert :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cleaner_test.exs:227: (test)

Elixir.Electric.Shapes.ConsumerTest::test transaction handling with real storage restarting a consumer doesn't lower the last known offset when only snapshot is present

Stack Traces | 0.0657s run time

13) test transaction handling with real storage restarting a consumer doesn't lower the last known offset when only snapshot is present (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:725
     ** (exit) exited in: GenServer.call(#PID<0.14166.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test transaction handling with real storage restarting a consumer doesn't lower the last known offset when only snapshot is present", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       .../electric/shapes/consumer_test.exs:729: (test)

Elixir.Electric.Shapes.ConsumerTest::test event handling notifies live listeners when invalidated

Stack Traces | 0.0693s run time

18) test event handling notifies live listeners when invalidated (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:514
     ** (exit) exited in: GenServer.call(#PID<0.12578.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test event handling notifies live listeners when invalidated", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       .../electric/shapes/consumer_test.exs:180: anonymous fn/3 in Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       (stdlib 7.1) maps.erl:894: :maps.fold_1/4
       .../electric/shapes/consumer_test.exs:162: Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       Electric.Shapes.ConsumerTest.__ex_unit_describe_0/1

Elixir.Electric.Shapes.ConsumerTest::test transaction handling with real storage duplicate transactions storage is idempotent

Stack Traces | 0.0697s run time

3) test transaction handling with real storage duplicate transactions storage is idempotent (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:618
     ** (exit) exited in: GenServer.call(#PID<0.15763.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test transaction handling with real storage duplicate transactions storage is idempotent", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       .../electric/shapes/consumer_test.exs:623: (test)

Elixir.Electric.Shapes.ConsumerTest::test event handling consumer crashing stops affected consumer

Stack Traces | 0.0716s run time

19) test event handling consumer crashing stops affected consumer (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:554
     ** (exit) exited in: GenServer.call(#PID<0.12433.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test event handling consumer crashing stops affected consumer", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       .../electric/shapes/consumer_test.exs:180: anonymous fn/3 in Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       (stdlib 7.1) maps.erl:894: :maps.fold_1/4
       .../electric/shapes/consumer_test.exs:162: Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       Electric.Shapes.ConsumerTest.__ex_unit_describe_0/1

Elixir.Electric.ShapeCacheTest::test after restart restores shape_handles

Stack Traces | 0.073s run time

15) test after restart restores shape_handles (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:978
     ** (exit) exited in: GenServer.call(#PID<0.16522.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test after restart restores shape_handles", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: :started = ShapeCache.await_snapshot_start(shape_handle1, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:980: (test)

Elixir.Electric.Shapes.ConsumerTest::test transaction handling with real storage terminating the consumers cleans up its entry from Storage ETS

Stack Traces | 0.0759s run time

22) test transaction handling with real storage terminating the consumers cleans up its entry from Storage ETS (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:972
     ** (exit) exited in: GenServer.call(#PID<0.11933.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test transaction handling with real storage terminating the consumers cleans up its entry from Storage ETS", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       .../electric/shapes/consumer_test.exs:977: (test)

Elixir.Electric.Shapes.ConsumerTest::test event handling cleans shapes affected by a relation rename

Stack Traces | 0.0762s run time

1) test event handling cleans shapes affected by a relation rename (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:441
     ** (exit) exited in: GenServer.call(#PID<0.16444.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test event handling cleans shapes affected by a relation rename", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       .../electric/shapes/consumer_test.exs:180: anonymous fn/3 in Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       (stdlib 7.1) maps.erl:894: :maps.fold_1/4
       .../electric/shapes/consumer_test.exs:162: Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       Electric.Shapes.ConsumerTest.__ex_unit_describe_0/1

Elixir.Electric.ShapeCleanerTest::test remove_shape/2 cleans up shape data and rotates the shape handle

Stack Traces | 0.078s run time

3) test remove_shape/2 cleans up shape data and rotates the shape handle (Electric.ShapeCleanerTest)
     test/electric/shape_cleaner_test.exs:107
     ** (exit) exited in: GenServer.call(#PID<0.17430.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCleanerTest test remove_shape/2 cleans up shape data and rotates the shape handle", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: assert :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cleaner_test.exs:120: (test)

Elixir.Electric.Shapes.ConsumerTest::test event handling appends to log when xid >= xmin

Stack Traces | 0.0801s run time

8) test event handling appends to log when xid >= xmin (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:188
     ** (exit) exited in: GenServer.call(#PID<0.14991.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test event handling appends to log when xid >= xmin", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       .../electric/shapes/consumer_test.exs:180: anonymous fn/3 in Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       (stdlib 7.1) maps.erl:894: :maps.fold_1/4
       .../electric/shapes/consumer_test.exs:162: Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       Electric.Shapes.ConsumerTest.__ex_unit_describe_0/1

Elixir.Electric.Shapes.ConsumerTest::test event handling handles truncate without appending to log

Stack Traces | 0.0812s run time

17) test event handling handles truncate without appending to log (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:312
     ** (exit) exited in: GenServer.call(#PID<0.12739.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test event handling handles truncate without appending to log", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       .../electric/shapes/consumer_test.exs:180: anonymous fn/3 in Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       (stdlib 7.1) maps.erl:894: :maps.fold_1/4
       .../electric/shapes/consumer_test.exs:162: Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       Electric.Shapes.ConsumerTest.__ex_unit_describe_0/1

Elixir.Electric.Shapes.ConsumerTest::test event handling handles truncate when shape has a where clause

Stack Traces | 0.0839s run time

10) test event handling handles truncate when shape has a where clause (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:368
     ** (exit) exited in: GenServer.call(#PID<0.14667.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test event handling handles truncate when shape has a where clause", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       .../electric/shapes/consumer_test.exs:180: anonymous fn/3 in Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       (stdlib 7.1) maps.erl:894: :maps.fold_1/4
       .../electric/shapes/consumer_test.exs:162: Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       Electric.Shapes.ConsumerTest.__ex_unit_describe_0/1

Elixir.Electric.Shapes.ConsumerTest::test event handling does not clean shapes if relation didn't change

Stack Traces | 0.0849s run time

11) test event handling does not clean shapes if relation didn't change (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:416
     ** (exit) exited in: GenServer.call(#PID<0.14494.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test event handling does not clean shapes if relation didn't change", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       .../electric/shapes/consumer_test.exs:180: anonymous fn/3 in Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       (stdlib 7.1) maps.erl:894: :maps.fold_1/4
       .../electric/shapes/consumer_test.exs:162: Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       Electric.Shapes.ConsumerTest.__ex_unit_describe_0/1

Elixir.Electric.Shapes.ConsumerTest::test event handling cleans shapes affected by a relation change

Stack Traces | 0.0883s run time

21) test event handling cleans shapes affected by a relation change (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:472
     ** (exit) exited in: GenServer.call(#PID<0.12115.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test event handling cleans shapes affected by a relation change", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       .../electric/shapes/consumer_test.exs:180: anonymous fn/3 in Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       (stdlib 7.1) maps.erl:894: :maps.fold_1/4
       .../electric/shapes/consumer_test.exs:162: Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       Electric.Shapes.ConsumerTest.__ex_unit_describe_0/1

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 against real db can create shape from partitioned table

Stack Traces | 0.103s run time

4) test get_or_create_shape_handle/2 against real db can create shape from partitioned table (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:468
     ** (exit) exited in: GenServer.call(#PID<0.18880.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test get_or_create_shape_handle/2 against real db can create shape from partitioned table", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: assert :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:483: (test)

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 shape initialization creates initial snapshot if one doesn't exist

Stack Traces | 0.103s run time

16) test get_or_create_shape_handle/2 shape initialization creates initial snapshot if one doesn't exist (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:154
     ** (exit) exited in: GenServer.call(#PID<0.16385.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test get_or_create_shape_handle/2 shape initialization creates initial snapshot if one doesn't exist", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: assert :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:168: (test)

Elixir.Electric.Shapes.ConsumerTest::test event handling correctly writes only relevant changes to multiple shape logs

Stack Traces | 0.118s run time

15) test event handling correctly writes only relevant changes to multiple shape logs (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:229
     ** (exit) exited in: GenServer.call(#PID<0.13061.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test event handling correctly writes only relevant changes to multiple shape logs", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       .../electric/shapes/consumer_test.exs:180: anonymous fn/3 in Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       (stdlib 7.1) maps.erl:894: :maps.fold_1/4
       .../electric/shapes/consumer_test.exs:162: Electric.Shapes.ConsumerTest.__ex_unit_setup_0_11/1
       Electric.Shapes.ConsumerTest.__ex_unit_describe_0/1

Elixir.Electric.ShapeCacheTest::test start_consumer_for_handle/2 starts a consumer plus dependencies

Stack Traces | 0.12s run time

29) test start_consumer_for_handle/2 starts a consumer plus dependencies (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:1136
     ** (exit) exited in: GenServer.call(#PID<0.11326.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: GenServer.call({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test start_consumer_for_handle/2 starts a consumer plus dependencies", {Electric.Shapes.Consumer.Materializer, "86050472-1769095443360722"}}}, :subscribe, 5000)
             ** (EXIT) shutdown
     code: :started = ShapeCache.await_snapshot_start(shape_handle, stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:1140: (test)

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 shape initialization triggers table prep and snapshot creation only once

Stack Traces | 0.143s run time

30) test get_or_create_shape_handle/2 shape initialization triggers table prep and snapshot creation only once (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:174
     match (=) failed
     The following variables were pinned:
       shape_handle = "95846100-1769095443198549"
     code:  assert {^shape_handle, _} = ShapeCache.get_or_create_shape_handle(@shape, ctx.stack_id)
     left:  {^shape_handle, _}
     right: {"95846100-1769095443209857", LogOffset.last_before_real_offsets()}
     stacktrace:
       test/electric/shape_cache_test.exs:208: anonymous fn/4 in Electric.ShapeCacheTest."test get_or_create_shape_handle/2 shape initialization triggers table prep and snapshot creation only once"/1
       (elixir 1.19.1) lib/enum.ex:4562: Enum.reduce_range/5
       test/electric/shape_cache_test.exs:206: (test)

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 against real db correctly propagates the error

Stack Traces | 0.157s run time

28) test get_or_create_shape_handle/2 against real db correctly propagates the error (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:440
     ** (exit) exited in: GenServer.call(#PID<0.11621.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test get_or_create_shape_handle/2 against real db correctly propagates the error", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: with_log(fn ->
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:452: anonymous fn/2 in Electric.ShapeCacheTest."test get_or_create_shape_handle/2 against real db correctly propagates the error"/1
       (ex_unit 1.19.1) lib/ex_unit/capture_log.ex:121: ExUnit.CaptureLog.with_log/2
       test/electric/shape_cache_test.exs:448: (test)

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 against real db crashes when initial snapshot query fails to return data quickly enough

Stack Traces | 0.2s run time

23) test get_or_create_shape_handle/2 against real db crashes when initial snapshot query fails to return data quickly enough (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:501
     ** (exit) exited in: GenServer.call(#PID<0.14865.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test get_or_create_shape_handle/2 against real db crashes when initial snapshot query fails to return data quickly enough", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: ShapeCache.await_snapshot_start(shape_handle, stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:514: (test)

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 against real db uses correct display settings when querying initial data

Stack Traces | 0.236s run time

27) test get_or_create_shape_handle/2 against real db uses correct display settings when querying initial data (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:379
     ** (exit) exited in: GenServer.call(#PID<0.12034.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test get_or_create_shape_handle/2 against real db uses correct display settings when querying initial data", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: assert :started = ShapeCache.await_snapshot_start(shape_handle, stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:414: (test)

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 against real db creates initial snapshot from DB data

Stack Traces | 0.334s run time

32) test get_or_create_shape_handle/2 against real db creates initial snapshot from DB data (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:347
     ** (exit) exited in: GenServer.call(#PID<0.10634.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test get_or_create_shape_handle/2 against real db creates initial snapshot from DB data", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: assert :started = ShapeCache.await_snapshot_start(shape_handle, stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       test/electric/shape_cache_test.exs:355: (test)

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 shape initialization shape gets cleaned up if terminated unexpectedly

Stack Traces | 0.424s run time

1) test get_or_create_shape_handle/2 shape initialization shape gets cleaned up if terminated unexpectedly (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:270
     Assertion failed, no matching message after 400ms
     The following variables were pinned:
       consumer_ref = #Reference<0.1565559805.1070858244.238356>
     Showing 2 of 2 messages in the mailbox
     code: assert_receive {:DOWN, ^consumer_ref, :process, _pid, :some_reason}
     mailbox:
       pattern: {:DOWN, ^consumer_ref, :process, _pid, :some_reason}
       value:   {:DOWN, #Reference<0.1565559805.1070858244.238356>, :process, #PID<0.19046.0>, {:noproc, {PartitionSupervisor, :partitions, [{:via, Registry, {:"Electric.ProcessRegistry:Electric.ShapeCacheTest test get_or_create_shape_handle/2 shape initialization shape gets cleaned up if terminated unexpectedly", {Electric.Shapes.SnapshotterSupervisor, nil}}}]}}}

       pattern: {:DOWN, ^consumer_ref, :process, _pid, :some_reason}
       value:   {Electric.ShapeCache.ShapeCleaner, :cleanup, "95846100-1769095451169103"}
     stacktrace:
       test/electric/shape_cache_test.exs:280: (test)

Elixir.Electric.ShapeCacheTest::test has_shape?/2 works with slow snapshot generation

Stack Traces | 0.428s run time

12) test has_shape?/2 works with slow snapshot generation (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:633
     Assertion failed, no matching message after 400ms
     The following variables were pinned:
       handle = "95846100-1769095448849377"
     Showing 1 of 1 message in the mailbox
     code: assert_receive {:snapshot, ^handle}
     mailbox:
       pattern: {:snapshot, ^handle}
       value:   {Electric.ShapeCache.ShapeCleaner, :cleanup, "95846100-1769095448849377"}
     stacktrace:
       test/electric/shape_cache_test.exs:1221: anonymous fn/1 in Electric.ShapeCacheTest.wait_snapshot/1
       (elixir 1.19.1) lib/enum.ex:1688: Enum."-map/2-lists^map/1-1-"/2
       test/electric/shape_cache_test.exs:1201: Electric.ShapeCacheTest.wait_shape_init/2
       test/electric/shape_cache_test.exs:643: (test)

Elixir.Electric.ShapeCacheTest::test await_snapshot_start/4 errors while streaming from database are sent to all callers

Stack Traces | 0.438s run time

7) test await_snapshot_start/4 errors while streaming from database are sent to all callers (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:735
     Assertion failed, no matching message after 400ms
     Showing 1 of 1 message in the mailbox
     code: assert_receive {:stream_start, stream_pid}
     mailbox:
       pattern: {:stream_start, stream_pid}
       value:   {Electric.ShapeCache.ShapeCleaner, :cleanup, "95846100-1769095450204012"}
     stacktrace:
       test/electric/shape_cache_test.exs:798: (test)

Elixir.Electric.Shapes.ConsumerTest::test transaction handling with real storage compaction is scheduled and invoked for a shape that has compaction enabled

Stack Traces | 0.445s run time

2) test transaction handling with real storage compaction is scheduled and invoked for a shape that has compaction enabled (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:954
     Assertion failed, no matching message after 400ms
     The following variables were pinned:
       ref = #Reference<0.1565559805.1070858241.170651>
     Showing 1 of 1 message in the mailbox
     code: assert_receive {:consumer_did_invoke_compact, ^ref}
     mailbox:
       pattern: {:consumer_did_invoke_compact, ^ref}
       value:   {Electric.ShapeCache.ShapeCleaner, :cleanup, "27335419-1769095446566958"}
     stacktrace:
       .../electric/shapes/consumer_test.exs:969: (test)

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 returns existing shape_handle

Stack Traces | 0.488s run time

24) test get_or_create_shape_handle/2 returns existing shape_handle (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:95
     Assertion failed, no matching message after 400ms
     The following variables were pinned:
       handle = "95846100-1769095445146889"
     Showing 1 of 1 message in the mailbox
     code: assert_receive {:snapshot, ^handle}
     mailbox:
       pattern: {:snapshot, ^handle}
       value:   {Electric.ShapeCache.ShapeCleaner, :cleanup, "95846100-1769095445146889"}
     stacktrace:
       test/electric/shape_cache_test.exs:1221: anonymous fn/1 in Electric.ShapeCacheTest.wait_snapshot/1
       (elixir 1.19.1) lib/enum.ex:1688: Enum."-map/2-lists^map/1-1-"/2
       test/electric/shape_cache_test.exs:1201: Electric.ShapeCacheTest.wait_shape_init/2
       test/electric/shape_cache_test.exs:99: (test)

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 creates a new shape_handle

Stack Traces | 0.495s run time

13) test get_or_create_shape_handle/2 creates a new shape_handle (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:89
     Assertion failed, no matching message after 400ms
     The following variables were pinned:
       handle = "95846100-1769095448384309"
     Showing 1 of 1 message in the mailbox
     code: assert_receive {:snapshot, ^handle}
     mailbox:
       pattern: {:snapshot, ^handle}
       value:   {Electric.ShapeCache.ShapeCleaner, :cleanup, "95846100-1769095448384309"}
     stacktrace:
       test/electric/shape_cache_test.exs:1221: anonymous fn/1 in Electric.ShapeCacheTest.wait_snapshot/1
       (elixir 1.19.1) lib/enum.ex:1688: Enum."-map/2-lists^map/1-1-"/2
       test/electric/shape_cache_test.exs:1201: Electric.ShapeCacheTest.wait_shape_init/2
       test/electric/shape_cache_test.exs:92: (test)

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 should not return the same shape_handle for all columns and selected columns

Stack Traces | 0.504s run time

26) test get_or_create_shape_handle/2 should not return the same shape_handle for all columns and selected columns (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:127
     Assertion failed, no matching message after 400ms
     The following variables were pinned:
       handle = "95846100-1769095443986959"
     Showing 2 of 2 messages in the mailbox
     code: assert_receive {:snapshot, ^handle}
     mailbox:
       pattern: {:snapshot, ^handle}
       value:   {Electric.ShapeCache.ShapeCleaner, :cleanup, "95846100-1769095443986959"}

       pattern: {:snapshot, ^handle}
       value:   {Electric.ShapeCache.ShapeCleaner, :cleanup, "117685989-1769095443981361"}
     stacktrace:
       test/electric/shape_cache_test.exs:1221: anonymous fn/1 in Electric.ShapeCacheTest.wait_snapshot/1
       (elixir 1.19.1) lib/enum.ex:1688: Enum."-map/2-lists^map/1-1-"/2
       test/electric/shape_cache_test.exs:1201: Electric.ShapeCacheTest.wait_shape_init/2
       test/electric/shape_cache_test.exs:142: (test)

Elixir.Electric.Shapes.ConsumerTest::test transaction handling with real storage transactions are buffered until snapshot xmin is known

Stack Traces | 0.581s run time

14) test transaction handling with real storage transactions are buffered until snapshot xmin is known (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:668
     Assertion failed, no matching message after 400ms
     The following variables were pinned:
       shape_handle = "27335419-1769095444798256"
     Showing 1 of 1 message in the mailbox
     code: assert_receive {:snapshot, ^shape_handle}
     mailbox:
       pattern: {:snapshot, ^shape_handle}
       value:   {Electric.ShapeCache.ShapeCleaner, :cleanup, "27335419-1769095444798256"}
     stacktrace:
       .../electric/shapes/consumer_test.exs:676: (test)

Elixir.Electric.ShapeCacheTest::test list_shapes/1 lists the shape even if we don't know xmin

Stack Traces | 0.596s run time

25) test list_shapes/1 lists the shape even if we don't know xmin (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:549
     Assertion failed, no matching message after 400ms
     Showing 1 of 1 message in the mailbox
     code: assert_receive {:waiting_point, ref, pid}
     mailbox:
       pattern: {:waiting_point, ref, pid}
       value:   {Electric.ShapeCache.ShapeCleaner, :cleanup, "95846100-1769095444639024"}
     stacktrace:
       test/electric/shape_cache_test.exs:569: (test)

Elixir.Electric.ShapeCacheTest::test await_snapshot_start/4 should wait for consumer to come up

Stack Traces | 0.639s run time

21) test await_snapshot_start/4 should wait for consumer to come up (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:877
     match (=) failed
     code:  assert :started = Task.await(wait_task, start_consumer_delay)
     left:  :started
     right: {:error, :unknown}
     stacktrace:
       test/electric/shape_cache_test.exs:915: (test)

Elixir.Electric.ShapeCacheTest::test get_or_create_shape_handle/2 should not return the same shape_handle for different shapes despite hash collision

Stack Traces | 0.679s run time

8) test get_or_create_shape_handle/2 should not return the same shape_handle for different shapes despite hash collision (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:102
     Assertion failed, no matching message after 400ms
     The following variables were pinned:
       handle = "1234-1769095449731831"
     Showing 2 of 2 messages in the mailbox
     code: assert_receive {:snapshot, ^handle}
     mailbox:
       pattern: {:snapshot, ^handle}
       value:   {Electric.ShapeCache.ShapeCleaner, :cleanup, "1234-1769095449731831"}

       pattern: {:snapshot, ^handle}
       value:   {Electric.ShapeCache.ShapeCleaner, :cleanup, "1234-1769095449732726"}
     stacktrace:
       test/electric/shape_cache_test.exs:1221: anonymous fn/1 in Electric.ShapeCacheTest.wait_snapshot/1
       (elixir 1.19.1) lib/enum.ex:1688: Enum."-map/2-lists^map/1-1-"/2
       test/electric/shape_cache_test.exs:1201: Electric.ShapeCacheTest.wait_shape_init/2
       test/electric/shape_cache_test.exs:124: (test)

Elixir.Electric.ShapeCacheTest::test count_shapes/1 returns the correct count of shapes

Stack Traces | 0.972s run time

14) test count_shapes/1 returns the correct count of shapes (Electric.ShapeCacheTest)
     test/electric/shape_cache_test.exs:589
     Assertion with == failed
     code:  assert num_shapes == ShapeCache.count_shapes(ctx.stack_id)
     left:  73
     right: 3
     stacktrace:
       test/electric/shape_cache_test.exs:604: (test)

View the full list of 2 ❄️ flaky test(s)

Elixir.Electric.Shapes.ConsumerTest::test transaction handling with real storage ConsumerRegistry.enable_suspend should suspend hibernated consumers

Flake rate in main: 24.16% (Passed 135 times, Failed 43 times)

Stack Traces | 0.0915s run time

7) test transaction handling with real storage ConsumerRegistry.enable_suspend should suspend hibernated consumers (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:912
     ** (exit) exited in: GenServer.call(#PID<0.15157.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: PartitionSupervisor.partitions({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test transaction handling with real storage ConsumerRegistry.enable_suspend should suspend hibernated consumers", {Electric.Shapes.SnapshotterSupervisor, nil}}})
             ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started
     code: :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       .../electric/shapes/consumer_test.exs:919: (test)

Elixir.Electric.Shapes.ConsumerTest::test transaction handling with real storage UPDATE during pending move-in is converted to INSERT and query result skips duplicate key

Flake rate in main: 19.26% (Passed 218 times, Failed 52 times)

Stack Traces | 0.123s run time

5) test transaction handling with real storage UPDATE during pending move-in is converted to INSERT and query result skips duplicate key (Electric.Shapes.ConsumerTest)
     .../electric/shapes/consumer_test.exs:995
     ** (exit) exited in: GenServer.call(#PID<0.15565.0>, :await_snapshot_start, 45000)
         ** (EXIT) exited in: GenServer.call({:via, Registry, {:"Electric.ProcessRegistry:Electric.Shapes.ConsumerTest test transaction handling with real storage UPDATE during pending move-in is converted to INSERT and query result skips duplicate key", {Electric.Shapes.Consumer.Materializer, "26585834-1769095446234774"}}}, :subscribe, 5000)
             ** (EXIT) shutdown
     code: :started = ShapeCache.await_snapshot_start(shape_handle, ctx.stack_id)
     stacktrace:
       (elixir 1.19.1) lib/gen_server.ex:1142: GenServer.call/3
       (electric 1.3.3) lib/electric/shape_cache.ex:131: Electric.ShapeCache."REPATCH-await_snapshot_start"/2
       .../electric/shapes/consumer_test.exs:1027: (test)

To view more test analytics, go to the Test Analytics Dashboard
_{📋 Got 3 mins? Take this short survey to help us improve Test Analytics.}

coderabbitai · 2026-01-22T13:46:04Z

Important

Review skipped

Draft detected.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

blacksmith-sh · 2026-01-22T13:48:30Z

Found 110 test failures on Blacksmith runners:

Failures

Test	View Logs
`Elixir.Electric.ShapeCacheTest/test after restart restores latest offset`	View Logs
`Elixir.Electric.ShapeCacheTest/test after restart restores latest offset`	View Logs
`Elixir.Electric.ShapeCacheTest/test after restart restores shape_handles`	View Logs
`Elixir.Electric.ShapeCacheTest/test after restart restores shape_handles`	View Logs
`Elixir.Electric.ShapeCacheTest/` `test after restart restores shapes with subqueries and their materializers`	View Logs
`Elixir.Electric.ShapeCacheTest/` `test after restart restores shapes with subqueries and their materializers`	View Logs
`Elixir.Electric.ShapeCacheTest/` `test after restart restores shapes with subqueries and their materializers when backup` `missing`	View Logs
`Elixir.Electric.ShapeCacheTest/` `test after restart restores shapes with subqueries and their materializers when backup` `missing`	View Logs
`Elixir.Electric.ShapeCacheTest/` `test after restart waits until publication filters are restored`	View Logs
`Elixir.Electric.ShapeCacheTest/` `test after restart waits until publication filters are restored`	View Logs
`Elixir.Electric.ShapeCacheTest/test await_snapshot_start/` `4 errors while streaming from database are sent to all callers`	View Logs
`Elixir.Electric.ShapeCacheTest/test await_snapshot_start/` `4 errors while streaming from database are sent to all callers`	View Logs
`Elixir.Electric.ShapeCacheTest/test await_snapshot_start/` `4 handles buffering multiple callers correctly`	View Logs
`Elixir.Electric.ShapeCacheTest/test await_snapshot_start/` `4 handles buffering multiple callers correctly`	View Logs
`Elixir.Electric.ShapeCacheTest/test await_snapshot_start/` `4 propagates error in snapshot creation to listeners`	View Logs
`Elixir.Electric.ShapeCacheTest/test await_snapshot_start/` `4 propagates error in snapshot creation to listeners`	View Logs
`Elixir.Electric.ShapeCacheTest/test await_snapshot_start/` `4 returns :started for snapshots that have started`	View Logs
`Elixir.Electric.ShapeCacheTest/test await_snapshot_start/` `4 returns :started for snapshots that have started`	View Logs
`Elixir.Electric.ShapeCacheTest/test await_snapshot_start/` `4 should stop awaiting if shape process dies unexpectedly`	View Logs
`Elixir.Electric.ShapeCacheTest/test await_snapshot_start/` `4 should stop awaiting if shape process dies unexpectedly`	View Logs
`Elixir.Electric.ShapeCacheTest/test await_snapshot_start/` `4 should wait for consumer to come up`	View Logs
`Elixir.Electric.ShapeCacheTest/test await_snapshot_start/` `4 should wait for consumer to come up`	View Logs
`Elixir.Electric.ShapeCacheTest/test count_shapes/1 returns the correct count of shapes`	View Logs
`Elixir.Electric.ShapeCacheTest/test count_shapes/1 returns the correct count of shapes`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 against real db can create shape from partitioned table`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 against real db can create shape from partitioned table`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 against real db correctly propagates the error`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 against real db correctly propagates the error`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 against real db crashes when initial snapshot query fails to return data quickly enou` `gh`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 against real db crashes when initial snapshot query fails to return data quickly enou` `gh`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 against real db creates initial snapshot from DB data`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 against real db creates initial snapshot from DB data`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 against real db uses correct display settings when querying initial data`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 against real db uses correct display settings when querying initial data`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 creates a new shape_handle`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 creates a new shape_handle`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 returns existing shape_handle`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 returns existing shape_handle`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 shape initialization creates initial snapshot if one doesn't exist`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 shape initialization creates initial snapshot if one doesn't exist`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 shape initialization shape gets cleaned up if terminated unexpectedly`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 shape initialization shape gets cleaned up if terminated unexpectedly`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 shape initialization triggers table prep and snapshot creation only once`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 shape initialization triggers table prep and snapshot creation only once`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 shape initialization triggers table prep and snapshot creation only once even with qu` `eued requests`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 shape initialization triggers table prep and snapshot creation only once even with qu` `eued requests`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 should not return the same shape_handle for all columns and selected columns`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 should not return the same shape_handle for all columns and selected columns`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 should not return the same shape_handle for different shapes despite hash collision`	View Logs
`Elixir.Electric.ShapeCacheTest/test get_or_create_shape_handle/` `2 should not return the same shape_handle for different shapes despite hash collision`	View Logs
`Elixir.Electric.ShapeCacheTest/test has_shape?/2 returns true for known shape handle`	View Logs
`Elixir.Electric.ShapeCacheTest/test has_shape?/2 returns true for known shape handle`	View Logs
`Elixir.Electric.ShapeCacheTest/test has_shape?/2 works with slow snapshot generation`	View Logs
`Elixir.Electric.ShapeCacheTest/test has_shape?/2 works with slow snapshot generation`	View Logs
`Elixir.Electric.ShapeCacheTest/test list_shapes/` `1 lists the shape as active once there is a snapshot`	View Logs
`Elixir.Electric.ShapeCacheTest/test list_shapes/` `1 lists the shape as active once there is a snapshot`	View Logs
`Elixir.Electric.ShapeCacheTest/test list_shapes/` `1 lists the shape even if we don't know xmin`	View Logs
`Elixir.Electric.ShapeCacheTest/test list_shapes/` `1 lists the shape even if we don't know xmin`	View Logs
`Elixir.Electric.ShapeCacheTest/test start_consumer_for_handle/` `2 starts a consumer plus dependencies`	View Logs
`Elixir.Electric.ShapeCacheTest/test start_consumer_for_handle/` `2 starts a consumer plus dependencies`	View Logs
`Elixir.Electric.ShapeCleanerTest/test remove_shape/` `2 cleans up shape data and rotates the shape handle`	View Logs
`Elixir.Electric.ShapeCleanerTest/test remove_shape/` `2 cleans up shape data and rotates the shape handle`	View Logs
`Elixir.Electric.ShapeCleanerTest/test remove_shape_async/` `2 cleans up shape data and rotates the shape handle`	View Logs
`Elixir.Electric.ShapeCleanerTest/test remove_shape_async/` `2 cleans up shape data and rotates the shape handle`	View Logs
`Elixir.Electric.ShapeCleanerTest/test remove_shapes_for_relations/` `2 cleans up shape data for relevant shapes`	View Logs
`Elixir.Electric.ShapeCleanerTest/test remove_shapes_for_relations/` `2 cleans up shape data for relevant shapes`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/test event handling appends to log when xid >= xmin`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/test event handling appends to log when xid >= xmin`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling cleans shapes affected by a relation change`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling cleans shapes affected by a relation change`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling cleans shapes affected by a relation rename`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling cleans shapes affected by a relation rename`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling consumer crashing stops affected consumer`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling consumer crashing stops affected consumer`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling correctly writes only relevant changes to multiple shape logs`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling correctly writes only relevant changes to multiple shape logs`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling does not clean shapes if relation didn't change`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling does not clean shapes if relation didn't change`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling doesn't append to log when change is irrelevant for active shapes`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling doesn't append to log when change is irrelevant for active shapes`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling handles truncate when shape has a where clause`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling handles truncate when shape has a where clause`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling handles truncate without appending to log`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling handles truncate without appending to log`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling notifies listeners of new changes`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling notifies listeners of new changes`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling notifies live listeners when invalidated`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test event handling notifies live listeners when invalidated`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage compaction is scheduled and invoked for a s` `hape that has compaction enabled`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage compaction is scheduled and invoked for a s` `hape that has compaction enabled`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage ConsumerRegistry.enable_suspend should susp` `end hibernated consumers`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage ConsumerRegistry.enable_suspend should susp` `end hibernated consumers`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage duplicate transactions storage is idempoten` `t`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage duplicate transactions storage is idempoten` `t`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage restarting a consumer doesn't lower the las` `t known offset when only snapshot is present`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage restarting a consumer doesn't lower the las` `t known offset when only snapshot is present`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage should correctly normalize a flush boundary` `to txn`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage should correctly normalize a flush boundary` `to txn`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage should hibernate not suspend if has depende` `ncies`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage should hibernate not suspend if has depende` `ncies`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage should notify txns skipped because of xmin/` `xip as flushed`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage should notify txns skipped because of xmin/` `xip as flushed`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage should terminate after :hibernate_after ms`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage should terminate after :hibernate_after ms`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage terminating the consumers cleans up its ent` `ry from Storage ETS`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage terminating the consumers cleans up its ent` `ry from Storage ETS`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage transactions are buffered until snapshot xm` `in is known`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage transactions are buffered until snapshot xm` `in is known`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage UPDATE during pending move-in is converted` `to INSERT and query result skips duplicate key`	View Logs
`Elixir.Electric.Shapes.ConsumerTest/` `test transaction handling with real storage UPDATE during pending move-in is converted` `to INSERT and query result skips duplicate key`	View Logs

msfstef · 2026-01-22T14:52:11Z

packages/sync-service/lib/electric/shapes/snapshotter_supervisor.ex

+    # need to call `super()` to obtain the original DynamicSupervisor child_spec() to pass as an option to
+    # PartitionSupervisor.
+    PartitionSupervisor.child_spec(
+      child_spec: Supervisor.child_spec(super(opts), shutdown: :brutal_kill),


can we not specify this shutdown policy on the snapshotter genserver?

magnetised changed the title ~~move snapshotters to separate supervisor~~ [wip]: Speed up shutdown by brutally killing snapshot processes Jan 21, 2026

magnetised force-pushed the magnetised/sqlite-ets-cache branch 5 times, most recently from 6037b8a to 4168319 Compare January 22, 2026 10:49

magnetised added 2 commits January 22, 2026 13:28

move snapshotters to separate supervisor

5f62ede

don't error if not in a txn

f650b8a

magnetised force-pushed the magnetised/speedup-shutdown branch from 2b93719 to f650b8a Compare January 22, 2026 13:45

msfstef reviewed Jan 22, 2026

View reviewed changes

debug shutdown

31df264

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[wip]: Speed up shutdown by brutally killing snapshot processes #3756

[wip]: Speed up shutdown by brutally killing snapshot processes #3756

Uh oh!

magnetised commented Jan 21, 2026

Uh oh!

codecov bot commented Jan 21, 2026 •

edited

Loading

Uh oh!

coderabbitai bot commented Jan 22, 2026

Review skipped

Uh oh!

blacksmith-sh bot commented Jan 22, 2026 •

edited

Loading

Uh oh!

msfstef Jan 22, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

[wip]: Speed up shutdown by brutally killing snapshot processes #3756

Are you sure you want to change the base?

[wip]: Speed up shutdown by brutally killing snapshot processes #3756

Uh oh!

Conversation

magnetised commented Jan 21, 2026

Uh oh!

codecov bot commented Jan 21, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

❌ 55 Tests Failed:

Uh oh!

coderabbitai bot commented Jan 22, 2026

Review skipped

Uh oh!

blacksmith-sh bot commented Jan 22, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Failures

Uh oh!

msfstef Jan 22, 2026

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

codecov bot commented Jan 21, 2026 •

edited

Loading

blacksmith-sh bot commented Jan 22, 2026 •

edited

Loading