serverless-spy 0.0.35 → 0.0.37

package/common/SpyEventSender.ts

@@ -0,0 +1,291 @@
+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';
+
+export class SpyEventSender {
+  ddb = new DynamoDBClient({
+    region: process.env.AWS_REGION,
+  });
+  debugMode = process.env[envVariableNames.SSPY_DEBUG] === 'true';
+  apigwManagementApi = new ApiGatewayManagementApi({
+    apiVersion: '2018-11-29',
+    endpoint: process.env[envVariableNames.SSPY_WS_ENDPOINT]!,
+  });
+  connections: Record<string, AttributeValue>[] | undefined;
+
+  constructor(params?: {
+    log: (message: string, ...optionalParams: any[]) => void;
+    logError: (message: string, ...optionalParams: any[]) => void;
+  }) {
+    if (params?.log) {
+      this.log = params.log;
+    }
+
+    if (params?.logError) {
+      this.logError = params.logError;
+    }
+  }
+
+  public async publishSpyEvent(event: any) {
+    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] as string,
+      ProjectionExpression: 'connectionId',
+    });
+
+    connectionData = await this.ddb.send(scanParams);
+
+    this.connections = connectionData.Items;
+
+    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 = this.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(this.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(this.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(this.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(this.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 = this.getSpyEventType(serviceKey) as
+        | 'EventBridge'
+        | 'EventBridgeRule';
+
+      const message = eventEb.detail;
+
+      const data: EventBridgeSpyEvent | EventBridgeRuleSpyEvent = {
+        spyEventType,
+        detail: message,
+        detailType: eventEb['detail-type'],
+        eventBridgeId: eventEb['id'],
+        source: eventEb.source,
+        time: eventEb.time,
+        account: eventEb.account,
+      };
+
+      const fluentEvent: Omit<SpyMessage, 'timestamp'> = {
+        data,
+        serviceKey,
+      };
+      postDataPromises.push(this.postData(fluentEvent));
+    } else {
+      //console.log('*** OTHER ***');
+      const fluentEvent: Omit<SpyMessage, 'timestamp'> = event;
+      postDataPromises.push(this.postData(fluentEvent));
+    }
+
+    await Promise.all(postDataPromises);
+  }
+
+  private async postData(spyMessage: Omit<SpyMessage, 'timestamp'>) {
+    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,
+          }) as any,
+        });
+
+        await this.apigwManagementApi.send(postToConnectionCommand);
+      } catch (e) {
+        this.logError(`Faild sending spy message to: ${connectionId.S}`, e);
+        if ((e as any).$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');
+  }
+
+  private getSpyEventType(serviceKey: string) {
+    if (!serviceKey) {
+      throw new Error('Missing serviceKey');
+    }
+
+    return serviceKey.substring(0, serviceKey.indexOf('#'));
+  }
+
+  private log(message: string, ...optionalParams: any[]) {
+    if (this.debugMode) {
+      console.debug('SSPY EXTENSION', message, ...optionalParams);
+    }
+  }
+
+  private logError(message: string, ...optionalParams: any[]) {
+    if (this.debugMode) {
+      console.error('SSPY EXTENSION', message, ...optionalParams);
+    }
+  }
+}

package/common/getWebSocketUrl.ts

@@ -4,9 +4,26 @@ import * as aws4 from 'aws4';
 
 // ""wss://m6g3w6ttdh.execute-api.eu-west-1.amazonaws.com/prod";"
 
-export async function getWebSocketUrl(url: string, credentials?: Credentials) {
-  const urlParsed = parseUrl(url);
-  const hostParts = urlParsed!.host.split('.');
+export async function getSignedWebSocketUrl(
+  url: string,
+  credentials?: Credentials
+) {
+  let hostParts: string[];
+  let pathname: string;
+
+  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 = fromNodeProviderChain();
@@ -15,7 +32,7 @@ export async function getWebSocketUrl(url: string, credentials?: Credentials) {
 
   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

package/common/spyEvents/EventBridgeBaseSpyEvent.ts

@@ -0,0 +1,13 @@
+import { SpyEvent } from './SpyEvent';
+
+export interface EventBridgeBaseSpyEvent<
+  MessageType = any,
+  EventBridgeDetailType extends string = string
+> extends SpyEvent {
+  eventBridgeId: string;
+  detail: MessageType;
+  detailType: EventBridgeDetailType;
+  source: string;
+  time: string;
+  account: string;
+}

package/common/spyEvents/EventBridgeRuleSpyEvent.ts

@@ -1,13 +1,8 @@
-import { SpyEvent } from './SpyEvent';
+import { EventBridgeBaseSpyEvent } from './EventBridgeBaseSpyEvent';
 
 export interface EventBridgeRuleSpyEvent<
   MessageType = any,
   EventBridgeDetailType extends string = string
-> extends SpyEvent {
+> extends EventBridgeBaseSpyEvent<MessageType, EventBridgeDetailType> {
   spyEventType: 'EventBridgeRule';
-  detail: MessageType;
-  detailType: EventBridgeDetailType;
-  source: string;
-  time: string;
-  account: string;
 }

package/common/spyEvents/EventBridgeSpyEvent.ts

@@ -1,13 +1,8 @@
-import { SpyEvent } from './SpyEvent';
+import { EventBridgeBaseSpyEvent } from './EventBridgeBaseSpyEvent';
 
 export interface EventBridgeSpyEvent<
   MessageType = any,
   EventBridgeDetailType extends string = string
-> extends SpyEvent {
+> extends EventBridgeBaseSpyEvent<MessageType, EventBridgeDetailType> {
   spyEventType: 'EventBridge';
-  detail: MessageType;
-  detailType: EventBridgeDetailType;
-  source: string;
-  time: string;
-  account: string;
 }

package/common/spyEvents/FunctionBaseSpyEvent.ts

@@ -0,0 +1,7 @@
+import { FunctionContext } from './FunctionContext';
+import { SpyEvent } from './SpyEvent';
+
+export interface FunctionBaseSpyEvent<TData = any> extends SpyEvent {
+  request: TData;
+  context: FunctionContext;
+}

package/common/spyEvents/FunctionConsole.ts

@@ -0,0 +1,5 @@
+export type FunctionConsole = {
+  type: 'log' | 'debug' | 'info' | 'error' | 'warn';
+  message?: any;
+  optionalParams: any[];
+};

package/common/spyEvents/FunctionConsoleSpyEvent.ts

@@ -1,11 +1,8 @@
-import { SpyEvent } from './SpyEvent';
+import { FunctionBaseSpyEvent } from './FunctionBaseSpyEvent';
+import { FunctionConsole } from './FunctionConsole';
 
-export interface FunctionConsoleSpyEvent<TRequest = any> extends SpyEvent {
+export interface FunctionConsoleSpyEvent<TRequest = any>
+  extends FunctionBaseSpyEvent<TRequest> {
   spyEventType: 'FunctionConsole';
-  request: TRequest;
-  console: {
-    type: 'log' | 'debug' | 'info' | 'error' | 'warn';
-    message?: any;
-    optionalParams: any[];
-  };
+  console: FunctionConsole;
 }

package/common/spyEvents/FunctionResponseSpyEvent.ts

@@ -1,10 +1,7 @@
-import { FunctionContext } from './FunctionContext';
-import { SpyEvent } from './SpyEvent';
+import { FunctionBaseSpyEvent } from './FunctionBaseSpyEvent';
 
 export interface FunctionResponseSpyEvent<TRequest = any, TResponse = any>
-  extends SpyEvent {
+  extends FunctionBaseSpyEvent<TRequest> {
   spyEventType: 'FunctionResponse';
-  request: TRequest;
-  context: FunctionContext;
   response: TResponse;
 }

package/common/spyEvents/SnsSpyEventBase.ts

@@ -0,0 +1,11 @@
+import { SNSMessageAttributes } from 'aws-lambda';
+import { SpyEvent } from './SpyEvent';
+
+export interface SnsSpyEventBase<MessageType = any> extends SpyEvent {
+  message: MessageType;
+  subject: string;
+  timestamp: string;
+  topicArn: string;
+  messageId: string;
+  messageAttributes: SNSMessageAttributes;
+}

package/common/spyEvents/SnsSubscriptionSpyEvent.ts

@@ -1,12 +1,6 @@
-import { SNSMessageAttributes } from 'aws-lambda';
-import { SpyEvent } from './SpyEvent';
+import { SnsSpyEventBase } from './SnsSpyEventBase';
 
-export interface SnsSubscriptionSpyEvent<MessageType = any> extends SpyEvent {
+export interface SnsSubscriptionSpyEvent<MessageType = any>
+  extends SnsSpyEventBase<MessageType> {
   spyEventType: 'FunctionSnsSubscription';
-  message: MessageType;
-  subject: string;
-  timestamp: string;
-  topicArn: string;
-  messageId: string;
-  messageAttributes: SNSMessageAttributes;
 }

package/common/spyEvents/SnsTopicSpyEvent.ts

@@ -1,12 +1,6 @@
-import { SNSMessageAttributes } from 'aws-lambda';
-import { SpyEvent } from './SpyEvent';
+import { SnsSpyEventBase } from './SnsSpyEventBase';
 
-export interface SnsTopicSpyEvent<MessageType = any> extends SpyEvent {
+export interface SnsTopicSpyEvent<MessageType = any>
+  extends SnsSpyEventBase<MessageType> {
   spyEventType: 'FunctionSnsTopic';
-  message: MessageType;
-  subject: string;
-  timestamp: string;
-  topicArn: string;
-  messageId: string;
-  messageAttributes: SNSMessageAttributes;
 }

package/dist/releasetag.txt

@@ -1 +1 @@
-v0.0.35
+v0.0.37

package/extension/interceptor.ts

@@ -1,10 +1,10 @@
-import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
 import { Callback, Context, Handler } from 'aws-lambda';
-import { publishSpyEvent } from '../common/publishSpyEvent';
+import { FunctionConsoleSpyEvent } from '../common/spyEvents/FunctionConsoleSpyEvent';
 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 { SpyEventSender } from '../common/SpyEventSender';
 import { envVariableNames } from '../src/common/envVariableNames';
 import { load } from './aws/UserFunction';
 
@@ -13,7 +13,23 @@ const ORIGINAL_HANDLER_KEY = 'ORIGINAL_HANDLER';
 const subscribedToSQS =
   process.env[envVariableNames.SSPY_SUBSCRIBED_TO_SQS] === 'true';
 
-const lambdaClient = new LambdaClient({});
+const debugMode = process.env[envVariableNames.SSPY_DEBUG] === 'true';
+
+const oldConsoleLog = console.log;
+const oldConsoleWarn = console.warn;
+const oldConsoleDebug = console.debug;
+const oldConsoleInfo = console.info;
+const oldConsoleError = console.error;
+let currentEvent: any;
+let currentContext: FunctionContext | undefined;
+let promises: Promise<any>[] = [];
+
+interceptConsole();
+
+const spyEventSender = new SpyEventSender({
+  log,
+  logError,
+});
 
 // Wrap original handler.
 // Handler can be async or non-async:
@@ -23,15 +39,6 @@ export const handler = (
   context: Context,
   callback: Callback
 ): Promise<any> | undefined => {
-  const promises: Promise<any>[] = [];
-
-  if (subscribedToSQS) {
-    // send raw message
-    console.log('EXTENSION: Send raw message for SQS');
-    const p = sendRawSpyEvent(event);
-    promises.push(p);
-  }
-
   const contextSpy: FunctionContext = {
     functionName: context.functionName,
     awsRequestId: context.awsRequestId,
@@ -39,7 +46,20 @@ export const handler = (
     clientContext: context.clientContext,
   };
 
-  console.log('EXTENSION REQUEST:', JSON.stringify(event));
+  currentEvent = event;
+  currentContext = contextSpy;
+
+  promises = [];
+
+  log('Request', JSON.stringify(event));
+
+  if (subscribedToSQS) {
+    // send raw message
+    log('Send raw message for SQS');
+    const p = sendRawSpyEvent(event);
+    promises.push(p);
+  }
+
   const key = `Function#${
     process.env[envVariableNames.SSPY_FUNCTION_NAME]
   }#Request`;
@@ -52,7 +72,7 @@ export const handler = (
   const originalHandler = getOriginalHandler();
 
   const fail = (error: any) => {
-    console.error('FAIL', error);
+    logError(error);
     const key = `Function#${
       process.env[envVariableNames.SSPY_FUNCTION_NAME]
     }#Error`;
@@ -62,11 +82,13 @@ export const handler = (
       context: contextSpy,
     });
     promises.push(p);
+    currentEvent = undefined;
+    currentContext = undefined;
     return Promise.all(promises);
   };
 
   const succeed = (response: any) => {
-    console.log('EXTENSION RESPONSE:', JSON.stringify(response));
+    log('Response', JSON.stringify(response));
     const key = `Function#${
       process.env[envVariableNames[envVariableNames.SSPY_FUNCTION_NAME]]
     }#Response`;
@@ -76,6 +98,9 @@ export const handler = (
       context: contextSpy,
     });
     promises.push(p);
+    currentEvent = undefined;
+    currentContext = undefined;
+
     return Promise.all(promises);
   };
 
@@ -116,6 +141,59 @@ export const handler = (
   }
 };
 
+function interceptConsole() {
+  const sendLogs = (
+    type: 'log' | 'debug' | 'info' | 'error' | 'warn',
+    args?: any[]
+  ) => {
+    if (!currentContext) return;
+
+    log(`Console ${type}`, JSON.stringify(args));
+    const message = args?.shift();
+
+    const key = `Function#${
+      process.env[envVariableNames.SSPY_FUNCTION_NAME]
+    }#Console`;
+
+    const p = sendLambdaSpyEvent(key, <FunctionConsoleSpyEvent>{
+      request: currentEvent,
+      context: currentContext,
+      console: {
+        type,
+        message,
+        optionalParams: args,
+      },
+    });
+
+    promises.push(p);
+  };
+
+  console.log = function (...args: any[]) {
+    sendLogs('log', args);
+    oldConsoleLog.apply(console, args);
+  };
+
+  console.warn = function (...args: any[]) {
+    sendLogs('warn', args);
+    oldConsoleWarn.apply(console, args);
+  };
+
+  console.debug = function (...args: any[]) {
+    sendLogs('debug', args);
+    oldConsoleDebug.apply(console, args);
+  };
+
+  console.info = function (...args: any[]) {
+    sendLogs('info', args);
+    oldConsoleInfo.apply(console, args);
+  };
+
+  console.error = function (...args: any[]) {
+    sendLogs('error', args);
+    oldConsoleError.apply(console, args);
+  };
+}
+
 function isPromise(obj: any): boolean {
   return typeof obj?.then === 'function';
 }
@@ -135,21 +213,11 @@ async function sendLambdaSpyEvent(
 }
 
 async function sendRawSpyEvent(data: any) {
-  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);
+  await spyEventSender.publishSpyEvent(data);
 }
 
 function getOriginalHandler(): Handler {
-  console.log('ORIGINAL_HANDLER_KEY', process.env[ORIGINAL_HANDLER_KEY]);
+  log('Original handler', process.env[ORIGINAL_HANDLER_KEY]);
 
   if (process.env[ORIGINAL_HANDLER_KEY] === undefined)
     throw Error('Missing original handler');
@@ -158,3 +226,15 @@ function getOriginalHandler(): Handler {
     process.env[ORIGINAL_HANDLER_KEY]
   ) as Handler;
 }
+
+function log(message: string, ...optionalParams: any[]) {
+  if (debugMode) {
+    oldConsoleDebug('SSPY EXTENSION', message, ...optionalParams);
+  }
+}
+
+function logError(message: string, ...optionalParams: any[]) {
+  if (debugMode) {
+    oldConsoleError('SSPY EXTENSION', message, ...optionalParams);
+  }
+}