tigerbeetle-node 0.11.1 → 0.11.3

package/dist/.client.node.sha256

@@ -0,0 +1 @@
+cd58e7f1a46beef96d550cfb8423c01542980ff7f9832127e73ad2e5cd0e3a63  dist/client.node

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tigerbeetle-node",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "TigerBeetle Node.js client",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -13,6 +13,7 @@
     "LICENSE",
     "README.md",
     "dist",
+    "dist/.client.node.sha256",
     "!dist/client.node",
     "package.json",
     "package-lock.json",

package/src/tigerbeetle/src/cli.zig

@@ -1,16 +1,18 @@
 const std = @import("std");
 const assert = std.debug.assert;
 const fmt = std.fmt;
+const math = std.math;
 const mem = std.mem;
 const meta = std.meta;
 const net = std.net;
 const os = std.os;
 
 const config = @import("config.zig");
+const tigerbeetle = @import("tigerbeetle.zig");
 const vsr = @import("vsr.zig");
 const IO = @import("io.zig").IO;
 
-// TODO Document --memory
+// TODO Document --cache-accounts, --cache-transfers, --cache-transfers-posted
 const usage = fmt.comptimePrint(
     \\Usage:
     \\
@@ -84,7 +86,9 @@ pub const Command = union(enum) {
     start: struct {
         args_allocated: std.ArrayList([:0]const u8),
         addresses: []net.Address,
-        memory: u64,
+        cache_accounts: u32,
+        cache_transfers: u32,
+        cache_transfers_posted: u32,
         path: [:0]const u8,
     },
     version: struct {
@@ -110,7 +114,9 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
     var cluster: ?[]const u8 = null;
     var replica: ?[]const u8 = null;
     var addresses: ?[]const u8 = null;
-    var memory: ?[]const u8 = null;
+    var cache_accounts: ?[]const u8 = null;
+    var cache_transfers: ?[]const u8 = null;
+    var cache_transfers_posted: ?[]const u8 = null;
     var verbose: ?bool = null;
 
     var args = try std.process.argsWithAllocator(allocator);
@@ -140,14 +146,25 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
         try args_allocated.append(arg);
 
         if (mem.startsWith(u8, arg, "--cluster")) {
+            if (command != .format) fatal("--cluster: supported only by 'format' command", .{});
             cluster = parse_flag("--cluster", arg);
         } else if (mem.startsWith(u8, arg, "--replica")) {
+            if (command != .format) fatal("--replica: supported only by 'format' command", .{});
             replica = parse_flag("--replica", arg);
         } else if (mem.startsWith(u8, arg, "--addresses")) {
+            if (command != .start) fatal("--addresses: supported only by 'start' command", .{});
             addresses = parse_flag("--addresses", arg);
-        } else if (mem.startsWith(u8, arg, "--memory")) {
-            memory = parse_flag("--memory", arg);
+        } else if (mem.startsWith(u8, arg, "--cache-accounts")) {
+            if (command != .start) fatal("--cache-accounts: supported only by 'start' command", .{});
+            cache_accounts = parse_flag("--cache-accounts", arg);
+        } else if (mem.startsWith(u8, arg, "--cache-transfers")) {
+            if (command != .start) fatal("--cache-transfers: supported only by 'start' command", .{});
+            cache_transfers = parse_flag("--cache-transfers", arg);
+        } else if (mem.startsWith(u8, arg, "--cache-transfers-posted")) {
+            if (command != .start) fatal("--cache-transfers-posted: supported only by 'start' command", .{});
+            cache_transfers_posted = parse_flag("--cache-transfers-posted", arg);
         } else if (mem.eql(u8, arg, "--verbose")) {
+            if (command != .version) fatal("--verbose: supported only by 'version' command", .{});
             verbose = true;
         } else if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
             std.io.getStdOut().writeAll(usage) catch os.exit(1);
@@ -155,6 +172,7 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
         } else if (mem.startsWith(u8, arg, "-")) {
             fatal("unexpected argument: '{s}'", .{arg});
         } else if (path == null) {
+            if (!(command == .format or command == .start)) fatal("unexpected path", .{});
             path = arg;
         } else {
             fatal("unexpected argument: '{s}' (must start with '--')", .{arg});
@@ -163,21 +181,11 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
 
     switch (command) {
         .version => {
-            if (addresses != null) fatal("--addresses: supported only by 'start' command", .{});
-            if (memory != null) fatal("--memory: supported only by 'start' command", .{});
-            if (cluster != null) fatal("--cluster: supported only by 'format' command", .{});
-            if (replica != null) fatal("--replica: supported only by 'format' command", .{});
-            if (path != null) fatal("unexpected path", .{});
-
             return Command{
                 .version = .{ .verbose = verbose orelse false },
             };
         },
         .format => {
-            if (addresses != null) fatal("--addresses: supported only by 'start' command", .{});
-            if (memory != null) fatal("--memory: supported only by 'start' command", .{});
-            if (verbose != null) fatal("--verbose: supported only by 'version' command", .{});
-
             return Command{
                 .format = .{
                     .args_allocated = args_allocated,
@@ -188,10 +196,6 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
             };
         },
         .start => {
-            if (cluster != null) fatal("--cluster: supported only by 'format' command", .{});
-            if (replica != null) fatal("--replica: supported only by 'format' command", .{});
-            if (verbose != null) fatal("--verbose: supported only by 'version' command", .{});
-
             return Command{
                 .start = .{
                     .args_allocated = args_allocated,
@@ -199,7 +203,21 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
                         allocator,
                         addresses orelse fatal("required: --addresses", .{}),
                     ),
-                    .memory = if (memory) |m| parse_size(m) else config.memory_size_max_default,
+                    .cache_accounts = parse_size_to_count(
+                        tigerbeetle.Account,
+                        cache_accounts,
+                        config.cache_accounts_max,
+                    ),
+                    .cache_transfers = parse_size_to_count(
+                        tigerbeetle.Transfer,
+                        cache_transfers,
+                        config.cache_transfers_max,
+                    ),
+                    .cache_transfers_posted = parse_size_to_count(
+                        u256, // TODO(#264): Use actual type here, once exposed.
+                        cache_transfers_posted,
+                        config.cache_transfers_posted_max,
+                    ),
                     .path = path orelse fatal("required: <path>", .{}),
                 },
             };
@@ -323,6 +341,30 @@ test "parse_size" {
     try expectEqual(@as(u64, 1000 * kib), parse_size("  1000  kb "));
 }
 
+/// Given a limit like `10GiB`, return the maximum power-of-two count of `T`s
+/// that can fit in the limit.
+fn parse_size_to_count(comptime T: type, string_opt: ?[]const u8, comptime default: u32) u32 {
+    var result: u32 = default;
+    if (string_opt) |string| {
+        const byte_size = parse_size(string);
+        const count_u64 = math.floorPowerOfTwo(u64, @divFloor(byte_size, @sizeOf(T)));
+        const count = math.cast(u32, count_u64) catch |err| switch (err) {
+            error.Overflow => fatal("size value is too large: '{s}'", .{string}),
+        };
+        if (count < 2048) fatal("size value is too small: '{s}'", .{string});
+        assert(count * @sizeOf(T) <= byte_size);
+
+        result = count;
+    }
+
+    // SetAssociativeCache requires a power-of-two cardinality and a minimal
+    // size.
+    assert(result >= 2048);
+    assert(math.isPowerOfTwo(result));
+
+    return result;
+}
+
 fn parse_replica(raw_replica: []const u8) u8 {
     comptime assert(config.replicas_max <= std.math.maxInt(u8));
     const replica = fmt.parseUnsigned(u8, raw_replica, 10) catch |err| switch (err) {

package/src/tigerbeetle/src/config.zig

@@ -1,8 +1,9 @@
 const std = @import("std");
 const assert = std.debug.assert;
-const tigerbeetle = @import("tigerbeetle.zig");
 const vsr = @import("vsr.zig");
 
+const build_options = @import("tigerbeetle_build_options");
+
 const Environment = enum {
     development,
     production,
@@ -64,7 +65,7 @@ pub const cache_transfers_max = switch (deployment_environment) {
 
 /// The maximum number of two-phase transfers to store in memory:
 /// This impacts the amount of memory allocated at initialization by the server.
-pub const cache_transfers_pending_max = cache_transfers_max;
+pub const cache_transfers_posted_max = cache_transfers_max;
 
 /// The maximum number of batch entries in the journal file:
 /// A batch entry may contain many transfers, so this is not a limit on the number of transfers.
@@ -331,6 +332,10 @@ pub const verify = true;
 pub const journal_size_headers = journal_slot_count * @sizeOf(vsr.Header);
 pub const journal_size_prepares = journal_slot_count * message_size_max;
 
+// Which backend to use for ./tracer.zig.
+// Default is `.none`.
+pub const tracer_backend = build_options.tracer_backend;
+
 // TODO Move these into a separate `config_valid.zig` which we import here:
 comptime {
     // vsr.parse_address assumes that config.address/config.port are valid.
@@ -383,7 +388,7 @@ comptime {
     // SetAssociativeCache requires a power-of-two cardinality.
     assert(std.math.isPowerOfTwo(cache_accounts_max));
     assert(std.math.isPowerOfTwo(cache_transfers_max));
-    assert(std.math.isPowerOfTwo(cache_transfers_pending_max));
+    assert(std.math.isPowerOfTwo(cache_transfers_posted_max));
 }
 
 pub const is_32_bit = @sizeOf(usize) == 4; // TODO Return a compile error if we are not 32-bit.

package/src/tigerbeetle/src/ewah.zig

@@ -160,6 +160,24 @@ pub fn ewah(comptime Word: type) type {
     };
 }
 
+test "ewah encode→decode cycle" {
+    const fuzz = @import("./ewah_fuzz.zig");
+    var prng = std.rand.DefaultPrng.init(123);
+
+    inline for (.{ u8, u16, u32, u64, usize }) |Word| {
+        var decoded: [4096]Word = undefined;
+
+        std.mem.set(Word, &decoded, 0);
+        try fuzz.fuzz_encode_decode(Word, std.testing.allocator, &decoded);
+
+        std.mem.set(Word, &decoded, std.math.maxInt(Word));
+        try fuzz.fuzz_encode_decode(Word, std.testing.allocator, &decoded);
+
+        prng.random().bytes(std.mem.asBytes(&decoded));
+        try fuzz.fuzz_encode_decode(Word, std.testing.allocator, &decoded);
+    }
+}
+
 test "ewah Word=u8 decode→encode→decode" {
     try test_decode_with_word(u8);
 
@@ -179,35 +197,6 @@ test "ewah Word=u8 decode→encode→decode" {
     }
 }
 
-test "ewah Word=u8 encode→decode→encode" {
-    const codec = ewah(u8);
-
-    var seed: u64 = undefined;
-    try std.os.getrandom(mem.asBytes(&seed));
-
-    var prng = std.rand.DefaultPrng.init(seed);
-    const random = prng.random();
-
-    var decoded_expect: [4096]u8 = undefined;
-    var decoded_actual: [4096]u8 = undefined;
-
-    const encoded_actual = try std.testing.allocator.alignedAlloc(
-        u8,
-        @alignOf(u8),
-        codec.encode_size_max(decoded_expect.len),
-    );
-    defer std.testing.allocator.free(encoded_actual);
-
-    var t: usize = 0;
-    while (t < 100) : (t += 1) {
-        random.bytes(decoded_expect[0..]);
-        _ = codec.encode(decoded_expect[0..], encoded_actual);
-        const decoded_actual_length = codec.decode(encoded_actual[0..], decoded_actual[0..]);
-        try std.testing.expectEqual(decoded_expect.len, decoded_actual_length);
-        try std.testing.expectEqual(decoded_expect, decoded_actual);
-    }
-}
-
 test "ewah Word=u16" {
     try test_decode_with_word(u16);
 }

package/src/tigerbeetle/src/ewah_fuzz.zig

@@ -0,0 +1,128 @@
+//! Fuzz EWAH encode/decode cycle.
+const std = @import("std");
+const assert = std.debug.assert;
+const log = std.log.scoped(.fuzz_ewah);
+
+const ewah = @import("./ewah.zig");
+const fuzz = @import("./test/fuzz.zig");
+
+pub fn main() !void {
+    const allocator = std.testing.allocator;
+    const args = try fuzz.parse_fuzz_args(allocator);
+
+    inline for (.{ u8, u16, u32, u64, usize }) |Word| {
+        var prng = std.rand.DefaultPrng.init(args.seed);
+        const random = prng.random();
+
+        const decoded_size_max = @divExact(1024 * 1024, @sizeOf(Word));
+        const decoded_size = 1 + random.uintLessThan(usize, decoded_size_max);
+        const decoded = try allocator.alloc(Word, decoded_size);
+        defer allocator.free(decoded);
+
+        const decoded_bits_total = decoded_size * @bitSizeOf(Word);
+        const decoded_bits = random.uintLessThan(usize, decoded_bits_total);
+        generate_bits(random, std.mem.sliceAsBytes(decoded[0..decoded_size]), decoded_bits);
+
+        var context = try ContextType(Word).init(allocator, decoded.len);
+        defer context.deinit(allocator);
+
+        const encoded_size = try context.test_encode_decode(decoded);
+
+        log.info("word={} decoded={} encoded={} compression_ratio={d:.2} set={d:.2}", .{
+            Word,
+            decoded_size,
+            encoded_size,
+            @intToFloat(f64, decoded_size) / @intToFloat(f64, encoded_size),
+            @intToFloat(f64, decoded_bits) / @intToFloat(f64, decoded_bits_total),
+        });
+    }
+}
+
+pub fn fuzz_encode_decode(
+    comptime Word: type,
+    allocator: std.mem.Allocator,
+    decoded: []const Word,
+) !void {
+    var context = try ContextType(Word).init(allocator, decoded.len);
+    defer context.deinit(allocator);
+
+    _ = try context.test_encode_decode(decoded);
+}
+
+/// Modify `data` such that it has exactly `bits_set_total` randomly-chosen bits set,
+/// with the remaining bits unset.
+fn generate_bits(random: std.rand.Random, data: []u8, bits_set_total: usize) void {
+    const bits_total = data.len * @bitSizeOf(u8);
+    assert(bits_set_total <= bits_total);
+
+    // Start off full or empty to save some work.
+    const init_empty = bits_set_total < @divExact(bits_total, 2);
+    std.mem.set(u8, data, if (init_empty) @as(u8, 0) else std.math.maxInt(u8));
+
+    var bits_set = if (init_empty) 0 else bits_total;
+    while (bits_set != bits_set_total) {
+        const bit = random.uintLessThan(usize, bits_total);
+        const word = @divFloor(bit, @bitSizeOf(u8));
+        const mask = @as(u8, 1) << @intCast(std.math.Log2Int(u8), bit % @bitSizeOf(u8));
+
+        if (init_empty) {
+            if (data[word] & mask != 0) continue;
+            data[word] |= mask;
+            bits_set += 1;
+        } else {
+            if (data[word] & mask == 0) continue;
+            data[word] &= ~mask;
+            bits_set -= 1;
+        }
+    }
+}
+
+fn ContextType(comptime Word: type) type {
+    return struct {
+        const Self = @This();
+        const Codec = ewah.ewah(Word);
+
+        decoded_actual: []Word,
+        encoded_actual: []align(@alignOf(Word)) u8,
+
+        fn init(allocator: std.mem.Allocator, size_max: usize) !Self {
+            const decoded_actual = try allocator.alloc(Word, size_max);
+            errdefer allocator.free(decoded_actual);
+
+            const encoded_actual = try allocator.alignedAlloc(
+                u8,
+                @alignOf(Word),
+                Codec.encode_size_max(size_max),
+            );
+            errdefer allocator.free(encoded_actual);
+
+            return Self{
+                .decoded_actual = decoded_actual,
+                .encoded_actual = encoded_actual,
+            };
+        }
+
+        fn deinit(context: *Self, allocator: std.mem.Allocator) void {
+            allocator.free(context.decoded_actual);
+            allocator.free(context.encoded_actual);
+        }
+
+        fn test_encode_decode(context: Self, decoded_expect: []const Word) !usize {
+            assert(decoded_expect.len > 0);
+
+            const encoded_size = Codec.encode(decoded_expect, context.encoded_actual);
+            const decoded_actual_size = Codec.decode(
+                context.encoded_actual[0..encoded_size],
+                context.decoded_actual[0..],
+            );
+
+            try std.testing.expectEqual(decoded_expect.len, decoded_actual_size);
+            try std.testing.expectEqualSlices(
+                Word,
+                decoded_expect,
+                context.decoded_actual[0..decoded_actual_size],
+            );
+            return encoded_size;
+        }
+    };
+}

package/src/tigerbeetle/src/lsm/compaction.zig

@@ -36,6 +36,8 @@ const math = std.math;
 const assert = std.debug.assert;
 
 const log = std.log.scoped(.compaction);
+const tracer = @import("../tracer.zig");
+
 const config = @import("../config.zig");
 
 const GridType = @import("grid.zig").GridType;
@@ -120,6 +122,8 @@ pub fn CompactionType(
             done,
         };
 
+        tree_name: []const u8,
+
         grid: *Grid,
         grid_reservation: Grid.Reservation,
         range: Manifest.CompactionRange,
@@ -155,7 +159,9 @@ pub fn CompactionType(
 
         tables_output_count: usize = 0,
 
-        pub fn init(allocator: mem.Allocator) !Compaction {
+        tracer_slot: ?tracer.SpanStart = null,
+
+        pub fn init(allocator: mem.Allocator, tree_name: []const u8) !Compaction {
             var iterator_a = try IteratorA.init(allocator);
             errdefer iterator_a.deinit(allocator);
 
@@ -166,6 +172,8 @@ pub fn CompactionType(
             errdefer table_builder.deinit(allocator);
 
             return Compaction{
+                .tree_name = tree_name,
+
                 // Assigned by start()
                 .grid = undefined,
                 .grid_reservation = undefined,
@@ -216,6 +224,7 @@ pub fn CompactionType(
             assert(compaction.callback == null);
             assert(compaction.io_pending == 0);
             assert(!compaction.merge_done and compaction.merge_iterator == null);
+            assert(compaction.tracer_slot == null);
 
             assert(op_min % @divExact(config.lsm_batch_multiple, 2) == 0);
             assert(range.table_count > 0);
@@ -230,6 +239,8 @@ pub fn CompactionType(
             assert(drop_tombstones or level_b < config.lsm_levels - 1);
 
             compaction.* = .{
+                .tree_name = compaction.tree_name,
+
                 .grid = grid,
                 // Reserve enough blocks to write our output tables in the worst case, where:
                 // - no tombstones are dropped,
@@ -337,6 +348,15 @@ pub fn CompactionType(
 
             compaction.callback = callback;
 
+            tracer.start(
+                &compaction.tracer_slot,
+                .{ .tree = .{ .tree_name = compaction.tree_name } },
+                .{ .tree_compaction_tick = .{
+                    .tree_name = compaction.tree_name,
+                    .level_b = compaction.level_b,
+                } },
+            );
+
             // Generate fake IO to make sure io_pending doesn't reach zero multiple times from
             // IO being completed inline down below.
             // The fake IO is immediately resolved and triggers the cpu_merge_start if all
@@ -405,6 +425,16 @@ pub fn CompactionType(
             assert(compaction.io_pending == 0);
             assert(!compaction.merge_done);
 
+            var tracer_slot: ?tracer.SpanStart = null;
+            tracer.start(
+                &tracer_slot,
+                .{ .tree = .{ .tree_name = compaction.tree_name } },
+                .{ .tree_compaction_merge = .{
+                    .tree_name = compaction.tree_name,
+                    .level_b = compaction.level_b,
+                } },
+            );
+
             // Create the merge iterator only when we can peek() from the read iterators.
             // This happens after IO for the first reads complete.
             if (compaction.merge_iterator == null) {
@@ -422,6 +452,23 @@ pub fn CompactionType(
                 compaction.cpu_merge_finish();
             }
 
+            tracer.end(
+                &tracer_slot,
+                .{ .tree = .{ .tree_name = compaction.tree_name } },
+                .{ .tree_compaction_merge = .{
+                    .tree_name = compaction.tree_name,
+                    .level_b = compaction.level_b,
+                } },
+            );
+            tracer.end(
+                &compaction.tracer_slot,
+                .{ .tree = .{ .tree_name = compaction.tree_name } },
+                .{ .tree_compaction_tick = .{
+                    .tree_name = compaction.tree_name,
+                    .level_b = compaction.level_b,
+                } },
+            );
+
             // TODO Implement pacing here by deciding if we should do another compact_tick()
             // instead of invoking the callback, using compaction.range.table_count as the heuristic.
 
@@ -560,6 +607,7 @@ pub fn CompactionType(
             assert(compaction.callback == null);
             assert(compaction.io_pending == 0);
             assert(compaction.merge_done);
+            assert(compaction.tracer_slot == null);
 
             // TODO(Beat Pacing) This should really be where the compaction callback is invoked,
             // but currently that can occur multiple times per beat.

package/src/tigerbeetle/src/lsm/forest_fuzz.zig

@@ -6,7 +6,9 @@ const assert = std.debug.assert;
 const config = @import("../config.zig");
 const fuzz = @import("../test/fuzz.zig");
 const vsr = @import("../vsr.zig");
+
 const log = std.log.scoped(.lsm_forest_fuzz);
+const tracer = @import("../tracer.zig");
 
 const MessagePool = @import("../message_pool.zig").MessagePool;
 const Transfer = @import("../tigerbeetle.zig").Transfer;
@@ -395,6 +397,9 @@ pub fn generate_fuzz_ops(random: std.rand.Random) ![]const FuzzOp {
 }
 
 pub fn main() !void {
+    try tracer.init(allocator);
+    defer tracer.deinit(allocator);
+
     const fuzz_args = try fuzz.parse_fuzz_args(allocator);
     var rng = std.rand.DefaultPrng.init(fuzz_args.seed);
     const random = rng.random();

package/src/tigerbeetle/src/lsm/grid.zig

@@ -172,9 +172,9 @@ pub fn GridType(comptime Storage: type) type {
             // Resolve reads that were seen in the cache during start_read()
             // but deferred to be asynchronously resolved on the next tick.
             //
-            // Drain directly from the queue so that new cache reads (added upon completion of old 
-            // cache reads) that can be serviced immediately aren't deferred until the next tick 
-            // (which may be milliseconds later due to IO.run_for_ns). This is necessary to ensure 
+            // Drain directly from the queue so that new cache reads (added upon completion of old
+            // cache reads) that can be serviced immediately aren't deferred until the next tick
+            // (which may be milliseconds later due to IO.run_for_ns). This is necessary to ensure
             // that groove prefetch completes promptly.
             //
             // Even still, we cap the reads processed to prevent going over

package/src/tigerbeetle/src/lsm/tree.zig

@@ -7,6 +7,7 @@ const mem = std.mem;
 const os = std.os;
 
 const log = std.log.scoped(.tree);
+const tracer = @import("../tracer.zig");
 
 const config = @import("../config.zig");
 const div_ceil = @import("../util.zig").div_ceil;
@@ -144,6 +145,8 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
         checkpoint_callback: ?fn (*Tree) void,
         open_callback: ?fn (*Tree) void,
 
+        tracer_slot: ?tracer.SpanStart = null,
+
         pub const Options = struct {
             /// The maximum number of keys that may be committed per batch.
             ///
@@ -188,13 +191,13 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
             var manifest = try Manifest.init(allocator, node_pool, grid, tree_hash);
             errdefer manifest.deinit(allocator);
 
-            var compaction_table_immutable = try CompactionTableImmutable.init(allocator);
+            var compaction_table_immutable = try CompactionTableImmutable.init(allocator, tree_name);
             errdefer compaction_table_immutable.deinit(allocator);
 
             var compaction_table: [@divFloor(config.lsm_levels, 2)]CompactionTable = undefined;
             for (compaction_table) |*compaction, i| {
                 errdefer for (compaction_table[0..i]) |*c| c.deinit(allocator);
-                compaction.* = try CompactionTable.init(allocator);
+                compaction.* = try CompactionTable.init(allocator, tree_name);
             }
             errdefer for (compaction_table) |*c| c.deinit(allocator);
 
@@ -221,6 +224,8 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
         }
 
         pub fn deinit(tree: *Tree, allocator: mem.Allocator) void {
+            assert(tree.tracer_slot == null);
+
             tree.compaction_table_immutable.deinit(allocator);
             for (tree.compaction_table) |*compaction| compaction.deinit(allocator);
 
@@ -548,6 +553,12 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
             assert(tree.compaction_io_pending == 0);
             assert(tree.compaction_callback == null);
 
+            tracer.start(
+                &tree.tracer_slot,
+                .{ .tree = .{ .tree_name = tree_name } },
+                .{ .tree_compaction_beat = .{ .tree_name = tree_name } },
+            );
+
             tree.compaction_callback = callback;
 
             const compaction_beat = tree.compaction_op % config.lsm_batch_multiple;
@@ -917,6 +928,12 @@ pub fn TreeType(comptime TreeTable: type, comptime Storage: type, comptime tree_
             assert(tree.compaction_io_pending == 0);
             assert(tree.table_mutable.can_commit_batch(tree.options.commit_entries_max));
 
+            tracer.end(
+                &tree.tracer_slot,
+                .{ .tree = .{ .tree_name = tree_name } },
+                .{ .tree_compaction_beat = .{ .tree_name = tree_name } },
+            );
+
             // Invoke the compact() callback after the manifest compacts at the end of the beat.
             const callback = tree.compaction_callback.?;
             tree.compaction_callback = null;

package/src/tigerbeetle/src/lsm/tree_fuzz.zig

@@ -6,7 +6,9 @@ const assert = std.debug.assert;
 const config = @import("../config.zig");
 const fuzz = @import("../test/fuzz.zig");
 const vsr = @import("../vsr.zig");
+
 const log = std.log.scoped(.lsm_tree_fuzz);
+const tracer = @import("../tracer.zig");
 
 const MessagePool = @import("../message_pool.zig").MessagePool;
 const Transfer = @import("../tigerbeetle.zig").Transfer;
@@ -27,7 +29,7 @@ const Table = @import("table.zig").TableType(
     Key.tombstone,
     Key.tombstone_from_key,
 );
-const Tree = @import("tree.zig").TreeType(Table, Storage, @typeName(Table) ++ "_test");
+const Tree = @import("tree.zig").TreeType(Table, Storage, "Key.Value");
 
 const Grid = GridType(Storage);
 const SuperBlock = vsr.SuperBlockType(Storage);
@@ -440,6 +442,9 @@ pub fn generate_fuzz_ops(random: std.rand.Random) ![]const FuzzOp {
 }
 
 pub fn main() !void {
+    try tracer.init(allocator);
+    defer tracer.deinit(allocator);
+
     const fuzz_args = try fuzz.parse_fuzz_args(allocator);
     var rng = std.rand.DefaultPrng.init(fuzz_args.seed);
     const random = rng.random();