86 lines
2.6 KiB
Markdown
86 lines
2.6 KiB
Markdown
# zlog
|
|
|
|
Standard Library log wrapper. `zlog` provides adjusted `std.log` output and a pretty print function for easy overwriting of user defined types (`struct`, `enum`, `union` and `vector`).
|
|
|
|
## Usage
|
|
|
|
The following snippet shows an example usage of `zlog` to change the default log format and add pretty printing to both user defined types (`Options` and `Struct`):
|
|
|
|
```zig
|
|
const std = @import("std");
|
|
const zlog = @import("zlog");
|
|
|
|
// use this to overwrite the default log format of `std.log`
|
|
pub const std_options = zlog.std_options;
|
|
|
|
const Options = enum {
|
|
a,
|
|
b,
|
|
c,
|
|
|
|
// copy and paste this function into your user defined types to enable pretty printing for these types
|
|
pub fn format(value: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) anyerror!void {
|
|
try zlog.pretty_format(value, fmt, options, writer);
|
|
}
|
|
};
|
|
|
|
const Struct = struct {
|
|
a: usize = 42,
|
|
b: bool = true,
|
|
c: [5]u16 = .{ 1, 2, 3, 4, 5 },
|
|
d: []const u8 = "string",
|
|
e: Options = Options.b,
|
|
|
|
// same function as above...
|
|
pub fn format(value: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) anyerror!void {
|
|
try zlog.pretty_format(value, fmt, options, writer);
|
|
}
|
|
};
|
|
|
|
pub fn main() void {
|
|
// initialize zlog with the scope of `main`
|
|
const log = std.log.scoped(.main);
|
|
// NOTE: the scope of `default` will result in no scoping being printed in
|
|
// the resulting output (default behavior of `std.log.defaultLog`)
|
|
|
|
// some variables to log
|
|
const int_var = 42;
|
|
const array_var = [_]i32{ 1, 2, 3, 4 };
|
|
const string_var = "This is a test";
|
|
const option_var = Options.a;
|
|
const struct_var: Struct = .{};
|
|
|
|
// NOTE: Depending on the optimization target some of these log messages
|
|
// will not show, which is inline with the behavior of `std.log`.
|
|
log.debug("Debug message {any}", .{int_var});
|
|
log.info("Info message {any}", .{array_var});
|
|
log.info("Info message \"{s}\"", .{string_var});
|
|
log.warn("Warning message {any}", .{option_var});
|
|
log.err("Error message {any}", .{struct_var});
|
|
}
|
|
```
|
|
|
|
This will result in the following output:
|
|
|
|
```
|
|
debug(main): Debug message 42
|
|
info(main): Info message { 1, 2, 3, 4 }
|
|
info(main): Info message "This is a test"
|
|
warning(main): Warning message main.Options = enum {
|
|
a,
|
|
b,
|
|
c,
|
|
} = a
|
|
error(main): Error message main.Struct = struct {
|
|
.a = 42,
|
|
.b = true,
|
|
.c = []u16: { 1, 2, 3, 4, 5 },
|
|
.d = { 115, 116, 114, 105, 110, 103 },
|
|
.e = main.Options = enum {
|
|
a,
|
|
b,
|
|
c,
|
|
} = b,
|
|
}
|
|
```
|