@zudojs/observability 1.1.0 → 1.1.1

package/dist/observability/observability.core.js

@@ -143,6 +143,35 @@ function buildResourceAttributes(config) {
         ...(config.resource ?? {}),
     };
 }
+/** Shortest interval between two repeat queue-overflow reports. */
+const DROP_REPORT_INTERVAL_MS = 60_000;
+/**
+ * Rate-limits a processor's `onDrop` callback.
+ *
+ * `onDrop` fires once per record the bounded queue refuses, on the
+ * synchronous `logger.info()` path, and the report below allocates an
+ * `Error` (so, a stack capture) and re-enters the caller's `onError` —
+ * which usually writes to the sink that is already stalled. The bounded
+ * queue is the control that makes a stalled exporter survivable; reporting
+ * every drop turned it into a second, louder failure.
+ *
+ * Handled the same way an over-cardinality metric is a few lines below: the
+ * first occurrence is reported immediately, then at most one per interval.
+ * The count handed to `report` is the processor's running total, so
+ * whoever does get notified still sees how many records were lost.
+ */
+function throttleDropReports(report) {
+    let lastReportedAt;
+    return (dropped) => {
+        const at = Date.now();
+        if (lastReportedAt !== undefined &&
+            at - lastReportedAt < DROP_REPORT_INTERVAL_MS) {
+            return;
+        }
+        lastReportedAt = at;
+        report(dropped);
+    };
+}
 function buildPipeline(config) {
     const useConsole = config.useConsoleExporters ?? true;
     /* ── Logging ─────────────────────────────────────────────────────────── */
@@ -153,7 +182,7 @@ function buildPipeline(config) {
         batchSize: config.logBatchSize,
         flushIntervalMs: config.logFlushIntervalMs,
         onError: config.onError,
-        onDrop: (dropped) => config.onError?.(new Error(`Dropped ${dropped} log records: queue full`), "BatchLogProcessor"),
+        onDrop: throttleDropReports((dropped) => config.onError?.(new Error(`Dropped ${dropped} log records: queue full`), "BatchLogProcessor")),
     });
     // Redaction is applied by the logger, so every transport and exporter
     // downstream sees redacted records — configuring it and not wiring it here
@@ -179,7 +208,7 @@ function buildPipeline(config) {
         new BatchSpanProcessor({
             exporter: ownSpanExporter(),
             onError: config.onError,
-            onDrop: (dropped) => config.onError?.(new Error(`Dropped ${dropped} spans: queue full`), "BatchSpanProcessor"),
+            onDrop: throttleDropReports((dropped) => config.onError?.(new Error(`Dropped ${dropped} spans: queue full`), "BatchSpanProcessor")),
         }),
     ];
     // When the caller supplied their own processors, they own the exporter's

package/dist/tracing/span/span.core.js

@@ -6,6 +6,23 @@
  */
 import { SpanKind, SpanStatus } from "../../types.js";
 import { createSpanContext, createChildSpanContext, } from "./spanContext.type.js";
+/**
+ * Stores one attribute on a bag whose keys come from instrumentation.
+ *
+ * `bag[key] = value` invokes the inherited `__proto__` setter for that one
+ * key: the attribute never lands, and an object value replaces the bag's
+ * prototype. A poisoned prototype then defeats `maxAttributes`, because the
+ * cap is only applied to keys the bag does not already answer for. Matches
+ * the same guard in `redaction.core.ts`.
+ */
+function defineAttribute(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true,
+    });
+}
 /** Defaults matching the OpenTelemetry specification. */
 const DEFAULT_LIMITS = {
     maxAttributes: 128,
@@ -81,12 +98,12 @@ export class DefaultSpan {
     setAttribute(key, value) {
         if (this.ended || !this.recording)
             return;
-        if (!(key in this.attributes) &&
+        if (!Object.prototype.hasOwnProperty.call(this.attributes, key) &&
             Object.keys(this.attributes).length >= this.limits.maxAttributes) {
             this.droppedAttributes++;
             return;
         }
-        this.attributes[key] = this.sanitize(key, value);
+        defineAttribute(this.attributes, key, this.sanitize(key, value));
     }
     addEvent(name, attributes) {
         if (this.ended || !this.recording)
@@ -104,7 +121,7 @@ export class DefaultSpan {
                     this.droppedAttributes++;
                     continue;
                 }
-                eventAttributes[key] = this.sanitize(key, value);
+                defineAttribute(eventAttributes, key, this.sanitize(key, value));
                 kept++;
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/observability",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Structured logging, metrics, tracing, context propagation, and exporters for Zudojs applications.",
   "license": "MIT",
   "author": {
@@ -26,7 +26,7 @@
     "!dist/.tsbuildinfo"
   ],
   "dependencies": {
-    "@zudojs/errors": "1.1.0"
+    "@zudojs/errors": "1.2.0"
   },
   "devDependencies": {
     "typescript": "7.0.2",