@friggframework/core 2.0.0--canary.578.3f8e78e.0 → 2.0.0--canary.579.312fe8b.0

package/core/Worker.js

@@ -20,45 +20,15 @@ class Worker {
         const records = get(params, 'Records');
         const batchItemFailures = [];
 
-        console.log(
-            `[Worker] run: processing ${records.length} record(s)`
-        );
-
         for (const record of records) {
-            // Log record entry with SQS-provided attributes useful for tracing
-            // delivery history (ApproximateReceiveCount for retries, etc.).
-            let parsedEvent;
-            try {
-                parsedEvent = JSON.parse(record.body)?.event;
-            } catch {
-                parsedEvent = undefined;
-            }
-            console.log(`[Worker] record begin`, {
-                messageId: record.messageId,
-                event: parsedEvent,
-                receiveCount: record.attributes?.ApproximateReceiveCount,
-            });
-
             try {
                 const runParams = JSON.parse(record.body);
                 this._validateParams(runParams);
                 await this._run(runParams, context);
-                console.log(`[Worker] record success`, {
-                    messageId: record.messageId,
-                    event: runParams?.event,
-                });
             } catch (error) {
                 if (error.isHaltError) {
                     // HaltError means "discard this message, don't retry".
                     // Treat as success so SQS deletes it from the queue.
-                    // Logged explicitly — silent discards made prod debugging
-                    // extremely hard; keep this visible.
-                    console.warn(`[Worker] record halted (discarded, no retry)`, {
-                        messageId: record.messageId,
-                        event: parsedEvent,
-                        reason: error.message,
-                        statusCode: error.statusCode,
-                    });
                     continue;
                 }
                 console.error(`[Worker] Failed to process record ${record.messageId}:`, error);
@@ -66,12 +36,6 @@ class Worker {
             }
         }
 
-        if (batchItemFailures.length > 0) {
-            console.warn(
-                `[Worker] run: returning ${batchItemFailures.length} batchItemFailure(s) of ${records.length}`
-            );
-        }
-
         return { batchItemFailures };
     }
 

package/core/create-handler.js

@@ -5,45 +5,6 @@
 const { initDebugLog, flushDebugLog } = require('../logs');
 const { secretsToEnv } = require('./secrets-to-env');
 
-// Best-effort extraction of correlation identifiers from a Lambda event.
-// For SQS: pulls messageIds + parsed event/processId/integrationId from each
-// record body. For HTTP: pulls method+path. Never throws.
-const summarizeLambdaEvent = (event) => {
-    if (!event) return {};
-    if (Array.isArray(event.Records)) {
-        return {
-            source: 'sqs',
-            records: event.Records.map((r) => {
-                let parsed = {};
-                try {
-                    const body = JSON.parse(r.body);
-                    parsed = {
-                        event: body?.event,
-                        processId: body?.data?.processId,
-                        integrationId: body?.data?.integrationId,
-                    };
-                } catch {
-                    // ignore unparseable bodies
-                }
-                return {
-                    messageId: r.messageId,
-                    receiveCount: r.attributes?.ApproximateReceiveCount,
-                    ...parsed,
-                };
-            }),
-        };
-    }
-    if (event.httpMethod || event.requestContext?.http) {
-        return {
-            source: 'http',
-            method:
-                event.httpMethod || event.requestContext?.http?.method,
-            path: event.path || event.rawPath,
-        };
-    }
-    return { source: 'other' };
-};
-
 const createHandler = (optionByName = {}) => {
     const {
         eventName = 'Event',
@@ -56,18 +17,7 @@ const createHandler = (optionByName = {}) => {
     }
 
     return async (event, context) => {
-        const eventSummary = summarizeLambdaEvent(event);
-
         try {
-            console.info(
-                `[createHandler] ${eventName}: handler entry`,
-                {
-                    eventName,
-                    awsRequestId: context?.awsRequestId,
-                    ...eventSummary,
-                }
-            );
-
             initDebugLog(eventName, event);
 
             const requestMethod = event.httpMethod;
@@ -112,21 +62,7 @@ const createHandler = (optionByName = {}) => {
             // Handle server-to-server responses.
 
             // Halt errors are logged but suceed and won't be retried.
-            // Log explicitly — silent suppression here previously made stuck
-            // messages invisible to observability tooling. Include
-            // eventSummary so operators can correlate across concurrent
-            // invocations (processId / messageIds / HTTP path).
             if (error.isHaltError === true) {
-                console.warn(
-                    `[createHandler] ${eventName}: halt error suppressed (no retry)`,
-                    {
-                        eventName,
-                        errorName: error.name,
-                        errorMessage: error.message,
-                        statusCode: error.statusCode,
-                        ...eventSummary,
-                    }
-                );
                 return;
             }
 

package/handlers/backend-utils.js

@@ -141,17 +141,8 @@ const loadIntegrationForProcess = async (processId, integrationClass) => {
 };
 
 const createQueueWorker = (integrationClass) => {
-    const integrationName = integrationClass.Definition.name;
-
     class QueueWorker extends Worker {
         async _run(params, context) {
-            const logCtx = {
-                integration: integrationName,
-                event: params.event,
-                processId: params.data?.processId,
-                integrationId: params.data?.integrationId,
-            };
-
             try {
                 let integrationInstance;
 
@@ -159,46 +150,29 @@ const createQueueWorker = (integrationClass) => {
                 // then integrationId (for ANY event type that needs hydration),
                 // fallback to unhydrated instance
                 if (params.data?.processId) {
-                    console.log(
-                        `[QueueWorker] hydrating by processId`,
-                        logCtx
-                    );
                     integrationInstance = await loadIntegrationForProcess(
                         params.data.processId,
                         integrationClass
                     );
-                    console.log(`[QueueWorker] hydrated`, {
-                        ...logCtx,
-                        integrationStatus: integrationInstance?.status,
-                        hydratedIntegrationId: integrationInstance?.id,
-                    });
                     if (['DISABLED', 'ERROR'].includes(integrationInstance?.status)) {
                         console.warn(
-                            `[${integrationName}] Integration for process ${params.data.processId} is ${integrationInstance.status}. Discarding ${params.event} message.`
+                            `[${integrationClass.Definition.name}] Integration for process ${params.data.processId} is ${integrationInstance.status}. Discarding ${params.event} message.`
                         );
                         return;
                     }
                 } else if (params.data?.integrationId) {
-                    console.log(
-                        `[QueueWorker] hydrating by integrationId`,
-                        logCtx
-                    );
                     integrationInstance = await loadIntegrationForWebhook(
                         params.data.integrationId
                     );
                     if (!integrationInstance) {
                         console.warn(
-                            `[${integrationName}] Integration ${params.data.integrationId} no longer exists. Discarding ${params.event} message.`
+                            `[${integrationClass.Definition.name}] Integration ${params.data.integrationId} no longer exists. Discarding ${params.event} message.`
                         );
                         return;
                     }
-                    console.log(`[QueueWorker] hydrated`, {
-                        ...logCtx,
-                        integrationStatus: integrationInstance?.status,
-                    });
                     if (['DISABLED', 'ERROR'].includes(integrationInstance.status)) {
                         console.warn(
-                            `[${integrationName}] Integration ${params.data.integrationId} is ${integrationInstance.status}. Discarding ${params.event} message.`
+                            `[${integrationClass.Definition.name}] Integration ${params.data.integrationId} is ${integrationInstance.status}. Discarding ${params.event} message.`
                         );
                         return;
                     }
@@ -207,10 +181,6 @@ const createQueueWorker = (integrationClass) => {
                     // There will be cases where we need to use helpers that the api modules can export.
                     // Like for HubSpot, the answer is to do a reverse lookup for the integration by the entity external ID (HubSpot Portal ID),
                     // and then you'll have the integration ID available to hydrate from.
-                    console.log(
-                        `[QueueWorker] no processId/integrationId — running dry instance`,
-                        logCtx
-                    );
                     integrationInstance = new integrationClass();
                 }
 
@@ -218,17 +188,14 @@ const createQueueWorker = (integrationClass) => {
                     integrationInstance
                 );
 
-                console.log(`[QueueWorker] dispatching ${params.event}`, logCtx);
-                const result = await dispatcher.dispatchJob({
+                return await dispatcher.dispatchJob({
                     event: params.event,
                     data: params.data,
                     context: context,
                 });
-                console.log(`[QueueWorker] ${params.event} dispatched ok`, logCtx);
-                return result;
             } catch (error) {
                 console.error(
-                    `Error in ${params.event} for ${integrationName}:`,
+                    `Error in ${params.event} for ${integrationClass.Definition.name}:`,
                     error
                 );
 
@@ -240,12 +207,7 @@ const createQueueWorker = (integrationClass) => {
                 if (status && status >= 400 && status < 500 && status !== 408 && status !== 429) {
                     error.isHaltError = true;
                     console.warn(
-                        `[${integrationName}] Permanent ${status} error for ${params.event} — message will be discarded (no retry)`,
-                        {
-                            ...logCtx,
-                            errorName: error.name,
-                            errorMessage: error.message,
-                        }
+                        `[${integrationClass.Definition.name}] Permanent ${status} error for ${params.event} — message will be discarded (no retry)`
                     );
                 }
 

package/modules/requester/requester.js

@@ -3,6 +3,8 @@ const { Delegate } = require('../../core');
 const { FetchError } = require('../../errors');
 const { get } = require('../../assertions');
 
+const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
+
 class Requester extends Delegate {
     constructor(params) {
         super(params);
@@ -13,6 +15,30 @@ class Requester extends Delegate {
         this.delegateTypes.push(this.DLGT_INVALID_AUTH);
         this.agent = get(params, 'agent', null);
 
+        // Per-attempt HTTP timeout. Without this the framework called fetch()
+        // with no AbortController and no timeout — a silently-hung TCP
+        // connection (server accepts but never responds) blocked the calling
+        // promise forever, cascading into stalled batches, stalled syncs,
+        // and worker-lambda timeouts.
+        //
+        // Configuration precedence:
+        //   1. Instance param:   new Requester({ requestTimeoutMs: 30_000 })
+        //   2. Class static:     static requestTimeoutMs = 30_000
+        //   3. Default:          DEFAULT_REQUEST_TIMEOUT_MS (60s)
+        //
+        // Pass 0 (or null) to disable the timeout entirely — reserved for
+        // test doubles and documented long-running endpoints.
+        // Intentionally NOT using `get(params, ...)` here — the Frigg
+        // `get` helper throws RequiredPropertyError if the key is missing
+        // and no default is provided, which would collide with the fall-
+        // through to the class-level static override.
+        const instanceTimeout = params?.requestTimeoutMs;
+        this.requestTimeoutMs =
+            instanceTimeout !== undefined && instanceTimeout !== null
+                ? instanceTimeout
+                : this.constructor.requestTimeoutMs ??
+                  DEFAULT_REQUEST_TIMEOUT_MS;
+
         // Allow passing in the fetch function
         // Instance methods can use this.fetch without differentiating
         this.fetch = get(params, 'fetch', fetch);
@@ -48,52 +74,134 @@ class Requester extends Delegate {
 
         if (this.agent) options.agent = this.agent;
 
-        let response;
+        // Per-attempt timeout — fresh AbortController per call so the retry
+        // recursion (with its own backoff sleeps) always gets a clean
+        // signal. Timer is cleared in the finally block regardless of
+        // outcome.
+        const timeoutMs = this.requestTimeoutMs;
+        const controller = timeoutMs > 0 ? new AbortController() : null;
+        const timeoutHandle = controller
+            ? setTimeout(() => controller.abort(), timeoutMs)
+            : null;
+        const fetchOptions = controller
+            ? { ...options, signal: controller.signal }
+            : options;
+
+        // Timer must stay active through body consumption. node-fetch v2
+        // resolves the fetch() promise when headers arrive, not when the
+        // body is fully read — so a server that sends headers and then
+        // stalls the body would still hang parsedBody() or
+        // FetchError.create()'s response.text() call. We clear the timer
+        // only after the body is fully consumed (success path) or
+        // deliberately before each recursive retry so the new attempt
+        // starts with its own fresh timer.
+        let timerCleared = false;
+        const clearRequestTimer = () => {
+            if (!timerCleared && timeoutHandle) {
+                clearTimeout(timeoutHandle);
+                timerCleared = true;
+            }
+        };
+
         try {
-            response = await this.fetch(encodedUrl, options);
-        } catch (e) {
-            if (e.code === 'ECONNRESET' && i < this.backOff.length) {
+            let response;
+            try {
+                response = await this.fetch(encodedUrl, fetchOptions);
+            } catch (e) {
+                // AbortController fires AbortError (name) / ETIMEDOUT-shaped
+                // errors (type on node-fetch) when we hit the timeout. No
+                // retry on timeout: a slow endpoint is a downstream problem,
+                // and each retry would wait another `timeoutMs` before giving
+                // up — amplifying the hang into a per-record multi-minute
+                // stall at batch scale.
+                const isTimeout =
+                    e?.name === 'AbortError' || e?.type === 'aborted';
+                if (e?.code === 'ECONNRESET' && i < this.backOff.length) {
+                    clearRequestTimer();
+                    const delay = this.backOff[i] * 1000;
+                    await new Promise((resolve) =>
+                        setTimeout(resolve, delay)
+                    );
+                    return this._request(url, options, i + 1);
+                }
+                const fetchError = await FetchError.create({
+                    resource: encodedUrl,
+                    init: options,
+                    responseBody: isTimeout
+                        ? `Request timed out after ${timeoutMs}ms`
+                        : e,
+                });
+                if (isTimeout) {
+                    // Flag + machine-readable fields so callers can
+                    // distinguish a timeout from a generic network error
+                    // without parsing the message (which FetchError
+                    // sanitizes outside of STAGE=dev).
+                    fetchError.isTimeout = true;
+                    fetchError.timeoutMs = timeoutMs;
+                }
+                throw fetchError;
+            }
+
+            const { status } = response;
+
+            // If the status is retriable and there are back off requests left, retry the request
+            if ((status === 429 || status >= 500) && i < this.backOff.length) {
+                clearRequestTimer();
                 const delay = this.backOff[i] * 1000;
                 await new Promise((resolve) => setTimeout(resolve, delay));
                 return this._request(url, options, i + 1);
-            }
-            throw await FetchError.create({
-                resource: encodedUrl,
-                init: options,
-                responseBody: e,
-            });
-        }
-        const { status } = response;
-
-        // If the status is retriable and there are back off requests left, retry the request
-        if ((status === 429 || status >= 500) && i < this.backOff.length) {
-            const delay = this.backOff[i] * 1000;
-            await new Promise((resolve) => setTimeout(resolve, delay));
-            return this._request(url, options, i + 1);
-        } else if (status === 401) {
-            if (!this.isRefreshable || this.refreshCount > 0) {
-                await this.notify(this.DLGT_INVALID_AUTH);
-            } else {
-                this.refreshCount++;
-                const refreshSucceeded = await this.refreshAuth();
-                if (refreshSucceeded) {
-                    return this._request(url, options, i + 1);
+            } else if (status === 401) {
+                if (!this.isRefreshable || this.refreshCount > 0) {
+                    await this.notify(this.DLGT_INVALID_AUTH);
+                } else {
+                    this.refreshCount++;
+                    const refreshSucceeded = await this.refreshAuth();
+                    if (refreshSucceeded) {
+                        clearRequestTimer();
+                        return this._request(url, options, i + 1);
+                    }
                 }
             }
-        }
 
-        // If the error wasn't retried, throw.
-        if (status >= 400) {
-            throw await FetchError.create({
-                resource: encodedUrl,
-                init: options,
-                response,
-            });
+            // If the error wasn't retried, throw. FetchError.create reads
+            // the response body (response.text()) — timer must still be
+            // alive to catch a stalled body stream.
+            if (status >= 400) {
+                const fetchError = await FetchError.create({
+                    resource: encodedUrl,
+                    init: options,
+                    response,
+                });
+                throw this._maybeFlagTimeoutDuringBodyRead(
+                    fetchError,
+                    timeoutMs
+                );
+            }
+
+            // parsedBody consumes the response body stream. If the server
+            // stalls mid-stream the timer (still armed) aborts it.
+            return options.returnFullRes
+                ? response
+                : await this.parsedBody(response);
+        } catch (e) {
+            // If the abort fired during body consumption, node-fetch emits
+            // the error as an AbortError on the body stream. Surface the
+            // same isTimeout flag callers use for header-phase timeouts.
+            throw this._maybeFlagTimeoutDuringBodyRead(e, timeoutMs);
+        } finally {
+            clearRequestTimer();
         }
+    }
 
-        return options.returnFullRes
-            ? response
-            : await this.parsedBody(response);
+    _maybeFlagTimeoutDuringBodyRead(err, timeoutMs) {
+        if (!err || typeof err !== 'object') return err;
+        if (err.isTimeout) return err;
+        const isAbort =
+            err.name === 'AbortError' || err.type === 'aborted';
+        if (!isAbort) return err;
+        err.isTimeout = true;
+        err.timeoutMs = timeoutMs;
+        return err;
     }
 
     async _get(options) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.578.3f8e78e.0",
+    "version": "2.0.0--canary.579.312fe8b.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -38,9 +38,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.578.3f8e78e.0",
-        "@friggframework/prettier-config": "2.0.0--canary.578.3f8e78e.0",
-        "@friggframework/test": "2.0.0--canary.578.3f8e78e.0",
+        "@friggframework/eslint-config": "2.0.0--canary.579.312fe8b.0",
+        "@friggframework/prettier-config": "2.0.0--canary.579.312fe8b.0",
+        "@friggframework/test": "2.0.0--canary.579.312fe8b.0",
         "@prisma/client": "^6.17.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -80,5 +80,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "3f8e78e2186c5d793aeffe803a2687ea0644fba1"
+    "gitHead": "312fe8be9f6afce4d78c1af5f13b03e0a5595cd6"
 }

package/queues/queuer-util.js

@@ -18,88 +18,13 @@ const awsConfigOptions = () => {
 
 const sqs = new SQSClient(awsConfigOptions());
 
-// Best-effort extraction of the logical event/processId/integrationId from a
-// JSON message body. Used only for log correlation — never throws.
-const summarizeMessageBody = (bodyStr) => {
-    try {
-        const parsed = JSON.parse(bodyStr);
-        return {
-            event: parsed?.event,
-            processId: parsed?.data?.processId,
-            integrationId: parsed?.data?.integrationId,
-        };
-    } catch {
-        return {};
-    }
-};
-
-// Inspect SendMessageBatchResult for partial failures and log them.
-// AWS SendMessageBatch can succeed at the HTTP level while individual entries
-// are rejected (KMS errors, per-entry throttling, service errors). Callers that
-// don't inspect result.Failed silently lose those messages. This logs the
-// details — including the logical event/processId of the failed entry — so
-// the loss is visible and correlatable in CloudWatch.
-const inspectBatchResult = (result, queueUrl, buffer) => {
-    const bufferSize = buffer.length;
-    const failedCount = result?.Failed?.length ?? 0;
-    const successCount = result?.Successful?.length ?? 0;
-
-    // Index buffer by Id so we can attach event/processId to failures.
-    const bufferById = new Map(buffer.map((b) => [b.Id, b]));
-
-    if (failedCount > 0) {
-        console.error(
-            `[QueuerUtil] SendMessageBatch partial failure: ${failedCount}/${bufferSize} failed`,
-            {
-                queueUrl,
-                bufferSize,
-                successCount,
-                failedCount,
-                failed: result.Failed.map((f) => {
-                    const bufEntry = bufferById.get(f.Id);
-                    const summary = bufEntry
-                        ? summarizeMessageBody(bufEntry.MessageBody)
-                        : {};
-                    return {
-                        Id: f.Id,
-                        Code: f.Code,
-                        SenderFault: f.SenderFault,
-                        Message: f.Message,
-                        ...summary,
-                    };
-                }),
-            }
-        );
-    } else if (successCount > 0) {
-        // Include a compact per-entry summary so operators can correlate
-        // "which send contained which logical message" during incident triage.
-        const entries = result.Successful.map((s) => {
-            const bufEntry = bufferById.get(s.Id);
-            const summary = bufEntry
-                ? summarizeMessageBody(bufEntry.MessageBody)
-                : {};
-            return { MessageId: s.MessageId, ...summary };
-        });
-        console.log(
-            `[QueuerUtil] SendMessageBatch ok: ${successCount}/${bufferSize} to ${queueUrl}`,
-            { entries }
-        );
-    }
-
-    return result;
-};
-
 const QueuerUtil = {
     send: async (message, queueUrl) => {
         const command = new SendMessageCommand({
             MessageBody: JSON.stringify(message),
             QueueUrl: queueUrl,
         });
-        const result = await sqs.send(command);
-        console.log(
-            `[QueuerUtil] SendMessage ok: MessageId=${result?.MessageId} to ${queueUrl}`
-        );
-        return result;
+        return sqs.send(command);
     },
 
     batchSend: async (entries = [], queueUrl) => {
@@ -117,8 +42,7 @@ const QueuerUtil = {
                     Entries: buffer,
                     QueueUrl: queueUrl,
                 });
-                const result = await sqs.send(command);
-                inspectBatchResult(result, queueUrl, buffer);
+                await sqs.send(command);
                 // Purge the buffer
                 buffer.splice(0, buffer.length);
             }
@@ -130,8 +54,7 @@ const QueuerUtil = {
                 Entries: buffer,
                 QueueUrl: queueUrl,
             });
-            const result = await sqs.send(command);
-            return inspectBatchResult(result, queueUrl, buffer);
+            return sqs.send(command);
         }
 
         // If we're exact... just return an empty object for now