@mastra/observability 1.13.0-alpha.0 → 1.13.0-alpha.1

package/dist/index.js

@@ -16012,7 +16012,10 @@ var DefaultExporter = class extends BaseExporter {
         deferredUpdates.length = 0;
         this.emitDrop("tracing", "unsupported-storage", events.length + deferredCountAtEntry, error48);
       } else {
-        deferredUpdates.length = 0;
+        const newlyDeferred = deferredUpdates.length - deferredCountAtEntry;
+        if (newlyDeferred > 0) {
+          deferredUpdates.splice(deferredUpdates.length - newlyDeferred, newlyDeferred);
+        }
         const dropped = this.#eventBuffer.reAddUpdates(events);
         this.emitDrop("tracing", "retry-exhausted", dropped.length, error48);
       }
@@ -16711,6 +16714,7 @@ var MastraStorageExporter = class extends BaseExporter {
   #observabilityStorage;
   #resolvedStrategy;
   #flushTimer;
+  #emitDropEvent;
   // Signals whose storage methods threw "not implemented" — skip on future flushes
   #unsupportedSignals = /* @__PURE__ */ new Set();
   constructor(config2 = {}) {
@@ -16732,6 +16736,7 @@ var MastraStorageExporter = class extends BaseExporter {
   async init(options) {
     try {
       this.#isInitializing = true;
+      this.#emitDropEvent = options.emitDropEvent;
       this.#storage = options.mastra?.getStorage();
       if (!this.#storage) {
         this.logger.warn("MastraStorageExporter disabled: Storage not available. Traces will not be persisted.");
@@ -16817,21 +16822,54 @@ var MastraStorageExporter = class extends BaseExporter {
       this.scheduleFlush();
     }
   }
+  sanitizeDropError(error48) {
+    if (error48 instanceof MastraError) {
+      return {
+        id: error48.id,
+        domain: String(error48.domain),
+        message: error48.message
+      };
+    }
+    if (error48 instanceof Error) {
+      return { message: error48.message };
+    }
+    return { message: String(error48) };
+  }
+  emitDrop(signal, reason, count, error48) {
+    if (count === 0) return;
+    const dropEvent = {
+      type: "drop",
+      signal,
+      reason,
+      count,
+      timestamp: /* @__PURE__ */ new Date(),
+      exporterName: this.name,
+      ...this.#observabilityStorage ? { storageName: this.#observabilityStorage.constructor.name } : {},
+      ...error48 === void 0 ? {} : { error: this.sanitizeDropError(error48) }
+    };
+    this.#emitDropEvent?.(dropEvent);
+  }
   /**
    * Flush a batch of create events for a single signal type.
    * On "not implemented" errors, disables the signal for future flushes.
    * On other errors, re-adds events to the buffer for retry.
    */
   async flushCreates(signal, events, storageCall) {
-    if (this.#unsupportedSignals.has(signal) || events.length === 0) return;
+    if (events.length === 0) return;
+    if (this.#unsupportedSignals.has(signal)) {
+      this.emitDrop(signal, "unsupported-storage", events.length);
+      return;
+    }
     try {
       await storageCall(events);
     } catch (error48) {
       if (error48 instanceof MastraError && error48.domain === ErrorDomain.MASTRA_OBSERVABILITY && error48.id.endsWith("_NOT_IMPLEMENTED")) {
         this.logger.warn(error48.message);
         this.#unsupportedSignals.add(signal);
+        this.emitDrop(signal, "unsupported-storage", events.length, error48);
       } else {
-        this.#eventBuffer.reAddCreates(events);
+        const dropped = this.#eventBuffer.reAddCreates(events);
+        this.emitDrop(signal, "retry-exhausted", dropped.length, error48);
       }
     }
   }
@@ -16840,7 +16878,12 @@ var MastraStorageExporter = class extends BaseExporter {
    * When `isEnd` is true, successfully flushed spans are removed from tracking.
    */
   async flushSpanUpdates(events, deferredUpdates, isEnd) {
-    if (this.#unsupportedSignals.has("tracing") || events.length === 0) return;
+    const deferredCountAtEntry = deferredUpdates.length;
+    if (events.length === 0) return;
+    if (this.#unsupportedSignals.has("tracing")) {
+      this.emitDrop("tracing", "unsupported-storage", events.length);
+      return;
+    }
     const partials = [];
     for (const event of events) {
       const span = event.exportedSpan;
@@ -16864,9 +16907,15 @@ var MastraStorageExporter = class extends BaseExporter {
       if (error48 instanceof MastraError && error48.domain === ErrorDomain.MASTRA_OBSERVABILITY && error48.id.endsWith("_NOT_IMPLEMENTED")) {
         this.logger.warn(error48.message);
         this.#unsupportedSignals.add("tracing");
-      } else {
         deferredUpdates.length = 0;
-        this.#eventBuffer.reAddUpdates(events);
+        this.emitDrop("tracing", "unsupported-storage", events.length + deferredCountAtEntry, error48);
+      } else {
+        const newlyDeferred = deferredUpdates.length - deferredCountAtEntry;
+        if (newlyDeferred > 0) {
+          deferredUpdates.splice(deferredUpdates.length - newlyDeferred, newlyDeferred);
+        }
+        const dropped = this.#eventBuffer.reAddUpdates(events);
+        this.emitDrop("tracing", "retry-exhausted", dropped.length, error48);
       }
     }
   }
@@ -16942,17 +16991,17 @@ var MastraStorageExporter = class extends BaseExporter {
         (events) => this.#observabilityStorage.batchCreateFeedback({ feedbacks: events.map((f) => buildFeedbackRecord(f)) })
       ),
       this.flushCreates(
-        "logs",
+        "log",
         createLogEvents,
         (events) => this.#observabilityStorage.batchCreateLogs({ logs: events.map((l) => buildLogRecord(l)) })
       ),
       this.flushCreates(
-        "metrics",
+        "metric",
         createMetricEvents,
         (events) => this.#observabilityStorage.batchCreateMetrics({ metrics: events.map((m) => buildMetricRecord(m)) })
       ),
       this.flushCreates(
-        "scores",
+        "score",
         createScoreEvents,
         (events) => this.#observabilityStorage.batchCreateScores({ scores: events.map((s) => buildScoreRecord(s)) })
       ),
@@ -16966,7 +17015,13 @@ var MastraStorageExporter = class extends BaseExporter {
     await this.flushSpanUpdates(updateSpanEvents, deferredUpdates, false);
     await this.flushSpanUpdates(endSpanEvents, deferredUpdates, true);
     if (deferredUpdates.length > 0) {
-      this.#eventBuffer.reAddUpdates(deferredUpdates);
+      if (this.#unsupportedSignals.has("tracing")) {
+        this.emitDrop("tracing", "unsupported-storage", deferredUpdates.length);
+        deferredUpdates.length = 0;
+      } else {
+        const dropped = this.#eventBuffer.reAddUpdates(deferredUpdates);
+        this.emitDrop("tracing", "retry-exhausted", dropped.length);
+      }
     }
     const elapsed = Date.now() - startTime;
     this.logger.debug("Batch flushed", {