serverless-spy 0.0.36 → 0.0.37

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

@@ -25658,7 +25658,7 @@ __export(interceptor_exports, {
 });
 module.exports = __toCommonJS(interceptor_exports);
 
-// common/publishSpyEvent.ts
+// common/SpyEventSender.ts
 var import_client_apigatewaymanagementapi = __toESM(require_dist_cjs44());
 var import_client_dynamodb = __toESM(require_dist_cjs48());
 var import_util_dynamodb = __toESM(require_dist_cjs49());
@@ -25674,192 +25674,204 @@ var envVariableNames = /* @__PURE__ */ ((envVariableNames2) => {
   return envVariableNames2;
 })(envVariableNames || {});
 
-// common/publishSpyEvent.ts
-var ddb = new import_client_dynamodb.DynamoDBClient({
-  region: process.env.AWS_REGION
-});
-var apigwManagementApi = new import_client_apigatewaymanagementapi.ApiGatewayManagementApi({
-  apiVersion: "2018-11-29",
-  endpoint: process.env["SSPY_WS_ENDPOINT" /* SSPY_WS_ENDPOINT */]
-});
-var connections;
-async function publishSpyEvent(event) {
-  console.log("EVENT", JSON.stringify(event));
-  const mapping = JSON.parse(process.env["SSPY_INFRA_MAPPING" /* SSPY_INFRA_MAPPING */]);
-  console.log("mapping", JSON.stringify(mapping));
-  let connectionData;
-  const scanParams = new import_client_dynamodb.ScanCommand({
-    TableName: process.env["SSPY_WS_TABLE_NAME" /* SSPY_WS_TABLE_NAME */],
-    ProjectionExpression: "connectionId"
-  });
-  connectionData = await ddb.send(scanParams);
-  connections = connectionData.Items;
-  console.log(
-    `connections at ${new Date().toISOString()}`,
-    JSON.stringify(connections)
-  );
-  const postDataPromises = [];
-  if (event?.Records && event.Records[0]?.Sns) {
-    console.log("*** SNS ***");
-    const eventSns = event;
-    for (const record of eventSns.Records) {
-      const subscriptionArn = record.EventSubscriptionArn;
-      let serviceKey;
-      if (mapping[subscriptionArn]) {
-        serviceKey = mapping[subscriptionArn];
-      } else {
-        const topicArn = record.Sns.TopicArn;
-        serviceKey = mapping[topicArn];
-      }
-      let message;
-      try {
-        message = JSON.parse(record.Sns.Message);
-      } catch {
-        message = record.Sns.Message;
+// common/SpyEventSender.ts
+var SpyEventSender = class {
+  constructor(params) {
+    this.ddb = new import_client_dynamodb.DynamoDBClient({
+      region: process.env.AWS_REGION
+    });
+    this.debugMode = process.env["SSPY_DEBUG" /* SSPY_DEBUG */] === "true";
+    this.apigwManagementApi = new import_client_apigatewaymanagementapi.ApiGatewayManagementApi({
+      apiVersion: "2018-11-29",
+      endpoint: process.env["SSPY_WS_ENDPOINT" /* SSPY_WS_ENDPOINT */]
+    });
+    if (params?.log) {
+      this.log = params.log;
+    }
+    if (params?.logError) {
+      this.logError = params.logError;
+    }
+  }
+  async publishSpyEvent(event) {
+    this.log("Event", JSON.stringify(event));
+    const mapping = JSON.parse(
+      process.env["SSPY_INFRA_MAPPING" /* SSPY_INFRA_MAPPING */]
+    );
+    this.log("ARN to names mapping", JSON.stringify(mapping));
+    let connectionData;
+    const scanParams = new import_client_dynamodb.ScanCommand({
+      TableName: process.env["SSPY_WS_TABLE_NAME" /* SSPY_WS_TABLE_NAME */],
+      ProjectionExpression: "connectionId"
+    });
+    connectionData = await this.ddb.send(scanParams);
+    this.connections = connectionData.Items;
+    const postDataPromises = [];
+    if (event?.Records && event.Records[0]?.Sns) {
+      const eventSns = event;
+      for (const record of eventSns.Records) {
+        const subscriptionArn = record.EventSubscriptionArn;
+        let serviceKey;
+        if (mapping[subscriptionArn]) {
+          serviceKey = mapping[subscriptionArn];
+        } else {
+          const topicArn = record.Sns.TopicArn;
+          serviceKey = mapping[topicArn];
+        }
+        let message;
+        try {
+          message = JSON.parse(record.Sns.Message);
+        } catch {
+          message = record.Sns.Message;
+        }
+        const spyEventType = this.getSpyEventType(serviceKey);
+        const data = {
+          spyEventType,
+          message,
+          subject: record.Sns.Subject,
+          timestamp: record.Sns.Timestamp,
+          topicArn: record.Sns.TopicArn,
+          messageId: record.Sns.MessageId,
+          messageAttributes: record.Sns.MessageAttributes
+        };
+        const fluentEvent = {
+          data,
+          serviceKey
+        };
+        postDataPromises.push(this.postData(fluentEvent));
+      }
+    } else if (event?.Records && event.Records[0]?.eventSource === "aws:sqs") {
+      const eventSqs = event;
+      for (const record of eventSqs.Records) {
+        const subscriptionArn = record.eventSourceARN;
+        const serviceKey = mapping[subscriptionArn];
+        let body;
+        try {
+          body = JSON.parse(record.body);
+        } catch {
+          body = record.body;
+        }
+        const data = {
+          spyEventType: "Sqs",
+          body,
+          messageAttributes: record.messageAttributes
+        };
+        const fluentEvent = {
+          data,
+          serviceKey
+        };
+        postDataPromises.push(this.postData(fluentEvent));
+      }
+    } else if (event?.Records && event.Records[0]?.s3) {
+      const eventS3 = event;
+      for (const record of eventS3.Records) {
+        const bucketArn = record.s3.bucket.arn;
+        const data = {
+          spyEventType: "S3",
+          eventName: record.eventName,
+          eventTime: record.eventTime,
+          bucket: record.s3.bucket.name,
+          key: record.s3.object.key
+        };
+        const fluentEvent = {
+          data,
+          serviceKey: mapping[bucketArn]
+        };
+        postDataPromises.push(this.postData(fluentEvent));
+      }
+    } else if (event.Records && event.Records[0]?.dynamodb) {
+      const eventDynamoDB = event;
+      for (const record of eventDynamoDB.Records) {
+        let arn = record.eventSourceARN;
+        arn = arn.substring(0, arn.indexOf("/stream/"));
+        const data = {
+          spyEventType: "DynamoDB",
+          eventName: record.eventName,
+          newImage: (0, import_util_dynamodb.unmarshall)(record.dynamodb?.NewImage),
+          keys: (0, import_util_dynamodb.unmarshall)(record.dynamodb?.Keys),
+          oldImage: record.dynamodb?.OldImage ? (0, import_util_dynamodb.unmarshall)(record.dynamodb?.OldImage) : void 0
+        };
+        const fluentEvent = {
+          data,
+          serviceKey: mapping[arn]
+        };
+        postDataPromises.push(this.postData(fluentEvent));
       }
-      const spyEventType = getSpyEventType(serviceKey);
+    } else if (event.detail && event["detail-type"] && event.version && event.source) {
+      const eventEb = event;
+      const serviceKey = mapping.eventBridge;
+      const spyEventType = this.getSpyEventType(serviceKey);
+      const message = eventEb.detail;
       const data = {
         spyEventType,
-        message,
-        subject: record.Sns.Subject,
-        timestamp: record.Sns.Timestamp,
-        topicArn: record.Sns.TopicArn,
-        messageId: record.Sns.MessageId,
-        messageAttributes: record.Sns.MessageAttributes
+        detail: message,
+        detailType: eventEb["detail-type"],
+        eventBridgeId: eventEb["id"],
+        source: eventEb.source,
+        time: eventEb.time,
+        account: eventEb.account
       };
       const fluentEvent = {
         data,
         serviceKey
       };
-      postDataPromises.push(postData(fluentEvent));
+      postDataPromises.push(this.postData(fluentEvent));
+    } else {
+      const fluentEvent = event;
+      postDataPromises.push(this.postData(fluentEvent));
     }
-  } else if (event?.Records && event.Records[0]?.eventSource === "aws:sqs") {
-    console.log("*** SQS ***");
-    const eventSqs = event;
-    for (const record of eventSqs.Records) {
-      const subscriptionArn = record.eventSourceARN;
-      const serviceKey = mapping[subscriptionArn];
-      let body;
+    await Promise.all(postDataPromises);
+  }
+  async postData(spyMessage) {
+    this.log("Post spy message", JSON.stringify(spyMessage));
+    if (!this.connections) {
+      return;
+    }
+    const postCalls = this.connections.map(async ({ connectionId }) => {
+      this.log(`Sending message to client: ${connectionId.S}`);
       try {
-        body = JSON.parse(record.body);
-      } catch {
-        body = record.body;
+        const postToConnectionCommand = new import_client_apigatewaymanagementapi.PostToConnectionCommand({
+          ConnectionId: connectionId.S,
+          Data: JSON.stringify({
+            timestamp: new Date().toISOString(),
+            serviceKey: spyMessage.serviceKey,
+            data: spyMessage.data
+          })
+        });
+        await this.apigwManagementApi.send(postToConnectionCommand);
+      } catch (e) {
+        this.logError(`Faild sending spy message to: ${connectionId.S}`, e);
+        if (e.$metadata.httpStatusCode === 410) {
+          this.log(`Found stale connection, deleting ${connectionId}`);
+          const deleteParams = new import_client_dynamodb.DeleteItemCommand({
+            TableName: process.env["SSPY_WS_TABLE_NAME" /* SSPY_WS_TABLE_NAME */],
+            Key: { connectionId }
+          });
+          await this.ddb.send(deleteParams);
+        } else {
+          throw e;
+        }
       }
-      const data = {
-        spyEventType: "Sqs",
-        body,
-        messageAttributes: record.messageAttributes
-      };
-      const fluentEvent = {
-        data,
-        serviceKey
-      };
-      postDataPromises.push(postData(fluentEvent));
-    }
-  } else if (event?.Records && event.Records[0]?.s3) {
-    console.log("*** S3 ***");
-    const eventS3 = event;
-    for (const record of eventS3.Records) {
-      const bucketArn = record.s3.bucket.arn;
-      const data = {
-        spyEventType: "S3",
-        eventName: record.eventName,
-        eventTime: record.eventTime,
-        bucket: record.s3.bucket.name,
-        key: record.s3.object.key
-      };
-      const fluentEvent = {
-        data,
-        serviceKey: mapping[bucketArn]
-      };
-      postDataPromises.push(postData(fluentEvent));
+    });
+    await Promise.all(postCalls);
+    this.log("Send spy message finish");
+  }
+  getSpyEventType(serviceKey) {
+    if (!serviceKey) {
+      throw new Error("Missing serviceKey");
     }
-  } else if (event.Records && event.Records[0]?.dynamodb) {
-    console.log("*** DYNAMODB ***");
-    const eventDynamoDB = event;
-    for (const record of eventDynamoDB.Records) {
-      let arn = record.eventSourceARN;
-      arn = arn.substring(0, arn.indexOf("/stream/"));
-      const data = {
-        spyEventType: "DynamoDB",
-        eventName: record.eventName,
-        newImage: (0, import_util_dynamodb.unmarshall)(record.dynamodb?.NewImage),
-        keys: (0, import_util_dynamodb.unmarshall)(record.dynamodb?.Keys),
-        oldImage: record.dynamodb?.OldImage ? (0, import_util_dynamodb.unmarshall)(record.dynamodb?.OldImage) : void 0
-      };
-      const fluentEvent = {
-        data,
-        serviceKey: mapping[arn]
-      };
-      postDataPromises.push(postData(fluentEvent));
+    return serviceKey.substring(0, serviceKey.indexOf("#"));
+  }
+  log(message, ...optionalParams) {
+    if (this.debugMode) {
+      console.debug("SSPY EXTENSION", message, ...optionalParams);
     }
-  } else if (event.detail && event["detail-type"] && event.version && event.source) {
-    console.log("*** EventBridge ***");
-    const eventEb = event;
-    const serviceKey = mapping.eventBridge;
-    const spyEventType = getSpyEventType(serviceKey);
-    const message = eventEb.detail;
-    const data = {
-      spyEventType,
-      detail: message,
-      detailType: eventEb["detail-type"],
-      source: eventEb.source,
-      time: eventEb.time,
-      account: eventEb.account
-    };
-    const fluentEvent = {
-      data,
-      serviceKey
-    };
-    postDataPromises.push(postData(fluentEvent));
-  } else {
-    console.log("*** OTHER ***");
-    const fluentEvent = event;
-    postDataPromises.push(postData(fluentEvent));
   }
-  await Promise.all(postDataPromises);
-}
-async function postData(spyMessage) {
-  console.log("postData", JSON.stringify(spyMessage));
-  if (!connections) {
-    return;
-  }
-  const postCalls = connections.map(async ({ connectionId }) => {
-    console.log(`Sending message to: ${connectionId.S}`);
-    try {
-      const postToConnectionCommand = new import_client_apigatewaymanagementapi.PostToConnectionCommand({
-        ConnectionId: connectionId.S,
-        Data: JSON.stringify({
-          timestamp: new Date().toISOString(),
-          serviceKey: spyMessage.serviceKey,
-          data: spyMessage.data
-        })
-      });
-      await apigwManagementApi.send(postToConnectionCommand);
-    } catch (e) {
-      console.error(`Fails sending message to: ${connectionId.S}`, e);
-      console.error(`Status code: ${e.statusCode}`);
-      if (e.$metadata.httpStatusCode === 410) {
-        console.log(`Found stale connection, deleting ${connectionId}`);
-        const deleteParams = new import_client_dynamodb.DeleteItemCommand({
-          TableName: process.env["SSPY_WS_TABLE_NAME" /* SSPY_WS_TABLE_NAME */],
-          Key: { connectionId }
-        });
-        await ddb.send(deleteParams);
-      } else {
-        throw e;
-      }
+  logError(message, ...optionalParams) {
+    if (this.debugMode) {
+      console.error("SSPY EXTENSION", message, ...optionalParams);
     }
-  });
-  await Promise.all(postCalls);
-  console.log("Send message finish");
-}
-function getSpyEventType(serviceKey) {
-  if (!serviceKey) {
-    throw new Error("Missing serviceKey");
   }
-  return serviceKey.substring(0, serviceKey.indexOf("#"));
-}
+};
 
 // extension/aws/UserFunction.ts
 var import_fs = __toESM(require("fs"));
@@ -25976,20 +25988,35 @@ var load = function(appRoot, fullHandlerString) {
 var ORIGINAL_HANDLER_KEY = "ORIGINAL_HANDLER";
 var subscribedToSQS = process.env["SSPY_SUBSCRIBED_TO_SQS" /* SSPY_SUBSCRIBED_TO_SQS */] === "true";
 var debugMode = process.env["SSPY_DEBUG" /* SSPY_DEBUG */] === "true";
+var oldConsoleLog = console.log;
+var oldConsoleWarn = console.warn;
+var oldConsoleDebug = console.debug;
+var oldConsoleInfo = console.info;
+var oldConsoleError = console.error;
+var currentEvent;
+var currentContext;
+var promises = [];
+interceptConsole();
+var spyEventSender = new SpyEventSender({
+  log,
+  logError
+});
 var handler = (event, context, callback) => {
-  log("Request", JSON.stringify(event));
-  const promises = [];
-  if (subscribedToSQS) {
-    log("Send raw message for SQS");
-    const p2 = sendRawSpyEvent(event);
-    promises.push(p2);
-  }
   const contextSpy = {
     functionName: context.functionName,
     awsRequestId: context.awsRequestId,
     identity: context.identity,
     clientContext: context.clientContext
   };
+  currentEvent = event;
+  currentContext = contextSpy;
+  promises = [];
+  log("Request", JSON.stringify(event));
+  if (subscribedToSQS) {
+    log("Send raw message for SQS");
+    const p2 = sendRawSpyEvent(event);
+    promises.push(p2);
+  }
   const key = `Function#${process.env["SSPY_FUNCTION_NAME" /* SSPY_FUNCTION_NAME */]}#Request`;
   const p = sendLambdaSpyEvent(key, {
     request: event,
@@ -26006,6 +26033,8 @@ var handler = (event, context, callback) => {
       context: contextSpy
     });
     promises.push(p2);
+    currentEvent = void 0;
+    currentContext = void 0;
     return Promise.all(promises);
   };
   const succeed = (response) => {
@@ -26017,6 +26046,8 @@ var handler = (event, context, callback) => {
       context: contextSpy
     });
     promises.push(p2);
+    currentEvent = void 0;
+    currentContext = void 0;
     return Promise.all(promises);
   };
   const newCallback = (err, data) => {
@@ -26047,6 +26078,45 @@ var handler = (event, context, callback) => {
     );
   }
 };
+function interceptConsole() {
+  const sendLogs = (type, args) => {
+    if (!currentContext)
+      return;
+    log(`Console ${type}`, JSON.stringify(args));
+    const message = args == null ? void 0 : args.shift();
+    const key = `Function#${process.env["SSPY_FUNCTION_NAME" /* SSPY_FUNCTION_NAME */]}#Console`;
+    const p = sendLambdaSpyEvent(key, {
+      request: currentEvent,
+      context: currentContext,
+      console: {
+        type,
+        message,
+        optionalParams: args
+      }
+    });
+    promises.push(p);
+  };
+  console.log = function(...args) {
+    sendLogs("log", args);
+    oldConsoleLog.apply(console, args);
+  };
+  console.warn = function(...args) {
+    sendLogs("warn", args);
+    oldConsoleWarn.apply(console, args);
+  };
+  console.debug = function(...args) {
+    sendLogs("debug", args);
+    oldConsoleDebug.apply(console, args);
+  };
+  console.info = function(...args) {
+    sendLogs("info", args);
+    oldConsoleInfo.apply(console, args);
+  };
+  console.error = function(...args) {
+    sendLogs("error", args);
+    oldConsoleError.apply(console, args);
+  };
+}
 function isPromise(obj) {
   return typeof (obj == null ? void 0 : obj.then) === "function";
 }
@@ -26057,7 +26127,7 @@ async function sendLambdaSpyEvent(serviceKey, data) {
   });
 }
 async function sendRawSpyEvent(data) {
-  await publishSpyEvent(data);
+  await spyEventSender.publishSpyEvent(data);
 }
 function getOriginalHandler() {
   log("Original handler", process.env[ORIGINAL_HANDLER_KEY]);
@@ -26070,12 +26140,12 @@ function getOriginalHandler() {
 }
 function log(message, ...optionalParams) {
   if (debugMode) {
-    console.debug("SSPY EXTENSION", message, ...optionalParams);
+    oldConsoleDebug("SSPY EXTENSION", message, ...optionalParams);
   }
 }
 function logError(message, ...optionalParams) {
   if (debugMode) {
-    console.error("SSPY EXTENSION", message, ...optionalParams);
+    oldConsoleError("SSPY EXTENSION", message, ...optionalParams);
   }
 }
 // Annotate the CommonJS export names for ESM import in node: