@friggframework/core 2.0.0--canary.658.93c8e07.0 → 2.0.0--canary.658.164d92b.0

package/integrations/use-cases/record-rate-limit-message.js

@@ -1,7 +1,19 @@
-const RATE_LIMITED = 'RATE_LIMITED';
+const { getLogger } = require('../../logs');
+const { MAX_MESSAGES_PER_TYPE } = require('./update-integration-messages');
+
+const log = getLogger('frigg.integrations');
+
+const RATE_LIMITED_MESSAGE_CODE = 'RATE_LIMITED';
 const SAME_LIMIT_WINDOW_MS = 60_000;
 const MINUTE_MS = 60_000;
 
+const isNonEmptyString = (value) => typeof value === 'string' && value !== '';
+
+const isValidTime = (value) =>
+    value !== null &&
+    value !== undefined &&
+    !Number.isNaN(new Date(value).getTime());
+
 const isLink = (link) =>
     typeof link?.label === 'string' && typeof link?.url === 'string';
 
@@ -10,16 +22,12 @@ const linkActions = (links) =>
         .filter(isLink)
         .map(({ label, url }) => ({ type: 'LINK', label, url }));
 
-function utcMinuteAfter(date) {
+function formatResetTime(date) {
     const minute = new Date(Math.ceil(date.getTime() / MINUTE_MS) * MINUTE_MS);
     return `${minute.toISOString().slice(0, 16).replace('T', ' ')} UTC`;
 }
 
 /**
- * Use case that records one user-facing warning when a module reports a rate
- * limit that is too long to wait for. The text is fixed and the payload's
- * message, url, body and headers are never read, because the message reaches
- * end users. It changes no integration status: a rate limit is not an error.
  * @class RecordRateLimitMessage
  */
 class RecordRateLimitMessage {
@@ -32,10 +40,6 @@ class RecordRateLimitMessage {
     }
 
     /**
-     * Writes the warning, unless the stored warnings already hold one for the
-     * same module whose reset time is within a minute of this one. Many workers
-     * hit one limit together and each reports it, so the check reads the
-     * stored warnings and not the messages of this instance.
      * @async
      * @param {string} integrationId - ID of the integration to warn on.
      * @param {Object} payload - The RATE_LIMITED payload of the Module.
@@ -43,12 +47,33 @@ class RecordRateLimitMessage {
      * @param {string} payload.reason
      * @param {Date|string|number} payload.retryAt
      * @param {Array<{label: string, url: string}>} [payload.links]
-     * @returns {Promise<boolean>} True when it wrote a warning.
-     * @throws When the read or the write fails; the caller decides what a
-     *   failed warning is worth.
      */
-    async execute(integrationId, { moduleName, reason, retryAt, links }) {
-        const resetAt = new Date(retryAt);
+    async execute(integrationId, payload) {
+        const { moduleName, reason, retryAt, links } = payload ?? {};
+        if (!isNonEmptyString(moduleName) || !isValidTime(retryAt)) return;
+
+        try {
+            await this._recordUnlessStored(integrationId, {
+                moduleName,
+                reason,
+                resetAt: new Date(retryAt),
+                links,
+            });
+        } catch (error) {
+            log.warn('Failed to record rate limit message', {
+                eventName:
+                    'frigg.integrations.rate_limit_message_record_failed',
+                integrationId,
+                moduleName,
+                error,
+            });
+        }
+    }
+
+    async _recordUnlessStored(
+        integrationId,
+        { moduleName, reason, resetAt, links }
+    ) {
         const warnings =
             await this.integrationRepository.findIntegrationMessages(
                 integrationId,
@@ -56,14 +81,14 @@ class RecordRateLimitMessage {
             );
         const alreadyRecorded = warnings.some(
             (warning) =>
-                warning?.code === RATE_LIMITED &&
+                warning?.code === RATE_LIMITED_MESSAGE_CODE &&
                 warning.module === moduleName &&
                 Math.abs(Date.parse(warning.retryAt) - resetAt.getTime()) <=
                     SAME_LIMIT_WINDOW_MS
         );
-        if (alreadyRecorded) return false;
+        if (alreadyRecorded) return;
 
-        const resetsAt = utcMinuteAfter(resetAt);
+        const resetsAt = formatResetTime(resetAt);
         await this.integrationRepository.updateIntegrationMessages(
             integrationId,
             'warnings',
@@ -71,14 +96,14 @@ class RecordRateLimitMessage {
                 title: 'Rate limit reached',
                 message: `The ${moduleName} API rate limit was reached and resets at ${resetsAt}.`,
                 timestamp: Date.now(),
-                code: RATE_LIMITED,
+                code: RATE_LIMITED_MESSAGE_CODE,
                 module: moduleName,
                 reason,
                 retryAt: resetAt.toISOString(),
                 actions: [{ type: 'RETRY_WHEN_READY' }, ...linkActions(links)],
-            }
+            },
+            { keepLast: MAX_MESSAGES_PER_TYPE }
         );
-        return true;
     }
 }
 

package/integrations/use-cases/update-integration-messages.js

@@ -1,3 +1,17 @@
+const MAX_MESSAGES_PER_TYPE = 50;
+
+const isPlainObject = (value) =>
+    value !== null && typeof value === 'object' && !Array.isArray(value);
+
+function toMessageItem(titleOrItem, messageBody, messageTimestamp) {
+    if (isPlainObject(titleOrItem)) return { ...titleOrItem };
+    return {
+        title: titleOrItem,
+        message: messageBody,
+        timestamp: messageTimestamp,
+    };
+}
+
 /**
  * Use case for updating messages associated with an integration.
  * @class UpdateIntegrationMessages
@@ -35,12 +49,15 @@ class UpdateIntegrationMessages {
             await this.integrationRepository.updateIntegrationMessages(
                 integrationId,
                 messageType,
-                messageTitleOrItem,
-                messageBody,
-                messageTimestamp
+                toMessageItem(
+                    messageTitleOrItem,
+                    messageBody,
+                    messageTimestamp
+                ),
+                { keepLast: MAX_MESSAGES_PER_TYPE }
             );
         return integration;
     }
 }
 
-module.exports = { UpdateIntegrationMessages };
+module.exports = { MAX_MESSAGES_PER_TYPE, UpdateIntegrationMessages };

package/logs/serialize.js

@@ -235,6 +235,20 @@ function errorCode(err) {
     return undefined;
 }
 
+function rateLimitFields(err) {
+    const retryAt = attempt(
+        () => (err.isRateLimited ? err.retryAt : undefined),
+        undefined
+    );
+    if (!(retryAt instanceof Date) || Number.isNaN(retryAt.getTime())) {
+        return {};
+    }
+    const reason = attempt(() => err.reason, undefined);
+    return typeof reason === 'string'
+        ? { retryAt: retryAt.toISOString(), reason: cleanString(reason) }
+        : { retryAt: retryAt.toISOString() };
+}
+
 function errorStack(err, type, message) {
     const stack = attempt(() => err.stack, undefined);
     if (typeof stack !== 'string') return undefined;
@@ -279,6 +293,7 @@ function serializeErrorAt(err, depth, seen) {
     if (code !== undefined) out.code = code;
     const status = errorStatus(err);
     if (status !== undefined) out.status = status;
+    Object.assign(out, rateLimitFields(err));
     const stack = errorStack(err, type, message);
     if (stack !== undefined) out.stack = stack;
 

package/modules/module.js

@@ -8,6 +8,7 @@ const {
 const {
     createModuleRepository,
 } = require('./repositories/module-repository-factory');
+const { readRateLimitPolicy } = require('./requester/rate-limit');
 
 // todo: this class should be a Domain class, and the Delegate function is preventing us from
 // doing that, we probably have to get rid of the Delegate class as well as the event based
@@ -238,15 +239,11 @@ class Module extends Delegate {
         }
     }
 
-    /**
-     * Passes a rate limit the api reported to the parent delegate, best
-     * effort. The payload never holds the error's message, url, body or
-     * headers, because the parent shows it to end users.
-     * @param {import('../errors').RateLimitError} rateLimitError
-     */
     async reportRateLimit(rateLimitError) {
         const { reason, retryAt, policy, statusCode } = rateLimitError;
-        const links = this.apiClass.rateLimit?.userHints?.[reason]?.links ?? [];
+        const links =
+            readRateLimitPolicy(this.apiClass)?.userHints?.[reason]?.links ??
+            [];
         try {
             await this.notify(this.DLGT_RATE_LIMITED, {
                 moduleName: this.name,
@@ -257,8 +254,8 @@ class Module extends Delegate {
                 links,
             });
         } catch (err) {
-            this.logger.error('Failed to propagate RATE_LIMITED', {
-                eventName: `${this.logger.name}.rate_limited_propagation_failed`,
+            this.logger.warn('Failed to propagate RATE_LIMITED', {
+                eventName: `${this.logger.name}.rate_limit_propagation_failed`,
                 error: err,
             });
         }

package/modules/requester/rate-limit/parsers.js

@@ -34,11 +34,6 @@ function readKeys(headers, wanted) {
     return undefined;
 }
 
-/**
- * Reads one header from a Headers-like object, a Map, an entries array or a
- * plain object. The name match is case-insensitive.
- * @returns {string|undefined}
- */
 function headerValue(headers, name) {
     if (!headers || typeof headers !== 'object') return undefined;
     const wanted = name.toLowerCase();
@@ -70,10 +65,6 @@ function definedOnly(fields) {
     return result;
 }
 
-/**
- * Builds a hint from a wait in ms. Returns null for a wait that is not a
- * finite number in [0, MAX_HINT_WAIT_MS].
- */
 function hintFromWait(waitMs, now, { source = 'header', ...extra } = {}) {
     if (!Number.isFinite(waitMs) || waitMs < 0 || waitMs > MAX_HINT_WAIT_MS) {
         return null;
@@ -86,9 +77,6 @@ function hintFromWait(waitMs, now, { source = 'header', ...extra } = {}) {
     };
 }
 
-/**
- * Builds a hint from an absolute time. A time in the past waits 0 ms.
- */
 function hintFromRetryAt(retryAt, now, { source = 'header', ...extra } = {}) {
     const at = retryAt instanceof Date ? retryAt.getTime() : Number.NaN;
     if (Number.isNaN(at)) return null;
@@ -103,9 +91,6 @@ function parseDate(text) {
     return Number.isNaN(at) ? null : new Date(at);
 }
 
-/**
- * Retry-After: delta seconds, an HTTP-date or an ISO timestamp.
- */
 function parseRetryAfter(value, { now = Date.now() } = {}) {
     if (isMissing(value)) return null;
     const text = String(value).trim();
@@ -145,10 +130,6 @@ function parseResetValue(text, now, extra) {
     return date ? hintFromRetryAt(date, now, extra) : null;
 }
 
-/**
- * X-RateLimit-Reset and the other reset headers. The magnitude tells the
- * unit: epoch milliseconds, epoch seconds, or delta seconds.
- */
 function parseResetHeaders(headers, { now = Date.now() } = {}) {
     const remaining = numberOrUndefined(
         firstHeader(headers, REMAINING_HEADERS)
@@ -222,11 +203,6 @@ function readKeyValue(text, key) {
     return match ? match[1] : undefined;
 }
 
-/**
- * The IETF RateLimit field: the key=value form (limit=, remaining=, reset=)
- * and the structured-field form ("name";r=0;t=12). The list form picks the
- * policy with the fewest remaining calls, then the longest wait.
- */
 function parseIetfRateLimit(headers, { now = Date.now() } = {}) {
     const raw = headerValue(headers, 'ratelimit');
     if (raw === undefined) return null;
@@ -259,6 +235,7 @@ const BUILT_IN_PARSERS = {
 module.exports = {
     BUILT_IN_PARSERS,
     MAX_HINT_WAIT_MS,
+    definedOnly,
     headerValue,
     hintFromRetryAt,
     hintFromWait,

package/modules/requester/rate-limit/policy.js

@@ -1,5 +1,6 @@
 const {
     BUILT_IN_PARSERS,
+    definedOnly,
     hintFromRetryAt,
     hintFromWait,
 } = require('./parsers');
@@ -24,6 +25,7 @@ const normalizedPolicies = new WeakSet();
 const policiesByClass = new WeakMap();
 
 const isObject = (value) => value !== null && typeof value === 'object';
+const isThenable = (value) => typeof value?.then === 'function';
 
 function isPlainObject(value) {
     if (!isObject(value) || Array.isArray(value)) return false;
@@ -31,14 +33,6 @@ function isPlainObject(value) {
     return prototype === Object.prototype || prototype === null;
 }
 
-function definedOnly(fields) {
-    const result = {};
-    for (const [key, value] of Object.entries(fields)) {
-        if (value !== undefined) result[key] = value;
-    }
-    return result;
-}
-
 function readParsers(raw, owner) {
     if (!Array.isArray(raw.parsers)) return [...DEFAULT_PARSERS];
     for (const name of raw.parsers) {
@@ -79,11 +73,6 @@ function normalizePolicy(raw, owner) {
     return policy;
 }
 
-/**
- * Reads the static `rateLimit` policy of an API module class. Returns
- * undefined when the class declares none. The result is memoized per class.
- * Throws a TypeError for a parser name that is not built in.
- */
 function readRateLimitPolicy(ctor) {
     if (typeof ctor !== 'function') return undefined;
     if (policiesByClass.has(ctor)) return policiesByClass.get(ctor);
@@ -98,10 +87,6 @@ function asPolicy(value) {
     return normalizePolicy(value, 'policy');
 }
 
-/**
- * The key a limit counts against, for one requester. Undefined when the
- * scope needs an id that the requester does not have.
- */
 function computeScopeKey(policy, requester) {
     const label = requester?._telemetryModuleLabel?.() ?? 'unknown';
     const scope = policy?.scope ?? 'entity';
@@ -136,8 +121,18 @@ function computeScopeKey(policy, requester) {
     return undefined;
 }
 
+function toDate(value) {
+    if (value === undefined || value === null) return null;
+    const date = value instanceof Date ? value : new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+
 function normalizeClassified(raw, now) {
     if (!isObject(raw)) return null;
+    const retryAt = toDate(raw.retryAt);
+    if (!REASONS.has(raw.reason) && !Number.isFinite(raw.waitMs) && !retryAt) {
+        return null;
+    }
 
     const extra = {
         reason: REASONS.has(raw.reason) ? raw.reason : 'unknown',
@@ -146,12 +141,7 @@ function normalizeClassified(raw, now) {
         source: CLASSIFY_SOURCES.has(raw.source) ? raw.source : 'body',
     };
 
-    let hint = null;
-    if (raw.retryAt !== undefined && raw.retryAt !== null) {
-        const date =
-            raw.retryAt instanceof Date ? raw.retryAt : new Date(raw.retryAt);
-        hint = hintFromRetryAt(date, now, extra);
-    }
+    let hint = retryAt ? hintFromRetryAt(retryAt, now, extra) : null;
     if (!hint && Number.isFinite(raw.waitMs)) {
         hint = hintFromWait(raw.waitMs, now, extra);
     }
@@ -172,6 +162,12 @@ function runClassify(policy, signal, now, onClassifyError) {
             headers: signal.headers,
             body: signal.body,
         });
+        if (isThenable(raw)) {
+            Promise.resolve(raw).catch(() => {});
+            throw new TypeError(
+                'classify() must return a hint or null, not a Promise'
+            );
+        }
     } catch (error) {
         if (!onClassifyError) throw error;
         onClassifyError(error);
@@ -226,28 +222,12 @@ function resolveCandidates(policy, signal, { now, onClassifyError }) {
     return { hint: null, classified };
 }
 
-/**
- * Finds the hint of a throttled response: the module's classify(), then the
- * header parsers, then the static policy. Returns null when there is none.
- * A status other than 429 counts only when classify recognised it.
- *
- * @param {object} [policy] The static `rateLimit` object of an API module.
- * @param {{status?: number, headers?: object, body?: unknown}} signal
- * @param {{now?: number, onClassifyError?: (error: Error) => void}} [options]
- *   Without `onClassifyError` an error thrown by classify propagates.
- */
 function classifyRateLimit(policy, signal, options = {}) {
     const { now = Date.now(), onClassifyError } = options;
     return resolveCandidates(asPolicy(policy), signal, { now, onClassifyError })
         .hint;
 }
 
-/**
- * Like classifyRateLimit, but a throttled response always gets a hint: with
- * none found it gets the step of the fixed backoff ladder, with source
- * "backoff". Null when the response is not throttled: a status other than 429
- * that classify did not recognise.
- */
 function resolveRateLimitHint(policy, signal, options = {}) {
     const {
         attempt = 0,
@@ -276,11 +256,6 @@ function resolveRateLimitHint(policy, signal, options = {}) {
     };
 }
 
-/**
- * The wait before the next attempt, for a hint that came from the provider
- * or the policy. Jitter only adds to the wait and never passes the budget.
- * `fits` is false when the wait alone is over the budget.
- */
 function computeWaitMs({ hint, policy, budgetMs, random = Math.random }) {
     const base = Math.max(
         hint.waitMs,
@@ -295,10 +270,6 @@ function computeWaitMs({ hint, policy, budgetMs, random = Math.random }) {
     return { waitMs: Math.min(base + jitter, budgetMs), fits: true };
 }
 
-/**
- * How long this request may still sleep in process: the cap, less what it
- * slept already, and the time left in the invocation, less one request.
- */
 function inProcessBudgetMs({
     policy,
     requestTimeoutMs = 0,
@@ -306,10 +277,8 @@ function inProcessBudgetMs({
     waitedMs = 0,
 } = {}) {
     const cap = policy?.maxInProcessWaitMs ?? DEFAULT_MAX_IN_PROCESS_WAIT_MS;
-    return Math.max(
-        0,
-        Math.min(cap - waitedMs, remainingMs - (requestTimeoutMs || 0))
-    );
+    const reserveMs = Math.min(requestTimeoutMs || 0, remainingMs / 2);
+    return Math.max(0, Math.min(cap - waitedMs, remainingMs - reserveMs));
 }
 
 module.exports = {

package/modules/requester/requester.js

@@ -10,9 +10,9 @@ const { redactUrl } = require('../../logs/redact');
 const { toSanitizedSurrogate } = require('../../logs/serialize');
 const { getLoggerScope } = require('../../logs/context');
 const {
+    DEFAULT_MAX_IN_PROCESS_WAIT_MS,
     computeScopeKey,
     computeWaitMs,
-    headerValue,
     inProcessBudgetMs,
     readRateLimitPolicy,
     resolveRateLimitHint,
@@ -20,18 +20,6 @@ const {
 
 const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
 
-function isJsonMediaType(contentType) {
-    const mediaType = String(contentType ?? '')
-        .split(';')[0]
-        .trim()
-        .toLowerCase();
-    return (
-        mediaType === 'application/json' ||
-        mediaType === 'text/json' ||
-        mediaType.endsWith('+json')
-    );
-}
-
 // A node-fetch error message holds the raw URL, and util.inspect prints the
 // cause chain, so the FetchError keeps only a sanitized copy.
 function sanitizedCause(err) {
@@ -237,9 +225,6 @@ class Requester extends Delegate {
      * @param {number} attempt - 0-based count of retries already made for
      *   this call. Indexes `this.backOff` for the next delay and is passed
      *   back in on each recursive retry.
-     * @param {number} waitedMs - Milliseconds this call has slept already
-     *   for a wait that a provider or a policy set. It counts against the
-     *   in-process cap.
      */
     async _rawRequest(url, options, attempt = 0, waitedMs = 0) {
         let encodedUrl = encodeURI(url);
@@ -336,7 +321,7 @@ class Requester extends Delegate {
                 status,
                 attempt
             );
-            const throttleRetry = await this._throttleRetry({
+            const hintedDelayMs = await this._hintedRetryDelayMs({
                 throttle,
                 status,
                 attempt,
@@ -346,21 +331,24 @@ class Requester extends Delegate {
                 response,
                 timeoutMs,
             });
-            if (throttleRetry) {
+            if (hintedDelayMs !== null) {
                 clearRequestTimer();
                 await new Promise((resolve) =>
-                    setTimeout(resolve, throttleRetry.delayMs)
+                    setTimeout(resolve, hintedDelayMs)
                 );
                 return this._rawRequest(
                     url,
                     options,
                     attempt + 1,
-                    waitedMs + throttleRetry.hintedMs
+                    waitedMs + hintedDelayMs
                 );
             }
 
             // If the status is retriable and there are back off requests left, retry the request
-            if (status >= 500 && attempt < this.backOff.length) {
+            if (
+                (throttle?.throttled || status >= 500) &&
+                attempt < this.backOff.length
+            ) {
                 clearRequestTimer();
                 const delay = this.backOff[attempt] * 1000;
                 await new Promise((resolve) => setTimeout(resolve, delay));
@@ -499,16 +487,7 @@ class Requester extends Delegate {
         }
     }
 
-    /**
-     * What to do about a throttled response: the delay before the next
-     * attempt, or null when there is no attempt left. A wait that a hint set
-     * and that does not fit the budget throws RateLimitError.
-     *
-     * @returns {Promise<{delayMs: number, hintedMs: number}|null>}
-     *   `hintedMs` is the part of the delay that a provider or a policy set,
-     *   which counts against the in-process cap.
-     */
-    async _throttleRetry({
+    async _hintedRetryDelayMs({
         throttle,
         status,
         attempt,
@@ -518,35 +497,28 @@ class Requester extends Delegate {
         response,
         timeoutMs,
     }) {
-        if (!throttle?.throttled) return null;
-        const { hint } = throttle;
-        if (hint.source === 'backoff') {
-            return attempt < this.backOff.length
-                ? { delayMs: this.backOff[attempt] * 1000, hintedMs: 0 }
-                : null;
+        if (!throttle?.throttled || throttle.hint.source === 'backoff') {
+            return null;
         }
-
-        const budgetMs = inProcessBudgetMs({
-            policy: this._rateLimitPolicy,
-            requestTimeoutMs: this.requestTimeoutMs,
-            remainingMs: remainingInvocationMs(),
-            waitedMs,
-        });
+        const { hint } = throttle;
+        const budgetMs = this.backOff.length
+            ? inProcessBudgetMs({
+                  policy: this._rateLimitPolicy,
+                  requestTimeoutMs: this.requestTimeoutMs,
+                  remainingMs: remainingInvocationMs(),
+                  waitedMs,
+              })
+            : 0;
         const { waitMs, fits } = computeWaitMs({
             hint,
             policy: this._rateLimitPolicy,
             budgetMs,
             random: this._random,
         });
-        this._logRateLimited({
-            status,
-            hint,
-            waitMs,
-            attempt,
-            waitedMs,
-            action: fits ? 'wait' : 'throw',
-        });
-        if (fits) return { delayMs: waitMs, hintedMs: waitMs };
+        if (fits) {
+            this._logRateLimited({ status, hint, waitMs, attempt, waitedMs });
+            return waitMs;
+        }
 
         this._logRequestFailed(encodedUrl, options, status);
         const rateLimitError = await RateLimitError.create({
@@ -563,14 +535,6 @@ class Requester extends Delegate {
         throw this._maybeFlagTimeoutDuringBodyRead(rateLimitError, timeoutMs);
     }
 
-    /**
-     * Decides whether a response says a limit was hit. A 429 always does. A
-     * 4xx or 5xx other than 401 does only when the module's classify() names
-     * a limit. The body is read here, once, only for classify(); the text is
-     * handed on so the error need not read the stream again.
-     *
-     * @returns {Promise<{throttled: boolean, hint?: object, responseBody?: string}|null>}
-     */
     async _detectThrottle(response, status, attempt) {
         const policy = this._rateLimitPolicy;
         const canClassify =
@@ -605,9 +569,6 @@ class Requester extends Delegate {
             return {};
         }
         const text = await response.text();
-        if (!isJsonMediaType(headerValue(response.headers, 'content-type'))) {
-            return { text };
-        }
         try {
             return { text, json: JSON.parse(text) };
         } catch {
@@ -615,9 +576,9 @@ class Requester extends Delegate {
         }
     }
 
-    _logRateLimited({ status, hint, waitMs, attempt, waitedMs, action }) {
+    _logRateLimited({ status, hint, waitMs, attempt, waitedMs }) {
         const logger = this.logger;
-        logger.info('Rate limited', {
+        logger.trace('Rate limited', {
             eventName: `${logger.name}.rate_limited`,
             statusCode: status,
             waitMs,
@@ -626,7 +587,6 @@ class Requester extends Delegate {
             hintSource: hint.source,
             attempt,
             waitedMs,
-            action,
         });
     }
 
@@ -639,12 +599,8 @@ class Requester extends Delegate {
         });
     }
 
-    /**
-     * Tells the delegate a wait was too long to sleep. Best effort: a failed
-     * notification is logged and never replaces the RateLimitError the caller
-     * is about to receive.
-     */
     async _notifyRateLimited(rateLimitError) {
+        if (!this._waitsLongerThanInProcessCap(rateLimitError)) return;
         try {
             await this.notify(this.DLGT_RATE_LIMITED, rateLimitError);
         } catch (error) {
@@ -657,6 +613,16 @@ class Requester extends Delegate {
         }
     }
 
+    _waitsLongerThanInProcessCap(rateLimitError) {
+        const waitMs = Number.isFinite(rateLimitError?.waitMs)
+            ? rateLimitError.waitMs
+            : new Date(rateLimitError?.retryAt).getTime() - Date.now();
+        const capMs =
+            this._rateLimitPolicy?.maxInProcessWaitMs ??
+            DEFAULT_MAX_IN_PROCESS_WAIT_MS;
+        return waitMs > capMs;
+    }
+
     _logRequestFailed(encodedUrl, options, status) {
         const logger = this.logger;
         if (!logger.isLevelEnabled('DEBUG')) return;