@dudousxd/nestjs-telescope-mikro-orm 2.0.0 → 2.0.2

package/dist/mikro-orm-storage.provider.js

@@ -1,8 +1,33 @@
-import { decodeCursor, encodeCursor, isBatchOrigin, mergeHistograms, normalizeHistogram, } from '@dudousxd/nestjs-telescope';
+import { createHash } from 'node:crypto';
+import { HISTOGRAM_BUCKET_COUNT, decodeCursor, encodeCursor, isBatchOrigin, mergeHistograms, normalizeHistogram, } from '@dudousxd/nestjs-telescope';
 import { MikroORM, raw } from '@mikro-orm/core';
 import { TelescopeEntry } from './telescope-entry.entity.js';
+import { TelescopeLease } from './telescope-lease.entity.js';
 import { TelescopeRollup } from './telescope-rollup.entity.js';
+import { TelescopeSchemaMeta } from './telescope-schema-meta.entity.js';
 const DEFAULT_LIMIT = 50;
+/**
+ * Hand-bump escape hatch for DDL changes that are NOT visible in entity metadata
+ * (e.g. a collation tweak, an index expression, anything `schema.update` would
+ * emit but the fingerprint inputs below can't see). Incrementing this forces
+ * every pod to re-run the additive `schema.update` once, then re-cache.
+ */
+const SCHEMA_REVISION = 1;
+/** Stable PK of the single fingerprint marker row. */
+const SCHEMA_META_ID = 'mikro-orm';
+/**
+ * Cross-driver DDL for the fingerprint marker table. `if not exists` keeps it
+ * idempotent and introspection-free (no `information_schema` round-trip), and
+ * the unquoted lowercase identifiers + portable `varchar`/`bigint` types parse
+ * on MySQL, PostgreSQL, and SQLite alike. Mirrors `TelescopeSchemaMeta`.
+ */
+const CREATE_SCHEMA_META_TABLE_SQL = 'create table if not exists telescope_schema_meta (' +
+    'id varchar(32) not null, ' +
+    'fingerprint varchar(64) not null, ' +
+    'applied_at bigint not null, ' +
+    'primary key (id))';
+/** A shared advisory-lock name/key both lock dialects derive from. */
+const SCHEMA_LOCK_NAME = 'telescope_schema';
 /**
  * Every persisted column EXCEPT `content`, used as the MikroORM `fields`
  * projection for content-less aggregate scans (omitContent). Selecting these
@@ -57,6 +82,68 @@ function rowToEntry(row, omitContent = false) {
 function entryToRowData(entry) {
     return { ...entry, tagsText: padTags(entry.tags) };
 }
+/**
+ * `createdAt < before` plus the type selector (single type, or all-except a set,
+ * or — when neither is given — no type filter). MikroORM renders the type clause
+ * to `type = ?` / `type not in (?, …)` on every driver. Shared by the unbounded
+ * and the batched prune so the two can never select different rows.
+ */
+function scopedWhere(scope) {
+    const where = { createdAt: { $lt: scope.before } };
+    if (scope.type !== undefined) {
+        where.type = scope.type;
+    }
+    else if (scope.excludeTypes !== undefined && scope.excludeTypes.length > 0) {
+        where.type = { $nin: scope.excludeTypes };
+    }
+    return where;
+}
+/**
+ * The oldest `limit` rows of `where`, deleted: SELECT their ids, then DELETE BY PRIMARY KEY.
+ *
+ * This shape is chosen for PORTABILITY, and the obvious alternative is not portable: `DELETE ...
+ * ORDER BY created_at LIMIT n` is MySQL/MariaDB-only. PostgreSQL has no ORDER BY/LIMIT on DELETE at
+ * all (it needs exactly this subquery on the primary key), SQLite only has it when compiled with
+ * SQLITE_ENABLE_UPDATE_DELETE_LIMIT, and SQL Server spells it `DELETE TOP (n)` with no ordering.
+ * Expressed at the ORM level as find-then-delete it renders correctly on every driver MikroORM
+ * supports, takes no row locks to read, and the DELETE touches exactly those primary keys.
+ *
+ * With a `type = ?` filter the read is a range of the `(type, created_at, id)` index, already in
+ * the ORDER BY's order: it starts at that type's oldest row, stops after `limit` matches, and costs
+ * one index seek when nothing of that type has expired. Without it the planner sorts or walks
+ * another index past the rows of every other type, on PostgreSQL every row of the table.
+ *
+ * `hasMore` comes from what was SELECTED, not from what was deleted: another pruner racing us can
+ * delete some of these rows first, which lowers `deleted` while saying nothing about whether work
+ * remains.
+ */
+async function pruneOldestBatch(em, where, limit) {
+    const doomed = await em.find(TelescopeEntry, where, {
+        orderBy: { createdAt: 'asc', id: 'asc' },
+        limit,
+        fields: ['id'],
+    });
+    if (doomed.length === 0)
+        return { deleted: 0, hasMore: false };
+    const deleted = await em.nativeDelete(TelescopeEntry, {
+        id: { $in: doomed.map((row) => row.id) },
+    });
+    return { deleted, hasMore: doomed.length === limit };
+}
+/**
+ * Every `type` present, one index seek each (`type > ?`, first in order): a skip scan by hand, since
+ * a plain `DISTINCT` reads the whole index on engines without one (PostgreSQL before 18).
+ */
+async function distinctTypes(em) {
+    const types = [];
+    for (;;) {
+        const previous = types[types.length - 1];
+        const [next] = await em.find(TelescopeEntry, previous === undefined ? {} : { type: { $gt: previous } }, { orderBy: { type: 'asc' }, fields: ['type'], limit: 1 });
+        if (!next)
+            return types;
+        types.push(next.type);
+    }
+}
 function resolveLimit(limit) {
     return typeof limit === 'number' && Number.isInteger(limit) && limit > 0 ? limit : DEFAULT_LIMIT;
 }
@@ -99,6 +186,185 @@ function pickHostConnection(hostConfig) {
         connection.timezone = hostConfig.timezone;
     return connection;
 }
+/**
+ * Table names the gate owns and fingerprints — `telescope_entries`,
+ * `telescope_rollups`, and `telescope_leases`. Derived from metadata (never
+ * hardcoded) so a future tableName rename flows through automatically.
+ * Deliberately EXCLUDES the marker table, whose own shape must never invalidate
+ * the gate.
+ *
+ * `telescope_leases` is INSIDE the fingerprint on purpose: that is what makes an
+ * existing deployment notice the new table and create it on the next boot,
+ * through the same additive `schema.update` path as any other schema change. If
+ * it were excluded, the fingerprint would still match and the lease table would
+ * never be created.
+ */
+function collectOwnedTableNames(orm) {
+    const metadata = orm.getMetadata();
+    return [
+        metadata.get(TelescopeEntry).tableName,
+        metadata.get(TelescopeRollup).tableName,
+        metadata.get(TelescopeLease).tableName,
+    ];
+}
+function compareStrings(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+/** Maps an entity's properties to per-column fingerprints, expanding any
+ * multi-column property by its `fieldNames`. Columns are sorted by name. */
+function columnsOf(meta) {
+    const columns = [];
+    for (const prop of meta.props) {
+        prop.fieldNames.forEach((fieldName, index) => {
+            columns.push({
+                autoincrement: prop.autoincrement === true,
+                default: prop.default ?? null,
+                name: fieldName,
+                nullable: prop.nullable === true,
+                primary: prop.primary === true,
+                type: prop.columnTypes[index] ?? prop.columnTypes[0] ?? prop.type,
+            });
+        });
+    }
+    return columns.sort((left, right) => compareStrings(left.name, right.name));
+}
+function indexNameFromFlag(flag) {
+    return typeof flag === 'string' ? flag : '';
+}
+/**
+ * Index fingerprints from BOTH property-level flags (`{ index: true }` /
+ * `{ unique: true }`, which is how the telescope entities declare every index)
+ * AND any entity-level `meta.indexes`. Without the property-level pass, flipping
+ * an existing column to indexed (no new column) would slip past the gate. Sorted
+ * by name then properties for determinism.
+ */
+function indexesOf(meta) {
+    const indexes = [];
+    for (const prop of meta.props) {
+        if (prop.index) {
+            indexes.push({
+                name: indexNameFromFlag(prop.index),
+                properties: [...prop.fieldNames].sort(),
+            });
+        }
+        if (prop.unique) {
+            indexes.push({
+                name: indexNameFromFlag(prop.unique),
+                properties: [...prop.fieldNames].sort(),
+            });
+        }
+    }
+    for (const index of meta.indexes) {
+        const declared = index.properties;
+        const properties = Array.isArray(declared)
+            ? [...declared]
+            : declared !== undefined
+                ? [declared]
+                : [];
+        indexes.push({ name: index.name ?? '', properties: properties.map(String).sort() });
+    }
+    return indexes.sort((left, right) => compareStrings(left.name, right.name) ||
+        compareStrings(left.properties.join(','), right.properties.join(',')));
+}
+/**
+ * Pure, in-memory sha256 of a CANONICAL serialization of the owned tables' shape
+ * (sorted tables, sorted columns, sorted indexes; object keys authored
+ * alphabetically so `JSON.stringify` is order-stable). The platform name is
+ * folded in so a SQLite CI marker can never satisfy a MySQL boot, the configured
+ * collation so a collation change re-heals, and SCHEMA_REVISION as the manual
+ * escape hatch. Never reads enumeration order — everything is sorted.
+ */
+function computeExpectedFingerprint(orm, ownedTableNames) {
+    const owned = new Set(ownedTableNames);
+    const tables = [];
+    for (const meta of orm.getMetadata()) {
+        if (!owned.has(meta.tableName))
+            continue;
+        tables.push({ columns: columnsOf(meta), indexes: indexesOf(meta), tableName: meta.tableName });
+    }
+    tables.sort((left, right) => compareStrings(left.tableName, right.tableName));
+    const collate = orm.config.get('collate');
+    const payload = {
+        collate: collate ?? null,
+        platform: orm.em.getPlatform().constructor.name,
+        revision: SCHEMA_REVISION,
+        tables,
+    };
+    return createHash('sha256').update(JSON.stringify(payload)).digest('hex');
+}
+/** Reads the single stored fingerprint, or null when the marker row is absent. */
+async function readStoredFingerprint(orm) {
+    const em = orm.em.fork();
+    const row = await em.findOne(TelescopeSchemaMeta, { id: SCHEMA_META_ID });
+    return row ? row.fingerprint : null;
+}
+/** Driver-agnostic upsert of the single marker row with the reconciled fingerprint. */
+async function writeStoredFingerprint(orm, fingerprint) {
+    const em = orm.em.fork();
+    await em.upsert(TelescopeSchemaMeta, {
+        id: SCHEMA_META_ID,
+        fingerprint,
+        appliedAt: Date.now(),
+    });
+}
+/**
+ * Best-effort advisory lock so concurrent pods serialize the one-time heal
+ * instead of all introspecting at once. MySQL/MariaDB use `GET_LOCK`,
+ * PostgreSQL `pg_advisory_lock(hashtext(...))`; SQLite and unknown drivers get a
+ * no-op (single-writer or unsupported). Acquisition failures (permissions,
+ * timeout) degrade to a no-op so the heal still proceeds — the re-SELECT after
+ * locking is what actually prevents duplicate work, the lock just reduces it.
+ */
+async function acquireSchemaLock(orm) {
+    const platform = orm.em.getPlatform().constructor.name.toLowerCase();
+    const connection = orm.em.getConnection();
+    const noop = {
+        release: async () => {
+            /* nothing acquired */
+        },
+    };
+    try {
+        if (platform.includes('mysql') || platform.includes('maria')) {
+            await connection.execute(`select get_lock('${SCHEMA_LOCK_NAME}', 10) as locked`);
+            return {
+                release: async () => {
+                    try {
+                        await connection.execute(`select release_lock('${SCHEMA_LOCK_NAME}')`);
+                    }
+                    catch {
+                        /* lock auto-releases on connection close */
+                    }
+                },
+            };
+        }
+        if (platform.includes('postgre')) {
+            await connection.execute(`select pg_advisory_lock(hashtext('${SCHEMA_LOCK_NAME}'))`);
+            return {
+                release: async () => {
+                    try {
+                        await connection.execute(`select pg_advisory_unlock(hashtext('${SCHEMA_LOCK_NAME}'))`);
+                    }
+                    catch {
+                        /* lock auto-releases on connection close */
+                    }
+                },
+            };
+        }
+    }
+    catch {
+        /* advisory lock unavailable → proceed without it */
+    }
+    return noop;
+}
+/**
+ * Declared against {@link BoundedPruneCapable} and {@link LeaseCapableStorage}
+ * (both extend `StorageProvider`) so dropping either capability is a compile
+ * error rather than a silent fall back to unbounded, unlocked pruning.
+ */
 export class MikroOrmStorageProvider {
     source;
     ensureSchema;
@@ -120,7 +386,7 @@ export class MikroOrmStorageProvider {
             const connection = pickHostConnection(this.source.config.getAll());
             return {
                 ...connection,
-                entities: [TelescopeEntry, TelescopeRollup],
+                entities: [TelescopeEntry, TelescopeRollup, TelescopeSchemaMeta, TelescopeLease],
                 contextName: TELESCOPE_CONTEXT_NAME,
                 allowGlobalContext: true,
             };
@@ -128,7 +394,7 @@ export class MikroOrmStorageProvider {
         const { ensureSchema: _ensureSchema, entities: _entities, ...rest } = this.source;
         return {
             ...rest,
-            entities: [TelescopeEntry, TelescopeRollup],
+            entities: [TelescopeEntry, TelescopeRollup, TelescopeSchemaMeta, TelescopeLease],
             contextName: TELESCOPE_CONTEXT_NAME,
             allowGlobalContext: true,
         };
@@ -138,11 +404,52 @@ export class MikroOrmStorageProvider {
             return;
         this.orm = await MikroORM.init(this.buildOrmOptions());
         if (this.ensureSchema) {
-            await this.orm.schema.ensureDatabase();
+            await this.reconcileSchema(this.orm);
+        }
+    }
+    /**
+     * Fingerprint-gated schema reconciliation. Replaces a bare
+     * `ensureDatabase(); schema.update()` so steady-state boots skip the
+     * whole-database introspection (see the gate notes above the helpers).
+     *
+     * FRESH-DB ORDERING: `ensureDatabase()` runs FIRST, before the marker table is
+     * touched. The provider owns a DEDICATED connection, so on a brand-new DB the
+     * database itself may not exist yet — a `create table telescope_schema_meta`
+     * issued before `ensureDatabase()` would hit "unknown database" on MySQL/PG.
+     * `ensureDatabase()` creates it when missing and is a single cheap existence
+     * check when it already exists (the common case: the host app is already
+     * connected to that database), so paying for it every boot is negligible next
+     * to the multi-second `schema.update` introspection the gate eliminates.
+     */
+    async reconcileSchema(orm) {
+        // (0) Create the database if the owned connection points at one that does
+        //     not exist yet. MUST precede any statement on the connection.
+        await orm.schema.ensureDatabase();
+        const ownedTableNames = collectOwnedTableNames(orm);
+        // (1) Idempotent, introspection-free marker table (empty-DB safe).
+        await orm.em.getConnection().execute(CREATE_SCHEMA_META_TABLE_SQL);
+        // (2) One PK read + (3) in-memory expected fingerprint.
+        const stored = await readStoredFingerprint(orm);
+        const expected = computeExpectedFingerprint(orm, ownedTableNames);
+        // (4) Steady state: identical fingerprint ⇒ skip the whole-DB schema.update.
+        if (stored === expected)
+            return;
+        // (5) Absent/mismatch ⇒ heal once, under a best-effort advisory lock so
+        //     concurrent pods don't all introspect.
+        const lock = await acquireSchemaLock(orm);
+        try {
+            // Another pod may have healed between our SELECT and the lock; re-check.
+            const reStored = await readStoredFingerprint(orm);
+            if (reStored === expected)
+                return;
             // `{ safe: true }` disables BOTH table and column dropping, so the update
-            // is additive-only: it creates the table and adds missing columns/indexes
-            // but never drops anything that already exists.
-            await this.orm.schema.update({ safe: true });
+            // is additive-only: it creates tables and adds missing columns/indexes but
+            // never drops anything that already exists.
+            await orm.schema.update({ safe: true });
+            await writeStoredFingerprint(orm, expected);
+        }
+        finally {
+            await lock.release();
         }
     }
     async close() {
@@ -157,14 +464,27 @@ export class MikroOrmStorageProvider {
         }
         return this.orm.em.fork();
     }
+    /**
+     * Plain multi-row INSERTs, not `em.create()` + `flush()`: entries are write-once, so managed
+     * entities and change sets bought nothing and cost several times the INSERT itself on a busy
+     * host. Chunked by the ORM's `batchSize` so a large flush stays under every driver's
+     * bound-parameter limit; a flush spanning several chunks runs in one transaction so it lands
+     * whole or not at all, and the recorder's retry never re-inserts rows a failed attempt wrote.
+     */
     async store(entries) {
         if (entries.length === 0)
             return;
         const em = this.forkEm();
-        for (const entry of entries) {
-            em.create(TelescopeEntry, entryToRowData(entry));
+        const chunk = em.config.get('batchSize');
+        if (entries.length <= chunk) {
+            await em.insertMany(TelescopeEntry, entries.map(entryToRowData));
+            return;
         }
-        await em.flush();
+        await em.transactional(async (tx) => {
+            for (let offset = 0; offset < entries.length; offset += chunk) {
+                await tx.insertMany(TelescopeEntry, entries.slice(offset, offset + chunk).map(entryToRowData));
+            }
+        });
     }
     async update(id, patch) {
         const em = this.forkEm();
@@ -198,15 +518,18 @@ export class MikroOrmStorageProvider {
             }
             where.id = { $in: query.ids };
         }
-        if (query.type)
+        // Presence-based, not truthy: an explicit empty-string filter must still
+        // apply (matching the in-memory/sqlite/redis providers, which all use
+        // `!== undefined`). A truthy check would silently drop a `type: ''` filter.
+        if (query.type !== undefined)
             where.type = query.type;
-        if (query.familyHash)
+        if (query.familyHash !== undefined)
             where.familyHash = query.familyHash;
-        if (query.batchId)
+        if (query.batchId !== undefined)
             where.batchId = query.batchId;
         if (query.traceId !== undefined)
             where.traceId = query.traceId;
-        if (query.tag)
+        if (query.tag !== undefined)
             where.tagsText = { $like: `% ${query.tag} %` };
         if (query.before || query.after) {
             where.createdAt = {
@@ -251,18 +574,28 @@ export class MikroOrmStorageProvider {
         const rows = await em.find(TelescopeEntry, { batchId }, { orderBy: { sequence: 'asc' } });
         return rows.map((row) => rowToEntry(row));
     }
-    async tags(prefix) {
+    async tags(prefix, query) {
         const em = this.forkEm();
         const rows = await em.find(TelescopeEntry, {}, { orderBy: { createdAt: 'desc', id: 'desc' }, limit: 10000, fields: ['tags'] });
+        const search = query?.search?.trim().toLowerCase();
         const counts = new Map();
         for (const row of rows) {
             for (const tag of row.tags) {
                 if (prefix && !tag.startsWith(prefix))
                     continue;
+                if (search && !tag.toLowerCase().includes(search))
+                    continue;
                 counts.set(tag, (counts.get(tag) ?? 0) + 1);
             }
         }
-        return [...counts.entries()].map(([tag, count]) => ({ tag, count }));
+        // Count descending, ties by tag: the total order `offset` pages over.
+        const ordered = [...counts.entries()]
+            .map(([tag, count]) => ({ tag, count }))
+            .sort((a, b) => b.count - a.count || (a.tag < b.tag ? -1 : a.tag > b.tag ? 1 : 0));
+        if (query?.limit === undefined)
+            return ordered;
+        const offset = query.offset ?? 0;
+        return ordered.slice(offset, offset + query.limit);
     }
     async prune(olderThan, keepLast) {
         const em = this.forkEm();
@@ -275,6 +608,78 @@ export class MikroOrmStorageProvider {
             return 0;
         return em.nativeDelete(TelescopeEntry, { id: { $in: toDelete } });
     }
+    async pruneScopedBatch(input) {
+        const em = this.forkEm();
+        const limit = input.limit;
+        if (input.type !== undefined || !input.excludeTypes?.length) {
+            return pruneOldestBatch(em, scopedWhere(input), limit);
+        }
+        // All types but some, one type at a time. As one `type NOT IN (…)` query the planner walks the
+        // `created_at` index from the oldest row and steps over every row of the excluded types, which
+        // are excluded because they are kept longer: on a table where they hold most of the rows, each
+        // batch read the whole retained backlog to find a few hundred rows (10 s for 1,000 rows next to
+        // 2.8M kept `durable` entries). Per type it reads only that type's expired rows.
+        const excluded = new Set(input.excludeTypes);
+        let deleted = 0;
+        for (const type of await distinctTypes(em)) {
+            if (excluded.has(type))
+                continue;
+            const batch = await pruneOldestBatch(em, scopedWhere({ before: input.before, type }), limit - deleted);
+            deleted += batch.deleted;
+            if (batch.hasMore)
+                return { deleted, hasMore: true };
+        }
+        return { deleted, hasMore: false };
+    }
+    async tryAcquireLease(key, owner, ttlMs, nowMs) {
+        const em = this.forkEm();
+        const expiresAt = nowMs + ttlMs;
+        // Atomicity comes from the CONDITIONAL UPDATE, not from the transaction
+        // isolation level: `update ... where key = ? and (expires_at <= ? or owner = ?)`
+        // is a single statement that takes a row lock, so exactly one of two racing
+        // pods can match. Whoever matches gets the lease; the other's update affects
+        // zero rows.
+        return em.transactional(async (tx) => {
+            const updated = await tx.nativeUpdate(TelescopeLease, { key, $or: [{ expiresAt: { $lte: nowMs } }, { owner }] }, { owner, expiresAt });
+            if (updated > 0)
+                return true;
+            // No row matched: either somebody else holds a live lease, or there is no
+            // row at all. Distinguish by trying the insert — the primary key makes a
+            // concurrent double-insert impossible, and a duplicate-key failure simply
+            // means the other pod won the race.
+            const existing = await tx.findOne(TelescopeLease, { key });
+            if (existing !== null)
+                return false;
+            try {
+                await tx.insert(TelescopeLease, { key, owner, expiresAt });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    async releaseLease(key, owner) {
+        const em = this.forkEm();
+        // Owner-scoped: a holder whose lease already expired and was re-granted must
+        // not delete the new holder's row.
+        await em.nativeDelete(TelescopeLease, { key, owner });
+    }
+    async pruneScoped(input) {
+        const em = this.forkEm();
+        const where = scopedWhere(input);
+        if (input.keepLast === undefined) {
+            return em.nativeDelete(TelescopeEntry, where);
+        }
+        const older = await em.find(TelescopeEntry, where, {
+            orderBy: { createdAt: 'desc', id: 'desc' },
+            fields: ['id'],
+        });
+        const toDelete = older.slice(input.keepLast).map((row) => row.id);
+        if (toDelete.length === 0)
+            return 0;
+        return em.nativeDelete(TelescopeEntry, { id: { $in: toDelete } });
+    }
     async clear() {
         const em = this.forkEm();
         await em.nativeDelete(TelescopeEntry, {});
@@ -282,25 +687,44 @@ export class MikroOrmStorageProvider {
     }
     // ── RollupStore SPI ────────────────────────────────────────────────────────
     /**
-     * Additively merge deltas into `telescope_rollups`, matching the sqlite
-     * provider's `on conflict do update set count = count + excluded.count, ...`
-     * semantics: accumulate count/sum and keep a running max per
+     * Additively merge deltas into `telescope_rollups`: count/sum accumulate, `max`
+     * keeps the running maximum and the histogram adds element-wise, per
      * (metric, bucketStart).
      *
-     * Implemented as a read-modify-write inside ONE transaction rather than a
-     * native upsert. MikroORM's `em.upsert` / `qb.onConflict().merge()` REPLACE
-     * conflicting columns; neither expresses a portable `count = count +
-     * excluded.count` self-referential increment across MySQL and SQLite without
-     * driver-specific raw SQL. The transactional read-modify-write is portable,
-     * cast-free, and — because the whole batch commits atomically with row locks
-     * on the touched PKs — safe to call repeatedly and concurrently: concurrent
-     * writers serialize on the same (metric, bucketStart) rows, so no increment is
-     * lost. New buckets are inserted; existing ones accumulate.
+     * On MySQL/MariaDB, PostgreSQL and SQLite this is one native upsert per chunk
+     * of buckets, with every merge done by the database against the row as it is
+     * at write time, so concurrent writers (other pods) never lose each other's
+     * increments. Buckets are written in key order, so two writers touching the
+     * same buckets lock them in the same order. Other drivers fall back to a
+     * transactional read-modify-write.
      */
     async recordRollups(deltas) {
         if (deltas.length === 0)
             return;
         const em = this.forkEm();
+        const platform = em.getPlatform();
+        const dialect = rollupUpsertDialect(platform.constructor.name);
+        if (dialect === null) {
+            await this.recordRollupsReadModifyWrite(em, deltas);
+            return;
+        }
+        const tableName = em.getMetadata().get(TelescopeRollup).tableName;
+        const quote = (identifier) => platform.quoteIdentifier(identifier);
+        const buckets = mergeDeltasByBucket(deltas);
+        const connection = em.getConnection();
+        for (let offset = 0; offset < buckets.length; offset += ROLLUP_UPSERT_CHUNK) {
+            const chunk = buckets.slice(offset, offset + ROLLUP_UPSERT_CHUNK);
+            await connection.execute(rollupUpsertSql(dialect, quote, tableName, chunk.length), chunk.flatMap((delta) => [
+                delta.metric,
+                delta.bucketStart,
+                delta.count,
+                delta.sum,
+                delta.max,
+                JSON.stringify(normalizeHistogram(delta.histogram)),
+            ]), 'run');
+        }
+    }
+    async recordRollupsReadModifyWrite(em, deltas) {
         await em.transactional(async (tx) => {
             for (const delta of deltas) {
                 const existing = await tx.findOne(TelescopeRollup, {
@@ -345,4 +769,71 @@ export class MikroOrmStorageProvider {
         }));
     }
 }
+/** Buckets per rollup upsert statement (6 bound values each). */
+const ROLLUP_UPSERT_CHUNK = 100;
+/** The upsert flavour for a MikroORM platform class name, or null when it has none here. */
+function rollupUpsertDialect(platformName) {
+    const name = platformName.toLowerCase();
+    if (name.includes('mysql') || name.includes('maria'))
+        return 'mysql';
+    if (name.includes('postgre'))
+        return 'postgresql';
+    if (name.includes('sqlite') || name.includes('libsql'))
+        return 'sqlite';
+    return null;
+}
+/** One delta per (metric, bucketStart), sorted by that key: an upsert may touch a row once. */
+function mergeDeltasByBucket(deltas) {
+    const byKey = new Map();
+    for (const delta of deltas) {
+        const key = `${delta.metric}\u0000${delta.bucketStart}`;
+        const existing = byKey.get(key);
+        if (existing === undefined) {
+            byKey.set(key, { ...delta, histogram: normalizeHistogram(delta.histogram) });
+        }
+        else {
+            existing.count += delta.count;
+            existing.sum += delta.sum;
+            existing.max = Math.max(existing.max, delta.max);
+            existing.histogram = mergeHistograms(existing.histogram, delta.histogram);
+        }
+    }
+    return [...byKey.values()].sort((a, b) => (a.metric < b.metric ? -1 : a.metric > b.metric ? 1 : 0) || a.bucketStart - b.bucketStart);
+}
+/**
+ * `INSERT ... ON CONFLICT/ON DUPLICATE KEY UPDATE` for `rows` rollup buckets.
+ * The histogram is a fixed-length JSON array, rebuilt cell by cell as the sum
+ * of the stored cell (0 when the column is null or short) and the new one.
+ */
+function rollupUpsertSql(dialect, quote, tableName, rows) {
+    const table = quote(tableName);
+    const columns = ['metric', 'bucket_start', 'count', 'sum', 'max', 'histogram'];
+    const values = Array.from({ length: rows }, () => `(${columns.map(() => '?').join(', ')})`);
+    const insert = `insert into ${table} (${columns.map(quote).join(', ')}) values ${values.join(', ')}`;
+    const [count, sum, max, histogram] = ['count', 'sum', 'max', 'histogram'].map(quote);
+    const cells = Array.from({ length: HISTOGRAM_BUCKET_COUNT }, (_, index) => index);
+    if (dialect === 'mysql') {
+        const cell = (source, index) => `cast(coalesce(json_extract(${source}, '$[${index}]'), 0) as signed)`;
+        const merged = cells
+            .map((index) => `${cell(histogram, index)} + ${cell(`values(${histogram})`, index)}`)
+            .join(', ');
+        return `${insert} on duplicate key update ${count} = ${count} + values(${count}), ${sum} = ${sum} + values(${sum}), ${max} = greatest(${max}, values(${max})), ${histogram} = json_array(${merged})`;
+    }
+    const current = (column) => `${table}.${column}`;
+    const incoming = (column) => `excluded.${column}`;
+    const conflict = `on conflict (${quote('metric')}, ${quote('bucket_start')}) do update set`;
+    const totals = `${count} = ${current(count)} + ${incoming(count)}, ${sum} = ${current(sum)} + ${incoming(sum)}`;
+    if (dialect === 'postgresql') {
+        const cell = (source, index) => `coalesce((${source} ->> ${index})::bigint, 0)`;
+        const merged = cells
+            .map((index) => `${cell(current(histogram), index)} + ${cell(incoming(histogram), index)}`)
+            .join(', ');
+        return `${insert} ${conflict} ${totals}, ${max} = greatest(${current(max)}, ${incoming(max)}), ${histogram} = jsonb_build_array(${merged})`;
+    }
+    const cell = (source, index) => `coalesce(json_extract(${source}, '$[${index}]'), 0)`;
+    const merged = cells
+        .map((index) => `${cell(current(histogram), index)} + ${cell(incoming(histogram), index)}`)
+        .join(', ');
+    return `${insert} ${conflict} ${totals}, ${max} = max(${current(max)}, ${incoming(max)}), ${histogram} = json_array(${merged})`;
+}
 //# sourceMappingURL=mikro-orm-storage.provider.js.map