serverless-spy 0.0.36 → 0.0.38

package/lib/common/SpyEventSender.d.ts

@@ -0,0 +1,17 @@
+import { ApiGatewayManagementApi } from '@aws-sdk/client-apigatewaymanagementapi';
+import { AttributeValue, DynamoDBClient } from '@aws-sdk/client-dynamodb';
+export declare class SpyEventSender {
+    ddb: DynamoDBClient;
+    debugMode: boolean;
+    apigwManagementApi: ApiGatewayManagementApi;
+    connections: Record<string, AttributeValue>[] | undefined;
+    constructor(params?: {
+        log: (message: string, ...optionalParams: any[]) => void;
+        logError: (message: string, ...optionalParams: any[]) => void;
+    });
+    publishSpyEvent(event: any): Promise<void>;
+    private postData;
+    private getSpyEventType;
+    private log;
+    private logError;
+}

package/lib/common/SpyEventSender.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpyEventSender = void 0;
+const client_apigatewaymanagementapi_1 = require("@aws-sdk/client-apigatewaymanagementapi");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const envVariableNames_1 = require("../src/common/envVariableNames");
+class SpyEventSender {
+    constructor(params) {
+        this.ddb = new client_dynamodb_1.DynamoDBClient({
+            region: process.env.AWS_REGION,
+        });
+        this.debugMode = process.env[envVariableNames_1.envVariableNames.SSPY_DEBUG] === 'true';
+        this.apigwManagementApi = new client_apigatewaymanagementapi_1.ApiGatewayManagementApi({
+            apiVersion: '2018-11-29',
+            endpoint: process.env[envVariableNames_1.envVariableNames.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[envVariableNames_1.envVariableNames.SSPY_INFRA_MAPPING]);
+        this.log('ARN to names mapping', JSON.stringify(mapping));
+        let connectionData;
+        const scanParams = new client_dynamodb_1.ScanCommand({
+            TableName: process.env[envVariableNames_1.envVariableNames.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) {
+            //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 = 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') {
+            //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(this.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(this.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: (0, util_dynamodb_1.unmarshall)(record.dynamodb?.NewImage),
+                    keys: (0, util_dynamodb_1.unmarshall)(record.dynamodb?.Keys),
+                    oldImage: record.dynamodb?.OldImage
+                        ? (0, util_dynamodb_1.unmarshall)(record.dynamodb?.OldImage)
+                        : undefined,
+                };
+                const fluentEvent = {
+                    data,
+                    serviceKey: mapping[arn],
+                };
+                postDataPromises.push(this.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 = this.getSpyEventType(serviceKey);
+            const message = eventEb.detail;
+            const data = {
+                spyEventType,
+                detail: message,
+                detailType: eventEb['detail-type'],
+                eventBridgeId: eventEb['id'],
+                source: eventEb.source,
+                time: eventEb.time,
+                account: eventEb.account,
+            };
+            const fluentEvent = {
+                data,
+                serviceKey,
+            };
+            postDataPromises.push(this.postData(fluentEvent));
+        }
+        else {
+            //console.log('*** OTHER ***');
+            const fluentEvent = event;
+            postDataPromises.push(this.postData(fluentEvent));
+        }
+        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 {
+                const postToConnectionCommand = new client_apigatewaymanagementapi_1.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 client_dynamodb_1.DeleteItemCommand({
+                        TableName: process.env[envVariableNames_1.envVariableNames.SSPY_WS_TABLE_NAME],
+                        Key: { connectionId },
+                    });
+                    await this.ddb.send(deleteParams);
+                }
+                else {
+                    throw e;
+                }
+            }
+        });
+        await Promise.all(postCalls);
+        this.log('Send spy message finish');
+    }
+    getSpyEventType(serviceKey) {
+        if (!serviceKey) {
+            throw new Error('Missing serviceKey');
+        }
+        return serviceKey.substring(0, serviceKey.indexOf('#'));
+    }
+    log(message, ...optionalParams) {
+        if (this.debugMode) {
+            console.debug('SSPY EXTENSION', message, ...optionalParams);
+        }
+    }
+    logError(message, ...optionalParams) {
+        if (this.debugMode) {
+            console.error('SSPY EXTENSION', message, ...optionalParams);
+        }
+    }
+}
+exports.SpyEventSender = SpyEventSender;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SpyEventSender.js","sourceRoot":"","sources":["../../common/SpyEventSender.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\nexport class SpyEventSender {\n  ddb = new DynamoDBClient({\n    region: process.env.AWS_REGION,\n  });\n  debugMode = process.env[envVariableNames.SSPY_DEBUG] === 'true';\n  apigwManagementApi = new ApiGatewayManagementApi({\n    apiVersion: '2018-11-29',\n    endpoint: process.env[envVariableNames.SSPY_WS_ENDPOINT]!,\n  });\n  connections: Record<string, AttributeValue>[] | undefined;\n\n  constructor(params?: {\n    log: (message: string, ...optionalParams: any[]) => void;\n    logError: (message: string, ...optionalParams: any[]) => void;\n  }) {\n    if (params?.log) {\n      this.log = params.log;\n    }\n\n    if (params?.logError) {\n      this.logError = params.logError;\n    }\n  }\n\n  public async publishSpyEvent(event: any) {\n    this.log('Event', JSON.stringify(event));\n\n    const mapping = JSON.parse(\n      process.env[envVariableNames.SSPY_INFRA_MAPPING]!\n    );\n    this.log('ARN to names 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 this.ddb.send(scanParams);\n\n    this.connections = connectionData.Items;\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 = this.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(this.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(this.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(this.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(this.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 = this.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        eventBridgeId: eventEb['id'],\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(this.postData(fluentEvent));\n    } else {\n      //console.log('*** OTHER ***');\n      const fluentEvent: Omit<SpyMessage, 'timestamp'> = event;\n      postDataPromises.push(this.postData(fluentEvent));\n    }\n\n    await Promise.all(postDataPromises);\n  }\n\n  private async postData(spyMessage: Omit<SpyMessage, 'timestamp'>) {\n    this.log('Post spy message', JSON.stringify(spyMessage));\n\n    if (!this.connections) {\n      return;\n    }\n\n    const postCalls = this.connections.map(async ({ connectionId }) => {\n      this.log(`Sending message to client: ${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 this.apigwManagementApi.send(postToConnectionCommand);\n      } catch (e) {\n        this.logError(`Faild sending spy message to: ${connectionId.S}`, e);\n        if ((e as any).$metadata.httpStatusCode === 410) {\n          this.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 this.ddb.send(deleteParams);\n        } else {\n          throw e;\n        }\n      }\n    });\n\n    await Promise.all(postCalls);\n    this.log('Send spy message finish');\n  }\n\n  private getSpyEventType(serviceKey: string) {\n    if (!serviceKey) {\n      throw new Error('Missing serviceKey');\n    }\n\n    return serviceKey.substring(0, serviceKey.indexOf('#'));\n  }\n\n  private log(message: string, ...optionalParams: any[]) {\n    if (this.debugMode) {\n      console.debug('SSPY EXTENSION', message, ...optionalParams);\n    }\n  }\n\n  private logError(message: string, ...optionalParams: any[]) {\n    if (this.debugMode) {\n      console.error('SSPY EXTENSION', message, ...optionalParams);\n    }\n  }\n}\n"]}

package/lib/common/SpyEventSender.mjs

@@ -0,0 +1,223 @@
+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';
+export class SpyEventSender {
+    constructor(params) {
+        this.ddb = new DynamoDBClient({
+            region: process.env.AWS_REGION,
+        });
+        this.debugMode = process.env[envVariableNames.SSPY_DEBUG] === 'true';
+        this.apigwManagementApi = new ApiGatewayManagementApi({
+            apiVersion: '2018-11-29',
+            endpoint: process.env[envVariableNames.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[envVariableNames.SSPY_INFRA_MAPPING]);
+        this.log('ARN to names mapping', JSON.stringify(mapping));
+        let connectionData;
+        const scanParams = new ScanCommand({
+            TableName: process.env[envVariableNames.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) {
+            //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 = 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') {
+            //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(this.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(this.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(this.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 = this.getSpyEventType(serviceKey);
+            const message = eventEb.detail;
+            const data = {
+                spyEventType,
+                detail: message,
+                detailType: eventEb['detail-type'],
+                eventBridgeId: eventEb['id'],
+                source: eventEb.source,
+                time: eventEb.time,
+                account: eventEb.account,
+            };
+            const fluentEvent = {
+                data,
+                serviceKey,
+            };
+            postDataPromises.push(this.postData(fluentEvent));
+        }
+        else {
+            //console.log('*** OTHER ***');
+            const fluentEvent = event;
+            postDataPromises.push(this.postData(fluentEvent));
+        }
+        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 {
+                const postToConnectionCommand = new 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 DeleteItemCommand({
+                        TableName: process.env[envVariableNames.SSPY_WS_TABLE_NAME],
+                        Key: { connectionId },
+                    });
+                    await this.ddb.send(deleteParams);
+                }
+                else {
+                    throw e;
+                }
+            }
+        });
+        await Promise.all(postCalls);
+        this.log('Send spy message finish');
+    }
+    getSpyEventType(serviceKey) {
+        if (!serviceKey) {
+            throw new Error('Missing serviceKey');
+        }
+        return serviceKey.substring(0, serviceKey.indexOf('#'));
+    }
+    log(message, ...optionalParams) {
+        if (this.debugMode) {
+            console.debug('SSPY EXTENSION', message, ...optionalParams);
+        }
+    }
+    logError(message, ...optionalParams) {
+        if (this.debugMode) {
+            console.error('SSPY EXTENSION', message, ...optionalParams);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SpyEventSender.js","sourceRoot":"","sources":["../../common/SpyEventSender.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\nexport class SpyEventSender {\n  ddb = new DynamoDBClient({\n    region: process.env.AWS_REGION,\n  });\n  debugMode = process.env[envVariableNames.SSPY_DEBUG] === 'true';\n  apigwManagementApi = new ApiGatewayManagementApi({\n    apiVersion: '2018-11-29',\n    endpoint: process.env[envVariableNames.SSPY_WS_ENDPOINT]!,\n  });\n  connections: Record<string, AttributeValue>[] | undefined;\n\n  constructor(params?: {\n    log: (message: string, ...optionalParams: any[]) => void;\n    logError: (message: string, ...optionalParams: any[]) => void;\n  }) {\n    if (params?.log) {\n      this.log = params.log;\n    }\n\n    if (params?.logError) {\n      this.logError = params.logError;\n    }\n  }\n\n  public async publishSpyEvent(event: any) {\n    this.log('Event', JSON.stringify(event));\n\n    const mapping = JSON.parse(\n      process.env[envVariableNames.SSPY_INFRA_MAPPING]!\n    );\n    this.log('ARN to names 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 this.ddb.send(scanParams);\n\n    this.connections = connectionData.Items;\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 = this.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(this.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(this.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(this.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(this.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 = this.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        eventBridgeId: eventEb['id'],\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(this.postData(fluentEvent));\n    } else {\n      //console.log('*** OTHER ***');\n      const fluentEvent: Omit<SpyMessage, 'timestamp'> = event;\n      postDataPromises.push(this.postData(fluentEvent));\n    }\n\n    await Promise.all(postDataPromises);\n  }\n\n  private async postData(spyMessage: Omit<SpyMessage, 'timestamp'>) {\n    this.log('Post spy message', JSON.stringify(spyMessage));\n\n    if (!this.connections) {\n      return;\n    }\n\n    const postCalls = this.connections.map(async ({ connectionId }) => {\n      this.log(`Sending message to client: ${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 this.apigwManagementApi.send(postToConnectionCommand);\n      } catch (e) {\n        this.logError(`Faild sending spy message to: ${connectionId.S}`, e);\n        if ((e as any).$metadata.httpStatusCode === 410) {\n          this.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 this.ddb.send(deleteParams);\n        } else {\n          throw e;\n        }\n      }\n    });\n\n    await Promise.all(postCalls);\n    this.log('Send spy message finish');\n  }\n\n  private getSpyEventType(serviceKey: string) {\n    if (!serviceKey) {\n      throw new Error('Missing serviceKey');\n    }\n\n    return serviceKey.substring(0, serviceKey.indexOf('#'));\n  }\n\n  private log(message: string, ...optionalParams: any[]) {\n    if (this.debugMode) {\n      console.debug('SSPY EXTENSION', message, ...optionalParams);\n    }\n  }\n\n  private logError(message: string, ...optionalParams: any[]) {\n    if (this.debugMode) {\n      console.error('SSPY EXTENSION', message, ...optionalParams);\n    }\n  }\n}\n"]}

package/lib/common/getWebSocketUrl.d.ts

@@ -1,2 +1,2 @@
 import { Credentials } from '@aws-sdk/types';
-export declare function getWebSocketUrl(url: string, credentials?: Credentials): Promise<string>;
+export declare function getSignedWebSocketUrl(url: string, credentials?: Credentials): Promise<string>;

package/lib/common/getWebSocketUrl.js

@@ -1,19 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWebSocketUrl = void 0;
+exports.getSignedWebSocketUrl = void 0;
 const credential_providers_1 = require("@aws-sdk/credential-providers");
 const aws4 = require("aws4");
 // ""wss://m6g3w6ttdh.execute-api.eu-west-1.amazonaws.com/prod";"
-async function getWebSocketUrl(url, credentials) {
-    const urlParsed = parseUrl(url);
-    const hostParts = urlParsed.host.split('.');
+async function getSignedWebSocketUrl(url, credentials) {
+    let hostParts;
+    let pathname;
+    if (!url) {
+        throw new Error(`Missing websocket URL`);
+    }
+    try {
+        new URL(url); //validate URL
+        const urlParsed = parseUrl(url);
+        pathname = urlParsed.pathname;
+        hostParts = urlParsed.host.split('.');
+    }
+    catch {
+        throw new Error(`Invalid websocket URL ${url}`);
+    }
     if (!credentials) {
         const credentialsProvider = (0, credential_providers_1.fromNodeProviderChain)();
         credentials = await credentialsProvider();
     }
     const AWS_REGION = hostParts[2]; // The region of your API-gateway
     const SOCKET_HOST = hostParts[0]; // Your API-gateway ID
-    const ENV = urlParsed.pathname.replace(/^\//, ''); // The stage of your target deployment
+    const ENV = pathname.replace(/^\//, ''); // The stage of your target deployment
     const WEBSOCKET_URL = `${SOCKET_HOST}.execute-api.${AWS_REGION}.amazonaws.com`; // Don't prepend with wss!
     // const AWS_REGION = "eu-west-1"; // The region of your API-gateway
     // const SOCKET_HOST = "m6g3w6ttdh"; // Your API-gateway ID
@@ -38,7 +50,7 @@ async function getWebSocketUrl(url, credentials) {
     const url2 = `wss://${WEBSOCKET_URL}${path}`;
     return url2;
 }
-exports.getWebSocketUrl = getWebSocketUrl;
+exports.getSignedWebSocketUrl = getSignedWebSocketUrl;
 function parseUrl(href) {
     const match = href.match(/^(wss?:)\/\/(([^:/?#]*)(?::([0-9]+))?)([/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/);
     return (match && {
@@ -52,4 +64,4 @@ function parseUrl(href) {
         hash: match[7],
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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