Merge pull request #735 from lightpanda-io/improved_logging

Improved logging

Author: karlseguin

build.zig

@@ -44,21 +44,6 @@ pub fn build(b: *std.Build) !void {
         b.option([]const u8, "git_commit", "Current git commit") orelse "dev",
     );
 
-    {
-        const log = @import("src/log.zig");
-        opts.addOption(
-            log.Level,
-            "log_level",
-            b.option(log.Level, "log_level", "The log level") orelse .info,
-        );
-    }
-
-    opts.addOption(
-        bool,
-        "log_unknown_properties",
-        b.option(bool, "log_unknown_properties", "Log access to unknown properties") orelse false,
-    );
-
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 

src/browser/console/console.zig

@@ -19,8 +19,9 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-const JsObject = @import("../env.zig").Env.JsObject;
+const Allocator = std.mem.Allocator;
 const Page = @import("../page.zig").Page;
+const JsObject = @import("../env.zig").Env.JsObject;
 
 const log = if (builtin.is_test) &test_capture else @import("../../log.zig");
 
@@ -29,6 +30,13 @@ pub const Console = struct {
     timers: std.StringHashMapUnmanaged(u32) = .{},
     counts: std.StringHashMapUnmanaged(u32) = .{},
 
+    pub fn _lp(_: *const Console, values: []JsObject, page: *Page) !void {
+        if (values.len == 0) {
+            return;
+        }
+        log.fatal(.console, "lightpanda", .{ .args = try serializeValues(values, page) });
+    }
+
     pub fn _log(_: *const Console, values: []JsObject, page: *Page) !void {
         if (values.len == 0) {
             return;
@@ -134,12 +142,19 @@ pub const Console = struct {
     }
 
     fn serializeValues(values: []JsObject, page: *Page) ![]const u8 {
+        if (values.len == 0) {
+            return "";
+        }
+
         const arena = page.call_arena;
+        const separator = log.separator();
         var arr: std.ArrayListUnmanaged(u8) = .{};
-        try arr.appendSlice(arena, try values[0].toString());
-        for (values[1..]) |value| {
-            try arr.append(arena, ' ');
-            try arr.appendSlice(arena, try value.toString());
+
+        for (values, 1..) |value, i| {
+            try arr.appendSlice(arena, separator);
+            try arr.writer(arena).print("{d}: ", .{i});
+            const serialized = if (builtin.mode == .Debug) value.toDetailString() else value.toString();
+            try arr.appendSlice(arena, try serialized);
         }
         return arr.items;
     }
@@ -165,8 +180,8 @@ test "Browser.Console" {
         }, .{});
 
         const captured = test_capture.captured.items;
-        try testing.expectEqual("[info] args=a", captured[0]);
-        try testing.expectEqual("[warn] args=hello world 23 true [object Object]", captured[1]);
+        try testing.expectEqual("[info] args= 1: a", captured[0]);
+        try testing.expectEqual("[warn] args= 1: hello world 2: 23 3: true 4: #<Object>", captured[1]);
     }
 
     {
@@ -207,13 +222,17 @@ test "Browser.Console" {
 
         const captured = test_capture.captured.items;
         try testing.expectEqual("[assertion failed] values=", captured[0]);
-        try testing.expectEqual("[assertion failed] values=x true", captured[1]);
-        try testing.expectEqual("[assertion failed] values=x", captured[2]);
+        try testing.expectEqual("[assertion failed] values= 1: x 2: true", captured[1]);
+        try testing.expectEqual("[assertion failed] values= 1: x", captured[2]);
     }
 }
 const TestCapture = struct {
     captured: std.ArrayListUnmanaged([]const u8) = .{},
 
+    fn separator(_: *const TestCapture) []const u8 {
+        return " ";
+    }
+
     fn reset(self: *TestCapture) void {
         self.captured = .{};
     }
@@ -254,6 +273,15 @@ const TestCapture = struct {
         self.capture(scope, msg, args);
     }
 
+    fn fatal(
+        self: *TestCapture,
+        comptime scope: @Type(.enum_literal),
+        comptime msg: []const u8,
+        args: anytype,
+    ) void {
+        self.capture(scope, msg, args);
+    }
+
     fn capture(
         self: *TestCapture,
         comptime scope: @Type(.enum_literal),
@@ -278,7 +306,7 @@ const TestCapture = struct {
         inline for (@typeInfo(@TypeOf(args)).@"struct".fields) |f| {
             try buf.appendSlice(allocator, f.name);
             try buf.append(allocator, '=');
-            try @import("../../log.zig").writeValue(false, @field(args, f.name), buf.writer(allocator));
+            try @import("../../log.zig").writeValue(.pretty, @field(args, f.name), buf.writer(allocator));
             try buf.append(allocator, ' ');
         }
         self.captured.append(testing.arena_allocator, std.mem.trimRight(u8, buf.items, " ")) catch unreachable;

src/browser/dom/element.zig

@@ -147,7 +147,7 @@ pub const Element = struct {
         while (true) {
             if (try select.match(current)) {
                 if (!current.isElement()) {
-                    log.err(.element, "closest invalid type", .{ .type = try current.tag() });
+                    log.err(.browser, "closest invalid type", .{ .type = try current.tag() });
                     return null;
                 }
                 return parser.nodeToElement(current.node);

src/browser/dom/intersection_observer.zig

@@ -86,7 +86,11 @@ pub const IntersectionObserver = struct {
 
         var result: Env.Function.Result = undefined;
         self.callback.tryCall(void, .{self.observed_entries.items}, &result) catch {
-            log.debug(.int_obs, "callback error", .{ .err = result.exception, .stack = result.stack });
+            log.debug(.user_script, "callback error", .{
+                .err = result.exception,
+                .stack = result.stack,
+                .source = "intersection observer",
+            });
         };
     }
 

src/browser/dom/mutation_observer.zig

@@ -114,7 +114,11 @@ pub const MutationObserver = struct {
             const records = [_]MutationRecord{r.*};
             var result: Env.Function.Result = undefined;
             self.cbk.tryCall(void, .{records}, &result) catch {
-                log.debug(.mut_obs, "callback error", .{ .err = result.exception, .stack = result.stack });
+                log.debug(.user_script, "callback error", .{
+                    .err = result.exception,
+                    .stack = result.stack,
+                    .source = "mutation observer",
+                });
             };
         }
     }
@@ -242,7 +246,7 @@ const Observer = struct {
     fn handle(en: *parser.EventNode, event: *parser.Event) void {
         const self: *Observer = @fieldParentPtr("event_node", en);
         self._handle(event) catch |err| {
-            log.err(.mut_obs, "handle error", .{ .err = err });
+            log.err(.web_api, "handle error", .{ .err = err, .source = "mutation observer" });
         };
     }
 

src/browser/dom/node.zig

@@ -269,7 +269,7 @@ pub const Node = struct {
     // - An Element that is not attached to a document or a shadow tree will return the root of the DOM tree it belongs to
     pub fn _getRootNode(self: *parser.Node, options: ?struct { composed: bool = false }) !Union {
         if (options) |options_| if (options_.composed) {
-            log.warn(.node, "not implemented", .{ .feature = "getRootNode composed" });
+            log.warn(.web_api, "not implemented", .{ .feature = "getRootNode composed" });
         };
         return try Node.toInterface(try parser.nodeGetRootNode(self));
     }

src/browser/dom/nodelist.zig

@@ -145,7 +145,7 @@ pub const NodeList = struct {
             const ii: u32 = @intCast(i);
             var result: Function.Result = undefined;
             cbk.tryCall(void, .{ n, ii, self }, &result) catch {
-                log.debug(.node_list, "forEach callback", .{ .err = result.exception, .stack = result.stack });
+                log.debug(.user_script, "forEach callback", .{ .err = result.exception, .stack = result.stack });
             };
         }
     }

src/browser/dom/token_list.zig

@@ -142,7 +142,11 @@ pub const DOMTokenList = struct {
         while (try entries._next()) |entry| {
             var result: Function.Result = undefined;
             cbk.tryCallWithThis(void, this_arg, .{ entry.@"1", entry.@"0", self }, &result) catch {
-                log.debug(.token_list, "foreach callback error", .{ .err = result.exception, .stack = result.stack });
+                log.debug(.user_script, "callback error", .{
+                    .err = result.exception,
+                    .stack = result.stack,
+                    .soure = "tokenList foreach",
+                });
             };
         }
     }

src/browser/events/event.zig

@@ -237,14 +237,18 @@ pub const EventHandler = struct {
 
     fn handle(node: *parser.EventNode, event: *parser.Event) void {
         const ievent = Event.toInterface(event) catch |err| {
-            log.err(.event, "toInterface error", .{ .err = err });
+            log.err(.app, "toInterface error", .{ .err = err });
             return;
         };
 
         const self: *EventHandler = @fieldParentPtr("node", node);
         var result: Function.Result = undefined;
         self.callback.tryCall(void, .{ievent}, &result) catch {
-            log.debug(.event, "handle callback error", .{ .err = result.exception, .stack = result.stack });
+            log.debug(.user_script, "callback error", .{
+                .err = result.exception,
+                .stack = result.stack,
+                .source = "event handler",
+            });
         };
 
         if (self.once) {

src/browser/html/document.zig

@@ -18,6 +18,7 @@
 
 const std = @import("std");
 
+const log = @import("../../log.zig");
 const parser = @import("../netsurf.zig");
 const Page = @import("../page.zig").Page;
 
@@ -276,6 +277,10 @@ pub const HTMLDocument = struct {
         const evt = try parser.eventCreate();
         defer parser.eventDestroy(evt);
 
+        log.debug(.script_event, "dispatch event", .{
+            .type = "DOMContentLoaded",
+            .source = "document",
+        });
         try parser.eventInit(evt, "DOMContentLoaded", .{ .bubbles = true, .cancelable = true });
         _ = try parser.eventTargetDispatchEvent(parser.toEventTarget(parser.DocumentHTML, html_doc), evt);
     }