serverless-spy 0.0.0

package/functions/sendMessage.ts

@@ -0,0 +1,277 @@
+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 { DynamoDBSpyEvent } from '../common/spyEvents/DynamoDBSpyEvent';
+import { EventBridgeRuleSpyEvent } from '../common/spyEvents/EventBridgeRuleSpyEvent';
+import { EventBridgeSpyEvent } from '../common/spyEvents/EventBridgeSpyEvent';
+import { S3SpyEvent } from '../common/spyEvents/S3SpyEvent';
+import { SnsSubscriptionSpyEvent } from '../common/spyEvents/SnsSubscriptionSpyEvent';
+import { SnsTopicSpyEvent } from '../common/spyEvents/SnsTopicSpyEvent';
+import { SpyMessage } from '../common/spyEvents/SpyMessage';
+import { SqsSpyEvent } from '../common/spyEvents/SqsSpyEvent';
+
+const ddb = new DynamoDBClient({
+  region: process.env.AWS_REGION,
+});
+
+const { TABLE_NAME } = process.env;
+const endpoint = process.env.WS_ENDPOINT!;
+
+const apigwManagementApi = new ApiGatewayManagementApi({
+  apiVersion: '2018-11-29',
+  endpoint,
+});
+
+let connections: Record<string, AttributeValue>[] | undefined;
+
+export const handler = async (event: any, context: any) => {
+  console.log('EVENT', JSON.stringify(event));
+  // console.log("CONTEXT", JSON.stringify(context));
+
+  const mapping = JSON.parse(process.env.INFRA_MAPPING!);
+  console.log('mapping', JSON.stringify(mapping));
+
+  let connectionData;
+
+  const scanParams = new ScanCommand({
+    TableName: process.env.TABLE_NAME as string,
+    ProjectionExpression: 'connectionId',
+  });
+
+  try {
+    connectionData = await ddb.send(scanParams);
+  } catch (e) {
+    console.error(e);
+    return { statusCode: 500, body: (e as Error)?.stack };
+  }
+  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 = 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);
+
+  return { statusCode: 200, body: 'Data sent.' };
+};
+
+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: TABLE_NAME,
+          Key: { connectionId },
+        });
+
+        await ddb.send(deleteParams);
+      } else {
+        throw e;
+      }
+    }
+  });
+
+  try {
+    await Promise.all(postCalls);
+    console.log('Send message finish');
+  } catch (e) {
+    return { statusCode: 500, body: (e as Error)?.stack };
+  }
+}
+
+function getSpyEventType(serviceKey: string) {
+  if (!serviceKey) {
+    throw new Error('Missing serviceKey');
+  }
+
+  return serviceKey.substring(0, serviceKey.indexOf('#'));
+}

package/functions/tsconfig.dev.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Node 16",
+  "compilerOptions": {
+    "lib": ["es2021"],
+    "module": "esnext",
+    "target": "es2021",
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  }
+}

package/functions/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Node 16",
+  "compilerOptions": {
+    "lib": ["es2021"],
+    "module": "esnext",
+    "target": "es2021",
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  }
+}

package/index.ts

@@ -0,0 +1,2 @@
+export * from './src/ServerlessSpy';
+export * from './listener';

package/lambda-extension/aws/Common.ts

@@ -0,0 +1,88 @@
+/* eslint-disable no-unused-vars */
+/**
+ * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * This code was copied from:
+ * https://raw.githubusercontent.com/aws/aws-lambda-nodejs-runtime-interface-client/main/src/Common/index.ts
+ *
+ * This module defines types, enums and interfaces common to the other modules.
+ */
+
+import { IncomingHttpHeaders } from 'http';
+
+export interface InvocationResponse {
+  bodyJson: string;
+  headers: IncomingHttpHeaders;
+}
+
+export interface NativeClient {
+  initializeClient: (userAgent: string) => void;
+  done: (id: string, bodyString: string) => void;
+  error: (id: string, bodyString: string, xrayString: string) => void;
+  next: () => Promise<InvocationResponse>;
+}
+
+export enum INVOKE_HEADER {
+  ClientContext = 'lambda-runtime-client-context',
+  CognitoIdentity = 'lambda-runtime-cognito-identity',
+  ARN = 'lambda-runtime-invoked-function-arn',
+  AWSRequestId = 'lambda-runtime-aws-request-id',
+  DeadlineMs = 'lambda-runtime-deadline-ms',
+  XRayTrace = 'lambda-runtime-trace-id',
+}
+
+export interface IEnvironmentData {
+  functionVersion?: string;
+  functionName?: string;
+  memoryLimitInMB?: string;
+  logGroupName?: string;
+  logStreamName?: string;
+}
+
+export interface IHeaderData {
+  clientContext?: string;
+  identity?: string;
+  invokedFunctionArn?: string;
+  awsRequestId?: string;
+  getRemainingTimeInMillis: () => number;
+}
+
+export type ErrorStringOrUndefined = Error | string | undefined;
+
+export type ErrorStringOrUndefinedOrNull = ErrorStringOrUndefined | null;
+
+/**
+ *
+ */
+export interface ICallbackContext {
+  callbackWaitsForEmptyEventLoop: boolean;
+  succeed: (result: unknown) => void;
+  fail: (err: ErrorStringOrUndefinedOrNull) => void;
+  done: (err: ErrorStringOrUndefinedOrNull, result?: unknown) => void;
+}
+
+export type CallbackFunction = (
+  err: ErrorStringOrUndefinedOrNull,
+  result?: unknown
+) => void;
+
+export interface IBeforeExitListener {
+  invoke: () => void;
+  reset: () => () => void;
+  set: (listener: () => void) => () => void;
+}
+
+export interface IErrorCallbacks {
+  uncaughtException: (err: Error) => void;
+  unhandledRejection: (err: Error) => void;
+}
+
+export type HandlerFunction = (
+  body: unknown,
+  data: IEnvironmentData & IHeaderData,
+  callback: CallbackFunction
+) => PromiseLike<unknown> | unknown;
+
+export function isHandlerFunction(value: any): value is HandlerFunction {
+  return typeof value === 'function';
+}

package/lambda-extension/aws/Errors.ts

@@ -0,0 +1,140 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * This code was copied from:
+ * https://raw.githubusercontent.com/aws/aws-lambda-nodejs-runtime-interface-client/main/src/Errors/index.ts
+ *
+ * Defines custom error types throwable by the runtime.
+ */
+
+'use strict';
+
+import util from 'util';
+
+export function isError(obj: any): obj is Error {
+  return (
+    obj &&
+    obj.name &&
+    obj.message &&
+    obj.stack &&
+    typeof obj.name === 'string' &&
+    typeof obj.message === 'string' &&
+    typeof obj.stack === 'string'
+  );
+}
+
+interface RuntimeErrorResponse {
+  errorType: string;
+  errorMessage: string;
+  trace: string[];
+}
+
+/**
+ * Attempt to convert an object into a response object.
+ * This method accounts for failures when serializing the error object.
+ */
+export function toRuntimeResponse(error: unknown): RuntimeErrorResponse {
+  try {
+    if (util.types.isNativeError(error) || isError(error)) {
+      if (!error.stack) {
+        throw new Error('Error stack is missing.');
+      }
+      return {
+        errorType: error.name,
+        errorMessage: error.message,
+        trace: error.stack.split('\n') || [],
+      };
+    } else {
+      return {
+        errorType: typeof error,
+        errorMessage: (error as any).toString(),
+        trace: [],
+      };
+    }
+  } catch (_err) {
+    return {
+      errorType: 'handled',
+      errorMessage:
+        'callback called with Error argument, but there was a problem while retrieving one or more of its message, name, and stack',
+      trace: [],
+    };
+  }
+}
+
+/**
+ * Format an error with the expected properties.
+ * For compatability, the error string always starts with a tab.
+ */
+export const toFormatted = (error: unknown): string => {
+  try {
+    return (
+      '\t' + JSON.stringify(error, (_k, v) => _withEnumerableProperties(v))
+    );
+  } catch (err) {
+    return '\t' + JSON.stringify(toRuntimeResponse(error));
+  }
+};
+
+/**
+ * Error name, message, code, and stack are all members of the superclass, which
+ * means they aren't enumerable and don't normally show up in JSON.stringify.
+ * This method ensures those interesting properties are available along with any
+ * user-provided enumerable properties.
+ */
+function _withEnumerableProperties(error: any) {
+  if (error instanceof Error) {
+    const extendedError: ExtendedError = <ExtendedError>(<any>error);
+    const ret: any = Object.assign(
+      {
+        errorType: extendedError.name,
+        errorMessage: extendedError.message,
+        code: extendedError.code,
+      },
+      extendedError
+    );
+    if (typeof extendedError.stack === 'string') {
+      ret.stack = extendedError.stack.split('\n');
+    }
+    return ret;
+  } else {
+    return error;
+  }
+}
+
+export class ExtendedError extends Error {
+  code?: number;
+  custom?: string;
+  reason?: string;
+  promise?: Promise<any>;
+
+  constructor(reason?: string) {
+    super(reason); // 'Error' breaks prototype chain here
+    Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
+  }
+}
+
+export class ImportModuleError extends ExtendedError {}
+export class HandlerNotFound extends ExtendedError {}
+export class MalformedHandlerName extends ExtendedError {}
+export class UserCodeSyntaxError extends ExtendedError {}
+export class UnhandledPromiseRejection extends ExtendedError {
+  constructor(reason?: string, promise?: Promise<any>) {
+    super(reason);
+    this.reason = reason;
+    this.promise = promise;
+  }
+}
+
+const errorClasses = [
+  ImportModuleError,
+  HandlerNotFound,
+  MalformedHandlerName,
+  UserCodeSyntaxError,
+  UnhandledPromiseRejection,
+];
+
+errorClasses.forEach((e) => {
+  e.prototype.name = `Runtime.${e.name}`;
+});