@hue-run/sdk 0.18.1 → 0.19.0

package/dist/transport.d.ts

@@ -11,9 +11,11 @@ export type RecordValue = ReadableSpan | ReadableLogRecord;
  * them, reported like any refused request.
  */
 export declare const MAX_RATE_LIMIT_HOLD_MILLIS = 60000;
-/** How long one export may take with requests of `timeoutMillis` each: its uploads of values over
+/** How long one export may take with requests of `timeoutMillis` each: hashing its values over
  * the inline limit, its requests, and a hold for a rate-limited receiver on top. Processors and
- * providers wait this long for a drain. */
+ * providers wait this long for a drain. A drain also waits for the uploads its exports queued,
+ * which run beside the requests and end within six timeouts and a minute of being queued, so they
+ * fit within the same budget. */
 export declare function exportBudgetMillis(timeoutMillis: number): number;
 /**
  * Rejection of {@link HueClient.flush} and {@link HueClient.shutdown}: telemetry was not fully
@@ -67,7 +69,11 @@ export declare class HueTransport {
     private logExporter;
     private closed;
     private shutdownPromise?;
-    private flushPromise?;
+    /** The latest flush's send of its records; the next flush's send starts after it. */
+    private sendPromise?;
+    /** Set while a flush sends its records: the processors leave the uploads to that flush, which
+     * waits for them after its send, so no flush's send waits behind another's uploads. */
+    private sendingRecords;
     private live;
     private liveTimer?;
     private liveSpans;
@@ -83,11 +89,16 @@ export declare class HueTransport {
     private admissionCuts;
     private admissionDigests;
     private admissionInspected;
+    private admissionLarge;
     /** Uploads values over the inline limit apart from their spans; absent when disabled. */
     private uploader?;
     /** Bytes of values over the inline limit queued spans hold whole for upload, and each span's. */
     private heldBytes;
     private held;
+    /** Bytes of each record's charge (its own held values and its staged files) that its queued
+     * uploads took over before the record was finished: charged to the uploads alone until they
+     * settle or the record is finished. */
+    private heldByUploads;
     private mediaMemo;
     private media;
     private logParts;
@@ -97,6 +108,11 @@ export declare class HueTransport {
     private mediaFinalizer;
     private uploaded;
     private uploadFallbacks;
+    /** Each export's queued uploads, until they all settle and are reported. */
+    private uploadReports;
+    /** Settles once every upload report registered so far has: each drain awaits this one promise,
+     * so a drain costs the same however many uploads are pending. */
+    private uploadsSettled;
     constructor(options: HueOptions);
     /**
      * Advisory records (placeholders) are admitted only while the queue is under a quarter of its
@@ -112,6 +128,15 @@ export declare class HueTransport {
     /** Holds the staged attachments of a log record being admitted with the queued record, within
      * the held-value budget; those the budget refuses are counted as not uploaded. */
     private admitLogParts;
+    /** What the held-value budget has room for: values queued records hold and bytes unsettled
+     * uploads hold share it. */
+    private heldRoom;
+    /** An upload `record`'s export queued, as it is queued: flushes and the processors wait for it
+     * from now on, and the `shared` bytes it holds of the record's own are charged to the upload
+     * alone, so the held-value budget never counts them twice while the export goes on. A charge
+     * `released` before the record is finished is handed back to the record, which still holds
+     * them. */
+    private uploadQueued;
     /** Registers a span whose staged files are released if it is never exported. */
     private ownMedia;
     private mediaIdentity;
@@ -135,15 +160,22 @@ export declare class HueTransport {
     private endedSpans;
     private countEnded;
     /**
-     * Waits for the processors' and exporters' in-flight work; drain the providers first.
+     * Waits for the processors' and exporters' in-flight work, then for the uploads their exports
+     * queued; drain the providers first. Only the sends are serialized: a flush sends its records
+     * once an earlier flush sent its own, never after that flush's uploads.
      *
      * @throws HueExportError when a new non-warning issue was recorded since the previous observation.
      */
     flush(): Promise<ExportReport>;
-    private flushOnce;
+    /** Sends what the processors and exporters hold, once the previous flush's send ended. */
+    private sendRecords;
+    /** Waits for the uploads queued so far; each ends within its lifetime, so this is bounded. */
+    private drainUploads;
+    private flushReport;
     /**
-     * Flushes and stops the processors; records emitted afterwards are dropped and counted. In attach
-     * mode call it after shutting down the application's providers.
+     * Flushes and stops the processors, waits for queued uploads, then ends the uploader; records
+     * emitted afterwards are dropped and counted. In attach mode call it after shutting down the
+     * application's providers.
      *
      * @throws HueExportError when the final flush observed new failures.
      */