Lightpanda: the headless browser designed for AI and automation
mem: reduce generic use in log
Karl Seguin93346ef5a62f
diff --git a/src/browser/js/TryCatch.zig b/src/browser/js/TryCatch.zigindex e3977fb37..0222e3c36 100644--- a/src/browser/js/TryCatch.zig+++ b/src/browser/js/TryCatch.zig@@ -129,11 +129,12 @@ pub const Caught = struct {try writer.print("{s}caught: {any}", .{ separator, self.caught });}- pub fn logFmt(self: Caught, comptime prefix: []const u8, writer: anytype) !void {- try writer.write(prefix ++ ".exception", self.exception orelse "???");- try writer.write(prefix ++ ".stack", self.stack orelse "na");- try writer.write(prefix ++ ".line", self.line);- try writer.write(prefix ++ ".caught", self.caught);+ pub fn logFmt(self: Caught, prefix: []const u8, writer: anytype) !void {+ var buf: [64]u8 = undefined;+ try writer.write(try std.fmt.bufPrint(&buf, "{s}.exception", .{prefix}), self.exception orelse "???");+ try writer.write(try std.fmt.bufPrint(&buf, "{s}.stack", .{prefix}), self.stack orelse "na");+ try writer.write(try std.fmt.bufPrint(&buf, "{s}.line", .{prefix}), self.line);+ try writer.write(try std.fmt.bufPrint(&buf, "{s}.caught", .{prefix}), self.caught);}pub fn jsonStringify(self: Caught, jw: anytype) !void {diff --git a/src/log.zig b/src/log.zigindex b7326bb86..04e839b79 100644--- a/src/log.zig+++ b/src/log.zig@@ -128,39 +128,51 @@ pub fn log(scope: Scope, level: Level, msg: []const u8, data: anytype) void {};}+// Converts each field of `data` into a runtime Value so that a single copy of+// the formatting code (logToErased and below) can do the actual writing.fn logTo(scope: Scope, level: Level, msg: []const u8, data: anytype, out: *std.Io.Writer) !void {+ const fields = @typeInfo(@TypeOf(data)).@"struct".fields;+ var kvs: [fields.len]KV = undefined;+ inline for (fields, 0..) |f, i| {+ const value = @field(data, f.name);+ kvs[i] = .{ .key = f.name, .value = Value.init(&value) };+ }+ return logToErased(scope, level, msg, &kvs, out);+}++fn logToErased(scope: Scope, level: Level, msg: []const u8, kvs: []const KV, out: *std.Io.Writer) !void {if (builtin.mode == .Debug) {if (msg.len > 30) {std.debug.print("debug-only-panic: log msg cannot be more than 30 characters: {s}", .{msg});- @panic("ivnalid log msg");+ @panic("invalid log msg");}for (msg) |b| {switch (b) {'A'...'Z', 'a'...'z', ' ', '0'...'9', '_', '-', '.', '{', '}' => {},else => {- std.debug.print("debug-only-panic: log msg cannot has invalid character: {s}", .{msg});+ std.debug.print("debug-only-panic: log msg contains an invalid character: {s}", .{msg});@panic("invalid log msg");},}}}switch (opts.format) {- .logfmt => try logLogfmt(scope, level, msg, data, out),- .pretty => try logPretty(scope, level, msg, data, out),+ .logfmt => try logLogfmt(scope, level, msg, kvs, out),+ .pretty => try logPretty(scope, level, msg, kvs, out),}out.flush() catch return;}-fn logLogfmt(scope: Scope, level: Level, msg: []const u8, data: anytype, writer: *std.Io.Writer) !void {+fn logLogfmt(scope: Scope, level: Level, msg: []const u8, kvs: []const KV, writer: *std.Io.Writer) !void {try logLogFmtPrefix(scope, level, msg, writer);- inline for (@typeInfo(@TypeOf(data)).@"struct".fields) |f| {- const value = @field(data, f.name);- if (std.meta.hasMethod(@TypeOf(value), "logFmt")) {- try value.logFmt(f.name, LogFormatWriter{ .writer = writer });- } else {- const key = " " ++ f.name ++ "=";- try writer.writeAll(key);- try writeValue(.logfmt, value, writer);+ for (kvs) |kv| {+ switch (kv.value) {+ // logFmt implementations write their own complete " key=value" pairs+ .log_fmt => |f| try f.logFmtFn(f.ptr, kv.key, writer),+ else => {+ try writer.print(" {s}=", .{kv.key});+ try writeErased(.logfmt, kv.value, writer);+ },}}try writer.writeByte('\n');@@ -181,12 +193,11 @@ fn logLogFmtPrefix(scope: Scope, level: Level, msg: []const u8, writer: *std.Io.try writer.writeByte('"');}-fn logPretty(scope: Scope, level: Level, msg: []const u8, data: anytype, writer: *std.Io.Writer) !void {+fn logPretty(scope: Scope, level: Level, msg: []const u8, kvs: []const KV, writer: *std.Io.Writer) !void {try logPrettyPrefix(scope, level, msg, writer);- inline for (@typeInfo(@TypeOf(data)).@"struct".fields) |f| {- const key = " " ++ f.name ++ " = ";- try writer.writeAll(key);- try writeValue(.pretty, @field(data, f.name), writer);+ for (kvs) |kv| {+ try writer.print(" {s} = ", .{kv.key});+ try writeErased(.pretty, kv.value, writer);try writer.writeByte('\n');}try writer.writeByte('\n');@@ -209,7 +220,6 @@ fn logPrettyPrefix(scope: Scope, level: Level, msg: []const u8, writer: *std.Io.try writer.writeAll(" : ");try writer.writeAll(msg);-{// msg.len cannot be > 30, and @tagName(scope).len cannot be > 15// so this is safe@@ -227,50 +237,147 @@ fn logPrettyPrefix(scope: Scope, level: Level, msg: []const u8, writer: *std.Io.}}-pub fn writeValue(comptime format: Format, value: anytype, writer: *std.Io.Writer) !void {- const T = @TypeOf(value);- if (std.meta.hasMethod(T, "format")) {- return writer.print("{f}", .{value});- }+const KV = struct {+ key: []const u8,+ value: Value,+};- switch (@typeInfo(T)) {- .optional => {- if (value) |v| {- return writeValue(format, v, writer);- }- return writer.writeAll("null");- },- .comptime_int, .int, .comptime_float, .float => {- return writer.print("{d}", .{value});- },- .bool => {- return writer.writeAll(if (value) "true" else "false");- },- .error_set => return writer.writeAll(@errorName(value)),- .@"enum" => return writer.writeAll(@tagName(value)),- .array => return writeValue(format, &value, writer),- .pointer => |ptr| switch (ptr.size) {- .slice => switch (ptr.child) {- u8 => return writeString(format, value, writer),- else => {},+const Value = union(enum) {+ null,+ string: []const u8,+ int: i64,+ uint: u64,+ float32: f32,+ float64: f64,+ boolean: bool,+ formatter: Formatter,+ log_fmt: LogFmt,++ const Formatter = struct {+ ptr: *const anyopaque,+ writeFn: *const fn (ptr: *const anyopaque, writer: *std.Io.Writer) anyerror!void,+ };++ const LogFmt = struct {+ ptr: *const anyopaque,+ // writes one or more complete " key=value" pairs (logfmt only)+ logFmtFn: *const fn (ptr: *const anyopaque, key: []const u8, writer: *std.Io.Writer) anyerror!void,+ // value-only formatting, used by the pretty format+ writeFn: *const fn (ptr: *const anyopaque, writer: *std.Io.Writer) anyerror!void,+ };++ fn init(vp: anytype) Value {+ const T = @TypeOf(vp.*);++ if (comptime std.meta.hasMethod(T, "logFmt")) {+ const Thunk = struct {+ fn logFmt(ptr: *const anyopaque, key: []const u8, writer: *std.Io.Writer) anyerror!void {+ const value: *const T = @ptrCast(@alignCast(ptr));+ return value.logFmt(key, LogFormatWriter{ .writer = writer });+ }+ };+ return .{ .log_fmt = .{+ .ptr = @ptrCast(vp),+ .logFmtFn = Thunk.logFmt,+ .writeFn = writeThunk(T, if (std.meta.hasMethod(T, "format")) "f" else ""),+ } };+ }++ if (comptime std.meta.hasMethod(T, "format")) {+ return formatterValue(vp, "f");+ }++ switch (@typeInfo(T)) {+ .optional => {+ if (vp.*) |_| {+ return init(&vp.*.?);+ }+ return .null;+ },+ .comptime_int => {+ const value = vp.*;+ if (value >= 0 and value <= std.math.maxInt(u64)) {+ return .{ .uint = value };+ }+ if (value < 0 and value >= std.math.minInt(i64)) {+ return .{ .int = value };+ }+ return .{ .string = std.fmt.comptimePrint("{d}", .{value}) };+ },+ .int => |int_info| {+ if (comptime int_info.bits <= 64) {+ return if (comptime int_info.signedness == .signed) .{ .int = vp.* } else .{ .uint = vp.* };+ }+ return formatterValue(vp, "d");+ },+ .comptime_float => return .{ .float64 = vp.* },+ .float => |float_info| switch (comptime float_info.bits) {+ 32 => return .{ .float32 = vp.* },+ 64 => return .{ .float64 = vp.* },+ else => return formatterValue(vp, "d"),+ },+ .bool => return .{ .boolean = vp.* },+ .error_set => return .{ .string = @errorName(vp.*) },+ .@"enum" => return .{ .string = @tagName(vp.*) },+ .array => |arr| if (comptime arr.child == u8) {+ return .{ .string = vp };},- .one => switch (@typeInfo(ptr.child)) {- .array => |arr| if (arr.child == u8) {- return writeString(format, value, writer);+ .pointer => |ptr| switch (comptime ptr.size) {+ .slice => if (comptime ptr.child == u8) {+ return .{ .string = vp.* };},- else => return writer.print("{f}", .{value}),+ .one => switch (@typeInfo(ptr.child)) {+ .array => |arr| if (comptime arr.child == u8) {+ return .{ .string = vp.* };+ },+ else => return formatterValue(vp, "f"),+ },+ else => {},},+ .@"union", .@"struct" => return formatterValue(vp, ""),else => {},- },- .@"union" => return writer.print("{}", .{value}),- .@"struct" => return writer.print("{}", .{value}),- else => {},+ }++ @compileError("cannot log a: " ++ @typeName(T));}+};- @compileError("cannot log a: " ++ @typeName(T));+pub fn writeValue(comptime format: Format, value: anytype, writer: *std.Io.Writer) !void {+ return writeErased(format, Value.init(&value), writer);+}++fn formatterValue(vp: anytype, comptime spec: []const u8) Value {+ return .{ .formatter = .{+ .ptr = @ptrCast(vp),+ .writeFn = writeThunk(@TypeOf(vp.*), spec),+ } };+}++// The per-type fallback for values that Value cannot represent as a primitive:+fn writeThunk(comptime T: type, comptime spec: []const u8) *const fn (*const anyopaque, *std.Io.Writer) anyerror!void {+ return struct {+ fn write(ptr: *const anyopaque, writer: *std.Io.Writer) anyerror!void {+ const vp: *const T = @ptrCast(@alignCast(ptr));+ return writer.print("{" ++ spec ++ "}", .{vp.*});+ }+ }.write;+}++fn writeErased(format: Format, value: Value, writer: *std.Io.Writer) !void {+ switch (value) {+ .null => return writer.writeAll("null"),+ .string => |s| return writeString(format, s, writer),+ .int => |n| return writer.print("{d}", .{n}),+ .uint => |n| return writer.print("{d}", .{n}),+ .float32 => |n| return writer.print("{d}", .{n}),+ .float64 => |n| return writer.print("{d}", .{n}),+ .boolean => |b| return writer.writeAll(if (b) "true" else "false"),+ .formatter => |f| return f.writeFn(f.ptr, writer),+ .log_fmt => |f| return f.writeFn(f.ptr, writer),+ }}-fn writeString(comptime format: Format, value: []const u8, writer: *std.Io.Writer) !void {+fn writeString(format: Format, value: []const u8, writer: *std.Io.Writer) !void {if (format == .pretty) {return writer.writeAll(value);}@@ -330,7 +437,7 @@ pub const LogFormatWriter = struct {pub fn write(self: LogFormatWriter, key: []const u8, value: anytype) !void {const writer = self.writer;try writer.print(" {s}=", .{key});- try writeValue(.logfmt, value, writer);+ try writeErased(.logfmt, Value.init(&value), writer);}};