MACRO NEPAL
Serverless Monitoring in Java: Comprehensive Observability for AWS Lambda
awiskar acharya
November 26, 2025
12:48 pm

Serverless monitoring requires a different approach than traditional application monitoring. With Java AWS Lambda functions, you need to track cold starts, execution duration, memory usage, and distributed tracing across function invocations.

Dependencies and Setup

1. Maven Dependencies
<properties>
<aws-lambda-java-core.version>1.2.3</aws-lambda-java-core.version>
<aws-lambda-java-events.version>3.11.4</aws-lambda-java-events.version>
<datadog-lambda-java.version>1.6.0</datadog-lambda-java.version>
<micrometer.version>1.11.5</micrometer.version>
<aws-java-sdk.version>2.20.0</aws-java-sdk.version>
</properties>
<dependencies>
<!-- AWS Lambda Core -->
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-lambda-java-core</artifactId>
<version>${aws-lambda-java-core.version}</version>
</dependency>
<!-- AWS Lambda Events -->
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-lambda-java-events</artifactId>
<version>${aws-lambda-java-events.version}</version>
</dependency>
<!-- Datadog Lambda (Optional) -->
<dependency>
<groupId>com.datadoghq</groupId>
<artifactId>datadog-lambda-java</artifactId>
<version>${datadog-lambda-java.version}</version>
</dependency>
<!-- Micrometer for CloudWatch Metrics -->
<dependency>
<groupId>io.micrometer</groupId>
<artifactId>micrometer-core</artifactId>
<version>${micrometer.version}</version>
</dependency>
<dependency>
<groupId>io.micrometer</groupId>
<artifactId>micrometer-registry-cloudwatch2</artifactId>
<version>${micrometer.version}</version>
</dependency>
<!-- AWS SDK -->
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>cloudwatch</artifactId>
<version>${aws-java-sdk.version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>2.0.7</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.15.2</version>
</dependency>
</dependencies>
2. SAM Template for Deployment
# template.yaml
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Globals:
Function:
Runtime: java17
Timeout: 30
MemorySize: 1024
Environment:
Variables:
POWERTOOLS_SERVICE_NAME: user-service
LOG_LEVEL: INFO
DD_TRACE_ENABLED: true
DD_MERGE_XRAY_TRACES: true
Resources:
UserFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: user-service
Handler: com.example.UserHandler::handleRequest
CodeUri: target/user-service.jar
Layers:
- !Sub arn:aws:lambda:${AWS::Region}:464622532012:layer:Datadog-Extension:{{LATEST_DATADOG_LAYER_VERSION}}
Environment:
Variables:
DD_API_KEY: {{DATADOG_API_KEY}}
DD_ENV: production
DD_SERVICE: user-service
DD_VERSION: 1.0.0
Tracing: Active
# API Gateway
UserApi:
Type: AWS::Serverless::Api
Properties:
StageName: prod
TracingEnabled: true
Outputs:
UserApi:
Description: "API Gateway endpoint URL"
Value: !Sub "https://${UserApi}.execute-api.${AWS::Region}.amazonaws.com/prod/"

Core Monitoring Implementation

1. Base Lambda Handler with Monitoring
package com.example.monitoring;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;
public abstract class MonitoredLambdaHandler<I, O> implements RequestHandler<I, O> {
protected final ObjectMapper objectMapper = new ObjectMapper();
protected final LambdaMetrics metrics = new LambdaMetrics();
protected final LambdaTracer tracer = new LambdaTracer();
@Override
public O handleRequest(I input, Context context) {
long startTime = System.currentTimeMillis();
boolean isColdStart = isColdStart(context);
// Initialize monitoring context
MonitoringContext monitoringContext = new MonitoringContext(context, isColdStart);
try {
// Record cold start metric
if (isColdStart) {
metrics.recordColdStart(context.getFunctionName());
tracer.recordColdStart(context);
}
// Pre-processing
monitoringContext.startInvocation();
// Execute business logic
O result = processRequest(input, context, monitoringContext);
// Record success metrics
monitoringContext.recordSuccess();
return result;
} catch (Exception e) {
// Record error metrics
monitoringContext.recordError(e);
throw e;
} finally {
// Record invocation metrics
long duration = System.currentTimeMillis() - startTime;
monitoringContext.recordInvocation(duration);
// Cleanup
monitoringContext.endInvocation();
}
}
protected abstract O processRequest(I input, Context context, MonitoringContext monitoringContext);
private boolean isColdStart(Context context) {
// Check if this is a cold start
return System.getenv("AWS_LAMBDA_INITIALIZATION_TYPE") != null;
}
}
2. Monitoring Context Class
package com.example.monitoring;
import com.amazonaws.services.lambda.runtime.Context;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Tags;
public class MonitoringContext {
private final Context lambdaContext;
private final boolean coldStart;
private final long startTime;
private final MeterRegistry meterRegistry;
private String traceId;
private String spanId;
private Map<String, String> customTags = new HashMap<>();
public MonitoringContext(Context context, boolean coldStart) {
this.lambdaContext = context;
this.coldStart = coldStart;
this.startTime = System.currentTimeMillis();
this.meterRegistry = CloudWatchRegistry.getInstance();
}
public void startInvocation() {
// Initialize tracing
this.traceId = generateTraceId();
this.spanId = generateSpanId();
// Record invocation start
meterRegistry.counter("lambda.invocation.start",
Tags.of("function_name", lambdaContext.getFunctionName(),
"cold_start", String.valueOf(coldStart))
).increment();
}
public void recordSuccess() {
meterRegistry.counter("lambda.invocation.success",
Tags.of("function_name", lambdaContext.getFunctionName())
).increment();
}
public void recordError(Exception error) {
meterRegistry.counter("lambda.invocation.error",
Tags.of("function_name", lambdaContext.getFunctionName(),
"error_type", error.getClass().getSimpleName())
).increment();
}
public void recordInvocation(long duration) {
// Record duration histogram
meterRegistry.timer("lambda.invocation.duration",
Tags.of("function_name", lambdaContext.getFunctionName())
).record(java.time.Duration.ofMillis(duration));
// Record memory usage
Runtime runtime = Runtime.getRuntime();
long usedMemory = runtime.totalMemory() - runtime.freeMemory();
long maxMemory = runtime.maxMemory();
meterRegistry.gauge("lambda.memory.used", 
Tags.of("function_name", lambdaContext.getFunctionName()),
usedMemory);
meterRegistry.gauge("lambda.memory.max",
Tags.of("function_name", lambdaContext.getFunctionName()),
maxMemory);
}
public void endInvocation() {
// Cleanup resources
}
public void addCustomTag(String key, String value) {
customTags.put(key, value);
}
public String getTraceId() { return traceId; }
public String getSpanId() { return spanId; }
public Map<String, String> getCustomTags() { return customTags; }
private String generateTraceId() {
return java.util.UUID.randomUUID().toString().replace("-", "").substring(0, 16);
}
private String generateSpanId() {
return java.util.UUID.randomUUID().toString().replace("-", "").substring(0, 8);
}
}
3. Metrics Service
package com.example.monitoring;
import io.micrometer.cloudwatch2.CloudWatchConfig;
import io.micrometer.cloudwatch2.CloudWatchMeterRegistry;
import io.micrometer.core.instrument.Clock;
import io.micrometer.core.instrument.MeterRegistry;
import software.amazon.awssdk.services.cloudwatch.CloudWatchAsyncClient;
import java.time.Duration;
import java.util.Map;
public class LambdaMetrics {
private final MeterRegistry meterRegistry;
public LambdaMetrics() {
this.meterRegistry = createCloudWatchRegistry();
}
private MeterRegistry createCloudWatchRegistry() {
CloudWatchConfig config = new CloudWatchConfig() {
@Override
public String get(String key) {
return null;
}
@Override
public String namespace() {
return "LambdaMetrics";
}
@Override
public Duration step() {
return Duration.ofMinutes(1);
}
};
CloudWatchAsyncClient cloudWatchAsyncClient = CloudWatchAsyncClient.create();
return new CloudWatchMeterRegistry(config, Clock.SYSTEM, cloudWatchAsyncClient);
}
public void recordColdStart(String functionName) {
meterRegistry.counter("lambda.cold_start",
io.micrometer.core.instrument.Tags.of("function_name", functionName)
).increment();
}
public void recordBusinessMetric(String metricName, double value, Map<String, String> tags) {
io.micrometer.core.instrument.Tags micrometerTags = io.micrometer.core.instrument.Tags.empty();
for (Map.Entry<String, String> tag : tags.entrySet()) {
micrometerTags = micrometerTags.and(tag.getKey(), tag.getValue());
}
meterRegistry.gauge(metricName, micrometerTags, value);
}
public void incrementCounter(String counterName, Map<String, String> tags) {
io.micrometer.core.instrument.Tags micrometerTags = io.micrometer.core.instrument.Tags.empty();
for (Map.Entry<String, String> tag : tags.entrySet()) {
micrometerTags = micrometerTags.and(tag.getKey(), tag.getValue());
}
meterRegistry.counter(counterName, micrometerTags).increment();
}
public void recordExecutionTime(String timerName, long durationMs, Map<String, String> tags) {
io.micrometer.core.instrument.Tags micrometerTags = io.micrometer.core.instrument.Tags.empty();
for (Map.Entry<String, String> tag : tags.entrySet()) {
micrometerTags = micrometerTags.and(tag.getKey(), tag.getValue());
}
meterRegistry.timer(timerName, micrometerTags)
.record(Duration.ofMillis(durationMs));
}
}
4. Tracing Service
package com.example.monitoring;
import com.amazonaws.services.lambda.runtime.Context;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.util.HashMap;
import java.util.Map;
public class LambdaTracer {
private final ObjectMapper objectMapper = new ObjectMapper();
public void recordColdStart(Context context) {
Map<String, Object> traceData = new HashMap<>();
traceData.put("event", "cold_start");
traceData.put("function_name", context.getFunctionName());
traceData.put("memory_limit", context.getMemoryLimitInMB());
traceData.put("timestamp", System.currentTimeMillis());
logStructured("COLD_START", traceData);
}
public void startSpan(String operationName, Map<String, String> tags) {
Map<String, Object> spanData = new HashMap<>();
spanData.put("event", "span_start");
spanData.put("operation", operationName);
spanData.put("timestamp", System.currentTimeMillis());
spanData.putAll(tags);
logStructured("SPAN_START", spanData);
}
public void endSpan(String operationName, long durationMs, Map<String, String> tags) {
Map<String, Object> spanData = new HashMap<>();
spanData.put("event", "span_end");
spanData.put("operation", operationName);
spanData.put("duration_ms", durationMs);
spanData.put("timestamp", System.currentTimeMillis());
spanData.putAll(tags);
logStructured("SPAN_END", spanData);
}
public void recordError(String operationName, Exception error, Map<String, String> tags) {
Map<String, Object> errorData = new HashMap<>();
errorData.put("event", "error");
errorData.put("operation", operationName);
errorData.put("error_type", error.getClass().getSimpleName());
errorData.put("error_message", error.getMessage());
errorData.put("timestamp", System.currentTimeMillis());
errorData.putAll(tags);
logStructured("ERROR", errorData);
}
private void logStructured(String logType, Map<String, Object> data) {
try {
ObjectNode logEntry = objectMapper.createObjectNode();
logEntry.put("log_type", logType);
logEntry.put("timestamp", System.currentTimeMillis());
ObjectNode dataNode = objectMapper.valueToTree(data);
logEntry.set("data", dataNode);
// This will be captured by CloudWatch Logs and can be processed
System.out.println(objectMapper.writeValueAsString(logEntry));
} catch (Exception e) {
// Fallback to regular logging
System.err.println("Failed to log structured data: " + e.getMessage());
}
}
}

Business Logic Implementation

1. User Service Lambda
package com.example.handlers;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
import com.example.monitoring.MonitoredLambdaHandler;
import com.example.monitoring.MonitoringContext;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;
public class UserHandler extends MonitoredLambdaHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
private final UserService userService = new UserService();
@Override
protected APIGatewayProxyResponseEvent processRequest(APIGatewayProxyRequestEvent input, 
Context context, 
MonitoringContext monitoringContext) {
try {
String httpMethod = input.getHttpMethod();
String path = input.getPath();
// Add custom tags for monitoring
monitoringContext.addCustomTag("http.method", httpMethod);
monitoringContext.addCustomTag("http.path", path);
monitoringContext.addCustomTag("user_agent", input.getHeaders().get("User-Agent"));
// Start business operation span
monitoringContext.getTracer().startSpan("user_operation", 
Map.of("http.method", httpMethod, "http.path", path));
switch (httpMethod) {
case "GET":
return handleGetRequest(input, context, monitoringContext);
case "POST":
return handlePostRequest(input, context, monitoringContext);
case "PUT":
return handlePutRequest(input, context, monitoringContext);
case "DELETE":
return handleDeleteRequest(input, context, monitoringContext);
default:
return createResponse(405, "Method Not Allowed");
}
} catch (Exception e) {
monitoringContext.recordError(e);
return createResponse(500, "Internal Server Error: " + e.getMessage());
}
}
private APIGatewayProxyResponseEvent handleGetRequest(APIGatewayProxyRequestEvent input, 
Context context, 
MonitoringContext monitoringContext) {
String path = input.getPath();
Map<String, String> pathParameters = input.getPathParameters();
if (path.contains("/users/") && pathParameters != null && pathParameters.containsKey("userId")) {
String userId = pathParameters.get("userId");
// Add user-specific tags
monitoringContext.addCustomTag("user.id", userId);
long startTime = System.currentTimeMillis();
try {
User user = userService.getUserById(userId);
// Record business metric
monitoringContext.getMetrics().recordExecutionTime("user.fetch.duration", 
System.currentTimeMillis() - startTime,
Map.of("user_id", userId, "status", "success"));
return createResponse(200, toJson(user));
} catch (UserNotFoundException e) {
monitoringContext.getMetrics().incrementCounter("user.fetch.error",
Map.of("error_type", "not_found", "user_id", userId));
return createResponse(404, "User not found");
}
} else {
// List users logic
return createResponse(200, toJson(userService.listUsers()));
}
}
private APIGatewayProxyResponseEvent handlePostRequest(APIGatewayProxyRequestEvent input,
Context context,
MonitoringContext monitoringContext) {
try {
CreateUserRequest createRequest = objectMapper.readValue(input.getBody(), CreateUserRequest.class);
// Validate input
if (createRequest.getEmail() == null || createRequest.getEmail().isEmpty()) {
monitoringContext.getMetrics().incrementCounter("user.create.error",
Map.of("error_type", "validation_error"));
return createResponse(400, "Email is required");
}
long startTime = System.currentTimeMillis();
User user = userService.createUser(createRequest);
// Record business metrics
long duration = System.currentTimeMillis() - startTime;
monitoringContext.getMetrics().recordExecutionTime("user.create.duration", duration,
Map.of("user_id", user.getId(), "status", "success"));
monitoringContext.getMetrics().incrementCounter("user.created",
Map.of("user_id", user.getId()));
return createResponse(201, toJson(user));
} catch (Exception e) {
monitoringContext.recordError(e);
monitoringContext.getMetrics().incrementCounter("user.create.error",
Map.of("error_type", "system_error"));
return createResponse(500, "Failed to create user");
}
}
private APIGatewayProxyResponseEvent createResponse(int statusCode, String body) {
APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent();
response.setStatusCode(statusCode);
response.setBody(body);
Map<String, String> headers = new HashMap<>();
headers.put("Content-Type", "application/json");
headers.put("X-Powered-By", "AWS-Lambda");
response.setHeaders(headers);
return response;
}
private String toJson(Object object) {
try {
return objectMapper.writeValueAsString(object);
} catch (Exception e) {
throw new RuntimeException("Failed to serialize object to JSON", e);
}
}
// Other handler methods...
private APIGatewayProxyResponseEvent handlePutRequest(APIGatewayProxyRequestEvent input, 
Context context, 
MonitoringContext monitoringContext) {
return createResponse(501, "Not Implemented");
}
private APIGatewayProxyResponseEvent handleDeleteRequest(APIGatewayProxyRequestEvent input, 
Context context, 
MonitoringContext monitoringContext) {
return createResponse(501, "Not Implemented");
}
}
2. User Service Business Logic
package com.example.services;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public class UserService {
private final Map<String, User> userStore = new ConcurrentHashMap<>();
public User getUserById(String userId) {
// Simulate database latency
simulateLatency(50, 150);
User user = userStore.get(userId);
if (user == null) {
throw new UserNotFoundException("User not found: " + userId);
}
return user;
}
public List<User> listUsers() {
simulateLatency(100, 300);
return new ArrayList<>(userStore.values());
}
public User createUser(CreateUserRequest request) {
simulateLatency(80, 200);
String userId = UUID.randomUUID().toString();
User user = new User(userId, request.getEmail(), request.getName());
userStore.put(userId, user);
return user;
}
public User updateUser(String userId, UpdateUserRequest request) {
simulateLatency(60, 180);
User existingUser = getUserById(userId);
if (request.getName() != null) {
existingUser.setName(request.getName());
}
if (request.getEmail() != null) {
existingUser.setEmail(request.getEmail());
}
return existingUser;
}
public void deleteUser(String userId) {
simulateLatency(40, 120);
userStore.remove(userId);
}
private void simulateLatency(int minMs, int maxMs) {
try {
int latency = minMs + new Random().nextInt(maxMs - minMs);
Thread.sleep(latency);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
class UserNotFoundException extends RuntimeException {
public UserNotFoundException(String message) {
super(message);
}
}
3. Data Models
package com.example.models;
public class User {
private String id;
private String email;
private String name;
private Date createdAt;
private Date updatedAt;
public User() {}
public User(String id, String email, String name) {
this.id = id;
this.email = email;
this.name = name;
this.createdAt = new Date();
this.updatedAt = new Date();
}
// Getters and setters
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public Date getCreatedAt() { return createdAt; }
public void setCreatedAt(Date createdAt) { this.createdAt = createdAt; }
public Date getUpdatedAt() { return updatedAt; }
public void setUpdatedAt(Date updatedAt) { this.updatedAt = updatedAt; }
}
public class CreateUserRequest {
private String email;
private String name;
// Getters and setters
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
}
public class UpdateUserRequest {
private String email;
private String name;
// Getters and setters
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
}

Advanced Monitoring Features

1. Custom CloudWatch Dashboard
package com.example.monitoring;
import software.amazon.awssdk.services.cloudwatch.CloudWatchClient;
import software.amazon.awssdk.services.cloudwatch.model.*;
public class CloudWatchDashboardManager {
private final CloudWatchClient cloudWatchClient;
public CloudWatchDashboardManager() {
this.cloudWatchClient = CloudWatchClient.create();
}
public void createLambdaDashboard(String functionName) {
try {
PutDashboardRequest request = PutDashboardRequest.builder()
.dashboardName(functionName + "-Dashboard")
.dashboardBody(createDashboardBody(functionName))
.build();
PutDashboardResponse response = cloudWatchClient.putDashboard(request);
System.out.println("Dashboard created: " + response.dashboardValidationMessages());
} catch (Exception e) {
System.err.println("Failed to create dashboard: " + e.getMessage());
}
}
private String createDashboardBody(String functionName) {
return String.format("""
{
"widgets": [
{
"type": "metric",
"x": 0,
"y": 0,
"width": 12,
"height": 6,
"properties": {
"metrics": [
[ "AWS/Lambda", "Invocations", "FunctionName", "%s" ],
[ ".", "Errors", ".", "." ],
[ ".", "Throttles", ".", "." ]
],
"period": 300,
"stat": "Sum",
"region": "us-east-1",
"title": "Lambda Invocations and Errors"
}
},
{
"type": "metric",
"x": 0,
"y": 6,
"width": 12,
"height": 6,
"properties": {
"metrics": [
[ "AWS/Lambda", "Duration", "FunctionName", "%s" ]
],
"period": 300,
"stat": "Average",
"region": "us-east-1",
"title": "Average Duration"
}
}
]
}
""", functionName, functionName);
}
}
2. X-Ray Tracing Integration
package com.example.monitoring;
import com.amazonaws.xray.AWSXRay;
import com.amazonaws.xray.entities.Segment;
import com.amazonaws.xray.entities.Subsegment;
public class XRayTracer {
public static Subsegment startSubsegment(String name) {
return AWSXRay.beginSubsegment(name);
}
public static void endSubsegment(Subsegment subsegment) {
if (subsegment != null) {
AWSXRay.endSubsegment();
}
}
public static void addAnnotation(String key, String value) {
Segment segment = AWSXRay.getCurrentSegment();
if (segment != null) {
segment.putAnnotation(key, value);
}
}
public static void addMetadata(String key, Object value) {
Segment segment = AWSXRay.getCurrentSegment();
if (segment != null) {
segment.putMetadata(key, value);
}
}
public static void recordException(Exception e) {
Segment segment = AWSXRay.getCurrentSegment();
if (segment != null) {
segment.addException(e);
}
}
}
// Usage in Lambda function
public class XRayEnabledHandler {
public String handleRequest(Object input, Context context) {
Subsegment subsegment = XRayTracer.startSubsegment("BusinessLogic");
try {
XRayTracer.addAnnotation("functionVersion", context.getFunctionVersion());
XRayTracer.addAnnotation("coldStart", String.valueOf(isColdStart()));
// Business logic here
String result = executeBusinessLogic(input);
XRayTracer.addMetadata("result", result);
return result;
} catch (Exception e) {
XRayTracer.recordException(e);
throw e;
} finally {
XRayTracer.endSubsegment(subsegment);
}
}
private boolean isColdStart() {
return System.getenv("AWS_LAMBDA_INITIALIZATION_TYPE") != null;
}
}
3. Datadog Integration
package com.example.monitoring;
import com.datadoghq.datadog_lambda_java.DDLambda;
import com.datadoghq.datadog_lambda_java.DDLambdaScope;
import com.datadoghq.datadog_lambda_java.DDLambdaLogger;
public class DatadogMonitor {
private final DDLambda ddLambda;
public DatadogMonitor() {
this.ddLambda = new DDLambda();
}
public void recordCustomMetric(String metricName, double value, String... tags) {
ddLambda.metric(metricName, value, tags);
}
public void incrementCounter(String metricName, String... tags) {
ddLambda.metric(metricName, 1, tags);
}
public void recordExecutionTime(String metricName, long durationMs, String... tags) {
ddLambda.metric(metricName, durationMs, tags);
}
public DDLambdaScope startScope() {
return ddLambda.newScope();
}
}
// Enhanced handler with Datadog
public class DatadogEnabledHandler implements RequestHandler<Object, Object> {
private final DatadogMonitor datadogMonitor = new DatadogMonitor();
@Override
public Object handleRequest(Object input, Context context) {
DDLambdaScope scope = datadogMonitor.startScope();
try {
scope.setTag("function_name", context.getFunctionName());
scope.setTag("cold_start", String.valueOf(isColdStart()));
// Record cold start
if (isColdStart()) {
datadogMonitor.incrementCounter("lambda.cold_start", 
"function:" + context.getFunctionName());
}
// Business logic
Object result = processInput(input);
// Record success
datadogMonitor.incrementCounter("lambda.invocation.success",
"function:" + context.getFunctionName());
return result;
} catch (Exception e) {
// Record error
datadogMonitor.incrementCounter("lambda.invocation.error",
"function:" + context.getFunctionName(),
"error_type:" + e.getClass().getSimpleName());
throw e;
} finally {
scope.finish();
}
}
private boolean isColdStart() {
return System.getenv("AWS_LAMBDA_INITIALIZATION_TYPE") != null;
}
}

Testing and Local Development

1. Local Testing Handler
package com.example.testing;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
public class LocalTestHandler {
public static void main(String[] args) {
// Simulate Lambda execution locally
UserHandler handler = new UserHandler();
// Create mock context
Context context = new MockContext();
// Create test event
APIGatewayProxyRequestEvent event = new APIGatewayProxyRequestEvent();
event.setHttpMethod("GET");
event.setPath("/users/test-user");
event.setPathParameters(Map.of("userId", "test-user"));
// Execute
APIGatewayProxyResponseEvent response = handler.handleRequest(event, context);
System.out.println("Status: " + response.getStatusCode());
System.out.println("Body: " + response.getBody());
}
static class MockContext implements Context {
@Override
public String getAwsRequestId() { return "local-test-request-id"; }
@Override
public String getLogGroupName() { return "/aws/lambda/local-test"; }
@Override
public String getLogStreamName() { return "2023/01/01/[$LATEST]test"; }
@Override
public String getFunctionName() { return "local-test-function"; }
@Override
public String getFunctionVersion() { return "$LATEST"; }
@Override
public String getInvokedFunctionArn() { return "arn:aws:lambda:us-east-1:123456789012:function:local-test-function"; }
@Override
public LambdaLogger getLogger() { return new MockLogger(); }
@Override
public int getMemoryLimitInMB() { return 512; }
@Override
public int getRemainingTimeInMillis() { return 30000; }
}
static class MockLogger implements LambdaLogger {
@Override
public void log(String message) {
System.out.println("LOG: " + message);
}
@Override
public void log(byte[] message) {
System.out.println("LOG: " + new String(message));
}
}
}
2. Performance Test
package com.example.testing;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
public class LambdaPerformanceTest {
private final UserHandler handler = new UserHandler();
private final ExecutorService executor = Executors.newFixedThreadPool(10);
public void runConcurrentTest(int numberOfRequests) throws InterruptedException {
AtomicInteger successCount = new AtomicInteger();
AtomicInteger errorCount = new AtomicInteger();
CountDownLatch latch = new CountDownLatch(numberOfRequests);
long startTime = System.currentTimeMillis();
for (int i = 0; i < numberOfRequests; i++) {
final int requestId = i;
executor.submit(() -> {
try {
APIGatewayProxyRequestEvent event = createTestEvent(requestId);
Context context = new MockContext();
handler.handleRequest(event, context);
successCount.incrementAndGet();
} catch (Exception e) {
errorCount.incrementAndGet();
System.err.println("Request " + requestId + " failed: " + e.getMessage());
} finally {
latch.countDown();
}
});
}
latch.await();
long totalTime = System.currentTimeMillis() - startTime;
System.out.println("Performance Test Results:");
System.out.println("Total Requests: " + numberOfRequests);
System.out.println("Successful: " + successCount.get());
System.out.println("Errors: " + errorCount.get());
System.out.println("Total Time: " + totalTime + "ms");
System.out.println("Requests/sec: " + (numberOfRequests / (totalTime / 1000.0)));
}
private APIGatewayProxyRequestEvent createTestEvent(int requestId) {
APIGatewayProxyRequestEvent event = new APIGatewayProxyRequestEvent();
event.setHttpMethod("GET");
event.setPath("/users/user-" + requestId);
event.setPathParameters(Map.of("userId", "user-" + requestId));
return event;
}
}

Best Practices

  1. Cold Start Optimization:
  • Keep deployment packages small
  • Use provisioned concurrency for critical functions
  • Initialize connections outside handler method
  1. Memory Configuration:
  • Monitor and optimize memory settings
  • Balance cost vs performance
  1. Error Handling:
  • Implement comprehensive error tracking
  • Use dead letter queues for async processing
  1. Security:
  • Follow principle of least privilege for IAM roles
  • Encrypt environment variables
  • Use VPC endpoints when needed
  1. Cost Optimization:
  • Set appropriate timeout values
  • Monitor and optimize memory usage
  • Use appropriate logging levels
// Example of optimized Lambda handler
public class OptimizedLambdaHandler implements RequestHandler<Object, Object> {
// Initialize expensive resources once
private final DatabaseConnection dbConnection;
private final ObjectMapper objectMapper;
public OptimizedLambdaHandler() {
this.dbConnection = initializeDatabaseConnection();
this.objectMapper = new ObjectMapper();
}
@Override
public Object handleRequest(Object input, Context context) {
// Handler logic using pre-initialized resources
return processRequest(input);
}
}

Conclusion

Serverless monitoring in Java requires:

  • Comprehensive metrics for performance tracking
  • Distributed tracing for request flow analysis
  • Structured logging for better observability
  • Cold start monitoring for performance optimization
  • Business metrics for domain-specific monitoring

By implementing the patterns shown above, you can achieve full observability of your Java AWS Lambda functions, identify performance bottlenecks, monitor business metrics, and ensure reliable operation in production environments. The combination of CloudWatch, X-Ray, and custom monitoring provides a complete picture of your serverless application's health and performance.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper