feat(shred-tracker): add --log-finished-slots CLI flag

- Add flag to log highest finished slot when it updates in setBottom
- Wire flag through cmd.zig -> config.zig -> service.zig -> shred_tracker
- Log directly in existing code path, no separate thread

Author: Ubuntu

src/cmd.zig

@@ -128,6 +128,7 @@ pub fn main() !void {
             params.gossip_node.apply(&current_config);
             params.repair.apply(&current_config);
             current_config.shred_network.dump_shred_tracker = params.repair.dump_shred_tracker;
+            current_config.shred_network.log_finished_slots = params.repair.log_finished_slots;
             // Derive snapshot_dir from validator_dir if using default
             if (std.mem.eql(u8, params.snapshot_dir, sig.VALIDATOR_DIR ++ "accounts_db")) {
                 current_config.accounts_db.snapshot_dir = try std.fs.path.join(gpa, &.{ current_config.validator_dir, "accounts_db" });
@@ -181,6 +182,7 @@ pub fn main() !void {
             params.gossip_node.apply(&current_config);
             params.repair.apply(&current_config);
             current_config.shred_network.dump_shred_tracker = params.repair.dump_shred_tracker;
+            current_config.shred_network.log_finished_slots = params.repair.log_finished_slots;
             current_config.turbine.overwrite_stake_for_testing =
                 params.overwrite_stake_for_testing;
             current_config.shred_network.no_retransmit = params.no_retransmit;
@@ -677,6 +679,7 @@ const Cmd = struct {
         max_shreds: u64,
         num_retransmit_threads: ?usize,
         dump_shred_tracker: bool,
+        log_finished_slots: bool,
 
         const cmd_info: cli.ArgumentInfoGroup(@This()) = .{
             .turbine_port = .{
@@ -733,6 +736,14 @@ const Cmd = struct {
                 .help = "Create shred-tracker.txt" ++
                     " to visually represent the currently tracked slots.",
             },
+            .log_finished_slots = .{
+                .kind = .named,
+                .name_override = "log-finished-slots",
+                .alias = .none,
+                .default_value = false,
+                .config = {},
+                .help = "Log the highest finished slot when it updates.",
+            },
         };
 
         fn apply(args: @This(), cfg: *config.Cmd) void {

src/config.zig

@@ -76,6 +76,7 @@ pub const ShredNetwork = struct {
     turbine_recv_port: u16 = 8002,
     no_retransmit: bool = true,
     dump_shred_tracker: bool = false,
+    log_finished_slots: bool = false,
 
     /// Converts from the CLI args into the `shred_network.start` parameters
     pub fn toConfig(self: ShredNetwork, fallback_slot: sig.core.Slot) ShredNetworkConfig {
@@ -85,6 +86,7 @@ pub const ShredNetwork = struct {
             .turbine_recv_port = self.turbine_recv_port,
             .retransmit = !self.no_retransmit,
             .dump_shred_tracker = self.dump_shred_tracker,
+            .log_finished_slots = self.log_finished_slots,
         };
     }
 };

src/shred_network/collector/repair_service.zig

@@ -659,7 +659,7 @@ test "RepairService sends repair request to gossip peer" {
     );
 
     var tracker: BasicShredTracker = undefined;
-    try tracker.init(std.testing.allocator, 13579, .noop, &registry);
+    try tracker.init(std.testing.allocator, 13579, .noop, &registry, false);
     defer tracker.deinit();
 
     var service: RepairService = blk: {

src/shred_network/collector/shred_receiver.zig

@@ -305,7 +305,7 @@ test "handleBatch/handlePacket" {
 
     const shred_tracker = try allocator.create(BasicShredTracker);
     defer allocator.destroy(shred_tracker);
-    try shred_tracker.init(allocator, root_slot + 1, .noop, &registry);
+    try shred_tracker.init(allocator, root_slot + 1, .noop, &registry, false);
     defer shred_tracker.deinit();
 
     var exit = Atomic(bool).init(false);

src/shred_network/collector/shred_tracker.zig

@@ -47,6 +47,8 @@ pub const BasicShredTracker = struct {
     /// ring buffer
     slots: [num_slots]MonitoredSlot = @splat(.{}),
     metrics: Metrics,
+    /// Whether to log when finished_slots_through is updated
+    log_finished_slots: bool,
 
     const num_slots: usize = 1024;
 
@@ -65,6 +67,7 @@ pub const BasicShredTracker = struct {
         slot: Slot,
         logger: Logger,
         registry: *Registry(.{}),
+        log_finished_slots: bool,
     ) !void {
         const metrics = try registry.initStruct(Metrics);
         metrics.finished_slots_through.set(slot);
@@ -77,6 +80,7 @@ pub const BasicShredTracker = struct {
             .max_slot_seen = slot,
             .logger = logger,
             .metrics = metrics,
+            .log_finished_slots = log_finished_slots,
         };
     }
 
@@ -282,6 +286,9 @@ pub const BasicShredTracker = struct {
         }
         self.current_bottom_slot = @max(self.current_bottom_slot, slot);
         self.metrics.finished_slots_through.max(slot -| 1);
+        if (self.log_finished_slots) {
+            self.logger.info().logf("tracked to slot: {}", .{slot -| 1});
+        }
     }
 
     /// - Record that a slot has been observed.
@@ -518,7 +525,7 @@ test "trivial happy path" {
 
     const tracker = try allocator.create(BasicShredTracker);
     defer allocator.destroy(tracker);
-    try tracker.init(allocator, 13579, .noop, &registry);
+    try tracker.init(allocator, 13579, .noop, &registry, false);
     defer tracker.deinit();
 
     _ = try tracker.identifyMissing(&msr, Instant.EPOCH_ZERO.plus(Duration.fromSecs(1)));
@@ -542,7 +549,7 @@ test "1 registered shred is identified" {
 
     const tracker = try allocator.create(BasicShredTracker);
     defer allocator.destroy(tracker);
-    try tracker.init(allocator, 13579, .noop, &registry);
+    try tracker.init(allocator, 13579, .noop, &registry, false);
     defer tracker.deinit();
 
     try tracker.registerShred(13579, 123, 13578, false, .EPOCH_ZERO);
@@ -573,7 +580,7 @@ test "slots are only skipped after a competing fork has developed sufficiently"
 
     const tracker = try allocator.create(BasicShredTracker);
     defer allocator.destroy(tracker);
-    try tracker.init(allocator, 1, .noop, &registry);
+    try tracker.init(allocator, 1, .noop, &registry, false);
     defer tracker.deinit();
 
     const start = Instant.EPOCH_ZERO;
@@ -625,7 +632,7 @@ test "slots are not skipped when the current fork is developed" {
 
     const tracker = try allocator.create(BasicShredTracker);
     defer allocator.destroy(tracker);
-    try tracker.init(allocator, 1, .noop, &registry);
+    try tracker.init(allocator, 1, .noop, &registry, false);
     defer tracker.deinit();
 
     const start = Instant.EPOCH_ZERO;

src/shred_network/service.zig

@@ -32,6 +32,7 @@ pub const ShredNetworkConfig = struct {
     turbine_recv_port: u16,
     retransmit: bool,
     dump_shred_tracker: bool,
+    log_finished_slots: bool,
 };
 
 /// Resources that are required for the Shred Network to operate.
@@ -85,7 +86,7 @@ pub fn start(
 
     // tracker (shared state, internal to Shred Network)
     const shred_tracker = try arena.create(BasicShredTracker);
-    try shred_tracker.init(deps.allocator, conf.root_slot + 1, .from(deps.logger), deps.registry);
+    try shred_tracker.init(deps.allocator, conf.root_slot + 1, .from(deps.logger), deps.registry, conf.log_finished_slots);
     try defers.deferCall(BasicShredTracker.deinit, .{shred_tracker});
 
     // channels (cant use arena as they need to alloc/free frequently &
@@ -202,6 +203,7 @@ test "start and stop gracefully" {
         .turbine_recv_port = 50305,
         .retransmit = true,
         .dump_shred_tracker = false,
+        .log_finished_slots = false,
     };
 
     var exit = Atomic(bool).init(false);