google-site-verification: google61fe8ba583a51912.html
MACRO NEPAL
APM Tool Integration in Java: Mastering New Relic and Datadog
awiskar acharya
November 10, 2025
12:27 pm

Application Performance Monitoring (APM) tools are essential for modern Java applications, providing deep insights into performance, errors, dependencies, and business metrics. This article explores integrating two leading APM solutions—New Relic and Datadog—into Java applications, covering installation, configuration, custom instrumentation, and best practices.

APM Integration Overview

Why APM Integration?

  • Performance Monitoring: Track response times, throughput, and resource usage
  • Error Tracking: Identify and diagnose exceptions and errors
  • Dependency Monitoring: Database queries, external HTTP calls, message queues
  • Business Metrics: Track custom business transactions and KPIs
  • Distributed Tracing: End-to-end request tracing across microservices

New Relic Integration

1. Automatic Installation

1.1 Using the Java Agent (Recommended)

Download the New Relic agent:

wget https://download.newrelic.com/newrelic/java-agent/newrelic-agent/current/newrelic-java.zip unzip newrelic-java.zip

1.2 Configuration File (newrelic.yml)

common: &default_settings # License key license_key: YOUR_LICENSE_KEY_HERE # Application name app_name: My Java Application # Logging configuration log_level: info log_file_path: logs/ # Security settings security: enabled: false # Transaction tracing transaction_tracer: enabled: true transaction_threshold: apdex_f record_sql: obfuscated stack_trace_threshold: 0.5 # Error collection error_collector: enabled: true ignore_errors: "" # Browser monitoring browser_monitoring: auto_instrument: true # Environment-specific settings development: <<: *default_settings app_name: My App (Development) production: <<: *default_settings app_name: My App (Production) log_level: error

1.3 JVM Integration

java -javaagent:/path/to/newrelic/newrelic.jar \ -Dnewrelic.config.file=/path/to/newrelic/newrelic.yml \ -Dnewrelic.environment=production \ -jar myapp.jar

1.4 Programmatic Installation (Spring Boot)

@SpringBootApplication public class MyApplication { public static void main(String[] args) { // Set system properties before Spring Boot starts System.setProperty("newrelic.config.file", "/path/to/newrelic.yml"); System.setProperty("newrelic.environment", "production"); SpringApplication.run(MyApplication.class, args); } }

2. Custom Instrumentation

2.1 Using Annotations

import com.newrelic.api.agent.*; @Service public class OrderService { @Trace(dispatcher = true) public Order createOrder(OrderRequest request) { // This method will be tracked as a transaction validateOrder(request); processPayment(request); return saveOrder(request); } @Trace(metricName = "Order/Validate") private void validateOrder(OrderRequest request) { // Custom segment NewRelic.addCustomParameter("order.amount", request.getAmount()); NewRelic.addCustomParameter("order.currency", request.getCurrency()); if (request.getAmount() <= 0) { NewRelic.noticeError("Invalid order amount"); throw new IllegalArgumentException("Amount must be positive"); } } @Trace(metricName = "Payment/Process") private void processPayment(OrderRequest request) { try { // Business logic NewRelic.recordMetric("Custom/Payment/Processed", 1); } catch (PaymentException e) { NewRelic.noticeError(e, false); throw e; } } }

2.2 Manual Transaction Tracing

import com.newrelic.api.agent.*; @Service public class ManualTracingService { public void complexOperation() { Transaction transaction = NewRelic.getAgent().getTransaction(); // Start a segment Segment segment = transaction.startSegment("ComplexCalculation"); try { // Perform complex operation performCalculation(); // Record custom metrics NewRelic.recordMetric("Custom/ComplexOperation", 1); NewRelic.incrementCounter("Custom/Operations/Completed"); } finally { segment.end(); } } @Trace private void performCalculation() { // This will be part of the transaction trace NewRelic.addCustomParameter("calculation.timestamp", System.currentTimeMillis()); } }

2.3 Custom HTTP Client Instrumentation

import com.newrelic.api.agent.*; @Component public class ExternalServiceClient { @Trace public String callExternalService(String url) { HttpHeaders headers = new HttpHeaders(); // Add distributed tracing headers Transaction transaction = NewRelic.getAgent().getTransaction(); transaction.insertDistributedTraceHeaders(new Headers() { @Override public HeaderType getHeaderType() { return HeaderType.HTTP; } @Override public void setHeader(String name, String value) { headers.add(name, value); } }); // Make HTTP request ResponseEntity<String> response = restTemplate.exchange( url, HttpMethod.GET, new HttpEntity<>(headers), String.class); // Record external call metrics NewRelic.recordResponseTimeMetric("External/Service/" + url, responseTime); return response.getBody(); } }

Datadog Integration

1. Automatic Installation

1.1 Using the Java Agent

Download the Datadog agent:

DD_AGENT_MAJOR_VERSION=7 bash -c "$(curl -L https://s3.amazonaws.com/dd-agent/scripts/install_script.sh)"

1.2 JVM Integration

java -javaagent:/path/to/dd-java-agent.jar \ -Ddd.service=my-java-app \ -Ddd.env=production \ -Ddd.version=1.0.0 \ -Ddd.logs.injection=true \ -jar myapp.jar

1.3 Docker Integration

FROM openjdk:11-jre-slim # Copy Datadog agent COPY dd-java-agent.jar /app/dd-java-agent.jar # Application JAR COPY myapp.jar /app/myapp.jar # Run with Datadog agent CMD ["java", "-javaagent:/app/dd-java-agent.jar", \ "-Ddd.service=my-java-app", \ "-Ddd.env=production", \ "-jar", "/app/myapp.jar"]

2. Configuration

2.1 System Properties

// application.properties or system properties public class DatadogConfig { static { System.setProperty("dd.service", "order-service"); System.setProperty("dd.env", "production"); System.setProperty("dd.version", "1.2.3"); System.setProperty("dd.trace.analytics.enabled", "true"); System.setProperty("dd.trace.methods", "com.example.OrderService[*]"); System.setProperty("dd.trace.db.client.split-by-instance", "true"); System.setProperty("dd.http.server.tag.query-string", "true"); } }

2.2 Environment Variables

export DD_SERVICE=order-service export DD_ENV=production export DD_VERSION=1.0.0 export DD_LOGS_INJECTION=true export DD_TRACE_ANALYTICS_ENABLED=true

3. Custom Instrumentation

3.1 Using Datadog Annotations

import datadog.trace.api.Trace; import datadog.trace.api.Config; @Service public class InventoryService { @Trace(operationName = "inventory.check", resourceName = "InventoryService.checkStock") public boolean checkStock(String productId, int quantity) { // Add custom tags datadog.trace.api.GlobalTracer.get() .activeSpan() .setTag("product.id", productId) .setTag("requested.quantity", quantity); try { boolean available = databaseCheck(productId, quantity); // Record custom metric if (available) { datadog.trace.api.GlobalTracer.get() .activeSpan() .setMetric("inventory.available", 1); } return available; } catch (Exception e) { // Mark span as error datadog.trace.api.GlobalTracer.get() .activeSpan() .setError(true); throw e; } } @Trace(operationName = "database.query", resourceName = "InventoryService.databaseCheck") private boolean databaseCheck(String productId, int quantity) { // Database operation will be automatically traced return inventoryRepository.hasStock(productId, quantity); } }

3.2 Manual Span Creation

import datadog.trace.api.DDTags; import io.opentracing.Span; import io.opentracing.Tracer; import io.opentracing.util.GlobalTracer; @Service public class ManualTracingService { private final Tracer tracer = GlobalTracer.get(); public void processBatch(List<Item> items) { Span span = tracer.buildSpan("batch.process") .withTag("batch.size", items.size()) .withTag("processing.type", "async") .start(); try (Scope scope = tracer.activateSpan(span)) { // Business logic for (Item item : items) { processItem(item, span); } span.setTag(DDTags.RESOURCE_NAME, "Processed " + items.size() + " items"); } catch (Exception e) { span.setTag(DDTags.ERROR, true); span.log(Map.of("event", "error", "error.object", e)); throw e; } finally { span.finish(); } } private void processItem(Item item, Span parentSpan) { Span span = tracer.buildSpan("item.process") .asChildOf(parentSpan) .withTag("item.id", item.getId()) .withTag("item.type", item.getType()) .start(); try (Scope scope = tracer.activateSpan(span)) { // Process individual item itemProcessor.process(item); } catch (Exception e) { span.setTag(DDTags.ERROR, true); span.log(Map.of("event", "error", "error.object", e)); } finally { span.finish(); } } }

3.3 Custom HTTP Client Instrumentation

import io.opentracing.contrib.spring.web.client.TracingRestTemplateInterceptor; @Configuration public class TracingConfig { @Bean public RestTemplate tracingRestTemplate() { RestTemplate restTemplate = new RestTemplate(); // Add tracing interceptor restTemplate.getInterceptors().add(new TracingRestTemplateInterceptor()); return restTemplate; } } @Service public class ExternalAPIClient { private final RestTemplate restTemplate; public ExternalAPIClient(RestTemplate restTemplate) { this.restTemplate = restTemplate; } @Trace public ApiResponse callExternalAPI(String url) { Tracer tracer = GlobalTracer.get(); Span span = tracer.activeSpan(); if (span != null) { span.setTag("external.api.url", url); span.setTag("http.method", "GET"); } try { ResponseEntity<ApiResponse> response = restTemplate.getForEntity( url, ApiResponse.class); if (span != null) { span.setTag("http.status_code", response.getStatusCodeValue()); } return response.getBody(); } catch (HttpStatusCodeException e) { if (span != null) { span.setTag(DDTags.ERROR, true); span.setTag("http.status_code", e.getRawStatusCode()); } throw e; } } }

Spring Boot Auto-Configuration

1. New Relic Spring Boot Starter

Maven Dependency:

<dependency> <groupId>com.newrelic.agent.java</groupId> <artifactId>newrelic-spring-boot-starter</artifactId> <version>2.0.0</version> </dependency>

Configuration:

# application.yml newrelic: config: license-key: ${NEW_RELIC_LICENSE_KEY} app-name: My Spring Boot App log-level: INFO security: enabled: true

2. Datadog Spring Boot Starter

Maven Dependency:

<dependency> <groupId>com.datadoghq</groupId> <artifactId>dd-trace-spring-boot-starter</artifactId> <version>1.0.0</version> </dependency>

Configuration:

# application.yml dd: service: order-service env: production version: 1.0.0 trace: enabled: true analytics: enabled: true logs: injection: true

Custom Metrics and Business Monitoring

1. New Relic Custom Metrics

import com.newrelic.api.agent.*; @Component public class BusinessMetricsService { public void recordOrderMetrics(Order order) { // Count-based metric NewRelic.incrementCounter("Order/Completed"); // Value-based metric NewRelic.recordMetric("Order/Amount", order.getAmount()); NewRelic.recordMetric("Order/Items", order.getItemCount()); // Custom event Map<String, Object> orderEvent = new HashMap<>(); orderEvent.put("orderId", order.getId()); orderEvent.put("customerId", order.getCustomerId()); orderEvent.put("amount", order.getAmount()); orderEvent.put("currency", order.getCurrency()); orderEvent.put("timestamp", order.getTimestamp()); NewRelic.getAgent().getInsights().recordCustomEvent("OrderCompleted", orderEvent); } public void recordErrorMetrics(Exception error, String context) { NewRelic.incrementCounter("Errors/" + error.getClass().getSimpleName()); Map<String, Object> errorEvent = new HashMap<>(); errorEvent.put("errorType", error.getClass().getName()); errorEvent.put("errorMessage", error.getMessage()); errorEvent.put("context", context); errorEvent.put("timestamp", System.currentTimeMillis()); NewRelic.getAgent().getInsights().recordCustomEvent("ApplicationError", errorEvent); } }

2. Datadog Custom Metrics

import datadog.trace.api.StatsDClient; import org.springframework.beans.factory.annotation.Autowired; @Service public class DatadogMetricsService { @Autowired private StatsDClient statsDClient; public void recordBusinessMetrics(Order order) { // Increment counter statsDClient.incrementCounter("order.completed"); // Record gauge statsDClient.recordGaugeValue("order.amount", order.getAmount()); statsDClient.recordGaugeValue("order.items.count", order.getItemCount()); // Record histogram statsDClient.recordHistogramValue("order.processing.time", order.getProcessingTime()); // Add tags Map<String, String> tags = new HashMap<>(); tags.put("currency", order.getCurrency()); tags.put("customer_tier", order.getCustomerTier()); statsDClient.incrementCounter("order.by_currency", tags); } public void recordErrorRate(String errorType) { statsDClient.incrementCounter("application.errors", "error_type:" + errorType, "environment:production"); } }

Log Integration

1. New Relic Logging

<!-- Logback integration --> <dependency> <groupId>com.newrelic.logging</groupId> <artifactId>logback</artifactId> <version>2.0.0</version> </dependency>

logback.xml:

<configuration> <appender name="NEW_RELIC" class="com.newrelic.logging.logback.NewRelicAppender"/> <root level="INFO"> <appender-ref ref="NEW_RELIC"/> </root> </configuration>

2. Datadog Logging

<!-- Logback integration --> <dependency> <groupId>com.datadoghq</groupId> <artifactId>dd-java-agent</artifactId> <version>1.0.0</version> </dependency>

JSON Layout for Structured Logging:

import lombok.extern.slf4j.Slf4j; @Slf4j @Service public class LoggingService { public void processWithLogging(Order order) { MDC.put("orderId", order.getId()); MDC.put("customerId", order.getCustomerId()); log.info("Processing order", kv("order_amount", order.getAmount()), kv("currency", order.getCurrency())); try { // Business logic processOrder(order); log.info("Order processed successfully"); } catch (Exception e) { log.error("Failed to process order", kv("error_message", e.getMessage()), kv("error_type", e.getClass().getSimpleName())); throw e; } finally { MDC.clear(); } } }

Performance Best Practices

1. Sampling for High-Throughput Applications

@Component public class SamplingStrategy { private static final double SAMPLE_RATE = 0.1; // Sample 10% of requests public boolean shouldTrace(String operation) { // Sample expensive operations less frequently if (operation.startsWith("BATCH_")) { return Math.random() < 0.01; // 1% for batch operations } return Math.random() < SAMPLE_RATE; } }

2. Asynchronous Instrumentation

@Service public class AsyncTracingService { @Async @Trace public CompletableFuture<Result> processAsync(Data data) { // Trace context is automatically propagated return CompletableFuture.supplyAsync(() -> { // Async processing return heavyComputation(data); }); } }

3. Resource Cleanup

@Component public class ResourceMonitoring { @PreDestroy public void cleanup() { // Flush any pending metrics/traces try { NewRelic.getAgent().getTracedMethod().setMetricName("Application/Shutdown"); } catch (Exception e) { // Log but don't throw } } }

Troubleshooting Common Issues

1. Debugging Configuration

public class APMDebugger { public static void checkAPMStatus() { // New Relic try { boolean connected = NewRelic.getAgent().getConfig().getValue("agent_connected"); System.out.println("New Relic connected: " + connected); } catch (Exception e) { System.out.println("New Relic not available"); } // Datadog try { Tracer tracer = GlobalTracer.get(); System.out.println("Datadog tracer active: " + (tracer != null)); } catch (Exception e) { System.out.println("Datadog not available"); } } }

2. Performance Impact Monitoring

@Aspect @Component public class APMPerformanceMonitor { @Around("@annotation(org.springframework.web.bind.annotation.GetMapping)") public Object monitorControllerPerformance(ProceedingJoinPoint joinPoint) throws Throwable { long startTime = System.currentTimeMillis(); try { return joinPoint.proceed(); } finally { long duration = System.currentTimeMillis() - startTime; // Alert if APM adds significant overhead if (duration > 1000) { // 1 second threshold log.warn("APM overhead detected: {}ms for method {}", duration, joinPoint.getSignature().getName()); } } } }

Conclusion

Integrating New Relic and Datadog APM tools into Java applications provides:

  1. Comprehensive Monitoring: End-to-end visibility into application performance
  2. Proactive Alerting: Early detection of performance degradation and errors
  3. Business Insights: Correlation of technical metrics with business outcomes
  4. Distributed Tracing: Understanding complex microservice interactions

Key Success Factors:

  • Proper configuration and environment-specific settings
  • Strategic sampling to balance overhead and insights
  • Custom instrumentation for business-specific metrics
  • Structured logging with trace context propagation
  • Regular monitoring of APM tool performance impact

By following these integration patterns and best practices, you can effectively monitor your Java applications' health, performance, and business impact using industry-leading APM tools.

Category : JAVA

Leave a Reply

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


Macro Nepal Helper