@debugkit/dashboard 0.4.0 → 0.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/client/assets/_authed-DTn7rMla.js +1 -0
- package/dist/client/assets/_authed-Dc7covsB.js +7 -0
- package/dist/client/assets/{charts-C76vsG2N.js → charts-C0zeGTzu.js} +18 -18
- package/dist/client/assets/index-D12jr1bm.js +10 -0
- package/dist/client/assets/issues._fingerprint-C6ryZvIu.js +1 -0
- package/dist/client/assets/login-oLP1Yyz3.js +1 -0
- package/dist/client/assets/preload-helper-CDziuvpw.js +3 -0
- package/dist/client/assets/settings-9oQsCwdV.js +1 -0
- package/dist/client/assets/styles-DBg7wMRg.css +2 -0
- package/dist/client/assets/ui-BiRMJGWB.js +1 -0
- package/dist/server/assets/{_authed-ClbGOSDJ.js → _authed-CuDay0Tl.js} +296 -70
- package/dist/server/assets/{_authed-BaehIntL.js → _authed-DODQ_Iys.js} +28 -8
- package/dist/server/assets/{_tanstack-start-manifest_v-eNUCOzFz.js → _tanstack-start-manifest_v-BBxgjm04.js} +16 -7
- package/dist/server/assets/{charts-CNlV7Pga.js → charts-DzTVqJ8z.js} +21 -4
- package/dist/server/assets/{demo-DTdlXNgj.js → demo-hrRBo9_U.js} +87 -10
- package/dist/server/assets/dynamodb-DyPK9SVV.js +354 -0
- package/dist/server/assets/{firestore-BH-gx9no.js → firestore-B2xzpzYA.js} +89 -5
- package/dist/server/assets/fns-DPsnK0zS.js +79 -0
- package/dist/server/assets/fns-hk_OJe6M.js +250 -0
- package/dist/server/assets/{issues._fingerprint-D78dy5os.js → issues._fingerprint-CZCZDm7t.js} +159 -17
- package/dist/server/assets/{login-h3B5Vdhl.js → login-D-UG6SFw.js} +3 -3
- package/dist/server/assets/{queries-DIVV-5j6.js → memory-Do0CDoAX.js} +205 -505
- package/dist/server/assets/queries-CxHrgTdM.js +955 -0
- package/dist/server/assets/range-picker-0zbSGr3Z.js +106 -0
- package/dist/server/assets/rolldown-runtime-D8jQpDG7.js +12 -0
- package/dist/server/assets/{router-DqTf7XfT.js → router-CIIGBCmL.js} +84 -44
- package/dist/server/assets/settings-BHfngShx.js +371 -0
- package/dist/server/assets/src-D9VHcuh4.js +491 -0
- package/dist/server/assets/src-JXktBs5H.js +4 -0
- package/dist/server/assets/{ui-Lv-KcOoP.js → ui-BJokJdYa.js} +25 -3
- package/dist/server/server.js +32 -8
- package/package.json +4 -4
- package/dist/client/assets/_authed-Bi62GTX3.js +0 -7
- package/dist/client/assets/_authed-mWCAMokt.js +0 -1
- package/dist/client/assets/index-D7uhDdvA.js +0 -12
- package/dist/client/assets/issues._fingerprint-fVGLnT37.js +0 -1
- package/dist/client/assets/login-MqvT094Y.js +0 -1
- package/dist/client/assets/styles-CZZRuG1z.css +0 -2
- package/dist/client/assets/ui-Bj6uJIr8.js +0 -1
- package/dist/server/assets/dynamodb-DejcakaF.js +0 -187
- package/dist/server/assets/fns-CgB12FUN.js +0 -31
- package/dist/server/assets/fns-Yg8sT1Cb.js +0 -87
- package/dist/server/assets/memory-4DwW5cTO.js +0 -59
- package/dist/server/assets/rollups-JXbazRNh.js +0 -22
- package/dist/server/assets/src-D5jyi_C4.js +0 -235
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import { useEffect, useState } from "react";
|
|
2
2
|
import { jsx, jsxs } from "react/jsx-runtime";
|
|
3
|
-
import { Area, AreaChart, Bar, BarChart, CartesianGrid, Cell, ResponsiveContainer, Tooltip, XAxis, YAxis } from "recharts";
|
|
3
|
+
import { Area, AreaChart, Bar, BarChart, CartesianGrid, Cell, ReferenceLine, ResponsiveContainer, Tooltip, XAxis, YAxis } from "recharts";
|
|
4
4
|
// src/components/charts.tsx
|
|
5
5
|
var SEV_COLOR = {
|
|
6
6
|
critical: "var(--sev-critical)",
|
|
@@ -34,12 +34,18 @@ function ClientOnly({ height, children }) {
|
|
|
34
34
|
children: ready ? children : null
|
|
35
35
|
});
|
|
36
36
|
}
|
|
37
|
-
|
|
37
|
+
/** "13 Nov" for a day, "14:00" for an hour bucket ("YYYY-MM-DDTHH"). */
|
|
38
|
+
var shortDay = (d) => d.length === 13 ? `${d.slice(11)}:00` : (/* @__PURE__ */ new Date(`${d}T00:00:00Z`)).toLocaleDateString(void 0, {
|
|
38
39
|
month: "short",
|
|
39
40
|
day: "numeric",
|
|
40
41
|
timeZone: "UTC"
|
|
41
42
|
});
|
|
42
|
-
function TrendChart({ data }) {
|
|
43
|
+
function TrendChart({ data, markers = [] }) {
|
|
44
|
+
const days = data.map((d) => d.day);
|
|
45
|
+
const snapped = markers.map((m) => ({
|
|
46
|
+
...m,
|
|
47
|
+
x: [...days].reverse().find((d) => d <= m.day)
|
|
48
|
+
})).filter((m) => !!m.x);
|
|
43
49
|
return /* @__PURE__ */ jsx(ClientOnly, {
|
|
44
50
|
height: 220,
|
|
45
51
|
children: /* @__PURE__ */ jsx(ResponsiveContainer, {
|
|
@@ -96,7 +102,18 @@ function TrendChart({ data }) {
|
|
|
96
102
|
stroke: "var(--chart-errors)",
|
|
97
103
|
strokeWidth: 2,
|
|
98
104
|
fill: "url(#errFill)"
|
|
99
|
-
})
|
|
105
|
+
}),
|
|
106
|
+
snapped.map((m) => /* @__PURE__ */ jsx(ReferenceLine, {
|
|
107
|
+
x: m.x,
|
|
108
|
+
stroke: "var(--chart-events)",
|
|
109
|
+
strokeDasharray: "3 3",
|
|
110
|
+
label: {
|
|
111
|
+
value: m.label,
|
|
112
|
+
position: "insideTopLeft",
|
|
113
|
+
fontSize: 10,
|
|
114
|
+
fill: "var(--chart-events)"
|
|
115
|
+
}
|
|
116
|
+
}, `${m.label}${m.day}`))
|
|
100
117
|
]
|
|
101
118
|
})
|
|
102
119
|
})
|
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import { MemoryStore } from "./memory-
|
|
2
|
-
import { n as ingest } from "./src-
|
|
1
|
+
import { t as MemoryStore } from "./memory-Do0CDoAX.js";
|
|
2
|
+
import { n as ingest } from "./src-D9VHcuh4.js";
|
|
3
3
|
// src/server/demo.ts
|
|
4
4
|
/**
|
|
5
5
|
* Builds a realistic 14-day dataset for a fictional app by pushing synthetic SDK
|
|
@@ -171,10 +171,62 @@ async function seedDemo() {
|
|
|
171
171
|
}
|
|
172
172
|
];
|
|
173
173
|
const successFlows = [
|
|
174
|
-
"auth.login",
|
|
175
|
-
"checkout.payment",
|
|
176
|
-
"feed.load",
|
|
177
|
-
"profile.update"
|
|
174
|
+
["auth.login", "submit_otp"],
|
|
175
|
+
["checkout.payment", "create_intent"],
|
|
176
|
+
["feed.load", "parse"],
|
|
177
|
+
["profile.update", "upload_avatar"]
|
|
178
|
+
];
|
|
179
|
+
const endpoints = [
|
|
180
|
+
[
|
|
181
|
+
"GET /v1/feed",
|
|
182
|
+
380,
|
|
183
|
+
900,
|
|
184
|
+
.03
|
|
185
|
+
],
|
|
186
|
+
[
|
|
187
|
+
"POST /v2/auth/otp/verify",
|
|
188
|
+
420,
|
|
189
|
+
500,
|
|
190
|
+
.01
|
|
191
|
+
],
|
|
192
|
+
[
|
|
193
|
+
"POST /v1/payments/intent",
|
|
194
|
+
1900,
|
|
195
|
+
9e3,
|
|
196
|
+
.06
|
|
197
|
+
],
|
|
198
|
+
[
|
|
199
|
+
"GET /v1/profile",
|
|
200
|
+
160,
|
|
201
|
+
250,
|
|
202
|
+
.002
|
|
203
|
+
]
|
|
204
|
+
];
|
|
205
|
+
const EDGES = [
|
|
206
|
+
50,
|
|
207
|
+
100,
|
|
208
|
+
200,
|
|
209
|
+
300,
|
|
210
|
+
500,
|
|
211
|
+
750,
|
|
212
|
+
1e3,
|
|
213
|
+
1500,
|
|
214
|
+
2e3,
|
|
215
|
+
3e3,
|
|
216
|
+
5e3,
|
|
217
|
+
1e4
|
|
218
|
+
];
|
|
219
|
+
const rand2 = mulberry32(7);
|
|
220
|
+
const pick2 = (xs) => xs[Math.floor(rand2() * xs.length)];
|
|
221
|
+
const places = [
|
|
222
|
+
["Africa/Johannesburg", "en-ZA"],
|
|
223
|
+
["Africa/Johannesburg", "en-ZA"],
|
|
224
|
+
["Africa/Johannesburg", "en-ZA"],
|
|
225
|
+
["Africa/Johannesburg", "en-US"],
|
|
226
|
+
["Africa/Johannesburg", "en-ZA"],
|
|
227
|
+
["Europe/London", "en-GB"],
|
|
228
|
+
["Africa/Windhoek", "en-NA"],
|
|
229
|
+
["Africa/Gaborone", "en-BW"]
|
|
178
230
|
];
|
|
179
231
|
for (let dayAgo = 13; dayAgo >= 0; dayAgo--) {
|
|
180
232
|
const version = dayAgo <= 3 ? pick([
|
|
@@ -253,14 +305,37 @@ async function seedDemo() {
|
|
|
253
305
|
});
|
|
254
306
|
}
|
|
255
307
|
}
|
|
256
|
-
for (const flow of successFlows) if (rand() < .55) events.push({
|
|
308
|
+
for (const [flow, step] of successFlows) if (rand() < .55) events.push({
|
|
257
309
|
type: "event",
|
|
258
310
|
id: `evt_${(seq++).toString().padStart(10, "0")}`,
|
|
259
311
|
ts,
|
|
260
|
-
name: `${flow}
|
|
312
|
+
name: `${flow}.${step}`,
|
|
261
313
|
flow,
|
|
314
|
+
step,
|
|
262
315
|
outcome: "success"
|
|
263
316
|
});
|
|
317
|
+
for (const [key, typical, spread, failRate] of endpoints) {
|
|
318
|
+
if (rand2() < .4) continue;
|
|
319
|
+
const buckets = new Array(13).fill(0);
|
|
320
|
+
const count = 1 + Math.floor(rand2() * 6);
|
|
321
|
+
let errors = 0;
|
|
322
|
+
for (let k = 0; k < count; k++) {
|
|
323
|
+
const msTaken = typical * (.5 + rand2()) + (rand2() < .1 ? rand2() * spread : 0);
|
|
324
|
+
const b = EDGES.findIndex((e) => msTaken <= e);
|
|
325
|
+
buckets[b === -1 ? 12 : b]++;
|
|
326
|
+
if (rand2() < failRate) errors++;
|
|
327
|
+
}
|
|
328
|
+
events.push({
|
|
329
|
+
type: "metric",
|
|
330
|
+
id: id(),
|
|
331
|
+
ts,
|
|
332
|
+
name: "http",
|
|
333
|
+
key,
|
|
334
|
+
count,
|
|
335
|
+
errors,
|
|
336
|
+
buckets
|
|
337
|
+
});
|
|
338
|
+
}
|
|
264
339
|
events.unshift({
|
|
265
340
|
type: "session",
|
|
266
341
|
id: id(),
|
|
@@ -298,8 +373,10 @@ async function seedDemo() {
|
|
|
298
373
|
engine: "hermes"
|
|
299
374
|
},
|
|
300
375
|
network: { type: pick(networks) },
|
|
301
|
-
locale
|
|
302
|
-
|
|
376
|
+
...(([timezone, locale]) => ({
|
|
377
|
+
timezone,
|
|
378
|
+
locale
|
|
379
|
+
}))(pick2(places))
|
|
303
380
|
},
|
|
304
381
|
user: {
|
|
305
382
|
id: userId,
|
|
@@ -0,0 +1,354 @@
|
|
|
1
|
+
import { f as coalesceRollups, s as isRegression } from "./memory-Do0CDoAX.js";
|
|
2
|
+
import "./src-JXktBs5H.js";
|
|
3
|
+
import { BatchWriteCommand, GetCommand, PutCommand, QueryCommand, UpdateCommand } from "@aws-sdk/lib-dynamodb";
|
|
4
|
+
// ../../packages/adapters/src/dynamodb.ts
|
|
5
|
+
/**
|
|
6
|
+
* Single-table layout. Table needs: partition key `pk` (S), sort key `sk` (S),
|
|
7
|
+
* and TTL enabled on attribute `ttl`.
|
|
8
|
+
*
|
|
9
|
+
* APPS | {app} app marker
|
|
10
|
+
* APP#{app}#ISSUE | {fingerprint} Issue
|
|
11
|
+
* APP#{app}#ROLLUP#{dimension} | {day}#{key} RollupRow (ADD counters)
|
|
12
|
+
* APP#{app}#ISSUEEV#{fp} | {ts}#{id} StoredEvent (error events by issue)
|
|
13
|
+
* APP#{app}#EV#{day} | {ts}#{id} StoredEvent (all events by day)
|
|
14
|
+
* APP#{app}#SETTINGS | app AppSettings
|
|
15
|
+
* APP#{app}#USERS#{scope} | {member} { lastDay } (hashed ids; for "users affected")
|
|
16
|
+
*
|
|
17
|
+
* Hourly rollups (dimension issueHour) also carry `ttl`, so they expire after 7 days.
|
|
18
|
+
*/
|
|
19
|
+
var DynamoStore = class {
|
|
20
|
+
doc;
|
|
21
|
+
opts;
|
|
22
|
+
constructor(doc, opts) {
|
|
23
|
+
this.doc = doc;
|
|
24
|
+
this.opts = opts;
|
|
25
|
+
}
|
|
26
|
+
get table() {
|
|
27
|
+
return this.opts.table;
|
|
28
|
+
}
|
|
29
|
+
async registerApp(app) {
|
|
30
|
+
await this.doc.send(new PutCommand({
|
|
31
|
+
TableName: this.table,
|
|
32
|
+
Item: {
|
|
33
|
+
pk: "APPS",
|
|
34
|
+
sk: app
|
|
35
|
+
}
|
|
36
|
+
}));
|
|
37
|
+
}
|
|
38
|
+
async writeEvents(events, opts = {}) {
|
|
39
|
+
const days = opts.retentionDays ?? this.opts.retentionDays ?? 30;
|
|
40
|
+
const ttl = (e) => Math.floor(Date.parse(e.receivedAt) / 1e3) + days * 86400;
|
|
41
|
+
const items = events.flatMap((e) => {
|
|
42
|
+
const sk = `${e.event.ts}#${e.event.id}`;
|
|
43
|
+
const base = {
|
|
44
|
+
...e,
|
|
45
|
+
ttl: ttl(e)
|
|
46
|
+
};
|
|
47
|
+
const rows = [{
|
|
48
|
+
pk: `APP#${e.app}#EV#${e.day}`,
|
|
49
|
+
sk,
|
|
50
|
+
...base
|
|
51
|
+
}];
|
|
52
|
+
if (e.fingerprint) rows.push({
|
|
53
|
+
pk: `APP#${e.app}#ISSUEEV#${e.fingerprint}`,
|
|
54
|
+
sk,
|
|
55
|
+
...base
|
|
56
|
+
});
|
|
57
|
+
return rows;
|
|
58
|
+
});
|
|
59
|
+
for (let i = 0; i < items.length; i += 25) {
|
|
60
|
+
let req = { [this.table]: items.slice(i, i + 25).map((Item) => ({ PutRequest: { Item } })) };
|
|
61
|
+
for (let attempt = 0; req && Object.keys(req).length && attempt < 5; attempt++) {
|
|
62
|
+
req = (await this.doc.send(new BatchWriteCommand({ RequestItems: req }))).UnprocessedItems;
|
|
63
|
+
if (req && Object.keys(req).length) await new Promise((r) => setTimeout(r, 50 * 2 ** attempt));
|
|
64
|
+
}
|
|
65
|
+
}
|
|
66
|
+
}
|
|
67
|
+
async upsertIssues(updates) {
|
|
68
|
+
const outcome = {
|
|
69
|
+
created: [],
|
|
70
|
+
regressed: []
|
|
71
|
+
};
|
|
72
|
+
await Promise.all(updates.map(async (u) => {
|
|
73
|
+
if ((await this.doc.send(new UpdateCommand({
|
|
74
|
+
TableName: this.table,
|
|
75
|
+
Key: {
|
|
76
|
+
pk: `APP#${u.app}#ISSUE`,
|
|
77
|
+
sk: u.fingerprint
|
|
78
|
+
},
|
|
79
|
+
UpdateExpression: "ADD #count :by SET app = :app, fingerprint = :fp, title = :title, flow = :flow, culprit = :culprit, firstSeen = if_not_exists(firstSeen, :first)",
|
|
80
|
+
ExpressionAttributeNames: { "#count": "count" },
|
|
81
|
+
ExpressionAttributeValues: {
|
|
82
|
+
":by": u.by,
|
|
83
|
+
":app": u.app,
|
|
84
|
+
":fp": u.fingerprint,
|
|
85
|
+
":title": u.title,
|
|
86
|
+
":flow": u.flow ?? null,
|
|
87
|
+
":culprit": u.culprit ?? null,
|
|
88
|
+
":first": u.firstTs
|
|
89
|
+
},
|
|
90
|
+
ReturnValues: "UPDATED_OLD"
|
|
91
|
+
}))).Attributes?.count === void 0) outcome.created.push(u.fingerprint);
|
|
92
|
+
await this.doc.send(new UpdateCommand({
|
|
93
|
+
TableName: this.table,
|
|
94
|
+
Key: {
|
|
95
|
+
pk: `APP#${u.app}#ISSUE`,
|
|
96
|
+
sk: u.fingerprint
|
|
97
|
+
},
|
|
98
|
+
UpdateExpression: "SET lastSeen = :ts, lastEvent = :ev, lastVersion = :v, firstVersion = if_not_exists(firstVersion, :v)",
|
|
99
|
+
ConditionExpression: "attribute_not_exists(lastSeen) OR lastSeen < :ts",
|
|
100
|
+
ExpressionAttributeValues: {
|
|
101
|
+
":ts": u.ts,
|
|
102
|
+
":ev": u.lastEvent,
|
|
103
|
+
":v": u.version ?? null
|
|
104
|
+
}
|
|
105
|
+
})).catch((e) => {
|
|
106
|
+
if (e.name !== "ConditionalCheckFailedException") throw e;
|
|
107
|
+
});
|
|
108
|
+
const cur = (await this.doc.send(new GetCommand({
|
|
109
|
+
TableName: this.table,
|
|
110
|
+
Key: {
|
|
111
|
+
pk: `APP#${u.app}#ISSUE`,
|
|
112
|
+
sk: u.fingerprint
|
|
113
|
+
},
|
|
114
|
+
ProjectionExpression: "#s, resolvedIn, resolvedAt",
|
|
115
|
+
ExpressionAttributeNames: { "#s": "status" }
|
|
116
|
+
}))).Item;
|
|
117
|
+
if (cur?.status === "resolved" && isRegression(cur.resolvedIn, u.version, cur.resolvedAt, u.ts)) await this.doc.send(new UpdateCommand({
|
|
118
|
+
TableName: this.table,
|
|
119
|
+
Key: {
|
|
120
|
+
pk: `APP#${u.app}#ISSUE`,
|
|
121
|
+
sk: u.fingerprint
|
|
122
|
+
},
|
|
123
|
+
UpdateExpression: "SET #s = :r, regressedAt = :ts",
|
|
124
|
+
ConditionExpression: "#s = :resolved",
|
|
125
|
+
ExpressionAttributeNames: { "#s": "status" },
|
|
126
|
+
ExpressionAttributeValues: {
|
|
127
|
+
":r": "regressed",
|
|
128
|
+
":ts": u.ts,
|
|
129
|
+
":resolved": "resolved"
|
|
130
|
+
}
|
|
131
|
+
})).then(() => outcome.regressed.push(u.fingerprint)).catch((e) => {
|
|
132
|
+
if (e.name !== "ConditionalCheckFailedException") throw e;
|
|
133
|
+
});
|
|
134
|
+
await this.doc.send(new UpdateCommand({
|
|
135
|
+
TableName: this.table,
|
|
136
|
+
Key: {
|
|
137
|
+
pk: `APP#${u.app}#ISSUE`,
|
|
138
|
+
sk: u.fingerprint
|
|
139
|
+
},
|
|
140
|
+
UpdateExpression: "SET firstSeen = :first",
|
|
141
|
+
ConditionExpression: "firstSeen > :first",
|
|
142
|
+
ExpressionAttributeValues: { ":first": u.firstTs }
|
|
143
|
+
})).catch((e) => {
|
|
144
|
+
if (e.name !== "ConditionalCheckFailedException") throw e;
|
|
145
|
+
});
|
|
146
|
+
}));
|
|
147
|
+
return outcome;
|
|
148
|
+
}
|
|
149
|
+
async incrementRollups(incs) {
|
|
150
|
+
await Promise.all(coalesceRollups(incs).map((r) => this.doc.send(new UpdateCommand({
|
|
151
|
+
TableName: this.table,
|
|
152
|
+
Key: {
|
|
153
|
+
pk: `APP#${r.app}#ROLLUP#${r.dimension}`,
|
|
154
|
+
sk: `${r.day}#${r.key}`
|
|
155
|
+
},
|
|
156
|
+
UpdateExpression: `ADD errors :e, events :v SET app = :app, #day = :day, dimension = :dim, #key = :key${r.dimension === "issueHour" ? ", #ttl = :ttl" : ""}`,
|
|
157
|
+
ExpressionAttributeNames: {
|
|
158
|
+
"#day": "day",
|
|
159
|
+
"#key": "key",
|
|
160
|
+
...r.dimension === "issueHour" ? { "#ttl": "ttl" } : {}
|
|
161
|
+
},
|
|
162
|
+
ExpressionAttributeValues: {
|
|
163
|
+
":e": r.errors,
|
|
164
|
+
":v": r.events,
|
|
165
|
+
":app": r.app,
|
|
166
|
+
":day": r.day,
|
|
167
|
+
":dim": r.dimension,
|
|
168
|
+
":key": r.key,
|
|
169
|
+
...r.dimension === "issueHour" ? { ":ttl": Math.floor(Date.parse(`${r.day}:00:00Z`) / 1e3) + 604800 } : {}
|
|
170
|
+
}
|
|
171
|
+
}))));
|
|
172
|
+
}
|
|
173
|
+
async markUsers(app, marks) {
|
|
174
|
+
await Promise.all(marks.map((m) => this.doc.send(new UpdateCommand({
|
|
175
|
+
TableName: this.table,
|
|
176
|
+
Key: {
|
|
177
|
+
pk: `APP#${app}#USERS#${m.scope}`,
|
|
178
|
+
sk: m.member
|
|
179
|
+
},
|
|
180
|
+
UpdateExpression: "SET lastDay = :d",
|
|
181
|
+
ConditionExpression: "attribute_not_exists(lastDay) OR lastDay < :d",
|
|
182
|
+
ExpressionAttributeValues: { ":d": m.day }
|
|
183
|
+
})).catch((e) => {
|
|
184
|
+
if (e.name !== "ConditionalCheckFailedException") throw e;
|
|
185
|
+
})));
|
|
186
|
+
}
|
|
187
|
+
async countUsers(app, scope, sinceDay) {
|
|
188
|
+
let n = 0;
|
|
189
|
+
let ExclusiveStartKey;
|
|
190
|
+
do {
|
|
191
|
+
const out = await this.doc.send(new QueryCommand({
|
|
192
|
+
TableName: this.table,
|
|
193
|
+
KeyConditionExpression: "pk = :pk",
|
|
194
|
+
FilterExpression: "lastDay >= :d",
|
|
195
|
+
ExpressionAttributeValues: {
|
|
196
|
+
":pk": `APP#${app}#USERS#${scope}`,
|
|
197
|
+
":d": sinceDay
|
|
198
|
+
},
|
|
199
|
+
Select: "COUNT",
|
|
200
|
+
ExclusiveStartKey
|
|
201
|
+
}));
|
|
202
|
+
n += out.Count ?? 0;
|
|
203
|
+
ExclusiveStartKey = out.LastEvaluatedKey;
|
|
204
|
+
} while (ExclusiveStartKey);
|
|
205
|
+
return n;
|
|
206
|
+
}
|
|
207
|
+
async setIssueStatus(app, fp, change) {
|
|
208
|
+
const resolved = change.status === "resolved";
|
|
209
|
+
const out = await this.doc.send(new UpdateCommand({
|
|
210
|
+
TableName: this.table,
|
|
211
|
+
Key: {
|
|
212
|
+
pk: `APP#${app}#ISSUE`,
|
|
213
|
+
sk: fp
|
|
214
|
+
},
|
|
215
|
+
UpdateExpression: resolved ? "SET #s = :s, resolvedAt = :at, resolvedIn = :in REMOVE regressedAt" : "SET #s = :s REMOVE resolvedIn, resolvedAt, regressedAt",
|
|
216
|
+
ConditionExpression: "attribute_exists(pk)",
|
|
217
|
+
ExpressionAttributeNames: { "#s": "status" },
|
|
218
|
+
ExpressionAttributeValues: resolved ? {
|
|
219
|
+
":s": change.status,
|
|
220
|
+
":at": (/* @__PURE__ */ new Date()).toISOString(),
|
|
221
|
+
":in": change.resolvedIn ?? null
|
|
222
|
+
} : { ":s": change.status },
|
|
223
|
+
ReturnValues: "ALL_NEW"
|
|
224
|
+
})).catch((e) => {
|
|
225
|
+
if (e.name === "ConditionalCheckFailedException") return null;
|
|
226
|
+
throw e;
|
|
227
|
+
});
|
|
228
|
+
return out?.Attributes ? clean(out.Attributes) : null;
|
|
229
|
+
}
|
|
230
|
+
async getSettings(app) {
|
|
231
|
+
const out = await this.doc.send(new GetCommand({
|
|
232
|
+
TableName: this.table,
|
|
233
|
+
Key: {
|
|
234
|
+
pk: `APP#${app}#SETTINGS`,
|
|
235
|
+
sk: "app"
|
|
236
|
+
}
|
|
237
|
+
}));
|
|
238
|
+
return out.Item ? clean(out.Item) : null;
|
|
239
|
+
}
|
|
240
|
+
async putSettings(app, s) {
|
|
241
|
+
const next = Object.fromEntries(Object.entries({
|
|
242
|
+
...s,
|
|
243
|
+
updatedAt: (/* @__PURE__ */ new Date()).toISOString()
|
|
244
|
+
}).filter(([, v]) => v !== void 0));
|
|
245
|
+
const names = Object.keys(next);
|
|
246
|
+
return clean((await this.doc.send(new UpdateCommand({
|
|
247
|
+
TableName: this.table,
|
|
248
|
+
Key: {
|
|
249
|
+
pk: `APP#${app}#SETTINGS`,
|
|
250
|
+
sk: "app"
|
|
251
|
+
},
|
|
252
|
+
UpdateExpression: `SET ${names.map((n, i) => `#n${i} = :v${i}`).join(", ")}`,
|
|
253
|
+
ExpressionAttributeNames: Object.fromEntries(names.map((n, i) => [`#n${i}`, n])),
|
|
254
|
+
ExpressionAttributeValues: Object.fromEntries(names.map((n, i) => [`:v${i}`, next[n]])),
|
|
255
|
+
ReturnValues: "ALL_NEW"
|
|
256
|
+
}))).Attributes ?? next);
|
|
257
|
+
}
|
|
258
|
+
/**
|
|
259
|
+
* Events live in one partition per day (and a copy per issue). Walk the day partitions newest
|
|
260
|
+
* first, one per call; the cursor is how many days back we've got. Stops after 10 years.
|
|
261
|
+
*/
|
|
262
|
+
async restampExpiry(app, retentionDays, { cursor } = {}) {
|
|
263
|
+
let back = cursor ? Number(cursor) : 0;
|
|
264
|
+
let updated = 0;
|
|
265
|
+
for (let n = 0; n < 30 && back <= 3650; n++, back++) {
|
|
266
|
+
const day = (/* @__PURE__ */ new Date(Date.now() - back * 864e5)).toISOString().slice(0, 10);
|
|
267
|
+
const items = await this.queryAll({ pk: `APP#${app}#EV#${day}` });
|
|
268
|
+
for (const item of items) {
|
|
269
|
+
const ttl = Math.floor(Date.parse(item.receivedAt) / 1e3) + retentionDays * 86400;
|
|
270
|
+
const keys = [{
|
|
271
|
+
pk: item.pk,
|
|
272
|
+
sk: item.sk
|
|
273
|
+
}, ...item.fingerprint ? [{
|
|
274
|
+
pk: `APP#${app}#ISSUEEV#${item.fingerprint}`,
|
|
275
|
+
sk: item.sk
|
|
276
|
+
}] : []];
|
|
277
|
+
await Promise.all(keys.map((Key) => this.doc.send(new UpdateCommand({
|
|
278
|
+
TableName: this.table,
|
|
279
|
+
Key,
|
|
280
|
+
UpdateExpression: "SET #t = :t",
|
|
281
|
+
ConditionExpression: "attribute_exists(pk)",
|
|
282
|
+
ExpressionAttributeNames: { "#t": "ttl" },
|
|
283
|
+
ExpressionAttributeValues: { ":t": ttl }
|
|
284
|
+
})).catch((e) => {
|
|
285
|
+
if (e.name !== "ConditionalCheckFailedException") throw e;
|
|
286
|
+
})));
|
|
287
|
+
updated++;
|
|
288
|
+
}
|
|
289
|
+
if (items.length) {
|
|
290
|
+
back++;
|
|
291
|
+
break;
|
|
292
|
+
}
|
|
293
|
+
}
|
|
294
|
+
return {
|
|
295
|
+
updated,
|
|
296
|
+
cursor: back <= 3650 ? String(back) : void 0
|
|
297
|
+
};
|
|
298
|
+
}
|
|
299
|
+
async listApps() {
|
|
300
|
+
return (await this.queryAll({ pk: "APPS" })).map((i) => i.sk).sort();
|
|
301
|
+
}
|
|
302
|
+
async listIssues(app, { limit = 200 } = {}) {
|
|
303
|
+
return (await this.queryAll({ pk: `APP#${app}#ISSUE` })).sort((a, b) => b.lastSeen.localeCompare(a.lastSeen)).slice(0, limit).map(clean);
|
|
304
|
+
}
|
|
305
|
+
async getIssue(app, fp) {
|
|
306
|
+
const out = await this.doc.send(new GetCommand({
|
|
307
|
+
TableName: this.table,
|
|
308
|
+
Key: {
|
|
309
|
+
pk: `APP#${app}#ISSUE`,
|
|
310
|
+
sk: fp
|
|
311
|
+
}
|
|
312
|
+
}));
|
|
313
|
+
return out.Item ? clean(out.Item) : null;
|
|
314
|
+
}
|
|
315
|
+
async getRollups(app, dimension, fromDay, toDay) {
|
|
316
|
+
return (await this.queryAll({
|
|
317
|
+
pk: `APP#${app}#ROLLUP#${dimension}`,
|
|
318
|
+
between: [`${fromDay}#`, `${toDay}#`]
|
|
319
|
+
})).map((i) => clean(i));
|
|
320
|
+
}
|
|
321
|
+
async listIssueEvents(app, fp, { limit = 50 } = {}) {
|
|
322
|
+
return ((await this.doc.send(new QueryCommand({
|
|
323
|
+
TableName: this.table,
|
|
324
|
+
KeyConditionExpression: "pk = :pk",
|
|
325
|
+
ExpressionAttributeValues: { ":pk": `APP#${app}#ISSUEEV#${fp}` },
|
|
326
|
+
ScanIndexForward: false,
|
|
327
|
+
Limit: limit
|
|
328
|
+
}))).Items ?? []).map((i) => clean(i));
|
|
329
|
+
}
|
|
330
|
+
async queryAll({ pk, between }) {
|
|
331
|
+
const items = [];
|
|
332
|
+
let ExclusiveStartKey;
|
|
333
|
+
do {
|
|
334
|
+
const out = await this.doc.send(new QueryCommand({
|
|
335
|
+
TableName: this.table,
|
|
336
|
+
KeyConditionExpression: between ? "pk = :pk AND sk BETWEEN :a AND :b" : "pk = :pk",
|
|
337
|
+
ExpressionAttributeValues: between ? {
|
|
338
|
+
":pk": pk,
|
|
339
|
+
":a": between[0],
|
|
340
|
+
":b": between[1]
|
|
341
|
+
} : { ":pk": pk },
|
|
342
|
+
ExclusiveStartKey
|
|
343
|
+
}));
|
|
344
|
+
items.push(...out.Items ?? []);
|
|
345
|
+
ExclusiveStartKey = out.LastEvaluatedKey;
|
|
346
|
+
} while (ExclusiveStartKey);
|
|
347
|
+
return items;
|
|
348
|
+
}
|
|
349
|
+
};
|
|
350
|
+
function clean(item) {
|
|
351
|
+
const { pk: _p, sk: _s, ttl: _t, ...rest } = item;
|
|
352
|
+
return rest;
|
|
353
|
+
}
|
|
354
|
+
export { DynamoStore };
|
|
@@ -1,4 +1,5 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { f as coalesceRollups, p as rollupId, s as isRegression } from "./memory-Do0CDoAX.js";
|
|
2
|
+
import "./src-JXktBs5H.js";
|
|
2
3
|
import { FieldValue, Timestamp } from "firebase-admin/firestore";
|
|
3
4
|
// ../../packages/adapters/src/firestore.ts
|
|
4
5
|
/**
|
|
@@ -8,6 +9,10 @@ import { FieldValue, Timestamp } from "firebase-admin/firestore";
|
|
|
8
9
|
* {root}/{app}/issues/{fingerprint} Issue
|
|
9
10
|
* {root}/{app}/rollups/{day__dim__key} RollupRow (counters via FieldValue.increment)
|
|
10
11
|
* {root}/{app}/events/{eventId} StoredEvent + expireAt (enable a TTL policy on `expireAt`)
|
|
12
|
+
* {root}/{app}/settings/app AppSettings (retention, set from the dashboard)
|
|
13
|
+
* {root}/{app}/users/{scope__member} { scope, member, lastDay } (hashed ids; for "users affected")
|
|
14
|
+
*
|
|
15
|
+
* Hourly rollups (dimension issueHour) also carry expireAt, so they expire after 7 days.
|
|
11
16
|
*
|
|
12
17
|
* Composite index needed: rollups (dimension ASC, day ASC). See firestore.indexes.json.
|
|
13
18
|
*/
|
|
@@ -30,8 +35,8 @@ var FirestoreStore = class {
|
|
|
30
35
|
updatedAt: FieldValue.serverTimestamp()
|
|
31
36
|
}, { merge: true });
|
|
32
37
|
}
|
|
33
|
-
async writeEvents(events) {
|
|
34
|
-
const days = this.opts.retentionDays ?? 30;
|
|
38
|
+
async writeEvents(events, opts = {}) {
|
|
39
|
+
const days = opts.retentionDays ?? this.opts.retentionDays ?? 30;
|
|
35
40
|
for (const chunk of chunks(events, 400)) {
|
|
36
41
|
const batch = this.db.batch();
|
|
37
42
|
for (const e of chunk) {
|
|
@@ -46,10 +51,19 @@ var FirestoreStore = class {
|
|
|
46
51
|
}
|
|
47
52
|
}
|
|
48
53
|
async upsertIssues(updates) {
|
|
54
|
+
const outcome = {
|
|
55
|
+
created: [],
|
|
56
|
+
regressed: []
|
|
57
|
+
};
|
|
49
58
|
await Promise.all(updates.map((u) => this.db.runTransaction(async (tx) => {
|
|
50
59
|
const ref = this.app(u.app).collection("issues").doc(u.fingerprint);
|
|
51
60
|
const cur = (await tx.get(ref)).data();
|
|
52
61
|
const newer = !cur || u.ts >= cur.lastSeen;
|
|
62
|
+
const regressed = cur?.status === "resolved" && isRegression(cur.resolvedIn, u.version, cur.resolvedAt, u.ts);
|
|
63
|
+
outcome.created = outcome.created.filter((f) => f !== u.fingerprint);
|
|
64
|
+
outcome.regressed = outcome.regressed.filter((f) => f !== u.fingerprint);
|
|
65
|
+
if (!cur) outcome.created.push(u.fingerprint);
|
|
66
|
+
if (regressed) outcome.regressed.push(u.fingerprint);
|
|
53
67
|
tx.set(ref, strip({
|
|
54
68
|
app: u.app,
|
|
55
69
|
fingerprint: u.fingerprint,
|
|
@@ -59,9 +73,18 @@ var FirestoreStore = class {
|
|
|
59
73
|
firstSeen: cur && cur.firstSeen < u.firstTs ? cur.firstSeen : u.firstTs,
|
|
60
74
|
lastSeen: newer ? u.ts : cur.lastSeen,
|
|
61
75
|
count: FieldValue.increment(u.by),
|
|
62
|
-
...newer ? {
|
|
76
|
+
...newer ? {
|
|
77
|
+
lastEvent: strip(u.lastEvent),
|
|
78
|
+
lastVersion: u.version
|
|
79
|
+
} : {},
|
|
80
|
+
...!cur?.firstVersion && u.version ? { firstVersion: u.version } : {},
|
|
81
|
+
...regressed ? {
|
|
82
|
+
status: "regressed",
|
|
83
|
+
regressedAt: u.ts
|
|
84
|
+
} : {}
|
|
63
85
|
}), { merge: true });
|
|
64
86
|
})));
|
|
87
|
+
return outcome;
|
|
65
88
|
}
|
|
66
89
|
async incrementRollups(incs) {
|
|
67
90
|
const rows = coalesceRollups(incs);
|
|
@@ -73,11 +96,72 @@ var FirestoreStore = class {
|
|
|
73
96
|
dimension: r.dimension,
|
|
74
97
|
key: r.key,
|
|
75
98
|
errors: FieldValue.increment(r.errors),
|
|
76
|
-
events: FieldValue.increment(r.events)
|
|
99
|
+
events: FieldValue.increment(r.events),
|
|
100
|
+
...r.dimension === "issueHour" ? { expireAt: Timestamp.fromMillis(Date.parse(`${r.day}:00:00Z`) + 6048e5) } : {}
|
|
101
|
+
}, { merge: true });
|
|
102
|
+
await batch.commit();
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
async markUsers(app, marks) {
|
|
106
|
+
for (const chunk of chunks(marks, 400)) {
|
|
107
|
+
const batch = this.db.batch();
|
|
108
|
+
for (const m of chunk) batch.set(this.app(app).collection("users").doc(`${m.scope}__${m.member}`.slice(0, 1400)), {
|
|
109
|
+
scope: m.scope,
|
|
110
|
+
member: m.member,
|
|
111
|
+
lastDay: m.day
|
|
77
112
|
}, { merge: true });
|
|
78
113
|
await batch.commit();
|
|
79
114
|
}
|
|
80
115
|
}
|
|
116
|
+
async countUsers(app, scope, sinceDay) {
|
|
117
|
+
return (await this.app(app).collection("users").where("scope", "==", scope).where("lastDay", ">=", sinceDay).count().get()).data().count;
|
|
118
|
+
}
|
|
119
|
+
async setIssueStatus(app, fp, change) {
|
|
120
|
+
const ref = this.app(app).collection("issues").doc(fp);
|
|
121
|
+
if (!(await ref.get()).exists) return null;
|
|
122
|
+
await ref.update({
|
|
123
|
+
status: change.status,
|
|
124
|
+
resolvedIn: change.status === "resolved" && change.resolvedIn ? change.resolvedIn : FieldValue.delete(),
|
|
125
|
+
resolvedAt: change.status === "resolved" ? (/* @__PURE__ */ new Date()).toISOString() : FieldValue.delete(),
|
|
126
|
+
regressedAt: FieldValue.delete()
|
|
127
|
+
});
|
|
128
|
+
return (await ref.get()).data();
|
|
129
|
+
}
|
|
130
|
+
settingsRef(app) {
|
|
131
|
+
return this.app(app).collection("settings").doc("app");
|
|
132
|
+
}
|
|
133
|
+
async getSettings(app) {
|
|
134
|
+
const snap = await this.settingsRef(app).get();
|
|
135
|
+
return snap.exists ? snap.data() : null;
|
|
136
|
+
}
|
|
137
|
+
async putSettings(app, s) {
|
|
138
|
+
const next = strip({
|
|
139
|
+
...s,
|
|
140
|
+
updatedAt: (/* @__PURE__ */ new Date()).toISOString()
|
|
141
|
+
});
|
|
142
|
+
await this.settingsRef(app).set(next, { merge: true });
|
|
143
|
+
return {
|
|
144
|
+
...await this.getSettings(app),
|
|
145
|
+
...next
|
|
146
|
+
};
|
|
147
|
+
}
|
|
148
|
+
async restampExpiry(app, retentionDays, { cursor, limit = 400 } = {}) {
|
|
149
|
+
let q = this.app(app).collection("events").orderBy("__name__").limit(Math.min(limit, 400));
|
|
150
|
+
if (cursor) q = q.startAfter(cursor);
|
|
151
|
+
const snap = await q.get();
|
|
152
|
+
if (snap.empty) return { updated: 0 };
|
|
153
|
+
const batch = this.db.batch();
|
|
154
|
+
for (const d of snap.docs) {
|
|
155
|
+
const receivedAt = Date.parse(d.get("receivedAt") ?? d.get("ts"));
|
|
156
|
+
batch.update(d.ref, { expireAt: Timestamp.fromMillis(receivedAt + retentionDays * 864e5) });
|
|
157
|
+
}
|
|
158
|
+
await batch.commit();
|
|
159
|
+
const last = snap.docs[snap.docs.length - 1].id;
|
|
160
|
+
return {
|
|
161
|
+
updated: snap.size,
|
|
162
|
+
cursor: snap.size === Math.min(limit, 400) ? last : void 0
|
|
163
|
+
};
|
|
164
|
+
}
|
|
81
165
|
async listApps() {
|
|
82
166
|
return (await this.root.select().get()).docs.map((d) => d.id).sort();
|
|
83
167
|
}
|