remove unused code and fix types

Author: hendriknielaender

benchmarks/isolated.zig

@@ -21,7 +21,7 @@ pub fn main() !void {
             zlog.field.string("user_id", "12345"),
             zlog.field.string("action", "login"),
             zlog.field.int("ts", @as(i64, @intCast(i))),
-        }) catch unreachable;
+        }) catch @panic("isolated serialization buffer overflow");
         serialize_ns += @as(u64, @intCast(support.nowNs() - start));
     }
 
@@ -37,7 +37,7 @@ pub fn main() !void {
     var mutex: std.Io.Mutex = .init;
     for (0..iterations) |_| {
         const start = support.nowNs();
-        mutex.lock(io) catch unreachable;
+        mutex.lock(io) catch @panic("isolated mutex lock failed");
         std.mem.doNotOptimizeAway(dummy_json.len);
         mutex.unlock(io);
         mutex_ns += @as(u64, @intCast(support.nowNs() - start));

benchmarks/memory.zig

@@ -11,8 +11,8 @@ pub fn main() !void {
 
     const iterations = 50_000;
     const zlog_ns = benchZlog(iterations);
-    const alloc_print_ns = benchAllocPrint(allocator, iterations);
-    const buf_print_ns = benchBufPrint(iterations);
+    const alloc_print_ns = try benchAllocPrint(allocator, iterations);
+    const buf_print_ns = try benchBufPrint(iterations);
 
     printCase("zlog sync logger", iterations, zlog_ns);
     printCase("std.fmt.allocPrint", iterations, alloc_print_ns);
@@ -41,32 +41,32 @@ fn benchZlog(iterations: usize) i128 {
     return support.nowNs() - start;
 }
 
-fn benchAllocPrint(allocator: std.mem.Allocator, iterations: usize) i128 {
+fn benchAllocPrint(allocator: std.mem.Allocator, iterations: usize) !i128 {
     const start = support.nowNs();
     for (0..iterations) |i| {
-        const line = std.fmt.allocPrint(
+        const line = try std.fmt.allocPrint(
             allocator,
             "{{\"level\":\"Info\",\"message\":\"User action\",\"user_id\":\"12345\",\"action\":\"login\",\"timestamp\":{d}}}\n",
             .{i},
-        ) catch unreachable;
+        );
         allocator.free(line);
     }
     return support.nowNs() - start;
 }
 
-fn benchBufPrint(iterations: usize) i128 {
+fn benchBufPrint(iterations: usize) !i128 {
     var sink_buffer: [256]u8 = undefined;
     var sink = std.Io.Writer.Discarding.init(&sink_buffer);
     var line_buffer: [160]u8 = undefined;
 
     const start = support.nowNs();
     for (0..iterations) |i| {
-        const line = std.fmt.bufPrint(
+        const line = try std.fmt.bufPrint(
             &line_buffer,
             "{{\"level\":\"Info\",\"message\":\"User action\",\"user_id\":\"12345\",\"action\":\"login\",\"timestamp\":{d}}}\n",
             .{i},
-        ) catch unreachable;
-        sink.writer.writeAll(line) catch unreachable;
+        );
+        try sink.writer.writeAll(line);
     }
     return support.nowNs() - start;
 }

benchmarks/production.zig

@@ -71,7 +71,9 @@ fn runWorkload(logger: anytype, request_count: usize) BenchmarkResult {
         const req_start = support.nowNs();
 
         var request_id_buffer: [24]u8 = undefined;
-        const request_id = std.fmt.bufPrint(&request_id_buffer, "req-{d}", .{i}) catch unreachable;
+        const request_id = std.fmt.bufPrint(&request_id_buffer, "req-{d}", .{i}) catch {
+            @panic("request id buffer overflow");
+        };
         const method = if (i % 3 == 0) "POST" else "GET";
         const endpoint = switch (i % 4) {
             0 => "/api/users",

benchmarks/redaction.zig

@@ -8,8 +8,8 @@ pub fn main() !void {
     std.debug.print("=== Redaction Benchmark ===\n\n", .{});
 
     const baseline_ns = benchmarkBaseline(150_000);
-    const redacted_ns = benchmarkWithRedaction(150_000);
-    const dense_redaction_ns = benchmarkDenseRedaction(150_000);
+    const redacted_ns = try benchmarkWithRedaction(150_000);
+    const dense_redaction_ns = try benchmarkDenseRedaction(150_000);
 
     printCase("baseline", 150_000, baseline_ns);
     printCase("runtime redaction", 150_000, redacted_ns);
@@ -36,12 +36,12 @@ fn benchmarkBaseline(iterations: usize) i128 {
     return support.nowNs() - start;
 }
 
-fn benchmarkWithRedaction(iterations: usize) i128 {
+fn benchmarkWithRedaction(iterations: usize) !i128 {
     var redaction_storage: [8][]const u8 = undefined;
     var redaction_config = zlog.RedactionConfig.init(&redaction_storage);
     defer redaction_config.deinit();
-    redaction_config.addKey("password") catch unreachable;
-    redaction_config.addKey("api_key") catch unreachable;
+    try redaction_config.addKey("password");
+    try redaction_config.addKey("api_key");
 
     var sink_buffer: [256]u8 = undefined;
     var sink = std.Io.Writer.Discarding.init(&sink_buffer);
@@ -62,12 +62,12 @@ fn benchmarkWithRedaction(iterations: usize) i128 {
     return support.nowNs() - start;
 }
 
-fn benchmarkDenseRedaction(iterations: usize) i128 {
+fn benchmarkDenseRedaction(iterations: usize) !i128 {
     var redaction_storage: [16][]const u8 = undefined;
     var redaction_config = zlog.RedactionConfig.init(&redaction_storage);
     defer redaction_config.deinit();
     for ([_][]const u8{ "ssn", "credit_card", "cvv", "pin", "password", "api_key", "secret_token" }) |key| {
-        redaction_config.addKey(key) catch unreachable;
+        try redaction_config.addKey(key);
     }
 
     var sink_buffer: [256]u8 = undefined;

benchmarks/support.zig

@@ -5,15 +5,17 @@ pub fn runtimeIo() std.Io {
 }
 
 pub fn nowNs() i128 {
-    return @as(i128, std.Io.Timestamp.now(runtimeIo(), .awake).nanoseconds);
+    return std.Io.Timestamp.now(runtimeIo(), .awake).nanoseconds;
 }
 
 pub fn nowMs() i64 {
     return std.Io.Timestamp.now(runtimeIo(), .real).toMilliseconds();
 }
 
 pub fn sleepMs(ms: i64) void {
-    runtimeIo().sleep(.fromMilliseconds(ms), .awake) catch {};
+    runtimeIo().sleep(.fromMilliseconds(ms), .awake) catch |err| {
+        std.debug.panic("benchmark sleep failed: {}", .{err});
+    };
 }
 
 pub fn nsToMs(ns: i128) f64 {
@@ -59,8 +61,8 @@ pub const LatencyWriter = struct {
 };
 
 fn busyWait(io: std.Io, ns: i128) void {
-    const start = @as(i128, std.Io.Timestamp.now(io, .awake).nanoseconds);
-    while (@as(i128, std.Io.Timestamp.now(io, .awake).nanoseconds) - start < ns) {
+    const start: i128 = std.Io.Timestamp.now(io, .awake).nanoseconds;
+    while (std.Io.Timestamp.now(io, .awake).nanoseconds - start < ns) {
         std.atomic.spinLoopHint();
     }
 }

build.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-const version = std.SemanticVersion{ .major = 0, .minor = 3, .patch = 0 };
+const version = std.SemanticVersion{ .major = 0, .minor = 4, .patch = 0 };
 
 pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});