feat(middleware-logger): log request errors

Author: simonbuchan

packages/middleware-logger/src/loggerMiddleware.spec.ts

@@ -72,6 +72,14 @@ describe("loggerMiddleware", () => {
     expect(response).toStrictEqual(mockResponse);
   });
 
+  it("rejects without logging if context.logger doesn't have error function", async () => {
+    const nextError = new Error("next error");
+    mockNext.mockRejectedValueOnce(nextError);
+    const logger = {} as Logger;
+    const response = await expect(loggerMiddleware()(mockNext, { logger })(mockArgs)).rejects.toThrow(nextError);
+    expect(mockNext).toHaveBeenCalledTimes(1);
+  });
+
   describe("logs if context.logger has info function", () => {
     it("success case with clientName, commandName, input, metadata", async () => {
       mockNext.mockResolvedValueOnce(mockResponse);
@@ -149,4 +157,76 @@ describe("loggerMiddleware", () => {
       });
     });
   });
+
+  describe("logs if context.logger has error function", () => {
+    it("next throws synchronously", async () => {
+      const { $metadata } = mockOutput;
+      const nextError = new Error("example error");
+      Object.assign(nextError, { $metadata });
+      mockNext.mockImplementationOnce(() => {
+        throw nextError;
+      });
+
+      const clientName = "mockClientName";
+      const commandName = "mockCommandName";
+
+      const logger = { error: jest.fn() } as unknown as Logger;
+      const inputFilterSensitiveLog = jest.fn().mockImplementationOnce((input) => input);
+      const outputFilterSensitiveLog = jest.fn().mockImplementationOnce((output) => output);
+
+      const context = {
+        clientName,
+        commandName,
+        logger,
+        inputFilterSensitiveLog,
+        outputFilterSensitiveLog,
+      };
+
+      await expect(loggerMiddleware()(mockNext, context)(mockArgs)).rejects.toThrow(nextError);
+      expect(mockNext).toHaveBeenCalledTimes(1);
+
+      expect(logger.error).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledWith({
+        clientName,
+        commandName,
+        input: mockArgs.input,
+        error: nextError,
+        metadata: $metadata,
+      });
+    });
+
+    it("next rejects", async () => {
+      const { $metadata } = mockOutput;
+      const nextError = new Error("example error");
+      Object.assign(nextError, { $metadata });
+      mockNext.mockRejectedValueOnce(nextError);
+
+      const clientName = "mockClientName";
+      const commandName = "mockCommandName";
+
+      const logger = { error: jest.fn() } as unknown as Logger;
+      const inputFilterSensitiveLog = jest.fn().mockImplementationOnce((input) => input);
+      const outputFilterSensitiveLog = jest.fn().mockImplementationOnce((output) => output);
+
+      const context = {
+        clientName,
+        commandName,
+        logger,
+        inputFilterSensitiveLog,
+        outputFilterSensitiveLog,
+      };
+
+      await expect(loggerMiddleware()(mockNext, context)(mockArgs)).rejects.toThrow(nextError);
+      expect(mockNext).toHaveBeenCalledTimes(1);
+
+      expect(logger.error).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledWith({
+        clientName,
+        commandName,
+        input: mockArgs.input,
+        error: nextError,
+        metadata: $metadata,
+      });
+    });
+  });
 });

packages/middleware-logger/src/loggerMiddleware.ts

@@ -16,26 +16,28 @@ export const loggerMiddleware =
     context: HandlerExecutionContext
   ): InitializeHandler<any, Output> =>
   async (args: InitializeHandlerArguments<any>): Promise<InitializeHandlerOutput<Output>> => {
-    const { clientName, commandName, inputFilterSensitiveLog, logger, outputFilterSensitiveLog } = context;
-
-    const response = await next(args);
-
-    if (!logger) {
-      return response;
-    }
-
-    if (typeof logger.info === "function") {
-      const { $metadata, ...outputWithoutMetadata } = response.output;
-      logger.info({
+    const { clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, logger } = context;
+    try {
+      const response = await next(args);
+      const { $metadata, ...output } = response.output;
+      logger?.info?.({
         clientName,
         commandName,
         input: inputFilterSensitiveLog(args.input),
-        output: outputFilterSensitiveLog(outputWithoutMetadata),
+        output: outputFilterSensitiveLog(output),
         metadata: $metadata,
       });
+      return response;
+    } catch (error) {
+      logger?.error?.({
+        clientName,
+        commandName,
+        input: inputFilterSensitiveLog(args.input),
+        error,
+        metadata: (error as any).$metadata,
+      });
+      throw error;
     }
-
-    return response;
   };
 
 export const loggerMiddlewareOptions: InitializeHandlerOptions & AbsoluteLocation = {