/g,n(o))),lookbehind:!0,inside:null}],"builtin-type":{pattern:/\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\b/,alias:"keyword"},keyword:r,function:/\b(?!\d)\w+(?=\s*\()/,number:/\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\d]+(?:\.[a-fA-F\d]*)?(?:[pP][+-]?[a-fA-F\d]+)?|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)\b/,boolean:/\b(?:false|true)\b/,operator:/\.[*?]|\.{2,3}|[-=]>|\*\*|\+\+|\|\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/,punctuation:/[.:,;(){}[\]]/},e.languages.zig["class-name"].forEach((function(n){null===n.inside&&(n.inside=e.languages.zig)}))}(Prism);
diff --git a/src/jetzig.zig b/src/jetzig.zig
index de8af9e..db5a2c1 100644
--- a/src/jetzig.zig
+++ b/src/jetzig.zig
@@ -23,6 +23,7 @@ pub const testing = @import("jetzig/testing.zig");
pub const config = @import("jetzig/config.zig");
pub const auth = @import("jetzig/auth.zig");
pub const callbacks = @import("jetzig/callbacks.zig");
+pub const debug = @import("jetzig/debug.zig");
pub const TemplateContext = @import("jetzig/TemplateContext.zig");
pub const DateTime = jetcommon.types.DateTime;
diff --git a/src/jetzig/debug.zig b/src/jetzig/debug.zig
new file mode 100644
index 0000000..80d634e
--- /dev/null
+++ b/src/jetzig/debug.zig
@@ -0,0 +1,218 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+pub const ErrorInfo = struct {
+ stack_trace: ?*std.builtin.StackTrace = null,
+ err: ?anyerror = null,
+};
+
+pub fn sourceLocations(
+ allocator: std.mem.Allocator,
+ debug_info: *std.debug.SelfInfo,
+ stack_trace: *std.builtin.StackTrace,
+) ![]const std.debug.SourceLocation {
+ var source_locations = std.ArrayList(std.debug.SourceLocation).init(allocator);
+
+ if (builtin.strip_debug_info) return error.MissingDebugInfo;
+
+ var frame_index: usize = 0;
+ var frames_left: usize = @min(stack_trace.index, stack_trace.instruction_addresses.len);
+
+ while (frames_left != 0) : ({
+ frames_left -= 1;
+ frame_index = (frame_index + 1) % stack_trace.instruction_addresses.len;
+ }) {
+ const return_address = stack_trace.instruction_addresses[frame_index];
+ const address = return_address - 1;
+ const module = try debug_info.getModuleForAddress(address);
+ const symbol_info = try module.getSymbolAtAddress(debug_info.allocator, address);
+
+ if (symbol_info.source_location) |source_location| {
+ try source_locations.append(source_location);
+ }
+ }
+
+ return try source_locations.toOwnedSlice();
+}
+
+pub const HtmlStackTrace = struct {
+ allocator: std.mem.Allocator,
+ stack_trace: *std.builtin.StackTrace,
+
+ pub fn format(self: HtmlStackTrace, _: anytype, _: anytype, writer: anytype) !void {
+ const debug_info = try std.debug.getSelfDebugInfo();
+ const source_locations = try sourceLocations(
+ self.allocator,
+ debug_info,
+ self.stack_trace,
+ );
+ for (source_locations) |source_location| {
+ defer debug_info.allocator.free(source_location.file_name);
+ try writer.print(
+ \\
+ \\ {s}:{d}
+ \\
+ ,
+ .{
+ source_location.file_name,
+ source_location.line,
+ },
+ );
+ const surrounding_previous = try surroundingLinesFromFile(
+ self.allocator,
+ .previous,
+ 3,
+ source_location.file_name,
+ source_location.line,
+ );
+ const surrounding_next = try surroundingLinesFromFile(
+ self.allocator,
+ .next,
+ 3,
+ source_location.file_name,
+ source_location.line,
+ );
+ const target_source_line = try readLineFromFile(
+ self.allocator,
+ source_location.file_name,
+ source_location.line,
+ );
+
+ for (surrounding_previous) |source_line| {
+ try writer.print(surrounding_line_template, .{ source_line.line, source_line.content });
+ }
+ try writer.print(target_line_template, .{ target_source_line.line, target_source_line.content });
+ for (surrounding_next) |source_line| {
+ try writer.print(surrounding_line_template, .{ source_line.line, source_line.content });
+ }
+
+ try writer.print(
+ \\
+ \\
+ , .{});
+ }
+ }
+};
+
+const SourceLine = struct { content: []const u8, line: usize };
+
+pub fn readLineFromFile(allocator: std.mem.Allocator, path: []const u8, line: usize) !SourceLine {
+ const file = try std.fs.openFileAbsolute(path, .{});
+ var buf: [std.mem.page_size]u8 = undefined;
+
+ var count: usize = 1;
+ var cursor: usize = 0;
+
+ seek: {
+ while (true) {
+ const bytes_read = try file.readAll(buf[0..]);
+ for (buf[0..bytes_read]) |char| {
+ if (char == '\n') count += 1;
+ cursor += 1;
+ if (count == line) {
+ cursor += 1;
+ break :seek;
+ }
+ }
+ if (bytes_read < buf.len) return error.EndOfFile;
+ }
+ }
+
+ var size: usize = 0;
+ try file.seekTo(cursor);
+ read: {
+ const bytes_read = try file.readAll(buf[0..]);
+ if (std.mem.indexOf(u8, buf[0..bytes_read], "\n")) |index| {
+ size += index;
+ break :read;
+ } else if (bytes_read < buf.len) {
+ size += bytes_read;
+ break :read;
+ } else {
+ while (true) {
+ const more_bytes_read = try file.readAll(buf[0..]);
+ if (std.mem.indexOf(u8, buf[0..more_bytes_read], "\n")) |index| {
+ size += index;
+ break :read;
+ } else if (more_bytes_read < buf.len) {
+ size += more_bytes_read;
+ break :read;
+ } else {
+ size += more_bytes_read;
+ }
+ }
+ }
+ }
+ const line_content = try allocator.alloc(u8, size);
+ try file.seekTo(cursor);
+ const bytes_read = try file.readAll(line_content[0..]);
+
+ std.debug.assert(bytes_read == size);
+
+ return .{ .content = line_content[0..], .line = line };
+}
+
+fn surroundingLinesFromFile(
+ allocator: std.mem.Allocator,
+ context: enum { previous, next },
+ desired_count: usize,
+ path: []const u8,
+ target_line: usize,
+) ![]SourceLine {
+ // This isn't very efficient but we only use it in debug mode so not a huge deal.
+ const start = switch (context) {
+ .previous => if (target_line > desired_count)
+ target_line - desired_count
+ else
+ target_line,
+ .next => target_line + 2,
+ };
+
+ var lines = std.ArrayList(SourceLine).init(allocator);
+
+ switch (context) {
+ .previous => {
+ for (start..target_line) |line| {
+ try lines.append(try readLineFromFile(allocator, path, line));
+ }
+ },
+ .next => {
+ for (0..desired_count, start..) |_, line| {
+ try lines.append(try readLineFromFile(allocator, path, line));
+ }
+ },
+ }
+
+ return try lines.toOwnedSlice();
+}
+
+pub const console_template =
+ \\
+ \\
+ \\
+ \\
+ \\
+ \\
+ \\ Encountered Error: {0s}
+ \\
+ \\ {1}
+ \\
+ \\ Response Data
+ \\
+ \\
+ \\
+ \\
+;
+
+const surrounding_line_template =
+ \\
+ \\
+;
+const target_line_template =
+ \\
+ \\
+;
diff --git a/src/jetzig/http/Server.zig b/src/jetzig/http/Server.zig
index 28568fa..fad3456 100644
--- a/src/jetzig/http/Server.zig
+++ b/src/jetzig/http/Server.zig
@@ -198,7 +198,10 @@ fn renderResponse(self: *Server, request: *jetzig.http.Request) !void {
try callback(request, route);
if (request.rendered_view) |view| {
if (request.state == .failed) {
- request.setResponse(try self.renderError(request, view.status_code), .{});
+ request.setResponse(
+ try self.renderError(request, view.status_code, .{}),
+ .{},
+ );
} else if (request.state == .rendered) {
// TODO: Allow callbacks to set content
}
@@ -334,7 +337,7 @@ fn renderView(
.data = request.response_data,
.status_code = .internal_server_error,
};
- return try self.renderError(request, view.status_code);
+ return try self.renderError(request, view.status_code, .{});
}
const template: ?zmpl.Template = if (request.dynamic_assigned_template) |request_template|
@@ -353,12 +356,17 @@ fn renderView(
.content = try self.renderTemplateWithLayout(request, capture, rendered_view, route),
};
} else {
- try self.logger.DEBUG(
- "Missing template for route `{s}.{s}`. Expected: `src/app/views/{s}.zmpl`.",
- .{ route.view_name, @tagName(route.action), route.template },
- );
return switch (request.requestFormat()) {
- .HTML, .UNKNOWN => try self.renderNotFound(request),
+ .HTML, .UNKNOWN => blk: {
+ try self.logger.DEBUG(
+ "Missing template for route `{s}.{s}`. Expected: `src/app/views/{s}.zmpl`.",
+ .{ route.view_name, @tagName(route.action), route.template },
+ );
+ if (comptime jetzig.build_options.debug_console) {
+ return error.ZmplTemplateNotFound;
+ }
+ break :blk try self.renderNotFound(request);
+ },
.JSON => .{ .view = rendered_view, .content = "" },
};
}
@@ -467,32 +475,44 @@ fn renderInternalServerError(
stack_trace: ?*std.builtin.StackTrace,
err: anyerror,
) !RenderedView {
- request.response_data.reset();
+ // request.response_data.reset();
try self.logger.logError(stack_trace, err);
- const status = .internal_server_error;
- return try self.renderError(request, status);
+ const status = jetzig.http.StatusCode.internal_server_error;
+
+ return try self.renderError(request, status, .{ .stack_trace = stack_trace, .err = err });
}
fn renderNotFound(self: *Server, request: *jetzig.http.Request) !RenderedView {
request.response_data.reset();
const status: jetzig.http.StatusCode = .not_found;
- return try self.renderError(request, status);
+ return try self.renderError(request, status, .{});
}
fn renderBadRequest(self: *Server, request: *jetzig.http.Request) !RenderedView {
request.response_data.reset();
const status: jetzig.http.StatusCode = .bad_request;
- return try self.renderError(request, status);
+ return try self.renderError(request, status, .{});
}
fn renderError(
self: Server,
request: *jetzig.http.Request,
status_code: jetzig.http.StatusCode,
+ error_info: jetzig.debug.ErrorInfo,
+) !RenderedView {
+ if (comptime jetzig.build_options.debug_console) {
+ return try self.renderDebugConsole(request, status_code, error_info);
+ } else return try self.renderGeneralError(request, status_code);
+}
+
+fn renderGeneralError(
+ self: Server,
+ request: *jetzig.http.Request,
+ status_code: jetzig.http.StatusCode,
) !RenderedView {
if (try self.renderErrorView(request, status_code)) |view| return view;
if (try renderStaticErrorPage(request, status_code)) |view| return view;
@@ -500,6 +520,42 @@ fn renderError(
return try renderDefaultError(request, status_code);
}
+fn renderDebugConsole(
+ self: Server,
+ request: *jetzig.http.Request,
+ status_code: jetzig.http.StatusCode,
+ error_info: jetzig.debug.ErrorInfo,
+) !RenderedView {
+ if (comptime jetzig.build_options.debug_console) {
+ var buf = std.ArrayList(u8).init(request.allocator);
+ const writer = buf.writer();
+
+ if (error_info.stack_trace) |stack_trace| {
+ const debug_content = jetzig.debug.HtmlStackTrace{
+ .allocator = request.allocator,
+ .stack_trace = stack_trace,
+ };
+ const error_name = if (error_info.err) |err| @errorName(err) else "[UnknownError]";
+ try writer.print(
+ jetzig.debug.console_template,
+ .{
+ error_name,
+ debug_content,
+ try request.response_data.toJsonOptions(.{ .pretty = true }),
+ @embedFile("../../assets/debug.css"),
+ },
+ );
+ } else return try self.renderGeneralError(request, status_code);
+
+ const content = try buf.toOwnedSlice();
+
+ return .{
+ .view = .{ .data = request.response_data, .status_code = status_code },
+ .content = if (content.len == 0) "" else content,
+ };
+ } else unreachable;
+}
+
fn renderErrorView(
self: Server,
request: *jetzig.http.Request,
@@ -647,6 +703,13 @@ const StaticResource = struct {
};
fn matchStaticResource(self: *Server, request: *jetzig.http.Request) !?StaticResource {
+ if (comptime jetzig.build_options.debug_console) {
+ if (std.mem.eql(u8, request.path.path, "/_jetzig_debug.js")) return .{
+ .content = @embedFile("../../assets/debug.js"),
+ .mime_type = "text/javascript",
+ };
+ }
+
// TODO: Map public and static routes at launch to avoid accessing the file system when
// matching any route - currently every request causes file system traversal.
const public_resource = try self.matchPublicContent(request);