serverless-spy 0.0.32 → 0.0.34

package/.jsii

@@ -3149,7 +3149,7 @@
         },
         "locationInModule": {
           "filename": "src/ServerlessSpy.ts",
-          "line": 43
+          "line": 37
         },
         "parameters": [
           {
@@ -3176,7 +3176,7 @@
       "kind": "class",
       "locationInModule": {
         "filename": "src/ServerlessSpy.ts",
-        "line": 24
+        "line": 25
       },
       "methods": [
         {
@@ -3185,7 +3185,7 @@
           },
           "locationInModule": {
             "filename": "src/ServerlessSpy.ts",
-            "line": 469
+            "line": 493
           },
           "name": "getConstructName",
           "parameters": [
@@ -3211,7 +3211,7 @@
           },
           "locationInModule": {
             "filename": "src/ServerlessSpy.ts",
-            "line": 39
+            "line": 34
           },
           "name": "serviceKeys",
           "type": {
@@ -3229,7 +3229,7 @@
           },
           "locationInModule": {
             "filename": "src/ServerlessSpy.ts",
-            "line": 41
+            "line": 35
           },
           "name": "wsUrl",
           "type": {
@@ -3249,7 +3249,7 @@
       "kind": "interface",
       "locationInModule": {
         "filename": "src/ServerlessSpy.ts",
-        "line": 20
+        "line": 21
       },
       "name": "ServerlessSpyProps",
       "properties": [
@@ -3261,7 +3261,7 @@
           "immutable": true,
           "locationInModule": {
             "filename": "src/ServerlessSpy.ts",
-            "line": 21
+            "line": 22
           },
           "name": "generateSpyEventsFileLocation",
           "optional": true,
@@ -3273,6 +3273,6 @@
       "symbolId": "src/ServerlessSpy:ServerlessSpyProps"
     }
   },
-  "version": "0.0.32",
-  "fingerprint": "Lly28xuuNsA7KsQvFz88vDGS3Ud6VJ5mBWvOmE0UlaE="
+  "version": "0.0.34",
+  "fingerprint": "VlGyOqTBqt3S7lh687Y1De02BbMROvvJmMqb0uEIX00="
 }

package/common/publishSpyEvent.ts

@@ -0,0 +1,269 @@
+import {
+  ApiGatewayManagementApi,
+  PostToConnectionCommand,
+} from '@aws-sdk/client-apigatewaymanagementapi';
+import {
+  AttributeValue,
+  DeleteItemCommand,
+  DynamoDBClient,
+  ScanCommand,
+} from '@aws-sdk/client-dynamodb';
+
+import { unmarshall } from '@aws-sdk/util-dynamodb';
+import {
+  DynamoDBStreamEvent,
+  S3Event,
+  SNSEvent,
+  EventBridgeEvent,
+  SQSEvent,
+} from 'aws-lambda';
+import { envVariableNames } from '../src/common/envVariableNames';
+import { DynamoDBSpyEvent } from './spyEvents/DynamoDBSpyEvent';
+import { EventBridgeRuleSpyEvent } from './spyEvents/EventBridgeRuleSpyEvent';
+import { EventBridgeSpyEvent } from './spyEvents/EventBridgeSpyEvent';
+import { S3SpyEvent } from './spyEvents/S3SpyEvent';
+import { SnsSubscriptionSpyEvent } from './spyEvents/SnsSubscriptionSpyEvent';
+import { SnsTopicSpyEvent } from './spyEvents/SnsTopicSpyEvent';
+import { SpyMessage } from './spyEvents/SpyMessage';
+import { SqsSpyEvent } from './spyEvents/SqsSpyEvent';
+
+const ddb = new DynamoDBClient({
+  region: process.env.AWS_REGION,
+});
+
+const apigwManagementApi = new ApiGatewayManagementApi({
+  apiVersion: '2018-11-29',
+  endpoint: process.env[envVariableNames.WS_ENDPOINT]!,
+});
+
+let connections: Record<string, AttributeValue>[] | undefined;
+
+export async function publishSpyEvent(event: any) {
+  console.log('EVENT', JSON.stringify(event));
+
+  const mapping = JSON.parse(process.env[envVariableNames.INFRA_MAPPING]!);
+  console.log('mapping', JSON.stringify(mapping));
+
+  let connectionData;
+
+  const scanParams = new ScanCommand({
+    TableName: process.env[envVariableNames.TABLE_NAME] as string,
+    ProjectionExpression: 'connectionId',
+  });
+
+  connectionData = await ddb.send(scanParams);
+
+  connections = connectionData.Items;
+
+  console.log(
+    `connections at ${new Date().toISOString()}`,
+    JSON.stringify(connections)
+  );
+
+  const postDataPromises: Promise<any>[] = [];
+
+  if (event?.Records && event.Records[0]?.Sns) {
+    console.log('*** SNS ***');
+    const eventSns = event as SNSEvent;
+    for (const record of eventSns.Records) {
+      const subscriptionArn = record.EventSubscriptionArn;
+
+      let serviceKey: string;
+      if (mapping[subscriptionArn]) {
+        // subscription event that could contain filter based on existing subscription
+        serviceKey = mapping[subscriptionArn];
+      } else {
+        // catch all subscription
+        const topicArn = record.Sns.TopicArn;
+        serviceKey = mapping[topicArn];
+      }
+
+      let message: string;
+
+      try {
+        message = JSON.parse(record.Sns.Message);
+      } catch {
+        message = record.Sns.Message;
+      }
+
+      const spyEventType = getSpyEventType(serviceKey) as
+        | 'FunctionSnsTopic'
+        | 'FunctionSnsSubscription';
+
+      const data: SnsTopicSpyEvent | SnsSubscriptionSpyEvent = {
+        spyEventType,
+        message,
+        subject: record.Sns.Subject,
+        timestamp: record.Sns.Timestamp,
+        topicArn: record.Sns.TopicArn,
+        messageId: record.Sns.MessageId,
+        messageAttributes: record.Sns.MessageAttributes,
+      };
+
+      const fluentEvent: Omit<SpyMessage, 'timestamp'> = {
+        data,
+        serviceKey,
+      };
+      postDataPromises.push(postData(fluentEvent));
+    }
+  } else if (event?.Records && event.Records[0]?.eventSource === 'aws:sqs') {
+    console.log('*** SQS ***');
+    const eventSqs = event as SQSEvent;
+    for (const record of eventSqs.Records) {
+      const subscriptionArn = record.eventSourceARN;
+
+      const serviceKey = mapping[subscriptionArn];
+      let body: string;
+
+      try {
+        body = JSON.parse(record.body);
+      } catch {
+        body = record.body;
+      }
+
+      const data: SqsSpyEvent = {
+        spyEventType: 'Sqs',
+        body,
+        messageAttributes: record.messageAttributes,
+      };
+
+      const fluentEvent: Omit<SpyMessage, 'timestamp'> = {
+        data,
+        serviceKey,
+      };
+      postDataPromises.push(postData(fluentEvent));
+    }
+  } else if (event?.Records && event.Records[0]?.s3) {
+    console.log('*** S3 ***');
+    const eventS3 = event as S3Event;
+    for (const record of eventS3.Records) {
+      const bucketArn = record.s3.bucket.arn;
+
+      const data: S3SpyEvent = {
+        spyEventType: 'S3',
+        eventName: record.eventName,
+        eventTime: record.eventTime,
+        bucket: record.s3.bucket.name,
+        key: record.s3.object.key,
+      };
+
+      const fluentEvent: Omit<SpyMessage, 'timestamp'> = {
+        data,
+        serviceKey: mapping[bucketArn],
+      };
+      postDataPromises.push(postData(fluentEvent));
+    }
+  } else if (event.Records && event.Records[0]?.dynamodb) {
+    console.log('*** DYNAMODB ***');
+    const eventDynamoDB = event as DynamoDBStreamEvent;
+    for (const record of eventDynamoDB.Records) {
+      let arn = record.eventSourceARN!;
+      arn = arn.substring(0, arn.indexOf('/stream/'));
+
+      const data: DynamoDBSpyEvent = {
+        spyEventType: 'DynamoDB',
+        eventName: record.eventName,
+        newImage: unmarshall(record.dynamodb?.NewImage as any),
+        keys: unmarshall(record.dynamodb?.Keys as any),
+        oldImage: record.dynamodb?.OldImage
+          ? unmarshall(record.dynamodb?.OldImage as any)
+          : undefined,
+      };
+
+      const fluentEvent: Omit<SpyMessage, 'timestamp'> = {
+        data,
+        serviceKey: mapping[arn],
+      };
+      postDataPromises.push(postData(fluentEvent));
+    }
+  } else if (
+    event.detail &&
+    event['detail-type'] &&
+    event.version &&
+    event.source
+  ) {
+    console.log('*** EventBridge ***');
+    const eventEb = event as EventBridgeEvent<any, any>;
+
+    const serviceKey = mapping.eventBridge; // the is new lambda for each subscription
+
+    const spyEventType = getSpyEventType(serviceKey) as
+      | 'EventBridge'
+      | 'EventBridgeRule';
+
+    const message = eventEb.detail;
+
+    const data: EventBridgeSpyEvent | EventBridgeRuleSpyEvent = {
+      spyEventType,
+      detail: message,
+      detailType: eventEb['detail-type'],
+      source: eventEb.source,
+      time: eventEb.time,
+      account: eventEb.account,
+    };
+
+    const fluentEvent: Omit<SpyMessage, 'timestamp'> = {
+      data,
+      serviceKey,
+    };
+    postDataPromises.push(postData(fluentEvent));
+  } else {
+    console.log('*** OTHER ***');
+    const fluentEvent: Omit<SpyMessage, 'timestamp'> = event;
+    postDataPromises.push(postData(fluentEvent));
+  }
+
+  await Promise.all(postDataPromises);
+}
+
+export async function postData(spyMessage: Omit<SpyMessage, 'timestamp'>) {
+  // const postData = JSON.parse(event.body!).data;
+  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 PostToConnectionCommand({
+        ConnectionId: connectionId.S,
+        Data: JSON.stringify({
+          timestamp: new Date().toISOString(),
+          serviceKey: spyMessage.serviceKey,
+          data: spyMessage.data,
+        }) as any,
+      });
+
+      await apigwManagementApi.send(postToConnectionCommand);
+    } catch (e) {
+      console.error(`Fails sending message to: ${connectionId.S}`, e);
+      console.error(`Status code: ${(e as any).statusCode}`);
+      if ((e as any).$metadata.httpStatusCode === 410) {
+        console.log(`Found stale connection, deleting ${connectionId}`);
+
+        const deleteParams = new DeleteItemCommand({
+          TableName: process.env[envVariableNames.TABLE_NAME],
+          Key: { connectionId },
+        });
+
+        await ddb.send(deleteParams);
+      } else {
+        throw e;
+      }
+    }
+  });
+
+  await Promise.all(postCalls);
+  console.log('Send message finish');
+}
+
+export function getSpyEventType(serviceKey: string) {
+  if (!serviceKey) {
+    throw new Error('Missing serviceKey');
+  }
+
+  return serviceKey.substring(0, serviceKey.indexOf('#'));
+}

package/dist/releasetag.txt

@@ -1 +1 @@
-v0.0.32
+v0.0.34

package/extension/interceptor.ts

@@ -1,14 +1,18 @@
 import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
 import { Callback, Context, Handler } from 'aws-lambda';
+import { publishSpyEvent } from '../common/publishSpyEvent';
 import { FunctionContext } from '../common/spyEvents/FunctionContext';
 import { FunctionErrorSpyEvent } from '../common/spyEvents/FunctionErrorSpyEvent';
 import { FunctionRequestSpyEvent } from '../common/spyEvents/FunctionRequestSpyEvent';
 import { FunctionResponseSpyEvent } from '../common/spyEvents/FunctionResponseSpyEvent';
+import { envVariableNames } from '../src/common/envVariableNames';
 import { load } from './aws/UserFunction';
 
 const ORIGINAL_HANDLER_KEY = 'ORIGINAL_HANDLER';
-const fluentTestSendFunctionName = process.env.FLUENT_TEST_SEND_FUNCTION_NAME;
-const subscribedToSQS = process.env.FLUENT_TEST_SUBSCRIBED_TO_SQS === 'true';
+const fluentTestSendFunctionName =
+  process.env[envVariableNames.FLUENT_TEST_SEND_FUNCTION_NAME];
+const subscribedToSQS =
+  process.env[envVariableNames.FLUENT_TEST_SUBSCRIBED_TO_SQS] === 'true';
 
 const lambdaClient = new LambdaClient({});
 
@@ -37,7 +41,7 @@ export const handler = (
   };
 
   console.log('EXTENSION REQUEST:', JSON.stringify(event));
-  const key = `Function#${process.env.FUNCTION_NAME}#Request`;
+  const key = `Function#${process.env[envVariableNames.FUNCTION_NAME]}#Request`;
   const p = sendLambdaSpyEvent(key, <FunctionRequestSpyEvent>{
     request: event,
     context: contextSpy,
@@ -47,7 +51,8 @@ export const handler = (
   const originalHandler = getOriginalHandler();
 
   const fail = (error: any) => {
-    const key = `Function#${process.env.FUNCTION_NAME}#Error`;
+    console.error('FAIL', error);
+    const key = `Function#${process.env[envVariableNames.FUNCTION_NAME]}#Error`;
     const p = sendLambdaSpyEvent(key, <FunctionErrorSpyEvent>{
       request: event,
       error,
@@ -59,7 +64,9 @@ export const handler = (
 
   const succeed = (response: any) => {
     console.log('EXTENSION RESPONSE:', JSON.stringify(response));
-    const key = `Function#${process.env.FUNCTION_NAME}#Response`;
+    const key = `Function#${
+      process.env[envVariableNames[envVariableNames.FUNCTION_NAME]]
+    }#Response`;
     const p = sendLambdaSpyEvent(key, <FunctionResponseSpyEvent>{
       request: event,
       response,
@@ -71,7 +78,7 @@ export const handler = (
 
   const newCallback = (err: any, data: any) => {
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    (err ? fail(data) : succeed(data)).then(() => {
+    (err ? fail(err) : succeed(data)).then(() => {
       callback(err, data);
     });
   };
@@ -125,13 +132,17 @@ async function sendLambdaSpyEvent(
 }
 
 async function sendRawSpyEvent(data: any) {
-  const command = new InvokeCommand({
-    FunctionName: fluentTestSendFunctionName,
-    InvocationType: 'RequestResponse',
-    LogType: 'Tail',
-    Payload: JSON.stringify(data) as any,
-  });
-  await lambdaClient.send(command);
+  await publishSpyEvent(data);
+
+  // console.log('EXTENSION SPY EVENT:', JSON.stringify(data));
+
+  // const command = new InvokeCommand({
+  //   FunctionName: fluentTestSendFunctionName,
+  //   InvocationType: 'RequestResponse',
+  //   LogType: 'Tail',
+  //   Payload: JSON.stringify(data) as any,
+  // });
+  // await lambdaClient.send(command);
 }
 
 function getOriginalHandler(): Handler {

package/functions/onConnect.ts

@@ -1,5 +1,6 @@
 import { DynamoDBClient, PutItemCommand } from '@aws-sdk/client-dynamodb';
 import { APIGatewayEvent } from 'aws-lambda';
+import { envVariableNames } from '../src/common/envVariableNames';
 
 const ddb = new DynamoDBClient({
   region: process.env.AWS_REGION,
@@ -9,7 +10,7 @@ exports.handler = async (event: APIGatewayEvent) => {
   console.log('EVENT', JSON.stringify(event));
 
   const putParams = new PutItemCommand({
-    TableName: process.env.TABLE_NAME as string,
+    TableName: process.env[envVariableNames.TABLE_NAME] as string,
     Item: {
       connectionId: { S: event.requestContext.connectionId! },
     },

package/functions/onDisconnect.ts

@@ -1,5 +1,6 @@
 import { DeleteItemCommand, DynamoDBClient } from '@aws-sdk/client-dynamodb';
 import { APIGatewayEvent } from 'aws-lambda';
+import { envVariableNames } from '../src/common/envVariableNames';
 
 const ddb = new DynamoDBClient({
   region: process.env.AWS_REGION,
@@ -8,7 +9,7 @@ export const handler = async (event: APIGatewayEvent) => {
   console.log('EVENT', JSON.stringify(event));
 
   const deleteParams = new DeleteItemCommand({
-    TableName: process.env.TABLE_NAME,
+    TableName: process.env[envVariableNames.TABLE_NAME],
     Key: {
       connectionId: { S: event.requestContext.connectionId! },
     },