@intelligems/sst 2.49.6-ig.1 → 2.49.6-ig.10

package/runtime/worker-pool-logging.js

@@ -0,0 +1,185 @@
+import { createDebugFileLogger } from "./debug-file-logger.js";
+// Configuration
+const SST_BUILD_CONCURRENCY = parseInt(process.env.SST_BUILD_CONCURRENCY || "4", 10);
+export const POOL_SIZE = parseInt(process.env.SST_WORKER_POOL_SIZE || "10", 10);
+export const IDLE_TIMEOUT = parseInt(process.env.SST_WORKER_IDLE_TIMEOUT || "60000", 10);
+const DEBUG_POOL = process.env.SST_DEBUG_POOL === "true";
+const DEBUG_POOL_FILE = process.env.SST_DEBUG_POOL_FILE || ".sst/worker-pool.log";
+const INVOKE_TRACE_FILE = ".sst/invoke-trace.log";
+const metrics = {
+    coldStarts: new Map(),
+    concurrentRequests: new Map(),
+    peakConcurrent: new Map(),
+    totalRequests: new Map(),
+    poolHits: new Map(),
+    avgResponseTime: new Map(),
+    responseCount: new Map(),
+};
+// Create pool logger using the abstract logger
+let poolLogger = null;
+function getPoolLogger() {
+    if (!DEBUG_POOL)
+        return null;
+    if (!poolLogger) {
+        poolLogger = createDebugFileLogger({
+            filePath: DEBUG_POOL_FILE,
+            sessionName: "POOL",
+            sessionHeader: `POOL_SIZE=${POOL_SIZE} IDLE_TIMEOUT=${IDLE_TIMEOUT}ms BUILD_CONCURRENCY=${SST_BUILD_CONCURRENCY}`,
+            width: 100,
+        });
+    }
+    return poolLogger;
+}
+// Function name resolver - set by workers.ts
+let functionNameResolver = (id) => id.slice(0, 25);
+/**
+ * Set the function name resolver callback
+ * Called by workers.ts to provide access to useFunctions()
+ */
+export function setFunctionNameResolver(resolver) {
+    functionNameResolver = resolver;
+}
+// Extract readable function name from handler path
+function getFunctionName(functionID) {
+    return functionNameResolver(functionID);
+}
+// Calculate bottleneck indicators
+function getBottleneckFlags(functionID) {
+    const flags = [];
+    const concurrent = metrics.concurrentRequests.get(functionID) || 0;
+    const total = metrics.totalRequests.get(functionID) || 0;
+    const hits = metrics.poolHits.get(functionID) || 0;
+    const hitRate = total > 0 ? (hits / total) * 100 : 0;
+    const coldStarts = metrics.coldStarts.get(functionID) || 0;
+    // SATURATED: All pool slots in use
+    if (concurrent >= POOL_SIZE) {
+        flags.push("SATURATED");
+    }
+    // HIGH_LOAD: >70% pool utilization
+    else if (concurrent >= POOL_SIZE * 0.7) {
+        flags.push("HIGH_LOAD");
+    }
+    // COLD_START: Low hit rate indicates frequent cold starts
+    if (total >= 5 && hitRate < 30) {
+        flags.push("LOW_REUSE");
+    }
+    // BOTTLENECK: High cold start ratio
+    if (total >= 3 && coldStarts / total > 0.5) {
+        flags.push("COLD_HEAVY");
+    }
+    return flags.length > 0 ? " [" + flags.join(" ") + "]" : "";
+}
+/**
+ * Pool debug logging helper - writes to file with bottleneck detection
+ */
+export function logPool(action, details = {}) {
+    const logger = getPoolLogger();
+    if (!logger)
+        return;
+    const funcName = details.functionID
+        ? getFunctionName(details.functionID)
+        : "";
+    const bottleneckFlags = details.functionID &&
+        ["CREATE", "REUSE", "POOL_MISS", "RESPONSE"].includes(action)
+        ? getBottleneckFlags(details.functionID)
+        : "";
+    // Build metrics string for key actions
+    let metricsStr = "";
+    if (details.functionID && ["RESPONSE", "RETURN_TO_POOL"].includes(action)) {
+        const concurrent = metrics.concurrentRequests.get(details.functionID) || 0;
+        const total = metrics.totalRequests.get(details.functionID) || 0;
+        const hits = metrics.poolHits.get(details.functionID) || 0;
+        const hitRate = total > 0 ? ((hits / total) * 100).toFixed(0) : "0";
+        metricsStr = `concurrent=${concurrent} hitRate=${hitRate}%`;
+    }
+    // Build the log details
+    const logDetails = {};
+    // Add function name first if present
+    if (funcName) {
+        logDetails.func = funcName;
+    }
+    // Add all other details except functionID
+    for (const [k, v] of Object.entries(details)) {
+        if (k !== "functionID") {
+            logDetails[k] = v;
+        }
+    }
+    // Add metrics if present
+    if (metricsStr) {
+        logDetails.metrics = metricsStr;
+    }
+    // Add bottleneck flags
+    if (bottleneckFlags) {
+        logDetails.status = bottleneckFlags.trim();
+    }
+    logger.log(action, logDetails);
+}
+/**
+ * Track request lifecycle for metrics - called at request start
+ */
+export function trackRequestStart(functionID, isPoolHit) {
+    const current = (metrics.concurrentRequests.get(functionID) || 0) + 1;
+    metrics.concurrentRequests.set(functionID, current);
+    metrics.totalRequests.set(functionID, (metrics.totalRequests.get(functionID) || 0) + 1);
+    const peak = metrics.peakConcurrent.get(functionID) || 0;
+    if (current > peak) {
+        metrics.peakConcurrent.set(functionID, current);
+    }
+    if (isPoolHit) {
+        metrics.poolHits.set(functionID, (metrics.poolHits.get(functionID) || 0) + 1);
+    }
+    else {
+        metrics.coldStarts.set(functionID, (metrics.coldStarts.get(functionID) || 0) + 1);
+    }
+}
+/**
+ * Track request lifecycle for metrics - called at request end
+ */
+export function trackRequestEnd(functionID) {
+    const current = metrics.concurrentRequests.get(functionID) || 0;
+    if (current > 0) {
+        metrics.concurrentRequests.set(functionID, current - 1);
+    }
+}
+/**
+ * Write session end summary and close log stream
+ * Called from workers.ts on process exit
+ */
+export function writeSessionEndSummary() {
+    const logger = getPoolLogger();
+    if (!logger)
+        return;
+    let summary = "";
+    for (const [funcID, total] of metrics.totalRequests) {
+        const hits = metrics.poolHits.get(funcID) || 0;
+        const cold = metrics.coldStarts.get(funcID) || 0;
+        const peak = metrics.peakConcurrent.get(funcID) || 0;
+        const hitRate = total > 0 ? ((hits / total) * 100).toFixed(1) : "0";
+        const funcName = getFunctionName(funcID);
+        summary += `  ${funcName.padEnd(25)} total=${total} poolHits=${hits} coldStarts=${cold} peakConcurrent=${peak} hitRate=${hitRate}%\n`;
+    }
+    logger.close(summary);
+}
+// Invocation trace logging - uses the abstract logger
+let traceLogger = null;
+function getTraceLogger() {
+    if (!traceLogger) {
+        traceLogger = createDebugFileLogger({
+            filePath: INVOKE_TRACE_FILE,
+            sessionName: "TRACE",
+            width: 80,
+        });
+    }
+    return traceLogger;
+}
+/**
+ * Log invocation trace events to .sst/invoke-trace.log
+ * Always enabled for debugging invocation flow
+ */
+export function logInvokeTrace(stage, requestID, details) {
+    const logger = getTraceLogger();
+    logger.log(stage, {
+        req: requestID.slice(0, 8),
+        ...(details ? { info: details } : {}),
+    });
+}

package/runtime/workers.d.ts

@@ -18,20 +18,52 @@ declare module "../bus.js" {
             requestID: string;
             message: string;
         };
+        "worker.reused": {
+            workerID: string;
+            functionID: string;
+            pooledWorkerID: string;
+        };
+        "warmup.start": {
+            count: number;
+        };
+        "warmup.progress": {
+            completed: number;
+            total: number;
+            success: number;
+            failed: number;
+        };
+        "warmup.complete": {
+            success: number;
+            failed: number;
+            elapsedMs: number;
+        };
     }
 }
-interface Worker {
-    workerID: string;
-    functionID: string;
-}
 export declare const useRuntimeWorkers: () => Promise<{
-    fromID(workerID: string): Worker;
+    fromID(workerID: string): {
+        workerID: string;
+        functionID: string;
+    };
     getCurrentRequestID(workerID: string): string | undefined;
     stdout(workerID: string, message: string): void;
     exited(workerID: string): void;
-    subscribe: <Type extends "worker.started" | "worker.stopped" | "worker.exited" | "worker.stdout">(type: Type, cb: (payload: import("../bus.js").EventPayload<Type>) => void) => {
+    onResponse(pooledWorkerID: string): void;
+    getAwsWorkerID(pooledWorkerID: string): string | undefined;
+    isPooled(workerID: string): boolean;
+    subscribe: <Type extends "worker.started" | "worker.stopped" | "worker.exited" | "worker.stdout" | "worker.reused">(type: Type, cb: (payload: import("../bus.js").EventPayload<Type>) => void) => {
         type: keyof import("../bus.js").Events;
         cb: (payload: any) => void;
     };
+    /**
+     * Trigger warmup by invoking Lambda functions with warmup payloads.
+     * This sends real requests through the IoT bridge, which naturally creates workers.
+     * @param count Number of workers to warm up (default: 15)
+     */
+    triggerWarmup(count?: number): Promise<{
+        warmed: number;
+        elapsed?: undefined;
+    } | {
+        warmed: number;
+        elapsed: number;
+    }>;
 }>;
-export {};