lambda-live-debugger 1.1.3 → 1.2.1

package/.vitepress/config.mts

@@ -74,10 +74,10 @@ export default defineConfig({
           { text: 'CLI Parameters', link: '#cli-parameters' },
           { text: 'Configuration file', link: '#configuration-file' },
           { text: 'Debugging', link: '#debugging' },
+          { text: 'Removing', link: '#removing' },
           { text: 'Development Process', link: '#development-process' },
           { text: 'Observability Mode', link: '#observability-mode' },
           { text: 'Monorepo', link: '#monorepo-setup' },
-          { text: 'Removing', link: '#removing' },
         ],
       },
       {

package/README.md

@@ -167,21 +167,9 @@ Now, you have to press F5 or press Run -> Start Debugging, and you can set break
 
 For other tools, please send documentation to include here. WebStorm instructions are especially needed.
 
-## Development Process
-
-Since you deploy code to a real AWS account, it's best to have a dedicated environment only for yourself. It could be your personal environment or an environment created for a feature. That is [common practice when developing serverless systems](https://theburningmonk.com/2019/09/why-you-should-use-temporary-stacks-when-you-do-serverless/). If that's not feasible due to organizational or technical reasons, use Observability Mode.
-
-## Observability Mode
-
-In Observability Mode, Lambda Live Debugger intercepts requests and sends them to your computer without waiting for a response. The Lambda continues as usual. The response from your machine is ignored. This mode can be used in the development, testing, or even, if you are adventurous, production environment. It samples requests every 3 seconds by default (configurable with an `interval` setting) to avoid overloading the system.
-
-## Monorepo Setup
-
-Set the `subfolder` parameter if your framework is in a subfolder.
-
 ## Removing
 
-To remove Lambda Live Debugger from your AWS account
+When you no longer want to debug and want Lambda to execute the code deployed to the cloud, you need to remove the Lambda Live Debugger:
 
 ```
 lld -r
@@ -195,6 +183,18 @@ To also remove the Layer:
 lld -r=all
 ```
 
+## Development Process
+
+Since you deploy code to a real AWS account, it's best to have a dedicated environment only for yourself. It could be your personal environment or an environment created for a feature. That is [common practice when developing serverless systems](https://theburningmonk.com/2019/09/why-you-should-use-temporary-stacks-when-you-do-serverless/). If that's not feasible due to organizational or technical reasons, use Observability Mode.
+
+## Observability Mode
+
+In Observability Mode, Lambda Live Debugger intercepts requests and sends them to your computer without waiting for a response. The Lambda continues as usual. The response from your machine is ignored. This mode can be used in the development, testing, or even, if you are adventurous, production environment. It samples requests every 3 seconds by default (configurable with an `interval` setting) to avoid overloading the system.
+
+## Monorepo Setup
+
+Set the `subfolder` parameter if your framework is in a subfolder.
+
 ## Frameworks
 
 ### AWS CDK v2

package/dist/extension/nodejs/node_modules/interceptor.js

@@ -53648,13 +53648,17 @@ function verbose(...args) {
 function setVerbose(enabled) {
   verboseEnabled = enabled;
 }
+function isVerbose() {
+  return verboseEnabled;
+}
 var Logger = {
   log,
   error,
   warn,
   important,
   verbose,
-  setVerbose
+  setVerbose,
+  isVerbose
 };
 
 // ../ioTService.ts
@@ -53764,6 +53768,7 @@ var IoTService = {
 var workerId = import_crypto5.default.randomBytes(16).toString("hex");
 var topic = `${process.env.LLD_DEBUGGER_ID}/events/${workerId}`;
 var ORIGINAL_HANDLER_KEY = "ORIGINAL_HANDLER";
+var originalHandlerName = process.env[ORIGINAL_HANDLER_KEY];
 var observableInterval = process.env.LLD_OBSERVABLE_INTERVAL ? parseInt(process.env.LLD_OBSERVABLE_INTERVAL) : 0;
 var lastObservableInvoke;
 if (process.env.LLD_VERBOSE === "true") {
@@ -53838,10 +53843,47 @@ async function regularMode(context, event) {
   return promise;
 }
 async function observableMode(context, event) {
-  const regularHandler = async () => {
-    const handler2 = await getOriginalHandler();
-    return await handler2(event, context);
-  };
+  let regularHandler = void 0;
+  if (process.env.LLD_INITIAL_AWS_LAMBDA_EXEC_WRAPPER) {
+    try {
+      Logger.log(
+        `Another extensions exists ${process.env.LLD_INITIAL_AWS_LAMBDA_EXEC_WRAPPER}.`
+      );
+      const { promisify } = require("util");
+      const exec = require("child_process").exec;
+      const execAsync = promisify(exec);
+      const fs = require("fs/promises");
+      const originalScript = await fs.readFile(
+        process.env.LLD_INITIAL_AWS_LAMBDA_EXEC_WRAPPER,
+        "utf8"
+      );
+      Logger.verbose("Original script", originalScript);
+      const script = `export _HANDLER=${process.env.ORIGINAL_HANDLER}
+                      ${originalScript}
+                      echo _HANDLER=$_HANDLER`;
+      Logger.verbose("Execute script", script);
+      const response2 = await execAsync(script);
+      Logger.verbose(`Output of the script: ${response2.stdout}`);
+      const handlerLine = response2.stdout.split("\n").find((line) => line.startsWith("_HANDLER"));
+      const oldHandler = handlerLine.split("=")[1];
+      Logger.verbose(`Getting handler "${oldHandler}" for another extension`);
+      regularHandler = async () => {
+        const handler2 = await getOriginalHandler(oldHandler);
+        return await handler2(event, context);
+      };
+    } catch (e) {
+      Logger.error(
+        `Error while running the initial AWS_LAMBDA_EXEC_WRAPPER: ${e.message}`,
+        e
+      );
+    }
+  }
+  if (!regularHandler) {
+    regularHandler = async () => {
+      const handler2 = await getOriginalHandler(originalHandlerName);
+      return await handler2(event, context);
+    };
+  }
   const observableHandler = async () => {
     if (observableInterval > 0) {
       if (lastObservableInvoke) {
@@ -53878,13 +53920,14 @@ async function observableMode(context, event) {
   const response = await regularHandlerPromise;
   return response;
 }
-async function getOriginalHandler() {
+async function getOriginalHandler(originalHandlerName2) {
+  Logger.verbose("Original handler:", originalHandlerName2);
   const { load } = await Promise.resolve().then(() => __toESM(require_UserFunction()));
-  if (process.env[ORIGINAL_HANDLER_KEY] === void 0)
+  if (originalHandlerName2 === void 0)
     throw Error("Missing original handler");
   return load(
     process.env.LAMBDA_TASK_ROOT,
-    process.env[ORIGINAL_HANDLER_KEY]
+    originalHandlerName2
   );
 }
 // Annotate the CommonJS export names for ESM import in node: