serverless-spy 0.0.33 → 0.0.35

package/lib/common/publishSpyEvent.mjs

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