skuba 12.1.0-hoist-less-20250722131939 → 12.1.0-main-20250812041011

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

@@ -19,7 +19,10 @@ import { DatadogLambda } from 'datadog-cdk-constructs-v2';
 import { config } from './config.js';
 
 // Updated by https://github.com/seek-oss/rynovate
-const DATADOG_EXTENSION_LAYER_VERSION = 64;
+const DATADOG_EXTENSION_LAYER_VERSION = 84;
+
+// Updated by https://github.com/seek-oss/rynovate
+const DATADOG_NODE_LAYER_VERSION = 126;
 
 export class AppStack extends Stack {
   constructor(scope: Construct, id: string, props?: StackProps) {
@@ -95,7 +98,6 @@ export class AppStack extends Stack {
         target: 'node22',
         // 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: {
@@ -127,11 +129,15 @@ export class AppStack extends Stack {
     );
 
     const datadog = new DatadogLambda(this, 'datadog', {
+      env: config.env,
+      service: config.service,
+      version: config.version,
+
       apiKeySecret: datadogSecret,
-      addLayers: false,
       enableDatadogLogs: false,
-      flushMetricsToLogs: false,
       extensionLayerVersion: DATADOG_EXTENSION_LAYER_VERSION,
+      flushMetricsToLogs: false,
+      nodeLayerVersion: DATADOG_NODE_LAYER_VERSION,
     });
 
     datadog.addLambdaFunctions([worker]);
@@ -141,7 +147,11 @@ export class AppStack extends Stack {
     });
 
     workerDeployment.alias.addEventSource(
-      new aws_lambda_event_sources.SqsEventSource(queue),
+      new aws_lambda_event_sources.SqsEventSource(queue, {
+        batchSize: config.workerLambda.batchSize,
+        maxConcurrency: config.workerLambda.reservedConcurrency - 1, // Ensure we have capacity reserved for our blue/green deployment
+        reportBatchItemFailures: true,
+      }),
     );
   }
 }

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

@@ -1,52 +1,64 @@
 import { Env } from 'skuba-dive';
 
-const ENVIRONMENTS = ['dev', 'prod'] as const;
+type Deployment = (typeof deployments)[number];
 
-type Environment = (typeof ENVIRONMENTS)[number];
+const deployments = ['dev', 'prod'] as const;
 
-const environment = Env.oneOf(ENVIRONMENTS)('ENVIRONMENT');
+const deployment = Env.oneOf(deployments)('DEPLOYMENT');
 
 interface Config {
-  appName: string;
+  env: 'development' | 'production';
+  service: string;
+  version: string;
+
   workerLambda: {
+    batchSize: number;
     reservedConcurrency: number;
     environment: {
-      ENVIRONMENT: Environment;
-      SERVICE: string;
-      VERSION: string;
+      DEPLOYMENT: Deployment;
     };
   };
+
   datadogApiKeySecretArn: string;
   sourceSnsTopicArn: string;
 }
 
-const configs: Record<Environment, Config> = {
+const service = '<%- serviceName %>';
+const version = Env.string('VERSION');
+
+const configs: Record<Deployment, Config> = {
   dev: {
-    appName: '<%- serviceName %>',
+    env: 'development',
+    service,
+    version,
+
     workerLambda: {
-      reservedConcurrency: 2,
+      batchSize: 10,
+      reservedConcurrency: 3,
       environment: {
-        ENVIRONMENT: 'dev',
-        SERVICE: '<%- serviceName %>',
-        VERSION: Env.string('VERSION', { default: 'local' }),
+        DEPLOYMENT: 'dev',
       },
     },
+
     datadogApiKeySecretArn: 'TODO: datadogApiKeySecretArn',
     sourceSnsTopicArn: 'TODO: sourceSnsTopicArn',
   },
   prod: {
-    appName: '<%- serviceName %>',
+    env: 'production',
+    service,
+    version,
+
     workerLambda: {
+      batchSize: 10,
       reservedConcurrency: 20,
       environment: {
-        ENVIRONMENT: 'prod',
-        SERVICE: '<%- serviceName %>',
-        VERSION: Env.string('VERSION', { default: 'local' }),
+        DEPLOYMENT: 'prod',
       },
     },
+
     datadogApiKeySecretArn: 'TODO: datadogApiKeySecretArn',
     sourceSnsTopicArn: 'TODO: sourceSnsTopicArn',
   },
 };
 
-export const config: Config = configs[environment];
+export const config: Config = configs[deployment];

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

@@ -7,7 +7,7 @@ import { config } from './config.js';
 const app = new App();
 
 const appStack = new AppStack(app, 'appStack', {
-  stackName: config.appName,
+  stackName: config.service,
   tags: {
     'seek:source:url': 'https://github.com/SEEK-Jobs/<%- repoName %>',
     // 'seek:system:name': 'TODO: https://rfc.skinfra.xyz/RFC051-AWS-Tagging-Standard.html#tagging-schema',

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

@@ -18,11 +18,9 @@
     "@aws-sdk/client-lambda": "^3.363.0",
     "@aws-sdk/client-sns": "^3.363.0",
     "@seek/aws-codedeploy-hooks": "^2.0.0",
-    "@seek/logger": "^10.0.0",
-    "datadog-lambda-js": "^10.0.0",
-    "dd-trace": "^5.0.0",
+    "@seek/logger": "11.0.0",
     "skuba-dive": "^2.0.0",
-    "zod": "^3.25.67"
+    "zod": "^4.0.0"
   },
   "devDependencies": {
     "@seek/aws-codedeploy-infra": "^3.0.0",
@@ -35,11 +33,13 @@
     "aws-sdk-client-mock-jest": "^4.0.0",
     "chance": "^1.1.8",
     "constructs": "^10.0.17",
-    "datadog-cdk-constructs-v2": "^2.0.0",
+    "datadog-cdk-constructs-v2": "^3.0.0",
+    "datadog-lambda-js": "^12.0.0",
+    "dd-trace": "^5.0.0",
     "pino-pretty": "^13.0.0",
-    "skuba": "12.1.0-hoist-less-20250722131939"
+    "skuba": "12.1.0-main-20250812041011"
   },
-  "packageManager": "pnpm@10.12.4",
+  "packageManager": "pnpm@10.14.0",
   "engines": {
     "node": ">=22"
   }

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

@@ -1,4 +1,5 @@
 import { PublishCommand } from '@aws-sdk/client-sns';
+import type { SQSBatchResponse } from 'aws-lambda';
 
 import { metricsClient } from 'src/framework/metrics.js';
 import { createCtx, createSqsEvent } from 'src/testing/handler.js';
@@ -40,42 +41,100 @@ describe('handler', () => {
   it('handles one record', async () => {
     const event = createSqsEvent([JSON.stringify(jobPublished)]);
 
-    await expect(app.handler(event, ctx)).resolves.toBeUndefined();
+    await expect(app.handler(event, ctx)).resolves.toEqual<SQSBatchResponse>({
+      batchItemFailures: [],
+    });
 
     expect(scoringService.request).toHaveBeenCalledTimes(1);
 
     expect(stdoutMock.calls).toMatchObject([
+      { count: 1, level: 20, msg: 'Received jobs' },
       {
-        awsRequestId: '-',
-        count: 1,
         level: 20,
-        msg: 'Received jobs',
+        msg: 'Scored job',
+        snsMessageId: expect.any(String),
+        sqsMessageId: event.Records[0]!.messageId,
       },
+      { level: 20, msg: 'Function completed' },
+    ]);
+
+    expect(distribution.mock.calls).toEqual([
+      ['job.received', 1],
+      ['job.scored', 1],
+    ]);
+
+    expect(sns.client).toReceiveCommandTimes(PublishCommand, 1);
+  });
+
+  it('handles multiple records', async () => {
+    const event = createSqsEvent([
+      JSON.stringify(jobPublished),
+      JSON.stringify(jobPublished),
+    ]);
+
+    await expect(app.handler(event, ctx)).resolves.toEqual<SQSBatchResponse>({
+      batchItemFailures: [],
+    });
+
+    expect(stdoutMock.calls).toMatchObject([
+      { count: 2, level: 20, msg: 'Received jobs' },
       {
-        awsRequestId: '-',
         level: 20,
         msg: 'Scored job',
         snsMessageId: expect.any(String),
+        sqsMessageId: event.Records[0]!.messageId,
       },
       {
-        awsRequestId: '-',
         level: 20,
-        msg: 'Function succeeded',
+        msg: 'Scored job',
+        snsMessageId: expect.any(String),
+        sqsMessageId: event.Records[1]!.messageId,
       },
+      { level: 20, msg: 'Function completed' },
     ]);
+  });
 
-    expect(distribution.mock.calls).toEqual([
-      ['job.received', 1],
-      ['job.scored', 1],
+  it('handles partial batch failure', async () => {
+    const event = createSqsEvent([
+      JSON.stringify('}'),
+      JSON.stringify(jobPublished),
     ]);
 
-    expect(sns.client).toReceiveCommandTimes(PublishCommand, 1);
+    await expect(app.handler(event, ctx)).resolves.toEqual<SQSBatchResponse>({
+      batchItemFailures: [{ itemIdentifier: event.Records[0]!.messageId }],
+    });
+
+    expect(stdoutMock.calls).toMatchObject([
+      { count: 2, level: 20, msg: 'Received jobs' },
+      {
+        error: {
+          name: 'ZodError',
+          type: 'ZodError',
+        },
+        level: 50,
+        msg: 'Processing record failed',
+        sqsMessageId: event.Records[0]!.messageId,
+      },
+      {
+        level: 20,
+        msg: 'Scored job',
+        snsMessageId: expect.any(String),
+        sqsMessageId: event.Records[1]!.messageId,
+      },
+      { level: 20, msg: 'Function completed' },
+    ]);
   });
 
-  it('throws on invalid input', () => {
+  it('returns a batchItemFailure on invalid input', () => {
     const event = createSqsEvent(['}']);
 
-    return expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
+    return expect(app.handler(event, ctx)).resolves.toEqual<SQSBatchResponse>({
+      batchItemFailures: [
+        {
+          itemIdentifier: event.Records[0]!.messageId,
+        },
+      ],
+    });
   });
 
   it('bubbles up scoring service error', async () => {
@@ -85,24 +144,22 @@ describe('handler', () => {
 
     const event = createSqsEvent([JSON.stringify(jobPublished)]);
 
-    await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
+    await expect(app.handler(event, ctx)).resolves.toEqual<SQSBatchResponse>({
+      batchItemFailures: [{ itemIdentifier: event.Records[0]!.messageId }],
+    });
 
     expect(stdoutMock.calls).toMatchObject([
+      { count: 1, level: 20, msg: 'Received jobs' },
       {
-        awsRequestId: '-',
-        count: 1,
-        level: 20,
-        msg: 'Received jobs',
-      },
-      {
-        awsRequestId: '-',
-        err: {
+        error: {
           message: err.message,
           type: 'Error',
         },
         level: 50,
-        msg: 'Function failed',
+        msg: 'Processing record failed',
+        sqsMessageId: event.Records[0]!.messageId,
       },
+      { level: 20, msg: 'Function completed' },
     ]);
   });
 
@@ -113,23 +170,28 @@ describe('handler', () => {
 
     const event = createSqsEvent([JSON.stringify(jobPublished)]);
 
-    await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
+    await expect(app.handler(event, ctx)).resolves.toEqual<SQSBatchResponse>({
+      batchItemFailures: [{ itemIdentifier: event.Records[0]!.messageId }],
+    });
 
     expect(stdoutMock.calls).toMatchObject([
       {
-        awsRequestId: '-',
         count: 1,
         level: 20,
         msg: 'Received jobs',
       },
       {
-        awsRequestId: '-',
-        err: {
+        error: {
           message: err.message,
           type: 'Error',
         },
         level: 50,
-        msg: 'Function failed',
+        msg: 'Processing record failed',
+        sqsMessageId: event.Records[0]!.messageId,
+      },
+      {
+        level: 20,
+        msg: 'Function completed',
       },
     ]);
   });
@@ -141,8 +203,7 @@ describe('handler', () => {
 
     expect(stdoutMock.calls).toMatchObject([
       {
-        awsRequestId: '-',
-        err: {
+        error: {
           message: 'Received 0 records',
           type: 'Error',
         },
@@ -151,25 +212,4 @@ describe('handler', () => {
       },
     ]);
   });
-
-  it('throws on multiple records', async () => {
-    const event = createSqsEvent([
-      JSON.stringify(jobPublished),
-      JSON.stringify(jobPublished),
-    ]);
-
-    await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
-
-    expect(stdoutMock.calls).toMatchObject([
-      {
-        awsRequestId: '-',
-        err: {
-          message: 'Received 2 records',
-          type: 'Error',
-        },
-        level: 50,
-        msg: 'Function failed',
-      },
-    ]);
-  });
 });

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

@@ -3,7 +3,7 @@ import 'skuba-dive/register';
 import { isLambdaHook } from '@seek/aws-codedeploy-hooks';
 import type { SQSEvent } from 'aws-lambda';
 
-import { createHandler } from 'src/framework/handler.js';
+import { createBatchSQSHandler, createHandler } from 'src/framework/handler.js';
 import { logger } from 'src/framework/logging.js';
 import { metricsClient } from 'src/framework/metrics.js';
 import { validateJson } from 'src/framework/validation.js';
@@ -36,19 +36,17 @@ export const handler = createHandler<SQSEvent>(async (event, ctx) => {
 
   const count = event.Records.length;
 
-  if (count !== 1) {
-    throw Error(`Received ${count} records`);
+  if (!count) {
+    throw Error('Received 0 records');
   }
-
   logger.debug({ count }, 'Received jobs');
 
-  metricsClient.distribution('job.received', event.Records.length);
+  metricsClient.distribution('job.received', count);
 
-  const record = event.Records[0];
-  if (!record) {
-    throw new Error('Malformed SQS event with no records');
-  }
+  return recordHandler(event, ctx);
+});
 
+const recordHandler = createBatchSQSHandler(async (record, _ctx) => {
   const { body } = record;
 
   // TODO: this throws an error, which will cause the Lambda function to retry

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

@@ -1,27 +1,25 @@
 import { Env } from 'skuba-dive';
 
 interface Config {
-  environment: Environment;
+  deployment: Deployment;
 
   logLevel: string;
-  metrics: boolean;
   name: string;
   version: string;
 
   destinationSnsTopicArn: string;
 }
 
-type Environment = (typeof environments)[number];
+type Deployment = (typeof deployments)[number];
 
-const environments = ['local', 'test', 'dev', 'prod'] as const;
+const deployments = ['local', 'test', 'dev', 'prod'] as const;
 
-const environment = Env.oneOf(environments)('ENVIRONMENT');
+const deployment = Env.oneOf(deployments)('DEPLOYMENT');
 
 /* istanbul ignore next: config verification makes more sense in a smoke test */
-const configs: Record<Environment, () => Omit<Config, 'environment'>> = {
+const configs: Record<Deployment, () => Omit<Config, 'deployment'>> = {
   local: () => ({
     logLevel: 'debug',
-    metrics: false,
     name: '<%- serviceName %>',
     version: 'local',
 
@@ -30,7 +28,6 @@ const configs: Record<Environment, () => Omit<Config, 'environment'>> = {
 
   test: () => ({
     logLevel: Env.string('LOG_LEVEL', { default: 'debug' }),
-    metrics: false,
     name: '<%- serviceName %>',
     version: 'test',
 
@@ -39,24 +36,22 @@ const configs: Record<Environment, () => Omit<Config, 'environment'>> = {
 
   dev: () => ({
     logLevel: 'debug',
-    metrics: true,
-    name: Env.string('SERVICE'),
-    version: Env.string('VERSION'),
+    name: Env.string('DD_SERVICE'),
+    version: Env.string('DD_VERSION'),
 
     destinationSnsTopicArn: Env.string('DESTINATION_SNS_TOPIC_ARN'),
   }),
 
   prod: () => ({
     logLevel: 'info',
-    metrics: true,
-    name: Env.string('SERVICE'),
-    version: Env.string('VERSION'),
+    name: Env.string('DD_SERVICE'),
+    version: Env.string('DD_VERSION'),
 
     destinationSnsTopicArn: Env.string('DESTINATION_SNS_TOPIC_ARN'),
   }),
 };
 
 export const config: Config = {
-  ...configs[environment](),
-  environment,
+  ...configs[deployment](),
+  deployment,
 };

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

@@ -1,3 +1,5 @@
+import type { SQSEvent } from 'aws-lambda';
+
 import { createCtx } from 'src/testing/handler.js';
 import { chance } from 'src/testing/types.js';
 
@@ -6,12 +8,14 @@ import { logger, stdoutMock } from './logging.js';
 
 describe('createHandler', () => {
   const ctx = createCtx();
-  const input = chance.paragraph();
+  const input: SQSEvent = {
+    Records: [],
+  };
 
   afterEach(stdoutMock.clear);
 
   it('handles happy path', async () => {
-    const output = chance.paragraph();
+    const output = chance.sentence();
 
     const handler = createHandler((event) => {
       expect(event).toBe(input);
@@ -32,7 +36,8 @@ describe('createHandler', () => {
       {
         awsRequestId: '-',
         level: 20,
-        msg: 'Function succeeded',
+        output,
+        msg: 'Function completed',
       },
     ]);
   });
@@ -47,7 +52,7 @@ describe('createHandler', () => {
     expect(stdoutMock.calls).toMatchObject([
       {
         awsRequestId: '-',
-        err: {
+        error: {
           message: err.message,
           type: 'Error',
         },
@@ -69,7 +74,7 @@ describe('createHandler', () => {
     expect(stdoutMock.calls).toMatchObject([
       {
         awsRequestId: '-',
-        err: {
+        error: {
           message: err.message,
           type: 'Error',
         },

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

@@ -1,40 +1,60 @@
-import type { Context as LambdaContext } from 'aws-lambda';
-import { datadog } from 'datadog-lambda-js';
+import type {
+  Context as LambdaContext,
+  SQSBatchItemFailure,
+  SQSBatchResponse,
+  SQSEvent,
+  SQSRecord,
+} from 'aws-lambda';
 
-import { config } from 'src/config.js';
-import { logger, loggerContext } from 'src/framework/logging.js';
+import { lambdaContext, logger, recordContext } from 'src/framework/logging.js';
 
 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, ctx: LambdaContext) => Promise<Output>,
-) =>
-  withDatadog<Event>((event, ctx) =>
-    loggerContext.run({ awsRequestId: ctx.awsRequestId }, async () => {
+export const createHandler =
+  <Event extends SQSEvent, Output = unknown>(
+    fn: (event: Event, ctx: LambdaContext) => Promise<Output>,
+  ): Handler<Event, Output> =>
+  async (event, ctx) =>
+    lambdaContext.run({ awsRequestId: ctx.awsRequestId }, async () => {
       try {
         const output = await fn(event, ctx);
 
-        logger.debug('Function succeeded');
+        logger.debug({ output }, 'Function completed');
 
         return output;
       } catch (err) {
-        logger.error({ err }, 'Function failed');
+        logger.error(err, 'Function failed');
 
         throw new Error('Function failed');
       }
-    }),
-  );
+    });
+
+export const createBatchSQSHandler =
+  (
+    fn: (record: SQSRecord, ctx: LambdaContext) => Promise<unknown>,
+  ): Handler<SQSEvent, SQSBatchResponse> =>
+  async (event, ctx) => {
+    const processRecord = (
+      record: SQSRecord,
+    ): Promise<SQSBatchItemFailure | undefined> =>
+      recordContext.run({ sqsMessageId: record.messageId }, async () => {
+        try {
+          await fn(record, ctx);
+          return;
+        } catch (err) {
+          logger.error(err, 'Processing record failed');
+          return {
+            itemIdentifier: record.messageId,
+          };
+        }
+      });
+
+    const results = await Promise.all(event.Records.map(processRecord));
+
+    return {
+      batchItemFailures: results.filter((item) => item !== undefined),
+    };
+  };