test: add integration test for durable-function cold-start metric tag

Deploys a real durable-configured Lambda alongside a plain guard function
and asserts the cold-start aws.lambda.enhanced.invocations metric carries
durable_function:true only for the durable one, exercising the fix in
a905347 end-to-end.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: lym953

.gitlab/datasources/test-suites.yaml

@@ -7,3 +7,4 @@ test_suites:
   - name: oom
   - name: lmi-oom
   - name: payload-size
+  - name: durable-cold-start

integration-tests/bin/app.ts

@@ -10,6 +10,7 @@ import {Oom} from '../lib/stacks/oom';
 import {LmiOom} from '../lib/stacks/lmi-oom';
 import {CustomMetrics} from '../lib/stacks/custom-metrics';
 import {PayloadSize} from '../lib/stacks/payload-size';
+import {DurableColdStart} from '../lib/stacks/durable-cold-start';
 import {AuthRoleStack} from '../lib/auth-role';
 import {ACCOUNT, IDENTIFIER, REGION} from '../config';
 import {CapacityProviderStack} from "../lib/capacity-provider";
@@ -54,6 +55,9 @@ const stacks = [
     new PayloadSize(app, `${IDENTIFIER}-payload-size`, {
         env,
     }),
+    new DurableColdStart(app, `${IDENTIFIER}-durable-cold-start`, {
+        env,
+    }),
 ]
 
 // Tag all stacks so we can easily clean them up

integration-tests/lib/stacks/durable-cold-start.ts

@@ -0,0 +1,71 @@
+import * as cdk from 'aws-cdk-lib';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+import {
+  createLogGroup,
+  defaultDatadogEnvVariables,
+  defaultDatadogSecretPolicy,
+  getExtensionLayer,
+  getDefaultNodeLayer,
+  defaultNodeRuntime,
+} from '../util';
+
+// Durable-function cold-start metric tag test.
+// The Lambda Telemetry API only reports a `platform.initStart` runtimeVersion
+// containing "DurableFunction" for functions actually configured with
+// `durableConfig`, so this stack deploys one durable and one non-durable
+// function to exercise bottlecap's `durable_function:true` tagging on the
+// cold-start `aws.lambda.enhanced.invocations` metric end-to-end.
+export class DurableColdStart extends cdk.Stack {
+  constructor(scope: Construct, id: string, props: cdk.StackProps) {
+    super(scope, id, props);
+
+    const extensionLayer = getExtensionLayer(this);
+    const nodeLayer = getDefaultNodeLayer(this);
+
+    const durableFunctionName = `${id}-durable-lambda`;
+    const durableFunction = new lambda.Function(this, durableFunctionName, {
+      runtime: defaultNodeRuntime,
+      architecture: lambda.Architecture.ARM_64,
+      handler: '/opt/nodejs/node_modules/datadog-lambda-js/handler.handler',
+      code: lambda.Code.fromAsset('./lambda/default-node'),
+      functionName: durableFunctionName,
+      timeout: cdk.Duration.seconds(30),
+      memorySize: 256,
+      durableConfig: {
+        executionTimeout: cdk.Duration.minutes(5),
+      },
+      environment: {
+        ...defaultDatadogEnvVariables,
+        DD_SERVICE: durableFunctionName,
+        DD_TRACE_ENABLED: 'true',
+        DD_LAMBDA_HANDLER: 'index.handler',
+      },
+      logGroup: createLogGroup(this, durableFunctionName),
+    });
+    durableFunction.addToRolePolicy(defaultDatadogSecretPolicy);
+    durableFunction.addLayers(extensionLayer);
+    durableFunction.addLayers(nodeLayer);
+
+    const nonDurableFunctionName = `${id}-non-durable-lambda`;
+    const nonDurableFunction = new lambda.Function(this, nonDurableFunctionName, {
+      runtime: defaultNodeRuntime,
+      architecture: lambda.Architecture.ARM_64,
+      handler: '/opt/nodejs/node_modules/datadog-lambda-js/handler.handler',
+      code: lambda.Code.fromAsset('./lambda/default-node'),
+      functionName: nonDurableFunctionName,
+      timeout: cdk.Duration.seconds(30),
+      memorySize: 256,
+      environment: {
+        ...defaultDatadogEnvVariables,
+        DD_SERVICE: nonDurableFunctionName,
+        DD_TRACE_ENABLED: 'true',
+        DD_LAMBDA_HANDLER: 'index.handler',
+      },
+      logGroup: createLogGroup(this, nonDurableFunctionName),
+    });
+    nonDurableFunction.addToRolePolicy(defaultDatadogSecretPolicy);
+    nonDurableFunction.addLayers(extensionLayer);
+    nonDurableFunction.addLayers(nodeLayer);
+  }
+}

integration-tests/tests/durable-cold-start.test.ts

@@ -0,0 +1,70 @@
+// Verifies bottlecap holds the cold-start `aws.lambda.enhanced.invocations`
+// metric until the Telemetry API's `platform.initStart` event reports the
+// runtime, so the metric carries `durable_function:true` for a real
+// durable-configured Lambda function (#1301). A plain (non-durable) function
+// is invoked alongside as a guard against the tag being set unconditionally.
+import { hasMetricWithTag } from './utils/datadog';
+import { forceColdStart, invokeLambda } from './utils/lambda';
+import { IDENTIFIER, DEFAULT_DATADOG_INDEXING_WAIT_MS } from '../config';
+
+const stackName = `${IDENTIFIER}-durable-cold-start`;
+
+const INVOCATIONS_METRIC = 'aws.lambda.enhanced.invocations';
+
+describe('Durable Function Cold-Start Metric Tag Integration Tests', () => {
+  let invocationStartTime: number;
+  let metricsEndTime: number;
+
+  const durableFunctionName = `${stackName}-durable-lambda`;
+  const nonDurableFunctionName = `${stackName}-non-durable-lambda`;
+
+  beforeAll(async () => {
+    const functionNames = [durableFunctionName, nonDurableFunctionName];
+
+    await Promise.all(functionNames.map((fn) => forceColdStart(fn)));
+
+    // Back up the query window by 60s so the metric bucket (which Datadog
+    // aligns to the rollup interval boundary, often before the invocation)
+    // falls inside the range we pass to /api/v1/query.
+    invocationStartTime = Date.now() - 60_000;
+
+    // Durable functions reject unqualified-ARN invokes ("You cannot invoke a
+    // durable function using an unqualified ARN"); `:$LATEST` satisfies that
+    // without publishing a version. Metric queries below use the base
+    // (unqualified) function name, which is unaffected by this qualifier.
+    await Promise.all([
+      invokeLambda(`${durableFunctionName}:$LATEST`),
+      invokeLambda(nonDurableFunctionName),
+    ]);
+
+    await new Promise((resolve) =>
+      setTimeout(resolve, DEFAULT_DATADOG_INDEXING_WAIT_MS),
+    );
+
+    metricsEndTime = Date.now();
+
+    console.log('Lambdas invoked and indexing wait complete');
+  }, 1800000);
+
+  it('durable function cold-start invocation metric should have durable_function:true', async () => {
+    const hasTag = await hasMetricWithTag(
+      INVOCATIONS_METRIC,
+      durableFunctionName,
+      'durable_function:true',
+      invocationStartTime,
+      metricsEndTime,
+    );
+    expect(hasTag).toBe(true);
+  });
+
+  it('non-durable function cold-start invocation metric should NOT have durable_function:true', async () => {
+    const hasTag = await hasMetricWithTag(
+      INVOCATIONS_METRIC,
+      nonDurableFunctionName,
+      'durable_function:true',
+      invocationStartTime,
+      metricsEndTime,
+    );
+    expect(hasTag).toBe(false);
+  });
+});