@friggframework/core 2.0.0--canary.654.be44e66.0 → 2.0.0--canary.654.ebad223.0

package/.eslintrc.json

@@ -1,3 +1,20 @@
 {
-    "extends": "@friggframework/eslint-config"
+    "extends": "@friggframework/eslint-config",
+    "rules": {
+        "no-restricted-syntax": [
+            "warn",
+            {
+                "selector": "CallExpression[callee.object.object.name='process'][callee.object.property.name=/^(stdout|stderr)$/][callee.property.name='write']",
+                "message": "Write through the logger; only logs/sinks.js writes to fd 1 (ADR-048 §14)"
+            }
+        ]
+    },
+    "overrides": [
+        {
+            "files": ["*.test.js", "database/utils/prisma-runner.js"],
+            "rules": {
+                "no-restricted-syntax": "off"
+            }
+        }
+    ]
 }

package/core/Worker.js

@@ -3,8 +3,10 @@ const _ = require('lodash');
 const { RequiredPropertyError } = require('../errors');
 const { get } = require('../assertions');
 const { runMessageScope } = require('./invocation-scope');
+const { getLogger } = require('../logs');
 
 const sqs = new SQSClient({ region: process.env.AWS_REGION });
+const log = getLogger('frigg.worker');
 
 class Worker {
     async getQueueURL(params) {
@@ -27,43 +29,32 @@ class Worker {
 
         for (const record of records) {
             await runMessageScope(record, async () => {
-                // 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,
-                });
+                // messageId, receiveCount and the event come from the scope.
+                log.debug('Record started', { eventName: 'frigg.worker.record_started' });
 
                 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,
-                    });
+                    log.debug('Record succeeded', { eventName: 'frigg.worker.record_succeeded' });
                 } 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,
+                        log.error('Record halted (discarded, no retry)', {
+                            eventName: 'frigg.worker.record_halted',
                             statusCode: error.statusCode,
+                            error,
                         });
                         return;
                     }
-                    console.error(`[Worker] Failed to process record ${record.messageId}:`, error);
+                    // The message goes back to SQS, so WARN (ADR-048 §4).
+                    log.warn('Record failed, returned for retry', {
+                        eventName: 'frigg.worker.record_failed',
+                        error,
+                    });
                     batchItemFailures.push({ itemIdentifier: record.messageId });
                 }
             });

package/core/create-handler.js

@@ -6,6 +6,7 @@ const { getLogger, toSanitizedSurrogate } = require('../logs');
 const {
     summarizeLambdaEvent,
     toScopeInvocation,
+    toRequestInvocation,
 } = require('../logs/summarize-event');
 const {
     runInvocationScope,
@@ -57,6 +58,8 @@ const createHandler = (optionByName = {}) => {
             routeKey: eventSummary.routeKey,
             invocation: toScopeInvocation(eventSummary),
         };
+        // The full redacted summary goes only on the entry and failure records.
+        const requestInvocation = toRequestInvocation(eventSummary);
 
         return runInvocationScope(
             scopeFields,
@@ -64,6 +67,7 @@ const createHandler = (optionByName = {}) => {
                 try {
                     log.info('Handler invoked', {
                         eventName: 'frigg.handler.invoked',
+                        invocation: requestInvocation,
                     });
 
                     // If enabled (i.e. if SECRET_ARN is set in process.env) Fetch secrets from AWS Secrets Manager, and set them as environment variables.
@@ -84,45 +88,28 @@ const createHandler = (optionByName = {}) => {
                     // Run the Lambda
                     return await method(event, context);
                 } catch (error) {
-                    // Don't leak implementation details to end users.
-                    if (isUserFacingResponse) {
-                        // Allow client-safe errors to pass through with their actual message
-                        if (error.isClientSafe === true) {
-                            const statusCode = error.statusCode || 400;
-                            log.warn('Request rejected', {
-                                eventName: 'frigg.handler.rejected',
-                                statusCode,
-                                error,
-                            });
-                            return {
-                                statusCode,
-                                body: JSON.stringify({
-                                    error: error.message,
-                                }),
-                            };
-                        }
-
-                        log.error('Handler failed', {
-                            eventName: 'frigg.handler.failed',
+                    // Allow client-safe errors to pass through with their actual message
+                    if (isUserFacingResponse && error.isClientSafe === true) {
+                        const statusCode = error.statusCode || 400;
+                        log.warn('Request rejected', {
+                            eventName: 'frigg.handler.rejected',
+                            statusCode,
                             error,
                         });
-
-                        // Hide other errors with generic message
                         return {
-                            statusCode: 500,
+                            statusCode,
                             body: JSON.stringify({
-                                error: 'An Internal Error Occurred',
+                                error: error.message,
                             }),
                         };
                     }
 
-                    // Handle server-to-server responses.
-
-                    // Halt errors succeed and won't be retried, so the halt
-                    // itself is the failure record.
-                    if (error.isHaltError === true) {
+                    // Server-to-server: halt errors succeed and won't be
+                    // retried, so the halt itself is the failure record.
+                    if (!isUserFacingResponse && error.isHaltError === true) {
                         log.error('Handler halted', {
                             eventName: 'frigg.handler.halted',
+                            invocation: requestInvocation,
                             error,
                         });
                         return;
@@ -130,8 +117,20 @@ const createHandler = (optionByName = {}) => {
 
                     log.error('Handler failed', {
                         eventName: 'frigg.handler.failed',
+                        invocation: requestInvocation,
                         error,
                     });
+
+                    // Don't leak implementation details to end users.
+                    if (isUserFacingResponse) {
+                        return {
+                            statusCode: 500,
+                            body: JSON.stringify({
+                                error: 'An Internal Error Occurred',
+                            }),
+                        };
+                    }
+
                     // The Lambda runtime writes a rethrown error itself, so
                     // rethrow a sanitized copy (ADR-048 §6 item 11).
                     throw toSanitizedSurrogate(error);

package/handlers/app-definition-loader.js

@@ -3,6 +3,7 @@ const path = require('node:path');
 const fs = require('fs-extra');
 const { resolveTelemetryConfig } = require('../telemetry/telemetry-config');
 const { addDeniedKeys } = require('../logs/redact');
+const { getLogger } = require('../logs');
 const {
     extractCredentialFieldsFromModules,
 } = require('../database/encryption/encryption-schema-registry');
@@ -12,18 +13,32 @@ const {
 
 // Handlers without a database never load the encryption registry, so the
 // credential leaf keys are registered for redaction here too.
+const warnedIgnoredKeys = new Set();
+
+function warnIgnoredKeys(ignored) {
+    for (const key of ignored) {
+        if (warnedIgnoredKeys.has(key)) continue;
+        warnedIgnoredKeys.add(key);
+        getLogger('frigg.logger').warn(
+            'Credential field name is a record field; it stays visible in logs',
+            { eventName: 'frigg.logger.denied_key_ignored', key }
+        );
+    }
+}
+
 function registerCredentialLogKeys(appDefinition, integrations) {
     try {
-        extractCredentialFieldsFromModules(
+        const fields = extractCredentialFieldsFromModules(
             getModulesDefinitionFromIntegrationClasses(integrations)
         );
+        warnIgnoredKeys(addDeniedKeys(fields));
     } catch {
         // An odd integration shape must not stop the app from loading.
     }
     const schema = appDefinition.encryption?.schema;
     if (schema && typeof schema === 'object') {
         for (const config of Object.values(schema)) {
-            addDeniedKeys(config?.fields);
+            warnIgnoredKeys(addDeniedKeys(config?.fields));
         }
     }
 }

package/handlers/app-handler-helpers.js

@@ -1,5 +1,6 @@
 const { createHandler } = require('@friggframework/core');
 const { getLogger } = require('../logs');
+const { summarizeExpressRequest } = require('../logs/summarize-event');
 const express = require('express');
 const bodyParser = require('body-parser');
 const cors = require('cors');
@@ -35,14 +36,16 @@ const createApp = (applyMiddleware) => {
             log.error('Request failed', {
                 eventName: 'frigg.http.request_failed',
                 statusCode,
+                invocation: summarizeExpressRequest(req),
                 error: boomError,
             });
             res.status(statusCode).json({ error: 'Internal Server Error' });
         } else {
+            // A client error needs no stack; the logger scrubs the reason.
             log.warn('Request rejected', {
                 eventName: 'frigg.http.request_rejected',
                 statusCode,
-                error: boomError,
+                reason: boomError.message,
             });
             res.status(statusCode).json({ error: err.message });
         }

package/handlers/backend-utils.js

@@ -273,11 +273,6 @@ const createQueueWorker = (integrationClass) => {
                     return;
                 }
 
-                console.error(
-                    `Error in ${params.event} for ${integrationName}:`,
-                    error
-                );
-
                 // 4xx HTTP errors are permanent — the requester already
                 // attempted token refresh (401) and backoff (429/5xx).
                 // By the time a 4xx reaches here, retrying won't help.

package/handlers/workers/dlq-processor.js

@@ -27,24 +27,22 @@ function extractQueueName(eventSourceARN) {
 // The body can hold credentials, so only its size and digest are logged.
 function describeBody(body) {
     const text = typeof body === 'string' ? body : String(body ?? '');
+    let parsed = true;
+    try {
+        JSON.parse(text);
+    } catch {
+        parsed = false;
+    }
     return {
+        parsed,
         bodyLength: Buffer.byteLength(text),
         bodySha256: crypto.createHash('sha256').update(text).digest('hex'),
     };
 }
 
-function isJson(body) {
-    try {
-        JSON.parse(body);
-        return true;
-    } catch {
-        return false;
-    }
-}
-
 function logRecord(record) {
-    const body = describeBody(record.body);
-    if (!isJson(record.body)) {
+    const { parsed, ...body } = describeBody(record.body);
+    if (!parsed) {
         log.warn('DLQ message body is not JSON', {
             eventName: 'frigg.queue.dlq.body_unparsed',
             ...body,

package/integrations/integration-base.js

@@ -778,7 +778,7 @@ class IntegrationBase {
                 if (this.events[eventName]) {
                     if (typeof handlers[eventName] === 'string') {
                         this.logger.warn(
-                            `Binding handler "${handlers[eventName]}" for event "${eventName}" is ignored because this.events["${eventName}"] was already set`,
+                            'Binding handler is ignored: the event is already set',
                             {
                                 eventName: `${this.logger.name}.extension_handler_shadowed`,
                                 bindingName,

package/logs/__fixtures__/vectors.js

@@ -7,6 +7,16 @@ const { summarizeLambdaEvent } = require('../summarize-event');
 const secretUrl = `https://api.example.com/v1/items?api_key=${S.apiKeyQuery}`;
 const SIGNATURE_VALUE = 'fakeSgnValue2Gh9Tc5Wp7LmQx3';
 
+// Built by concatenation so push protection does not match the prefixes.
+const TOKEN_TAIL = 'ZqPr3fixTail8Hn2Kd8Ws1Yc6';
+const PREFIXED_TOKENS = [
+    'sk_' + 'live_' + TOKEN_TAIL,
+    'whsec' + '_' + TOKEN_TAIL,
+    'xox' + 'b-' + TOKEN_TAIL,
+    'gh' + 'p_' + TOKEN_TAIL,
+    'AK' + 'IA' + 'ZQPR3FIXTAIL8HN2',
+];
+
 function errorWithMessage(message, name = 'Error') {
     const error = new Error(message);
     error.name = name;
@@ -188,6 +198,13 @@ function vectors() {
             fields: () => ({ note: `blob ${S.base64Run} end` }),
             secrets: [S.base64Run],
         },
+        {
+            name: 'provider token prefixes',
+            level: 'warn',
+            message: () => `provider rejected ${PREFIXED_TOKENS.join(' and ')}`,
+            fields: () => ({ note: PREFIXED_TOKENS.join(',') }),
+            secrets: PREFIXED_TOKENS,
+        },
         {
             name: '40-hex token',
             level: 'error',

package/logs/debug-shims.js

@@ -1,7 +1,10 @@
 const util = require('node:util');
 const { getLogger } = require('./logger');
 const { getContext } = require('./context');
-const { summarizeLambdaEvent, toScopeInvocation } = require('./summarize-event');
+const {
+    summarizeLambdaEvent,
+    toRequestInvocation,
+} = require('./summarize-event');
 
 // Deprecated. Kept for one major version; use getLogger or this.logger.
 const LEGACY_LOGGER_NAME = 'frigg.legacy';
@@ -29,7 +32,7 @@ function initDebugLog(...initMessages) {
     if (!log.isLevelEnabled('DEBUG')) return;
     const event = initMessages.find((m) => m && typeof m === 'object');
     log.debug('Debug log initialized', {
-        invocation: toScopeInvocation(summarizeLambdaEvent(event)),
+        invocation: toRequestInvocation(summarizeLambdaEvent(event)),
     });
 }
 

package/logs/record.js

@@ -78,6 +78,29 @@ function buildMessage(message, callSite) {
     return '[non-string message]';
 }
 
+const INVOCATION_KEY = 'invocation';
+
+function isPlainObject(value) {
+    return (
+        value !== null &&
+        typeof value === 'object' &&
+        Object.getPrototypeOf(value) === Object.prototype
+    );
+}
+
+// A boundary adds request detail to the scope's invocation; scope keys win.
+function extendInvocation(scoped, detail, dropped) {
+    const merged = { ...scoped };
+    for (const [key, value] of Object.entries(detail)) {
+        if (!Object.prototype.hasOwnProperty.call(scoped, key)) {
+            merged[key] = value;
+        } else if (JSON.stringify(scoped[key]) !== JSON.stringify(value)) {
+            dropped.add(`${INVOCATION_KEY}.${key}`);
+        }
+    }
+    return merged;
+}
+
 function traceFields(spanContext) {
     if (
         !spanContext ||
@@ -135,7 +158,8 @@ function buildRecord({
                 OWNED_KEYS.has(key) ||
                 RESERVED_KEYS.has(key) ||
                 (dropPayloads && PAYLOAD_KEYS.has(key)) ||
-                Object.prototype.hasOwnProperty.call(record, key)
+                (Object.prototype.hasOwnProperty.call(record, key) &&
+                    !canExtendInvocation(key, value))
             ) {
                 dropped.add(key);
                 continue;
@@ -149,10 +173,18 @@ function buildRecord({
             const value =
                 key === 'error' ? serializeError(accepted[key]) : safe?.[key];
             if (value === undefined || value === null) continue;
+            if (key === INVOCATION_KEY && isPlainObject(record[key])) {
+                record[key] = extendInvocation(record[key], value, dropped);
+                continue;
+            }
             record[key] = value;
             if (isCallSite) callSiteKeys.push(key);
         }
     };
+    const canExtendInvocation = (key, value) =>
+        key === INVOCATION_KEY &&
+        isPlainObject(record[key]) &&
+        isPlainObject(value);
     place(readFields(scope), false);
     place(readFields(bindings), false);
     place(callSite, true);

package/logs/redact.js

@@ -14,8 +14,8 @@ const DENIED_SUFFIXES = [
 ];
 
 // Core encryption registry leaves and exact names the suffix rule does not
-// cover. `header` is Node's raw `_header` request text. `domain` stays
-// allowed: it is too common a key.
+// cover. `header` is Node's raw `_header` request text. `domain` is not
+// seeded (too common); a module can still register it as a credential field.
 const deniedKeys = new Set([
     'hashword',
     'cookies',
@@ -25,6 +25,29 @@ const deniedKeys = new Set([
     'header',
 ]);
 
+// Record-contract fields. A credential field with one of these names must not
+// blank the field in every record.
+const PROTECTED_KEYS = new Set(
+    [
+        'integrationId',
+        'integrationType',
+        'userId',
+        'version',
+        'entityId',
+        'credentialId',
+        'requestId',
+        'messageId',
+        'processId',
+        'integrationEvent',
+        'eventName',
+        'handlerName',
+        'method',
+        'route',
+        'routeKey',
+        'statusCode',
+    ].map((key) => key.toLowerCase())
+);
+
 const PAIR_KEYS = new Set(['code', 'codeverifier']);
 const DIGEST_KEY = /(sha(1|256)|hash|digest|checksum)$/;
 
@@ -33,7 +56,11 @@ const MAX_SCRUB_INPUT = 65536;
 const URL_IN_TEXT = /\b[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^\s"'<>`]+/g;
 const URL_TRAILING_PUNCT = /[.,;:!?)\]}]+$/;
 const ABSOLUTE_URL = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//;
-const ROOT_SLASH = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^/?#]*\//;
+const RAW_ABSOLUTE_PATH = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^/?#]*([^?#]*)/;
+const RAW_RELATIVE_PATH = /^[^?#]*/;
+const PATH_TOKEN_SEGMENT = /^[A-Za-z0-9_.~-]{20,}$/;
+const PREFIXED_TOKEN =
+    /(?<![A-Za-z0-9_-])(?:(?:sk|rk)_(?:live|test)_|whsec_|xox[abprs]-|gh[opsu]_|github_pat_|shp(?:at|ss)_|glpat-|npm_)[A-Za-z0-9_-]{16,}|\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g;
 const JWT = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g;
 const AUTH_SCHEME = /\b(Bearer|bearer|BEARER|Basic|basic|BASIC|Token|token|TOKEN)(\s+)([A-Za-z0-9._~+/=-]{8,})/g;
 const AUTH_SCHEME_WORD = /^(bearer|basic|token)$/i;
@@ -62,7 +89,7 @@ function normalizeKey(key) {
 
 function isDeniedKey(key) {
     const normalized = normalizeKey(key);
-    if (!normalized) return false;
+    if (!normalized || PROTECTED_KEYS.has(normalized)) return false;
     if (deniedKeys.has(normalized)) return true;
     return DENIED_SUFFIXES.some((suffix) => normalized.endsWith(suffix));
 }
@@ -80,13 +107,19 @@ function isPairKey(key, { withState = false } = {}) {
     );
 }
 
+// Returns the leaves it skipped as record-contract keys, so a caller can warn.
 function addDeniedKeys(keys) {
-    if (!Array.isArray(keys)) return;
+    const ignored = [];
+    if (!Array.isArray(keys)) return ignored;
     for (const key of keys) {
         if (typeof key !== 'string') continue;
-        const leaf = normalizeKey(key.split('.').pop());
-        if (leaf) deniedKeys.add(leaf);
+        const rawLeaf = key.split('.').pop();
+        const leaf = normalizeKey(rawLeaf);
+        if (!leaf) continue;
+        if (PROTECTED_KEYS.has(leaf)) ignored.push(rawLeaf);
+        else deniedKeys.add(leaf);
     }
+    return ignored;
 }
 
 function hasMixedClasses(run) {
@@ -107,7 +140,8 @@ function isRedactedValue(value) {
 }
 
 function scrubTokens(text, { allowHex = false, segment = false } = {}) {
-    let out = text.replace(JWT, redacted);
+    let out = text.replace(PREFIXED_TOKEN, redacted);
+    out = out.replace(JWT, redacted);
     out = out.replace(AUTH_SCHEME, (match, scheme, space, credential) => {
         const classes = [/[A-Z]/, /[a-z]/, /[0-9]/, /[._~+/=-]/].filter((re) =>
             re.test(credential)
@@ -164,11 +198,18 @@ function redactHash(hash) {
     return scrubTokens(hash);
 }
 
+// A long segment mixing upper case, lower case and digits is an opaque
+// token (webhook secrets live in paths); hex ids and UUIDs lack one class.
+function redactPathSegment(segment) {
+    if (PATH_TOKEN_SEGMENT.test(segment) && hasMixedClasses(segment)) {
+        return redacted(segment);
+    }
+    return scrubTokens(segment, { segment: true });
+}
+
+// The raw path, not URL#pathname, which percent-encodes `{proxy+}`.
 function redactPath(pathname) {
-    return pathname
-        .split('/')
-        .map((segment) => scrubTokens(segment, { segment: true }))
-        .join('/');
+    return pathname.split('/').map(redactPathSegment).join('/');
 }
 
 function redactUrlFallback(raw) {
@@ -189,8 +230,7 @@ function redactUrl(url) {
     try {
         if (ABSOLUTE_URL.test(raw)) {
             const u = new URL(raw);
-            const path =
-                u.pathname === '/' && !ROOT_SLASH.test(raw) ? '' : u.pathname;
+            const path = raw.match(RAW_ABSOLUTE_PATH)[1];
             return `${u.protocol}//${u.host}${redactPath(path)}${redactParams(
                 u.search,
                 '?'
@@ -198,7 +238,7 @@ function redactUrl(url) {
         }
         if (raw.startsWith('/')) {
             const u = new URL(raw, 'http://relative.invalid');
-            return `${redactPath(u.pathname)}${redactParams(
+            return `${redactPath(raw.match(RAW_RELATIVE_PATH)[0])}${redactParams(
                 u.search,
                 '?'
             )}${redactHash(u.hash)}`;

package/logs/summarize-event.js

@@ -1,3 +1,5 @@
+const { redactUrl } = require('./redact');
+
 // Best-effort extraction of the logical event/processId/integrationId from a
 // JSON message body. Used only for log correlation. Never throws.
 function summarizeMessageBody(bodyStr) {
@@ -32,13 +34,26 @@ function unique(list) {
     return [...new Set(list)];
 }
 
+// The route template keeps ids out of the field: REST v1 `resource`, or the
+// path part of an HTTP API v2 `routeKey` such as `GET /api/{id}`.
+function routeTemplate(event, path) {
+    if (typeof event.resource === 'string' && event.resource) {
+        return event.resource;
+    }
+    if (typeof event.routeKey === 'string') {
+        const space = event.routeKey.indexOf(' ');
+        if (space > 0) return event.routeKey.slice(space + 1);
+    }
+    return path;
+}
+
 function summarizeHttp(event) {
     const path = event.path || event.rawPath;
     const summary = {
         source: 'http',
         method: event.httpMethod || event.requestContext?.http?.method,
         path,
-        route: path,
+        route: routeTemplate(event, path),
         queryKeys: unique([
             ...objectKeys(event.queryStringParameters),
             ...objectKeys(event.multiValueQueryStringParameters),
@@ -98,8 +113,6 @@ function toScopeInvocation(summary) {
             source: 'http',
             method: summary.method,
             route: summary.route,
-            queryKeys: summary.queryKeys ?? [],
-            headerNames: summary.headerNames ?? [],
         };
         if (summary.routeKey) invocation.routeKey = summary.routeKey;
         return invocation;
@@ -107,4 +120,43 @@ function toScopeInvocation(summary) {
     return { source: summary.source };
 }
 
-module.exports = { summarizeLambdaEvent, summarizeMessageBody, toScopeInvocation };
+// Per-request detail for the entry and failure records, never for the
+// scope. A raw path can hold a token, so it goes through redactUrl.
+function toRequestDetails(summary) {
+    if (!summary || summary.source !== 'http') return {};
+    return {
+        path: redactUrl(summary.path ?? ''),
+        queryKeys: summary.queryKeys ?? [],
+        headerNames: summary.headerNames ?? [],
+    };
+}
+
+// The full redacted request summary (ADR-048 §6: it goes under `invocation`).
+function toRequestInvocation(summary) {
+    return { ...toScopeInvocation(summary), ...toRequestDetails(summary) };
+}
+
+// The same shape from an express request, for the express error boundary.
+function summarizeExpressRequest(req) {
+    try {
+        if (!req || typeof req !== 'object') return { source: 'http' };
+        return {
+            source: 'http',
+            method: req.method,
+            path: redactUrl(req.path ?? ''),
+            queryKeys: objectKeys(req.query),
+            headerNames: unique(objectKeys(req.headers).map((name) => name.toLowerCase())),
+        };
+    } catch {
+        return { source: 'http' };
+    }
+}
+
+module.exports = {
+    summarizeLambdaEvent,
+    summarizeMessageBody,
+    toScopeInvocation,
+    toRequestDetails,
+    toRequestInvocation,
+    summarizeExpressRequest,
+};

package/modules/module.js

@@ -32,7 +32,7 @@ class Module extends Delegate {
         this.credential = entityObj?.credential;
         this.definition = definition;
         this.name = this.definition.moduleName;
-        this.logger = getLogger(`module.${this.name}`).child(() => ({
+        this.logger = getLogger(`module.${this.name ?? 'unknown'}`).child(() => ({
             entityId: this.entity?.id,
             credentialId:
                 this.credential?.id ??

package/modules/requester/oauth-2.js

@@ -357,7 +357,7 @@ class OAuth2Requester extends Requester {
                 eventName: `${this.logger.name}.token_refresh_failed`,
                 statusCode:
                     error?.statusCode ?? error?.status ?? error?.response?.status,
-                error,
+                reason: error?.message,
             });
 
             if (!this._isDefinitiveAuthRejection(error)) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.654.be44e66.0",
+    "version": "2.0.0--canary.654.ebad223.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -47,9 +47,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.654.be44e66.0",
-        "@friggframework/prettier-config": "2.0.0--canary.654.be44e66.0",
-        "@friggframework/test": "2.0.0--canary.654.be44e66.0",
+        "@friggframework/eslint-config": "2.0.0--canary.654.ebad223.0",
+        "@friggframework/prettier-config": "2.0.0--canary.654.ebad223.0",
+        "@friggframework/test": "2.0.0--canary.654.ebad223.0",
         "@prisma/client": "^6.19.3",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -89,5 +89,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "be44e66226ec1db051c264a5f8cf02998f3aa14c"
+    "gitHead": "ebad2239696f6fbfd7918a327bdbd45c737dc7e0"
 }

package/user/repositories/user-repository-documentdb.js

@@ -148,13 +148,8 @@ class UserRepositoryDocumentDB extends UserRepositoryInterface {
 
         // Defensive check: verify document was found after insert
         if (!created) {
-            log.error('User not found after insert', {
-                eventName: 'frigg.user.not_found_after_insert',
-                insertedId: fromObjectId(insertedId),
-                paramKeys: Object.keys(params),
-            });
             throw new Error(
-                'Failed to create individual user: Document not found after insert. ' +
+                `Failed to create individual user: Document not found after insert (insertedId ${fromObjectId(insertedId)}). ` +
                     'This indicates a database consistency issue.'
             );
         }
@@ -192,13 +187,8 @@ class UserRepositoryDocumentDB extends UserRepositoryInterface {
 
         // Defensive check: verify document was found after insert
         if (!created) {
-            log.error('Organization user not found after insert', {
-                eventName: 'frigg.user.organization_not_found_after_insert',
-                insertedId: fromObjectId(insertedId),
-                paramKeys: Object.keys(params),
-            });
             throw new Error(
-                'Failed to create organization user: Document not found after insert. ' +
+                `Failed to create organization user: Document not found after insert (insertedId ${fromObjectId(insertedId)}). ` +
                     'This indicates a database consistency issue.'
             );
         }
@@ -284,7 +274,8 @@ class UserRepositoryDocumentDB extends UserRepositoryInterface {
         // Defensive check: verify document was found after update
         if (!updated) {
             throw new Error(
-                `Failed to update user ${userId}: not found after update`
+                'Failed to update individual user: Document not found after update. ' +
+                    'This indicates a database consistency issue.'
             );
         }
 
@@ -317,7 +308,8 @@ class UserRepositoryDocumentDB extends UserRepositoryInterface {
 
         if (!updated) {
             throw new Error(
-                `Failed to update user ${userId}: not found after update`
+                'Failed to update organization user: Document not found after update. ' +
+                    'This indicates a database consistency issue.'
             );
         }