skuba 9.0.1 → 9.1.0-make-aaron-hate-me-20241019044405

package/template/lambda-sqs-worker-cdk/infra/appStack.ts

@@ -8,14 +8,18 @@ import {
   aws_lambda,
   aws_lambda_event_sources,
   aws_lambda_nodejs,
+  aws_secretsmanager,
   aws_sns,
-  aws_sns_subscriptions,
   aws_sqs,
 } from 'aws-cdk-lib';
 import type { Construct } from 'constructs';
+import { Datadog } from 'datadog-cdk-constructs-v2';
 
 import { config } from './config';
 
+// Updated by https://github.com/seek-oss/rynovate
+const DATADOG_EXTENSION_LAYER_VERSION = 64;
+
 export class AppStack extends Stack {
   constructor(scope: Construct, id: string, props?: StackProps) {
     super(scope, id, props);
@@ -49,47 +53,54 @@ export class AppStack extends Stack {
       encryptionMasterKey: kmsKey,
     });
 
-    const topic = aws_sns.Topic.fromTopicArn(
+    // const topic = aws_sns.Topic.fromTopicArn(
+    //   this,
+    //   'source-topic',
+    //   config.sourceSnsTopicArn,
+    // );
+
+    // topic.addSubscription(
+    //   new aws_sns_subscriptions.SqsSubscription(queue, {
+    //     rawMessageDelivery: true, // Remove this property if you require end to end datadog tracing
+    //   }),
+    // );
+
+    const snsKey = aws_kms.Alias.fromAliasName(
       this,
-      'source-topic',
-      config.sourceSnsTopicArn,
+      'alias-aws-sns',
+      'alias/aws/sns',
     );
 
-    topic.addSubscription(new aws_sns_subscriptions.SqsSubscription(queue));
+    const destinationTopic = new aws_sns.Topic(this, 'destination-topic', {
+      masterKey: snsKey,
+      topicName: '<%- serviceName %>',
+    });
 
     const architecture = '<%- lambdaCdkArchitecture %>';
 
-    const defaultWorkerConfig: aws_lambda_nodejs.NodejsFunctionProps = {
+    const worker = new aws_lambda_nodejs.NodejsFunction(this, 'worker', {
       architecture: aws_lambda.Architecture[architecture],
       runtime: aws_lambda.Runtime.NODEJS_20_X,
       environmentEncryption: kmsKey,
       // aws-sdk-v3 sets this to true by default, so it is not necessary to set the environment variable
       // https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html
       awsSdkConnectionReuse: false,
-    };
-
-    const defaultWorkerBundlingConfig: aws_lambda_nodejs.BundlingOptions = {
-      sourceMap: true,
-      target: 'node20',
-      // aws-sdk-v3 is set as an external module by default, but we want it to be bundled with the function
-      externalModules: [],
-    };
-
-    const defaultWorkerEnvironment: Record<string, string> = {
-      NODE_ENV: 'production',
-      // https://nodejs.org/api/cli.html#cli_node_options_options
-      NODE_OPTIONS: '--enable-source-maps',
-    };
-
-    const worker = new aws_lambda_nodejs.NodejsFunction(this, 'worker', {
-      ...defaultWorkerConfig,
       entry: './src/app.ts',
       timeout: Duration.seconds(30),
-      bundling: defaultWorkerBundlingConfig,
+      bundling: {
+        sourceMap: true,
+        target: 'node20',
+        // aws-sdk-v3 is set as an external module by default, but we want it to be bundled with the function
+        externalModules: [],
+        nodeModules: ['datadog-lambda-js', 'dd-trace'],
+      },
       functionName: '<%- serviceName %>',
       environment: {
-        ...defaultWorkerEnvironment,
         ...config.workerLambda.environment,
+        NODE_ENV: 'production',
+        // https://nodejs.org/api/cli.html#cli_node_options_options
+        NODE_OPTIONS: '--enable-source-maps',
+        DESTINATION_SNS_TOPIC_ARN: destinationTopic.topicArn,
       },
       // https://github.com/aws/aws-cdk/issues/28237
       // This forces the lambda to be updated on every deployment
@@ -98,6 +109,22 @@ export class AppStack extends Stack {
       reservedConcurrentExecutions: config.workerLambda.reservedConcurrency,
     });
 
+    const datadogSecret = aws_secretsmanager.Secret.fromSecretPartialArn(
+      this,
+      'datadog-api-key-secret',
+      config.datadogApiKeySecretArn,
+    );
+
+    const datadog = new Datadog(this, 'datadog', {
+      apiKeySecret: datadogSecret,
+      addLayers: false,
+      enableDatadogLogs: false,
+      flushMetricsToLogs: false,
+      extensionLayerVersion: DATADOG_EXTENSION_LAYER_VERSION,
+    });
+
+    datadog.addLambdaFunctions([worker]);
+
     const workerDeployment = new LambdaDeployment(this, 'workerDeployment', {
       lambdaFunction: worker,
     });

package/template/lambda-sqs-worker-cdk/infra/config.ts

@@ -16,6 +16,7 @@ interface Config {
       VERSION: string;
     };
   };
+  datadogApiKeySecretArn: string;
   sourceSnsTopicArn: string;
 }
 
@@ -30,6 +31,7 @@ const configs: Record<Environment, Config> = {
         VERSION: Env.string('VERSION', { default: 'local' }),
       },
     },
+    datadogApiKeySecretArn: 'TODO: datadogApiKeySecretArn',
     sourceSnsTopicArn: 'TODO: sourceSnsTopicArn',
   },
   prod: {
@@ -42,6 +44,7 @@ const configs: Record<Environment, Config> = {
         VERSION: Env.string('VERSION', { default: 'local' }),
       },
     },
+    datadogApiKeySecretArn: 'TODO: datadogApiKeySecretArn',
     sourceSnsTopicArn: 'TODO: sourceSnsTopicArn',
   },
 };

package/template/lambda-sqs-worker-cdk/package.json

@@ -17,20 +17,27 @@
     "@aws-sdk/client-lambda": "^3.363.0",
     "@aws-sdk/client-sns": "^3.363.0",
     "@seek/logger": "^9.0.0",
+    "datadog-lambda-js": "^9.0.0",
+    "dd-trace": "^5.0.0",
     "skuba-dive": "^2.0.0",
     "zod": "^3.19.1"
   },
   "devDependencies": {
     "@seek/aws-codedeploy-infra": "^2.1.0",
     "@types/aws-lambda": "^8.10.82",
+    "@types/chance": "^1.1.3",
     "@types/node": "^20.16.5",
     "aws-cdk": "^2.109.0",
     "aws-cdk-lib": "^2.109.0",
+    "aws-sdk-client-mock": "^4.0.0",
+    "aws-sdk-client-mock-jest": "^4.0.0",
+    "chance": "^1.1.8",
     "constructs": "^10.0.17",
+    "datadog-cdk-constructs-v2": "^1.18.0",
     "pino-pretty": "^11.0.0",
-    "skuba": "*"
+    "skuba": "9.1.0-make-aaron-hate-me-20241019044405"
   },
-  "packageManager": "pnpm@9.12.0",
+  "packageManager": "pnpm@9.12.2",
   "engines": {
     "node": ">=20"
   }

package/template/lambda-sqs-worker-cdk/src/app.test.ts

@@ -0,0 +1,116 @@
+import { PublishCommand } from '@aws-sdk/client-sns';
+
+import { metricsClient } from 'src/framework/metrics';
+import { createCtx, createSqsEvent } from 'src/testing/handler';
+import { logger } from 'src/testing/logging';
+import { scoringService, sns } from 'src/testing/services';
+import { chance, mockJobPublishedEvent } from 'src/testing/types';
+
+import * as app from './app';
+
+describe('app', () => {
+  it('exports a handler', () => expect(app).toHaveProperty('handler'));
+});
+
+describe('handler', () => {
+  const ctx = createCtx();
+
+  const jobPublished = mockJobPublishedEvent({ entityId: chance.name() });
+
+  const score = chance.floating({ max: 1, min: 0 });
+
+  const distribution = jest
+    .spyOn(metricsClient, 'distribution')
+    .mockReturnValue();
+
+  beforeAll(logger.spy);
+  beforeAll(scoringService.spy);
+
+  beforeEach(() => {
+    scoringService.request.mockResolvedValue(score);
+    sns.publish.resolves({ MessageId: chance.guid({ version: 4 }) });
+  });
+
+  afterEach(() => {
+    logger.clear();
+    distribution.mockClear();
+    scoringService.clear();
+    sns.clear();
+  });
+
+  it('handles one record', async () => {
+    const event = createSqsEvent([JSON.stringify(jobPublished)]);
+
+    await expect(app.handler(event, ctx)).resolves.toBeUndefined();
+
+    expect(scoringService.request).toHaveBeenCalledTimes(1);
+
+    expect(logger.error).not.toHaveBeenCalled();
+
+    expect(logger.debug.mock.calls).toEqual([
+      [{ count: 1 }, 'Received jobs'],
+      [{ snsMessageId: expect.any(String) }, 'Scored job'],
+      ['Function succeeded'],
+    ]);
+
+    expect(distribution.mock.calls).toEqual([
+      ['job.received', 1],
+      ['job.scored', 1],
+    ]);
+
+    expect(sns.client).toReceiveCommandTimes(PublishCommand, 1);
+  });
+
+  it('throws on invalid input', () => {
+    const event = createSqsEvent(['}']);
+
+    return expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
+  });
+
+  it('bubbles up scoring service error', async () => {
+    const err = Error(chance.sentence());
+
+    scoringService.request.mockRejectedValue(err);
+
+    const event = createSqsEvent([JSON.stringify(jobPublished)]);
+
+    await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
+
+    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
+  });
+
+  it('bubbles up SNS error', async () => {
+    const err = Error(chance.sentence());
+
+    sns.publish.rejects(err);
+
+    const event = createSqsEvent([JSON.stringify(jobPublished)]);
+
+    await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
+
+    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
+  });
+
+  it('throws on zero records', async () => {
+    const err = new Error('Received 0 records');
+
+    const event = createSqsEvent([]);
+
+    await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
+
+    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
+  });
+
+  it('throws on multiple records', async () => {
+    const err = new Error('Received 2 records');
+
+    const event = createSqsEvent([
+      JSON.stringify(jobPublished),
+      JSON.stringify(jobPublished),
+    ]);
+
+    await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
+
+    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
+  });
+});

package/template/lambda-sqs-worker-cdk/src/app.ts

@@ -1,35 +1,57 @@
-import createLogger from '@seek/logger';
-import type { SQSEvent, SQSHandler } from 'aws-lambda';
+import 'skuba-dive/register';
 
-import { config } from './config';
+import type { SQSEvent } from 'aws-lambda';
 
-export const logger = createLogger({
-  base: {
-    environment: config.environment,
-    version: config.version,
-  },
-
-  level: config.logLevel,
-
-  name: config.name,
-
-  transport:
-    config.environment === 'local' ? { target: 'pino-pretty' } : undefined,
-});
+import { createHandler } from 'src/framework/handler';
+import { logger } from 'src/framework/logging';
+import { metricsClient } from 'src/framework/metrics';
+import { validateJson } from 'src/framework/validation';
+import { scoreJobPublishedEvent, scoringService } from 'src/services/jobScorer';
+import { sendPipelineEvent } from 'src/services/pipelineEventSender';
+import { JobPublishedEventSchema } from 'src/types/pipelineEvents';
 
 /**
  * Tests connectivity to ensure appropriate access and network configuration.
  */
-const smokeTest = async () => Promise.resolve();
+const smokeTest = async () => {
+  await Promise.all([scoringService.smokeTest(), sendPipelineEvent({}, true)]);
+};
 
-export const handler: SQSHandler = (event: SQSEvent) => {
+export const handler = createHandler<SQSEvent>(async (event) => {
   // Treat an empty object as our smoke test event.
   if (!Object.keys(event).length) {
     logger.debug('Received smoke test request');
     return smokeTest();
   }
 
-  logger.info('Hello World!');
+  const count = event.Records.length;
 
-  return;
-};
+  if (count !== 1) {
+    throw Error(`Received ${count} records`);
+  }
+
+  logger.debug({ count }, 'Received jobs');
+
+  metricsClient.distribution('job.received', event.Records.length);
+
+  const record = event.Records[0];
+  if (!record) {
+    throw new Error('Malformed SQS event with no records');
+  }
+
+  const { body } = record;
+
+  // TODO: this throws an error, which will cause the Lambda function to retry
+  // the event and eventually send it to your dead-letter queue. If you don't
+  // trust your source to provide consistently well-formed input, consider
+  // catching and handling this error in code.
+  const publishedJob = validateJson(body, JobPublishedEventSchema);
+
+  const scoredJob = await scoreJobPublishedEvent(publishedJob);
+
+  const snsMessageId = await sendPipelineEvent(scoredJob);
+
+  logger.debug({ snsMessageId }, 'Scored job');
+
+  metricsClient.distribution('job.scored', 1);
+});

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

@@ -4,8 +4,11 @@ interface Config {
   environment: Environment;
 
   logLevel: string;
+  metrics: boolean;
   name: string;
   version: string;
+
+  destinationSnsTopicArn: string;
 }
 
 type Environment = (typeof environments)[number];
@@ -18,26 +21,38 @@ const environment = Env.oneOf(environments)('ENVIRONMENT');
 const configs: Record<Environment, () => Omit<Config, 'environment'>> = {
   local: () => ({
     logLevel: 'debug',
+    metrics: false,
     name: '<%- serviceName %>',
     version: 'local',
+
+    destinationSnsTopicArn: 'arn:aws:sns:us-east-2:123456789012:destination',
   }),
 
   test: () => ({
     logLevel: Env.string('LOG_LEVEL', { default: 'silent' }),
+    metrics: false,
     name: '<%- serviceName %>',
     version: 'test',
+
+    destinationSnsTopicArn: 'arn:aws:sns:us-east-2:123456789012:destination',
   }),
 
   dev: () => ({
     logLevel: 'debug',
+    metrics: true,
     name: Env.string('SERVICE'),
     version: Env.string('VERSION'),
+
+    destinationSnsTopicArn: Env.string('DESTINATION_SNS_TOPIC_ARN'),
   }),
 
   prod: () => ({
     logLevel: 'info',
+    metrics: true,
     name: Env.string('SERVICE'),
     version: Env.string('VERSION'),
+
+    destinationSnsTopicArn: Env.string('DESTINATION_SNS_TOPIC_ARN'),
   }),
 };
 

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

@@ -0,0 +1,61 @@
+import { createCtx } from 'src/testing/handler';
+import { logger } from 'src/testing/logging';
+import { chance } from 'src/testing/types';
+
+import { createHandler } from './handler';
+
+describe('createHandler', () => {
+  const ctx = createCtx();
+  const input = chance.paragraph();
+
+  beforeAll(logger.spy);
+
+  afterEach(logger.clear);
+
+  it('handles happy path', async () => {
+    const output = chance.paragraph();
+
+    const handler = createHandler((event) => {
+      expect(event).toBe(input);
+
+      logger.debug('Handler invoked');
+
+      return Promise.resolve(output);
+    });
+
+    await expect(handler(input, ctx)).resolves.toBe(output);
+
+    expect(logger.error).not.toHaveBeenCalled();
+
+    expect(logger.debug.mock.calls).toEqual([
+      ['Handler invoked'],
+      ['Function succeeded'],
+    ]);
+  });
+
+  it('handles async error', async () => {
+    const err = Error(chance.sentence());
+
+    const handler = createHandler(() => Promise.reject(err));
+
+    await expect(handler(input, ctx)).rejects.toThrow('Function failed');
+
+    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
+
+    expect(logger.debug).not.toHaveBeenCalled();
+  });
+
+  it('handles sync error', async () => {
+    const err = Error(chance.sentence());
+
+    const handler = createHandler(() => {
+      throw err;
+    });
+
+    await expect(handler(input, ctx)).rejects.toThrow('Function failed');
+
+    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
+
+    expect(logger.debug).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,43 @@
+import { datadog } from 'datadog-lambda-js';
+
+import { config } from 'src/config';
+import { logger, loggerContext } from 'src/framework/logging';
+
+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.debug('Function succeeded');
+
+        return output;
+      } catch (err) {
+        logger.error({ err }, 'Function failed');
+
+        throw new Error('Function failed');
+      }
+    }),
+  );

package/template/lambda-sqs-worker-cdk/src/framework/logging.ts

@@ -0,0 +1,27 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+import createLogger from '@seek/logger';
+
+import { config } from 'src/config';
+
+interface LoggerContext {
+  awsRequestId: string;
+}
+
+export const loggerContext = new AsyncLocalStorage<LoggerContext>();
+
+export const logger = createLogger({
+  base: {
+    environment: config.environment,
+    version: config.version,
+  },
+
+  level: config.logLevel,
+
+  mixin: () => ({ ...loggerContext.getStore() }),
+
+  name: config.name,
+
+  transport:
+    config.environment === 'local' ? { target: 'pino-pretty' } : undefined,
+});

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

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

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

@@ -0,0 +1,84 @@
+import {
+  IdDescriptionSchema,
+  chance,
+  mockIdDescription,
+} from 'src/testing/types';
+
+import { validateJson } from './validation';
+
+describe('validateJson', () => {
+  const idDescription = mockIdDescription();
+
+  it('permits valid input', () => {
+    const input = JSON.stringify(idDescription);
+
+    expect(validateJson(input, IdDescriptionSchema)).toStrictEqual(
+      idDescription,
+    );
+  });
+
+  it('filters additional properties', () => {
+    const input = JSON.stringify({ ...idDescription, hacker: chance.name() });
+
+    expect(validateJson(input, IdDescriptionSchema)).toStrictEqual(
+      idDescription,
+    );
+  });
+
+  it('blocks mistyped prop', () => {
+    const input = JSON.stringify({ ...idDescription, id: null });
+
+    expect(() => validateJson(input, IdDescriptionSchema))
+      .toThrowErrorMatchingInlineSnapshot(`
+      "[
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "received": "null",
+          "path": [
+            "id"
+          ],
+          "message": "Expected string, received null"
+        }
+      ]"
+    `);
+  });
+
+  it('blocks missing prop', () => {
+    const input = '{}';
+
+    expect(() => validateJson(input, IdDescriptionSchema))
+      .toThrowErrorMatchingInlineSnapshot(`
+      "[
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "received": "undefined",
+          "path": [
+            "id"
+          ],
+          "message": "Required"
+        },
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "received": "undefined",
+          "path": [
+            "description"
+          ],
+          "message": "Required"
+        }
+      ]"
+    `);
+  });
+
+  it('blocks invalid JSON', () => {
+    const input = '}';
+
+    expect(() =>
+      validateJson(input, IdDescriptionSchema),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `"Unexpected token '}', "}" is not valid JSON"`,
+    );
+  });
+});

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

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+
+export const validateJson = <
+  Output,
+  Def extends z.ZodTypeDef = z.ZodTypeDef,
+  Input = Output,
+>(
+  input: string,
+  schema: z.ZodSchema<Output, Def, Input>,
+): Output => schema.parse(JSON.parse(input));

package/template/lambda-sqs-worker-cdk/src/mapping/jobScorer.ts

@@ -0,0 +1,22 @@
+import type { JobScorerInput, JobScorerOutput } from 'src/types/jobScorer';
+import type {
+  JobPublishedEvent,
+  JobScoredEvent,
+} from 'src/types/pipelineEvents';
+
+export const jobPublishedEventToScorerInput = (
+  record: JobPublishedEvent,
+): JobScorerInput => ({
+  details: record.data.details,
+  id: record.entityId,
+});
+
+export const jobScorerOutputToScoredEvent = (
+  output: JobScorerOutput,
+): JobScoredEvent => ({
+  data: {
+    score: output.score,
+  },
+  entityId: output.id,
+  eventType: 'JobScored',
+});