tiny.tracy.FlightRecorder

1pub const FlightRecorder = struct {2    writer: std.Io.Writer,3    storage: []u8,4    event_storage: []u8,5    policy: OverflowPolicy,6    state: State = .accepting,7    header_seen: bool = false,8    header_len: usize = 0,9    ring_head: usize = 0,10    ring_len: usize = 0,11    ring_events: usize = 0,12    event_len: usize = 0,13    discarding_event: bool = false,14    observed_events: u64 = 0,15    stored_events: u64 = 0,16    overwritten_events: u64 = 0,17    dropped_events: u64 = 0,18    oversized_events: u64 = 0,1920    pub fn init(21        storage: []u8,22        event_storage: []u8,23        writer_storage: []u8,24        policy: OverflowPolicy,25    ) FlightRecorder {26        assert(storage.len > 0);27        assert(event_storage.len > 0);28        assert(writer_storage.len > 0);29        assert(disjoint(storage, event_storage));30        assert(disjoint(storage, writer_storage));31        assert(disjoint(event_storage, writer_storage));32        var recorder: FlightRecorder = .{33            .writer = .{ .vtable = &writer_vtable, .buffer = writer_storage },34            .storage = storage,35            .event_storage = event_storage,36            .policy = policy,37        };38        recorder.assertValid();39        return recorder;40    }4142    pub fn interface(self: *FlightRecorder) *std.Io.Writer {43        self.assertValid();44        return &self.writer;45    }4647    pub fn reset(self: *FlightRecorder) void {48        self.writer.flush() catch unreachable;49        self.state = .accepting;50        self.header_seen = false;51        self.header_len = 0;52        self.ring_head = 0;53        self.ring_len = 0;54        self.ring_events = 0;55        self.event_len = 0;56        self.discarding_event = false;57        self.observed_events = 0;58        self.stored_events = 0;59        self.overwritten_events = 0;60        self.dropped_events = 0;61        self.oversized_events = 0;62        self.assertValid();63    }6465    pub fn snapshot(self: *FlightRecorder, destination: *std.Io.Writer) !Report {66        if (destination == &self.writer) return error.InvalidSnapshotWriter;67        try self.writer.flush();68        self.assertValid();69        const result = self.report();70        if (self.header_len > 0) {71            try destination.writeAll(self.storage[0..self.header_len]);72        }73        const ring = self.ringStorage();74        if (self.ring_len > 0) {75            const first_len = @min(self.ring_len, ring.len - self.ring_head);76            try destination.writeAll(ring[self.ring_head..][0..first_len]);77            const second_len = self.ring_len - first_len;78            if (second_len > 0) try destination.writeAll(ring[0..second_len]);79        }80        try result.writeJsonl(destination);81        return result;82    }8384    pub fn report(self: *FlightRecorder) Report {85        self.writer.flush() catch unreachable;86        self.assertValid();87        const retained_header: usize = if (self.header_len > 0) 1 else 0;88        return .{89            .policy = self.policy,90            .state = self.state,91            .capacity_bytes = self.storage.len,92            .retained_bytes = self.header_len + self.ring_len,93            .event_capacity_bytes = self.event_storage.len,94            .writer_capacity_bytes = self.writer.buffer.len,95            .observed_events = self.observed_events,96            .stored_events = self.stored_events,97            .retained_events = retained_header + self.ring_events,98            .overwritten_events = self.overwritten_events,99            .dropped_events = self.dropped_events,100            .oversized_events = self.oversized_events,101            .partial_event_bytes = self.event_len,102            .discarding_oversized_event = self.discarding_event,103        };104    }105106    fn accept(self: *FlightRecorder, bytes: []const u8) void {107        for (bytes) |byte| {108            if (self.discarding_event) {109                if (byte == '\n') {110                    self.finishOversizedEvent();111                }112                continue;113            }114            if (byte == '\n') {115                self.commitEvent(self.event_storage[0..self.event_len]);116                self.event_len = 0;117            } else if (self.event_len == self.event_storage.len) {118                self.event_len = 0;119                self.discarding_event = true;120            } else {121                self.event_storage[self.event_len] = byte;122                self.event_len += 1;123            }124        }125        self.assertValid();126    }127128    fn finishOversizedEvent(self: *FlightRecorder) void {129        self.observed_events +|= 1;130        self.oversized_events +|= 1;131        self.discarding_event = false;132        if (self.header_seen) return;133        self.header_seen = true;134        if (self.policy == .stop_when_full) self.state = .full;135    }136137    fn commitEvent(self: *FlightRecorder, payload: []const u8) void {138        self.observed_events +|= 1;139        const required = std.math.add(usize, payload.len, 1) catch {140            self.oversized_events +|= 1;141            return;142        };143        if (!self.header_seen) {144            self.header_seen = true;145            if (required > self.storage.len) {146                self.oversized_events +|= 1;147                if (self.policy == .stop_when_full) self.state = .full;148                return;149            }150            @memcpy(self.storage[0..payload.len], payload);151            self.storage[payload.len] = '\n';152            self.header_len = required;153            self.stored_events +|= 1;154            return;155        }156        self.commitRingEvent(payload, required);157    }158159    fn commitRingEvent(self: *FlightRecorder, payload: []const u8, required: usize) void {160        if (self.state == .full) {161            self.dropped_events +|= 1;162            return;163        }164        const ring = self.ringStorage();165        if (required > ring.len) {166            self.oversized_events +|= 1;167            if (self.policy == .stop_when_full) self.state = .full;168            return;169        }170        if (self.policy == .stop_when_full and required > ring.len - self.ring_len) {171            self.state = .full;172            self.dropped_events +|= 1;173            return;174        }175        while (required > ring.len - self.ring_len) self.evictOldest();176        self.appendRing(payload);177        self.stored_events +|= 1;178        self.ring_events += 1;179    }180181    fn appendRing(self: *FlightRecorder, payload: []const u8) void {182        const ring = self.ringStorage();183        assert(payload.len + 1 <= ring.len - self.ring_len);184        var tail = advance(self.ring_head, self.ring_len, ring.len);185        const first_len = @min(payload.len, ring.len - tail);186        @memcpy(ring[tail..][0..first_len], payload[0..first_len]);187        const second_len = payload.len - first_len;188        if (second_len > 0) @memcpy(ring[0..second_len], payload[first_len..]);189        self.ring_len += payload.len;190        tail = advance(self.ring_head, self.ring_len, ring.len);191        ring[tail] = '\n';192        self.ring_len += 1;193    }194195    fn evictOldest(self: *FlightRecorder) void {196        const ring = self.ringStorage();197        assert(self.ring_len > 0);198        var event_bytes: usize = 1;199        while (event_bytes <= self.ring_len) : (event_bytes += 1) {200            const index = advance(self.ring_head, event_bytes - 1, ring.len);201            if (ring[index] == '\n') break;202        }203        assert(event_bytes <= self.ring_len);204        self.ring_head = advance(self.ring_head, event_bytes, ring.len);205        self.ring_len -= event_bytes;206        self.ring_events -= 1;207        self.overwritten_events +|= 1;208        if (self.ring_len == 0) self.ring_head = 0;209    }210211    fn ringStorage(self: *FlightRecorder) []u8 {212        return self.storage[self.header_len..];213    }214215    fn assertValid(self: *FlightRecorder) void {216        assert(self.storage.len > 0);217        assert(self.event_storage.len > 0);218        assert(self.writer.buffer.len > 0);219        assert(self.header_len <= self.storage.len);220        assert(self.ring_len <= self.storage.len - self.header_len);221        assert(self.event_len <= self.event_storage.len);222        if (self.discarding_event) assert(self.event_len == 0);223        assert(self.ring_events <= self.ring_len);224        if (self.state == .full) assert(self.policy == .stop_when_full);225        if (self.ring_len == 0) {226            assert(self.ring_head == 0);227        } else {228            assert(self.ringStorage().len > 0);229            assert(self.ring_head < self.ringStorage().len);230        }231        const header_events: usize = if (self.header_len > 0) 1 else 0;232        if (std.math.cast(u64, header_events + self.ring_events)) |retained| {233            const accounted = std.math.add(u64, self.overwritten_events, retained) catch null;234            if (accounted) |count| {235                if (self.stored_events != std.math.maxInt(u64)) {236                    assert(self.stored_events == count);237                }238            }239        }240        if (self.observed_events != std.math.maxInt(u64)) {241            const accepted = std.math.add(u64, self.stored_events, self.dropped_events) catch null;242            if (accepted) |count| {243                const accounted = std.math.add(u64, count, self.oversized_events) catch null;244                if (accounted) |total| assert(self.observed_events == total);245            }246        }247    }248249    const writer_vtable: std.Io.Writer.VTable = .{250        .drain = drain,251        .flush = std.Io.Writer.defaultFlush,252        .rebase = std.Io.Writer.defaultRebase,253    };254255    fn drain(256        writer: *std.Io.Writer,257        data: []const []const u8,258        splat: usize,259    ) std.Io.Writer.Error!usize {260        const self: *FlightRecorder = @alignCast(@fieldParentPtr("writer", writer));261        assert(data.len > 0);262        self.accept(writer.buffer[0..writer.end]);263        writer.end = 0;264        var consumed: usize = 0;265        for (data[0 .. data.len - 1]) |bytes| {266            self.accept(bytes);267            consumed += bytes.len;268        }269        const last = data[data.len - 1];270        for (0..splat) |_| {271            self.accept(last);272            consumed += last.len;273        }274        return consumed;275    }276};

1pub const FlightRecorder = flight_mod.FlightRecorder;