Setting Up AWS Distro for OpenTelemetry with Container-Based Lambda Functions and New Relic

├── Dockerfile
├── template.yaml
└── src/
    ├── index.js
    └── package.json

# Stage 1: Builder - Download and extract the ADOT Lambda Layer
# Using Alpine for minimal footprint and fast download
FROM alpine as builder

# Install tools needed to fetch and extract the layer
RUN apk add --no-cache curl unzip

# ADOT layer URL - update this if using a different language runtime
ARG ADOT_LAYER_URL="https://github.com/aws-observability/aws-otel-js-instrumentation/releases/latest/download/layer.zip"

# Download and extract to /opt (same location AWS uses for layers)
RUN curl -Lo /tmp/layer.zip "${ADOT_LAYER_URL}" && \
    unzip /tmp/layer.zip -d /opt && \
    rm /tmp/layer.zip

# Stage 2: Final Lambda Image
FROM public.ecr.aws/lambda/nodejs:22

# Copy ADOT layer contents from builder
COPY --from=builder /opt /opt

# Make the ADOT wrapper script executable
RUN chmod +x /opt/otel-instrument

# Install dependencies and copy function code
COPY src/package.json ${LAMBDA_TASK_ROOT}
RUN npm install

COPY src/index.js ${LAMBDA_TASK_ROOT}

CMD [ "index.handler" ]

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Container Lambda with ADOT and New Relic

Parameters:
  NewRelicLicenseKey:
    Type: String
    Description: "New Relic Ingest License Key"
    NoEcho: true

Globals:
  Function:
    Timeout: 30
    MemorySize: 256
    LoggingConfig:
      LogFormat: JSON
    Environment:
      Variables:
        AWS_LAMBDA_EXEC_WRAPPER: /opt/otel-instrument
        # Disable AWS Application Signals to prevent interference
        OTEL_AWS_APPLICATION_SIGNALS_ENABLED: 'false'
        # Enable specific instrumentations (Optional)
        OTEL_NODE_ENABLED_INSTRUMENTATIONS: 'aws-sdk,aws-lambda,http,pino'
        OTEL_SERVICE_NAME: container-lambda-hello
        OTEL_PROPAGATORS: 'tracecontext,baggage'
        # Exporters
        OTEL_TRACES_EXPORTER: otlp
        OTEL_METRICS_EXPORTER: otlp
        OTEL_LOGS_EXPORTER: otlp
        # OTLP Endpoints (signal-specific)
        OTEL_EXPORTER_OTLP_PROTOCOL: http/protobuf
        OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: https://otlp.nr-data.net:4318/v1/traces
        OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: https://otlp.nr-data.net:4318/v1/metrics
        OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: https://otlp.nr-data.net:4318/v1/logs
        OTEL_EXPORTER_OTLP_HEADERS: !Sub "api-key=${NewRelicLicenseKey}"

Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      PackageType: Image
      Architectures:
        - x86_64
      Events:
        Api:
          Type: HttpApi
    Metadata:
      DockerTag: latest
      DockerContext: .
      Dockerfile: Dockerfile

Outputs:
  ApiEndpoint:
    Description: "API Gateway endpoint URL"
    Value: !Sub "https://${ServerlessHttpApi}.execute-api.${AWS::Region}.amazonaws.com/"

{
  "type": "module",
  "dependencies": {
    "@opentelemetry/api": "^1.9.0",
    "pino": "^9.0.0"
  }
}

import { metrics } from '@opentelemetry/api';

const meter = metrics.getMeter('my-lambda-metrics');

const workDurationHistogram = meter.createHistogram('work_item_duration', {
    description: 'Duration of work items in milliseconds',
    unit: 'ms',
});

const workItemCounter = meter.createCounter('work_item_count', {
    description: 'Count of work items processed',
});

export const recordWorkMetrics = (id, duration, success = true) => {
    workDurationHistogram.record(duration, { 'work.item.id': id, 'work.success': success });
    workItemCounter.add(1, { 'work.item.id': id, 'work.success': success });
};

import { trace, SpanStatusCode } from '@opentelemetry/api';
import pino from 'pino';
import { recordWorkMetrics } from './metrics.js';

// Pino logger - ADOT auto-instruments this
const logger = pino({ level: 'info' });

const doWork = async (id) => {
    const tracer = trace.getTracer('my-lambda-tracer');
    const span = tracer.startSpan(`doWork-${id}`);
    span.setAttribute('work-item-id', id);

    try {
        logger.info({ itemId: id }, `Starting work item ${id}`);
        const delay = Math.floor(Math.random() * 200) + 100;
        await new Promise(resolve => setTimeout(resolve, delay));
        
        logger.info({ itemId: id, duration: delay }, `Completed work item ${id}`);
        recordWorkMetrics(id, delay, true);
        span.setStatus({ code: SpanStatusCode.OK });
        return { id, duration: delay };
    } catch (error) {
        logger.error({ itemId: id, error: error.message }, `Work item ${id} failed`);
        recordWorkMetrics(id, 0, false);
        span.recordException(error);
        span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
        return { id, error: error.message };
    } finally {
        span.end();
    }
};

export const handler = async (event) => {
    const tracer = trace.getTracer('my-lambda-tracer');
    return tracer.startActiveSpan('handler-span', async (span) => {
        logger.info({ event }, 'Event received');
        try {
            logger.info('Initializing processing...');
            const results = await Promise.all([1, 2, 3].map(doWork));
            
            span.setStatus({ code: SpanStatusCode.OK });
            span.end();
            return { statusCode: 200, body: JSON.stringify({ results }) };
        } catch (error) {
            logger.error({ error: error.message }, 'Handler failed');
            span.recordException(error);
            span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
            span.end();
            return { statusCode: 502, body: JSON.stringify({ error: 'Bad Gateway' }) };
        }
    });
};

# Build the container image
sam build

# Deploy to AWS
sam deploy --guided