langfuse

1
/** @jest-environment node */
2

3
import { prisma } from "@/src/server/db";
4
import { makeAPICall, pruneDatabase } from "@/src/__tests__/test-utils";
5
import { v4 as uuidv4 } from "uuid";
6

7
describe("/api/public/spans API Endpoint", () => {
8
  beforeEach(async () => await pruneDatabase());
9
  afterEach(async () => await pruneDatabase());
10

11
  it("should create span after trace", async () => {
12
    await pruneDatabase();
13

14
    const traceId = uuidv4();
15

16
    await makeAPICall("POST", "/api/public/traces", {
17
      id: traceId,
18
      name: "trace-name",
19
      userId: "user-1",
20
      projectId: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a",
21
      metadata: { key: "value" },
22
      release: "1.0.0",
23
      version: "2.0.0",
24
    });
25

26
    const dbTrace = await prisma.trace.findMany({
27
      where: {
28
        id: traceId,
29
      },
30
    });
31

32
    expect(dbTrace.length).toBeGreaterThan(0);
33
    expect(dbTrace[0]?.id).toBe(traceId);
34

35
    const spanId = uuidv4();
36
    const createSpan = await makeAPICall("POST", "/api/public/spans", {
37
      id: spanId,
38
      traceId: traceId,
39
      name: "span-name",
40
      startTime: "2021-01-01T00:00:00.000Z",
41
      endTime: "2021-01-01T00:00:00.000Z",
42
      input: { input: "value" },
43
      metadata: { meta: "value" },
44
      version: "2.0.0",
45
    });
46

47
    expect(createSpan.status).toBe(200);
48
    const dbSpan = await prisma.observation.findUnique({
49
      where: {
50
        id: spanId,
51
      },
52
    });
53

54
    expect(dbSpan?.id).toBe(spanId);
55
    expect(dbSpan?.traceId).toBe(traceId);
56
    expect(dbSpan?.name).toBe("span-name");
57
    expect(dbSpan?.startTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
58
    expect(dbSpan?.endTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
59
    expect(dbSpan?.input).toEqual({ input: "value" });
60
    expect(dbSpan?.metadata).toEqual({ meta: "value" });
61
    expect(dbSpan?.version).toBe("2.0.0");
62
  });
63

64
  it("should create span before trace", async () => {
65
    await pruneDatabase();
66

67
    const traceId = uuidv4();
68
    const spanId = uuidv4();
69

70
    const createSpan = await makeAPICall("POST", "/api/public/spans", {
71
      id: spanId,
72
      traceId: traceId,
73
      name: "span-name",
74
      startTime: "2021-01-01T00:00:00.000Z",
75
      endTime: "2021-01-01T00:00:00.000Z",
76
      input: { input: "value" },
77
      metadata: { meta: "value" },
78
      version: "2.0.0",
79
    });
80

81
    expect(createSpan.status).toBe(200);
82
    const dbSpan = await prisma.observation.findUnique({
83
      where: {
84
        id: spanId,
85
      },
86
    });
87

88
    expect(dbSpan?.id).toBe(spanId);
89
    expect(dbSpan?.traceId).toBe(traceId);
90
    expect(dbSpan?.name).toBe("span-name");
91
    expect(dbSpan?.startTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
92
    expect(dbSpan?.endTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
93
    expect(dbSpan?.input).toEqual({ input: "value" });
94
    expect(dbSpan?.metadata).toEqual({ meta: "value" });
95
    expect(dbSpan?.version).toBe("2.0.0");
96

97
    await makeAPICall("POST", "/api/public/traces", {
98
      id: traceId,
99
      name: "trace-name",
100
      userId: "user-1",
101
      projectId: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a",
102
      metadata: { key: "value" },
103
      release: "1.0.0",
104
      version: "2.0.0",
105
    });
106

107
    const dbTrace = await prisma.trace.findMany({
108
      where: {
109
        id: traceId,
110
      },
111
    });
112

113
    expect(dbTrace.length).toBeGreaterThan(0);
114
    expect(dbTrace[0]?.id).toBe(traceId);
115
  });
116

117
  it("should create span after trace ignoring externalId", async () => {
118
    const traceId = uuidv4();
119
    const spanId = uuidv4();
120

121
    const response = await makeAPICall("POST", "/api/public/traces", {
122
      externalId: uuidv4(),
123
      id: traceId,
124
      name: "trace-name",
125
      userId: "user-1",
126
      projectId: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a",
127
    });
128
    expect(response.status).toBe(200);
129
    const createSpan = await makeAPICall("POST", "/api/public/spans", {
130
      id: spanId,
131
      name: "spanName",
132
      projectId: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a",
133
      traceId: traceId,
134
      externalTraceIdType: "EXTERNAL",
135
    });
136
    expect(createSpan.status).toBe(200);
137

138
    const dbSpan = await prisma.observation.findFirstOrThrow({
139
      where: {
140
        name: "spanName",
141
      },
142
    });
143
    expect(dbSpan.id).toBe(spanId);
144
    expect(dbSpan.traceId).toBe(traceId);
145
  });
146

147
  it("should create trace when creating span without existing trace", async () => {
148
    const spanName = uuidv4();
149

150
    const spanId = uuidv4();
151
    const createSpan = await makeAPICall("POST", "/api/public/spans", {
152
      id: spanId,
153
      name: spanName,
154
      startTime: "2021-01-01T00:00:00.000Z",
155
      endTime: "2021-01-01T00:00:00.000Z",
156
      input: { input: "value" },
157
      metadata: { meta: "value" },
158
      version: "2.0.0",
159
    });
160

161
    const dbTrace = await prisma.trace.findMany({
162
      where: {
163
        name: spanName,
164
      },
165
    });
166

167
    expect(dbTrace.length).toBe(1);
168
    expect(dbTrace[0]?.name).toBe(spanName);
169

170
    expect(createSpan.status).toBe(200);
171
    const dbSpan = await prisma.observation.findUnique({
172
      where: {
173
        id: spanId,
174
      },
175
    });
176

177
    expect(dbSpan?.id).toBe(spanId);
178
    expect(dbSpan?.traceId).toBe(dbTrace[0]?.id);
179
    expect(dbSpan?.name).toBe(spanName);
180
    expect(dbSpan?.startTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
181
    expect(dbSpan?.endTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
182
    expect(dbSpan?.input).toEqual({ input: "value" });
183
    expect(dbSpan?.metadata).toEqual({ meta: "value" });
184
    expect(dbSpan?.version).toBe("2.0.0");
185
  });
186

187
  it("should create trace when creating span without existing trace with externalId", async () => {
188
    const spanName = uuidv4();
189

190
    const spanId = uuidv4();
191
    const traceId = uuidv4();
192
    const createSpan = await makeAPICall("POST", "/api/public/spans", {
193
      id: spanId,
194
      traceIdType: "EXTERNAL",
195
      traceId: traceId,
196
      name: spanName,
197
      startTime: "2021-01-01T00:00:00.000Z",
198
      endTime: "2021-01-01T00:00:00.000Z",
199
      input: { input: "value" },
200
      metadata: { meta: "value" },
201
      version: "2.0.0",
202
    });
203

204
    expect(createSpan.status).toBe(200);
205

206
    const dbSpan = await prisma.observation.findMany({
207
      where: {
208
        name: spanName,
209
      },
210
    });
211
    expect(dbSpan.length).toBe(1);
212
    expect(dbSpan[0]?.name).toBe(spanName);
213
    expect(dbSpan[0]?.id).toBe(spanId);
214
    expect(dbSpan[0]?.traceId).toBe(traceId);
215

216
    const dbTraces = await prisma.trace.findMany();
217
    expect(dbTraces.length).toBe(0);
218
  });
219

220
  it("should create trace when creating span without existing trace without traceId", async () => {
221
    const generationName = uuidv4();
222

223
    const spanId = uuidv4();
224
    const createSpan = await makeAPICall("POST", "/api/public/spans", {
225
      id: spanId,
226
      name: generationName,
227
      startTime: "2021-01-01T00:00:00.000Z",
228
      endTime: "2021-01-01T00:00:00.000Z",
229
      input: { key: "value" },
230
      metadata: { key: "value" },
231
      version: "2.0.0",
232
    });
233

234
    const dbSpan = await prisma.observation.findFirstOrThrow({
235
      where: {
236
        name: generationName,
237
      },
238
    });
239

240
    const dbTrace = await prisma.trace.findMany({
241
      where: {
242
        id: dbSpan.traceId!,
243
      },
244
    });
245

246
    expect(dbTrace.length).toBe(1);
247
    expect(dbTrace[0]?.name).toBe(generationName);
248

249
    expect(createSpan.status).toBe(200);
250

251
    expect(dbSpan.id).toBe(spanId);
252
    expect(dbSpan.traceId).toBe(dbTrace[0]?.id);
253
    expect(dbSpan.name).toBe(generationName);
254
    expect(dbSpan.startTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
255
    expect(dbSpan.endTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
256
    expect(dbSpan.input).toEqual({ key: "value" });
257
    expect(dbSpan.metadata).toEqual({ key: "value" });
258
    expect(dbSpan.version).toBe("2.0.0");
259
  });
260

261
  it("should update span", async () => {
262
    const spanName = uuidv4();
263

264
    const spanId = uuidv4();
265
    const createSpan = await makeAPICall("POST", "/api/public/spans", {
266
      id: spanId,
267
      name: spanName,
268
      startTime: "2021-01-01T00:00:00.000Z",
269
      endTime: "2021-01-01T00:00:00.000Z",
270
      input: { input: "value" },
271
      metadata: { meta: "value" },
272
      version: "2.0.0",
273
    });
274

275
    expect(createSpan.status).toBe(200);
276

277
    const updatedSpan = await makeAPICall("PATCH", "/api/public/spans", {
278
      spanId: spanId,
279
      output: { key: "this is a great gpt output" },
280
    });
281
    expect(updatedSpan.status).toBe(200);
282

283
    const dbSpan = await prisma.observation.findUnique({
284
      where: {
285
        id: spanId,
286
      },
287
    });
288

289
    expect(dbSpan?.id).toBe(spanId);
290
    expect(dbSpan?.name).toBe(spanName);
291
    expect(dbSpan?.startTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
292
    expect(dbSpan?.endTime).toEqual(new Date("2021-01-:00:00.000Z"));
293
    expect(dbSpan?.input).toEqual({ input: "value" });
294
    expect(dbSpan?.output).toEqual({ key: "this is a great gpt output" });
295
    expect(dbSpan?.metadata).toEqual({ meta: "value" });
296
    expect(dbSpan?.version).toBe("2.0.0");
297
  });
298

299
  it("should not upsert span if span does not exist", async () => {
300
    const spanId = uuidv4();
301

302
    const updatedSpan = await makeAPICall("PATCH", "/api/public/spans", {
303
      spanId: spanId,
304
      output: { key: "this is a great gpt output" },
305
    });
306
    expect(updatedSpan.status).toBe(404);
307

308
    const dbSpan = await prisma.observation.findUnique({
309
      where: {
310
        id: spanId,
311
      },
312
    });
313

314
    expect(dbSpan).toBeNull();
315
  });
316
});
317