@hue-run/sdk 0.21.1 → 0.23.0

package/dist/transport.js

@@ -1,5 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { gzip } from "node:zlib";
+import { waitUntil } from "@vercel/functions";
 import { ExportResultCode } from "@opentelemetry/core";
 import { createOtlpNetworkExportDelegate, OTLPExporterBase, OTLPExporterError, } from "@opentelemetry/otlp-exporter-base";
 import { createOtlpHttpExporterMetrics } from "@opentelemetry/otlp-exporter-base/node-http";
@@ -182,6 +183,10 @@ export class HueTransport {
     failed = { traces: 0, logs: 0 };
     spans = new Map();
     logs = new Map();
+    // A cohort closes when export starts, so later requests cannot extend its lifetime.
+    deliveryCohort;
+    deliveries = new WeakMap();
+    deliveryUploads = new WeakMap();
     pendingBytes = 0;
     dropped = { traces: 0, logs: 0 };
     /** Records of each trace the SDK never sent (dropped from the queue, refused as invalid or
@@ -214,6 +219,8 @@ export class HueTransport {
     placeholders = new WeakMap();
     // The running span each admitted placeholder announces, so one it has outlived is not sent.
     placeholderSources = new WeakMap();
+    forcedSpanDrains = 0;
+    completedSpanDrains = 0;
     batchSpans;
     // What the receiver accepts, as it last advertised; the limits of this release until it does.
     limits = DEFAULT_RECEIVER_LIMITS;
@@ -340,6 +347,7 @@ export class HueTransport {
                     this.protectMedia(admitted);
                     this.countEnded(admitted);
                     spans.onEnd(admitted);
+                    this.protectDelivery(admitted);
                 }
                 catch {
                     if (admitted)
@@ -352,12 +360,18 @@ export class HueTransport {
             // The spans are sent first, then the uploads queued so far are waited for, unless a
             // flush sends them: that flush waits for the uploads after its send.
             forceFlush: async () => {
+                const finish = this.beginSpanDrain();
                 try {
                     await spans.forceFlush();
                 }
                 finally {
-                    if (!this.sendingRecords.getStore())
-                        await this.drainUploads();
+                    try {
+                        if (!this.sendingRecords.getStore())
+                            await this.drainUploads();
+                    }
+                    finally {
+                        finish();
+                    }
                 }
             },
             shutdown: async () => {
@@ -391,6 +405,7 @@ export class HueTransport {
                     admitted = queued;
                     this.admitLogParts(log, queued);
                     logs.onEmit(queued);
+                    this.protectDelivery(admitted);
                 }
                 catch {
                     if (admitted)
@@ -399,12 +414,18 @@ export class HueTransport {
                 }
             },
             forceFlush: async () => {
+                const finish = this.beginSpanDrain();
                 try {
                     await logs.forceFlush();
                 }
                 finally {
-                    if (!this.sendingRecords.getStore())
-                        await this.drainUploads();
+                    try {
+                        if (!this.sendingRecords.getStore())
+                            await this.drainUploads();
+                    }
+                    finally {
+                        finish();
+                    }
                 }
             },
             shutdown: async () => {
@@ -472,6 +493,14 @@ export class HueTransport {
                 this.logs.set(snapshot.record, snapshot.bytes);
             if (snapshot.unresolvedResource && !advisory)
                 this.issue(signal, "warning", 0, "Unresolved resource attributes omitted from the telemetry snapshot");
+            if (!advisory) {
+                const cohort = (this.deliveryCohort ??= {
+                    pending: 0,
+                    ...Promise.withResolvers(),
+                });
+                cohort.pending++;
+                this.deliveries.set(snapshot.record, cohort);
+            }
             return snapshot.record;
         }
         catch {
@@ -481,11 +510,42 @@ export class HueTransport {
             return undefined;
         }
     }
+    /** Register in the caller's request before it can return; outside Vercel this is a no-op. */
+    protectDelivery(record) {
+        const cohort = this.deliveries.get(record);
+        if (!cohort)
+            return;
+        try {
+            waitUntil(cohort.promise);
+        }
+        catch {
+            // A host hook must never undo admission or change the application's result.
+        }
+    }
+    /** @internal Seal the batch's cohort before export can yield to another request. */
+    exporting(records) {
+        if (records.some((record) => this.deliveries.get(record) === this.deliveryCohort))
+            this.deliveryCohort = undefined;
+    }
+    holdDelivery(cohort, work) {
+        if (!cohort)
+            return;
+        cohort.pending++;
+        const finish = () => this.finishDelivery(cohort);
+        void work.then(finish, finish);
+    }
+    finishDelivery(cohort) {
+        if (--cohort.pending !== 0)
+            return;
+        if (this.deliveryCohort === cohort)
+            this.deliveryCohort = undefined;
+        cohort.resolve();
+    }
     track(span) {
         try {
             if (!this.liveSpans || this.live.size >= MAX_LIVE_SPANS)
                 return;
-            if (!(span.spanContext().traceFlags & 1) || !span.isRecording() || !announcesLiveSpan(span))
+            if (!(span.spanContext().traceFlags & 1) || span.ended || !announcesLiveSpan(span))
                 return;
             this.live.add(span);
             if (!this.liveTimer) {
@@ -500,6 +560,8 @@ export class HueTransport {
     }
     /** Placeholders are built lazily, so input set right after a span starts is included. */
     announceLiveSpans() {
+        if (this.forcedSpanDrains)
+            return;
         for (const span of this.live) {
             this.live.delete(span);
             try {
@@ -547,6 +609,28 @@ export class HueTransport {
     placeholderSettled(record) {
         return this.placeholderSources.get(record)?.ended === true;
     }
+    beginSpanDrain() {
+        const completed = [...this.spans.keys()].some((span) => !this.placeholders.has(span));
+        this.forcedSpanDrains++;
+        if (completed)
+            this.completedSpanDrains++;
+        return () => {
+            this.forcedSpanDrains--;
+            if (completed)
+                this.completedSpanDrains--;
+        };
+    }
+    /** @internal A forced drain sends completed spans without another advisory round trip. */
+    deferPlaceholders(records) {
+        if (!this.completedSpanDrains)
+            return false;
+        for (const record of records) {
+            const source = this.placeholderSources.get(record);
+            if (!this.closed && source)
+                this.track(source);
+        }
+        return true;
+    }
     /** @internal Exporter callback: false once the receiver refused placeholders; queued ones are then dropped. */
     sendsPlaceholders() {
         return !this.placeholdersRejected;
@@ -570,6 +654,11 @@ export class HueTransport {
     /** @internal Exporter callback: releases queued records after an export attempt settles. */
     finish(signal, records) {
         for (const record of records) {
+            const cohort = this.deliveries.get(record);
+            if (cohort) {
+                this.deliveries.delete(record);
+                this.finishDelivery(cohort);
+            }
             this.releaseMedia(record);
             this.logMedia.delete(record);
             const pending = signal === "traces" ? this.spans : this.logs;
@@ -737,6 +826,7 @@ export class HueTransport {
      * them. */
     uploadQueued(record, settled, shared, released) {
         this.awaitUploads(settled);
+        this.holdDelivery(this.deliveries.get(record), settled);
         const identity = this.mediaIdentity(record);
         const staged = identity
             ? (this.media.get(identity) ?? []).reduce((total, file) => total + heldBytesOf(file.bytes), 0)
@@ -853,8 +943,8 @@ export class HueTransport {
         return this.offloadsValues() && this.uploader?.available() === true;
     }
     /** @internal Exporter callback: a redacted span with the values its redaction left to the
-     * upload step placed: listed under `hue.blobs` with their uploads queued (each added to `late`
-     * once it settles, and charged in place of the `queued` record it came from), or cut as before.
+     * upload step placed: listed under `hue.blobs` with their uploads queued (reported once settled,
+     * and charged in place of the `queued` record they came from), or cut as before.
      * Never rejects. */
     async offloadSpan(span, collector, upload, tally, late, queued) {
         // A record without a readable context cannot name its trace: its values are cut.
@@ -878,8 +968,7 @@ export class HueTransport {
                 memo: this.mediaMemo,
                 background: own,
             });
-            if (own.settled.length)
-                late.settled.push(mergeWhenSettled(late.tally, own.tally, own.settled));
+            this.collectDeliveryUploads(queued, own, late);
             return { ...span, attributes: attributes };
         }
         catch {
@@ -919,14 +1008,37 @@ export class HueTransport {
                 memo: this.mediaMemo,
                 background: own,
             });
-            if (own.settled.length)
-                late.settled.push(mergeWhenSettled(late.tally, own.tally, own.settled));
+            this.collectDeliveryUploads(queued, own, late);
             return placed(result);
         }
         catch {
             return placed(fallbackRecord(log.attributes, collector, valueBytes, tally, traceId, this.mediaMemo));
         }
     }
+    /** Keep an export's warning aggregation within each cohort's upload ownership. */
+    collectDeliveryUploads(record, uploads, late) {
+        const { settled, tally } = uploads;
+        if (!settled.length)
+            return;
+        let groups = this.deliveryUploads.get(late);
+        if (!groups)
+            this.deliveryUploads.set(late, (groups = new Map()));
+        const cohort = this.deliveries.get(record);
+        let group = groups.get(cohort);
+        if (!group)
+            groups.set(cohort, (group = { tally: newTally(), settled: [] }));
+        group.settled.push(mergeWhenSettled(group.tally, tally, settled));
+    }
+    /** @internal Report only the uploads each cohort owns, without retaining their records. */
+    reportUploads(late, signal) {
+        const groups = this.deliveryUploads.get(late);
+        this.deliveryUploads.delete(late);
+        for (const [cohort, { settled, tally }] of groups ?? []) {
+            const report = Promise.all(settled).then(() => this.reportOffload(tally, signal, true));
+            this.awaitUploads(report);
+            this.holdDelivery(cohort, report);
+        }
+    }
     /** @internal Exporter callback: counts an export's uploads and reports each kind of fallback
      * once, as a warning naming its traces: the values were exported cut as before, or, `late`,
      * their uploads failed after their records listed them. */
@@ -1147,13 +1259,19 @@ export class HueTransport {
      */
     flushRecords(providers) {
         const from = this.observedSequence;
-        const join = () => this.sendRecords();
+        let finish;
+        const join = () => {
+            finish = this.beginSpanDrain();
+            return this.sendRecords();
+        };
         const sent = providers ? this.sendingRecords.run(true, providers).then(join, join) : join();
-        const report = sent.then(async (processors) => {
+        const report = sent
+            .then(async (processors) => {
             // Exports the processors did not start (a timer's, still in flight) queued uploads too.
             await this.drainUploads();
             return this.flushReport(from, processors);
-        });
+        })
+            .finally(() => finish?.());
         return { sent, report };
     }
     /** Sends what the processors and exporters hold, once the previous flush's send ended. */
@@ -1387,6 +1505,7 @@ class ReportingExporter {
         this.redact = redact;
     }
     export(records, callback) {
+        this.transport.exporting(records);
         const work = this.exportRecords(records)
             .then(() => callback({ code: ExportResultCode.SUCCESS }), () => callback({
             code: ExportResultCode.FAILED,
@@ -1423,23 +1542,16 @@ class ReportingExporter {
                 real.push(placeholder);
         return real;
     }
-    /** Places and sends the records; the uploads their placement queued are reported once they
-     * settle, after the records were sent, never awaited here. */
+    /** Queue final upload reports before releasing the records that own their cohorts. */
     async exportRecords(records) {
         const late = { tally: newTally(), settled: [] };
         try {
             await this.placeAndSend(records, late);
         }
         finally {
-            if (late.settled.length)
-                this.reportWhenSettled(late);
+            this.transport.reportUploads(late, this.signal);
         }
     }
-    /** Reports an export's uploads once they all settle. Built apart from the export, so a pending
-     * upload never keeps the export's records alive. */
-    reportWhenSettled(late) {
-        this.transport.awaitUploads(Promise.all(late.settled).then(() => this.transport.reportOffload(late.tally, this.signal, true)));
-    }
     async placeAndSend(records, late) {
         // Completed records and placeholders travel in separate requests, completed records first,
         // so a rejection count is always one kind of record's. Placeholders are advisory: losing one
@@ -1850,7 +1962,10 @@ class ReportingExporter {
         // records' acknowledgements may have just shown, nor after this export's completed records were
         // refused or unanswered: a receiver that just refused or timed out gets no second request with
         // its own retries. A record this side could not send keeps the placeholders going out.
-        if (pending.length && !refused && this.transport.sendsPlaceholders())
+        if (pending.length &&
+            !refused &&
+            this.transport.sendsPlaceholders() &&
+            !this.transport.deferPlaceholders(records))
             await pack(pending, true);
         if (failed)
             throw new Error("Hue telemetry export failed");

package/dist/version.d.ts

@@ -1,4 +1,4 @@
 /** Package version shared by the instrumentation scope and the export User-Agent. */
-export declare const sdkVersion = "0.21.1";
+export declare const sdkVersion = "0.23.0";
 /** OTLP dependency version sent in the export User-Agent. */
 export declare const otlpExporterVersion = "0.223.0";

package/dist/version.js

@@ -1,5 +1,5 @@
 // Generated by scripts/write-version.mjs from package.json; do not edit by hand.
 /** Package version shared by the instrumentation scope and the export User-Agent. */
-export const sdkVersion = "0.21.1";
+export const sdkVersion = "0.23.0";
 /** OTLP dependency version sent in the export User-Agent. */
 export const otlpExporterVersion = "0.223.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hue-run/sdk",
-  "version": "0.21.1",
+  "version": "0.23.0",
   "private": false,
   "license": "MIT",
   "publishConfig": {
@@ -98,6 +98,7 @@
     "@opentelemetry/resources": "2.12.0",
     "@opentelemetry/sdk-logs": "0.223.0",
     "@opentelemetry/sdk-trace": "2.12.0",
+    "@vercel/functions": "3.9.7",
     "zod": "^3.25.76 || ^4.6.5"
   },
   "devDependencies": {