skuba 4.3.0 → 4.4.1

package/template/lambda-sqs-worker/src/config.ts

@@ -4,6 +4,7 @@ interface Config {
   environment: Environment;
 
   logLevel: string;
+  metrics: boolean;
   name: string;
   version: string;
 
@@ -20,6 +21,7 @@ const environment = Env.oneOf(environments)('ENVIRONMENT');
 const configs: Record<Environment, () => Omit<Config, 'environment'>> = {
   local: () => ({
     logLevel: 'debug',
+    metrics: false,
     name: '<%- serviceName %>',
     version: 'local',
 
@@ -41,6 +43,7 @@ const configs: Record<Environment, () => Omit<Config, 'environment'>> = {
 
   prod: () => ({
     logLevel: 'info',
+    metrics: true,
     name: Env.string('SERVICE'),
     version: Env.string('VERSION'),
 

package/template/lambda-sqs-worker/src/framework/handler.test.ts

@@ -18,18 +18,18 @@ describe('createHandler', () => {
     const handler = createHandler((event) => {
       expect(event).toBe(input);
 
-      logger.info('hello from handler');
+      logger.info('Handler invoked');
 
       return Promise.resolve(output);
     });
 
     await expect(handler(input, ctx)).resolves.toBe(output);
 
-    expect(logger.error).not.toBeCalled();
+    expect(logger.error).not.toHaveBeenCalled();
 
     expect(logger.info.mock.calls).toEqual([
-      ['hello from handler'],
-      ['request'],
+      ['Handler invoked'],
+      ['Function succeeded'],
     ]);
   });
 
@@ -38,11 +38,11 @@ describe('createHandler', () => {
 
     const handler = createHandler(() => Promise.reject(err));
 
-    await expect(handler(input, ctx)).rejects.toThrow('invoke error');
+    await expect(handler(input, ctx)).rejects.toThrow('Function failed');
 
-    expect(logger.error.mock.calls).toEqual([[{ err }, 'request']]);
+    expect(logger.error.mock.calls).toEqual([[{ err }, 'Function failed']]);
 
-    expect(logger.info).not.toBeCalled();
+    expect(logger.info).not.toHaveBeenCalled();
   });
 
   it('handles sync error', async () => {
@@ -52,10 +52,10 @@ describe('createHandler', () => {
       throw err;
     });
 
-    await expect(handler(input, ctx)).rejects.toThrow('invoke error');
+    await expect(handler(input, ctx)).rejects.toThrow('Function failed');
 
-    expect(logger.error.mock.calls).toEqual([[{ err }, 'request']]);
+    expect(logger.error.mock.calls).toEqual([[{ err }, 'Function failed']]);
 
-    expect(logger.info).not.toBeCalled();
+    expect(logger.info).not.toHaveBeenCalled();
   });
 });

package/template/lambda-sqs-worker/src/framework/handler.ts

@@ -1,20 +1,43 @@
-import { Context } from 'aws-lambda';
+import { datadog } from 'datadog-lambda-js';
 
+import { config } from 'src/config';
 import { logger, loggerContext } from 'src/framework/logging';
 
-export const createHandler =
-  <Event, Output = unknown>(fn: (event: Event) => Promise<Output>) =>
-  (event: Event, { awsRequestId }: Context) =>
+interface LambdaContext {
+  awsRequestId: string;
+}
+
+type Handler<Event, Output> = (
+  event: Event,
+  ctx: LambdaContext,
+) => Promise<Output>;
+
+/**
+ * Conditionally applies the Datadog wrapper to a Lambda handler.
+ *
+ * This also "fixes" its broken type definitions.
+ */
+const withDatadog = <Event, Output = unknown>(
+  fn: Handler<Event, Output>,
+): Handler<Event, Output> =>
+  // istanbul ignore next
+  config.metrics ? (datadog(fn) as Handler<Event, Output>) : fn;
+
+export const createHandler = <Event, Output = unknown>(
+  fn: (event: Event) => Promise<Output>,
+) =>
+  withDatadog<Event>((event, { awsRequestId }) =>
     loggerContext.run({ awsRequestId }, async () => {
       try {
         const output = await fn(event);
 
-        logger.info('request');
+        logger.info('Function succeeded');
 
         return output;
       } catch (err) {
-        logger.error({ err }, 'request');
+        logger.error({ err }, 'Function failed');
 
-        throw new Error('invoke error');
+        throw new Error('Function failed');
       }
-    });
+    }),
+  );

package/template/lambda-sqs-worker/src/framework/metrics.ts

@@ -1,10 +1,14 @@
-import {
-  createCloudWatchClient,
-  createTimedSpan,
-} from 'seek-datadog-custom-metrics';
+import { sendDistributionMetric } from 'datadog-lambda-js';
 
 import { config } from 'src/config';
 
-export const metricsClient = createCloudWatchClient(config);
+const prefix = `${config.name}.`;
 
-export const timedSpan = createTimedSpan(metricsClient);
+export const metricsClient = {
+  distribution: (
+    ...[name, ...rest]: Parameters<typeof sendDistributionMetric>
+  ) =>
+    config.metrics
+      ? sendDistributionMetric(`${prefix}${name}`, ...rest)
+      : undefined,
+};

package/template/lambda-sqs-worker/src/framework/validation.test.ts

@@ -28,21 +28,28 @@ describe('validateJson', () => {
   it('blocks mistyped prop', () => {
     const input = JSON.stringify({ ...idDescription, id: null });
 
-    expect(() =>
-      validateJson(input, filterIdDescription),
-    ).toThrowErrorMatchingInlineSnapshot(
-      `"Expected { id: string; description: string; }, but was incompatible"`,
-    );
+    expect(() => validateJson(input, filterIdDescription))
+      .toThrowErrorMatchingInlineSnapshot(`
+      "Validation failed:
+      {
+        "id": "Expected string, but was null"
+      }.
+      Object should match { id: string; description: string; }"
+    `);
   });
 
   it('blocks missing prop', () => {
     const input = '{}';
 
-    expect(() =>
-      validateJson(input, filterIdDescription),
-    ).toThrowErrorMatchingInlineSnapshot(
-      `"Expected { id: string; description: string; }, but was incompatible"`,
-    );
+    expect(() => validateJson(input, filterIdDescription))
+      .toThrowErrorMatchingInlineSnapshot(`
+      "Validation failed:
+      {
+        "id": "Expected string, but was missing",
+        "description": "Expected string, but was missing"
+      }.
+      Object should match { id: string; description: string; }"
+    `);
   });
 
   it('blocks invalid JSON', () => {

package/template/lambda-sqs-worker/src/services/jobScorer.test.ts

@@ -25,7 +25,7 @@ describe('scoreJobPublishedEvent', () => {
       eventType: 'JobScored',
     });
 
-    expect(scoringService.request).toBeCalledTimes(1);
+    expect(scoringService.request).toHaveBeenCalledTimes(1);
   });
 
   it('bubbles up scoring service error', async () => {
@@ -39,6 +39,6 @@ describe('scoreJobPublishedEvent', () => {
       ),
     ).rejects.toThrow(err);
 
-    expect(scoringService.request).toBeCalledTimes(1);
+    expect(scoringService.request).toHaveBeenCalledTimes(1);
   });
 });

package/template/lambda-sqs-worker/src/services/pipelineEventSender.test.ts

@@ -15,7 +15,7 @@ describe('sendPipelineEvent', () => {
 
     await expect(sendPipelineEvent({})).resolves.toBe(messageId);
 
-    expect(sns.publish).toBeCalledTimes(1);
+    expect(sns.publish).toHaveBeenCalledTimes(1);
   });
 
   it('bubbles up SNS error', () => {

package/template/lambda-sqs-worker-cdk/.buildkite/pipeline.yml

@@ -32,7 +32,7 @@ configs:
         - *aws-sm
         - *private-npm
         - *docker-ecr-cache
-        - docker-compose#v3.9.0:
+        - docker-compose#v3.10.0:
             dependencies: false
             run: app
       retry:
@@ -57,7 +57,7 @@ steps:
       - *aws-sm
       - *private-npm
       - *docker-ecr-cache
-      - docker-compose#v3.9.0:
+      - docker-compose#v3.10.0:
           run: app
     timeout_in_minutes: 10