@10x-media/analytics 0.1.0-beta.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/CHANGELOG.md +41 -0
- package/LICENSE +21 -0
- package/README.md +387 -0
- package/dist/RealtimeCounter-BJrjMPSa.js +473 -0
- package/dist/RealtimeCounter-BJrjMPSa.js.map +1 -0
- package/dist/contract-CWZPKWuR.d.ts +83 -0
- package/dist/dist-B6HruP5v.js +4731 -0
- package/dist/dist-B6HruP5v.js.map +1 -0
- package/dist/exports/adapters/ga4.d.ts +20 -0
- package/dist/exports/adapters/ga4.js +177 -0
- package/dist/exports/adapters/ga4.js.map +1 -0
- package/dist/exports/adapters/native.d.ts +22 -0
- package/dist/exports/adapters/native.js +849 -0
- package/dist/exports/adapters/native.js.map +1 -0
- package/dist/exports/adapters/plausible.d.ts +15 -0
- package/dist/exports/adapters/plausible.js +143 -0
- package/dist/exports/adapters/plausible.js.map +1 -0
- package/dist/exports/adapters/posthog.d.ts +17 -0
- package/dist/exports/adapters/posthog.js +119 -0
- package/dist/exports/adapters/posthog.js.map +1 -0
- package/dist/exports/adapters/umami.d.ts +18 -0
- package/dist/exports/adapters/umami.js +139 -0
- package/dist/exports/adapters/umami.js.map +1 -0
- package/dist/exports/client.d.ts +77 -0
- package/dist/exports/client.js +388 -0
- package/dist/exports/client.js.map +1 -0
- package/dist/exports/geo.d.ts +19 -0
- package/dist/exports/geo.js +2 -0
- package/dist/exports/i18n.d.ts +63 -0
- package/dist/exports/i18n.js +3 -0
- package/dist/exports/rsc.d.ts +120 -0
- package/dist/exports/rsc.js +598 -0
- package/dist/exports/rsc.js.map +1 -0
- package/dist/exports/types.d.ts +4 -0
- package/dist/exports/types.js +1 -0
- package/dist/fetchJson-DZb2_Puj.js +36 -0
- package/dist/fetchJson-DZb2_Puj.js.map +1 -0
- package/dist/geoResolver-CasIa4T9.d.ts +12 -0
- package/dist/index-CZdCT0WJ.d.ts +98 -0
- package/dist/index.d.ts +3 -0
- package/dist/index.js +1081 -0
- package/dist/index.js.map +1 -0
- package/dist/keys-DEqL4LOT.js +57 -0
- package/dist/keys-DEqL4LOT.js.map +1 -0
- package/dist/lib-CE5x1zLQ.js +1058 -0
- package/dist/lib-CE5x1zLQ.js.map +1 -0
- package/dist/maxmindResolver-CXYXXdul.js +99 -0
- package/dist/maxmindResolver-CXYXXdul.js.map +1 -0
- package/dist/presets-CBfq_uJX.d.ts +38 -0
- package/dist/readForWidgetRealtime-D1BD37ST.d.ts +32 -0
- package/dist/series-zytbzPoc.js +17 -0
- package/dist/series-zytbzPoc.js.map +1 -0
- package/dist/server-Cuvhgz-S.js +492 -0
- package/dist/server-Cuvhgz-S.js.map +1 -0
- package/dist/testing/memoryAdapter.d.ts +16 -0
- package/dist/testing/memoryAdapter.js +98 -0
- package/dist/testing/memoryAdapter.js.map +1 -0
- package/dist/translations-keiKtSjF.js +77 -0
- package/dist/translations-keiKtSjF.js.map +1 -0
- package/package.json +156 -0
|
@@ -0,0 +1,849 @@
|
|
|
1
|
+
import { i as composeGeoResolvers, r as platformHeaderResolver, t as maxmindResolver } from "../../maxmindResolver-CXYXXdul.js";
|
|
2
|
+
import { createHmac, randomBytes } from "node:crypto";
|
|
3
|
+
//#region src/native/collections/events.ts
|
|
4
|
+
const EVENTS_SLUG = "analytics-events";
|
|
5
|
+
const eventsCollection = () => ({
|
|
6
|
+
slug: EVENTS_SLUG,
|
|
7
|
+
admin: { hidden: true },
|
|
8
|
+
access: {
|
|
9
|
+
read: () => false,
|
|
10
|
+
create: () => true,
|
|
11
|
+
update: () => false,
|
|
12
|
+
delete: () => false
|
|
13
|
+
},
|
|
14
|
+
fields: [
|
|
15
|
+
{
|
|
16
|
+
name: "timestamp",
|
|
17
|
+
type: "date",
|
|
18
|
+
required: true,
|
|
19
|
+
index: true
|
|
20
|
+
},
|
|
21
|
+
{
|
|
22
|
+
name: "type",
|
|
23
|
+
type: "select",
|
|
24
|
+
required: true,
|
|
25
|
+
options: ["pageview", "event"],
|
|
26
|
+
index: true
|
|
27
|
+
},
|
|
28
|
+
{
|
|
29
|
+
name: "name",
|
|
30
|
+
type: "text"
|
|
31
|
+
},
|
|
32
|
+
{
|
|
33
|
+
name: "path",
|
|
34
|
+
type: "text",
|
|
35
|
+
required: true,
|
|
36
|
+
index: true
|
|
37
|
+
},
|
|
38
|
+
{
|
|
39
|
+
name: "hostname",
|
|
40
|
+
type: "text",
|
|
41
|
+
required: true
|
|
42
|
+
},
|
|
43
|
+
{
|
|
44
|
+
name: "referrer",
|
|
45
|
+
type: "text"
|
|
46
|
+
},
|
|
47
|
+
{
|
|
48
|
+
name: "device",
|
|
49
|
+
type: "text"
|
|
50
|
+
},
|
|
51
|
+
{
|
|
52
|
+
name: "source",
|
|
53
|
+
type: "text"
|
|
54
|
+
},
|
|
55
|
+
{
|
|
56
|
+
name: "country",
|
|
57
|
+
type: "text"
|
|
58
|
+
},
|
|
59
|
+
{
|
|
60
|
+
name: "region",
|
|
61
|
+
type: "text"
|
|
62
|
+
},
|
|
63
|
+
{
|
|
64
|
+
name: "city",
|
|
65
|
+
type: "text"
|
|
66
|
+
},
|
|
67
|
+
{
|
|
68
|
+
name: "visitorHash",
|
|
69
|
+
type: "text",
|
|
70
|
+
required: true,
|
|
71
|
+
index: true
|
|
72
|
+
},
|
|
73
|
+
{
|
|
74
|
+
name: "sessionId",
|
|
75
|
+
type: "text",
|
|
76
|
+
required: true,
|
|
77
|
+
index: true
|
|
78
|
+
},
|
|
79
|
+
{
|
|
80
|
+
name: "durationMs",
|
|
81
|
+
type: "number"
|
|
82
|
+
},
|
|
83
|
+
{
|
|
84
|
+
name: "props",
|
|
85
|
+
type: "json"
|
|
86
|
+
}
|
|
87
|
+
],
|
|
88
|
+
indexes: [{ fields: ["path", "timestamp"] }, { fields: ["type", "timestamp"] }]
|
|
89
|
+
});
|
|
90
|
+
//#endregion
|
|
91
|
+
//#region src/native/collections/rollups.ts
|
|
92
|
+
const ROLLUPS_SLUG = "analytics-rollups";
|
|
93
|
+
const rollupsCollection = () => ({
|
|
94
|
+
slug: ROLLUPS_SLUG,
|
|
95
|
+
admin: { hidden: true },
|
|
96
|
+
access: {
|
|
97
|
+
read: () => false,
|
|
98
|
+
create: () => true,
|
|
99
|
+
update: () => true,
|
|
100
|
+
delete: () => true
|
|
101
|
+
},
|
|
102
|
+
fields: [
|
|
103
|
+
{
|
|
104
|
+
name: "granularity",
|
|
105
|
+
type: "text",
|
|
106
|
+
required: true
|
|
107
|
+
},
|
|
108
|
+
{
|
|
109
|
+
name: "period",
|
|
110
|
+
type: "date",
|
|
111
|
+
required: true,
|
|
112
|
+
index: true
|
|
113
|
+
},
|
|
114
|
+
{
|
|
115
|
+
name: "path",
|
|
116
|
+
type: "text",
|
|
117
|
+
required: true,
|
|
118
|
+
index: true
|
|
119
|
+
},
|
|
120
|
+
{
|
|
121
|
+
name: "dimension",
|
|
122
|
+
type: "text",
|
|
123
|
+
required: true,
|
|
124
|
+
defaultValue: ""
|
|
125
|
+
},
|
|
126
|
+
{
|
|
127
|
+
name: "dimvalue",
|
|
128
|
+
type: "text",
|
|
129
|
+
required: true,
|
|
130
|
+
defaultValue: ""
|
|
131
|
+
},
|
|
132
|
+
{
|
|
133
|
+
name: "pageviews",
|
|
134
|
+
type: "number",
|
|
135
|
+
required: true,
|
|
136
|
+
defaultValue: 0
|
|
137
|
+
},
|
|
138
|
+
{
|
|
139
|
+
name: "events",
|
|
140
|
+
type: "number",
|
|
141
|
+
required: true,
|
|
142
|
+
defaultValue: 0
|
|
143
|
+
},
|
|
144
|
+
{
|
|
145
|
+
name: "durationMs",
|
|
146
|
+
type: "number",
|
|
147
|
+
required: true,
|
|
148
|
+
defaultValue: 0
|
|
149
|
+
},
|
|
150
|
+
{
|
|
151
|
+
name: "visitors",
|
|
152
|
+
type: "number",
|
|
153
|
+
required: true,
|
|
154
|
+
defaultValue: 0
|
|
155
|
+
},
|
|
156
|
+
{
|
|
157
|
+
name: "sessions",
|
|
158
|
+
type: "number",
|
|
159
|
+
required: true,
|
|
160
|
+
defaultValue: 0
|
|
161
|
+
},
|
|
162
|
+
{
|
|
163
|
+
name: "samples",
|
|
164
|
+
type: "number",
|
|
165
|
+
required: true,
|
|
166
|
+
defaultValue: 0
|
|
167
|
+
}
|
|
168
|
+
],
|
|
169
|
+
indexes: [{
|
|
170
|
+
fields: [
|
|
171
|
+
"granularity",
|
|
172
|
+
"period",
|
|
173
|
+
"path",
|
|
174
|
+
"dimension",
|
|
175
|
+
"dimvalue"
|
|
176
|
+
],
|
|
177
|
+
unique: true
|
|
178
|
+
}]
|
|
179
|
+
});
|
|
180
|
+
//#endregion
|
|
181
|
+
//#region src/native/collections/seen.ts
|
|
182
|
+
const SEEN_SLUG = "analytics-seen";
|
|
183
|
+
const seenCollection = () => ({
|
|
184
|
+
slug: SEEN_SLUG,
|
|
185
|
+
admin: { hidden: true },
|
|
186
|
+
access: {
|
|
187
|
+
read: () => false,
|
|
188
|
+
create: () => true,
|
|
189
|
+
update: () => false,
|
|
190
|
+
delete: () => true
|
|
191
|
+
},
|
|
192
|
+
fields: [
|
|
193
|
+
{
|
|
194
|
+
name: "bucket",
|
|
195
|
+
type: "text",
|
|
196
|
+
required: true
|
|
197
|
+
},
|
|
198
|
+
{
|
|
199
|
+
name: "kind",
|
|
200
|
+
type: "text",
|
|
201
|
+
required: true
|
|
202
|
+
},
|
|
203
|
+
{
|
|
204
|
+
name: "value",
|
|
205
|
+
type: "text",
|
|
206
|
+
required: true
|
|
207
|
+
},
|
|
208
|
+
{
|
|
209
|
+
name: "period",
|
|
210
|
+
type: "date",
|
|
211
|
+
required: true,
|
|
212
|
+
index: true
|
|
213
|
+
}
|
|
214
|
+
],
|
|
215
|
+
indexes: [{
|
|
216
|
+
fields: [
|
|
217
|
+
"bucket",
|
|
218
|
+
"kind",
|
|
219
|
+
"value"
|
|
220
|
+
],
|
|
221
|
+
unique: true
|
|
222
|
+
}]
|
|
223
|
+
});
|
|
224
|
+
//#endregion
|
|
225
|
+
//#region src/native/rollups/bumpRollup.ts
|
|
226
|
+
const PG_TABLE_KEY = "analytics_rollups";
|
|
227
|
+
const ZERO = {
|
|
228
|
+
pageviews: 0,
|
|
229
|
+
events: 0,
|
|
230
|
+
durationMs: 0,
|
|
231
|
+
samples: 0,
|
|
232
|
+
visitors: 0,
|
|
233
|
+
sessions: 0
|
|
234
|
+
};
|
|
235
|
+
async function bumpRollup(payload, key, inc) {
|
|
236
|
+
if (payload.db.name === "mongoose") {
|
|
237
|
+
const model = payload.db.collections[ROLLUPS_SLUG];
|
|
238
|
+
if (!model) throw new Error(`analytics: mongoose collection "${ROLLUPS_SLUG}" not found`);
|
|
239
|
+
const setOnInsert = { ...key };
|
|
240
|
+
for (const [metric, zero] of Object.entries(ZERO)) if (!(metric in inc)) setOnInsert[metric] = zero;
|
|
241
|
+
await model.collection.updateOne(key, {
|
|
242
|
+
$inc: inc,
|
|
243
|
+
$setOnInsert: setOnInsert
|
|
244
|
+
}, { upsert: true });
|
|
245
|
+
return;
|
|
246
|
+
}
|
|
247
|
+
const { sql } = await import("../../dist-B6HruP5v.js");
|
|
248
|
+
const db = payload.db;
|
|
249
|
+
const tableName = db.tableNameMap.get(PG_TABLE_KEY);
|
|
250
|
+
if (!tableName) throw new Error(`analytics: drizzle table "${PG_TABLE_KEY}" not found`);
|
|
251
|
+
const table = db.tables[tableName];
|
|
252
|
+
if (!table) throw new Error(`analytics: drizzle table object for "${tableName}" not found`);
|
|
253
|
+
const set = {};
|
|
254
|
+
for (const [metric, amount] of Object.entries(inc)) set[metric] = sql`${table[metric]} + ${amount}`;
|
|
255
|
+
await db.drizzle.insert(table).values({
|
|
256
|
+
...key,
|
|
257
|
+
...ZERO,
|
|
258
|
+
...inc
|
|
259
|
+
}).onConflictDoUpdate({
|
|
260
|
+
target: [
|
|
261
|
+
table.granularity,
|
|
262
|
+
table.period,
|
|
263
|
+
table.path,
|
|
264
|
+
table.dimension,
|
|
265
|
+
table.dimvalue
|
|
266
|
+
],
|
|
267
|
+
set
|
|
268
|
+
});
|
|
269
|
+
}
|
|
270
|
+
//#endregion
|
|
271
|
+
//#region src/native/rollups/insertIfNew.ts
|
|
272
|
+
async function insertIfNew(payload, slug, key) {
|
|
273
|
+
if (payload.db.name === "mongoose") {
|
|
274
|
+
const model = payload.db.collections[slug];
|
|
275
|
+
if (!model) throw new Error(`analytics: mongoose collection "${slug}" not found`);
|
|
276
|
+
return (await model.collection.updateOne(key, { $setOnInsert: key }, { upsert: true })).upsertedCount === 1;
|
|
277
|
+
}
|
|
278
|
+
const db = payload.db;
|
|
279
|
+
const tableKey = slug.replace(/-/g, "_");
|
|
280
|
+
const tableName = db.tableNameMap.get(tableKey);
|
|
281
|
+
if (!tableName) throw new Error(`analytics: drizzle table "${tableKey}" not found`);
|
|
282
|
+
const table = db.tables[tableName];
|
|
283
|
+
if (!table) throw new Error(`analytics: drizzle table object for "${tableName}" not found`);
|
|
284
|
+
return (await db.drizzle.insert(table).values(key).onConflictDoNothing().returning()).length === 1;
|
|
285
|
+
}
|
|
286
|
+
//#endregion
|
|
287
|
+
//#region src/native/rollups/applyDistinctDeltas.ts
|
|
288
|
+
function bucketKey(key) {
|
|
289
|
+
return `${key.granularity}|${key.period.toISOString()}|${key.path}|${key.dimension}|${key.dimvalue}`;
|
|
290
|
+
}
|
|
291
|
+
//#endregion
|
|
292
|
+
//#region src/native/rollups/deltas.ts
|
|
293
|
+
const startOfUtcDay$1 = (d) => new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
|
|
294
|
+
function computeRollupDeltas(event) {
|
|
295
|
+
const period = startOfUtcDay$1(event.timestamp);
|
|
296
|
+
const inc = {
|
|
297
|
+
pageviews: event.type === "pageview" ? 1 : 0,
|
|
298
|
+
events: event.type === "event" ? 1 : 0,
|
|
299
|
+
durationMs: event.durationMs ?? 0,
|
|
300
|
+
samples: 1
|
|
301
|
+
};
|
|
302
|
+
const make = (path, dimension, dimvalue) => ({
|
|
303
|
+
key: {
|
|
304
|
+
granularity: "day",
|
|
305
|
+
period,
|
|
306
|
+
path,
|
|
307
|
+
dimension,
|
|
308
|
+
dimvalue
|
|
309
|
+
},
|
|
310
|
+
inc: { ...inc }
|
|
311
|
+
});
|
|
312
|
+
const deltas = [make(event.path, "", ""), make("", "", "")];
|
|
313
|
+
if (event.country) deltas.push(make("", "country", event.country));
|
|
314
|
+
if (event.device) deltas.push(make("", "device", event.device));
|
|
315
|
+
if (event.source) deltas.push(make("", "source", event.source));
|
|
316
|
+
return deltas;
|
|
317
|
+
}
|
|
318
|
+
//#endregion
|
|
319
|
+
//#region src/native/ingest/writeEvent.ts
|
|
320
|
+
async function writeEvent(payload, event) {
|
|
321
|
+
await payload.create({
|
|
322
|
+
collection: EVENTS_SLUG,
|
|
323
|
+
data: event,
|
|
324
|
+
overrideAccess: true
|
|
325
|
+
});
|
|
326
|
+
}
|
|
327
|
+
//#endregion
|
|
328
|
+
//#region src/native/ingest/flushBatch.ts
|
|
329
|
+
async function flushBatch(payload, events) {
|
|
330
|
+
if (events.length === 0) return;
|
|
331
|
+
await Promise.all(events.map((event) => writeEvent(payload, event)));
|
|
332
|
+
const base = /* @__PURE__ */ new Map();
|
|
333
|
+
const candidates = /* @__PURE__ */ new Map();
|
|
334
|
+
for (const event of events) for (const delta of computeRollupDeltas(event)) {
|
|
335
|
+
const bk = bucketKey(delta.key);
|
|
336
|
+
const agg = base.get(bk);
|
|
337
|
+
if (agg) {
|
|
338
|
+
agg.pageviews += delta.inc.pageviews;
|
|
339
|
+
agg.events += delta.inc.events;
|
|
340
|
+
agg.durationMs += delta.inc.durationMs;
|
|
341
|
+
agg.samples += delta.inc.samples;
|
|
342
|
+
} else base.set(bk, {
|
|
343
|
+
key: delta.key,
|
|
344
|
+
...delta.inc
|
|
345
|
+
});
|
|
346
|
+
candidates.set(`${bk}|visitor|${event.visitorHash}`, {
|
|
347
|
+
key: delta.key,
|
|
348
|
+
kind: "visitor",
|
|
349
|
+
value: event.visitorHash
|
|
350
|
+
});
|
|
351
|
+
candidates.set(`${bk}|session|${event.sessionId}`, {
|
|
352
|
+
key: delta.key,
|
|
353
|
+
kind: "session",
|
|
354
|
+
value: event.sessionId
|
|
355
|
+
});
|
|
356
|
+
}
|
|
357
|
+
for (const agg of base.values()) await bumpRollup(payload, agg.key, {
|
|
358
|
+
pageviews: agg.pageviews,
|
|
359
|
+
events: agg.events,
|
|
360
|
+
durationMs: agg.durationMs,
|
|
361
|
+
samples: agg.samples
|
|
362
|
+
});
|
|
363
|
+
const distinct = /* @__PURE__ */ new Map();
|
|
364
|
+
for (const candidate of candidates.values()) {
|
|
365
|
+
if (!await insertIfNew(payload, "analytics-seen", {
|
|
366
|
+
bucket: bucketKey(candidate.key),
|
|
367
|
+
kind: candidate.kind,
|
|
368
|
+
value: candidate.value,
|
|
369
|
+
period: candidate.key.period
|
|
370
|
+
})) continue;
|
|
371
|
+
const metric = candidate.kind === "visitor" ? "visitors" : "sessions";
|
|
372
|
+
const dk = `${bucketKey(candidate.key)}|${metric}`;
|
|
373
|
+
const entry = distinct.get(dk);
|
|
374
|
+
if (entry) entry.count += 1;
|
|
375
|
+
else distinct.set(dk, {
|
|
376
|
+
key: candidate.key,
|
|
377
|
+
metric,
|
|
378
|
+
count: 1
|
|
379
|
+
});
|
|
380
|
+
}
|
|
381
|
+
for (const entry of distinct.values()) {
|
|
382
|
+
const inc = {};
|
|
383
|
+
inc[entry.metric] = entry.count;
|
|
384
|
+
await bumpRollup(payload, entry.key, inc);
|
|
385
|
+
}
|
|
386
|
+
}
|
|
387
|
+
//#endregion
|
|
388
|
+
//#region src/native/ingest/device.ts
|
|
389
|
+
/**
|
|
390
|
+
* Coarse device class from a user-agent string. Tablets are checked before phones
|
|
391
|
+
* because an Android tablet UA lacks the `Mobile` token an Android phone carries.
|
|
392
|
+
*/
|
|
393
|
+
const classifyDevice = (ua) => {
|
|
394
|
+
const s = ua.toLowerCase();
|
|
395
|
+
if (/ipad|tablet|playbook|silk|kindle/.test(s) || /android/.test(s) && !/mobi/.test(s)) return "tablet";
|
|
396
|
+
if (/mobi|iphone|ipod|android|blackberry|iemobile|opera mini|windows phone/.test(s)) return "mobile";
|
|
397
|
+
return "desktop";
|
|
398
|
+
};
|
|
399
|
+
//#endregion
|
|
400
|
+
//#region src/native/ingest/source.ts
|
|
401
|
+
const stripWww = (host) => host.replace(/^www\./, "");
|
|
402
|
+
/**
|
|
403
|
+
* Reduce a raw referrer URL to a coarse traffic source: the bare referrer host
|
|
404
|
+
* (without `www.`), or `Direct` when there is no referrer, it is unparseable, or it
|
|
405
|
+
* points back at the site itself (internal navigation is not a traffic source).
|
|
406
|
+
*/
|
|
407
|
+
const deriveSource = (referrer, selfHostname) => {
|
|
408
|
+
if (!referrer) return "Direct";
|
|
409
|
+
let host;
|
|
410
|
+
try {
|
|
411
|
+
host = new URL(referrer).hostname;
|
|
412
|
+
} catch {
|
|
413
|
+
return "Direct";
|
|
414
|
+
}
|
|
415
|
+
if (!host || stripWww(host) === stripWww(selfHostname)) return "Direct";
|
|
416
|
+
return stripWww(host);
|
|
417
|
+
};
|
|
418
|
+
//#endregion
|
|
419
|
+
//#region src/native/ingest/visitorHash.ts
|
|
420
|
+
function dailyVisitorHash({ ip, ua, site, salt }) {
|
|
421
|
+
return createHmac("sha256", salt).update(`${ip}|${ua}|${site}`).digest("hex");
|
|
422
|
+
}
|
|
423
|
+
function deriveSessionId(visitorHash, hourBucket) {
|
|
424
|
+
return createHmac("sha256", visitorHash).update(hourBucket).digest("hex").slice(0, 32);
|
|
425
|
+
}
|
|
426
|
+
//#endregion
|
|
427
|
+
//#region src/native/ingest/normalizeEvent.ts
|
|
428
|
+
async function normalizeEvent({ raw, headers, geoResolver, salt, now }) {
|
|
429
|
+
const geo = await geoResolver(headers);
|
|
430
|
+
const ip = (headers.get("x-forwarded-for")?.split(",")[0] ?? headers.get("x-real-ip") ?? "").trim();
|
|
431
|
+
const ua = headers.get("user-agent") ?? "";
|
|
432
|
+
const visitorHash = dailyVisitorHash({
|
|
433
|
+
ip,
|
|
434
|
+
ua,
|
|
435
|
+
site: raw.hostname,
|
|
436
|
+
salt
|
|
437
|
+
});
|
|
438
|
+
const hourBucket = now.toISOString().slice(0, 13);
|
|
439
|
+
return {
|
|
440
|
+
timestamp: now,
|
|
441
|
+
type: raw.type,
|
|
442
|
+
name: raw.name,
|
|
443
|
+
path: raw.path,
|
|
444
|
+
hostname: raw.hostname,
|
|
445
|
+
referrer: raw.referrer,
|
|
446
|
+
device: classifyDevice(ua),
|
|
447
|
+
source: deriveSource(raw.referrer, raw.hostname),
|
|
448
|
+
country: geo.country,
|
|
449
|
+
region: geo.region,
|
|
450
|
+
city: geo.city,
|
|
451
|
+
visitorHash,
|
|
452
|
+
sessionId: deriveSessionId(visitorHash, hourBucket),
|
|
453
|
+
durationMs: raw.durationMs,
|
|
454
|
+
props: raw.props
|
|
455
|
+
};
|
|
456
|
+
}
|
|
457
|
+
//#endregion
|
|
458
|
+
//#region src/native/ingest/salt.ts
|
|
459
|
+
async function dailySalt(payload, now) {
|
|
460
|
+
const key = `analytics:salt:${now.toISOString().slice(0, 10)}`;
|
|
461
|
+
const existing = await payload.kv.get(key);
|
|
462
|
+
if (existing) return existing.salt;
|
|
463
|
+
const salt = randomBytes(16).toString("hex");
|
|
464
|
+
await payload.kv.set(key, { salt });
|
|
465
|
+
return salt;
|
|
466
|
+
}
|
|
467
|
+
//#endregion
|
|
468
|
+
//#region src/native/ingest/endpoint.ts
|
|
469
|
+
const makeIngestHandler = (geoResolver, getBuffer = () => null) => async (req) => {
|
|
470
|
+
const raw = (req.headers.get("content-type") ?? "").startsWith("application/json") ? await req.json?.() : JSON.parse(await req.text?.() ?? "{}");
|
|
471
|
+
if (!raw?.path || !raw?.hostname || raw.type !== "pageview" && raw.type !== "event") return Response.json({ error: "invalid payload" }, { status: 400 });
|
|
472
|
+
const now = /* @__PURE__ */ new Date();
|
|
473
|
+
const salt = await dailySalt(req.payload, now);
|
|
474
|
+
const event = await normalizeEvent({
|
|
475
|
+
raw,
|
|
476
|
+
headers: req.headers,
|
|
477
|
+
geoResolver,
|
|
478
|
+
salt,
|
|
479
|
+
now
|
|
480
|
+
});
|
|
481
|
+
const buffer = getBuffer();
|
|
482
|
+
if (buffer) buffer.add(event);
|
|
483
|
+
else await flushBatch(req.payload, [event]);
|
|
484
|
+
return Response.json({ ok: true }, { status: 202 });
|
|
485
|
+
};
|
|
486
|
+
//#endregion
|
|
487
|
+
//#region src/native/ingest/writeBuffer.ts
|
|
488
|
+
const defaultSetTimer = (fn, ms) => {
|
|
489
|
+
const handle = setTimeout(fn, ms);
|
|
490
|
+
handle.unref?.();
|
|
491
|
+
return () => clearTimeout(handle);
|
|
492
|
+
};
|
|
493
|
+
function createWriteBuffer(options) {
|
|
494
|
+
const { maxSize, maxAgeMs, onFlush, onError } = options;
|
|
495
|
+
const setTimer = options.setTimer ?? defaultSetTimer;
|
|
496
|
+
let items = [];
|
|
497
|
+
let cancelTimer = null;
|
|
498
|
+
let chain = Promise.resolve();
|
|
499
|
+
const disarm = () => {
|
|
500
|
+
if (cancelTimer) {
|
|
501
|
+
cancelTimer();
|
|
502
|
+
cancelTimer = null;
|
|
503
|
+
}
|
|
504
|
+
};
|
|
505
|
+
const drain = async () => {
|
|
506
|
+
disarm();
|
|
507
|
+
if (items.length === 0) return;
|
|
508
|
+
const batch = items;
|
|
509
|
+
items = [];
|
|
510
|
+
try {
|
|
511
|
+
await onFlush(batch);
|
|
512
|
+
} catch (error) {
|
|
513
|
+
onError?.(error);
|
|
514
|
+
}
|
|
515
|
+
if (items.length > 0) await drain();
|
|
516
|
+
};
|
|
517
|
+
const flush = () => {
|
|
518
|
+
chain = chain.then(drain);
|
|
519
|
+
return chain;
|
|
520
|
+
};
|
|
521
|
+
const add = (item) => {
|
|
522
|
+
items.push(item);
|
|
523
|
+
if (items.length >= maxSize) {
|
|
524
|
+
flush();
|
|
525
|
+
return;
|
|
526
|
+
}
|
|
527
|
+
if (!cancelTimer) cancelTimer = setTimer(() => {
|
|
528
|
+
flush();
|
|
529
|
+
}, maxAgeMs);
|
|
530
|
+
};
|
|
531
|
+
return {
|
|
532
|
+
add,
|
|
533
|
+
flush,
|
|
534
|
+
stop: flush,
|
|
535
|
+
size: () => items.length
|
|
536
|
+
};
|
|
537
|
+
}
|
|
538
|
+
//#endregion
|
|
539
|
+
//#region src/native/realtime/buildRealtime.ts
|
|
540
|
+
const MINUTE_MS = 6e4;
|
|
541
|
+
const startOfMinute = (ms) => ms - ms % MINUTE_MS;
|
|
542
|
+
const selectRealtime = (pageviews, visitors, metrics) => {
|
|
543
|
+
const out = {};
|
|
544
|
+
if (metrics.includes("pageviews")) out.pageviews = pageviews;
|
|
545
|
+
if (metrics.includes("visitors")) out.visitors = visitors;
|
|
546
|
+
return out;
|
|
547
|
+
};
|
|
548
|
+
/**
|
|
549
|
+
* Collapse recent events into a zero-filled per-minute series plus window totals.
|
|
550
|
+
* "Active visitors" is the distinct `visitorHash` count (over any event); pageviews
|
|
551
|
+
* count `type === 'pageview'`. Distinct visitors are counted per minute and over the
|
|
552
|
+
* whole window separately (never summed across minutes).
|
|
553
|
+
*/
|
|
554
|
+
const buildRealtime = (events, range, metrics) => {
|
|
555
|
+
const buckets = /* @__PURE__ */ new Map();
|
|
556
|
+
const allVisitors = /* @__PURE__ */ new Set();
|
|
557
|
+
let pageviews = 0;
|
|
558
|
+
for (const e of events) {
|
|
559
|
+
if (e.type === "pageview") pageviews++;
|
|
560
|
+
allVisitors.add(e.visitorHash);
|
|
561
|
+
const minute = startOfMinute(new Date(e.timestamp).getTime());
|
|
562
|
+
let b = buckets.get(minute);
|
|
563
|
+
if (!b) {
|
|
564
|
+
b = {
|
|
565
|
+
pv: 0,
|
|
566
|
+
visitors: /* @__PURE__ */ new Set()
|
|
567
|
+
};
|
|
568
|
+
buckets.set(minute, b);
|
|
569
|
+
}
|
|
570
|
+
if (e.type === "pageview") b.pv++;
|
|
571
|
+
b.visitors.add(e.visitorHash);
|
|
572
|
+
}
|
|
573
|
+
const rows = [];
|
|
574
|
+
const first = startOfMinute(range.start.getTime());
|
|
575
|
+
const last = startOfMinute(range.end.getTime());
|
|
576
|
+
for (let m = first; m <= last; m += MINUTE_MS) {
|
|
577
|
+
const b = buckets.get(m);
|
|
578
|
+
rows.push({
|
|
579
|
+
timestamp: new Date(m).toISOString(),
|
|
580
|
+
metrics: selectRealtime(b?.pv ?? 0, b?.visitors.size ?? 0, metrics)
|
|
581
|
+
});
|
|
582
|
+
}
|
|
583
|
+
return {
|
|
584
|
+
rows,
|
|
585
|
+
totals: selectRealtime(pageviews, allVisitors.size, metrics)
|
|
586
|
+
};
|
|
587
|
+
};
|
|
588
|
+
//#endregion
|
|
589
|
+
//#region src/native/retention/pruneTask.ts
|
|
590
|
+
const PRUNE_TASK_SLUG = "analytics-prune-events";
|
|
591
|
+
const pruneEventsTask = (retentionDays) => ({
|
|
592
|
+
slug: PRUNE_TASK_SLUG,
|
|
593
|
+
handler: async ({ req }) => {
|
|
594
|
+
const cutoff = (/* @__PURE__ */ new Date(Date.now() - retentionDays * 864e5)).toISOString();
|
|
595
|
+
const events = await req.payload.delete({
|
|
596
|
+
collection: EVENTS_SLUG,
|
|
597
|
+
where: { timestamp: { less_than: cutoff } },
|
|
598
|
+
overrideAccess: true
|
|
599
|
+
});
|
|
600
|
+
const seen = await req.payload.delete({
|
|
601
|
+
collection: SEEN_SLUG,
|
|
602
|
+
where: { period: { less_than: cutoff } },
|
|
603
|
+
overrideAccess: true
|
|
604
|
+
});
|
|
605
|
+
return { output: { deleted: events.docs.length + seen.docs.length } };
|
|
606
|
+
},
|
|
607
|
+
schedule: [{
|
|
608
|
+
cron: "0 3 * * *",
|
|
609
|
+
queue: "default"
|
|
610
|
+
}]
|
|
611
|
+
});
|
|
612
|
+
//#endregion
|
|
613
|
+
//#region src/native/rollupAcc.ts
|
|
614
|
+
const emptyAcc = () => ({
|
|
615
|
+
pageviews: 0,
|
|
616
|
+
events: 0,
|
|
617
|
+
durationMs: 0,
|
|
618
|
+
visitors: 0,
|
|
619
|
+
sessions: 0
|
|
620
|
+
});
|
|
621
|
+
const add = (acc, d) => {
|
|
622
|
+
acc.pageviews += d.pageviews;
|
|
623
|
+
acc.events += d.events;
|
|
624
|
+
acc.durationMs += d.durationMs;
|
|
625
|
+
acc.visitors += d.visitors;
|
|
626
|
+
acc.sessions += d.sessions;
|
|
627
|
+
};
|
|
628
|
+
const selectMetrics = (acc, wanted) => {
|
|
629
|
+
const out = {};
|
|
630
|
+
if (wanted.includes("pageviews")) out.pageviews = acc.pageviews;
|
|
631
|
+
if (wanted.includes("events")) out.events = acc.events;
|
|
632
|
+
if (wanted.includes("visitors")) out.visitors = acc.visitors;
|
|
633
|
+
if (wanted.includes("sessions")) out.sessions = acc.sessions;
|
|
634
|
+
if (wanted.includes("avgDuration")) out.avgDuration = acc.pageviews > 0 ? Math.round(acc.durationMs / acc.pageviews) : 0;
|
|
635
|
+
return out;
|
|
636
|
+
};
|
|
637
|
+
const startOfUtcDay = (d) => new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
|
|
638
|
+
/**
|
|
639
|
+
* Collapse per-day rollup docs into one time-series row per UTC day, ascending by
|
|
640
|
+
* day. Distinct metrics (visitors/sessions) come from each day's own rollup and are
|
|
641
|
+
* never summed across days, so a daily trend shows that day's uniques.
|
|
642
|
+
*/
|
|
643
|
+
const seriesFromRollups = (docs, metrics) => {
|
|
644
|
+
const byDay = /* @__PURE__ */ new Map();
|
|
645
|
+
for (const d of docs) {
|
|
646
|
+
const day = startOfUtcDay(new Date(d.period)).toISOString();
|
|
647
|
+
let acc = byDay.get(day);
|
|
648
|
+
if (!acc) {
|
|
649
|
+
acc = emptyAcc();
|
|
650
|
+
byDay.set(day, acc);
|
|
651
|
+
}
|
|
652
|
+
add(acc, d);
|
|
653
|
+
}
|
|
654
|
+
return [...byDay.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([day, acc]) => ({
|
|
655
|
+
timestamp: day,
|
|
656
|
+
metrics: selectMetrics(acc, metrics)
|
|
657
|
+
}));
|
|
658
|
+
};
|
|
659
|
+
//#endregion
|
|
660
|
+
//#region src/native/nativeAdapter.ts
|
|
661
|
+
const metrics = new Set([
|
|
662
|
+
"pageviews",
|
|
663
|
+
"visitors",
|
|
664
|
+
"sessions",
|
|
665
|
+
"events",
|
|
666
|
+
"avgDuration"
|
|
667
|
+
]);
|
|
668
|
+
const dimensions = new Set([
|
|
669
|
+
"page",
|
|
670
|
+
"country",
|
|
671
|
+
"source",
|
|
672
|
+
"device"
|
|
673
|
+
]);
|
|
674
|
+
const REALTIME_EVENT_LIMIT = 5e4;
|
|
675
|
+
const capabilities = {
|
|
676
|
+
perPageQuery: true,
|
|
677
|
+
realtime: true,
|
|
678
|
+
realtimeWindowMinutes: 60,
|
|
679
|
+
comparison: false,
|
|
680
|
+
minGranularity: "day",
|
|
681
|
+
maxLookbackDays: null,
|
|
682
|
+
metrics,
|
|
683
|
+
dimensions,
|
|
684
|
+
batchPageReport: true,
|
|
685
|
+
rateLimit: null,
|
|
686
|
+
recommendedTtl: {
|
|
687
|
+
realtime: 10,
|
|
688
|
+
aggregate: 300
|
|
689
|
+
}
|
|
690
|
+
};
|
|
691
|
+
function native(options = {}) {
|
|
692
|
+
const geoResolver = options.geoResolver ?? (options.geoDbPath ? composeGeoResolvers(platformHeaderResolver, maxmindResolver({ dbPath: options.geoDbPath })) : platformHeaderResolver);
|
|
693
|
+
let payloadRef = null;
|
|
694
|
+
let buffer = null;
|
|
695
|
+
const readRollups = async (payload, where) => {
|
|
696
|
+
const { docs } = await payload.find({
|
|
697
|
+
collection: ROLLUPS_SLUG,
|
|
698
|
+
where,
|
|
699
|
+
limit: 1e5,
|
|
700
|
+
pagination: false
|
|
701
|
+
});
|
|
702
|
+
return docs;
|
|
703
|
+
};
|
|
704
|
+
return {
|
|
705
|
+
id: "native",
|
|
706
|
+
label: "Native (Payload)",
|
|
707
|
+
capabilities,
|
|
708
|
+
isConfigured: () => true,
|
|
709
|
+
flush: () => buffer?.flush() ?? Promise.resolve(),
|
|
710
|
+
register(config) {
|
|
711
|
+
config.collections = [
|
|
712
|
+
...config.collections ?? [],
|
|
713
|
+
eventsCollection(),
|
|
714
|
+
rollupsCollection(),
|
|
715
|
+
seenCollection()
|
|
716
|
+
];
|
|
717
|
+
config.endpoints = [...config.endpoints ?? [], {
|
|
718
|
+
method: "post",
|
|
719
|
+
path: options.ingestPath ?? "/analytics/ingest",
|
|
720
|
+
handler: makeIngestHandler(geoResolver, () => buffer)
|
|
721
|
+
}];
|
|
722
|
+
if (options.retentionDays && options.retentionDays > 0) config.jobs = {
|
|
723
|
+
...config.jobs,
|
|
724
|
+
tasks: [...config.jobs?.tasks ?? [], pruneEventsTask(options.retentionDays)]
|
|
725
|
+
};
|
|
726
|
+
const prevOnInit = config.onInit;
|
|
727
|
+
config.onInit = async (p) => {
|
|
728
|
+
await prevOnInit?.(p);
|
|
729
|
+
payloadRef = p;
|
|
730
|
+
if (options.buffer) {
|
|
731
|
+
const cfg = options.buffer === true ? {} : options.buffer;
|
|
732
|
+
buffer = createWriteBuffer({
|
|
733
|
+
maxSize: cfg.maxSize ?? 50,
|
|
734
|
+
maxAgeMs: cfg.maxAgeMs ?? 2e3,
|
|
735
|
+
onFlush: (batch) => flushBatch(p, batch),
|
|
736
|
+
onError: (error) => {
|
|
737
|
+
p.logger.error({
|
|
738
|
+
err: error,
|
|
739
|
+
msg: "analytics: write buffer flush failed"
|
|
740
|
+
});
|
|
741
|
+
}
|
|
742
|
+
});
|
|
743
|
+
}
|
|
744
|
+
};
|
|
745
|
+
},
|
|
746
|
+
async query(q) {
|
|
747
|
+
if (!payloadRef) throw new Error("analytics: native adapter queried before init");
|
|
748
|
+
const fetchedAt = q.dateRange.end.toISOString();
|
|
749
|
+
const periodWhere = {
|
|
750
|
+
greater_than_equal: q.dateRange.start.toISOString(),
|
|
751
|
+
less_than_equal: q.dateRange.end.toISOString()
|
|
752
|
+
};
|
|
753
|
+
const dim = q.dimensions?.find((d) => dimensions.has(d));
|
|
754
|
+
const totalsPath = dim ? "" : q.path ?? "";
|
|
755
|
+
const totalsDocs = await readRollups(payloadRef, {
|
|
756
|
+
granularity: { equals: "day" },
|
|
757
|
+
dimension: { equals: "" },
|
|
758
|
+
path: { equals: totalsPath },
|
|
759
|
+
period: periodWhere
|
|
760
|
+
});
|
|
761
|
+
const totalsAcc = emptyAcc();
|
|
762
|
+
for (const d of totalsDocs) add(totalsAcc, d);
|
|
763
|
+
const totals = selectMetrics(totalsAcc, q.metrics);
|
|
764
|
+
if (!dim) {
|
|
765
|
+
if (q.granularity === "day") return {
|
|
766
|
+
rows: seriesFromRollups(totalsDocs, q.metrics),
|
|
767
|
+
totals,
|
|
768
|
+
meta: {
|
|
769
|
+
provider: "native",
|
|
770
|
+
fetchedAt
|
|
771
|
+
}
|
|
772
|
+
};
|
|
773
|
+
return {
|
|
774
|
+
rows: [{ metrics: totals }],
|
|
775
|
+
totals,
|
|
776
|
+
meta: {
|
|
777
|
+
provider: "native",
|
|
778
|
+
fetchedAt
|
|
779
|
+
}
|
|
780
|
+
};
|
|
781
|
+
}
|
|
782
|
+
const breakdownWhere = dim === "page" ? {
|
|
783
|
+
granularity: { equals: "day" },
|
|
784
|
+
dimension: { equals: "" },
|
|
785
|
+
path: { not_equals: "" },
|
|
786
|
+
period: periodWhere
|
|
787
|
+
} : {
|
|
788
|
+
granularity: { equals: "day" },
|
|
789
|
+
dimension: { equals: dim },
|
|
790
|
+
path: { equals: "" },
|
|
791
|
+
period: periodWhere
|
|
792
|
+
};
|
|
793
|
+
const groups = /* @__PURE__ */ new Map();
|
|
794
|
+
for (const d of await readRollups(payloadRef, breakdownWhere)) {
|
|
795
|
+
const value = dim === "page" ? d.path : d.dimvalue;
|
|
796
|
+
let acc = groups.get(value);
|
|
797
|
+
if (!acc) {
|
|
798
|
+
acc = emptyAcc();
|
|
799
|
+
groups.set(value, acc);
|
|
800
|
+
}
|
|
801
|
+
add(acc, d);
|
|
802
|
+
}
|
|
803
|
+
let rows = [...groups].map(([value, acc]) => ({
|
|
804
|
+
dimensions: { [dim]: value },
|
|
805
|
+
metrics: selectMetrics(acc, q.metrics)
|
|
806
|
+
}));
|
|
807
|
+
const sortMetric = q.order?.metric ?? "pageviews";
|
|
808
|
+
const direction = (q.order?.direction ?? "desc") === "asc" ? 1 : -1;
|
|
809
|
+
rows.sort((a, b) => ((a.metrics[sortMetric] ?? 0) - (b.metrics[sortMetric] ?? 0)) * direction);
|
|
810
|
+
if (q.limit) rows = rows.slice(0, q.limit);
|
|
811
|
+
return {
|
|
812
|
+
rows,
|
|
813
|
+
totals,
|
|
814
|
+
meta: {
|
|
815
|
+
provider: "native",
|
|
816
|
+
fetchedAt
|
|
817
|
+
}
|
|
818
|
+
};
|
|
819
|
+
},
|
|
820
|
+
async realtime(q, _ctx) {
|
|
821
|
+
if (!payloadRef) throw new Error("analytics: native adapter queried before init");
|
|
822
|
+
const fetchedAt = q.dateRange.end.toISOString();
|
|
823
|
+
const { docs } = await payloadRef.find({
|
|
824
|
+
collection: EVENTS_SLUG,
|
|
825
|
+
where: { timestamp: {
|
|
826
|
+
greater_than_equal: q.dateRange.start.toISOString(),
|
|
827
|
+
less_than_equal: q.dateRange.end.toISOString()
|
|
828
|
+
} },
|
|
829
|
+
limit: REALTIME_EVENT_LIMIT,
|
|
830
|
+
pagination: false,
|
|
831
|
+
depth: 0,
|
|
832
|
+
sort: "-timestamp"
|
|
833
|
+
});
|
|
834
|
+
const { rows, totals } = buildRealtime(docs, q.dateRange, q.metrics);
|
|
835
|
+
return {
|
|
836
|
+
rows,
|
|
837
|
+
totals,
|
|
838
|
+
meta: {
|
|
839
|
+
provider: "native",
|
|
840
|
+
fetchedAt
|
|
841
|
+
}
|
|
842
|
+
};
|
|
843
|
+
}
|
|
844
|
+
};
|
|
845
|
+
}
|
|
846
|
+
//#endregion
|
|
847
|
+
export { native };
|
|
848
|
+
|
|
849
|
+
//# sourceMappingURL=native.js.map
|