Skip to content

Lightpanda: the headless browser designed for AI and automation

console: log page values through the logger's escaping, capped at 64 KiB

Lucien Coffe35e3164b2e07
diff --git a/src/browser/Session.zig b/src/browser/Session.zig
index a43fb2bb2..9b8024268 100644
--- a/src/browser/Session.zig
+++ b/src/browser/Session.zig
@@ -153,7 +153,7 @@ pub fn isCancelled(self: *const Session) bool {
return hook.check(hook.context);
}
-const max_console_bytes = 64 * 1024;
+pub const max_console_bytes = 64 * 1024;
pub fn init(self: *Session, browser: *Browser, notification: *Notification) !void {
const allocator = browser.app.allocator;
diff --git a/src/browser/webapi/Console.zig b/src/browser/webapi/Console.zig
index 8420be810..644c1a742 100644
--- a/src/browser/webapi/Console.zig
+++ b/src/browser/webapi/Console.zig
@@ -20,7 +20,9 @@ const std = @import("std");
const lp = @import("lightpanda");
const js = @import("../js/js.zig");
+const Session = @import("../Session.zig");
const Notification = @import("../../Notification.zig");
+const LimitedWriter = @import("../../LimitedWriter.zig");
const logger = lp.log;
@@ -96,7 +98,7 @@ pub fn @"error"(values: []js.Value, exec: *js.Execution) void {
}
pub fn table(data: ?js.Value, columns: ?js.Value) void {
- logger.info(.js, "console.table", .{ .data = data, .columns = columns });
+ logger.info(.js, "console.table", .{ .data = LogValue{ .value = data }, .columns = LogValue{ .value = columns } });
}
pub fn dir(item_: ?js.Value, _: ?js.Value, exec: *js.Execution) void {
@@ -187,24 +189,75 @@ pub fn groupCollapsed(values: []js.Value) void {
}
fn groupEnd() void {}
+
+// Page values are logged as strings, so the logger escapes them. One console
+// call writes at most max_console_bytes of them, like the session's capture.
+const truncated_marker = "...[truncated]";
+
+const LogBuffer = struct {
+ buf: [Session.max_console_bytes + truncated_marker.len]u8 = undefined,
+ used: usize = 0,
+ full: bool = false,
+
+ // Null once an earlier value has used up the budget.
+ fn render(self: *LogBuffer, value: js.Value) !?[]const u8 {
+ if (self.full) {
+ return null;
+ }
+ var fixed: std.Io.Writer = .fixed(self.buf[self.used..]);
+ var limited: LimitedWriter = .init(&fixed, @intCast(Session.max_console_bytes - self.used));
+ value.format(&limited.writer) catch |err| {
+ if (!limited.truncated) {
+ return err;
+ }
+ self.full = true;
+ try fixed.writeAll(truncated_marker);
+ };
+ self.used += fixed.end;
+ return fixed.buffered();
+ }
+};
+
+const LogValue = struct {
+ value: ?js.Value,
+
+ pub fn format(self: LogValue, writer: *std.Io.Writer) !void {
+ const value = self.value orelse return writer.writeAll("null");
+ var buf: LogBuffer = .{};
+ return logger.writePrettyString((try buf.render(value)).?, writer);
+ }
+
+ pub fn logFmt(self: LogValue, key: []const u8, writer: anytype) !void {
+ const value = self.value orelse return writer.write(key, "null");
+ var buf: LogBuffer = .{};
+ return writer.write(key, (try buf.render(value)).?);
+ }
+};
+
const ValueWriter = struct {
values: []js.Value,
stack: ?[]const u8 = null,
pub fn format(self: ValueWriter, writer: *std.Io.Writer) !void {
+ var buf: LogBuffer = .{};
for (self.valuesToLog(), 1..) |value, i| {
- try writer.print("\n arg({d}): {f}", .{ i, value });
+ const text = try buf.render(value) orelse break;
+ try writer.print("\n arg({d}): ", .{i});
+ try logger.writePrettyString(text, writer);
}
if (self.stack) |s| {
- try writer.print("\n stack: {s}", .{s});
+ try writer.writeAll("\n stack: ");
+ try logger.writePrettyString(s, writer);
}
}
pub fn logFmt(self: ValueWriter, _: []const u8, writer: anytype) !void {
- var buf: [32]u8 = undefined;
+ var buf: LogBuffer = .{};
+ var name_buf: [32]u8 = undefined;
for (self.valuesToLog(), 0..) |value, i| {
- const name = try std.mem.print(&buf, "param.{d}", .{i});
- try writer.write(name, value);
+ const text = try buf.render(value) orelse break;
+ const name = try std.mem.print(&name_buf, "param.{d}", .{i});
+ try writer.write(name, text);
}
}
@@ -271,3 +324,41 @@ test "WebApi: Console" {
testing.expectLog(&.{ .js, .js, .js });
try testing.htmlRunner("console", .{});
}
+
+test "WebApi: Console escapes and caps page values in the log" {
+ const frame = try testing.createFrame();
+ defer testing.test_session.closeAllPages();
+
+ var ls: js.Local.Scope = undefined;
+ frame.js.localScope(&ls);
+ defer ls.deinit();
+
+ const format = logger.opts.format;
+ defer logger.opts.format = format;
+
+ var aw = std.Io.Writer.Allocating.init(testing.allocator);
+ defer aw.deinit();
+
+ var values = [_]js.Value{
+ try ls.local.exec("'one\\nx level=fatal'", null),
+ try ls.local.exec("'\\x1b[31m'", null),
+ };
+ logger.opts.format = .logfmt;
+ try logger.logTo(.js, .info, "console.log", .{ValueWriter{ .values = &values }}, &aw.writer);
+ try testing.expect(std.mem.endsWith(u8, aw.written(), " param.0=\"one\\nx level=fatal\" param.1=G1szMW0\n"));
+
+ aw.clearRetainingCapacity();
+ logger.opts.format = .pretty;
+ try logger.logTo(.js, .info, "console.log", .{ValueWriter{ .values = &values }}, &aw.writer);
+ try testing.expect(std.mem.endsWith(u8, aw.written(), "\n arg(1): one\nx level=fatal\n arg(2): \\x1b[31m\n\n"));
+
+ // The cut keeps whole code points ('a' + 32767 two-byte ones) and drops
+ // later arguments.
+ aw.clearRetainingCapacity();
+ values[0] = try ls.local.exec("'a' + '\\u00e9'.repeat(100000)", null);
+ try logger.logTo(.js, .info, "console.log", .{ValueWriter{ .values = &values }}, &aw.writer);
+ const es: [(Session.max_console_bytes - 1) / 2][2]u8 = @splat("\u{e9}".*);
+ const expected = try std.mem.concat(testing.allocator, u8, &.{ "\n arg(1): a", std.mem.sliceAsBytes(&es), truncated_marker ++ "\n\n" });
+ defer testing.allocator.free(expected);
+ try testing.expect(std.mem.endsWith(u8, aw.written(), expected));
+}
diff --git a/src/log.zig b/src/log.zig
index 5c996a998..a6e6463ba 100644
--- a/src/log.zig
+++ b/src/log.zig
@@ -280,7 +280,7 @@ pub fn logKVs(scope: Scope, level: Level, msg: []const u8, kvs: []const KV) void
// Like `log`, but to an explicit writer and without the enabled/sink
// gating. Only used by tests.
-fn logTo(scope: Scope, level: Level, msg: []const u8, data: anytype, out: *std.Io.Writer) !void {
+pub fn logTo(scope: Scope, level: Level, msg: []const u8, data: anytype, out: *std.Io.Writer) !void {
var kvs: [@typeInfo(@TypeOf(data)).@"struct".field_names.len]KV = undefined;
initKVs(data, &kvs);
return logToErased(scope, level, msg, &kvs, out);
@@ -640,7 +640,7 @@ fn writeString(format: Format, value: []const u8, writer: *std.Io.Writer) !void
// Control characters other than \n and \t are written as \xNN, so a logged
// value can't emit terminal escape sequences.
-fn writePrettyString(value: []const u8, writer: *std.Io.Writer) !void {
+pub fn writePrettyString(value: []const u8, writer: *std.Io.Writer) !void {
var start: usize = 0;
for (value, 0..) |b, i| {
if (!std.ascii.isControl(b) or b == '\n' or b == '\t') {