fixes

src/main.zig

@@ -67,9 +67,11 @@ fn readConfig(allocator: std.mem.Allocator, path: []const u8) !ConfigWrapper(Con
         .arena = try allocator.create(std.heap.ArenaAllocator),
         .value = undefined,
     };
-    config.arena.child_allocator = allocator;
+    errdefer allocator.destroy(config.arena);
-    const data = try std.fs.cwd().readFileAlloc(config.arena.child_allocator, path, 1024);
+    config.arena.* = std.heap.ArenaAllocator.init(allocator);
-    config.value = try std.json.parseFromSliceLeaky(Config, config.arena.child_allocator, data, .{});
+    errdefer config.arena.deinit();
+    const data = try std.fs.cwd().readFileAlloc(config.arena.allocator(), path, 1024);
+    config.value = try std.json.parseFromSliceLeaky(Config, config.arena.allocator(), data, .{});
     return config;
 }
 
@@ -102,7 +104,10 @@ pub fn main() !void {
     var password_buffer: [128]u8 = undefined;
     var password: []const u8 = undefined;
     if (config.value.loki.password_file) |password_file_path| {
-        password = try std.fs.cwd().readFile(password_file_path, &password_buffer);
+        password = std.fs.cwd().readFile(password_file_path, &password_buffer) catch |err| {
+            iperf3_log.err("error trying to read password file {s}: {}", .{ password_file_path, err });
+            return;
+        };
         password = std.mem.trimRight(u8, password, "\r\n");
     } else if (config.value.loki.password) |password_data| {
         @memcpy(&password_buffer, password_data);
@@ -133,9 +138,6 @@ pub fn main() !void {
 
     const uri = try std.Uri.parse(url);
 
-    var client = std.http.Client{ .allocator = allocator };
-    defer client.deinit();
-
     var port_buf: [16]u8 = undefined;
     var port: []u8 = undefined;
     if (config.value.iperf3.port) |p| {
@@ -155,7 +157,10 @@ pub fn main() !void {
     }
 
     while (true) {
-        iperf3_log.info("waiting for connection", .{});
+        iperf3_log.info("starting new iperf3", .{});
+
+        var arena = std.heap.ArenaAllocator.init(allocator);
+        defer arena.deinit();
 
         var c = std.process.Child.init(
             &[_][]const u8{
@@ -166,33 +171,61 @@ pub fn main() !void {
                 "--json",
                 "--one-off",
             },
-            allocator,
+            arena.allocator(),
         );
         c.stdin_behavior = .Ignore;
         c.stdout_behavior = .Pipe;
-        c.stderr_behavior = .Ignore;
+        c.stderr_behavior = .Pipe;
         try c.spawn();
 
-        var reader = c.stdout.?.reader();
+        var stdout = std.ArrayList(u8).init(arena.allocator());
-        var token_reader = std.json.reader(allocator, reader);
+        var stderr = std.ArrayList(u8).init(arena.allocator());
 
-        var obj = try std.json.parseFromTokenSource(
+        iperf3_log.info("waiting for data", .{});
+
+        try c.collectOutput(&stdout, &stderr, 16384);
+
+        var filename_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+        var filename: []u8 = undefined;
+        var timestamp = std.time.nanoTimestamp();
+
+        filename = try std.fmt.bufPrint(&filename_buf, "/tmp/{d}-stdout.json", .{timestamp});
+        try std.fs.cwd().writeFile(filename, stdout.items);
+
+        filename = try std.fmt.bufPrint(&filename_buf, "/tmp/{d}-stderr.json", .{timestamp});
+        try std.fs.cwd().writeFile(filename, stderr.items);
+
+        // var token_reader = std.json.reader(allocator, reader);
+
+        var obj_or_err = std.json.parseFromSliceLeaky(
             iperf3.IPerfReturn,
-            allocator,
+            arena.allocator(),
-            &token_reader,
+            stdout.items,
             .{},
         );
-        defer obj.deinit();
 
-        var line = std.ArrayList(u8).init(allocator);
+        var level = loki.LogLevel.info;
-        try std.json.stringify(
+        if (obj_or_err) |obj| {
-            obj.value,
+            iperf3_log.info("successfully parsed json {d}", .{timestamp});
-            .{
+            if (obj.@"error") |err| {
-                .emit_null_optional_fields = false,
+                iperf3_log.err("error from iperf3: {s}", .{err});
-            },
+                level = loki.LogLevel.@"error";
-            line.writer(),
+            }
-        );
+        } else |err| switch (err) {
-        defer line.deinit();
+            error.UnknownField => iperf3_log.err("unknown field parsing json {d}", .{timestamp}),
+            error.UnexpectedEndOfInput => iperf3_log.err("unexpected end of input parsing json {d}", .{timestamp}),
+            else => iperf3_log.err("other error while parsing json {} {d}", .{ err, timestamp }),
+        }
+
+        // var line = std.ArrayList(u8).init(allocator);
+        // try std.json.stringify(
+        //     obj.value,
+        //     .{
+        //         .emit_null_optional_fields = false,
+        //     },
+        //     line.writer(),
+        // );
+        // defer line.deinit();
 
         const streams = loki.LokiStreams{
             .streams = &[_]loki.LokiStream{
@@ -200,19 +233,19 @@ pub fn main() !void {
                     .stream = .{
                         .job = "iperf3",
                         .server = hostname,
-                        .level = if (obj.value.@"error" == null) .info else .@"error",
+                        .level = level,
                     },
                     .values = &[_]loki.LokiValue{
                         .{
-                            .ts = std.time.nanoTimestamp(),
+                            .ts = timestamp,
-                            .line = line.items,
+                            .line = stdout.items,
                         },
                     },
                 },
             },
         };
 
-        var data = std.ArrayList(u8).init(allocator);
+        var data = std.ArrayList(u8).init(arena.allocator());
         try std.json.stringify(
             streams,
             .{
@@ -229,22 +262,49 @@ pub fn main() !void {
             .{data.items.len},
         );
 
-        var headers = std.http.Headers{ .allocator = allocator };
+        var client = std.http.Client{ .allocator = arena.allocator() };
+        defer client.deinit();
+
+        var headers = std.http.Headers{ .allocator = arena.allocator() };
         try headers.append("Authorization", auth_header);
         try headers.append("Accept", "application/json");
         try headers.append("Content-Type", "application/json");
         try headers.append("Content-Length", content_length);
+        defer headers.deinit();
 
-        var req = try client.request(.POST, uri, headers, .{});
+        var req = try client.request(
+            .POST,
+            uri,
+            headers,
+            .{},
+        );
         defer req.deinit();
 
+        iperf3_log.info("sending stream to loki", .{});
+
         try req.start();
         try req.writeAll(data.items);
         try req.finish();
         try req.wait();
 
-        iperf3_log.info("{}\n", .{req.response.status});
+        if (req.response.status == .no_content) {
+            iperf3_log.info("successfully sent stream to loki", .{});
+        } else {
+            iperf3_log.info("response from loki: {}\n", .{req.response.status});
+        }
+        const term = try c.wait();
 
-        _ = try c.wait();
+        switch (term) {
+            .Exited => |value| {
+                if (value == 0) {
+                    iperf3_log.info("iperf3 competed successfully", .{});
+                } else {
+                    iperf3_log.info("iperf3 exited with error {d}", .{value});
+                }
+            },
+            else => {
+                iperf3_log.info("iperf3 terminated: {}", .{term});
+            },
+        }
     }
 }