@intelligems/sst 2.49.6-ig.5 → 2.49.6-ig.7

package/cli/commands/dev.js

@@ -36,6 +36,13 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
             const colors = ["#01cdfe", "#ff71ce", "#05ffa1", "#b967ff"];
             let index = 0;
             const pending = new Map();
+            // Track warmup request IDs to suppress their logs
+            const warmupRequestIDs = new Set();
+            // Helper to check if an event payload is a warmup request
+            function isWarmupEvent(event) {
+                return event && typeof event === 'object' &&
+                    ('ding' in event || 'warmer' in event || event.__sst_warmup === true);
+            }
             function prefix(requestID) {
                 const exists = pending.get(requestID);
                 if (exists) {
@@ -53,14 +60,54 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
                 // index--;
                 // if (index < 0) index = colors.length - 1;
                 pending.delete(requestID);
+                warmupRequestIDs.delete(requestID);
             }
+            // Warmup progress bar state
+            let warmupSpinner = null;
+            let warmupTotal = 0;
+            let warmupCompleted = 0;
+            bus.subscribe("warmup.start", async (evt) => {
+                warmupTotal = evt.properties.count;
+                warmupCompleted = 0;
+                warmupSpinner = createSpinner({
+                    color: "cyan",
+                    text: Colors.dim(` Warming up workers... 0/${warmupTotal}`),
+                }).start();
+            });
+            bus.subscribe("warmup.progress", async (evt) => {
+                warmupCompleted = evt.properties.completed;
+                if (warmupSpinner) {
+                    warmupSpinner.text = Colors.dim(` Warming up workers... ${warmupCompleted}/${warmupTotal}`);
+                }
+            });
+            bus.subscribe("warmup.complete", async (evt) => {
+                if (warmupSpinner) {
+                    warmupSpinner.succeed(Colors.dim(` Warmed up ${evt.properties.success} workers in ${evt.properties.elapsedMs}ms`));
+                    warmupSpinner = null;
+                }
+            });
             bus.subscribe("function.invoked", async (evt) => {
+                // Check if this is a warmup request and track it
+                if (isWarmupEvent(evt.properties.event)) {
+                    warmupRequestIDs.add(evt.properties.requestID);
+                    return; // Don't log warmup invocations
+                }
                 Colors.line(prefix(evt.properties.requestID), Colors.dim.bold("Invoked"), Colors.dim(useFunctions().fromID(evt.properties.functionID)?.handler));
             });
             bus.subscribe("worker.stdout", async (evt) => {
+                if (evt.properties.message.includes('[LOG]')) {
+                    console.log(evt.properties.message);
+                    return;
+                }
+                // Skip warmup request logs
+                if (warmupRequestIDs.has(evt.properties.requestID))
+                    return;
                 const info = useFunctions().fromID(evt.properties.functionID);
                 prefix(evt.properties.requestID);
-                const { started } = pending.get(evt.properties.requestID);
+                const pendingReq = pending.get(evt.properties.requestID);
+                if (!pendingReq)
+                    return; // Safety check
+                const { started } = pendingReq;
                 for (let line of evt.properties.message.split("\n")) {
                     // Remove prefix from container logs
                     if (info?.runtime === "container") {
@@ -104,22 +151,46 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
                 if (info.enableLiveDev === false)
                     return;
                 Colors.gap();
-                Colors.line(Colors.danger("✖ "), "Build failed", info.handler);
+                Colors.line(Colors.danger("═".repeat(60)));
+                Colors.line(Colors.danger("  FUNCTION BUILD FAILED - SST IS EXITING"));
+                Colors.line(Colors.danger("═".repeat(60)));
+                Colors.gap();
+                Colors.line(Colors.danger("✖ "), "Handler:", info.handler);
+                Colors.line(Colors.danger("✖ "), "Function ID:", evt.properties.functionID);
+                Colors.gap();
+                Colors.line(Colors.danger("  Errors:"));
                 for (const line of evt.properties.errors) {
-                    Colors.line("  ", line);
+                    Colors.line(Colors.danger("    → "), line);
                 }
                 Colors.gap();
+                Colors.line(Colors.danger("═".repeat(60)));
+                Colors.line(Colors.danger("  Fix the error above and restart `sst dev`"));
+                Colors.line(Colors.danger("═".repeat(60)));
+                Colors.gap();
+                process.exit(1);
             });
             bus.subscribe("function.success", async (evt) => {
+                // Skip warmup request logs
+                if (warmupRequestIDs.has(evt.properties.requestID)) {
+                    end(evt.properties.requestID);
+                    return;
+                }
                 // stdout logs sometimes come in after
                 const p = prefix(evt.properties.requestID);
                 const req = pending.get(evt.properties.requestID);
+                if (!req)
+                    return; // Safety check
                 setTimeout(() => {
                     Colors.line(p, Colors.dim(`Done in ${Date.now() - req.started - 100}ms`));
                     end(evt.properties.requestID);
                 }, 100);
             });
             bus.subscribe("function.error", async (evt) => {
+                // Skip warmup request logs
+                if (warmupRequestIDs.has(evt.properties.requestID)) {
+                    end(evt.properties.requestID);
+                    return;
+                }
                 setTimeout(() => {
                     Colors.line(prefix(evt.properties.requestID), Colors.danger.bold("Error:"), Colors.danger.bold(evt.properties.errorMessage));
                     for (const line of evt.properties.trace || []) {
@@ -342,6 +413,12 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
             import("./plugins/warmer.js").then((mod) => mod.useRDSWarmer()),
             useFunctionLogger(),
         ]);
+        // Trigger warmup by invoking Lambda functions with warmup payloads
+        // This creates workers through the real request flow
+        import("../../runtime/workers.js").then(async (mod) => {
+            const workers = await mod.useRuntimeWorkers();
+            await workers.triggerWarmup(30);
+        });
     }
     catch (e) {
         await exitWithError(e);

package/cli/sst.js

@@ -40,7 +40,6 @@ version(program);
 telemetry(program);
 types(program);
 if ("setSourceMapsEnabled" in process) {
-    // @ts-expect-error
     process.setSourceMapsEnabled(true);
 }
 process.removeAllListeners("uncaughtException");

package/iot.js

@@ -3,6 +3,9 @@ import { useAWSClient, useAWSCredentials } from "./credentials.js";
 import { VisibleError } from "./error.js";
 import { lazy } from "./util/lazy.js";
 import { Logger } from "./logger.js";
+import { logIotRx } from "./runtime/debug-bridge-logging.js";
+import { logEventTrace } from "./runtime/event-trace-logging.js";
+import { getRequestPath, getCorrelationId, getApiGatewayRequestId, getHttpMethod } from "./runtime/request-utils.js";
 export const useIOTEndpoint = lazy(async () => {
     const iot = useAWSClient(IoTClient);
     Logger.debug("Getting IoT endpoint");
@@ -120,6 +123,19 @@ export const useIOT = lazy(async () => {
     device.on("message", (_topic, buffer) => {
         const fragment = JSON.parse(buffer.toString());
         if (!fragment.id) {
+            const requestID = fragment.properties?.requestID;
+            logIotRx(`Received ${fragment.type} reqId=${requestID?.slice(0, 8) || 'N/A'}`);
+            if (fragment.type === "function.invoked" && requestID) {
+                const event = fragment.properties?.event;
+                logEventTrace("IOT_RECEIVED", {
+                    requestID,
+                    functionID: fragment.properties?.functionID,
+                    path: getRequestPath(event),
+                    method: getHttpMethod(event),
+                    correlationId: getCorrelationId(event),
+                    apiGwReqId: getApiGatewayRequestId(event),
+                });
+            }
             bus.publish(fragment.type, fragment.properties);
             return;
         }
@@ -138,6 +154,20 @@ export const useIOT = lazy(async () => {
             const evt = JSON.parse(data);
             if (evt.sourceID === bus.sourceID)
                 return;
+            const requestID = evt.properties?.requestID;
+            logIotRx(`Received ${evt.type} reqId=${requestID?.slice(0, 8) || 'N/A'} (${fragment.count} fragments)`);
+            if (evt.type === "function.invoked" && requestID) {
+                const event = evt.properties?.event;
+                logEventTrace("IOT_RECEIVED", {
+                    requestID,
+                    functionID: evt.properties?.functionID,
+                    path: getRequestPath(event),
+                    method: getHttpMethod(event),
+                    correlationId: getCorrelationId(event),
+                    apiGwReqId: getApiGatewayRequestId(event),
+                    fragments: fragment.count,
+                });
+            }
             bus.publish(evt.type, evt.properties);
         }
     });

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "@intelligems/sst",
-  "version": "2.49.6-ig.5",
+  "version": "2.49.6-ig.7",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -113,7 +113,7 @@
     "@types/babel__generator": "^7.6.4",
     "@types/cross-spawn": "^6.0.2",
     "@types/express": "^4.17.14",
-    "@types/node": "18.11.9",
+    "@types/node": "22.13.14",
     "@types/react": "^18.0.28",
     "@types/uuid": "^8.3.4",
     "@types/ws": "8.5.3",

package/package.json.bak

@@ -5,7 +5,7 @@
   },
   "sideEffects": false,
   "name": "@intelligems/sst",
-  "version": "2.49.6-ig.5",
+  "version": "2.49.6-ig.7",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -123,7 +123,7 @@
     "@types/babel__generator": "^7.6.4",
     "@types/cross-spawn": "^6.0.2",
     "@types/express": "^4.17.14",
-    "@types/node": "18.11.9",
+    "@types/node": "22.13.14",
     "@types/react": "^18.0.28",
     "@types/uuid": "^8.3.4",
     "@types/ws": "8.5.3",

package/runtime/debug-bridge-logging.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Log debug message for workers component
+ * Outputs to console and optionally to .sst/debug-workers.log
+ */
+export declare function logWorkers(message: string, details?: Record<string, any>): void;
+/**
+ * Log debug message for server component
+ * Outputs to console and optionally to .sst/debug-server.log
+ */
+export declare function logServer(message: string, details?: Record<string, any>): void;
+/**
+ * Log debug message for IoT component (publishing)
+ * Outputs to console and optionally to .sst/debug-iot.log
+ */
+export declare function logIot(message: string, details?: Record<string, any>): void;
+/**
+ * Log debug message for IoT component (receiving)
+ * Outputs to console and optionally to .sst/debug-iot.log
+ */
+export declare function logIotRx(message: string, details?: Record<string, any>): void;
+/**
+ * Check if bridge debug logging is enabled
+ */
+export declare function isDebugBridgeEnabled(): boolean;

package/runtime/debug-bridge-logging.js

@@ -0,0 +1,98 @@
+import { createDebugFileLogger } from "./debug-file-logger.js";
+/**
+ * Debug logging for SST dev bridge components
+ *
+ * Enable with: SST_DEBUG_BRIDGE=true
+ *
+ * Log files:
+ * - .sst/debug-workers.log - Worker pool and invocation handling
+ * - .sst/debug-server.log  - Runtime server request/response handling
+ * - .sst/debug-iot.log     - IoT message publishing and receiving
+ */
+const DEBUG_BRIDGE = process.env.SST_DEBUG_BRIDGE === "true";
+// Lazy-initialized loggers
+let workersLogger = null;
+let serverLogger = null;
+let iotLogger = null;
+function getWorkersLogger() {
+    if (!DEBUG_BRIDGE)
+        return null;
+    if (!workersLogger) {
+        workersLogger = createDebugFileLogger({
+            filePath: ".sst/debug-workers.log",
+            sessionName: "WORKERS",
+            width: 120,
+        });
+    }
+    return workersLogger;
+}
+function getServerLogger() {
+    if (!DEBUG_BRIDGE)
+        return null;
+    if (!serverLogger) {
+        serverLogger = createDebugFileLogger({
+            filePath: ".sst/debug-server.log",
+            sessionName: "SERVER",
+            width: 120,
+        });
+    }
+    return serverLogger;
+}
+function getIotLogger() {
+    if (!DEBUG_BRIDGE)
+        return null;
+    if (!iotLogger) {
+        iotLogger = createDebugFileLogger({
+            filePath: ".sst/debug-iot.log",
+            sessionName: "IOT",
+            width: 120,
+        });
+    }
+    return iotLogger;
+}
+/**
+ * Log debug message for workers component
+ * Outputs to console and optionally to .sst/debug-workers.log
+ */
+export function logWorkers(message, details) {
+    const logger = getWorkersLogger();
+    if (logger) {
+        logger.log("WORKERS", { msg: message, ...details });
+    }
+}
+/**
+ * Log debug message for server component
+ * Outputs to console and optionally to .sst/debug-server.log
+ */
+export function logServer(message, details) {
+    const logger = getServerLogger();
+    if (logger) {
+        logger.log("SERVER", { msg: message, ...details });
+    }
+}
+/**
+ * Log debug message for IoT component (publishing)
+ * Outputs to console and optionally to .sst/debug-iot.log
+ */
+export function logIot(message, details) {
+    const logger = getIotLogger();
+    if (logger) {
+        logger.log("IOT", { msg: message, ...details });
+    }
+}
+/**
+ * Log debug message for IoT component (receiving)
+ * Outputs to console and optionally to .sst/debug-iot.log
+ */
+export function logIotRx(message, details) {
+    const logger = getIotLogger();
+    if (logger) {
+        logger.log("IOT-RX", { msg: message, ...details });
+    }
+}
+/**
+ * Check if bridge debug logging is enabled
+ */
+export function isDebugBridgeEnabled() {
+    return DEBUG_BRIDGE;
+}

package/runtime/debug-file-logger.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="node" resolution-mode="require"/>
+import fs from "fs";
+/**
+ * Configuration for creating a debug file logger
+ */
+export interface DebugFileLoggerConfig {
+    /** Log file path (relative paths are relative to CWD) */
+    filePath: string;
+    /** Optional environment variable to enable/disable logging (if not set, logging is always enabled) */
+    envVar?: string;
+    /** Name for session markers (e.g., "POOL", "TRACE") */
+    sessionName: string;
+    /** Optional header line content for session start */
+    sessionHeader?: string;
+    /** Column width for padding (default: 80) */
+    width?: number;
+}
+/**
+ * Debug file logger instance
+ */
+export interface DebugFileLogger {
+    /** Log a message with timestamp and formatted details */
+    log: (action: string, details?: Record<string, any>) => void;
+    /** Log a raw line (no formatting) */
+    logRaw: (line: string) => void;
+    /** Check if logging is enabled */
+    isEnabled: () => boolean;
+    /** Write session end marker and close the stream */
+    close: (summary?: string) => void;
+    /** Get the write stream (for advanced use cases) */
+    getStream: () => fs.WriteStream | null;
+}
+/**
+ * Create a debug file logger with consistent formatting
+ *
+ * Features:
+ * - File-based logging to configurable path
+ * - Optional enable/disable via environment variable
+ * - Session start/end markers
+ * - Consistent timestamp formatting (HH:MM:SS.mmm)
+ * - Automatic directory creation
+ *
+ * @example
+ * ```ts
+ * const logger = createDebugFileLogger({
+ *   filePath: ".sst/debug-workers.log",
+ *   envVar: "SST_DEBUG_WORKERS",
+ *   sessionName: "WORKERS",
+ * });
+ *
+ * logger.log("REQUEST", { path: "/api/test", elapsed: 50 });
+ * // Output: [14:30:45.123] REQUEST path=/api/test elapsed=50
+ * ```
+ */
+export declare function createDebugFileLogger(config: DebugFileLoggerConfig): DebugFileLogger;
+/**
+ * Create a simple console+file logger for debug output
+ * Logs to both console and a file with consistent formatting
+ */
+export interface ConsoleFileLoggerConfig {
+    /** Log file path */
+    filePath: string;
+    /** Prefix for console output (e.g., "[WORKERS]") */
+    prefix: string;
+    /** Session name for file markers */
+    sessionName: string;
+}
+export interface ConsoleFileLogger {
+    /** Log a message to both console and file */
+    log: (message: string) => void;
+    /** Check if file logging is enabled */
+    isEnabled: () => boolean;
+    /** Close the file stream */
+    close: () => void;
+}
+/**
+ * Create a logger that writes to both console and a file
+ * Always writes to console, writes to file when SST_DEBUG_BRIDGE is set
+ */
+export declare function createConsoleFileLogger(config: ConsoleFileLoggerConfig): ConsoleFileLogger;

package/runtime/debug-file-logger.js

@@ -0,0 +1,148 @@
+import fs from "fs";
+import path from "path";
+// Active loggers registry (for cleanup)
+const activeLoggers = new Map();
+// Cleanup on process exit
+process.on("exit", () => {
+    for (const stream of activeLoggers.values()) {
+        try {
+            stream.end();
+        }
+        catch { }
+    }
+});
+/**
+ * Create a debug file logger with consistent formatting
+ *
+ * Features:
+ * - File-based logging to configurable path
+ * - Optional enable/disable via environment variable
+ * - Session start/end markers
+ * - Consistent timestamp formatting (HH:MM:SS.mmm)
+ * - Automatic directory creation
+ *
+ * @example
+ * ```ts
+ * const logger = createDebugFileLogger({
+ *   filePath: ".sst/debug-workers.log",
+ *   envVar: "SST_DEBUG_WORKERS",
+ *   sessionName: "WORKERS",
+ * });
+ *
+ * logger.log("REQUEST", { path: "/api/test", elapsed: 50 });
+ * // Output: [14:30:45.123] REQUEST path=/api/test elapsed=50
+ * ```
+ */
+export function createDebugFileLogger(config) {
+    const { filePath, envVar, sessionName, sessionHeader, width = 80 } = config;
+    let stream = null;
+    let initialized = false;
+    function isEnabled() {
+        // If no envVar specified, always enabled
+        if (!envVar)
+            return true;
+        return process.env[envVar] === "true";
+    }
+    function initLogFile() {
+        if (initialized)
+            return stream !== null;
+        initialized = true;
+        if (!isEnabled())
+            return false;
+        try {
+            const logDir = path.dirname(filePath);
+            if (!fs.existsSync(logDir)) {
+                fs.mkdirSync(logDir, { recursive: true });
+            }
+            stream = fs.createWriteStream(filePath, { flags: "w" });
+            activeLoggers.set(filePath, stream);
+            // Write session start marker
+            const header = sessionHeader ? ` | ${sessionHeader}` : "";
+            stream.write("\n" +
+                "=".repeat(width) +
+                "\n" +
+                `[${sessionName} SESSION START] ${new Date().toISOString()}${header}\n` +
+                "=".repeat(width) +
+                "\n");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    function formatTimestamp() {
+        return new Date().toISOString().slice(11, 23); // HH:MM:SS.mmm
+    }
+    function formatDetails(details) {
+        return Object.entries(details)
+            .filter(([_, v]) => v !== undefined)
+            .map(([k, v]) => {
+            if (typeof v === "object") {
+                return `${k}=${JSON.stringify(v)}`;
+            }
+            return `${k}=${v}`;
+        })
+            .join(" ");
+    }
+    return {
+        log(action, details = {}) {
+            if (!initLogFile() || !stream)
+                return;
+            const timestamp = formatTimestamp();
+            const detailStr = formatDetails(details);
+            const line = `[${timestamp}] ${action.padEnd(20)} ${detailStr}\n`;
+            stream.write(line);
+        },
+        logRaw(line) {
+            if (!initLogFile() || !stream)
+                return;
+            stream.write(line.endsWith("\n") ? line : line + "\n");
+        },
+        isEnabled,
+        close(summary) {
+            if (!stream)
+                return;
+            const endMarker = "\n" +
+                "-".repeat(width) +
+                "\n" +
+                `[${sessionName} SESSION END] ${new Date().toISOString()}\n` +
+                (summary ? summary + "\n" : "") +
+                "-".repeat(width) +
+                "\n";
+            stream.write(endMarker);
+            stream.end();
+            activeLoggers.delete(filePath);
+            stream = null;
+        },
+        getStream() {
+            initLogFile();
+            return stream;
+        },
+    };
+}
+/**
+ * Create a logger that writes to both console and a file
+ * Always writes to console, writes to file when SST_DEBUG_BRIDGE is set
+ */
+export function createConsoleFileLogger(config) {
+    const { filePath, prefix, sessionName } = config;
+    const fileLogger = createDebugFileLogger({
+        filePath,
+        envVar: "SST_DEBUG_BRIDGE",
+        sessionName,
+        width: 100,
+    });
+    return {
+        log(message) {
+            // Always log to console
+            console.log(`${prefix} ${message}`);
+            // Also log to file if enabled
+            if (fileLogger.isEnabled()) {
+                const timestamp = new Date().toISOString().slice(11, 23);
+                fileLogger.logRaw(`[${timestamp}] ${prefix} ${message}`);
+            }
+        },
+        isEnabled: fileLogger.isEnabled,
+        close: () => fileLogger.close(),
+    };
+}

package/runtime/event-trace-logging.d.ts

@@ -0,0 +1,27 @@
+type EventType = "IOT_RECEIVED" | "IOT_ACK" | "WORKER_START" | "WORKER_LOG" | "WORKER_END";
+interface EventTraceDetails {
+    requestID: string;
+    functionID?: string;
+    workerID?: string;
+    message?: string;
+    status?: "success" | "error";
+    elapsed?: number;
+    [key: string]: any;
+}
+/**
+ * Log an event trace entry with requestID as the common identifier
+ *
+ * @param event - The event type
+ * @param details - Event details including requestID (required)
+ *
+ * @example
+ * logEventTrace("IOT_RECEIVED", { requestID: "abc123", functionID: "MyFunc" });
+ * logEventTrace("WORKER_LOG", { requestID: "abc123", message: "[LOG] User action" });
+ * logEventTrace("WORKER_END", { requestID: "abc123", status: "success", elapsed: 150 });
+ */
+export declare function logEventTrace(event: EventType, details: EventTraceDetails): void;
+/**
+ * Check if event trace logging is enabled
+ */
+export declare function isEventTraceEnabled(): boolean;
+export {};

package/runtime/event-trace-logging.js

@@ -0,0 +1,69 @@
+import { createDebugFileLogger } from "./debug-file-logger.js";
+/**
+ * Event Trace Logging for SST Dev Bridge
+ *
+ * Tracks the complete lifecycle of a request from IOT reception to worker completion.
+ * All events share a common `requestID` for end-to-end tracing.
+ *
+ * Enable with: SST_EVENT_TRACE=true
+ *
+ * Log file: .sst/event-trace.log
+ *
+ * Event Types:
+ * - IOT_RECEIVED     : IOT event received from Lambda
+ * - IOT_ACK          : IOT acknowledgment published
+ * - WORKER_START     : Worker function started
+ * - WORKER_LOG       : Worker function log with [LOG] prefix
+ * - WORKER_END       : Worker function completed (success/error)
+ *
+ * Tracing from Frontend:
+ * - Send X-Correlation-ID header from frontend for easy correlation
+ * - Or use the path to filter by endpoint
+ * - Or use apiGwReqId (visible in browser as x-amzn-requestid response header)
+ */
+const EVENT_TRACE_ENABLED = process.env.SST_EVENT_TRACE === "true";
+let eventLogger = null;
+function getEventLogger() {
+    if (!EVENT_TRACE_ENABLED)
+        return null;
+    if (!eventLogger) {
+        eventLogger = createDebugFileLogger({
+            filePath: ".sst/event-trace.log",
+            sessionName: "EVENT_TRACE",
+            width: 140,
+        });
+    }
+    return eventLogger;
+}
+/**
+ * Log an event trace entry with requestID as the common identifier
+ *
+ * @param event - The event type
+ * @param details - Event details including requestID (required)
+ *
+ * @example
+ * logEventTrace("IOT_RECEIVED", { requestID: "abc123", functionID: "MyFunc" });
+ * logEventTrace("WORKER_LOG", { requestID: "abc123", message: "[LOG] User action" });
+ * logEventTrace("WORKER_END", { requestID: "abc123", status: "success", elapsed: 150 });
+ */
+export function logEventTrace(event, details) {
+    const logger = getEventLogger();
+    if (!logger)
+        return;
+    // Format requestID for consistent display (first 8 chars)
+    const reqId = details.requestID?.slice(0, 8) || "N/A";
+    // Build the log message with requestID prominently displayed
+    const logDetails = {
+        reqId,
+        ...details,
+    };
+    // Remove the full requestID since we're using the shortened version
+    delete logDetails.requestID;
+    logger.log(event, logDetails);
+}
+/**
+ * Check if event trace logging is enabled
+ */
+export function isEventTraceEnabled() {
+    return EVENT_TRACE_ENABLED;
+}