|
| 1 | +import { describe, expect, test } from "bun:test" |
| 2 | +import fs from "fs/promises" |
| 3 | +import path from "path" |
| 4 | +import { Tracer, FileExporter, type TraceFile } from "../../src/altimate/observability/tracing" |
| 5 | +import { tmpdir } from "../fixture/fixture" |
| 6 | + |
| 7 | +function makeStepFinish(overrides?: Partial<{ id: string; cost: number }>) { |
| 8 | + return { |
| 9 | + id: overrides?.id ?? "step-1", |
| 10 | + reason: "stop", |
| 11 | + cost: overrides?.cost ?? 0.005, |
| 12 | + tokens: { |
| 13 | + input: 1500, |
| 14 | + output: 300, |
| 15 | + reasoning: 100, |
| 16 | + cache: { read: 200, write: 50 }, |
| 17 | + }, |
| 18 | + } |
| 19 | +} |
| 20 | + |
| 21 | +describe("Trace persistence across sessions", () => { |
| 22 | + test("traces from multiple sessions are all persisted and listable", async () => { |
| 23 | + await using tmp = await tmpdir() |
| 24 | + const sessions = ["ses_first", "ses_second", "ses_third"] |
| 25 | + |
| 26 | + for (const sessionId of sessions) { |
| 27 | + const exporter = new FileExporter(tmp.path) |
| 28 | + const tracer = Tracer.withExporters([exporter]) |
| 29 | + tracer.startTrace(sessionId, { |
| 30 | + title: `Session ${sessionId}`, |
| 31 | + prompt: `prompt for ${sessionId}`, |
| 32 | + }) |
| 33 | + |
| 34 | + tracer.logStepStart({ id: "step-1" }) |
| 35 | + tracer.logStepFinish(makeStepFinish()) |
| 36 | + await tracer.endTrace() |
| 37 | + } |
| 38 | + |
| 39 | + const files = await fs.readdir(tmp.path) |
| 40 | + const jsonFiles = files.filter((f) => f.endsWith(".json")) |
| 41 | + expect(jsonFiles.length).toBe(3) |
| 42 | + |
| 43 | + const traces = await Tracer.listTraces(tmp.path) |
| 44 | + expect(traces.length).toBe(3) |
| 45 | + |
| 46 | + const listedIds = traces.map((t) => t.sessionId) |
| 47 | + for (const sessionId of sessions) { |
| 48 | + expect(listedIds).toContain(sessionId) |
| 49 | + } |
| 50 | + |
| 51 | + for (const { sessionId, trace } of traces) { |
| 52 | + expect(trace.metadata.title).toBe(`Session ${sessionId}`) |
| 53 | + expect(trace.metadata.prompt).toBe(`prompt for ${sessionId}`) |
| 54 | + expect(trace.summary.status).toBe("completed") |
| 55 | + } |
| 56 | + }) |
| 57 | + |
| 58 | + test("ending one session does not affect traces from other sessions", async () => { |
| 59 | + await using tmp = await tmpdir() |
| 60 | + |
| 61 | + const exporter1 = new FileExporter(tmp.path) |
| 62 | + const tracer1 = Tracer.withExporters([exporter1]) |
| 63 | + tracer1.startTrace("ses_A", { title: "Session A", prompt: "prompt A" }) |
| 64 | + tracer1.logStepStart({ id: "step-1" }) |
| 65 | + tracer1.logStepFinish(makeStepFinish()) |
| 66 | + await tracer1.endTrace() |
| 67 | + |
| 68 | + let traces = await Tracer.listTraces(tmp.path) |
| 69 | + expect(traces.length).toBe(1) |
| 70 | + expect(traces[0].sessionId).toBe("ses_A") |
| 71 | + |
| 72 | + const exporter2 = new FileExporter(tmp.path) |
| 73 | + const tracer2 = Tracer.withExporters([exporter2]) |
| 74 | + tracer2.startTrace("ses_B", { title: "Session B", prompt: "prompt B" }) |
| 75 | + tracer2.logStepStart({ id: "step-1" }) |
| 76 | + tracer2.logStepFinish(makeStepFinish()) |
| 77 | + await tracer2.endTrace() |
| 78 | + |
| 79 | + traces = await Tracer.listTraces(tmp.path) |
| 80 | + expect(traces.length).toBe(2) |
| 81 | + |
| 82 | + const ids = traces.map((t) => t.sessionId) |
| 83 | + expect(ids).toContain("ses_A") |
| 84 | + expect(ids).toContain("ses_B") |
| 85 | + |
| 86 | + const traceA = traces.find((t) => t.sessionId === "ses_A")! |
| 87 | + expect(traceA.trace.metadata.title).toBe("Session A") |
| 88 | + expect(traceA.trace.summary.status).toBe("completed") |
| 89 | + }) |
| 90 | + |
| 91 | + test("listTraces returns traces sorted by newest first", async () => { |
| 92 | + await using tmp = await tmpdir() |
| 93 | + |
| 94 | + for (let i = 0; i < 3; i++) { |
| 95 | + const exporter = new FileExporter(tmp.path) |
| 96 | + const tracer = Tracer.withExporters([exporter]) |
| 97 | + tracer.startTrace(`ses_${i}`, { title: `Session ${i}` }) |
| 98 | + tracer.logStepStart({ id: "step-1" }) |
| 99 | + tracer.logStepFinish(makeStepFinish()) |
| 100 | + await tracer.endTrace() |
| 101 | + await new Promise((r) => setTimeout(r, 10)) |
| 102 | + } |
| 103 | + |
| 104 | + const traces = await Tracer.listTraces(tmp.path) |
| 105 | + expect(traces.length).toBe(3) |
| 106 | + |
| 107 | + for (let i = 0; i < traces.length - 1; i++) { |
| 108 | + const dateA = new Date(traces[i].trace.startedAt).getTime() |
| 109 | + const dateB = new Date(traces[i + 1].trace.startedAt).getTime() |
| 110 | + expect(dateA).toBeGreaterThanOrEqual(dateB) |
| 111 | + } |
| 112 | + }) |
| 113 | + |
| 114 | + test("traces are individually accessible by session ID filename", async () => { |
| 115 | + await using tmp = await tmpdir() |
| 116 | + const sessionId = "ses_unique123" |
| 117 | + const exporter = new FileExporter(tmp.path) |
| 118 | + const tracer = Tracer.withExporters([exporter]) |
| 119 | + tracer.startTrace(sessionId, { title: "Unique Session", prompt: "test prompt" }) |
| 120 | + tracer.logStepStart({ id: "step-1" }) |
| 121 | + tracer.logStepFinish(makeStepFinish()) |
| 122 | + await tracer.endTrace() |
| 123 | + |
| 124 | + const expectedFile = path.join(tmp.path, `${sessionId}.json`) |
| 125 | + const exists = await fs.stat(expectedFile).then(() => true).catch(() => false) |
| 126 | + expect(exists).toBe(true) |
| 127 | + |
| 128 | + const content = await fs.readFile(expectedFile, "utf-8") |
| 129 | + const trace = JSON.parse(content) as TraceFile |
| 130 | + expect(trace.sessionId).toBe(sessionId) |
| 131 | + expect(trace.metadata.title).toBe("Unique Session") |
| 132 | + expect(trace.summary.totalTokens).toBeGreaterThan(0) |
| 133 | + }) |
| 134 | + |
| 135 | + test("listTraces returns empty array when no traces exist", async () => { |
| 136 | + await using tmp = await tmpdir() |
| 137 | + const traces = await Tracer.listTraces(tmp.path) |
| 138 | + expect(traces).toEqual([]) |
| 139 | + }) |
| 140 | + |
| 141 | + test("listTraces skips corrupted JSON files gracefully", async () => { |
| 142 | + await using tmp = await tmpdir() |
| 143 | + |
| 144 | + // Write a valid trace |
| 145 | + const exporter = new FileExporter(tmp.path) |
| 146 | + const tracer = Tracer.withExporters([exporter]) |
| 147 | + tracer.startTrace("ses_valid", { title: "Valid Session" }) |
| 148 | + tracer.logStepStart({ id: "step-1" }) |
| 149 | + tracer.logStepFinish(makeStepFinish()) |
| 150 | + await tracer.endTrace() |
| 151 | + |
| 152 | + // Write a corrupted JSON file |
| 153 | + await fs.writeFile(path.join(tmp.path, "corrupted.json"), "not valid json{{{") |
| 154 | + |
| 155 | + const traces = await Tracer.listTraces(tmp.path) |
| 156 | + expect(traces.length).toBe(1) |
| 157 | + expect(traces[0].sessionId).toBe("ses_valid") |
| 158 | + }) |
| 159 | +}) |
0 commit comments