Something went wrong. Try again.
My version of https://github.com/vercel-labs/fx
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733const std = @import("std");const io_mod = @import("io.zig");const profile_paths = @import("profile_paths.zig");
const Allocator = std.mem.Allocator;
const State = struct { configured: bool = false, enabled: bool = false, stderr_enabled: bool = false, scope_filter: ?[]u8 = null, file_path: ?[]u8 = null,};
const default_log_max_bytes: u64 = 2 * 1024 * 1024;const max_trace_line_bytes: usize = 64 * 1024;
pub const Options = struct { file_path: ?[]const u8 = null, stderr_enabled: bool = false, scope_filter: ?[]const u8 = null,};
pub const TraceContext = struct { turn_id: u64 = 0, step_id: u64 = 0, subagent_id: u64 = 0,};
var state_mutex: std.Io.Mutex = .init;var state: State = .{};var next_turn_id = std.atomic.Value(u64).init(1);var next_step_id = std.atomic.Value(u64).init(1);var next_subagent_id = std.atomic.Value(u64).init(1);
pub fn configureFromEnv(alloc: Allocator, workspace_root: []const u8) void { const options = loadOptionsFromEnv(alloc, workspace_root) catch return; defer if (options.file_path) |path| alloc.free(path); if (options.file_path == null and !options.stderr_enabled) return; configure(options) catch {};}
pub fn shutdown() void { if (!state.configured) return;
const zio = io_mod.getIo(); state_mutex.lockUncancelable(zio); defer state_mutex.unlock(zio);
if (state.scope_filter) |filter| std.heap.c_allocator.free(filter); if (state.file_path) |path| std.heap.c_allocator.free(path); state = .{};}
pub fn activeLogPath() ?[]const u8 { const zio = io_mod.getIo(); state_mutex.lockUncancelable(zio); defer state_mutex.unlock(zio); return state.file_path;}
pub fn nextTurnId() u64 { if (comptime @import("builtin").os.tag == .wasi) return 1; return next_turn_id.fetchAdd(1, .seq_cst);}
pub fn nextStepId() u64 { if (comptime @import("builtin").os.tag == .wasi) return 1; return next_step_id.fetchAdd(1, .seq_cst);}
pub fn nextSubagentId() u64 { if (comptime @import("builtin").os.tag == .wasi) return 1; return next_subagent_id.fetchAdd(1, .seq_cst);}
pub fn logf(scope: []const u8, comptime fmt: []const u8, args: anytype) void { var line: TraceLine = undefined; if (!line.begin(scope)) return; line.print(fmt, args); line.end();}
pub fn eventf(scope: []const u8, event: []const u8, ctx: TraceContext, comptime fmt: []const u8, args: anytype) void { var line: TraceLine = undefined; if (!line.beginEvent(scope, event, ctx, fmt.len != 0)) return; if (fmt.len != 0) line.print(fmt, args); line.end();}
// Keep generic trace wrappers small by centralizing line assembly here.// Failed lines accept remaining writes but emit nothing.const TraceLine = struct { out: std.Io.Writer.Allocating, failed: bool,
noinline fn begin(line: *TraceLine, scope: []const u8) bool { if (!isScopeEnabled(scope)) return false; line.* = .{ .out = .init(std.heap.c_allocator), .failed = false }; line.out.writer.print("{d} [{s}] ", .{ io_mod.milliTimestamp(), scope }) catch { line.failed = true; }; return true; }
noinline fn beginEvent(line: *TraceLine, scope: []const u8, event: []const u8, ctx: TraceContext, has_message: bool) bool { if (!line.begin(scope)) return false; if (line.failed) return true; line.appendEventHead(event, ctx, has_message) catch { line.failed = true; }; return true; }
fn appendEventHead(line: *TraceLine, event: []const u8, ctx: TraceContext, has_message: bool) !void { try line.out.writer.print("event={s}", .{event}); if (ctx.turn_id != 0) try line.out.writer.print(" turn_id={d}", .{ctx.turn_id}); if (ctx.step_id != 0) try line.out.writer.print(" step_id={d}", .{ctx.step_id}); if (ctx.subagent_id != 0) try line.out.writer.print(" subagent_id={d}", .{ctx.subagent_id}); if (has_message) try line.out.writer.writeByte(' '); }
fn print(line: *TraceLine, comptime fmt: []const u8, args: anytype) void { if (line.failed) return; line.out.writer.print(fmt, args) catch { line.failed = true; }; }
noinline fn end(line: *TraceLine) void { defer line.out.deinit(); if (line.failed) return; var safe: std.Io.Writer.Allocating = .init(std.heap.c_allocator); defer safe.deinit(); writeTerminalSafeTraceLine(&safe.writer, line.out.written()) catch return; safe.writer.writeByte('\n') catch return; writeLine(safe.written()); }};
fn writeTerminalSafeTraceLine(writer: *std.Io.Writer, raw: []const u8) !void { const marker = "..."; var index: usize = 0; while (index < raw.len) : (index += 1) { const byte = raw[index]; const encoded_len: usize = if (byte >= 0x20 and byte <= 0x7e) 1 else 4; if (writer.buffered().len + encoded_len + marker.len > max_trace_line_bytes) { try writer.writeAll(marker); return; } if (encoded_len == 1) { try writer.writeByte(byte); } else { try writer.print("\\x{x:0>2}", .{byte}); } }}
pub fn preview(text: []const u8, max_len: usize) []const u8 { const trimmed = std.mem.trim(u8, text, " \t\r\n"); const line_end = std.mem.findScalar(u8, trimmed, '\n') orelse trimmed.len; const first_line = std.mem.trimEnd(u8, trimmed[0..line_end], "\r"); if (first_line.len <= max_len) return first_line; return first_line[0..max_len];}
pub fn terminalPreview(buf: []u8, text: []const u8) []const u8 { if (buf.len == 0) return buf[0..0];
const first_line = preview(text, 512); var in_idx: usize = 0; var out_idx: usize = 0; while (in_idx < first_line.len and out_idx < buf.len) { const byte = first_line[in_idx]; if (byte == 0x1b) { in_idx = skipTerminalEscape(first_line, in_idx); continue; }
buf[out_idx] = if (byte == '\r' or byte == '\n' or byte == '\t') ' ' else if (byte < 0x20 or byte == 0x7f) '?' else byte; out_idx += 1; in_idx += 1; } return buf[0..out_idx];}
fn skipTerminalEscape(text: []const u8, start: usize) usize { if (start + 1 >= text.len) return start + 1;
const introducer = text[start + 1]; if (introducer == '[') { var i = start + 2; while (i < text.len) : (i += 1) { const byte = text[i]; if (byte >= 0x40 and byte <= 0x7e) return i + 1; } return text.len; }
if (introducer == ']') { var i = start + 2; while (i < text.len) : (i += 1) { if (text[i] == 0x07) return i + 1; if (text[i] == 0x1b and i + 1 < text.len and text[i + 1] == '\\') return i + 2; } return text.len; }
return start + 2;}
pub fn redactedJsonPreview(alloc: Allocator, text: []const u8) ![]u8 { if (text.len == 0) return alloc.dupe(u8, "<empty>");
var parsed = std.json.parseFromSlice(std.json.Value, alloc, text, .{}) catch { return std.fmt.allocPrint(alloc, "<invalid-json bytes={d}>", .{text.len}); }; defer parsed.deinit();
var out: std.Io.Writer.Allocating = .init(alloc); errdefer out.deinit(); try writeRedactedJsonValuePreview(&out.writer, parsed.value, 0, .preserve); return out.toOwnedSlice();}
pub fn keylessJsonPreview(alloc: Allocator, text: []const u8) ![]u8 { if (text.len == 0) return alloc.dupe(u8, "<empty>");
var parsed = std.json.parseFromSlice(std.json.Value, alloc, text, .{}) catch |err| { if (err == error.OutOfMemory) return err; return std.fmt.allocPrint(alloc, "<invalid-json bytes={d}>", .{text.len}); }; defer parsed.deinit();
return keylessJsonValuePreview(alloc, parsed.value);}
pub fn keylessJsonValuePreview(alloc: Allocator, value: std.json.Value) ![]u8 { var out: std.Io.Writer.Allocating = .init(alloc); errdefer out.deinit(); try writeRedactedJsonValuePreview(&out.writer, value, 0, .omit); return out.toOwnedSlice();}
const JsonKeyPolicy = enum { preserve, omit,};
fn writeRedactedJsonValuePreview( writer: anytype, value: std.json.Value, depth: usize, key_policy: JsonKeyPolicy,) !void { switch (value) { .object => |object| { if (depth >= 2) { try writer.print("<object_fields={d}>", .{object.count()}); return; }
switch (key_policy) { .preserve => { try writer.writeByte('{'); var it = object.iterator(); var written: usize = 0; while (it.next()) |entry| { if (written > 0) try writer.writeByte(','); if (written >= 6) { try writer.writeAll("..."); break; } try std.json.Stringify.value(entry.key_ptr.*, .{}, writer); try writer.writeByte(':'); try writeRedactedJsonValuePreview(writer, entry.value_ptr.*, depth + 1, key_policy); written += 1; } try writer.writeByte('}'); }, .omit => { try writer.print("<object_fields={d}", .{object.count()}); if (object.count() > 0) { try writer.writeAll(" values=["); var it = object.iterator(); var written: usize = 0; while (it.next()) |entry| { if (written > 0) try writer.writeByte(','); if (written >= 6) { try writer.writeAll("..."); break; } try writeRedactedJsonValuePreview(writer, entry.value_ptr.*, depth + 1, key_policy); written += 1; } try writer.writeByte(']'); } try writer.writeByte('>'); }, } }, .array => |array| try writer.print("<array_len={d}>", .{array.items.len}), .string => |string| try writer.print("<string_bytes={d}>", .{string.len}), .integer, .float, .number_string => try writer.writeAll("<number>"), .bool => try writer.writeAll("<bool>"), .null => try writer.writeAll("<null>"), }}
pub fn resetForTest() void { shutdown(); next_turn_id.store(1, .seq_cst); next_step_id.store(1, .seq_cst); next_subagent_id.store(1, .seq_cst);}
pub fn configureForTest(alloc: Allocator, path: []const u8) !void { const owned = try alloc.dupe(u8, path); defer alloc.free(owned); try configure(.{ .file_path = owned });}
pub fn configureForTestWithScopes(alloc: Allocator, path: []const u8, scope_filter: []const u8) !void { const owned = try alloc.dupe(u8, path); defer alloc.free(owned); try configure(.{ .file_path = owned, .scope_filter = scope_filter });}
pub fn configure(options: Options) !void { const zio = io_mod.getIo(); state_mutex.lockUncancelable(zio); defer state_mutex.unlock(zio);
if (state.configured) return; state.configured = true; state.stderr_enabled = options.stderr_enabled;
if (options.file_path) |path| { try ensureParentDir(path); rotateIfTooLarge(path, default_log_max_bytes); var file = try std.Io.Dir.createFileAbsolute(zio, path, .{ .truncate = false }); file.close(zio); state.file_path = std.heap.c_allocator.dupe(u8, path) catch null; } if (options.scope_filter) |filter| { const trimmed = std.mem.trim(u8, filter, " \t\r\n"); if (trimmed.len > 0) state.scope_filter = try std.heap.c_allocator.dupe(u8, trimmed); }
state.enabled = state.stderr_enabled or state.file_path != null;}
fn rotateIfTooLarge(path: []const u8, max_bytes: u64) void { const zio = io_mod.getIo(); var file = std.Io.Dir.openFileAbsolute(zio, path, .{}) catch return; var should_truncate = false; { defer file.close(zio); const stat = file.stat(zio) catch return; if (stat.size > max_bytes) should_truncate = true; } if (!should_truncate) return; var truncate = std.Io.Dir.createFileAbsolute(zio, path, .{ .truncate = true }) catch return; truncate.close(zio);}
pub fn isEnabled() bool { const zio = io_mod.getIo(); state_mutex.lockUncancelable(zio); defer state_mutex.unlock(zio); return state.enabled;}
pub fn isScopeEnabled(scope: []const u8) bool { const zio = io_mod.getIo(); state_mutex.lockUncancelable(zio); defer state_mutex.unlock(zio); if (!state.enabled) return false; const filter = state.scope_filter orelse return true; return scopeFilterAllows(filter, scope);}
fn writeLine(line: []const u8) void { const zio = io_mod.getIo(); state_mutex.lockUncancelable(zio); defer state_mutex.unlock(zio);
if (!state.enabled) return;
if (state.stderr_enabled) { std.debug.print("{s}", .{line}); } if (state.file_path) |path| { appendLineToFile(zio, path, line); }}
fn appendLineToFile(zio: std.Io, path: []const u8, line: []const u8) void { var file = std.Io.Dir.createFileAbsolute(zio, path, .{ .truncate = false, .lock = .exclusive, }) catch return; defer file.close(zio); _ = std.c.lseek(file.handle, 0, std.posix.SEEK.END); file.writeStreamingAll(zio, line) catch {};}
fn loadOptionsFromEnv(alloc: Allocator, workspace_root: []const u8) !Options { const trace_log = loadOptionalEnv("FX_TRACE_LOG"); const trace_flag = loadOptionalEnv("FX_TRACE"); const trace_stderr = loadOptionalEnv("FX_TRACE_STDERR"); const trace_scopes = loadOptionalEnv("FX_TRACE_SCOPES"); const stderr_enabled = isTruthy(trace_stderr);
if (trace_log) |raw_path| { const resolved = try resolveLogPath(alloc, workspace_root, raw_path); return .{ .file_path = resolved, .stderr_enabled = stderr_enabled, .scope_filter = trace_scopes }; }
if (isTruthy(trace_flag)) { return .{ .file_path = try defaultLogPath(alloc), .stderr_enabled = stderr_enabled, .scope_filter = trace_scopes, }; }
return .{ .stderr_enabled = stderr_enabled, .scope_filter = trace_scopes };}
fn loadOptionalEnv(name: []const u8) ?[]const u8 { return io_mod.getenv(name);}
fn isTruthy(value: ?[]const u8) bool { const raw = value orelse return false; const trimmed = std.mem.trim(u8, raw, " \t\r\n"); return std.ascii.eqlIgnoreCase(trimmed, "1") or std.ascii.eqlIgnoreCase(trimmed, "true") or std.ascii.eqlIgnoreCase(trimmed, "yes") or std.ascii.eqlIgnoreCase(trimmed, "on");}
fn scopeFilterAllows(filter: []const u8, scope: []const u8) bool { var rest = filter; while (true) { const next_comma = std.mem.findScalar(u8, rest, ','); const raw_part = if (next_comma) |idx| rest[0..idx] else rest; const part = std.mem.trim(u8, raw_part, " \t\r\n"); if (part.len > 0 and std.mem.eql(u8, part, scope)) return true; if (next_comma) |idx| { rest = rest[idx + 1 ..]; } else { return false; } }}
fn resolveLogPath(alloc: Allocator, workspace_root: []const u8, raw_path: []const u8) ![]u8 { const trimmed = std.mem.trim(u8, raw_path, " \t\r\n"); if (trimmed.len == 0) return error.InvalidTracePath; if (std.fs.path.isAbsolute(trimmed)) return alloc.dupe(u8, trimmed); return std.fs.path.join(alloc, &.{ workspace_root, trimmed });}
fn defaultLogPath(alloc: Allocator) ![]u8 { if (io_mod.getenv("HOME")) |home| { return defaultLogPathForHome(alloc, home); } return fallbackLogPathForMillis(alloc, io_mod.milliTimestamp());}
fn defaultLogPathForHome(alloc: Allocator, home: []const u8) ![]u8 { return profile_paths.traceLogPath(alloc, home);}
fn fallbackLogPathForMillis(alloc: Allocator, millis: i64) ![]u8 { return std.fmt.allocPrint(alloc, "/tmp/fx-trace-{d}.log", .{millis});}
fn ensureParentDir(path: []const u8) !void { const parent = std.fs.path.dirname(path) orelse return; try makeAbsolutePath(parent);}
fn makeAbsolutePath(path: []const u8) !void { const zio = io_mod.getIo(); std.Io.Dir.createDirAbsolute(zio, path, .default_dir) catch |err| switch (err) { error.PathAlreadyExists => {}, else => { if (std.fs.path.dirname(path)) |parent| { try makeAbsolutePath(parent); try std.Io.Dir.createDirAbsolute(zio, path, .default_dir); } else { return err; } }, };}
fn tmpRoot(alloc: Allocator, tmp: std.testing.TmpDir) ![]u8 { return io_mod.dirRealpathAlloc(alloc, tmp.dir, ".");}
fn tmpPath(alloc: Allocator, root: []const u8, name: []const u8) ![]u8 { return std.fs.path.join(alloc, &.{ root, name });}
fn readFileForTest(alloc: Allocator, path: []const u8) ![]u8 { const zio = io_mod.getIo(); var file = try std.Io.Dir.openFileAbsolute(zio, path, .{}); defer file.close(zio); return io_mod.readFileToEnd(alloc, &file, 8192);}
test "isTruthy parses accepted and rejected values" { try std.testing.expect(isTruthy("1")); try std.testing.expect(isTruthy("true")); try std.testing.expect(isTruthy("YES")); try std.testing.expect(isTruthy("on")); try std.testing.expect(!isTruthy("0")); try std.testing.expect(!isTruthy("")); try std.testing.expect(!isTruthy(" \t\r\n")); try std.testing.expect(!isTruthy(null));}
test "home default log path uses fx logs directory" { const alloc = std.testing.allocator; const path = try defaultLogPathForHome(alloc, "/tmp/fake-home"); defer alloc.free(path); try std.testing.expectEqualStrings("/tmp/fake-home/.fx/logs/trace.log", path);}
test "fallback default log path uses tmp trace path" { const alloc = std.testing.allocator; const path = try fallbackLogPathForMillis(alloc, 12345); defer alloc.free(path); try std.testing.expectEqualStrings("/tmp/fx-trace-12345.log", path);}
test "trace logger writes configured file" { const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); const root = try tmpRoot(alloc, tmp); defer alloc.free(root); const path = try tmpPath(alloc, root, "trace.log"); defer alloc.free(path);
resetForTest(); defer resetForTest(); try configureForTest(alloc, path); logf("test", "hello {d}", .{42});
const trace = try readFileForTest(alloc, path); defer alloc.free(trace); try std.testing.expect(std.mem.find(u8, trace, "[test] hello 42") != null);}
test "trace logger filters scopes and writes structured events" { const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); const root = try tmpRoot(alloc, tmp); defer alloc.free(root); const path = try tmpPath(alloc, root, "scoped-trace.log"); defer alloc.free(path);
resetForTest(); defer resetForTest(); try configureForTestWithScopes(alloc, path, "agent, tool"); logf("agent", "human line", .{}); logf("worker", "filtered line", .{}); eventf("tool", "execution_start", .{ .turn_id = 7, .step_id = 11 }, "name={s}", .{"read_file"});
const trace = try readFileForTest(alloc, path); defer alloc.free(trace); try std.testing.expect(std.mem.find(u8, trace, "[agent] human line") != null); try std.testing.expect(std.mem.find(u8, trace, "[worker] filtered line") == null); try std.testing.expect(std.mem.find(u8, trace, "[tool] event=execution_start turn_id=7 step_id=11 name=read_file") != null);}
test "trace id generators reset for tests" { resetForTest(); try std.testing.expectEqual(@as(u64, 1), nextTurnId()); try std.testing.expectEqual(@as(u64, 2), nextTurnId()); try std.testing.expectEqual(@as(u64, 1), nextStepId()); resetForTest(); try std.testing.expectEqual(@as(u64, 1), nextTurnId());}
test "redactedJsonPreview reports shape without values" { const alloc = std.testing.allocator; const preview_text = try redactedJsonPreview(alloc, "{\"path\":\"secret.txt\",\"content\":\"very secret\",\"nested\":{\"token\":\"abc\"}}"); defer alloc.free(preview_text);
try std.testing.expect(std.mem.find(u8, preview_text, "\"path\":<string_bytes=") != null); try std.testing.expect(std.mem.find(u8, preview_text, "\"content\":<string_bytes=") != null); try std.testing.expect(std.mem.find(u8, preview_text, "secret.txt") == null); try std.testing.expect(std.mem.find(u8, preview_text, "very secret") == null); try std.testing.expect(std.mem.find(u8, preview_text, "abc") == null);}
test "keylessJsonPreview reports shape without keys or values" { const alloc = std.testing.allocator; const preview_text = try keylessJsonPreview(alloc, "{\"FX_DYNAMIC_PATH\":\"secret.txt\",\"FX_DYNAMIC_CONTENT\":\"very secret\",\"nested\":{\"FX_DYNAMIC_TOKEN\":\"abc\"}}"); defer alloc.free(preview_text);
try std.testing.expect(std.mem.find(u8, preview_text, "<object_fields=3 values=[") != null); try std.testing.expect(std.mem.find(u8, preview_text, "FX_DYNAMIC_PATH") == null); try std.testing.expect(std.mem.find(u8, preview_text, "FX_DYNAMIC_CONTENT") == null); try std.testing.expect(std.mem.find(u8, preview_text, "FX_DYNAMIC_TOKEN") == null); try std.testing.expect(std.mem.find(u8, preview_text, "secret.txt") == null); try std.testing.expect(std.mem.find(u8, preview_text, "very secret") == null); try std.testing.expect(std.mem.find(u8, preview_text, "abc") == null);}
test "preview trims and keeps first line" { try std.testing.expectEqualStrings("first", preview(" \t\nfirst\nsecond\n ", 128));}
test "preview trims trailing carriage return for CRLF input" { try std.testing.expectEqualStrings("first", preview("first\r\nsecond", 128));}
test "preview clamps by byte length" { try std.testing.expectEqualStrings("abcd", preview("abcdef", 4));}
test "preview returns borrowed slice" { const input: []const u8 = " borrowed "; const result = preview(input, 128); const input_start = @intFromPtr(input.ptr); const input_end = input_start + input.len; const result_start = @intFromPtr(result.ptr); try std.testing.expect(result_start >= input_start); try std.testing.expect(result_start < input_end);}
test "terminalPreview strips common terminal controls" { var buf: [64]u8 = undefined; const result = terminalPreview(buf[0..], "hi \x1b[31mred\x1b[0m \x1b]8;;https://example.com\x07link\x1b]8;;\x07\nnext"); try std.testing.expectEqualStrings("hi red link", result);}
test "trace lines encode every non-ASCII and control byte" { var out: std.Io.Writer.Allocating = .init(std.testing.allocator); defer out.deinit(); try writeTerminalSafeTraceLine( &out.writer, "server=bad\n\x1b]0;owned\x07\xff", ); try std.testing.expectEqualStrings( "server=bad\\x0a\\x1b]0;owned\\x07\\xff", out.written(), );}
test "resolveLogPath resolves absolute and relative paths" { const alloc = std.testing.allocator; const absolute = try resolveLogPath(alloc, "/tmp/workspace", " \t/tmp/fx-absolute-trace.log\n"); defer alloc.free(absolute); try std.testing.expectEqualStrings("/tmp/fx-absolute-trace.log", absolute);
const relative = try resolveLogPath(alloc, "/tmp/workspace", "logs/trace.log"); defer alloc.free(relative); const expected = try std.fs.path.join(alloc, &.{ "/tmp/workspace", "logs/trace.log" }); defer alloc.free(expected); try std.testing.expectEqualStrings(expected, relative);}
test "resolveLogPath rejects empty trace paths" { const alloc = std.testing.allocator; try std.testing.expectError(error.InvalidTracePath, resolveLogPath(alloc, "/tmp/workspace", "")); try std.testing.expectError(error.InvalidTracePath, resolveLogPath(alloc, "/tmp/workspace", " \t\r\n"));}
test "configure is first config wins" { const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); const root = try tmpRoot(alloc, tmp); defer alloc.free(root); const first_path = try tmpPath(alloc, root, "first.log"); defer alloc.free(first_path); const second_path = try tmpPath(alloc, root, "second.log"); defer alloc.free(second_path);
resetForTest(); defer resetForTest(); try configureForTest(alloc, first_path); try configure(.{ .file_path = second_path }); logf("test", "first sink only", .{});
const first_trace = try readFileForTest(alloc, first_path); defer alloc.free(first_trace); try std.testing.expect(std.mem.find(u8, first_trace, "first sink only") != null); try std.testing.expectError(error.FileNotFound, std.Io.Dir.openFileAbsolute(std.testing.io, second_path, .{}));}
test "configure enables stderr-only tracing" { resetForTest(); defer resetForTest(); try configure(.{ .stderr_enabled = true }); try std.testing.expect(isEnabled());}
test "shutdown clears state and allows reconfigure" { resetForTest(); defer resetForTest(); try configure(.{ .stderr_enabled = true }); try std.testing.expect(isEnabled()); shutdown(); try std.testing.expect(!isEnabled()); try configure(.{ .stderr_enabled = true }); try std.testing.expect(isEnabled());}
test "configureFromEnv leaves tracing disabled without env" { resetForTest(); defer resetForTest(); try std.testing.expect(io_mod.getenv("FX_TRACE_LOG") == null); try std.testing.expect(io_mod.getenv("FX_TRACE") == null); try std.testing.expect(io_mod.getenv("FX_TRACE_STDERR") == null); configureFromEnv(std.testing.allocator, "/tmp/workspace"); try std.testing.expect(!isEnabled());}