lambda-live-debugger 1.2.0 → 1.2.2

package/dist/frameworks/samFramework.mjs

@@ -118,9 +118,11 @@ export class SamFramework {
             }
             if (!codePath) {
                 const fileWithExtension = handlerParts[0];
+                const possibleCodePathsTs = `${fileWithExtension}.ts`;
+                const possibleCodePathsJs = `${fileWithExtension}.js`;
                 const possibleCodePaths = [
-                    `${fileWithExtension}.ts`,
-                    `${fileWithExtension}.js`,
+                    possibleCodePathsTs,
+                    possibleCodePathsJs,
                     `${fileWithExtension}.cjs`,
                     `${fileWithExtension}.mjs`,
                 ];
@@ -134,9 +136,10 @@ export class SamFramework {
                         // ignore, file not found
                     }
                 }
-            }
-            if (!codePath) {
-                throw new Error(`Code path not found for function: ${func.Name}`);
+                if (!codePath) {
+                    codePath = possibleCodePathsJs;
+                    Logger.warn(`[Function ${functionName}] Can not find code path for handler: ${handlerFull}. Using fallback: ${codePath}`);
+                }
             }
             const packageJsonPath = await findPackageJson(codePath);
             Logger.verbose(`[SAM] package.json path: ${packageJsonPath}`);

package/dist/infraDeploy.mjs

@@ -11,6 +11,7 @@ let lambdaClient;
 let iamClient;
 const inlinePolicyName = 'LambdaLiveDebuggerPolicy';
 const layerName = 'LambdaLiveDebugger';
+const lldWrapperPath = '/opt/lld-wrapper';
 /**
  * Policy document to attach to the Lambda role
  */
@@ -217,7 +218,14 @@ async function removeLayerFromLambda(functionName) {
         else {
             Logger.verbose(`Skipping detaching layer from the function ${functionName}, no layer attached`);
         }
-        const ddlEnvironmentVariables = getEnvironmentVarablesForDebugger('xxx', 0);
+        const initalExecWraper = environmentVariables.LLD_INITIAL_AWS_LAMBDA_EXEC_WRAPPER;
+        const ddlEnvironmentVariables = getEnvironmentVarablesForDebugger({
+            // set dummy data, so we just get the list of environment variables
+            functionId: 'xxx',
+            timeout: 0,
+            verbose: true,
+            initalExecWraper: 'test',
+        });
         // check if environment variables are set for each property
         for (const [key] of Object.entries(ddlEnvironmentVariables)) {
             if (environmentVariables && environmentVariables[key]) {
@@ -231,9 +239,22 @@ async function removeLayerFromLambda(functionName) {
             //remove environment variables
             for (const [key] of Object.entries(ddlEnvironmentVariables)) {
                 if (environmentVariables && environmentVariables[key]) {
-                    delete environmentVariables[key];
+                    if (key === 'AWS_LAMBDA_EXEC_WRAPPER') {
+                        if (environmentVariables[key] === lldWrapperPath) {
+                            delete environmentVariables[key];
+                        }
+                        else {
+                            // do not remove the original AWS_LAMBDA_EXEC_WRAPPER that was set before LLD
+                        }
+                    }
+                    else {
+                        delete environmentVariables[key];
+                    }
                 }
             }
+            if (initalExecWraper) {
+                environmentVariables.AWS_LAMBDA_EXEC_WRAPPER = initalExecWraper;
+            }
             Logger.verbose('New environment variables', JSON.stringify(environmentVariables, null, 2));
             const updateFunctionConfigurationCommand = new UpdateFunctionConfigurationCommand({
                 FunctionName: functionName,
@@ -314,7 +335,19 @@ async function attachLayerToLambda(functionName, functionId, layerArn) {
         needToUpdate = true;
         Logger.verbose('Layer with the wrong version attached to the function');
     }
-    const ddlEnvironmentVariables = getEnvironmentVarablesForDebugger(functionId, initialTimeout);
+    // support for multiple internal Lambda extensions
+    const initalExecWraper = environmentVariables.AWS_LAMBDA_EXEC_WRAPPER !== lldWrapperPath
+        ? environmentVariables.AWS_LAMBDA_EXEC_WRAPPER
+        : undefined;
+    if (initalExecWraper) {
+        Logger.warn(`[Function ${functionName}] Another internal Lambda extension is already attached to the function, which might cause unpredictable behavior.`);
+    }
+    const ddlEnvironmentVariables = getEnvironmentVarablesForDebugger({
+        functionId,
+        timeout: initialTimeout,
+        verbose: Configuration.config.verbose,
+        initalExecWraper,
+    });
     // check if environment variables are already set for each property
     for (const [key, value] of Object.entries(ddlEnvironmentVariables)) {
         if (!environmentVariables || environmentVariables[key] !== value) {
@@ -386,19 +419,23 @@ async function addPolicyToLambdaRole(functionName) {
 }
 /**
  * Get the environment variables for the Lambda function
- * @param functionId
- * @param timeout
- * @returns
  */
-function getEnvironmentVarablesForDebugger(functionId, timeout) {
-    return {
+function getEnvironmentVarablesForDebugger({ functionId, timeout, verbose, initalExecWraper, }) {
+    const env = {
         LLD_FUNCTION_ID: functionId,
-        AWS_LAMBDA_EXEC_WRAPPER: '/opt/lld-wrapper',
+        AWS_LAMBDA_EXEC_WRAPPER: lldWrapperPath,
         LLD_DEBUGGER_ID: Configuration.config.debuggerId,
         LLD_INITIAL_TIMEOUT: timeout ? timeout.toString() : '-1', // should never be negative
         LLD_OBSERVABLE_MODE: Configuration.config.observable ? 'true' : 'false',
         LLD_OBSERVABLE_INTERVAL: Configuration.config.interval.toString(),
     };
+    if (initalExecWraper) {
+        env.LLD_INITIAL_AWS_LAMBDA_EXEC_WRAPPER = initalExecWraper;
+    }
+    if (verbose) {
+        env.LLD_VERBOSE = 'true';
+    }
+    return env;
 }
 /**
  * Remove the policy from the Lambda role

package/dist/lldebugger.mjs

@@ -79,5 +79,6 @@ async function run() {
     FileWatcher.watchForFileChanges(rootFolderForWarchingChanges);
     await LambdaConnection.connect();
     Logger.log('Debugger started!');
+    Logger.info(`When you want to stop debugging and return to normal execution, type command 'lld -r' to remove LLD Layer from the functions.`);
 }
 run().catch(Logger.error);

package/dist/logger.d.ts

@@ -18,6 +18,11 @@ declare function error(...args: any[]): void;
  * @param args The arguments to log
  */
 declare function warn(...args: any[]): void;
+/**
+ * Log an info message in green
+ * @param args The arguments to log
+ */
+declare function info(...args: any[]): void;
 /**
  * Log a verbose message if verbose is enabled. Log the message in grey.
  * @param args The arguments to log
@@ -28,12 +33,19 @@ declare function verbose(...args: any[]): void;
  * @param enabled Whether verbose logging should be enabled
  */
 declare function setVerbose(enabled: boolean): void;
+/**
+ * Check if verbose logging is enabled
+ * @returns Whether verbose logging is enabled
+ */
+declare function isVerbose(): boolean;
 export declare const Logger: {
     log: typeof log;
     error: typeof error;
     warn: typeof warn;
     important: typeof important;
+    info: typeof info;
     verbose: typeof verbose;
     setVerbose: typeof setVerbose;
+    isVerbose: typeof isVerbose;
 };
 export {};

package/dist/logger.mjs

@@ -38,6 +38,14 @@ function warn(...args) {
     args = args.map((arg) => (typeof arg === 'string' ? chalk.yellow(arg) : arg));
     console.warn(...args);
 }
+/**
+ * Log an info message in green
+ * @param args The arguments to log
+ */
+function info(...args) {
+    args = args.map((arg) => typeof arg === 'string' ? chalk.greenBright(arg) : arg);
+    console.info(...args);
+}
 /**
  * Log a verbose message if verbose is enabled. Log the message in grey.
  * @param args The arguments to log
@@ -55,11 +63,20 @@ function verbose(...args) {
 function setVerbose(enabled) {
     verboseEnabled = enabled;
 }
+/**
+ * Check if verbose logging is enabled
+ * @returns Whether verbose logging is enabled
+ */
+function isVerbose() {
+    return verboseEnabled;
+}
 export const Logger = {
     log,
     error,
     warn,
     important,
+    info,
     verbose,
     setVerbose,
+    isVerbose,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambda-live-debugger",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "type": "module",
   "description": "Debug Lambda functions locally like it is running in the cloud",
   "repository": {