Introduction to Dynatrace OneAgent
Dynatrace OneAgent provides automatic instrumentation for Java applications, delivering full-stack observability with minimal configuration. It captures metrics, traces, and logs across the entire application stack.
Installation and Setup
Maven Dependencies
<properties>
<dynatrace.version>8.277.1.1005</dynatrace.version>
</properties>
<dependencies>
<!-- Dynatrace OneAgent API -->
<dependency>
<groupId>com.dynatrace.oneagent</groupId>
<artifactId>oneagent-sdk</artifactId>
<version>${dynatrace.version}</version>
</dependency>
<!-- Dynatrace OpenTelemetry Bridge -->
<dependency>
<groupId>com.dynatrace.oneagent</groupId>
<artifactId>oneagent-opentelemetry-bridge</artifactId>
<version>${dynatrace.version}</version>
</dependency>
</dependencies>
Docker Deployment
FROM openjdk:17-jdk-slim
# Install Dynatrace OneAgent
ARG DT_ENVIRONMENT_ID
ARG DT_API_TOKEN
ARG DT_ONEAGENT_OPTIONS
# Download and install OneAgent
RUN curl -s -H "Authorization: Api-Token ${DT_API_TOKEN}" \
"https://${DT_ENVIRONMENT_ID}.live.dynatrace.com/api/v1/deployment/installer/agent/oneagent/unix/latest?arch=x86&flavor=default" \
--output /tmp/oneagent.tar.gz && \
tar -xzf /tmp/oneagent.tar.gz -C /opt && \
rm /tmp/oneagent.tar.gz
# Set OneAgent environment variables
ENV LD_PRELOAD /opt/dynatrace/oneagent/agent/lib64/liboneagentproc.so
ENV DT_ONEAGENT_OPTIONS="${DT_ONEAGENT_OPTIONS}"
COPY target/my-app.jar /app/my-app.jar
ENTRYPOINT ["java", "-jar", "/app/my-app.jar"]
Configuration
application.yml Configuration
dynatrace:
oneagent:
enabled: true
environment-id: ${DT_ENVIRONMENT_ID}
api-token: ${DT_API_TOKEN}
# OneAgent configuration options
options: >-
--set-app-log-content-access=true
--set-http-server-request-headers=X-Request-ID,X-Trace-ID
--set-http-server-response-headers=X-Request-ID
--set-log-level=INFO
# Custom service properties
service:
name: order-service
version: 1.0.0
technology: java
# Custom request attributes
request-attributes:
enabled: true
include-headers:
- "X-User-ID"
- "X-Session-ID"
- "X-Tenant-ID"
Java System Properties
@Configuration
public class DynatraceConfig {
@PostConstruct
public void configureDynatrace() {
// Set Dynatrace system properties
System.setProperty("dt_connection_environmentid",
System.getenv().getOrDefault("DT_ENVIRONMENT_ID", "your-environment-id"));
System.setProperty("dt_connection_authtoken",
System.getenv().getOrDefault("DT_API_TOKEN", "your-api-token"));
// Enable OneAgent features
System.setProperty("dt_feature_oneagent_custom_services", "true");
System.setProperty("dt_feature_oneagent_custom_request_attributes", "true");
System.setProperty("dt_capture_correlation_ids", "true");
// Logging configuration
System.setProperty("dt_logging_level", "INFO");
System.setProperty("dt_capture_java_method_bci", "true");
}
}
Custom Service Instrumentation
OneAgent SDK Integration
@Component
public class DynatraceOneAgentService {
private final OneAgentSDK oneAgentSDK;
private static final Logger logger = LoggerFactory.getLogger(DynatraceOneAgentService.class);
public DynatraceOneAgentService() {
this.oneAgentSDK = OneAgentSDKFactory.createInstance();
// Verify SDK state
SDKStateCallback sdkStateCallback = new SDKStateCallback() {
@Override
public void onSDKStateChanged(SDKState sdkState) {
logger.info("Dynatrace OneAgent SDK state changed: {}", sdkState);
}
};
oneAgentSDK.addSDKStateCallback(sdkStateCallback);
if (oneAgentSDK.getCurrentState() == SDKState.ACTIVE) {
logger.info("Dynatrace OneAgent SDK initialized successfully");
} else {
logger.warn("Dynatrace OneAgent SDK not active. Current state: {}",
oneAgentSDK.getCurrentState());
}
}
public OneAgentSDK getOneAgentSDK() {
return oneAgentSDK;
}
}
Custom Service Instrumentation
@Service
public class OrderProcessingService {
private final OneAgentSDK oneAgentSDK;
private final Tracer tracer;
private static final Logger logger = LoggerFactory.getLogger(OrderProcessingService.class);
public OrderProcessingService(DynatraceOneAgentService dynatraceService) {
this.oneAgentSDK = dynatraceService.getOneAgentSDK();
this.tracer = oneAgentSDK.traceCustomService("OrderProcessingService", "OrderProcessing");
}
@DynatraceTraced(serviceName = "OrderProcessing", methodName = "processOrder")
public Order processOrder(OrderRequest request) {
// This method will be automatically traced by Dynatrace
return executeOrderProcessing(request);
}
public Order processOrderWithCustomTrace(OrderRequest request) {
InProcessLink inProcessLink = oneAgentSDK.createInProcessLink();
String traceId = oneAgentSDK.getDynatraceStringRepresentation();
try {
// Start custom service
Tracer.ServerlessCallback serverlessCallback = tracer.enterServerless("processOrder", null);
// Add custom request attributes
oneAgentSDK.addCustomRequestAttribute("order.amount", request.getAmount());
oneAgentSDK.addCustomRequestAttribute("order.currency", request.getCurrency());
oneAgentSDK.addCustomRequestAttribute("order.customer", request.getCustomerId());
// Set trace context
MDC.put("dt_trace_id", traceId);
MDC.put("dt_span_id", serverlessCallback.getTraceContext().getSpanId());
logger.info("Processing order with Dynatrace trace: {}", traceId);
Order order = executeOrderProcessing(request);
// Add result as custom attribute
oneAgentSDK.addCustomRequestAttribute("order.result", "success");
oneAgentSDK.addCustomRequestAttribute("order.id", order.getId());
return order;
} catch (Exception e) {
// Report error to Dynatrace
oneAgentSDK.addCustomRequestAttribute("order.result", "error");
oneAgentSDK.addCustomRequestAttribute("order.error", e.getMessage());
oneAgentSDK.reportError(e);
throw e;
} finally {
tracer.leave();
MDC.remove("dt_trace_id");
MDC.remove("dt_span_id");
}
}
public CompletableFuture<Order> processOrderAsync(OrderRequest request) {
// Capture context for async operations
InProcessLink inProcessLink = oneAgentSDK.createInProcessLink();
return CompletableFuture.supplyAsync(() -> {
try {
inProcessLink.link();
return processOrderWithCustomTrace(request);
} finally {
inProcessLink.unlink();
}
});
}
private Order executeOrderProcessing(OrderRequest request) {
// Simulate processing time
try {
Thread.sleep(100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Order processing interrupted", e);
}
return new Order(UUID.randomUUID().toString(), request.getCustomerId(), request.getAmount());
}
}
// Custom annotation for Dynatrace tracing
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DynatraceTraced {
String serviceName();
String methodName() default "";
boolean captureParameters() default false;
}
Database Instrumentation
Custom Database Monitoring
@Repository
public class OrderRepository {
private final OneAgentSDK oneAgentSDK;
private final JdbcTemplate jdbcTemplate;
private static final Logger logger = LoggerFactory.getLogger(OrderRepository.class);
public OrderRepository(DynatraceOneAgentService dynatraceService, JdbcTemplate jdbcTemplate) {
this.oneAgentSDK = dynatraceService.getOneAgentSDK();
this.jdbcTemplate = jdbcTemplate;
}
public Order findById(String orderId) {
DatabaseRequestTracer tracer = oneAgentSDK.traceSQLDatabaseRequest(
"OrderRepository",
"findById",
"orders",
"SELECT * FROM orders WHERE id = ?"
);
try {
tracer.start();
tracer.setParameterData("orderId", orderId);
// Execute query
List<Order> orders = jdbcTemplate.query(
"SELECT * FROM orders WHERE id = ?",
new Object[]{orderId},
new OrderRowMapper()
);
tracer.setRowsReturned(orders.size());
if (orders.isEmpty()) {
tracer.error("Order not found: " + orderId);
return null;
}
return orders.get(0);
} catch (Exception e) {
tracer.error(e);
logger.error("Failed to find order: {}", orderId, e);
throw e;
} finally {
tracer.end();
}
}
public void saveOrder(Order order) {
DatabaseRequestTracer tracer = oneAgentSDK.traceSQLDatabaseRequest(
"OrderRepository",
"saveOrder",
"orders",
"INSERT INTO orders (id, customer_id, amount, status) VALUES (?, ?, ?, ?)"
);
try {
tracer.start();
tracer.setParameterData("orderId", order.getId());
tracer.setParameterData("customerId", order.getCustomerId());
tracer.setParameterData("amount", order.getAmount().toString());
int rowsAffected = jdbcTemplate.update(
"INSERT INTO orders (id, customer_id, amount, status) VALUES (?, ?, ?, ?)",
order.getId(),
order.getCustomerId(),
order.getAmount(),
"CREATED"
);
tracer.setRowsAffected(rowsAffected);
} catch (Exception e) {
tracer.error(e);
logger.error("Failed to save order: {}", order.getId(), e);
throw e;
} finally {
tracer.end();
}
}
}
// Custom DataSource wrapper for Dynatrace monitoring
@Component
public class DynatraceDataSource extends AbstractDataSource {
private final DataSource delegate;
private final OneAgentSDK oneAgentSDK;
public DynatraceDataSource(DataSource delegate, DynatraceOneAgentService dynatraceService) {
this.delegate = delegate;
this.oneAgentSDK = dynatraceService.getOneAgentSDK();
}
@Override
public Connection getConnection() throws SQLException {
return new DynatraceConnection(delegate.getConnection(), oneAgentSDK);
}
@Override
public Connection getConnection(String username, String password) throws SQLException {
return new DynatraceConnection(delegate.getConnection(username, password), oneAgentSDK);
}
private static class DynatraceConnection implements Connection {
private final Connection delegate;
private final OneAgentSDK oneAgentSDK;
public DynatraceConnection(Connection delegate, OneAgentSDK oneAgentSDK) {
this.delegate = delegate;
this.oneAgentSDK = oneAgentSDK;
}
@Override
public PreparedStatement prepareStatement(String sql) throws SQLException {
return new DynatracePreparedStatement(delegate.prepareStatement(sql), sql, oneAgentSDK);
}
// Implement all other Connection methods by delegating to the underlying connection
@Override
public void close() throws SQLException { delegate.close(); }
@Override
public boolean isClosed() throws SQLException { return delegate.isClosed(); }
// ... implement all other Connection methods
}
private static class DynatracePreparedStatement implements PreparedStatement {
private final PreparedStatement delegate;
private final String sql;
private final OneAgentSDK oneAgentSDK;
private DatabaseRequestTracer tracer;
public DynatracePreparedStatement(PreparedStatement delegate, String sql, OneAgentSDK oneAgentSDK) {
this.delegate = delegate;
this.sql = sql;
this.oneAgentSDK = oneAgentSDK;
}
@Override
public ResultSet executeQuery() throws SQLException {
startTracer();
try {
ResultSet resultSet = delegate.executeQuery();
tracer.setRowsReturned(getRowCount(resultSet));
return resultSet;
} catch (SQLException e) {
tracer.error(e);
throw e;
} finally {
endTracer();
}
}
@Override
public int executeUpdate() throws SQLException {
startTracer();
try {
int rowsAffected = delegate.executeUpdate();
tracer.setRowsAffected(rowsAffected);
return rowsAffected;
} catch (SQLException e) {
tracer.error(e);
throw e;
} finally {
endTracer();
}
}
private void startTracer() {
tracer = oneAgentSDK.traceSQLDatabaseRequest("CustomDataSource", "execute", "database", sql);
tracer.start();
}
private void endTracer() {
if (tracer != null) {
tracer.end();
tracer = null;
}
}
private int getRowCount(ResultSet resultSet) throws SQLException {
int rowCount = 0;
if (resultSet != null) {
resultSet.last();
rowCount = resultSet.getRow();
resultSet.beforeFirst();
}
return rowCount;
}
// Delegate all other methods
@Override
public void close() throws SQLException { delegate.close(); }
// ... implement all other PreparedStatement methods
}
}
HTTP Client Instrumentation
RestTemplate with Dynatrace
@Component
public class DynatraceRestTemplateInterceptor implements ClientHttpRequestInterceptor {
private final OneAgentSDK oneAgentSDK;
private static final Logger logger = LoggerFactory.getLogger(DynatraceRestTemplateInterceptor.class);
public DynatraceRestTemplateInterceptor(DynatraceOneAgentService dynatraceService) {
this.oneAgentSDK = dynatraceService.getOneAgentSDK();
}
@Override
public ClientHttpResponse intercept(HttpRequest request, byte[] body,
ClientHttpRequestExecution execution) throws IOException {
String url = request.getURI().toString();
String method = request.getMethod().name();
String host = request.getURI().getHost();
// Create web application tracer
WebApplicationTracer tracer = oneAgentSDK.traceWebApplicationRequest(
"OutboundHTTP", url, method, host
);
try {
tracer.start();
// Add Dynatrace headers for distributed tracing
tracer.injectTracingHeaders((name, value) -> {
request.getHeaders().add(name, value);
});
// Add custom attributes
tracer.setRemoteAddress(host);
tracer.setRemotePort(request.getURI().getPort());
ClientHttpResponse response = execution.execute(request, body);
// Set response information
tracer.setStatusCode(response.getRawStatusCode());
return response;
} catch (IOException e) {
tracer.error(e);
logger.error("HTTP request failed: {} {}", method, url, e);
throw e;
} finally {
tracer.end();
}
}
}
@Configuration
public class RestTemplateConfig {
@Bean
public RestTemplate restTemplate(DynatraceRestTemplateInterceptor interceptor) {
RestTemplate restTemplate = new RestTemplate();
List<ClientHttpRequestInterceptor> interceptors =
new ArrayList<>(restTemplate.getInterceptors());
interceptors.add(interceptor);
restTemplate.setInterceptors(interceptors);
return restTemplate;
}
}
WebClient Instrumentation
@Component
public class DynatraceWebClientFilter {
private final OneAgentSDK oneAgentSDK;
public DynatraceWebClientFilter(DynatraceOneAgentService dynatraceService) {
this.oneAgentSDK = dynatraceService.getOneAgentSDK();
}
public ExchangeFilterFunction dynatraceTracingFilter() {
return ExchangeFilterFunction.ofRequestProcessor(clientRequest -> {
String url = clientRequest.url().toString();
String method = clientRequest.method().name();
String host = clientRequest.url().getHost();
WebApplicationTracer tracer = oneAgentSDK.traceWebApplicationRequest(
"OutboundHTTP", url, method, host
);
try {
tracer.start();
// Inject Dynatrace headers
ClientRequest.Builder requestBuilder = ClientRequest.from(clientRequest);
tracer.injectTracingHeaders((name, value) -> {
requestBuilder.header(name, value);
});
return Mono.just(requestBuilder.build());
} catch (Exception e) {
tracer.error(e);
return Mono.error(e);
} finally {
tracer.end();
}
});
}
}
Custom Business Metrics
Custom Metrics and Events
@Service
public class BusinessMetricsService {
private final OneAgentSDK oneAgentSDK;
private static final Logger logger = LoggerFactory.getLogger(BusinessMetricsService.class);
// Custom metrics
private static final String ORDERS_PROCESSED_METRIC = "orders_processed_total";
private static final String ORDER_VALUE_METRIC = "order_value";
private static final String PROCESSING_TIME_METRIC = "order_processing_time";
public BusinessMetricsService(DynatraceOneAgentService dynatraceService) {
this.oneAgentSDK = dynatraceService.getOneAgentSDK();
}
public void recordOrderProcessed(String customerId, BigDecimal amount, long processingTimeMs) {
try {
// Record counter metric
oneAgentSDK.recordMetric(ORDERS_PROCESSED_METRIC, 1.0);
// Record value metric
oneAgentSDK.recordMetric(ORDER_VALUE_METRIC, amount.doubleValue());
// Record timing metric
oneAgentSDK.recordMetric(PROCESSING_TIME_METRIC, processingTimeMs);
// Add custom request attributes for business analysis
oneAgentSDK.addCustomRequestAttribute("order.customer", customerId);
oneAgentSDK.addCustomRequestAttribute("order.amount", amount.toString());
oneAgentSDK.addCustomRequestAttribute("order.processing_time_ms", processingTimeMs);
} catch (Exception e) {
logger.warn("Failed to record business metrics", e);
}
}
public void recordError(String operation, String errorType, String errorMessage) {
try {
oneAgentSDK.addCustomRequestAttribute("error.operation", operation);
oneAgentSDK.addCustomRequestAttribute("error.type", errorType);
oneAgentSDK.addCustomRequestAttribute("error.message", errorMessage);
} catch (Exception e) {
logger.warn("Failed to record error metrics", e);
}
}
public void recordCustomEvent(String eventType, Map<String, String> eventData) {
try {
CustomEvent event = new CustomEvent(eventType);
eventData.forEach(event::put);
oneAgentSDK.recordEvent(event);
} catch (Exception e) {
logger.warn("Failed to record custom event", e);
}
}
public void recordUserAction(String action, String userId, Map<String, String> context) {
try {
CustomEvent userAction = new CustomEvent("user_action");
userAction.put("action", action);
userAction.put("user_id", userId);
context.forEach(userAction::put);
oneAgentSDK.recordEvent(userAction);
} catch (Exception e) {
logger.warn("Failed to record user action", e);
}
}
}
Spring Boot Integration
Auto-Configuration
@Configuration
@EnableConfigurationProperties(DynatraceProperties.class)
@ConditionalOnProperty(name = "dynatrace.oneagent.enabled", havingValue = "true")
public class DynatraceAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public DynatraceOneAgentService dynatraceOneAgentService() {
return new DynatraceOneAgentService();
}
@Bean
public DynatraceRestTemplateInterceptor dynatraceRestTemplateInterceptor(
DynatraceOneAgentService dynatraceService) {
return new DynatraceRestTemplateInterceptor(dynatraceService);
}
@Bean
public BusinessMetricsService businessMetricsService(
DynatraceOneAgentService dynatraceService) {
return new BusinessMetricsService(dynatraceService);
}
@Bean
public DynatraceWebClientFilter dynatraceWebClientFilter(
DynatraceOneAgentService dynatraceService) {
return new DynatraceWebClientFilter(dynatraceService);
}
@Bean
public DynatraceAspect dynatraceAspect(DynatraceOneAgentService dynatraceService) {
return new DynatraceAspect(dynatraceService);
}
}
@ConfigurationProperties(prefix = "dynatrace.oneagent")
public class DynatraceProperties {
private boolean enabled = true;
private String environmentId;
private String apiToken;
private String options;
private Service service = new Service();
private RequestAttributes requestAttributes = new RequestAttributes();
public static class Service {
private String name;
private String version;
private String technology = "java";
// Getters and setters
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getVersion() { return version; }
public void setVersion(String version) { this.version = version; }
public String getTechnology() { return technology; }
public void setTechnology(String technology) { this.technology = technology; }
}
public static class RequestAttributes {
private boolean enabled = true;
private List<String> includeHeaders = new ArrayList<>();
// Getters and setters
public boolean isEnabled() { return enabled; }
public void setEnabled(boolean enabled) { this.enabled = enabled; }
public List<String> getIncludeHeaders() { return includeHeaders; }
public void setIncludeHeaders(List<String> includeHeaders) { this.includeHeaders = includeHeaders; }
}
// Getters and setters for main class
public boolean isEnabled() { return enabled; }
public void setEnabled(boolean enabled) { this.enabled = enabled; }
public String getEnvironmentId() { return environmentId; }
public void setEnvironmentId(String environmentId) { this.environmentId = environmentId; }
public String getApiToken() { return apiToken; }
public void setApiToken(String apiToken) { this.apiToken = apiToken; }
public String getOptions() { return options; }
public void setOptions(String options) { this.options = options; }
public Service getService() { return service; }
public void setService(Service service) { this.service = service; }
public RequestAttributes getRequestAttributes() { return requestAttributes; }
public void setRequestAttributes(RequestAttributes requestAttributes) { this.requestAttributes = requestAttributes; }
}
Aspect-Oriented Instrumentation
@Aspect
@Component
public class DynatraceAspect {
private final DynatraceOneAgentService dynatraceService;
private static final Logger logger = LoggerFactory.getLogger(DynatraceAspect.class);
public DynatraceAspect(DynatraceOneAgentService dynatraceService) {
this.dynatraceService = dynatraceService;
}
@Around("@annotation(dynatraceTraced)")
public Object traceMethod(ProceedingJoinPoint joinPoint, DynatraceTraced dynatraceTraced) throws Throwable {
String serviceName = dynatraceTraced.serviceName();
String methodName = !dynatraceTraced.methodName().isEmpty() ?
dynatraceTraced.methodName() : joinPoint.getSignature().getName();
Tracer tracer = dynatraceService.getOneAgentSDK()
.traceCustomService(serviceName, methodName);
long startTime = System.currentTimeMillis();
try {
tracer.enter();
// Capture method parameters if enabled
if (dynatraceTraced.captureParameters()) {
captureMethodParameters(joinPoint);
}
Object result = joinPoint.proceed();
// Record success metrics
recordMethodSuccess(serviceName, methodName, System.currentTimeMillis() - startTime);
return result;
} catch (Exception e) {
// Record error metrics
recordMethodError(serviceName, methodName, e, System.currentTimeMillis() - startTime);
dynatraceService.getOneAgentSDK().reportError(e);
throw e;
} finally {
tracer.leave();
}
}
@Around("execution(* com.myapp.service.*.*(..))")
public Object traceServiceMethods(ProceedingJoinPoint joinPoint) throws Throwable {
String className = joinPoint.getTarget().getClass().getSimpleName();
String methodName = joinPoint.getSignature().getName();
Tracer tracer = dynatraceService.getOneAgentSDK()
.traceCustomService(className, methodName);
try {
tracer.enter();
return joinPoint.proceed();
} finally {
tracer.leave();
}
}
private void captureMethodParameters(ProceedingJoinPoint joinPoint) {
Object[] args = joinPoint.getArgs();
for (int i = 0; i < args.length; i++) {
if (args[i] != null) {
dynatraceService.getOneAgentSDK().addCustomRequestAttribute(
"param." + i, args[i].toString()
);
}
}
}
private void recordMethodSuccess(String serviceName, String methodName, long duration) {
try {
dynatraceService.getOneAgentSDK().addCustomRequestAttribute(
serviceName + "." + methodName + ".duration", duration
);
dynatraceService.getOneAgentSDK().addCustomRequestAttribute(
serviceName + "." + methodName + ".result", "success"
);
} catch (Exception e) {
logger.warn("Failed to record method success metrics", e);
}
}
private void recordMethodError(String serviceName, String methodName, Exception error, long duration) {
try {
dynatraceService.getOneAgentSDK().addCustomRequestAttribute(
serviceName + "." + methodName + ".duration", duration
);
dynatraceService.getOneAgentSDK().addCustomRequestAttribute(
serviceName + "." + methodName + ".result", "error"
);
dynatraceService.getOneAgentSDK().addCustomRequestAttribute(
serviceName + "." + methodName + ".error", error.getClass().getSimpleName()
);
} catch (Exception e) {
logger.warn("Failed to record method error metrics", e);
}
}
}
Log Integration
MDC Integration with Dynatrace
@Component
public class DynatraceMDCIntegration {
private final DynatraceOneAgentService dynatraceService;
public DynatraceMDCIntegration(DynatraceOneAgentService dynatraceService) {
this.dynatraceService = dynatraceService;
}
public void updateMDCWithDynatraceContext() {
try {
OneAgentSDK oneAgentSDK = dynatraceService.getOneAgentSDK();
// Get Dynatrace trace context
String traceId = oneAgentSDK.getDynatraceStringRepresentation();
// Update MDC with Dynatrace context
MDC.put("dt.trace_id", traceId);
// Add custom request attributes to MDC for logging
Map<String, Object> customAttributes = getCustomAttributes();
customAttributes.forEach((key, value) -> {
if (value != null) {
MDC.put("dt." + key, value.toString());
}
});
} catch (Exception e) {
// Log warning but don't break application
LoggerFactory.getLogger(DynatraceMDCIntegration.class)
.warn("Failed to update MDC with Dynatrace context", e);
}
}
public void clearDynatraceMDC() {
// Remove all Dynatrace-related MDC entries
MDC.getCopyOfContextMap().keySet().stream()
.filter(key -> key.startsWith("dt."))
.forEach(MDC::remove);
}
private Map<String, Object> getCustomAttributes() {
// This would typically retrieve current custom request attributes
// For simplicity, return empty map
return Collections.emptyMap();
}
}
Testing and Validation
Test Configuration
@SpringBootTest
@TestPropertySource(properties = {
"dynatrace.oneagent.enabled=true",
"dynatrace.oneagent.service.name=test-service",
"dynatrace.oneagent.service.version=1.0.0"
})
public class DynatraceIntegrationTest {
@Autowired
private DynatraceOneAgentService dynatraceService;
@Autowired
private BusinessMetricsService businessMetricsService;
@Test
public void testOneAgentSDKInitialization() {
OneAgentSDK oneAgentSDK = dynatraceService.getOneAgentSDK();
assertNotNull(oneAgentSDK);
SDKState state = oneAgentSDK.getCurrentState();
assertTrue(state == SDKState.ACTIVE || state == SDKState.TEMPORARY_INACTIVE);
}
@Test
public void testCustomServiceTracing() {
OneAgentSDK oneAgentSDK = dynatraceService.getOneAgentSDK();
Tracer tracer = oneAgentSDK.traceCustomService("TestService", "testMethod");
try {
tracer.enter();
// Simulate work
Thread.sleep(50);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
tracer.leave();
}
}
@Test
public void testBusinessMetricsRecording() {
businessMetricsService.recordOrderProcessed("customer123",
new BigDecimal("99.99"), 150L);
// Verify metrics were recorded (this would typically be verified in Dynatrace UI)
}
@Test
public void testErrorReporting() {
OneAgentSDK oneAgentSDK = dynatraceService.getOneAgentSDK();
try {
throw new RuntimeException("Test error for Dynatrace");
} catch (RuntimeException e) {
oneAgentSDK.reportError(e);
}
}
}
Kubernetes Deployment
Deployment Configuration
apiVersion: apps/v1 kind: Deployment metadata: name: order-service labels: app: order-service spec: replicas: 3 selector: matchLabels: app: order-service template: metadata: labels: app: order-service annotations: dynatrace.com/inject: "true" spec: containers: - name: order-service image: my-registry/order-service:latest env: - name: DT_ENVIRONMENT_ID valueFrom: secretKeyRef: name: dynatrace-secrets key: environmentId - name: DT_API_TOKEN valueFrom: secretKeyRef: name: dynatrace-secrets key: apiToken - name: DT_ONEAGENT_OPTIONS value: "--set-app-log-content-access=true --set-log-level=INFO" ports: - containerPort: 8080 resources: requests: memory: "512Mi" cpu: "250m" limits: memory: "1Gi" cpu: "500m" --- apiVersion: v1 kind: Secret metadata: name: dynatrace-secrets type: Opaque data: environmentId: <base64-encoded-environment-id> apiToken: <base64-encoded-api-token>
Conclusion
Dynatrace OneAgent provides comprehensive observability for Java applications:
- Automatic Instrumentation - Zero-code monitoring for common frameworks
- Custom Service Monitoring - Fine-grained control over business logic tracing
- Database Monitoring - SQL query performance and error tracking
- HTTP Client Monitoring - Outbound request tracing and performance
- Business Metrics - Custom metrics and events for business analysis
- Distributed Tracing - End-to-end transaction tracking across services
- Error Reporting - Automatic error detection and reporting
The integration enables full-stack observability with minimal code changes while providing the flexibility to add custom instrumentation for specific business requirements.