Improve logging on Lambda function errors (#81)

Author: 72636c

.changeset/weak-owls-crash.md

@@ -0,0 +1,23 @@
+---
+'@seek/aws-codedeploy-infra': patch
+---
+
+HookStack: Improve logging on Lambda function errors
+
+When the `BeforeAllowTraffic` hook invokes your Lambda function and receives a `FunctionError` back, it now logs additional information from the response payload to aid troubleshooting:
+
+```diff
+{
+  "err": {
+    "message": "Lambda function responded with error: Unhandled",
++   "payload": {
++     "errorMessage": "RequestId: 00000000-0000-0000-0000-000000000000 Error: Task timed out after 1.00 seconds",
++     "errorType": "Sandbox.Timedout"
++   },
+    "stack": "Error: Lambda function responded with error: Unhandled...",
+    "type": "Error"
+  },
+  "level": 50,
+  "msg": "Failed to process lifecycle event"
+}
+```

packages/infra/package.json

@@ -38,6 +38,7 @@
     "@aws-sdk/client-cloudformation": "3.668.0",
     "@aws-sdk/client-codedeploy": "3.668.0",
     "@aws-sdk/client-lambda": "3.668.0",
+    "@smithy/util-stream": "3.2.1",
     "aws-sdk-client-mock": "4.1.0",
     "aws-sdk-client-mock-jest": "4.1.0",
     "isomorphic-git": "1.27.1",

packages/infra/src/handlers/index.test.ts

@@ -69,7 +69,16 @@ describe('handler', () => {
   });
 
   it('reports a failure back to CodeDeploy', async () => {
-    const err = new Error('mock-error');
+    const err = Object.assign(
+      new Error('Lambda function responded with error: Unhandled'),
+      {
+        payload: {
+          errorMessage:
+            'RequestId: 00000000-0000-0000-0000-000000000000 Error: Task timed out after 1.00 seconds',
+          errorType: 'Sandbox.Timedout',
+        },
+      },
+    );
 
     processEventMock.mockRejectedValue(err);
 
@@ -92,7 +101,12 @@ describe('handler', () => {
     expect(testLogs).toStrictEqual([
       {
         awsRequestId: context.awsRequestId,
-        err: expect.objectContaining({ message: err.message }),
+        err: {
+          message: err.message,
+          payload: err.payload,
+          stack: expect.any(String),
+          type: 'Error',
+        },
         level: 50,
         msg: 'Failed to process lifecycle event',
         timestamp: expect.any(String),

packages/infra/src/handlers/process/lambda/smokeTest.test.ts

@@ -1,6 +1,7 @@
 import 'aws-sdk-client-mock-jest';
 
 import { InvokeCommand, LambdaClient } from '@aws-sdk/client-lambda';
+import { Uint8ArrayBlobAdapter } from '@smithy/util-stream';
 import { mockClient } from 'aws-sdk-client-mock';
 
 import { storage } from '../../framework/context';
@@ -136,13 +137,60 @@ describe('smokeTest', () => {
   });
 
   it('propagates an error from the Lambda function', async () => {
-    lambda
-      .on(InvokeCommand)
-      .resolves({ FunctionError: 'mock-function-error', StatusCode: 200 });
+    const payload = {
+      errorMessage:
+        'RequestId: 00000000-0000-0000-0000-000000000000 Error: Task timed out after 1.00 seconds',
+      errorType: 'Sandbox.Timedout',
+    };
+
+    lambda.on(InvokeCommand).resolves({
+      FunctionError: 'Unhandled',
+      Payload: Uint8ArrayBlobAdapter.fromString(JSON.stringify(payload)),
+      // Yes, this is OK when there's a function error.
+      StatusCode: 200,
+    });
+
+    const err = await smokeTest(oneFn).catch((reason) => reason);
+
+    expect(err).toMatchInlineSnapshot(
+      `[Error: Lambda function responded with error: Unhandled]`,
+    );
+    expect(err).toHaveProperty('payload', payload);
+  });
 
-    await expect(smokeTest(oneFn)).rejects.toThrowErrorMatchingInlineSnapshot(
-      `"Lambda function responded with error: mock-function-error"`,
+  it('handles a non-JSON payload on Lambda function error', async () => {
+    // This isn't known to happen but we're being defensive.
+    const payload = 'Something happened';
+
+    lambda.on(InvokeCommand).resolves({
+      FunctionError: 'Unhandled',
+      Payload: Uint8ArrayBlobAdapter.fromString(payload),
+      // Yes, this is OK when there's a function error.
+      StatusCode: 200,
+    });
+
+    const err = await smokeTest(oneFn).catch((reason) => reason);
+
+    expect(err).toMatchInlineSnapshot(
+      `[Error: Lambda function responded with error: Unhandled]`,
+    );
+    expect(err).toHaveProperty('payload', payload);
+  });
+
+  it('handles an empty payload on the Lambda function error', async () => {
+    // This isn't known to happen but we're being defensive.
+    lambda.on(InvokeCommand).resolves({
+      FunctionError: 'Unhandled',
+      // Yes, this is OK when there's a function error.
+      StatusCode: 200,
+    });
+
+    const err = await smokeTest(oneFn).catch((reason) => reason);
+
+    expect(err).toMatchInlineSnapshot(
+      `[Error: Lambda function responded with error: Unhandled]`,
     );
+    expect(err).not.toHaveProperty('payload');
   });
 
   it('throws on an unexpected status code from the Lambda function', async () => {

packages/infra/src/handlers/process/lambda/smokeTest.ts

@@ -1,11 +1,26 @@
-import { InvokeCommand } from '@aws-sdk/client-lambda';
+import {
+  InvokeCommand,
+  type InvokeCommandOutput,
+} from '@aws-sdk/client-lambda';
 
 import { config } from '../../config';
 import { lambdaClient } from '../../framework/aws';
 import { getContext } from '../../framework/context';
 
 import type { LambdaFunction } from './types';
 
+const tryParsePayload = (response: InvokeCommandOutput) => {
+  let payload: unknown = response.Payload?.transformToString();
+
+  if (typeof payload === 'string') {
+    try {
+      payload = JSON.parse(payload);
+    } catch {}
+  }
+
+  return payload ? { payload } : undefined;
+};
+
 export const smokeTest = async (fns: LambdaFunction[]): Promise<void> => {
   await Promise.all(fns.map((fn) => smokeTestFunction(fn)));
 };
@@ -46,8 +61,11 @@ export const smokeTestFunction = async ({
   }
 
   if (response.FunctionError) {
-    throw new Error(
-      `Lambda function responded with error: ${response.FunctionError}`,
+    throw Object.assign(
+      new Error(
+        `Lambda function responded with error: ${response.FunctionError}`,
+      ),
+      tryParsePayload(response),
     );
   }
 };