tiny.trace.TraceWriter

1pub const Writer = struct {2    storage: ?*Storage = null,3    root_path: []u8 = &.{},4    target_triple: []u8 = &.{},5    build_id: []u8 = &.{},6    mode: []u8 = &.{},7    endian: []u8 = &.{},8    manifest: format.Manifest = .{},9    block_builder: block.Builder = undefined,10    manifest_io_buffer: []u8 = &.{},11    manifest_buffer: []u8 = &.{},12    path_buffers: [capacity_mod.path_buffer_count][]u8 = .{ &.{}, &.{} },13    sql_allocator: std.heap.FixedBufferAllocator = undefined,14    database_workspace: sql.FileDatabase.Workspace = undefined,15    database_workspace_open: bool = false,16    file: sql.FileDatabase = undefined,17    file_open: bool = false,18    events: sql.Tree = undefined,19    chunk_event_count: u64 = 0,20    chunk_byte_count: u64 = 0,21    event_hasher: std.hash.Wyhash = format.newHasher(),22    initialized: bool = false,23    finished: bool = false,2425    pub fn open(26        self: *Writer,27        storage: *Storage,28        root_path: []const u8,29        manifest_base: format.Manifest,30        trace_limits: format.Limits,31    ) !void {32        if (self.initialized) return error.TraceWriterAlreadyOpen;33        try trace_limits.validate();34        const regions = try storage.acquire(.{35            .root_path_bytes = root_path.len,36            .target_triple_bytes = manifest_base.target_triple.len,37            .build_id_bytes = manifest_base.build_id.len,38            .mode_bytes = manifest_base.mode.len,39            .endian_bytes = manifest_base.endian.len,40            .event_bytes = trace_limits.max_event_bytes,41        });42        var ownership_transferred = false;43        errdefer if (!ownership_transferred) storage.release();44        std.mem.copyForwards(u8, regions.root_path, root_path);45        std.mem.copyForwards(u8, regions.target_triple, manifest_base.target_triple);46        std.mem.copyForwards(u8, regions.build_id, manifest_base.build_id);47        std.mem.copyForwards(u8, regions.mode, manifest_base.mode);48        std.mem.copyForwards(u8, regions.endian, manifest_base.endian);49        self.* = .{50            .storage = storage,51            .root_path = regions.root_path,52            .target_triple = regions.target_triple,53            .build_id = regions.build_id,54            .mode = regions.mode,55            .endian = regions.endian,56            .manifest = manifest_base,57            .block_builder = block.Builder.init(regions.block),58            .manifest_io_buffer = regions.manifest_io,59            .manifest_buffer = regions.manifest,60            .path_buffers = regions.paths,61            .sql_allocator = std.heap.FixedBufferAllocator.init(regions.sql),62            .initialized = true,63        };64        ownership_transferred = true;65        errdefer self.deinit();66        self.manifest.format_version = event.trace_format_version;67        self.manifest.target_triple = self.target_triple;68        self.manifest.build_id = self.build_id;69        self.manifest.mode = self.mode;70        self.manifest.endian = self.endian;71        self.manifest.status = "open";72        self.manifest.limits = trace_limits;73        self.manifest.chunk_count = 0;74        self.manifest.event_count = 0;75        self.manifest.event_bytes = 0;76        self.manifest.event_checksum = 0;77        self.manifest.block_count = 0;78        self.manifest.block_bytes = 0;7980        try sys.fs.deleteTree(self.root_path);81        try self.ensureLayout();82        try self.writeManifest();83        self.database_workspace = try sql.FileDatabase.Workspace.allocate(84            self.sql_allocator.allocator(),85            database.workspaceLimits(storage.capacity.database),86        );87        self.database_workspace_open = true;88        self.file = try database.openWriter(89            self.sql_allocator.allocator(),90            &self.database_workspace,91            self.root_path,92            storage.capacity.database,93        );94        self.file_open = true;95        self.events = try database.events(&self.file);96    }9798    pub fn deinit(self: *Writer) void {99        if (!self.initialized) return;100        if (self.file_open) {101            self.file.deinit();102            self.file_open = false;103        }104        if (self.database_workspace_open) {105            self.database_workspace.deallocate(self.sql_allocator.allocator());106            self.database_workspace_open = false;107        }108        const storage = self.storage.?;109        self.* = .{};110        storage.release();111    }112113    pub fn sink(self: *Writer) event.Sink {114        return .{ .context = self, .appendFn = appendFromSink };115    }116117    pub fn append(self: *Writer, item: event.Event) !void {118        if (!self.initialized or self.finished) return error.TraceWriterNotOpen;119        const encoded_size = codec.encodedSize(item) catch |err| switch (err) {120            error.CapacityOverflow => return error.EventTooLarge,121            error.InvalidEvent, error.OutputTooSmall => unreachable,122        };123        if (encoded_size == 0 or encoded_size > self.manifest.limits.max_event_bytes) {124            return error.EventTooLarge;125        }126        const next_chunk_bytes = std.math.add(u64, self.chunk_byte_count, encoded_size) catch127            return error.TraceTooLarge;128        if (self.chunk_event_count != 0 and129            next_chunk_bytes > self.manifest.limits.max_chunk_bytes)130        {131            try self.finishChunk();132        }133        if (!self.block_builder.empty() and !self.block_builder.canAppend(encoded_size)) {134            try self.flushBlock();135        }136        std.debug.assert(self.block_builder.canAppend(encoded_size));137        const next_chunk_event_count = std.math.add(u64, self.chunk_event_count, 1) catch138            return error.TraceTooLarge;139        const next_chunk_byte_count = std.math.add(u64, self.chunk_byte_count, encoded_size) catch140            return error.TraceTooLarge;141        const next_event_count = std.math.add(u64, self.manifest.event_count, 1) catch142            return error.TraceTooLarge;143        const next_event_bytes = std.math.add(u64, self.manifest.event_bytes, encoded_size) catch144            return error.TraceTooLarge;145        const encoded = self.block_builder.append(item, encoded_size) catch |err| switch (err) {146            error.CapacityOverflow, error.OutputTooSmall => return error.EventTooLarge,147            error.InvalidEvent => unreachable,148        };149        var key_buffer: [database.key_bytes]u8 = undefined;150        const key = database.sequenceKey(&key_buffer, self.manifest.event_count);151        database.updateChecksum(&self.event_hasher, key, encoded);152        self.chunk_event_count = next_chunk_event_count;153        self.chunk_byte_count = next_chunk_byte_count;154        self.manifest.event_count = next_event_count;155        self.manifest.event_bytes = next_event_bytes;156    }157158    pub fn finish(self: *Writer) !void {159        if (!self.initialized or self.finished) return error.TraceWriterNotOpen;160        if (self.chunk_event_count != 0) try self.finishChunk();161        self.manifest.status = "closed";162        self.manifest.event_checksum = self.event_hasher.final();163        try self.writeManifest();164        self.finished = true;165    }166167    fn appendFromSink(context: *anyopaque, item: event.Event) !void {168        const self: *Writer = @ptrCast(@alignCast(context));169        try self.append(item);170    }171172    fn finishChunk(self: *Writer) !void {173        std.debug.assert(self.chunk_event_count != 0);174        const next_chunk_count = std.math.add(u64, self.manifest.chunk_count, 1) catch175            return error.TraceTooLarge;176        try self.flushBlock();177        try database.checkpoint(&self.file);178        self.manifest.chunk_count = next_chunk_count;179        self.chunk_event_count = 0;180        self.chunk_byte_count = 0;181    }182183    fn flushBlock(self: *Writer) !void {184        if (self.block_builder.empty()) return;185        const encoded = self.block_builder.finish();186        const next_block_count = std.math.add(u64, self.manifest.block_count, 1) catch187            return error.TraceTooLarge;188        const next_block_bytes = std.math.add(u64, self.manifest.block_bytes, encoded.len) catch189            return error.TraceTooLarge;190        try database.checkpointIfNeeded(&self.file);191        var key_buffer: [database.key_bytes]u8 = undefined;192        const key = database.sequenceKey(&key_buffer, self.manifest.block_count);193        _ = try self.events.put(key, encoded, .{ .durability = .buffered });194        self.manifest.block_count = next_block_count;195        self.manifest.block_bytes = next_block_bytes;196        self.block_builder.reset();197    }198199    fn ensureLayout(self: *Writer) !void {200        try sys.fs.createDirPath(self.root_path);201        try sys.fs.createDirPath(self.joinedPath(0, "snapshots"));202    }203204    fn writeManifest(self: *Writer) !void {205        const manifest_path = self.joinedPath(0, format.manifest_path);206        const pending_path = self.joinedPath(1, "manifest.pending");207        try format.writeManifest(208            self.manifest,209            manifest_path,210            pending_path,211            self.manifest_buffer,212            self.manifest_io_buffer,213        );214    }215216    fn joinedPath(self: *Writer, buffer_index: usize, relative: []const u8) []const u8 {217        std.debug.assert(buffer_index < self.path_buffers.len);218        std.debug.assert(self.root_path.len != 0);219        std.debug.assert(relative.len <= format.max_relative_path_bytes);220        const buffer = self.path_buffers[buffer_index];221        var length = self.root_path.len;222        @memcpy(buffer[0..length], self.root_path);223        if (!sys.path.isSeparator(buffer[length - 1])) {224            buffer[length] = sys.path.separator;225            length += 1;226        }227        @memcpy(buffer[length..][0..relative.len], relative);228        length += relative.len;229        std.debug.assert(length <= buffer.len);230        return buffer[0..length];231    }232};

1pub const TraceWriter = store.Writer;