@adaptic/utils 0.0.1007 → 0.0.1009

package/dist/test.js

@@ -1629,6 +1629,80 @@ function isTransientNetworkError(error) {
     }
     return false;
 }
+/**
+ * Error names that indicate the CLIENT's own request deadline expired (an
+ * `AbortSignal` timeout or an undici per-phase timeout) rather than a
+ * connection-phase fault. These faults have already consumed a full request
+ * timeout, so retrying them is expensive by construction.
+ */
+const DEADLINE_EXPIRY_ERROR_NAMES = new Set([
+    "AbortError",
+    "TimeoutError",
+    "RequestTimeoutError",
+    "ConnectTimeoutError",
+    "HeadersTimeoutError",
+    "BodyTimeoutError",
+]);
+/**
+ * Error codes that indicate an expired request/phase deadline (vs a fast
+ * connection-phase fault such as `ECONNRESET`/`ECONNREFUSED`).
+ */
+const DEADLINE_EXPIRY_ERROR_CODES = new Set([
+    "ETIMEDOUT",
+    "ESOCKETTIMEDOUT",
+    "ECONNABORTED",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+]);
+/** Message-pattern fallback for deadline-expiry errors that lost name/code. */
+const DEADLINE_EXPIRY_MESSAGE_PATTERNS = [
+    /timed out/i,
+    /timeout/i,
+    /aborted/i,
+];
+/**
+ * Whether an error represents the client's OWN deadline expiring (abort /
+ * timeout) rather than a connection-phase network fault. Both classes are
+ * "transient" per {@link isTransientNetworkError}, but they have very
+ * different retry economics: a connection fault (`ECONNRESET`, `EPIPE`,
+ * refused socket) settles in milliseconds and is cheap to retry, while a
+ * deadline expiry has already consumed the full per-attempt timeout — blindly
+ * retrying it multiplies time-to-failure exactly when the caller most needs
+ * to fail fast. Walks the `error.cause` chain like the transient classifier.
+ *
+ * @param error - The error to classify.
+ * @returns true when the fault is a client deadline/abort expiry.
+ */
+function isClientDeadlineExpiry(error) {
+    const MAX_CAUSE_DEPTH = 6;
+    let current = error;
+    for (let depth = 0; depth < MAX_CAUSE_DEPTH && current; depth++) {
+        if (current instanceof Error || typeof current === "object") {
+            const err = current;
+            if (typeof err.name === "string" &&
+                DEADLINE_EXPIRY_ERROR_NAMES.has(err.name)) {
+                return true;
+            }
+            if (typeof err.code === "string" &&
+                DEADLINE_EXPIRY_ERROR_CODES.has(err.code)) {
+                return true;
+            }
+            if (typeof err.message === "string") {
+                for (const pattern of DEADLINE_EXPIRY_MESSAGE_PATTERNS) {
+                    if (pattern.test(err.message)) {
+                        return true;
+                    }
+                }
+            }
+            current = err.cause;
+        }
+        else {
+            break;
+        }
+    }
+    return false;
+}
 
 /**
  * Structured error type hierarchy for all API integrations
@@ -1771,8 +1845,11 @@ class TokenBucketRateLimiter {
     async acquire() {
         const logger = getLogger();
         this.refill();
-        if (this.tokens > 0) {
-            this.tokens--;
+        // Require a WHOLE token: refill() accrues fractionally, and admitting on
+        // any positive fraction would release a full request per accrual tick,
+        // driving the bucket negative and overrunning the configured rate.
+        if (this.tokens >= TOKENS_PER_REQUEST) {
+            this.tokens -= TOKENS_PER_REQUEST;
             logger.debug(`Rate limit token acquired for ${this.config.label}`, {
                 remainingTokens: this.tokens,
                 queueLength: this.queue.length,
@@ -1868,8 +1945,9 @@ class TokenBucketRateLimiter {
         this.processingQueue = true;
         const logger = getLogger();
         try {
-            while (this.queue.length > 0 && this.tokens > 0) {
-                this.tokens--;
+            // Whole-token admission — see the matching guard in acquire().
+            while (this.queue.length > 0 && this.tokens >= TOKENS_PER_REQUEST) {
+                this.tokens -= TOKENS_PER_REQUEST;
                 const next = this.queue.shift();
                 if (next) {
                     clearTimeout(next.timeoutHandle);
@@ -2031,6 +2109,23 @@ function transientRetryDelayMs(attempt) {
     const ceiling = TRANSIENT_NETWORK_RETRY_BASE_MS * 2 ** attempt;
     return Math.floor(Math.random() * ceiling);
 }
+/**
+ * Total-deadline multiple over the per-attempt client timeout for one
+ * {@link AlpacaMarketDataAPI.makeRequest} call INCLUDING transient retries.
+ * The ECONNRESET class this loop targets settles in milliseconds, so the
+ * retries fit comfortably inside 1.5x the single-attempt timeout — while a
+ * request whose attempts each consume the full client timeout is refused
+ * further retries instead of stretching a hot-path read to a multi-minute
+ * stall (worst case before this budget: 3 x (60s limiter wait + 30s fetch)).
+ */
+const TRANSIENT_RETRY_BUDGET_TIMEOUT_MULTIPLE = 1.5;
+/**
+ * Maximum retries for a fault classified as the client's OWN deadline expiry
+ * (see {@link isClientDeadlineExpiry}): such a fault already consumed a full
+ * per-attempt timeout, so it is retried at most once — and then only if the
+ * total budget still allows a further full-length attempt.
+ */
+const CLIENT_DEADLINE_EXPIRY_MAX_RETRIES = 1;
 const log$1 = (message, options = { type: "info" }) => {
     log$2(message, { ...options, source: "AlpacaMarketDataAPI" });
 };
@@ -2544,7 +2639,15 @@ class AlpacaMarketDataAPI extends EventEmitter {
             // Retry ONLY transient connection faults, and only on GET (every
             // market-data read here is idempotent). A non-2xx response is a real
             // answer from Alpaca and is never retried — that path still throws on
-            // the first attempt exactly as before.
+            // the first attempt exactly as before. The whole loop is bounded by a
+            // cumulative deadline so retries can never stretch a hot-path read far
+            // beyond a single attempt's timeout: connection-phase faults
+            // (ECONNRESET class, millisecond-scale) retry cheaply, while a fault
+            // that consumed the full client timeout retries at most once and only
+            // when the remaining budget still fits a full-length attempt.
+            const retryLoopStartedAt = Date.now();
+            const totalBudgetMs = Math.round(DEFAULT_TIMEOUTS.ALPACA_API * TRANSIENT_RETRY_BUDGET_TIMEOUT_MULTIPLE);
+            let deadlineExpiryRetries = 0;
             let response;
             let lastNetworkError;
             for (let attempt = 0; attempt < TRANSIENT_NETWORK_RETRY_ATTEMPTS; attempt += 1) {
@@ -2558,12 +2661,21 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 }
                 catch (networkErr) {
                     lastNetworkError = networkErr;
+                    const deadlineExpiry = isClientDeadlineExpiry(networkErr);
+                    const nextAttemptFitsBudget = Date.now() - retryLoopStartedAt + DEFAULT_TIMEOUTS.ALPACA_API <=
+                        totalBudgetMs;
                     const retryable = method === "GET" &&
                         isTransientNetworkError(networkErr) &&
-                        attempt < TRANSIENT_NETWORK_RETRY_ATTEMPTS - 1;
+                        attempt < TRANSIENT_NETWORK_RETRY_ATTEMPTS - 1 &&
+                        nextAttemptFitsBudget &&
+                        (!deadlineExpiry ||
+                            deadlineExpiryRetries < CLIENT_DEADLINE_EXPIRY_MAX_RETRIES);
                     if (!retryable) {
                         throw networkErr;
                     }
+                    if (deadlineExpiry) {
+                        deadlineExpiryRetries += 1;
+                    }
                     const delayMs = transientRetryDelayMs(attempt);
                     log$1(`Transient network fault on ${endpoint} (attempt ${attempt + 1}/${TRANSIENT_NETWORK_RETRY_ATTEMPTS}); retrying in ${delayMs}ms`, { type: "warn" });
                     await new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -2584,8 +2696,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 });
                 throw new Error(`Market Data API error (${response.status}): ${errorText}`);
             }
-            const data = await response.json();
-            return data;
+            return (await response.json());
         }
         catch (err) {
             const error = err;
@@ -3272,7 +3383,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
                 });
                 throw new Error(`Alpaca news API error (${response.status}): ${errorText}`);
             }
-            const data = await response.json();
+            const data = (await response.json());
             if (!data.news || !Array.isArray(data.news)) {
                 log$1(`No news data found in Alpaca response for ${symbol}`, {
                     type: "warn",