@noego/telemetry 0.0.1 → 0.0.3

package/dist/node/index.d.cts

@@ -1,16 +1,16 @@
 import { T as TelemetryAdmissionPolicy, M as MetadataSnapshotLimits, a as TelemetryClient } from '../telemetry_client-CYaPYfOl.cjs';
-import { T as TelemetrySinkPlugin, c as MaintenanceLifecycleEvent, e as TelemetryCollectorRuntime, f as TelemetryCollectorStatus } from '../maintenance_coordinator.types-B-bZUNvw.cjs';
-import { S as SqliteTargetConfiguration, M as MetricDefinition } from '../query.types-Bntwh6KF.cjs';
-import { T as TelemetryStorageTransport, e as TelemetryStorageTarget, a as TelemetryStorageCapabilities } from '../storage.types-DjuUMinz.cjs';
+import { T as TelemetrySinkPlugin, c as MaintenanceLifecycleEvent, e as TelemetryCollectorRuntime, f as TelemetryCollectorStatus } from '../maintenance_coordinator.types-C4ULi4A4.cjs';
+import { S as SqliteTargetConfiguration, M as MetricDefinition } from '../query.types-DuYWbFFe.cjs';
+import { T as TelemetryStorageTransport, e as TelemetryStorageTarget, a as TelemetryStorageCapabilities } from '../storage.types-Bji_pWqr.cjs';
 import { a as TelemetryBatchValidationLimits, c as TelemetryBatchReceiver } from '../transport.types-BAl_TRtU.cjs';
 import { NodeTelemetryProducerOptions } from './producer/index.cjs';
 export { NodeTelemetryProducerHost } from './producer/index.cjs';
 export { SQLiteTelemetryTransport } from '../sqlite/index.cjs';
-export { a as NodeTelemetryConfigurationParseOptions, N as NodeTelemetryConfigurationParser, T as TelemetryConfigurationError, b as TelemetryDurationParser } from '../telemetry_configuration_parser-R-niZQRZ.cjs';
+export { a as NodeTelemetryConfigurationParseOptions, N as NodeTelemetryConfigurationParser, T as TelemetryConfigurationError, b as TelemetryDurationParser } from '../telemetry_configuration_parser-CgSN7R6A.cjs';
 export { D as DEFAULT_METADATA_SNAPSHOT_LIMITS, a as DEFAULT_TELEMETRY_ADMISSION_POLICY } from '../client_defaults-C9LnSX4j.cjs';
 import '../envelope.types-rOLpWXRC.cjs';
 import '../result.types-171Huujb.cjs';
-import '../metric_definition_contract-BR6a_GzF.cjs';
+import '../metric_definition_contract-DfhhmTZ1.cjs';
 
 type NodeLocalTelemetryProducerOptions = Omit<NodeTelemetryProducerOptions, 'transport'>;
 type NodeTelemetryCollectorOptions = Readonly<{

package/dist/node/index.d.ts

@@ -1,16 +1,16 @@
 import { T as TelemetryAdmissionPolicy, M as MetadataSnapshotLimits, a as TelemetryClient } from '../telemetry_client-BXw8WH_F.js';
-import { T as TelemetrySinkPlugin, c as MaintenanceLifecycleEvent, e as TelemetryCollectorRuntime, f as TelemetryCollectorStatus } from '../maintenance_coordinator.types-CBA5y74b.js';
-import { S as SqliteTargetConfiguration, M as MetricDefinition } from '../query.types-DySoqYop.js';
-import { T as TelemetryStorageTransport, e as TelemetryStorageTarget, a as TelemetryStorageCapabilities } from '../storage.types-BTCGVxOM.js';
+import { T as TelemetrySinkPlugin, c as MaintenanceLifecycleEvent, e as TelemetryCollectorRuntime, f as TelemetryCollectorStatus } from '../maintenance_coordinator.types-ikUrRXmO.js';
+import { S as SqliteTargetConfiguration, M as MetricDefinition } from '../query.types-DU5v7vM0.js';
+import { T as TelemetryStorageTransport, e as TelemetryStorageTarget, a as TelemetryStorageCapabilities } from '../storage.types-k7oElEB3.js';
 import { a as TelemetryBatchValidationLimits, c as TelemetryBatchReceiver } from '../transport.types-DDnZoKWi.js';
 import { NodeTelemetryProducerOptions } from './producer/index.js';
 export { NodeTelemetryProducerHost } from './producer/index.js';
 export { SQLiteTelemetryTransport } from '../sqlite/index.js';
-export { a as NodeTelemetryConfigurationParseOptions, N as NodeTelemetryConfigurationParser, T as TelemetryConfigurationError, b as TelemetryDurationParser } from '../telemetry_configuration_parser-C7Et_gwG.js';
+export { a as NodeTelemetryConfigurationParseOptions, N as NodeTelemetryConfigurationParser, T as TelemetryConfigurationError, b as TelemetryDurationParser } from '../telemetry_configuration_parser-BZ8Nvnle.js';
 export { D as DEFAULT_METADATA_SNAPSHOT_LIMITS, a as DEFAULT_TELEMETRY_ADMISSION_POLICY } from '../client_defaults-B5tC-TgG.js';
 import '../envelope.types-rOLpWXRC.js';
 import '../result.types-171Huujb.js';
-import '../metric_definition_contract-l4i4SaAp.js';
+import '../metric_definition_contract-BYtnODhu.js';
 
 type NodeLocalTelemetryProducerOptions = Omit<NodeTelemetryProducerOptions, 'transport'>;
 type NodeTelemetryCollectorOptions = Readonly<{

package/dist/node/index.js

@@ -3946,73 +3946,49 @@ var TelemetryRepository = class {
       lastSequence: sample.sequence
     };
   }
+  /**
+   * Raw retention is purely time-based, matching the native collector: every
+   * expired row goes in one set-based statement per level band. No page size,
+   * no row cap, and no rollup-completion gate — metric samples are extracted at
+   * ingest and retained on their own clock, so dropping a raw row costs no
+   * metric fidelity, and no row can outlive its window waiting on a rollup.
+   */
   createRawEventRetentionStep(nowMs) {
-    const cutoffMs = nowMs - this.options.retention.rawMs;
     const table = this.options.tableMap.quoted("rawEvents");
-    const readFirstPage = this.options.connection.prepare(
-      `SELECT producer_id, sequence, event_id, occurred_at_ms, monotonic_ns,
-              source, process_kind, level, label, conversation_id,
-              conversation_id_kind, correlation_id, metadata_json, schema_version
-       FROM ${table}
-       WHERE target_id = ? AND occurred_at_ms < ?
-       ORDER BY occurred_at_ms ASC, producer_id ASC, sequence ASC
-       LIMIT ${RETENTION_PAGE_SIZE}`
-    );
-    const readNextPage = this.options.connection.prepare(
-      `SELECT producer_id, sequence, event_id, occurred_at_ms, monotonic_ns,
-              source, process_kind, level, label, conversation_id,
-              conversation_id_kind, correlation_id, metadata_json, schema_version
-       FROM ${table}
-       WHERE target_id = ? AND occurred_at_ms < ?
-         AND (occurred_at_ms, producer_id, sequence) > (?, ?, ?)
-       ORDER BY occurred_at_ms ASC, producer_id ASC, sequence ASC
-       LIMIT ${RETENTION_PAGE_SIZE}`
+    const levelMs = this.options.retention.levelMs ?? {};
+    const levels = Object.keys(levelMs);
+    const removeByLevel = this.options.connection.prepare(
+      `DELETE FROM ${table}
+       WHERE target_id = ? AND lower(coalesce(level, '')) = ? AND occurred_at_ms < ?`
     );
-    const remove = this.options.connection.prepare(
-      `DELETE FROM ${table} WHERE target_id = ? AND producer_id = ? AND sequence = ?`
+    const fallbackPlaceholders = levels.map(() => "?").join(", ");
+    const removeFallback = this.options.connection.prepare(
+      `DELETE FROM ${table}
+       WHERE target_id = ? AND occurred_at_ms < ?` + (levels.length === 0 ? "" : ` AND lower(coalesce(level, '')) NOT IN (${fallbackPlaceholders})`)
     );
-    let cursor = null;
+    let done = false;
     return () => {
-      const rows = cursor === null ? readFirstPage.all(this.options.targetId, cutoffMs) : readNextPage.all(
-        this.options.targetId,
-        cutoffMs,
-        cursor.occurredAtMs,
-        cursor.producerId,
-        cursor.sequence
-      );
-      if (rows.length === 0) {
+      if (done) {
         return { deleted: 0, done: true };
       }
-      const scanned = rows.map((row) => {
-        const parsed = this.rowParser.parseRawEnvelope(row);
-        if (!parsed.ok) {
-          throw new Error(parsed.error);
-        }
-        return parsed.value;
-      });
-      const eligible = scanned.filter((envelope) => this.rawEventHasRequiredRollups(envelope));
+      done = true;
       const transaction = this.options.connection.transaction(() => {
-        let deleted2 = 0;
-        for (const envelope of eligible) {
-          deleted2 += remove.run(
-            this.options.targetId,
-            envelope.producerId,
-            envelope.sequence
-          ).changes;
+        let deleted = 0;
+        for (const level of levels) {
+          const retainMs = levelMs[level];
+          if (retainMs === void 0) {
+            continue;
+          }
+          deleted += removeByLevel.run(this.options.targetId, level, nowMs - retainMs).changes;
         }
-        return deleted2;
+        deleted += removeFallback.run(
+          this.options.targetId,
+          nowMs - this.options.retention.rawMs,
+          ...levels
+        ).changes;
+        return deleted;
       });
-      const deleted = transaction();
-      const last = scanned[scanned.length - 1];
-      if (last === void 0 || rows.length < RETENTION_PAGE_SIZE) {
-        return { deleted, done: true };
-      }
-      cursor = {
-        occurredAtMs: last.occurredAtMs,
-        producerId: last.producerId,
-        sequence: last.sequence
-      };
-      return { deleted, done: false };
+      return { deleted: transaction(), done: true };
     };
   }
   rawEventHasRequiredRollups(envelope) {
@@ -4753,6 +4729,7 @@ var TelemetryTableMap = class _TelemetryTableMap {
       rawEventsOccurredIndex: this.indexName(mapping.rawEvents, "occurred"),
       rawEventsConversationIndex: this.indexName(mapping.rawEvents, "conversation"),
       rawEventsLabelIndex: this.indexName(mapping.rawEvents, "label"),
+      rawEventsLevelIndex: this.indexName(mapping.rawEvents, "level"),
       metricSamplesTimeIndex: this.indexName(mapping.metricSamples, "time"),
       metricSamplesEventIndex: this.indexName(mapping.metricSamples, "event"),
       metricRollupsTimeIndex: this.indexName(mapping.metricRollups, "time")
@@ -6741,6 +6718,7 @@ var SqliteTargetSchema = z3.object({
     raw: DurationSchema,
     lateArrival: DurationSchema.optional(),
     samples: DurationSchema.optional(),
+    levels: z3.record(z3.string().min(1), DurationSchema).optional(),
     rollups: z3.array(
       z3.object({
         resolution: DurationSchema,
@@ -6883,6 +6861,7 @@ var NodeTelemetryConfigurationParser = class {
       true
     );
     const samplesMs = target.retention.samples === void 0 ? rawMs + lateArrivalMs : this.durations.parse(target.retention.samples, `${field}.retention.samples`);
+    const levelMs = this.resolveLevelRetention(target.retention.levels, field);
     const rollups = target.retention.rollups.map(
       (tier, tierIndex) => Object.freeze({
         resolutionMs: this.durations.parse(
@@ -6917,6 +6896,7 @@ var NodeTelemetryConfigurationParser = class {
         rawMs,
         lateArrivalMs,
         samplesMs,
+        levelMs,
         rollups: Object.freeze(rollups)
       }),
       maintenance: Object.freeze({
@@ -6947,6 +6927,26 @@ var NodeTelemetryConfigurationParser = class {
     }
     return resolved;
   }
+  resolveLevelRetention(levels, field) {
+    if (levels === void 0) {
+      return Object.freeze({});
+    }
+    const resolved = {};
+    for (const [level, duration] of Object.entries(levels)) {
+      const normalized = level.trim().toLowerCase();
+      if (normalized.length === 0) {
+        throw new Error(`${field}.retention.levels contains an empty level name`);
+      }
+      if (resolved[normalized] !== void 0) {
+        throw new Error(`${field}.retention.levels declares "${normalized}" more than once`);
+      }
+      resolved[normalized] = this.durations.parse(
+        duration,
+        `${field}.retention.levels.${normalized}`
+      );
+    }
+    return Object.freeze(resolved);
+  }
   validateRetention(target, field) {
     const retention = target.retention;
     const requiredSamplesMs = retention.rawMs + retention.lateArrivalMs;