add error handling (with caveat)

This commit is contained in:
Emil Lerch 2021-10-03 13:08:24 -07:00
parent 24e46bcf11
commit e698a789b4
Signed by untrusted user: lobo
GPG Key ID: A7B62D657EF764F8

View File

@ -13,7 +13,7 @@ pub fn run(event_handler: fn (*std.mem.Allocator, []const u8) anyerror![]const u
const url = try std.fmt.allocPrint(allocator, "{s}{s}{s}/next", .{ prefix, lambda_runtime_uri, postfix }); const url = try std.fmt.allocPrint(allocator, "{s}{s}{s}/next", .{ prefix, lambda_runtime_uri, postfix });
defer allocator.free(url); defer allocator.free(url);
std.log.info("Event Url: {s}", .{url}); std.log.notice("Bootstrap initializing with event url: {s}", .{url});
while (true) { while (true) {
var req_alloc = std.heap.ArenaAllocator.init(allocator); var req_alloc = std.heap.ArenaAllocator.init(allocator);
@ -21,9 +21,14 @@ pub fn run(event_handler: fn (*std.mem.Allocator, []const u8) anyerror![]const u
const req_allocator = &req_alloc.allocator; const req_allocator = &req_alloc.allocator;
var client = try requestz.Client.init(req_allocator); var client = try requestz.Client.init(req_allocator);
// defer client.deinit(); // defer client.deinit();
// Lambda freezes the process at this line of code. During warm start,
// the process will unfreeze and data will be sent in response to client.get
var response = client.get(url, .{}) catch |err| { var response = client.get(url, .{}) catch |err| {
// TODO: report error
std.log.err("Get fail: {}", .{err}); std.log.err("Get fail: {}", .{err});
// Documentation says something about "exit immediately". The
// Lambda infrastrucutre restarts, so it's unclear if that's necessary.
// It seems as though a continue should be fine, and slightly faster
// std.os.exit(1);
continue; continue;
}; };
defer response.deinit(); defer response.deinit();
@ -32,17 +37,51 @@ pub fn run(event_handler: fn (*std.mem.Allocator, []const u8) anyerror![]const u
for (response.headers.items()) |h| { for (response.headers.items()) |h| {
if (std.mem.indexOf(u8, h.name.value, "Lambda-Runtime-Aws-Request-Id")) |_| if (std.mem.indexOf(u8, h.name.value, "Lambda-Runtime-Aws-Request-Id")) |_|
request_id = h.value; request_id = h.value;
// TODO: XRay uses an environment variable to do its magic. It's our
// responsibility to set this, but no zig-native setenv(3)/putenv(3)
// exists. I would kind of rather not link in libc for this,
// so we'll hold for now and think on this
// if (std.mem.indexOf(u8, h.name.value, "Lambda-Runtime-Trace-Id")) |_|
// std.process.
// std.os.setenv("AWS_LAMBDA_RUNTIME_API");
} }
if (request_id == null) { if (request_id == null) {
// TODO: report error // We can't report back an issue because the runtime error reporting endpoint
// uses request id in its path. So the best we can do is log the error and move
// on here.
std.log.err("Could not find request id: skipping request", .{}); std.log.err("Could not find request id: skipping request", .{});
continue; continue;
} }
const req_id = request_id.?; const req_id = request_id.?;
const event_response = event_handler(req_allocator, response.body) catch |err| { const event_response = event_handler(req_allocator, response.body) catch |err| {
// TODO: report error // Stack trace will return null if stripped
std.log.err("Error posting response for request id {s}: {}", .{ req_id, err }); const return_trace = @errorReturnTrace();
std.log.err("Caught error: {}. Return Trace: {}", .{ err, return_trace });
const err_url = try std.fmt.allocPrint(req_allocator, "{s}{s}/runtime/invocation/{s}/error", .{ prefix, lambda_runtime_uri, req_id });
defer req_allocator.free(err_url);
const content =
\\ {s}
\\ "errorMessage": "{s}",
\\ "errorType": "HandlerReturnedError",
\\ "stackTrace": [ "{}" ]
\\ {s}
;
const content_fmt = try std.fmt.allocPrint(req_allocator, content, .{ "{", @errorName(err), return_trace, "}" });
defer req_allocator.free(content_fmt);
std.log.err("Posting to {s}: Data {s}", .{ err_url, content_fmt });
var headers = .{.{ "Lambda-Runtime-Function-Error-Type", "HandlerReturned" }};
// TODO: Determine why this post is not returning
var err_resp = client.post(err_url, .{
.content = content_fmt,
.headers = headers,
}) catch |post_err| { // Well, at this point all we can do is shout at the void
std.log.err("Error posting response for request id {s}: {}", .{ req_id, post_err });
std.os.exit(0);
continue;
};
std.log.err("Post complete", .{});
defer err_resp.deinit();
continue; continue;
}; };
const response_url = try std.fmt.allocPrint(req_allocator, "{s}{s}{s}/{s}/response", .{ prefix, lambda_runtime_uri, postfix, req_id }); const response_url = try std.fmt.allocPrint(req_allocator, "{s}{s}{s}/{s}/response", .{ prefix, lambda_runtime_uri, postfix, req_id });