@syncular/server-hono 0.0.2-138 → 0.0.2-140

package/dist/routes.js

@@ -25,6 +25,179 @@ const realtimeUnsubscribeMap = new WeakMap();
 const snapshotChunkParamsSchema = z.object({
     chunkId: z.string().min(1),
 });
+const MAX_REQUEST_PAYLOAD_SNAPSHOT_BYTES = 128 * 1024;
+function createOpaqueId(prefix) {
+    const randomPart = typeof crypto !== 'undefined' && 'randomUUID' in crypto
+        ? crypto.randomUUID()
+        : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    return `${prefix}-${randomPart}`;
+}
+function readRequestId(c) {
+    const headerRequestId = c.req.header('x-request-id')?.trim();
+    if (headerRequestId)
+        return headerRequestId;
+    return createOpaqueId('req');
+}
+function parseW3cTraceparent(traceparent) {
+    if (!traceparent)
+        return null;
+    const parsed = traceparent.trim();
+    const match = /^00-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/i.exec(parsed);
+    if (!match)
+        return null;
+    const traceId = match[1]?.toLowerCase() ?? null;
+    const spanId = match[2]?.toLowerCase() ?? null;
+    if (!traceId || !spanId)
+        return null;
+    return { traceId, spanId };
+}
+function parseSentryTraceHeader(sentryTrace) {
+    if (!sentryTrace)
+        return null;
+    const parsed = sentryTrace.trim();
+    const match = /^([0-9a-f]{32})-([0-9a-f]{16})(?:-[01])?$/i.exec(parsed);
+    if (!match)
+        return null;
+    const traceId = match[1]?.toLowerCase() ?? null;
+    const spanId = match[2]?.toLowerCase() ?? null;
+    if (!traceId || !spanId)
+        return null;
+    return { traceId, spanId };
+}
+function readTraceContext(c) {
+    const traceparent = parseW3cTraceparent(c.req.header('traceparent'));
+    if (traceparent)
+        return traceparent;
+    const sentryTrace = parseSentryTraceHeader(c.req.header('sentry-trace'));
+    if (sentryTrace)
+        return sentryTrace;
+    return { traceId: null, spanId: null };
+}
+function readStringField(data, key) {
+    const value = data[key];
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function readTraceContextFromMessage(msg) {
+    const directTraceId = readStringField(msg, 'traceId') ?? readStringField(msg, 'trace_id');
+    const directSpanId = readStringField(msg, 'spanId') ?? readStringField(msg, 'span_id');
+    if (directTraceId || directSpanId) {
+        return { traceId: directTraceId, spanId: directSpanId };
+    }
+    const traceparent = readStringField(msg, 'traceparent') ?? readStringField(msg, 'traceParent');
+    const parsedTraceparent = parseW3cTraceparent(traceparent);
+    if (parsedTraceparent)
+        return parsedTraceparent;
+    const sentryTrace = readStringField(msg, 'sentry-trace') ??
+        readStringField(msg, 'sentryTrace') ??
+        readStringField(msg, 'sentry_trace');
+    const parsedSentryTrace = parseSentryTraceHeader(sentryTrace);
+    if (parsedSentryTrace)
+        return parsedSentryTrace;
+    return { traceId: null, spanId: null };
+}
+function normalizeResponseStatus(statusCode, outcome) {
+    if (statusCode >= 500)
+        return 'server_error';
+    if (statusCode >= 400)
+        return 'client_error';
+    if (statusCode >= 300)
+        return 'redirect';
+    if (statusCode >= 200) {
+        if (outcome === 'error' || outcome === 'rejected')
+            return 'failure';
+        return 'success';
+    }
+    return 'unknown';
+}
+function firstPushErrorCode(results) {
+    if (!Array.isArray(results))
+        return null;
+    for (const result of results) {
+        if (!result || typeof result !== 'object')
+            continue;
+        const status = Reflect.get(result, 'status');
+        if (status !== 'error')
+            continue;
+        const code = Reflect.get(result, 'code');
+        if (typeof code === 'string' && code.length > 0) {
+            return code;
+        }
+    }
+    return null;
+}
+function summarizeScopeValues(scopes) {
+    const summary = {};
+    for (const [key, value] of Object.entries(scopes)) {
+        if (typeof value === 'string') {
+            summary[key] = value;
+            continue;
+        }
+        if (Array.isArray(value)) {
+            const normalized = value
+                .filter((entry) => typeof entry === 'string')
+                .slice(0, 20);
+            summary[key] = normalized;
+        }
+    }
+    return Object.keys(summary).length > 0 ? summary : null;
+}
+function summarizePullResponse(response) {
+    return {
+        subscriptions: response.subscriptions.map((subscription) => {
+            const changeCount = subscription.commits.reduce((totalChanges, commit) => totalChanges + commit.changes.length, 0);
+            const snapshotCount = subscription.snapshots?.length ?? 0;
+            const snapshotRowCount = subscription.snapshots?.reduce((totalRows, snapshot) => totalRows + snapshot.rows.length, 0) ?? 0;
+            return {
+                id: subscription.id,
+                status: subscription.status,
+                bootstrap: subscription.bootstrap,
+                nextCursor: subscription.nextCursor,
+                commitCount: subscription.commits.length,
+                changeCount,
+                snapshotCount,
+                snapshotRowCount,
+            };
+        }),
+    };
+}
+function countPullRows(response) {
+    return response.subscriptions.reduce((totalRows, subscription) => {
+        const commitRows = subscription.commits.reduce((totalChanges, commit) => totalChanges + commit.changes.length, 0);
+        const snapshotRows = subscription.snapshots?.reduce((totalSnapshotRows, snapshot) => totalSnapshotRows + snapshot.rows.length, 0) ?? 0;
+        return totalRows + commitRows + snapshotRows;
+    }, 0);
+}
+function encodePayloadSnapshot(value) {
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized.length <= MAX_REQUEST_PAYLOAD_SNAPSHOT_BYTES) {
+            return serialized;
+        }
+        return JSON.stringify({
+            truncated: true,
+            originalSizeBytes: serialized.length,
+            preview: serialized.slice(0, MAX_REQUEST_PAYLOAD_SNAPSHOT_BYTES),
+        });
+    }
+    catch {
+        return JSON.stringify({
+            truncated: false,
+            serializationError: 'Could not serialize payload snapshot',
+        });
+    }
+}
+function emitConsoleLiveEvent(emitter, type, data) {
+    if (!emitter)
+        return;
+    emitter.emit({
+        type,
+        timestamp: new Date().toISOString(),
+        data,
+    });
+}
 export function createSyncRoutes(options) {
     const routes = new Hono();
     routes.onError((error, c) => {
@@ -45,6 +218,7 @@ export function createSyncRoutes(options) {
     const maxPullLimitSnapshotRows = config.maxPullLimitSnapshotRows ?? 5000;
     const maxPullMaxSnapshotPages = config.maxPullMaxSnapshotPages ?? 10;
     const maxOperationsPerPush = config.maxOperationsPerPush ?? 200;
+    const consoleLiveEmitter = options.consoleLiveEmitter;
     // -------------------------------------------------------------------------
     // Optional WebSocket manager (scope-key based wake-ups)
     // -------------------------------------------------------------------------
@@ -89,18 +263,59 @@ export function createSyncRoutes(options) {
         realtimeUnsubscribeMap.set(routes, unsubscribe);
     }
     const recordRequestEvent = async (event) => {
+        let payloadRef = event.payloadRef ?? null;
+        if (event.payloadSnapshot) {
+            const nextPayloadRef = payloadRef ?? createOpaqueId('payload');
+            const nowIso = new Date().toISOString();
+            try {
+                await sql `
+          INSERT INTO sync_request_payloads (
+            payload_ref, partition_id, request_payload, response_payload, created_at
+          ) VALUES (
+            ${nextPayloadRef}, ${event.partitionId},
+            ${encodePayloadSnapshot(event.payloadSnapshot.request)},
+            ${encodePayloadSnapshot(event.payloadSnapshot.response)},
+            ${nowIso}
+          )
+          ON CONFLICT (payload_ref) DO UPDATE SET
+            partition_id = EXCLUDED.partition_id,
+            request_payload = EXCLUDED.request_payload,
+            response_payload = EXCLUDED.response_payload,
+            created_at = EXCLUDED.created_at
+        `.execute(options.db);
+                payloadRef = nextPayloadRef;
+            }
+            catch (error) {
+                payloadRef = null;
+                logAsyncFailureOnce('sync.request_payload_record_failed', {
+                    event: 'sync.request_payload_record_failed',
+                    userId: event.actorId,
+                    clientId: event.clientId,
+                    requestEventType: event.eventType,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
         const tablesValue = options.dialect.arrayToDb(event.tables ?? []);
+        const scopesSummaryValue = event.scopesSummary
+            ? JSON.stringify(event.scopesSummary)
+            : null;
         await sql `
       INSERT INTO sync_request_events (
-        event_type, actor_id, client_id, status_code, outcome,
-        duration_ms, commit_seq, operation_count, row_count,
-        tables, error_message, transport_path
+        partition_id, request_id, trace_id, span_id,
+        event_type, sync_path, actor_id, client_id, transport_path,
+        status_code, outcome, response_status, error_code,
+        duration_ms, commit_seq, operation_count, row_count, subscription_count,
+        scopes_summary, tables, error_message, payload_ref
       ) VALUES (
-        ${event.eventType}, ${event.actorId}, ${event.clientId},
-        ${event.statusCode}, ${event.outcome}, ${event.durationMs},
-        ${event.commitSeq ?? null}, ${event.operationCount ?? null},
-        ${event.rowCount ?? null}, ${tablesValue}, ${event.errorMessage ?? null},
-        ${event.transportPath}
+        ${event.partitionId}, ${event.requestId}, ${event.traceId ?? null},
+        ${event.spanId ?? null}, ${event.eventType}, ${event.syncPath},
+        ${event.actorId}, ${event.clientId}, ${event.transportPath},
+        ${event.statusCode}, ${event.outcome}, ${event.responseStatus},
+        ${event.errorCode ?? null}, ${event.durationMs}, ${event.commitSeq ?? null},
+        ${event.operationCount ?? null}, ${event.rowCount ?? null},
+        ${event.subscriptionCount ?? null}, ${scopesSummaryValue}, ${tablesValue},
+        ${event.errorMessage ?? null}, ${payloadRef}
       )
     `.execute(options.db);
     };
@@ -224,6 +439,8 @@ export function createSyncRoutes(options) {
         const partitionId = auth.partitionId ?? 'default';
         const body = c.req.valid('json');
         const clientId = body.clientId;
+        const requestId = readRequestId(c);
+        const traceContext = readTraceContext(c);
         let pushResponse;
         let pullResponse;
         // --- Push phase ---
@@ -259,16 +476,48 @@ export function createSyncRoutes(options) {
                 commitSeq: pushed.response.commitSeq,
             });
             recordRequestEventInBackground({
+                partitionId,
+                requestId,
+                traceId: traceContext.traceId,
+                spanId: traceContext.spanId,
                 eventType: 'push',
+                syncPath: 'http-combined',
                 actorId: auth.actorId,
                 clientId,
                 transportPath: readTransportPath(c),
                 statusCode: 200,
                 outcome: pushed.response.status,
+                responseStatus: normalizeResponseStatus(200, pushed.response.status),
                 durationMs: pushDurationMs,
+                errorCode: firstPushErrorCode(pushed.response.results),
                 commitSeq: pushed.response.commitSeq,
                 operationCount: pushOps.length,
                 tables: pushed.affectedTables,
+                payloadSnapshot: {
+                    request: {
+                        clientId,
+                        clientCommitId: body.push.clientCommitId,
+                        schemaVersion: body.push.schemaVersion,
+                        operations: body.push.operations,
+                    },
+                    response: pushed.response,
+                },
+            });
+            emitConsoleLiveEvent(consoleLiveEmitter, 'push', {
+                partitionId,
+                requestId,
+                traceId: traceContext.traceId,
+                spanId: traceContext.spanId,
+                actorId: auth.actorId,
+                clientId,
+                transportPath: readTransportPath(c),
+                syncPath: 'http-combined',
+                outcome: pushed.response.status,
+                statusCode: 200,
+                durationMs: pushDurationMs,
+                commitSeq: pushed.response.commitSeq ?? null,
+                operationCount: pushOps.length,
+                tables: pushed.affectedTables,
             });
             // WS notifications
             if (wsConnectionManager &&
@@ -301,6 +550,17 @@ export function createSyncRoutes(options) {
                     }
                 }
             }
+            if (pushed.response.ok === true &&
+                pushed.response.status === 'applied' &&
+                typeof pushed.response.commitSeq === 'number') {
+                emitConsoleLiveEvent(consoleLiveEmitter, 'commit', {
+                    partitionId,
+                    commitSeq: pushed.response.commitSeq,
+                    actorId: auth.actorId,
+                    clientId,
+                    affectedTables: pushed.affectedTables,
+                });
+            }
             pushResponse = pushed.response;
         }
         // --- Pull phase ---
@@ -363,7 +623,17 @@ export function createSyncRoutes(options) {
                 actorId: auth.actorId,
                 cursor: pullResult.clientCursor,
                 effectiveScopes: pullResult.effectiveScopes,
-            }).catch((error) => {
+            })
+                .then(() => {
+                emitConsoleLiveEvent(consoleLiveEmitter, 'client_update', {
+                    action: 'cursor_recorded',
+                    partitionId,
+                    actorId: auth.actorId,
+                    clientId,
+                    cursor: pullResult.clientCursor,
+                });
+            })
+                .catch((error) => {
                 logAsyncFailureOnce('sync.client_cursor_record_failed', {
                     event: 'sync.client_cursor_record_failed',
                     userId: auth.actorId,
@@ -381,13 +651,55 @@ export function createSyncRoutes(options) {
                 clientCursor: pullResult.clientCursor,
             });
             recordRequestEventInBackground({
+                partitionId,
+                requestId,
+                traceId: traceContext.traceId,
+                spanId: traceContext.spanId,
                 eventType: 'pull',
+                syncPath: 'http-combined',
                 actorId: auth.actorId,
                 clientId,
                 transportPath: readTransportPath(c),
                 statusCode: 200,
                 outcome: 'applied',
+                responseStatus: normalizeResponseStatus(200, 'applied'),
                 durationMs: pullDurationMs,
+                rowCount: countPullRows(pullResult.response),
+                subscriptionCount: request.subscriptions.length,
+                scopesSummary: summarizeScopeValues(pullResult.effectiveScopes),
+                payloadSnapshot: {
+                    request: {
+                        clientId,
+                        limitCommits: request.limitCommits,
+                        limitSnapshotRows: request.limitSnapshotRows,
+                        maxSnapshotPages: request.maxSnapshotPages,
+                        dedupeRows: request.dedupeRows,
+                        subscriptions: request.subscriptions.map((subscription) => ({
+                            id: subscription.id,
+                            table: subscription.table,
+                            scopes: subscription.scopes,
+                            cursor: subscription.cursor,
+                            bootstrapState: subscription.bootstrapState,
+                        })),
+                    },
+                    response: summarizePullResponse(pullResult.response),
+                },
+            });
+            emitConsoleLiveEvent(consoleLiveEmitter, 'pull', {
+                partitionId,
+                requestId,
+                traceId: traceContext.traceId,
+                spanId: traceContext.spanId,
+                actorId: auth.actorId,
+                clientId,
+                transportPath: readTransportPath(c),
+                syncPath: 'http-combined',
+                outcome: 'applied',
+                statusCode: 200,
+                durationMs: pullDurationMs,
+                rowCount: countPullRows(pullResult.response),
+                subscriptionCount: request.subscriptions.length,
+                clientCursor: pullResult.clientCursor,
             });
             pullResponse = pullResult.response;
         }
@@ -567,6 +879,14 @@ export function createSyncRoutes(options) {
                     connRef = conn;
                     unregister = wsConnectionManager.register(conn, initialScopeKeys);
                     conn.sendHeartbeat();
+                    emitConsoleLiveEvent(consoleLiveEmitter, 'client_update', {
+                        action: 'realtime_connected',
+                        actorId: auth.actorId,
+                        clientId,
+                        partitionId,
+                        transportPath: realtimeTransportPath,
+                        scopeCount: initialScopeKeys.length,
+                    });
                 },
                 onClose(_evt, _ws) {
                     unregister?.();
@@ -576,6 +896,12 @@ export function createSyncRoutes(options) {
                         event: 'sync.realtime.disconnect',
                         userId: auth.actorId,
                     });
+                    emitConsoleLiveEvent(consoleLiveEmitter, 'client_update', {
+                        action: 'realtime_disconnected',
+                        actorId: auth.actorId,
+                        clientId,
+                        partitionId,
+                    });
                 },
                 onError(_evt, _ws) {
                     unregister?.();
@@ -585,6 +911,12 @@ export function createSyncRoutes(options) {
                         event: 'sync.realtime.disconnect',
                         userId: auth.actorId,
                     });
+                    emitConsoleLiveEvent(consoleLiveEmitter, 'client_update', {
+                        action: 'realtime_error',
+                        actorId: auth.actorId,
+                        clientId,
+                        partitionId,
+                    });
                 },
                 onMessage(evt, _ws) {
                     if (!connRef)
@@ -668,10 +1000,13 @@ export function createSyncRoutes(options) {
         const requestId = typeof msg.requestId === 'string' ? msg.requestId : '';
         if (!requestId)
             return;
+        const traceContext = readTraceContextFromMessage(msg);
+        const timer = createSyncTimer();
         try {
             // Validate the push payload
             const parsed = SyncPushRequestSchema.omit({ clientId: true }).safeParse(msg);
             if (!parsed.success) {
+                const invalidDurationMs = timer();
                 conn.sendPushResponse({
                     requestId,
                     ok: false,
@@ -680,10 +1015,50 @@ export function createSyncRoutes(options) {
                         { opIndex: 0, status: 'error', error: 'Invalid push payload' },
                     ],
                 });
+                recordRequestEventInBackground({
+                    partitionId,
+                    requestId,
+                    traceId: traceContext.traceId,
+                    spanId: traceContext.spanId,
+                    eventType: 'push',
+                    syncPath: 'ws-push',
+                    actorId,
+                    clientId,
+                    transportPath: conn.transportPath,
+                    statusCode: 400,
+                    outcome: 'rejected',
+                    responseStatus: normalizeResponseStatus(400, 'rejected'),
+                    durationMs: invalidDurationMs,
+                    errorCode: 'INVALID_PUSH_PAYLOAD',
+                    errorMessage: 'Invalid push payload',
+                    payloadSnapshot: {
+                        request: msg,
+                        response: {
+                            ok: false,
+                            status: 'rejected',
+                            reason: 'invalid_push_payload',
+                        },
+                    },
+                });
+                emitConsoleLiveEvent(consoleLiveEmitter, 'push', {
+                    partitionId,
+                    requestId,
+                    traceId: traceContext.traceId,
+                    spanId: traceContext.spanId,
+                    actorId,
+                    clientId,
+                    transportPath: conn.transportPath,
+                    syncPath: 'ws-push',
+                    outcome: 'rejected',
+                    statusCode: 400,
+                    durationMs: invalidDurationMs,
+                    errorCode: 'INVALID_PUSH_PAYLOAD',
+                });
                 return;
             }
             const pushOps = parsed.data.operations ?? [];
             if (pushOps.length > maxOperationsPerPush) {
+                const rejectedDurationMs = timer();
                 conn.sendPushResponse({
                     requestId,
                     ok: false,
@@ -696,9 +1071,54 @@ export function createSyncRoutes(options) {
                         },
                     ],
                 });
+                recordRequestEventInBackground({
+                    partitionId,
+                    requestId,
+                    traceId: traceContext.traceId,
+                    spanId: traceContext.spanId,
+                    eventType: 'push',
+                    syncPath: 'ws-push',
+                    actorId,
+                    clientId,
+                    transportPath: conn.transportPath,
+                    statusCode: 400,
+                    outcome: 'rejected',
+                    responseStatus: normalizeResponseStatus(400, 'rejected'),
+                    durationMs: rejectedDurationMs,
+                    errorCode: 'MAX_OPERATIONS_EXCEEDED',
+                    errorMessage: `Maximum ${maxOperationsPerPush} operations per push`,
+                    operationCount: pushOps.length,
+                    payloadSnapshot: {
+                        request: {
+                            clientId,
+                            clientCommitId: parsed.data.clientCommitId,
+                            schemaVersion: parsed.data.schemaVersion,
+                            operations: parsed.data.operations,
+                        },
+                        response: {
+                            ok: false,
+                            status: 'rejected',
+                            reason: 'max_operations_exceeded',
+                        },
+                    },
+                });
+                emitConsoleLiveEvent(consoleLiveEmitter, 'push', {
+                    partitionId,
+                    requestId,
+                    traceId: traceContext.traceId,
+                    spanId: traceContext.spanId,
+                    actorId,
+                    clientId,
+                    transportPath: conn.transportPath,
+                    syncPath: 'ws-push',
+                    outcome: 'rejected',
+                    statusCode: 400,
+                    durationMs: rejectedDurationMs,
+                    operationCount: pushOps.length,
+                    errorCode: 'MAX_OPERATIONS_EXCEEDED',
+                });
                 return;
             }
-            const timer = createSyncTimer();
             const pushed = await pushCommit({
                 db: options.db,
                 dialect: options.dialect,
@@ -722,16 +1142,48 @@ export function createSyncRoutes(options) {
                 commitSeq: pushed.response.commitSeq,
             });
             recordRequestEventInBackground({
+                partitionId,
+                requestId,
+                traceId: traceContext.traceId,
+                spanId: traceContext.spanId,
                 eventType: 'push',
+                syncPath: 'ws-push',
                 actorId,
                 clientId,
                 transportPath: conn.transportPath,
                 statusCode: 200,
                 outcome: pushed.response.status,
+                responseStatus: normalizeResponseStatus(200, pushed.response.status),
                 durationMs: pushDurationMs,
+                errorCode: firstPushErrorCode(pushed.response.results),
                 commitSeq: pushed.response.commitSeq,
                 operationCount: pushOps.length,
                 tables: pushed.affectedTables,
+                payloadSnapshot: {
+                    request: {
+                        clientId,
+                        clientCommitId: parsed.data.clientCommitId,
+                        schemaVersion: parsed.data.schemaVersion,
+                        operations: parsed.data.operations,
+                    },
+                    response: pushed.response,
+                },
+            });
+            emitConsoleLiveEvent(consoleLiveEmitter, 'push', {
+                partitionId,
+                requestId,
+                traceId: traceContext.traceId,
+                spanId: traceContext.spanId,
+                actorId,
+                clientId,
+                transportPath: conn.transportPath,
+                syncPath: 'ws-push',
+                outcome: pushed.response.status,
+                statusCode: 200,
+                durationMs: pushDurationMs,
+                commitSeq: pushed.response.commitSeq ?? null,
+                operationCount: pushOps.length,
+                tables: pushed.affectedTables,
             });
             // WS notifications to other clients
             if (wsConnectionManager &&
@@ -764,6 +1216,17 @@ export function createSyncRoutes(options) {
                     }
                 }
             }
+            if (pushed.response.ok === true &&
+                pushed.response.status === 'applied' &&
+                typeof pushed.response.commitSeq === 'number') {
+                emitConsoleLiveEvent(consoleLiveEmitter, 'commit', {
+                    partitionId,
+                    commitSeq: pushed.response.commitSeq,
+                    actorId,
+                    clientId,
+                    affectedTables: pushed.affectedTables,
+                });
+            }
             conn.sendPushResponse({
                 requestId,
                 ok: pushed.response.ok,
@@ -773,6 +1236,7 @@ export function createSyncRoutes(options) {
             });
         }
         catch (err) {
+            const failedDurationMs = timer();
             captureSyncException(err, {
                 event: 'sync.realtime.push_failed',
                 requestId,
@@ -781,6 +1245,46 @@ export function createSyncRoutes(options) {
                 partitionId,
             });
             const message = err instanceof Error ? err.message : 'Internal server error';
+            recordRequestEventInBackground({
+                partitionId,
+                requestId,
+                traceId: traceContext.traceId,
+                spanId: traceContext.spanId,
+                eventType: 'push',
+                syncPath: 'ws-push',
+                actorId,
+                clientId,
+                transportPath: conn.transportPath,
+                statusCode: 500,
+                outcome: 'error',
+                responseStatus: normalizeResponseStatus(500, 'error'),
+                durationMs: failedDurationMs,
+                errorCode: 'INTERNAL_SERVER_ERROR',
+                errorMessage: message,
+                payloadSnapshot: {
+                    request: msg,
+                    response: {
+                        ok: false,
+                        status: 'rejected',
+                        reason: 'internal_server_error',
+                        message,
+                    },
+                },
+            });
+            emitConsoleLiveEvent(consoleLiveEmitter, 'push', {
+                partitionId,
+                requestId,
+                traceId: traceContext.traceId,
+                spanId: traceContext.spanId,
+                actorId,
+                clientId,
+                transportPath: conn.transportPath,
+                syncPath: 'ws-push',
+                outcome: 'error',
+                statusCode: 500,
+                durationMs: failedDurationMs,
+                errorCode: 'INTERNAL_SERVER_ERROR',
+            });
             conn.sendPushResponse({
                 requestId,
                 ok: false,