tigerbeetle-node 0.4.2 → 0.5.2

package/src/tigerbeetle/src/vsr/clock.zig

@@ -1,6 +1,7 @@
 const std = @import("std");
 const assert = std.debug.assert;
 const log = std.log.scoped(.clock);
+const fmt = std.fmt;
 
 const config = @import("../config.zig");
 
@@ -95,7 +96,7 @@ pub fn Clock(comptime Time: type) type {
         synchronization_disabled: bool,
 
         pub fn init(
-            allocator: *std.mem.Allocator,
+            allocator: std.mem.Allocator,
             /// The size of the cluster, i.e. the number of clock sources (including this replica).
             replica_count: u8,
             replica: u8,
@@ -133,7 +134,7 @@ pub fn Clock(comptime Time: type) type {
             return self;
         }
 
-        pub fn deinit(self: *Self, allocator: *std.mem.Allocator) void {
+        pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
             allocator.free(self.epoch.sources);
             allocator.free(self.window.sources);
             allocator.free(self.marzullo_tuples);
@@ -273,7 +274,7 @@ pub fn Clock(comptime Time: type) type {
             // Expire the current epoch if successive windows failed to synchronize:
             // Gradual clock drift prevents us from using an epoch for more than a few seconds.
             if (self.epoch.elapsed(self) >= epoch_max) {
-                log.alert(
+                log.err(
                     "{}: no agreement on cluster time (partitioned or too many clock faults)",
                     .{self.replica},
                 );
@@ -320,13 +321,13 @@ pub fn Clock(comptime Time: type) type {
                 // We took too long to synchronize the window, expire stale samples...
                 const sources_sampled = self.window.sources_sampled();
                 if (sources_sampled <= @divTrunc(self.window.sources.len, 2)) {
-                    log.crit("{}: synchronization failed, partitioned (sources={} samples={})", .{
+                    log.err("{}: synchronization failed, partitioned (sources={} samples={})", .{
                         self.replica,
                         sources_sampled,
                         self.window.samples,
                     });
                 } else {
-                    log.crit("{}: synchronization failed, no agreement (sources={} samples={})", .{
+                    log.err("{}: synchronization failed, no agreement (sources={} samples={})", .{
                         self.replica,
                         sources_sampled,
                         self.window.samples,
@@ -377,9 +378,9 @@ pub fn Clock(comptime Time: type) type {
                 self.replica,
                 new_interval.sources_true,
                 self.epoch.sources.len,
-                fmtDurationSigned(new_interval.lower_bound),
-                fmtDurationSigned(new_interval.upper_bound),
-                fmtDurationSigned(new_interval.upper_bound - new_interval.lower_bound),
+                fmt.fmtDurationSigned(new_interval.lower_bound),
+                fmt.fmtDurationSigned(new_interval.upper_bound),
+                fmt.fmtDurationSigned(new_interval.upper_bound - new_interval.lower_bound),
             });
 
             const elapsed = @intCast(i64, self.epoch.elapsed(self));
@@ -393,12 +394,12 @@ pub fn Clock(comptime Time: type) type {
                 if (delta < std.time.ns_per_ms) {
                     log.info("{}: system time is {} behind", .{
                         self.replica,
-                        fmtDurationSigned(delta),
+                        fmt.fmtDurationSigned(delta),
                     });
                 } else {
                     log.err("{}: system time is {} behind, clamping system time to cluster time", .{
                         self.replica,
-                        fmtDurationSigned(delta),
+                        fmt.fmtDurationSigned(delta),
                     });
                 }
             } else {
@@ -406,12 +407,12 @@ pub fn Clock(comptime Time: type) type {
                 if (delta < std.time.ns_per_ms) {
                     log.info("{}: system time is {} ahead", .{
                         self.replica,
-                        fmtDurationSigned(delta),
+                        fmt.fmtDurationSigned(delta),
                     });
                 } else {
                     log.err("{}: system time is {} ahead, clamping system time to cluster time", .{
                         self.replica,
-                        fmtDurationSigned(delta),
+                        fmt.fmtDurationSigned(delta),
                     });
                 }
             }
@@ -450,25 +451,6 @@ pub fn Clock(comptime Time: type) type {
     };
 }
 
-/// Return a Formatter for a signed number of nanoseconds according to magnitude:
-/// [#y][#w][#d][#h][#m]#[.###][n|u|m]s
-pub fn fmtDurationSigned(ns: i64) std.fmt.Formatter(formatDurationSigned) {
-    return .{ .data = ns };
-}
-
-fn formatDurationSigned(
-    ns: i64,
-    comptime fmt: []const u8,
-    options: std.fmt.FormatOptions,
-    writer: anytype,
-) !void {
-    if (ns < 0) {
-        try writer.print("-{}", .{std.fmt.fmtDuration(@intCast(u64, -ns))});
-    } else {
-        try writer.print("{}", .{std.fmt.fmtDuration(@intCast(u64, ns))});
-    }
-}
-
 const testing = std.testing;
 const OffsetType = @import("../test/time.zig").OffsetType;
 const DeterministicTime = @import("../test/time.zig").Time;
@@ -482,7 +464,7 @@ const ClockUnitTestContainer = struct {
     learn_interval: u64 = 5,
 
     pub fn init(
-        allocator: *std.mem.Allocator,
+        allocator: std.mem.Allocator,
         offset_type: OffsetType,
         offset_coefficient_A: i64,
         offset_coefficient_B: i64,
@@ -581,7 +563,7 @@ const ClockUnitTestContainer = struct {
 };
 
 test "ideal clocks get clamped to cluster time" {
-    std.testing.log_level = .crit;
+    std.testing.log_level = .err;
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
     const allocator = &arena.allocator;
@@ -646,7 +628,10 @@ const ClockSimulator = struct {
         clock_simulator: *ClockSimulator,
 
         /// PacketSimulator requires this function, but we don't actually have anything to deinit.
-        pub fn deinit(packet: *const Packet, path: Path) void {}
+        pub fn deinit(packet: *const Packet, path: Path) void {
+            _ = packet;
+            _ = path;
+        }
     };
 
     const Options = struct {
@@ -655,14 +640,14 @@ const ClockSimulator = struct {
         network_options: PacketSimulatorOptions,
     };
 
-    allocator: *std.mem.Allocator,
+    allocator: std.mem.Allocator,
     options: Options,
     ticks: u64 = 0,
     network: PacketSimulator(Packet),
     clocks: []DeterministicClock,
     prng: std.rand.DefaultPrng,
 
-    pub fn init(allocator: *std.mem.Allocator, options: Options) !ClockSimulator {
+    pub fn init(allocator: std.mem.Allocator, options: Options) !ClockSimulator {
         var self = ClockSimulator{
             .allocator = allocator,
             .options = options,
@@ -753,13 +738,12 @@ const ClockSimulator = struct {
 };
 
 test "fuzz test" {
-    std.testing.log_level = .emerg; // silence all clock logs
+    std.testing.log_level = .err; // silence all clock logs
     var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena_allocator.deinit();
     const allocator = &arena_allocator.allocator;
     const ticks_max: u64 = 1_000_000;
     const clock_count: u8 = 3;
-    const test_delta_time: u64 = std.time.ns_per_s / 2;
     const SystemTime = @import("../time.zig").Time;
     var system_time = SystemTime{};
     var seed = @intCast(u64, system_time.realtime());
@@ -787,7 +771,6 @@ test "fuzz test" {
     while (simulator.ticks < ticks_max) {
         simulator.tick();
 
-        const test_time: u64 = simulator.ticks * test_delta_time;
         for (simulator.clocks) |*clock, index| {
             var offset = clock.time.offset(simulator.ticks);
             var abs_offset = if (offset >= 0) @intCast(u64, offset) else @intCast(u64, -offset);
@@ -818,11 +801,11 @@ test "fuzz test" {
         clock_count,
     });
     std.debug.print("absolute clock offsets with respect to test time:\n", .{});
-    std.debug.print("maximum={}\n", .{fmtDurationSigned(@intCast(i64, max_clock_offset))});
-    std.debug.print("minimum={}\n", .{fmtDurationSigned(@intCast(i64, min_clock_offset))});
+    std.debug.print("maximum={}\n", .{fmt.fmtDurationSigned(@intCast(i64, max_clock_offset))});
+    std.debug.print("minimum={}\n", .{fmt.fmtDurationSigned(@intCast(i64, min_clock_offset))});
     std.debug.print("\nabsolute synchronization errors between clocks:\n", .{});
-    std.debug.print("maximum={}\n", .{fmtDurationSigned(@intCast(i64, max_sync_error))});
-    std.debug.print("minimum={}\n", .{fmtDurationSigned(@intCast(i64, min_sync_error))});
+    std.debug.print("maximum={}\n", .{fmt.fmtDurationSigned(@intCast(i64, max_sync_error))});
+    std.debug.print("minimum={}\n", .{fmt.fmtDurationSigned(@intCast(i64, min_sync_error))});
     std.debug.print("clock ticks without synchronization={d}\n", .{
         clock_ticks_without_synchronization,
     });

package/src/tigerbeetle/src/vsr/journal.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 const math = std.math;
@@ -120,7 +121,7 @@ pub fn Journal(comptime Replica: type, comptime Storage: type) type {
         recovering: bool = false,
 
         pub fn init(
-            allocator: *Allocator,
+            allocator: Allocator,
             storage: *Storage,
             replica: u8,
             size: u64,
@@ -201,7 +202,7 @@ pub fn Journal(comptime Replica: type, comptime Storage: type) type {
             return self;
         }
 
-        pub fn deinit(self: *Self, allocator: *Allocator) void {
+        pub fn deinit(self: *Self, allocator: Allocator) void {
             const replica = @fieldParentPtr(Replica, "journal", self);
 
             self.dirty.deinit(allocator);
@@ -278,7 +279,7 @@ pub fn Journal(comptime Replica: type, comptime Storage: type) type {
             return self.entry_for_op(header.op + 1);
         }
 
-        pub fn next_offset(self: *Self, header: *const Header) u64 {
+        pub fn next_offset(header: *const Header) u64 {
             // TODO Snapshots
             assert(header.command == .prepare);
             return header.offset + vsr.sector_ceil(header.size);
@@ -860,7 +861,7 @@ pub fn Journal(comptime Replica: type, comptime Storage: type) type {
             const sectors = message.buffer[0..vsr.sector_ceil(message.header.size)];
             assert(message.header.offset + sectors.len <= self.size_circular_buffer);
 
-            if (std.builtin.mode == .Debug) {
+            if (builtin.mode == .Debug) {
                 // Assert that any sector padding has already been zeroed:
                 var sum_of_sector_padding_bytes: u32 = 0;
                 for (sectors[message.header.size..]) |byte| sum_of_sector_padding_bytes += byte;
@@ -1227,7 +1228,7 @@ pub const BitSet = struct {
     /// The number of bits set (updated incrementally as bits are set or cleared):
     len: u64 = 0,
 
-    fn init(allocator: *Allocator, count: u64) !BitSet {
+    fn init(allocator: Allocator, count: u64) !BitSet {
         const bits = try allocator.alloc(bool, count);
         errdefer allocator.free(bits);
         std.mem.set(bool, bits, false);
@@ -1235,7 +1236,7 @@ pub const BitSet = struct {
         return BitSet{ .bits = bits };
     }
 
-    fn deinit(self: *BitSet, allocator: *Allocator) void {
+    fn deinit(self: *BitSet, allocator: Allocator) void {
         allocator.free(self.bits);
     }
 

package/src/tigerbeetle/src/vsr/marzullo.zig

@@ -117,6 +117,8 @@ pub const Marzullo = struct {
     /// upper bound. Alternatively, if such pathological overlaps are considered objectionable then
     /// they can be avoided by sorting the upper bound before the lower bound.
     fn less_than(context: void, a: Tuple, b: Tuple) bool {
+        _ = context;
+
         if (a.offset < b.offset) return true;
         if (b.offset < a.offset) return false;
         if (a.bound == .lower and b.bound == .upper) return true;
@@ -130,9 +132,10 @@ pub const Marzullo = struct {
 };
 
 fn test_smallest_interval(bounds: []const i64, smallest_interval: Marzullo.Interval) !void {
-    var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer arena_allocator.deinit();
-    const allocator = &arena_allocator.allocator;
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+
+    const allocator = arena.allocator();
 
     var tuples = try allocator.alloc(Marzullo.Tuple, bounds.len);
     for (bounds) |bound, i| {

package/src/tigerbeetle/src/vsr/replica.zig

@@ -197,7 +197,7 @@ pub fn Replica(
         on_change_state: ?fn (replica: *Self) void = null,
 
         pub fn init(
-            allocator: *Allocator,
+            allocator: Allocator,
             cluster: u32,
             replica_count: u8,
             replica: u8,
@@ -239,7 +239,7 @@ pub fn Replica(
 
             var client_table: ClientTable = .{};
             errdefer client_table.deinit(allocator);
-            try client_table.ensureCapacity(allocator, @intCast(u32, config.clients_max));
+            try client_table.ensureTotalCapacity(allocator, @intCast(u32, config.clients_max));
             assert(client_table.capacity() >= config.clients_max);
 
             var init_prepare = Header{
@@ -363,7 +363,7 @@ pub fn Replica(
 
         /// Free all memory and unref all messages held by the replica
         /// This does not deinitialize the StateMachine, MessageBus, Storage, or Time
-        pub fn deinit(self: *Self, allocator: *Allocator) void {
+        pub fn deinit(self: *Self, allocator: Allocator) void {
             self.journal.deinit(allocator);
             self.clock.deinit(allocator);
 
@@ -452,7 +452,7 @@ pub fn Replica(
             });
 
             if (message.header.invalid()) |reason| {
-                log.alert("{}: on_message: invalid ({s})", .{ self.replica, reason });
+                log.err("{}: on_message: invalid ({s})", .{ self.replica, reason });
                 return;
             }
 
@@ -506,7 +506,7 @@ pub fn Replica(
             }
 
             if (self.loopback_queue) |loopback_message| {
-                log.emerg("{}: on_message: on_{s}() queued a {s} loopback message with no flush", .{
+                log.err("{}: on_message: on_{s}() queued a {s} loopback message with no flush", .{
                     self.replica,
                     @tagName(message.header.command),
                     @tagName(loopback_message.header.command),
@@ -581,7 +581,7 @@ pub fn Replica(
             assert(message.header.view <= self.view); // The client's view may be behind ours.
 
             const realtime = self.clock.realtime_synchronized() orelse {
-                log.alert("{}: on_request: dropping (clock not synchronized)", .{self.replica});
+                log.err("{}: on_request: dropping (clock not synchronized)", .{self.replica});
                 return;
             };
 
@@ -599,7 +599,7 @@ pub fn Replica(
             message.header.view = self.view;
             message.header.op = self.op + 1;
             message.header.commit = self.commit_max;
-            message.header.offset = self.journal.next_offset(latest_entry);
+            message.header.offset = Journal.next_offset(latest_entry);
             message.header.replica = self.replica;
             message.header.command = .prepare;
 
@@ -885,7 +885,7 @@ pub fn Replica(
                 if (self.message_bus.get_message()) |available| {
                     self.message_bus.unref(available);
                 } else {
-                    log.alert("{}: on_start_view_change: waiting for message for do_view_change", .{
+                    log.err("{}: on_start_view_change: waiting for message for do_view_change", .{
                         self.replica,
                     });
                     return;
@@ -986,7 +986,7 @@ pub fn Replica(
                     assert(replica_view_normal < m.header.view);
 
                     var replica_latest = Header.reserved();
-                    self.set_latest_op(self.message_body_as_headers(m), &replica_latest);
+                    set_latest_op(self.message_body_as_headers(m), &replica_latest);
                     assert(replica_latest.op == m.header.op);
 
                     log.debug(
@@ -1062,7 +1062,7 @@ pub fn Replica(
             assert(message.header.view == self.view);
 
             var latest = Header.reserved();
-            self.set_latest_op(self.message_body_as_headers(message), &latest);
+            set_latest_op(self.message_body_as_headers(message), &latest);
             assert(latest.op == message.header.op);
 
             self.set_latest_op_and_k(&latest, message.header.commit, "on_start_view");
@@ -1098,7 +1098,7 @@ pub fn Replica(
             assert(self.leader());
 
             const start_view = self.create_view_change_message(.start_view) orelse {
-                log.alert("{}: on_request_start_view: dropping start_view, no message available", .{
+                log.err("{}: on_request_start_view: dropping start_view, no message available", .{
                     self.replica,
                 });
                 return;
@@ -1127,7 +1127,7 @@ pub fn Replica(
             }
 
             const response = self.message_bus.get_message() orelse {
-                log.alert("{}: on_recovery: ignoring (waiting for message)", .{self.replica});
+                log.err("{}: on_recovery: ignoring (waiting for message)", .{self.replica});
                 return;
             };
             defer self.message_bus.unref(response);
@@ -1172,7 +1172,10 @@ pub fn Replica(
         }
 
         /// TODO This is a work in progress (out of scope for the bounty)
-        fn on_recovery_response(self: *Self, message: *Message) void {}
+        fn on_recovery_response(self: *Self, message: *Message) void {
+            _ = self;
+            _ = message;
+        }
 
         fn on_request_prepare(self: *Self, message: *const Message) void {
             if (self.ignore_repair_message(message)) return;
@@ -1274,7 +1277,7 @@ pub fn Replica(
             assert(message.header.replica != self.replica);
 
             const response = self.message_bus.get_message() orelse {
-                log.alert("{}: on_request_headers: ignoring (op={}..{}, no message available)", .{
+                log.err("{}: on_request_headers: ignoring (op={}..{}, no message available)", .{
                     self.replica,
                     message.header.commit,
                     message.header.op,
@@ -1467,7 +1470,7 @@ pub fn Replica(
             assert(self.status == .normal);
             assert(self.leader());
 
-            const prepare = self.pipeline.peek_ptr().?;
+            const prepare = self.pipeline.head_ptr().?;
             assert(prepare.message.header.command == .prepare);
 
             if (prepare.ok_quorum_received) {
@@ -1513,7 +1516,7 @@ pub fn Replica(
                 return;
             }
 
-            self.prepare_timeout.backoff(&self.prng);
+            self.prepare_timeout.backoff(self.prng.random());
 
             assert(waiting_len <= self.replica_count);
             for (waiting[0..waiting_len]) |replica| {
@@ -1682,7 +1685,6 @@ pub fn Replica(
 
         /// Returns whether `b` succeeds `a` by having a newer view or same view and newer op.
         fn ascending_viewstamps(
-            self: *Self,
             a: *const Header,
             b: *const Header,
         ) bool {
@@ -1834,7 +1836,7 @@ pub fn Replica(
 
             // TODO We can optimize this to commit into the client table reply if it exists.
             const reply = self.message_bus.get_message() orelse {
-                log.alert("{}: commit_ops_commit: waiting for message", .{self.replica});
+                log.err("{}: commit_ops_commit: waiting for message", .{self.replica});
                 return;
             };
             defer self.message_bus.unref(reply);
@@ -1925,7 +1927,7 @@ pub fn Replica(
             assert(self.leader());
             assert(self.pipeline.count > 0);
 
-            while (self.pipeline.peek_ptr()) |prepare| {
+            while (self.pipeline.head_ptr()) |prepare| {
                 assert(self.pipeline.count > 0);
                 assert(self.commit_min == self.commit_max);
                 assert(self.commit_max + self.pipeline.count == self.op);
@@ -1947,7 +1949,7 @@ pub fn Replica(
                 // TODO We can optimize this to commit into the client table reply if it exists.
                 const reply = self.message_bus.get_message() orelse {
                     // Eventually handled by on_prepare_timeout().
-                    log.alert("{}: commit_pipeline: waiting for message", .{self.replica});
+                    log.err("{}: commit_pipeline: waiting for message", .{self.replica});
                     return;
                 };
                 defer self.message_bus.unref(reply);
@@ -2028,13 +2030,14 @@ pub fn Replica(
             assert(request == 0);
 
             // For correctness, it's critical that all replicas evict deterministically:
-            // We cannot depend on `HashMap.capacity()` since `HashMap.ensureCapacity()` may change
-            // across different versions of the Zig std lib. We therefore rely on `config.clients_max`,
-            // which must be the same across all replicas, and must not change after initing a cluster.
-            // We also do not depend on `HashMap.valueIterator()` being deterministic here. However, we
-            // do require that all entries have different commit numbers and are at least iterated.
+            // We cannot depend on `HashMap.capacity()` since `HashMap.ensureTotalCapacity()` may
+            // change across versions of the Zig std lib. We therefore rely on `config.clients_max`,
+            // which must be the same across all replicas, and must not change after initializing a
+            // cluster.
+            // We also do not depend on `HashMap.valueIterator()` being deterministic here. However,
+            // we do require that all entries have different commit numbers and are iterated.
             // This ensures that we will always pick the entry with the oldest commit number.
-            // We also double-check that a client has only one entry in the hash map (or it's buggy).
+            // We also check that a client has only one entry in the hash map (or it's buggy).
             const clients = self.client_table.count();
             assert(clients <= config.clients_max);
             if (clients == config.clients_max) {
@@ -2059,7 +2062,7 @@ pub fn Replica(
                     }
                 }
                 assert(iterated == clients);
-                log.alert("{}: create_client_table_entry: clients={}/{} evicting client={}", .{
+                log.err("{}: create_client_table_entry: clients={}/{} evicting client={}", .{
                     self.replica,
                     clients,
                     config.clients_max,
@@ -2453,11 +2456,11 @@ pub fn Replica(
                     // Fall through below to check if we should resend the .register session reply.
                 } else if (entry.session > message.header.context) {
                     // The client must not reuse the ephemeral client ID when registering a new session.
-                    log.alert("{}: on_request: ignoring older session (client bug)", .{self.replica});
+                    log.err("{}: on_request: ignoring older session (client bug)", .{self.replica});
                     return true;
                 } else if (entry.session < message.header.context) {
                     // This cannot be because of a partition since we check the client's view number.
-                    log.alert("{}: on_request: ignoring newer session (client bug)", .{self.replica});
+                    log.err("{}: on_request: ignoring newer session (client bug)", .{self.replica});
                     return true;
                 }
 
@@ -2472,7 +2475,7 @@ pub fn Replica(
                         self.message_bus.send_message_to_client(message.header.client, entry.reply);
                         return true;
                     } else {
-                        log.alert("{}: on_request: request collision (client bug)", .{self.replica});
+                        log.err("{}: on_request: request collision (client bug)", .{self.replica});
                         return true;
                     }
                 } else if (entry.reply.header.request + 1 == message.header.request) {
@@ -2482,11 +2485,11 @@ pub fn Replica(
                         return false;
                     } else {
                         // The client may have only one request inflight at a time.
-                        log.alert("{}: on_request: ignoring new request (client bug)", .{self.replica});
+                        log.err("{}: on_request: ignoring new request (client bug)", .{self.replica});
                         return true;
                     }
                 } else {
-                    log.alert("{}: on_request: ignoring newer request (client bug)", .{self.replica});
+                    log.err("{}: on_request: ignoring newer request (client bug)", .{self.replica});
                     return true;
                 }
             } else if (message.header.operation == .register) {
@@ -2573,7 +2576,7 @@ pub fn Replica(
                     log.debug("{}: on_request: ignoring (already preparing)", .{self.replica});
                     return true;
                 } else {
-                    log.alert("{}: on_request: ignoring (client forked)", .{self.replica});
+                    log.err("{}: on_request: ignoring (client forked)", .{self.replica});
                     return true;
                 }
             }
@@ -2682,7 +2685,7 @@ pub fn Replica(
             assert(self.op + 1 == header.op);
         }
 
-        fn message_body_as_headers(self: *Self, message: *const Message) []Header {
+        fn message_body_as_headers(_: *Self, message: *const Message) []Header {
             // TODO Assert message commands that we expect this to be called for.
             assert(message.header.size > @sizeOf(Header)); // Body must contain at least one header.
             return std.mem.bytesAsSlice(Header, message.buffer[@sizeOf(Header)..message.header.size]);
@@ -2701,8 +2704,8 @@ pub fn Replica(
             if (a.view == b.view and a.op + 1 == b.op and a.checksum != b.parent) {
                 assert(a.valid_checksum());
                 assert(b.valid_checksum());
-                log.emerg("{}: panic_if_hash_chain_would_break: a: {}", .{ self.replica, a });
-                log.emerg("{}: panic_if_hash_chain_would_break: b: {}", .{ self.replica, b });
+                log.err("{}: panic_if_hash_chain_would_break: a: {}", .{ self.replica, a });
+                log.err("{}: panic_if_hash_chain_would_break: b: {}", .{ self.replica, b });
                 @panic("hash chain would break");
             }
         }
@@ -3071,7 +3074,7 @@ pub fn Replica(
                 while (op > 0) {
                     op -= 1;
                     if (self.journal.entry_for_op(op)) |neighbor| {
-                        if (self.journal.next_offset(neighbor) > header.offset) return true;
+                        if (Journal.next_offset(neighbor) > header.offset) return true;
                         break;
                     }
                 }
@@ -3081,7 +3084,7 @@ pub fn Replica(
                 var op: u64 = header.op + 1;
                 while (op <= self.op) : (op += 1) {
                     if (self.journal.entry_for_op(op)) |neighbor| {
-                        if (self.journal.next_offset(header) > neighbor.offset) return true;
+                        if (Journal.next_offset(header) > neighbor.offset) return true;
                         break;
                     }
                 }
@@ -3581,7 +3584,7 @@ pub fn Replica(
             assert(count_start_view_change >= self.quorum_view_change - 1);
 
             const message = self.create_view_change_message(.do_view_change) orelse {
-                log.alert("{}: send_do_view_change: waiting for message", .{self.replica});
+                log.err("{}: send_do_view_change: waiting for message", .{self.replica});
                 return;
             };
             defer self.message_bus.unref(message);
@@ -3600,7 +3603,7 @@ pub fn Replica(
             assert(self.status == .normal);
             assert(self.leader());
 
-            log.alert("{}: too many sessions, sending eviction message to client={}", .{
+            log.err("{}: too many sessions, sending eviction message to client={}", .{
                 self.replica,
                 client,
             });
@@ -3616,7 +3619,7 @@ pub fn Replica(
 
         fn send_header_to_client(self: *Self, client: u128, header: Header) void {
             const message = self.create_message_from_header(header) orelse {
-                log.alert("{}: no header-only message available, dropping message to client {}", .{
+                log.err("{}: no header-only message available, dropping message to client {}", .{
                     self.replica,
                     client,
                 });
@@ -3629,7 +3632,7 @@ pub fn Replica(
 
         fn send_header_to_other_replicas(self: *Self, header: Header) void {
             const message = self.create_message_from_header(header) orelse {
-                log.alert("{}: no header-only message available, dropping message to replicas", .{
+                log.err("{}: no header-only message available, dropping message to replicas", .{
                     self.replica,
                 });
                 return;
@@ -3646,7 +3649,7 @@ pub fn Replica(
 
         fn send_header_to_replica(self: *Self, replica: u8, header: Header) void {
             const message = self.create_message_from_header(header) orelse {
-                log.alert("{}: no header-only message available, dropping message to replica {}", .{
+                log.err("{}: no header-only message available, dropping message to replica {}", .{
                     self.replica,
                     replica,
                 });
@@ -3675,7 +3678,7 @@ pub fn Replica(
             });
 
             if (message.header.invalid()) |reason| {
-                log.emerg("{}: send_message_to_replica: invalid ({s})", .{ self.replica, reason });
+                log.err("{}: send_message_to_replica: invalid ({s})", .{ self.replica, reason });
                 @panic("send_message_to_replica: invalid message");
             }
 
@@ -3764,7 +3767,7 @@ pub fn Replica(
                     assert(replica == self.leader_index(self.view));
                 },
                 else => {
-                    log.notice("{}: send_message_to_replica: TODO {s}", .{
+                    log.info("{}: send_message_to_replica: TODO {s}", .{
                         self.replica,
                         @tagName(message.header.command),
                     });
@@ -3781,7 +3784,7 @@ pub fn Replica(
 
         /// Finds the header with the highest op number in a slice of headers from a replica.
         /// Searches only by op number to find the highest `self.op for the replica.
-        fn set_latest_op(self: *Self, headers: []Header, latest: *Header) void {
+        fn set_latest_op(headers: []Header, latest: *Header) void {
             switch (latest.command) {
                 .reserved, .prepare => assert(latest.valid_checksum()),
                 else => unreachable,
@@ -3910,7 +3913,7 @@ pub fn Replica(
             assert(self.nack_prepare_op == null);
 
             const start_view = self.create_view_change_message(.start_view) orelse {
-                log.alert("{}: start_view_as_the_new_leader: waiting for message", .{self.replica});
+                log.err("{}: start_view_as_the_new_leader: waiting for message", .{self.replica});
                 return;
             };
             defer self.message_bus.unref(start_view);
@@ -4112,7 +4115,7 @@ pub fn Replica(
                 if (self.journal.entry_for_op_exact(op)) |a| {
                     assert(a.op + 1 == b.op);
                     if (a.checksum == b.parent) {
-                        assert(self.ascending_viewstamps(a, b));
+                        assert(ascending_viewstamps(a, b));
                         b = a;
                     } else {
                         log.debug("{}: valid_hash_chain_between: break: A: {}", .{ self.replica, a });