@senzops/apm-node 1.3.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@senzops/apm-node",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Universal APM SDK for Senzor",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,6 +15,11 @@
       "types": "./dist/register.d.ts",
       "require": "./dist/register.js",
       "import": "./dist/register.mjs"
+    },
+    "./lambda-handler": {
+      "types": "./dist/lambda-handler.d.ts",
+      "require": "./dist/lambda-handler.js",
+      "import": "./dist/lambda-handler.mjs"
     }
   },
   "scripts": {

package/src/lambda-handler.ts

@@ -0,0 +1,262 @@
+// ---------------------------------------------------------------------------
+// Senzor Lambda Auto-Handler Wrapper
+//
+// This module is the entry point for zero-code-change Lambda Extension Layer
+// deployments. It is referenced as the Lambda function's handler:
+//
+//   Handler: @senzops/apm-node/dist/lambda-handler.handler
+//
+// It reads the user's original handler from an environment variable,
+// dynamically loads it, wraps it with Senzor instrumentation, and
+// re-exports the wrapped function.
+//
+// Required environment variables:
+//   SENZOR_API_KEY           — Senzor API key
+//   SENZOR_LAMBDA_HANDLER    — Original handler in module.function format
+//                              (e.g., "index.handler", "src/app.myHandler")
+//
+// Optional environment variables:
+//   All standard SENZOR_* env vars (see register.ts)
+//
+// How it works:
+//   1. Initializes Senzor SDK via the same logic as register.ts
+//   2. Parses SENZOR_LAMBDA_HANDLER into module path + export name
+//   3. Resolves the module from LAMBDA_TASK_ROOT (the function's code dir)
+//   4. Extracts the named export (supports nested paths like "a.b.c")
+//   5. Wraps with wrapLambda() for full APM coverage
+//   6. Exports as "handler" for Lambda to invoke
+//
+// This gives users the same experience as New Relic / Datadog Lambda Layers:
+// just add the layer, set 2 env vars, zero code changes.
+// ---------------------------------------------------------------------------
+
+import { client } from './core/client';
+import { getEnv } from './core/runtime';
+import { wrapLambda } from './wrappers/lambda';
+import * as path from 'path';
+
+// ---------------------------------------------------------------------------
+// 1. Initialize Senzor SDK (same logic as register.ts)
+// ---------------------------------------------------------------------------
+
+const truthy = (value: string | undefined): boolean =>
+  value === '1' || value === 'true' || value === 'yes';
+
+const numberFromEnv = (value: string | undefined): number | undefined => {
+  if (!value) return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+};
+
+const apiKey =
+  getEnv('SENZOR_API_KEY') ||
+  getEnv('SENZOR_APM_API_KEY') ||
+  getEnv('SENZOR_SERVICE_API_KEY');
+
+const endpoint =
+  getEnv('SENZOR_ENDPOINT') ||
+  getEnv('SENZOR_APM_ENDPOINT');
+
+const isLambda = !!getEnv('AWS_LAMBDA_FUNCTION_NAME');
+
+const options = {
+  apiKey: apiKey || '',
+  endpoint,
+  debug: truthy(getEnv('SENZOR_DEBUG')),
+  autoLogs: getEnv('SENZOR_AUTO_LOGS') === 'false' ? false : undefined,
+  batchSize: numberFromEnv(getEnv('SENZOR_BATCH_SIZE')) ?? (isLambda ? 10 : undefined),
+  flushInterval: numberFromEnv(getEnv('SENZOR_FLUSH_INTERVAL')) ?? (isLambda ? 0 : undefined),
+  flushTimeoutMs: numberFromEnv(getEnv('SENZOR_FLUSH_TIMEOUT_MS')),
+  maxQueueSize: numberFromEnv(getEnv('SENZOR_MAX_QUEUE_SIZE')),
+  maxSpansPerTrace: numberFromEnv(getEnv('SENZOR_MAX_SPANS_PER_TRACE')),
+  captureHeaders: truthy(getEnv('SENZOR_CAPTURE_HEADERS')),
+  captureDbStatement:
+    getEnv('SENZOR_CAPTURE_DB_STATEMENT') === 'false' ? false : undefined,
+  frameworkSpans:
+    getEnv('SENZOR_FRAMEWORK_SPANS') === 'false' ? false : undefined,
+  captureMiddlewareSpans:
+    getEnv('SENZOR_CAPTURE_MIDDLEWARE_SPANS') === 'false' ? false : undefined,
+  captureRouterSpans:
+    getEnv('SENZOR_CAPTURE_ROUTER_SPANS') === 'false' ? false : undefined,
+  captureLifecycleHookSpans:
+    getEnv('SENZOR_CAPTURE_LIFECYCLE_HOOK_SPANS') === 'false' ? false : undefined,
+  runtimeMetrics:
+    getEnv('SENZOR_RUNTIME_METRICS') === 'false' || isLambda ? false : undefined,
+  runtimeMetricsInterval: numberFromEnv(getEnv('SENZOR_RUNTIME_METRICS_INTERVAL')),
+};
+
+if (apiKey) {
+  client.init(options);
+} else {
+  client.preload(options);
+}
+
+// ---------------------------------------------------------------------------
+// 2. Resolve and wrap the user's original handler
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse a Lambda handler string into module path and function path.
+ *
+ * Examples:
+ *   "index.handler"           → { modulePath: "index",     fnPath: ["handler"] }
+ *   "src/app.myHandler"       → { modulePath: "src/app",   fnPath: ["myHandler"] }
+ *   "dist/handlers.api.get"   → { modulePath: "dist/handlers", fnPath: ["api", "get"] }
+ *
+ * Lambda convention: everything before the LAST dot that isn't part of a
+ * directory path is the module, everything after is the function path.
+ * Since module paths can contain dots in directory names, we split on the
+ * last dot after the last path separator.
+ */
+const parseHandlerString = (handlerStr: string): { modulePath: string; fnPath: string[] } => {
+  const lastSlash = Math.max(handlerStr.lastIndexOf('/'), handlerStr.lastIndexOf('\\'));
+  const afterSlash = lastSlash >= 0 ? handlerStr.substring(lastSlash + 1) : handlerStr;
+  const beforeSlash = lastSlash >= 0 ? handlerStr.substring(0, lastSlash + 1) : '';
+
+  const firstDot = afterSlash.indexOf('.');
+  if (firstDot < 0) {
+    // No dot — treat the whole thing as the module, export "handler"
+    return { modulePath: handlerStr, fnPath: ['handler'] };
+  }
+
+  const moduleName = afterSlash.substring(0, firstDot);
+  const fnParts = afterSlash.substring(firstDot + 1).split('.');
+
+  return {
+    modulePath: beforeSlash + moduleName,
+    fnPath: fnParts,
+  };
+};
+
+/**
+ * Resolve a handler export from a module given a function path.
+ * Supports nested exports: ["api", "get"] resolves module.api.get
+ */
+const resolveExport = (moduleExports: any, fnPath: string[]): Function | null => {
+  let current = moduleExports;
+
+  for (const part of fnPath) {
+    if (current == null || typeof current !== 'object') return null;
+    current = current[part];
+  }
+
+  // Also check .default for ESM interop
+  if (current == null && moduleExports?.default) {
+    current = moduleExports.default;
+    for (const part of fnPath) {
+      if (current == null || typeof current !== 'object') return null;
+      current = current[part];
+    }
+  }
+
+  return typeof current === 'function' ? current : null;
+};
+
+/**
+ * Load the user's original handler module. Tries multiple resolution strategies:
+ *   1. Absolute path from LAMBDA_TASK_ROOT
+ *   2. require() with the module path as-is (for node_modules)
+ *   3. With common extensions (.js, .mjs, .cjs)
+ */
+const loadHandlerModule = (modulePath: string): any => {
+  const taskRoot = process.env.LAMBDA_TASK_ROOT || process.cwd();
+  const absolutePath = path.resolve(taskRoot, modulePath);
+
+  // Strategy 1: Direct absolute path
+  try {
+    return require(absolutePath);
+  } catch { }
+
+  // Strategy 2: With extensions
+  const extensions = ['.js', '.cjs', '.mjs'];
+  for (const ext of extensions) {
+    try {
+      return require(absolutePath + ext);
+    } catch { }
+  }
+
+  // Strategy 3: Module as-is (may be in node_modules or an absolute path)
+  try {
+    return require(modulePath);
+  } catch { }
+
+  return null;
+};
+
+// ---------------------------------------------------------------------------
+// 3. Build and export the wrapped handler
+// ---------------------------------------------------------------------------
+
+const handlerEnv = getEnv('SENZOR_LAMBDA_HANDLER');
+
+let wrappedHandler: Function;
+
+if (!handlerEnv) {
+  // No handler configured — export a diagnostic handler that returns an error
+  wrappedHandler = async () => {
+    const message =
+      'Senzor Lambda Layer: SENZOR_LAMBDA_HANDLER environment variable is not set. ' +
+      'Set it to your original handler (e.g., "index.handler") and set the Lambda ' +
+      'function handler to "@senzops/apm-node/dist/lambda-handler.handler".';
+
+    console.error(`[Senzor] ${message}`);
+
+    return {
+      statusCode: 500,
+      body: JSON.stringify({ error: message }),
+    };
+  };
+} else {
+  const { modulePath, fnPath } = parseHandlerString(handlerEnv);
+  const handlerModule = loadHandlerModule(modulePath);
+
+  if (!handlerModule) {
+    const errorMsg = `Senzor Lambda Layer: Could not load handler module "${modulePath}" ` +
+      `(from SENZOR_LAMBDA_HANDLER="${handlerEnv}"). Verify the module path exists ` +
+      `relative to your Lambda function code.`;
+
+    console.error(`[Senzor] ${errorMsg}`);
+
+    wrappedHandler = async () => ({
+      statusCode: 500,
+      body: JSON.stringify({ error: errorMsg }),
+    });
+  } else {
+    const originalHandler = resolveExport(handlerModule, fnPath);
+
+    if (!originalHandler) {
+      const errorMsg = `Senzor Lambda Layer: Module "${modulePath}" loaded successfully ` +
+        `but export "${fnPath.join('.')}" is not a function. ` +
+        `Available exports: ${Object.keys(handlerModule).join(', ')}`;
+
+      console.error(`[Senzor] ${errorMsg}`);
+
+      wrappedHandler = async () => ({
+        statusCode: 500,
+        body: JSON.stringify({ error: errorMsg }),
+      });
+    } else {
+      // Success — wrap the handler with full Senzor APM instrumentation
+      wrappedHandler = wrapLambda(originalHandler as any);
+
+      if (truthy(getEnv('SENZOR_DEBUG'))) {
+        console.log(
+          `[Senzor] Lambda handler wrapped: ${handlerEnv} → ` +
+          `module="${modulePath}", export="${fnPath.join('.')}"`,
+        );
+      }
+    }
+  }
+}
+
+/**
+ * The wrapped Lambda handler. Configure your Lambda function to use:
+ *
+ *   Handler: @senzops/apm-node/dist/lambda-handler.handler
+ *
+ * And set environment variables:
+ *
+ *   SENZOR_API_KEY=sz_apm_xxx
+ *   SENZOR_LAMBDA_HANDLER=index.handler
+ */
+export const handler = wrappedHandler;

package/tsup.config.ts

@@ -8,7 +8,7 @@ const NODE_BUILTINS = [
 
 export default defineConfig([
   {
-    entry: ['src/index.ts', 'src/register.ts'],
+    entry: ['src/index.ts', 'src/register.ts', 'src/lambda-handler.ts'],
     format: ['cjs', 'esm'],
     dts: true,
     clean: true,

package/wiki.md

@@ -333,7 +333,228 @@ With preload mode, no wrapper is needed — `http.createServer` is automatically
 
 ## 4. AWS Lambda Integration
 
-### 4.1 Handler Wrapper (Recommended)
+Three deployment methods, from zero-code to code-level:
+
+| Method | Code Changes | Setup | Coverage |
+|--------|-------------|-------|----------|
+| **Extension Layer** (recommended) | None | Add layer + set env vars | Full: auto-handler wrapping + all auto-instrumentation |
+| **Handler Wrapper** | Modify handler file | `npm install` + code change | Full |
+| **Preload Layer** | None | Add layer + `NODE_OPTIONS` | Partial: outgoing calls/DB only, no handler wrapping |
+
+### 4.1 Lambda Extension Layer (Zero Code Changes, Recommended)
+
+The Extension Layer approach works identically to New Relic and Datadog Lambda Layers. You package `@senzops/apm-node` as a Lambda Layer, point the function's handler to Senzor's auto-wrapper, and set `SENZOR_LAMBDA_HANDLER` to your original handler. No code changes.
+
+**How it works:**
+
+1. Lambda invokes `@senzops/apm-node/dist/lambda-handler.handler`
+2. The auto-wrapper reads `SENZOR_LAMBDA_HANDLER` (e.g., `index.handler`)
+3. It dynamically loads your original handler module from `LAMBDA_TASK_ROOT`
+4. It wraps your handler with `wrapLambda()` for full APM coverage
+5. It re-exports the wrapped function for Lambda to invoke
+
+**Step 1: Build the Lambda Layer**
+
+```sh
+mkdir -p senzor-layer/nodejs
+cd senzor-layer/nodejs
+npm init -y
+npm install @senzops/apm-node
+cd ..
+zip -r senzor-apm-layer.zip nodejs/
+```
+
+**Step 2: Publish the Layer**
+
+```sh
+aws lambda publish-layer-version \
+  --layer-name senzor-apm-node \
+  --zip-file fileb://senzor-apm-layer.zip \
+  --compatible-runtimes nodejs18.x nodejs20.x nodejs22.x
+```
+
+**Step 3: Configure Your Function**
+
+```sh
+aws lambda update-function-configuration \
+  --function-name my-function \
+  --layers <LAYER_ARN> \
+  --handler @senzops/apm-node/dist/lambda-handler.handler \
+  --environment Variables="{ \
+    SENZOR_API_KEY=sz_apm_xxx, \
+    SENZOR_LAMBDA_HANDLER=index.handler, \
+    NODE_OPTIONS=--require @senzops/apm-node/register \
+  }"
+```
+
+| Environment Variable | Required | Description |
+|---------------------|----------|-------------|
+| `SENZOR_API_KEY` | Yes | Your Senzor APM API key |
+| `SENZOR_LAMBDA_HANDLER` | Yes | Original handler path (e.g., `index.handler`, `src/app.myHandler`) |
+| `NODE_OPTIONS` | Recommended | `--require @senzops/apm-node/register` for full preload coverage |
+
+The handler path supports nested exports: `SENZOR_LAMBDA_HANDLER=src/handlers.api.get` resolves to `require('src/handlers').api.get`.
+
+### 4.2 Extension Layer with AWS CDK
+
+```ts
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as path from 'path';
+
+// Create the Senzor APM Layer
+const senzorLayer = new lambda.LayerVersion(this, 'SenzorApmLayer', {
+  code: lambda.Code.fromAsset(path.join(__dirname, 'senzor-layer')),
+  compatibleRuntimes: [
+    lambda.Runtime.NODEJS_18_X,
+    lambda.Runtime.NODEJS_20_X,
+    lambda.Runtime.NODEJS_22_X,
+  ],
+  description: 'Senzor APM Node.js Lambda Extension Layer',
+});
+
+// Attach to your Lambda function
+const fn = new lambda.Function(this, 'MyFunction', {
+  runtime: lambda.Runtime.NODEJS_20_X,
+  // Point handler to Senzor's auto-wrapper
+  handler: '@senzops/apm-node/dist/lambda-handler.handler',
+  code: lambda.Code.fromAsset('lambda'),
+  layers: [senzorLayer],
+  environment: {
+    SENZOR_API_KEY: senzorApiKey.stringValue,
+    // Your original handler path
+    SENZOR_LAMBDA_HANDLER: 'index.handler',
+    NODE_OPTIONS: '--require @senzops/apm-node/register',
+  },
+});
+```
+
+Build the layer directory first:
+
+```sh
+mkdir -p senzor-layer/nodejs && cd senzor-layer/nodejs
+npm init -y && npm install @senzops/apm-node
+```
+
+### 4.3 Extension Layer with AWS SAM
+
+```yaml
+# template.yaml
+AWSTemplateFormatVersion: '2010-09-09'
+Transform: AWS::Serverless-2016-10-31
+
+Globals:
+  Function:
+    Layers:
+      - !Ref SenzorApmLayer
+    Environment:
+      Variables:
+        SENZOR_API_KEY: !Ref SenzorApiKey
+        NODE_OPTIONS: '--require @senzops/apm-node/register'
+
+Resources:
+  SenzorApmLayer:
+    Type: AWS::Serverless::LayerVersion
+    Properties:
+      LayerName: senzor-apm-node
+      ContentUri: senzor-layer/
+      CompatibleRuntimes:
+        - nodejs18.x
+        - nodejs20.x
+        - nodejs22.x
+
+  MyFunction:
+    Type: AWS::Serverless::Function
+    Properties:
+      Handler: '@senzops/apm-node/dist/lambda-handler.handler'
+      Runtime: nodejs20.x
+      CodeUri: src/
+      Environment:
+        Variables:
+          SENZOR_LAMBDA_HANDLER: index.handler
+```
+
+### 4.4 Extension Layer with Serverless Framework
+
+```yaml
+# serverless.yml
+service: my-service
+
+provider:
+  name: aws
+  runtime: nodejs20.x
+  environment:
+    SENZOR_API_KEY: ${ssm:/senzor/api-key}
+    NODE_OPTIONS: '--require @senzops/apm-node/register'
+
+layers:
+  senzorApm:
+    path: senzor-layer
+    compatibleRuntimes:
+      - nodejs18.x
+      - nodejs20.x
+      - nodejs22.x
+
+functions:
+  api:
+    handler: '@senzops/apm-node/dist/lambda-handler.handler'
+    layers:
+      - !Ref SenzorApmLambdaLayer
+    environment:
+      SENZOR_LAMBDA_HANDLER: src/handlers/api.handler
+```
+
+### 4.5 Extension Layer via AWS Console
+
+1. **Create the Layer zip** locally:
+   ```sh
+   mkdir -p senzor-layer/nodejs && cd senzor-layer/nodejs
+   npm init -y && npm install @senzops/apm-node
+   cd .. && zip -r senzor-apm-layer.zip nodejs/
+   ```
+
+2. **Upload the Layer**: Go to Lambda > Layers > Create layer. Upload `senzor-apm-layer.zip`. Set compatible runtimes to `nodejs18.x`, `nodejs20.x`, `nodejs22.x`.
+
+3. **Attach to your function**: Go to your Lambda function > Layers > Add a layer. Choose "Custom layers" and select `senzor-apm-node`.
+
+4. **Update function configuration**:
+   - **Handler**: `@senzops/apm-node/dist/lambda-handler.handler`
+   - **Environment variables**:
+     - `SENZOR_API_KEY` = your API key
+     - `SENZOR_LAMBDA_HANDLER` = your original handler (e.g., `index.handler`)
+     - `NODE_OPTIONS` = `--require @senzops/apm-node/register`
+
+### 4.6 Extension Layer with Terraform
+
+```hcl
+resource "aws_lambda_layer_version" "senzor_apm" {
+  filename            = "senzor-apm-layer.zip"
+  layer_name          = "senzor-apm-node"
+  compatible_runtimes = ["nodejs18.x", "nodejs20.x", "nodejs22.x"]
+  description         = "Senzor APM Node.js Lambda Extension Layer"
+}
+
+resource "aws_lambda_function" "api" {
+  function_name = "my-function"
+  runtime       = "nodejs20.x"
+  handler       = "@senzops/apm-node/dist/lambda-handler.handler"
+  filename      = "function.zip"
+  role          = aws_iam_role.lambda.arn
+
+  layers = [aws_lambda_layer_version.senzor_apm.arn]
+
+  environment {
+    variables = {
+      SENZOR_API_KEY         = var.senzor_api_key
+      SENZOR_LAMBDA_HANDLER  = "index.handler"
+      NODE_OPTIONS           = "--require @senzops/apm-node/register"
+    }
+  }
+}
+```
+
+### 4.7 Code-Level Handler Wrapper
+
+When you prefer code-level control or cannot use Lambda Layers:
 
 ```ts
 import Senzor from '@senzops/apm-node';
@@ -346,7 +567,9 @@ export const handler = Senzor.wrapLambda(async (event, context) => {
 });
 ```
 
-### 4.2 What `wrapLambda` Does
+### 4.8 What Gets Captured
+
+Both the Extension Layer and code-level wrapper capture the same telemetry:
 
 **Cold Start Detection:**
 The first invocation in each container is tagged with `faas.coldstart: true`. Subsequent warm invocations are tagged `false`.
@@ -369,7 +592,6 @@ The wrapper inspects the event shape and automatically detects:
 For HTTP triggers (API Gateway, ALB), the wrapper extracts method, path, headers, client IP, and status code. For messaging triggers, it extracts queue/topic names, batch sizes, and table names.
 
 **Lambda Context Extraction:**
-Every invocation captures these attributes:
 
 | Attribute | Source |
 |-----------|--------|
@@ -387,49 +609,14 @@ Every invocation captures these attributes:
 | `aws.log.group.names` | `context.logGroupName` |
 
 **Forced Flush:**
-After every invocation, the wrapper calls `await Senzor.flush()` before returning to the Lambda runtime. This is critical because Lambda freezes the process immediately after the handler returns.
+After every invocation, the wrapper calls `await Senzor.flush()` before returning to the Lambda runtime. Lambda freezes the process immediately after the handler returns.
 
 **Lambda Extensions API:**
-The wrapper registers as an internal Lambda extension to receive `SHUTDOWN` lifecycle events. This provides a safety-net flush when the Lambda execution environment is being terminated.
-
-### 4.3 Lambda Layer Deployment (Zero Code Changes)
-
-Package the SDK as a Lambda Layer and use `NODE_OPTIONS` for automatic initialization:
-
-**Step 1: Create the Layer**
-
-```sh
-mkdir -p layer/nodejs
-cd layer/nodejs
-npm init -y
-npm install @senzops/apm-node
-cd ..
-zip -r senzor-apm-layer.zip nodejs/
-```
-
-**Step 2: Publish the Layer**
-
-```sh
-aws lambda publish-layer-version \
-  --layer-name senzor-apm-node \
-  --zip-file fileb://senzor-apm-layer.zip \
-  --compatible-runtimes nodejs18.x nodejs20.x nodejs22.x
-```
-
-**Step 3: Attach to Your Function**
+The wrapper registers as an internal Lambda extension to receive `SHUTDOWN` lifecycle events. This provides a safety-net flush when the execution environment is being terminated.
 
-```sh
-aws lambda update-function-configuration \
-  --function-name my-function \
-  --layers arn:aws:lambda:us-east-1:123456789:layer:senzor-apm-node:1 \
-  --environment Variables="{SENZOR_API_KEY=sz_apm_xxx,NODE_OPTIONS=--require @senzops/apm-node/register}"
-```
-
-With this approach, the SDK initializes via preload before your handler code runs. For HTTP triggers, you still need `Senzor.wrapLambda` in your handler for proper route detection and response status capture. For non-HTTP triggers, preload alone captures outgoing calls and database operations.
+### 4.9 Lambda Auto-Detection
 
-### 4.4 Lambda Auto-Detection
-
-When running inside Lambda (detected via `AWS_LAMBDA_FUNCTION_NAME` env var), the register entrypoint automatically applies these optimizations:
+When running inside Lambda (detected via `AWS_LAMBDA_FUNCTION_NAME` env var), the SDK automatically optimizes settings:
 
 | Setting | Default | Lambda Override |
 |---------|---------|-----------------|
@@ -437,47 +624,6 @@ When running inside Lambda (detected via `AWS_LAMBDA_FUNCTION_NAME` env var), th
 | `batchSize` | `100` | `10` (short-lived invocations) |
 | `flushInterval` | `10000` | `0` (flush on demand only) |
 
-### 4.5 Lambda with SAM / CDK / Serverless Framework
-
-**AWS SAM (`template.yaml`):**
-
-```yaml
-Globals:
-  Function:
-    Layers:
-      - !Ref SenzorLayer
-    Environment:
-      Variables:
-        SENZOR_API_KEY: !Ref SenzorApiKey
-        NODE_OPTIONS: "--require @senzops/apm-node/register"
-```
-
-**Serverless Framework (`serverless.yml`):**
-
-```yaml
-provider:
-  environment:
-    SENZOR_API_KEY: ${ssm:/senzor/api-key}
-    NODE_OPTIONS: "--require @senzops/apm-node/register"
-  layers:
-    - arn:aws:lambda:us-east-1:123456789:layer:senzor-apm-node:1
-```
-
-**AWS CDK:**
-
-```ts
-const fn = new lambda.Function(this, 'Handler', {
-  runtime: lambda.Runtime.NODEJS_20_X,
-  handler: 'index.handler',
-  code: lambda.Code.fromAsset('dist'),
-  layers: [senzorLayer],
-  environment: {
-    SENZOR_API_KEY: senzorApiKey.stringValue,
-    NODE_OPTIONS: '--require @senzops/apm-node/register',
-  },
-});
-```
-
 ---
 
 ## 5. Cloudflare Workers Integration