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/events API Endpoint", () => {
8
  beforeEach(async () => await pruneDatabase());
9

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

13
    const traceId = uuidv4();
14

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

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

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

34
    const eventId = uuidv4();
35
    const createEvent = await makeAPICall("POST", "/api/public/events", {
36
      id: eventId,
37
      traceId: traceId,
38
      name: "event-name",
39
      startTime: "2021-01-01T00:00:00.000Z",
40
      input: { input: "value" },
41
      output: { output: "value" },
42
      metadata: { meta: "value" },
43
      version: "2.0.0",
44
    });
45

46
    expect(createEvent.status).toBe(200);
47
    const dbEvent = await prisma.observation.findUnique({
48
      where: {
49
        id: eventId,
50
      },
51
    });
52

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

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

66
    const traceId = uuidv4();
67
    const eventId = uuidv4();
68

69
    const createEvent = await makeAPICall("POST", "/api/public/events", {
70
      id: eventId,
71
      traceId: traceId,
72
      name: "event-name",
73
      startTime: "2021-01-01T00:00:00.000Z",
74
      input: { input: "value" },
75
      output: { output: "value" },
76
      metadata: { meta: "value" },
77
      version: "2.0.0",
78
    });
79

80
    expect(createEvent.status).toBe(200);
81
    const dbEvent = await prisma.observation.findUnique({
82
      where: {
83
        id: eventId,
84
      },
85
    });
86

87
    expect(dbEvent?.id).toBe(eventId);
88
    expect(dbEvent?.traceId).toBe(traceId);
89
    expect(dbEvent?.name).toBe("event-name");
90
    expect(dbEvent?.startTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
91
    expect(dbEvent?.input).toEqual({ input: "value" });
92
    expect(dbEvent?.output).toEqual({ output: "value" });
93
    expect(dbEvent?.metadata).toEqual({ meta: "value" });
94
    expect(dbEvent?.version).toBe("2.0.0");
95

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

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

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

116
  it("should create trace and ignore externalId and create event afterwards", async () => {
117
    await pruneDatabase();
118

119
    const traceId = uuidv4();
120

121
    const response = await makeAPICall("POST", "/api/public/traces", {
122
      externalId: traceId,
123
      name: "trace-name",
124
      userId: "user-1",
125
      projectId: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a",
126
      metadata: { key: "value" },
127
      release: "1.0.0",
128
      version: "2.0.0",
129
    });
130

131
    expect(response.status).toBe(200);
132

133
    const dbTrace = await prisma.trace.findMany({
134
      where: {
135
        name: "trace-name",
136
      },
137
    });
138

139
    expect(dbTrace.length).toBeGreaterThan(0);
140
    expect(dbTrace[0]?.externalId).toBeNull();
141
    expect(dbTrace[0]?.id).not.toBe(traceId);
142

143
    const eventId = uuidv4();
144
    const createEvent = await makeAPICall("POST", "/api/public/events", {
145
      id: eventId,
146
      traceIdType: "EXTERNAL",
147
      traceId: dbTrace[0]?.id,
148
      name: "event-name",
149
      startTime: "2021-01-01T00:00:00.000Z",
150
      input: { input: "value" },
151
      output: { output: "value" },
152
      metadata: { meta: "value" },
153
      version: "2.0.0",
154
    });
155

156
    expect(createEvent.status).toBe(200);
157
    const dbEvent = await prisma.observation.findUnique({
158
      where: {
159
        id: eventId,
160
      },
161
    });
162

163
    expect(dbEvent?.id).toBe(eventId);
164
    expect(dbEvent?.traceId).toBe(dbTrace[0]?.id);
165
    expect(dbEvent?.name).toBe("event-name");
166
    expect(dbEvent?.startTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
167
    expect(dbEvent?.input).toEqual({ input: "value" });
168
    expect(dbEvent?.output).toEqual({ output: "value" });
169
    expect(dbEvent?.metadata).toEqual({ meta: "value" });
170
    expect(dbEvent?.version).toBe("2.0.0");
171
  });
172

173
  it("should create trace when creating span without existing trace", async () => {
174
    const eventName = uuidv4();
175

176
    const spanId = uuidv4();
177
    const createEvent = await makeAPICall("POST", "/api/public/events", {
178
      id: spanId,
179
      name: eventName,
180
      startTime: "2021-01-01T00:00:00.000Z",
181
      endTime: "2021-01-01T00:00:00.000Z",
182
      input: { input: "value" },
183
      output: { output: "value" },
184
      metadata: { meta: "value" },
185
      version: "2.0.0",
186
    });
187

188
    const dbTrace = await prisma.trace.findMany({
189
      where: {
190
        name: eventName,
191
      },
192
    });
193

194
    expect(dbTrace.length).toBe(1);
195
    expect(dbTrace[0]?.name).toBe(eventName);
196

197
    expect(createEvent.status).toBe(200);
198
    const dbEvent = await prisma.observation.findUnique({
199
      where: {
200
        id: spanId,
201
      },
202
    });
203

204
    expect(dbEvent?.id).toBe(spanId);
205
    expect(dbEvent?.traceId).toBe(dbTrace[0]?.id);
206
    expect(dbEvent?.name).toBe(eventName);
207
    expect(dbEvent?.startTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
208
    expect(dbEvent?.input).toEqual({ input: "value" });
209
    expect(dbEvent?.output).toEqual({ output: "value" });
210
    expect(dbEvent?.metadata).toEqual({ meta: "value" });
211
    expect(dbEvent?.version).toBe("2.0.0");
212
  });
213

214
  it("should create event when creating generation without existing trace without traceId", async () => {
215
    const generationName = uuidv4();
216

217
    const spanId = uuidv4();
218
    const createSpan = await makeAPICall("POST", "/api/public/events", {
219
      id: spanId,
220
      name: generationName,
221
      startTime: "2021-01-01T00:00:00.000Z",
222
      input: { key: "value" },
223
      metadata: { key: "value" },
224
      version: "2.0.0",
225
    });
226

227
    const dbEvent = await prisma.observation.findFirstOrThrow({
228
      where: {
229
        name: generationName,
230
      },
231
    });
232

233
    const dbTrace = await prisma.trace.findMany({
234
      where: {
235
        id: dbEvent.traceId!,
236
      },
237
    });
238

239
    expect(dbTrace.length).toBe(1);
240
    expect(dbTrace[0]?.name).toBe(generationName);
241

242
    expect(createSpan.status).toBe(200);
243

244
    expect(dbEvent.id).toBe(spanId);
245
    expect(dbEvent.traceId).toBe(dbTrace[0]?.id);
246
    expect(dbEvent.name).toBe(generationName);
247
    expect(dbEvent.startTime).toEqual(new Date("2021-01-01T00:00:00.000Z"));
248
    expect(dbEvent.input).toEqual({ key: "value" });
249
    expect(dbEvent.metadata).toEqual({ key: "value" });
250
    expect(dbEvent.version).toBe("2.0.0");
251
  });
252
});
253