refactor

Author: jchrostek-dd

integration-tests/README.md

@@ -2,26 +2,19 @@
 
 This directory contains integration tests for the Datadog Lambda Extension. 
 
+Each test suite has a cdk stack and an associated test file. Example, `base.ts` and `base.tests.ts`. Test suits are run in parallel in Gitlab CI/CD pipeline.
+
 The general flow is:
 1. Deploy test setup using CDK.
 2. Invoke lambda functions.
 3. Wait for data to propagate to Datadog.
 4. Call Datadog to get telemetry data and check the data based on test requirements.
 
-For simplicity, integration tests are setup to only test against ARM runtimes.
-
-## Supported Runtimes
+For simplicity, integration tests are set up to only test against ARM runtimes and 4 runtimes (Python, Node, Java, and Dotnet).
 
-All test suites cover the following Lambda runtimes:
-- **Java 21** - Eclipse Temurin
-- **.NET 8** - Alpine
-- **Python 3.12/3.13** - Standard Python runtime
-- **Node.js 20** - Alpine
 
 ## Test Suites
 
-Integration tests are organized into independent test suites that run in parallel in the GitLab CI/CD pipeline. Each suite has its own lifecycle (deploy → test → cleanup) and can be executed independently.
-
 ### Base Tests
 
 The base test suite provides basic functionality tests across all supported Lambda runtimes. These tests verify core extension functionality without additional instrumentation.
@@ -55,10 +48,6 @@ The OTLP test suite verifies OpenTelemetry Protocol (OTLP) integration with the
 
 ## CI/CD Pipeline Structure
 
-The GitLab CI/CD pipeline runs test suites independently in parallel, providing:
-- **Isolation**: One test suite failure doesn't block others
-- **Speed**: Test suites run simultaneously
-- **Efficiency**: Can retry individual test suites without redeploying all stacks
 
 ### Pipeline Flow
 
@@ -70,26 +59,26 @@ publish layer → build lambdas ─────┤
 
 ### Test Suite Lifecycle
 
-Each test suite (base, otlp) follows this lifecycle:
+Each test suite (base, otlp, etc.) follows this lifecycle:
 
 1. **Deploy**: Deploys only the stacks for that suite
-   - Pattern: `cdk deploy "integ-${IDENTIFIER}-${TEST_SUITE}-*"`
-   - Example: `integ-abc123-base-*` deploys all base test stacks
+   - Pattern: `cdk deploy "integ-${IDENTIFIER}-${TEST_SUITE}"`
+   - Example: `integ-abc123-base` deploys all base test stacks
 
 2. **Test**: Runs only the tests for that suite
    - Command: `jest tests/${TEST_SUITE}.test.ts`
    - Example: `jest tests/base.test.ts`
 
 3. **Cleanup**: Removes only the stacks for that suite
    - Runs with `when: always` to ensure cleanup on failure
-   - Pattern: Deletes all stacks matching `integ-${IDENTIFIER}-${TEST_SUITE}-*`
+   - Pattern: Deletes all stacks matching `integ-${IDENTIFIER}-${TEST_SUITE}`
 
 ### Adding a New Test Suite
 
 To add a new test suite to the parallel execution:
 
 1. **Create test file**: `tests/<suite-name>.test.ts`
-2. **Create CDK stacks**: `lib/stacks/<suite-name>-<runtime>-stack.ts`
+2. **Create CDK stacks**: `lib/stacks/<suite-name>.ts`
 3. **Register stacks**: Add to `bin/app.ts`
 4. **Update pipeline**: Add suite name to `.gitlab/templates/pipeline.yaml.tpl`:
    ```yaml
@@ -98,58 +87,6 @@ To add a new test suite to the parallel execution:
        - TEST_SUITE: [base, otlp, <suite-name>]
    ```
 
-### Running Test Suites Locally
-
-Test individual suites using CDK patterns:
-
-```bash
-# Deploy specific test suite
-export IDENTIFIER="john"
-npx cdk deploy "integ-${IDENTIFIER}-base-*" --require-approval never
-
-# Run specific test suite
-jest tests/base.test.ts
-
-# Cleanup specific test suite stacks
-aws cloudformation list-stacks \
-  --query "StackSummaries[?starts_with(StackName, 'integ-${IDENTIFIER}-base-')].StackName" \
-  --output text | xargs -n1 aws cloudformation delete-stack --stack-name
-```
-
-## Building Lambda Functions
-
-Lambda functions with compiled languages (Java, .NET) or external dependencies (Python, Node.js with packages) must be built before deployment. Build scripts use Docker for cross-platform compatibility and don't require local toolchains.
-
-### Build Scripts
-
-Runtime-specific build scripts are located in `scripts/`:
-
-```bash
-# Build all Java Lambda functions
-./scripts/build-java.sh
-
-# Build all .NET Lambda functions
-./scripts/build-dotnet.sh
-
-# Build all Python Lambda functions
-./scripts/build-python.sh
-
-# Build all Node.js Lambda functions
-./scripts/build-node.sh
-```
-
-You can also build a specific function by providing its path:
-
-```bash
-# Build a specific Java function
-./scripts/build-java.sh lambda/otlp-java
-
-# Build a specific .NET function
-./scripts/build-dotnet.sh lambda/base-dotnet
-```
-
-**Note:** The `local_deploy.sh` script automatically builds required Lambda functions based on the stack name, so manual building is optional for local development.
-
 ## Guidelines
 
 ### Naming
@@ -172,7 +109,7 @@ export DD_APP_KEY="your-datadog-app-key"
 export DATADOG_API_SECRET_ARN="arn:aws:secretsmanager:us-east-1:ACCOUNT_ID:secret:YOUR_SECRET"
 ```
 
-**Docker**: Required for building Lambda functions. [Install Docker](https://docs.docker.com/get-docker/)
+**Docker**: Required for building Lambda functions.
 
 ### Workflow
 
@@ -201,19 +138,11 @@ This creates `integ-<your-name>-<stack-name>` and automatically:
 
 **Examples:**
 ```bash
-# Deploy base Java test
-./scripts/local_deploy.sh base-java-stack
+# Deploy base test stack
+./scripts/local_deploy.sh base
 
-# Deploy OTLP Python test
-./scripts/local_deploy.sh otlp-python-stack
 ```
 
-**Available Stacks:**
-- `base-java-stack`, `otlp-java-stack`
-- `base-dotnet-stack`, `otlp-dotnet-stack`
-- `base-python-stack`, `otlp-python-stack`
-- `base-node-stack`, `otlp-node-stack`
-
 #### 3. Run Integration Tests
 
 Run Jest tests that invoke Lambda functions and verify Datadog telemetry:
@@ -223,27 +152,8 @@ Run Jest tests that invoke Lambda functions and verify Datadog telemetry:
 npm test
 
 # Run specific test file
-npm test -- base-java.test.ts
+npm test -- base.test.ts
 
-# Run specific test suite
-npm test -- --testNamePattern="OTLP"
 ```
 
 **Note**: Tests wait several minutes after Lambda invocation to allow telemetry to propagate to Datadog.
-
-### Manual Building (Optional)
-
-If you need to build Lambda functions manually without deploying:
-
-```bash
-# Build all functions for a runtime
-./scripts/build-java.sh
-./scripts/build-dotnet.sh
-./scripts/build-python.sh
-./scripts/build-node.sh
-
-# Build specific function
-./scripts/build-java.sh lambda/otlp-java
-``` 
-
-

integration-tests/bin/app.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import 'source-map-support/register';
 import * as cdk from 'aws-cdk-lib';
-import {BaseStack} from '../lib/stacks/base-stack';
-import {OtlpStack} from '../lib/stacks/otlp-stack';
+import {Base} from '../lib/stacks/base';
+import {Otlp} from '../lib/stacks/otlp';
 import {getIdentifier} from '../tests/utils/config';
 
 const app = new cdk.App();
@@ -15,10 +15,10 @@ const env = {
 const identifier = getIdentifier();
 
 const stacks = [
-    new BaseStack(app, `integ-${identifier}-base`, {
+    new Base(app, `integ-${identifier}-base`, {
         env,
     }),
-    new OtlpStack(app, `integ-${identifier}-otlp`, {
+    new Otlp(app, `integ-${identifier}-otlp`, {
         env,
     }),
 ]

integration-tests/lib/stacks/base-dotnet-stack.ts

@@ -12,7 +12,7 @@ import {
   getDotnet8Layer
 } from '../util';
 
-export class BaseStack extends cdk.Stack {
+export class Base extends cdk.Stack {
   constructor(scope: Construct, id: string, props: cdk.StackProps) {
     super(scope, id, props);