@friggframework/core 2.0.0--canary.657.b14221f.0 → 2.0.0--canary.658.a5177aa.0

package/CLAUDE.md

@@ -546,61 +546,6 @@ The single source of the max receive count is
 devtools integration builder uses it for the queue's `RedrivePolicy` and sets
 it as `FRIGG_QUEUE_MAX_RECEIVE_COUNT` on the queue worker function.
 
-**Rate-limit deferral** (ADR-049): when a queue handler throws an error with
-`isRateLimited` and a `retryAt` (a `RateLimitError` from the Requester, or one a
-module throws), `Worker.run` does not give the message back to SQS for a 30
-minute redelivery that spends one of its three receives. It puts the message
-back so it runs at `retryAt`:
-
-| Wait | What the worker does | Record |
-|---|---|---|
-| Up to 900 s | Sends the same body again with `DelaySeconds`, then acknowledges the old message | handled |
-| Over 900 s, and `SCHEDULER_ROLE_ARN` is set | Creates a one-time EventBridge schedule at `retryAt` that sends the body to the queue, then acknowledges | handled |
-| Over 900 s, no scheduler | Extends the message's visibility timeout to `retryAt` (12 h at most). This uses one receive | reported failed |
-
-- The new message starts at receive count 1. A deferred body carries
-  `_frigg: { deferrals, firstDeferredAt }`; `_frigg` is reserved and the handler
-  never sees it.
-- Two caps bound it: `FRIGG_QUEUE_MAX_DEFERRALS` (default 10) and
-  `FRIGG_QUEUE_MAX_DEFERRED_MS` (default 24 h, from the first deferral to the
-  retry time). Past a cap, with no `retryAt`, with no event source ARN or on a
-  FIFO queue, the record fails like any retryable error and `delivery`
-  applies.
-- The mock scheduler is never used for a deferral: a schedule kept in memory
-  would be lost with the acknowledged message.
-- With a `processId` in the message, the worker writes
-  `Process.context.rateLimit = { status: 'WAITING' | 'EXHAUSTED', mechanism,
-  retryAt, reason, module, deferrals, updatedAt }`. `EXHAUSTED` means a cap ended
-  the deferrals, or a visibility change came on the last delivery. The value is
-  one per process, so it holds the latest known wait: a new wait replaces it only
-  when its `retryAt` is later, a `WAITING` value never hides an `EXHAUSTED` one,
-  and after a deferred or redelivered message ran the worker sets it to `null`
-  only when it is `WAITING` and its `retryAt` is past or within 5 s.
-- Delivery stays at least once. The new message is sent before the old one is
-  acknowledged, so a crash between the two can run the work twice.
-- Handlers check `delivery.isLastAttempt` first, then rethrow. The delay and
-  schedule tiers send a new message, so they never reach the last attempt. The
-  visibility tier and a cap use a receive: on the last one the worker writes an
-  ERROR (`frigg.worker.record_lost_rate_limited`), and the handler has this one
-  chance to end the run.
-
-```javascript
-async processBatch({ data, delivery }) {
-    try {
-        await this.syncPage(data);
-    } catch (error) {
-        if (delivery?.isLastAttempt) return this.failRun(data.processId, error);
-        throw error; // a RateLimitError too: core puts the message back at retryAt
-    }
-}
-```
-
-Records: `frigg.worker.record_deferred` (`mechanism` `delay` or `schedule`),
-`record_visibility_extended`, `record_deferral_capped`,
-`record_lost_rate_limited` and `rate_limit_state_failed`. A queue in a stack
-that does not own it (`ownership.queue: 'external'`) needs its own
-`sqs:ChangeMessageVisibility` and scheduler access.
-
 ### 8. Error Handling (`/errors`)
 
 **Purpose**: Standardized error types with proper HTTP semantics.
@@ -623,6 +568,53 @@ if (!userId) {
 }
 ```
 
+**Rate-limit message** (ADR-049): when a wait is too long to sleep, the
+Requester tells its delegate (`RATE_LIMITED`, with the `RateLimitError`) and
+then throws. The notification takes the path of `CREDENTIAL_INVALIDATED`:
+Requester, `Module`, `IntegrationBase`.
+
+- The `Module` sends `{ moduleName, reason, retryAt, policy, statusCode, links }`.
+  `links` is `static rateLimit.userHints[reason].links`, or `[]`. The message,
+  url, body and headers of the error are never sent: the message reaches end
+  users.
+- `IntegrationBase` writes one `WARN` (`integration.<name>.rate_limited`), and
+  `RecordRateLimitMessage` appends one item to the stored `warnings`. It
+  changes no status. A rate limit is not an `ERROR`, and an `ERROR` status
+  makes the queue worker drop every webhook.
+- A report for the same module whose reset time is within 60 s of a stored one
+  is skipped. The check reads the stored `warnings` with
+  `findIntegrationMessages`, not `this.messages`, which is per instance and
+  empty on Postgres. It is a read then a write, so workers that report at the
+  same instant can still store a few copies.
+- Every hop is best effort. A failure is logged, and the caller still gets the
+  `RateLimitError`.
+
+```javascript
+{
+    title: 'Rate limit reached',
+    message: 'The hubspot API rate limit was reached and resets at 2026-09-28 14:31 UTC.',
+    timestamp: 1790000000000,
+    code: 'RATE_LIMITED',
+    module: 'hubspot',
+    reason: 'daily',
+    retryAt: '2026-09-28T14:30:15.000Z',
+    actions: [
+        { type: 'RETRY_WHEN_READY' },
+        { type: 'LINK', label: 'API usage limits', url: 'https://example.com/limits' },
+    ],
+}
+```
+
+The text is fixed. It holds the module name and the reset time in UTC, rounded
+up to the minute, and nothing from the request.
+`updateIntegrationMessages(id, type, title, body, timestamp)` still works, and
+it also takes one item object, `updateIntegrationMessages(id, type, item)`,
+whose keys are stored as they are. Every call appends.
+`findIntegrationMessages(id, type)` reads the stored items of one type. The
+`messages` of the record from `findIntegrationById` is not filled on Postgres
+and Mongo, because the schema keeps the messages in the `errors`, `warnings`,
+`info` and `logs` columns.
+
 ### 9. Logging System (`/logs`)
 
 **Purpose**: One redacted JSON record per line to stdout (ADR-048). See `docs/guides/LOGGING.md`.

package/core/CLAUDE.md

@@ -79,25 +79,6 @@ await worker.send({
 }, delaySeconds);
 ```
 
-**Rate-limit deferral** (ADR-049): `run()` handles an error with `isRateLimited`
-and a `retryAt` through `defer(record, body, error, delivery)`, which returns
-`{ outcome }`:
-- `acked`: the message was sent again with `DelaySeconds` (wait up to 900 s) or
-  scheduled with the one-time scheduler (longer wait). The record is handled.
-- `failed`: the visibility timeout was extended to `retryAt`, or a cap
-  (`FRIGG_QUEUE_MAX_DEFERRALS`, `FRIGG_QUEUE_MAX_DEFERRED_MS`) ended the
-  deferrals. The record is reported failed.
-- `skipped`: no `retryAt`, no `eventSourceARN`, a FIFO queue, or a failed send.
-  The record fails as any error does, and `record_failed` carries
-  `deferral: { skipped }`.
-
-Subclasses override two no-op hooks to keep run state: `recordRateLimitWait(body,
-error, state)` runs after the message was put back, and `clearRateLimitWait(body)`
-runs after a deferred or redelivered message succeeded. A failing hook logs
-`frigg.worker.rate_limit_state_failed` and never changes the outcome. The queue
-worker of an integration (`createQueueWorker`) writes `Process.context.rateLimit`
-in them. See `packages/core/CLAUDE.md` section 7.
-
 ### Delegate Pattern System (`Delegate.js:3-27`)
 
 **Purpose**: Observer/delegation pattern for decoupled component communication

package/core/Worker.js

@@ -1,39 +1,14 @@
-const { randomUUID } = require('node:crypto');
-const {
-    SQSClient,
-    GetQueueUrlCommand,
-    SendMessageCommand,
-    ChangeMessageVisibilityCommand,
-} = require('@aws-sdk/client-sqs');
+const { SQSClient, GetQueueUrlCommand, SendMessageCommand } = require('@aws-sdk/client-sqs');
 const _ = require('lodash');
 const { RequiredPropertyError } = require('../errors');
 const { get } = require('../assertions');
 const { readQueueDelivery } = require('../queues/queue-delivery');
-const { awsConfigOptions } = require('../queues/queuer-util');
-const {
-    MAX_DELAY_SECONDS,
-    MAX_VISIBILITY_TIMEOUT_SECONDS,
-    isDeferralCapped,
-    nextDeferral,
-    readDeferral,
-    readDeferralLimits,
-    withDeferral,
-} = require('../queues/queue-deferral');
 const { runMessageScope } = require('./invocation-scope');
-const { getLogger, serializeError } = require('../logs');
+const { getLogger } = require('../logs');
 
-const sqs = new SQSClient({
-    region: process.env.AWS_REGION,
-    ...awsConfigOptions(),
-});
+const sqs = new SQSClient({ region: process.env.AWS_REGION });
 const log = getLogger('frigg.worker');
 
-const validDate = (value) =>
-    value instanceof Date && !Number.isNaN(value.getTime()) ? value : null;
-const queueNameOf = (arn) =>
-    typeof arn === 'string' && arn ? arn.split(':').pop() : undefined;
-const causeOf = (error) => serializeError(error).message;
-
 class Worker {
     async getQueueURL(params) {
         // Passing params in because there will be multiple QueueNames
@@ -58,31 +33,12 @@ class Worker {
                 // messageId, receiveCount and the event come from the scope.
                 log.debug('Record started', { eventName: 'frigg.worker.record_started' });
 
-                const delivery = readQueueDelivery(record);
-                let runParams;
                 try {
-                    runParams = JSON.parse(record.body);
+                    const runParams = JSON.parse(record.body);
                     this._validateParams(runParams);
-                    await this._run(runParams, context, delivery);
-                    await this._clearDeferredState(runParams, delivery);
+                    await this._run(runParams, context, readQueueDelivery(record));
                     log.debug('Record succeeded', { eventName: 'frigg.worker.record_succeeded' });
                 } catch (error) {
-                    let deferral;
-                    if (error.isRateLimited && runParams) {
-                        deferral = await this.defer(
-                            record,
-                            runParams,
-                            error,
-                            delivery
-                        );
-                        if (deferral.outcome === 'acked') return;
-                        if (deferral.outcome === 'failed') {
-                            batchItemFailures.push({
-                                itemIdentifier: record.messageId,
-                            });
-                            return;
-                        }
-                    }
                     if (error.isHaltError) {
                         // HaltError means "discard this message, don't retry".
                         // Treat as success so SQS deletes it from the queue.
@@ -99,14 +55,6 @@ class Worker {
                     log.warn('Record failed, returned for retry', {
                         eventName: 'frigg.worker.record_failed',
                         error,
-                        ...(deferral && {
-                            deferral: {
-                                skipped: deferral.skipped,
-                                ...(deferral.cause && {
-                                    cause: causeOf(deferral.cause),
-                                }),
-                            },
-                        }),
                     });
                     batchItemFailures.push({ itemIdentifier: record.messageId });
                 }
@@ -127,285 +75,6 @@ class Worker {
         // parameters
     }
 
-    /**
-     * Puts a rate-limited message back so it runs at `error.retryAt`, without
-     * spending a receive. The message is sent again with a delay of up to 900 s,
-     * or scheduled with the one-time scheduler, or has its visibility timeout
-     * extended. The new message goes out before the old one is acknowledged, so
-     * delivery stays at least once.
-     *
-     * @returns {Promise<{outcome: 'acked'|'failed'|'skipped', skipped?: string, cause?: Error}>}
-     *   `acked`: the message is handled. `failed`: report the record failed and
-     *   let SQS redeliver it. `skipped`: nothing was done; fail the record as
-     *   any other error.
-     */
-    async defer(record, body, error, delivery) {
-        const retryAt = validDate(error.retryAt);
-        if (!retryAt) return { outcome: 'skipped', skipped: 'no_retry_at' };
-        const queueName = queueNameOf(record.eventSourceARN);
-        if (!queueName || queueName.endsWith('.fifo')) {
-            return { outcome: 'skipped', skipped: 'no_event_source' };
-        }
-
-        const now = Date.now();
-        const waitMs = Math.max(0, retryAt.getTime() - now);
-        const deferral = nextDeferral(body, now);
-        const details = {
-            waitMs,
-            retryAt: retryAt.toISOString(),
-            deferrals: deferral.deferrals,
-            firstDeferredAt: deferral.firstDeferredAt,
-            reason: error.reason,
-            module: error.module,
-            statusCode: error.statusCode,
-        };
-        const state = (status, mechanism) => ({
-            status,
-            mechanism,
-            deferrals: deferral.deferrals,
-            retryAt,
-        });
-
-        const limits = readDeferralLimits();
-        if (isDeferralCapped({ ...deferral, retryAt }, limits)) {
-            log.warn('Rate-limit deferral capped', {
-                eventName: 'frigg.worker.record_deferral_capped',
-                ...details,
-                maxDeferrals: limits.maxDeferrals,
-                maxDeferredMs: limits.maxDeferredMs,
-                deferredMs:
-                    retryAt.getTime() - Date.parse(deferral.firstDeferredAt),
-                error,
-            });
-            await this._recordWait(body, error, state('EXHAUSTED', 'none'));
-            this._logIfLost(delivery, error, details);
-            return { outcome: 'failed' };
-        }
-
-        const tier = {
-            record,
-            queueName,
-            body,
-            next: withDeferral(body, deferral),
-            error,
-            delivery,
-            retryAt,
-            waitMs,
-            details,
-            state,
-        };
-        if (waitMs <= MAX_DELAY_SECONDS * 1000)
-            return this._deferWithDelay(tier);
-        const scheduled = await this._deferWithSchedule(tier);
-        if (scheduled?.outcome) return scheduled;
-        return this._deferWithVisibility({
-            ...tier,
-            scheduleError: scheduled?.scheduleError,
-        });
-    }
-
-    async _deferWithDelay({
-        queueName,
-        body,
-        next,
-        error,
-        waitMs,
-        details,
-        state,
-    }) {
-        const delaySeconds = Math.ceil(waitMs / 1000);
-        try {
-            const queueUrl = await this._queueUrl(queueName);
-            await this.send({ ...next, QueueUrl: queueUrl }, delaySeconds);
-        } catch (cause) {
-            return { outcome: 'skipped', skipped: 'send_failed', cause };
-        }
-        await this._recordWait(body, error, state('WAITING', 'delay'));
-        log.warn('Record deferred', {
-            eventName: 'frigg.worker.record_deferred',
-            mechanism: 'delay',
-            delaySeconds,
-            ...details,
-            error,
-        });
-        return { outcome: 'acked' };
-    }
-
-    /** `acked`, `{ scheduleError }` when the schedule failed, null with no scheduler. */
-    async _deferWithSchedule({
-        record,
-        body,
-        next,
-        error,
-        retryAt,
-        details,
-        state,
-    }) {
-        const scheduler = this.getSchedulerService();
-        if (!scheduler) return null;
-        const scheduleName = `frigg-defer-${record.messageId || randomUUID()}`;
-        try {
-            await scheduler.scheduleOneTime({
-                scheduleName,
-                scheduleAt: retryAt,
-                queueResourceId: record.eventSourceARN,
-                payload: next,
-            });
-        } catch (cause) {
-            if (cause?.name !== 'ConflictException')
-                return { scheduleError: cause };
-        }
-        await this._recordWait(body, error, state('WAITING', 'schedule'));
-        log.warn('Record deferred', {
-            eventName: 'frigg.worker.record_deferred',
-            mechanism: 'schedule',
-            scheduleName,
-            ...details,
-            error,
-        });
-        return { outcome: 'acked' };
-    }
-
-    async _deferWithVisibility({
-        record,
-        queueName,
-        body,
-        error,
-        delivery,
-        waitMs,
-        details,
-        state,
-        scheduleError,
-    }) {
-        const visibilityTimeout = Math.min(
-            Math.ceil(waitMs / 1000),
-            MAX_VISIBILITY_TIMEOUT_SECONDS
-        );
-        try {
-            const queueUrl = await this._queueUrl(queueName);
-            await sqs.send(
-                new ChangeMessageVisibilityCommand({
-                    QueueUrl: queueUrl,
-                    ReceiptHandle: record.receiptHandle,
-                    VisibilityTimeout: visibilityTimeout,
-                })
-            );
-        } catch (cause) {
-            return { outcome: 'skipped', skipped: 'visibility_failed', cause };
-        }
-        await this._recordWait(
-            body,
-            error,
-            state(
-                delivery.isLastAttempt ? 'EXHAUSTED' : 'WAITING',
-                'visibility'
-            )
-        );
-        log.warn('Record visibility extended', {
-            eventName: 'frigg.worker.record_visibility_extended',
-            mechanism: 'visibility',
-            visibilityTimeout,
-            ...details,
-            ...(scheduleError && { scheduleError: causeOf(scheduleError) }),
-            error,
-        });
-        this._logIfLost(delivery, error, details);
-        return { outcome: 'failed' };
-    }
-
-    /**
-     * The one-time scheduler, or null when the stack has none. The mock
-     * scheduler is never used: a schedule kept in memory would be lost with
-     * the message.
-     */
-    getSchedulerService() {
-        if (this._schedulerService !== undefined) return this._schedulerService;
-        this._schedulerService = null;
-        if (
-            process.env.SCHEDULER_ROLE_ARN &&
-            process.env.SCHEDULER_PROVIDER !== 'mock'
-        ) {
-            const {
-                createSchedulerService,
-                SCHEDULER_PROVIDERS,
-            } = require('../infrastructure/scheduler/scheduler-service-factory');
-            this._schedulerService = createSchedulerService({
-                provider: SCHEDULER_PROVIDERS.EVENTBRIDGE,
-            });
-        }
-        return this._schedulerService;
-    }
-
-    /**
-     * Hook: the message was put back for a rate limit. Runs after it was sent.
-     * @param {Object} body The parsed message body.
-     * @param {Error} error The RateLimitError.
-     * @param {{status: 'WAITING'|'EXHAUSTED', mechanism: string, deferrals: number, retryAt: Date}} state
-     */
-    async recordRateLimitWait() {
-        // A subclass keeps the run state; nothing to do by default.
-    }
-
-    /**
-     * Hook: a message that was put back for a rate limit ran without error.
-     * @param {Object} body The parsed message body.
-     */
-    async clearRateLimitWait() {
-        // A subclass keeps the run state; nothing to do by default.
-    }
-
-    _queueUrl(queueName) {
-        this._queueUrls ??= new Map();
-        if (!this._queueUrls.has(queueName)) {
-            const lookup = this.getQueueURL({ QueueName: queueName }).catch(
-                (error) => {
-                    this._queueUrls.delete(queueName);
-                    throw error;
-                }
-            );
-            this._queueUrls.set(queueName, lookup);
-        }
-        return this._queueUrls.get(queueName);
-    }
-
-    async _recordWait(body, error, state) {
-        await this._runStateHook('record', () =>
-            this.recordRateLimitWait(body, error, state)
-        );
-    }
-
-    async _clearDeferredState(body, delivery) {
-        const redelivered = delivery.receiveCount > 1;
-        if (readDeferral(body).deferrals === 0 && !redelivered) return;
-        await this._runStateHook('clear', () => this.clearRateLimitWait(body));
-    }
-
-    async _runStateHook(operation, hook) {
-        try {
-            await hook();
-        } catch (error) {
-            log.warn('Rate-limit run state not written', {
-                eventName: 'frigg.worker.rate_limit_state_failed',
-                operation,
-                error,
-            });
-        }
-    }
-
-    _logIfLost(delivery, error, details) {
-        if (!delivery.isLastAttempt) return;
-        log.error(
-            'Rate-limited record lost: the message goes to the dead-letter queue next',
-            {
-                eventName: 'frigg.worker.record_lost_rate_limited',
-                retryAt: details.retryAt,
-                reason: error.reason,
-                module: error.module,
-                error,
-            }
-        );
-    }
-
     // returns the message id
     async send(params, delay = 0) {
         this._validateParams(params);

package/handlers/backend-utils.js

@@ -22,15 +22,6 @@ const {
 } = require('../integrations/utils/map-integration-dto');
 const { processNotFound } = require('../integrations/use-cases/process-errors');
 
-const CLEAR_RATE_LIMIT_TOLERANCE_MS = 5_000;
-
-const keepsCurrentRateLimit = (current, next) => {
-    if (!current) return false;
-    if (next.status === 'EXHAUSTED') return false;
-    if (current.status === 'EXHAUSTED') return true;
-    return Date.parse(current.retryAt) > next.retryAt.getTime();
-};
-
 const loadRouterFromObject = (IntegrationClass, routerObject) => {
     const router = Router();
     const { path, method, event } = routerObject;
@@ -174,42 +165,6 @@ const createQueueWorker = (integrationClass) => {
     const integrationName = integrationClass.Definition.name;
 
     class QueueWorker extends Worker {
-        async recordRateLimitWait(body, error, state) {
-            const processId = body.data?.processId;
-            if (!processId) return;
-            const processRepository = createProcessRepository();
-            const process = await processRepository.findById(processId);
-            if (keepsCurrentRateLimit(process?.context?.rateLimit, state))
-                return;
-            await processRepository.applyProcessUpdate(processId, {
-                set: {
-                    'context.rateLimit': {
-                        status: state.status,
-                        mechanism: state.mechanism,
-                        retryAt: state.retryAt.toISOString(),
-                        reason: error.reason,
-                        module: error.module,
-                        deferrals: state.deferrals,
-                        updatedAt: new Date().toISOString(),
-                    },
-                },
-            });
-        }
-
-        async clearRateLimitWait(body) {
-            const processId = body?.data?.processId;
-            if (!processId) return;
-            const processRepository = createProcessRepository();
-            const process = await processRepository.findById(processId);
-            const current = process?.context?.rateLimit;
-            if (current?.status !== 'WAITING') return;
-            const remainingMs = Date.parse(current.retryAt) - Date.now();
-            if (remainingMs > CLEAR_RATE_LIMIT_TOLERANCE_MS) return;
-            await processRepository.applyProcessUpdate(processId, {
-                set: { 'context.rateLimit': null },
-            });
-        }
-
         async _run(params, context, delivery) {
             const logCtx = {
                 integration: integrationName,

package/integrations/integration-base.js

@@ -17,6 +17,9 @@ const {
 const {
     UpdateIntegrationConfig,
 } = require('./use-cases/update-integration-config');
+const {
+    RecordRateLimitMessage,
+} = require('./use-cases/record-rate-limit-message');
 const { validateExtensionBinding } = require('./extension');
 const { getTelemetry } = require('../telemetry/telemetry-runtime');
 const { instrumentHandler } = require('../telemetry/instrument-handler');
@@ -59,6 +62,9 @@ class IntegrationBase {
     updateIntegrationConfig = new UpdateIntegrationConfig({
         integrationRepository: this.integrationRepository,
     });
+    recordRateLimitMessage = new RecordRateLimitMessage({
+        integrationRepository: this.integrationRepository,
+    });
 
     // this.telemetry.count('records.synced', n, { entity: 'contact' })
     telemetry = bindTelemetryContext(getTelemetry(), () =>
@@ -865,7 +871,9 @@ class IntegrationBase {
      * something integration-level needs attention. Today this catches the
      * `CREDENTIAL_INVALIDATED` event Module fires from `markCredentialsInvalid`
      * and flips this integration's status to ERROR so the queue worker
-     * stops processing further webhooks until the user re-authorizes.
+     * stops processing further webhooks until the user re-authorizes. It also
+     * catches `RATE_LIMITED`, which records one warning for the user and
+     * changes no status: a rate limit is not an error.
      *
      * Modules are wired to this delegate in `_appendModules()`, which runs
      * during `setIntegrationRecord()` — this covers every construction path
@@ -908,6 +916,17 @@ class IntegrationBase {
             });
             await this.persistStatus('ENABLED');
         }
+
+        if (delegateString === 'RATE_LIMITED') {
+            const moduleName = object?.moduleName ?? notifier?.name;
+            this.logger.warn('Module reported a rate limit', {
+                eventName: `${this.logger.name}.rate_limited`,
+                moduleName,
+                reason: object?.reason,
+                retryAt: object?.retryAt,
+            });
+            await this._recordRateLimitMessage({ ...object, moduleName });
+        }
     }
 
     /**
@@ -933,6 +952,23 @@ class IntegrationBase {
             });
         }
     }
+
+    /**
+     * Best-effort: the module's request is about to throw a RateLimitError,
+     * and a failed warning must not change that. A rate limit is not an ERROR,
+     * so this never touches the integration status.
+     * @param {Object} payload - The RATE_LIMITED payload of the module.
+     */
+    async _recordRateLimitMessage(payload) {
+        try {
+            await this.recordRateLimitMessage.execute(this.id, payload);
+        } catch (error) {
+            this.logger.error('Failed to record rate limit message', {
+                eventName: `${this.logger.name}.rate_limit_message_record_failed`,
+                error,
+            });
+        }
+    }
 }
 
 module.exports = { IntegrationBase };