lambda-live-debugger 1.12.2 → 1.12.3

package/dist/infraDeploy.mjs

@@ -7,6 +7,7 @@ import { Configuration } from './configuration.mjs';
 import { AwsCredentials } from './awsCredentials.mjs';
 import { getModuleDirname } from './getDirname.mjs';
 import { Logger } from './logger.mjs';
+import { runWithConcurrency } from './utils/runWithConcurrency.mjs';
 import * as crypto from 'crypto';
 let lambdaClient;
 let iamClient;
@@ -46,6 +47,9 @@ function getLambdaClient() {
                 profile: Configuration.config.profile,
                 role: Configuration.config.role,
             }),
+            // client-side rate limiting and generous retries to avoid TooManyRequestsException
+            retryMode: 'adaptive',
+            maxAttempts: 10,
         });
     }
     return lambdaClient;
@@ -63,6 +67,9 @@ function getIAMClient() {
                 profile: Configuration.config.profile,
                 role: Configuration.config.role,
             }),
+            // client-side rate limiting and generous retries to avoid TooManyRequestsException
+            retryMode: 'adaptive',
+            maxAttempts: 10,
         });
     }
     return iamClient;
@@ -321,10 +328,10 @@ async function applyAddingInfra(changes) {
         Logger.verbose(`Using existing layer version: ${changes.existingLayerVersionArn}`);
         layerVersionArn = changes.existingLayerVersionArn;
     }
-    const promises = [];
+    const tasks = [];
     // Add LLD to functions
     for (const lambdaData of changes.lambdasToAdd) {
-        promises.push(addLayerToLambda({
+        tasks.push(() => addLayerToLambda({
             ...lambdaData,
             layers: [
                 layerVersionArn,
@@ -335,17 +342,17 @@ async function applyAddingInfra(changes) {
     }
     // Remove LLD from filtered functions
     for (const lambdaData of changes.lambdasToRemove) {
-        promises.push(removeLayerFromLambda(lambdaData));
+        tasks.push(() => removeLayerFromLambda(lambdaData));
     }
     // Add policies to roles
     for (const roleName of changes.rolesToAdd) {
-        promises.push(addPolicyToRole(roleName));
+        tasks.push(() => addPolicyToRole(roleName));
     }
     // Remove policies from roles
     for (const roleName of changes.rolesToRemove) {
-        promises.push(removePolicyFromLambdaRole(roleName));
+        tasks.push(() => removePolicyFromLambdaRole(roleName));
     }
-    await Promise.all(promises);
+    await runWithConcurrency(tasks);
 }
 /**
  * Get the planned infrastructure changes including removal from filtered functions
@@ -356,29 +363,27 @@ async function getInfraChangesForAdding() {
     const configLambdasAll = Configuration.getLambdasAll();
     const configLambdasUpdate = configLambdasAll.filter((l) => !(l.filteredOut === true));
     const configLambdasRemove = configLambdasAll.filter((l) => l.filteredOut === true);
-    const lambdasToUpdatePromise = Promise.all(configLambdasUpdate.map(async (func) => {
+    const lambdasToUpdatePromise = runWithConcurrency(configLambdasUpdate.map((func) => async () => {
         const lambdaUpdate = await analyzeLambdaAdd(func.functionName, existingLayer?.LayerVersionArn);
         return lambdaUpdate;
     }));
-    const lambdasToRemovePromise = Promise.all(configLambdasRemove.map(async (func) => {
-        return analyzeLambdaRemove(func.functionName);
-    }));
+    const lambdasToRemovePromise = runWithConcurrency(configLambdasRemove.map((func) => () => analyzeLambdaRemove(func.functionName)));
     // Get all role names for lambdas to update, ensure uniqueness, then analyze
     const roleNamesToAddSet = new Set();
-    const roleNamesToAddPromise = Promise.all(configLambdasUpdate.map(async (func) => {
+    const roleNamesToAddPromise = runWithConcurrency(configLambdasUpdate.map((func) => async () => {
         const roleName = await getRoleNameFromFunction(func.functionName);
         roleNamesToAddSet.add(roleName);
     }));
     // Get all role names for lambdas to remove, ensure uniqueness, then analyze
     const roleNamesToRemoveSet = new Set();
-    const roleNamesToRemovePromise = Promise.all(configLambdasRemove.map(async (func) => {
+    const roleNamesToRemovePromise = runWithConcurrency(configLambdasRemove.map((func) => async () => {
         const roleName = await getRoleNameFromFunction(func.functionName);
         roleNamesToRemoveSet.add(roleName);
     }));
     // Analyze roles to add
     await roleNamesToAddPromise;
     const roleNamesToAdd = Array.from(roleNamesToAddSet);
-    const rolesToAddPromise = Promise.all(roleNamesToAdd.map(async (roleName) => {
+    const rolesToAddPromise = runWithConcurrency(roleNamesToAdd.map((roleName) => async () => {
         const roleUpdate = await analyzeRoleAdd(roleName);
         return roleUpdate.addPolicy ? roleUpdate.roleName : undefined;
     }));
@@ -387,7 +392,7 @@ async function getInfraChangesForAdding() {
     let roleNamesToRemove = Array.from(roleNamesToRemoveSet);
     // make sure that roles removed are not in the list to add
     roleNamesToRemove = roleNamesToRemove.filter((role) => !roleNamesToAdd.includes(role));
-    const rolesToRemovePromise = Promise.all(roleNamesToRemove.map(async (roleName) => {
+    const rolesToRemovePromise = runWithConcurrency(roleNamesToRemove.map((roleName) => async () => {
         const roleRemoval = await analyzeRoleRemove(roleName);
         return roleRemoval.needToRemovePolicy ? roleRemoval.roleName : undefined;
     }));
@@ -488,17 +493,15 @@ async function analyzeLambdaRemove(functionName) {
 async function getInfraChangesForRemoving() {
     Logger.verbose('Analyzing infrastructure changes for removing Lambda Live Debugger');
     const allLambdas = Configuration.getLambdasAll();
-    const lambdasToRemovePromise = Promise.all(allLambdas.map(async (func) => {
-        return analyzeLambdaRemove(func.functionName);
-    }));
+    const lambdasToRemovePromise = runWithConcurrency(allLambdas.map((func) => () => analyzeLambdaRemove(func.functionName)));
     // Get all role names for lambdas to remove, ensure uniqueness, then analyze
     const roleNamesToRemoveSet = new Set();
-    await Promise.all(allLambdas.map(async (func) => {
+    await runWithConcurrency(allLambdas.map((func) => async () => {
         const roleName = await getRoleNameFromFunction(func.functionName);
         roleNamesToRemoveSet.add(roleName);
     }));
     const roleNamesToRemove = Array.from(roleNamesToRemoveSet);
-    const rolesToRemovePromise = Promise.all(roleNamesToRemove.map(async (roleName) => {
+    const rolesToRemovePromise = runWithConcurrency(roleNamesToRemove.map((roleName) => async () => {
         const roleRemoval = await analyzeRoleRemove(roleName);
         return roleRemoval.needToRemovePolicy ? roleRemoval.roleName : undefined;
     }));
@@ -516,14 +519,14 @@ async function getInfraChangesForRemoving() {
  */
 async function applyRemoveInfra(changes) {
     Logger.verbose('Starting infrastructure removal');
-    const promises = [];
+    const tasks = [];
     for (const lambdaData of changes.lambdasToRemove) {
-        promises.push(removeLayerFromLambda(lambdaData));
+        tasks.push(() => removeLayerFromLambda(lambdaData));
     }
     for (const roleName of changes.rolesToRemove) {
-        promises.push(removePolicyFromLambdaRole(roleName));
+        tasks.push(() => removePolicyFromLambdaRole(roleName));
     }
-    await Promise.all(promises);
+    await runWithConcurrency(tasks);
 }
 /**
  * Get the Lambda function configuration including layers, environment variables, and timeout

package/dist/utils/runWithConcurrency.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Run async tasks with a limited number of tasks running concurrently,
+ * for example to avoid hitting AWS API rate limits.
+ * @param tasks
+ * @param limit
+ * @returns results in the same order as the tasks
+ */
+export declare function runWithConcurrency<T>(tasks: (() => Promise<T>)[], limit?: number): Promise<T[]>;

package/dist/utils/runWithConcurrency.mjs

@@ -0,0 +1,19 @@
+/**
+ * Run async tasks with a limited number of tasks running concurrently,
+ * for example to avoid hitting AWS API rate limits.
+ * @param tasks
+ * @param limit
+ * @returns results in the same order as the tasks
+ */
+export async function runWithConcurrency(tasks, limit = 5) {
+    const results = new Array(tasks.length);
+    let nextTaskIndex = 0;
+    const workers = Array.from({ length: Math.min(limit, tasks.length) }, async () => {
+        while (nextTaskIndex < tasks.length) {
+            const taskIndex = nextTaskIndex++;
+            results[taskIndex] = await tasks[taskIndex]();
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}

package/package.json

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