New Relic Logs in Context設定ガイド - APMとログの統合監視 ​

// Java
import com.newrelic.api.agent.NewRelic;

public class OrderService {
    private static final Logger logger = LoggerFactory.getLogger(OrderService.class);
    
    public void processOrder(String orderId) {
        // New Relicトレース情報の取得
        String traceId = NewRelic.getAgent().getTraceMetadata().getTraceId();
        String spanId = NewRelic.getAgent().getTraceMetadata().getSpanId();
        
        // ログにトレース情報を追加
        MDC.put("trace.id", traceId);
        MDC.put("span.id", spanId);
        MDC.put("order.id", orderId);
        
        logger.info("Starting order processing");
        
        try {
            // 処理ロジック
            performOrderProcessing(orderId);
            logger.info("Order processing completed");
        } catch (Exception e) {
            logger.error("Order processing failed", e);
            throw e;
        } finally {
            // MDCのクリア
            MDC.clear();
        }
    }
}

// Java - HTTPクライアント側
@RestController
public class UserController {
    
    @Autowired
    private OrderServiceClient orderServiceClient;
    
    @GetMapping("/users/{userId}/orders")
    public ResponseEntity<List<Order>> getUserOrders(@PathVariable String userId) {
        // New Relicトレース情報の取得
        String traceId = NewRelic.getAgent().getTraceMetadata().getTraceId();
        String spanId = NewRelic.getAgent().getTraceMetadata().getSpanId();
        
        // HTTPヘッダーにトレース情報を追加
        HttpHeaders headers = new HttpHeaders();
        headers.set("X-Trace-Id", traceId);
        headers.set("X-Span-Id", spanId);
        headers.set("X-User-Id", userId);
        
        return orderServiceClient.getOrdersByUser(userId, headers);
    }
}

// Java - HTTPサーバー側
@RestController
public class OrderController {
    
    @GetMapping("/orders/user/{userId}")
    public ResponseEntity<List<Order>> getOrdersByUser(
            @PathVariable String userId,
            @RequestHeader(value = "X-Trace-Id", required = false) String traceId,
            @RequestHeader(value = "X-Span-Id", required = false) String spanId) {
        
        // 受信したトレース情報をログコンテキストに設定
        if (traceId != null) {
            MDC.put("trace.id", traceId);
        }
        if (spanId != null) {
            MDC.put("parent.span.id", spanId);
        }
        
        logger.info("Fetching orders for user: {}", userId);
        
        try {
            List<Order> orders = orderService.getOrdersByUser(userId);
            logger.info("Found {} orders for user: {}", orders.size(), userId);
            return ResponseEntity.ok(orders);
        } catch (Exception e) {
            logger.error("Failed to fetch orders for user: {}", userId, e);
            throw e;
        } finally {
            MDC.clear();
        }
    }
}

// Java - メッセージ送信側
@Component
public class OrderEventPublisher {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void publishOrderEvent(OrderEvent event) {
        // トレース情報をメッセージヘッダーに追加
        String traceId = NewRelic.getAgent().getTraceMetadata().getTraceId();
        String spanId = NewRelic.getAgent().getTraceMetadata().getSpanId();
        
        MessageProperties properties = new MessageProperties();
        properties.getHeaders().put("X-Trace-Id", traceId);
        properties.getHeaders().put("X-Span-Id", spanId);
        properties.getHeaders().put("X-Service", "order-service");
        
        Message message = new Message(JSON.toJSONBytes(event), properties);
        
        rabbitTemplate.send("order.events", message);
        
        logger.info("Published order event: {}", event.getOrderId());
    }
}

// Java - メッセージ受信側
@RabbitListener(queues = "order.events")
public class OrderEventConsumer {
    
    public void handleOrderEvent(
            @Payload OrderEvent event,
            @Header Map<String, Object> headers) {
        
        // メッセージヘッダーからトレース情報を取得
        String traceId = (String) headers.get("X-Trace-Id");
        String spanId = (String) headers.get("X-Span-Id");
        
        if (traceId != null) {
            MDC.put("trace.id", traceId);
        }
        if (spanId != null) {
            MDC.put("parent.span.id", spanId);
        }
        
        logger.info("Processing order event: {}", event.getOrderId());
        
        try {
            processOrderEvent(event);
            logger.info("Order event processed successfully: {}", event.getOrderId());
        } catch (Exception e) {
            logger.error("Failed to process order event: {}", event.getOrderId(), e);
            throw e;
        } finally {
            MDC.clear();
        }
    }
}

// Java - カスタム属性の追加
public class OrderService {
    
    @NewRelic.Trace
    public void processOrder(Order order) {
        // New Relicカスタム属性の追加
        NewRelic.addCustomParameter("order.id", order.getId());
        NewRelic.addCustomParameter("order.amount", order.getAmount());
        NewRelic.addCustomParameter("customer.tier", order.getCustomer().getTier());
        
        // ログにも同様の情報を追加
        MDC.put("order.id", order.getId());
        MDC.put("order.amount", String.valueOf(order.getAmount()));
        MDC.put("customer.tier", order.getCustomer().getTier());
        
        logger.info("Processing order for customer tier: {}", 
                   order.getCustomer().getTier());
        
        // 処理ロジック
    }
}

// Java - 機密情報の自動マスキング設定
@Component
public class SecureLoggingFilter {
    private static final Logger logger = LoggerFactory.getLogger(SecureLoggingFilter.class);
    
    @Autowired
    private SensitiveDataMasker dataMasker;
    
    public void logSecurely(String message, Object... params) {
        // トレース情報の取得
        String traceId = NewRelic.getAgent().getTraceMetadata().getTraceId();
        String spanId = NewRelic.getAgent().getTraceMetadata().getSpanId();
        
        // 機密情報のマスキング
        String maskedMessage = dataMasker.maskSensitiveData(message);
        Object[] maskedParams = dataMasker.maskParameters(params);
        
        // セキュアなログ出力
        MDC.put("trace.id", traceId);
        MDC.put("span.id", spanId);
        MDC.put("security.masked", "true");
        
        logger.info(maskedMessage, maskedParams);
        
        MDC.clear();
    }
}

// Java - 動的サンプリング実装
@Component
public class DynamicSamplingLogger {
    private static final Logger logger = LoggerFactory.getLogger(DynamicSamplingLogger.class);
    private final AtomicLong errorCount = new AtomicLong(0);
    private final AtomicLong totalCount = new AtomicLong(0);
    
    @Value("${logging.sampling.error-threshold:0.1}")
    private double errorThreshold;
    
    public void logWithDynamicSampling(String level, String message, Object... params) {
        totalCount.incrementAndGet();
        
        boolean shouldLog = false;
        double currentErrorRate = getCurrentErrorRate();
        
        // エラー率に基づく動的サンプリング
        if ("ERROR".equals(level)) {
            errorCount.incrementAndGet();
            shouldLog = true;  // エラーは常に記録
        } else if ("WARN".equals(level)) {
            // エラー率が高い場合、警告ログの記録率を上げる
            shouldLog = currentErrorRate > errorThreshold ? 
                Math.random() < 0.5 : Math.random() < 0.1;
        } else {
            // 通常ログは低頻度でサンプリング
            shouldLog = Math.random() < 0.05;
        }
        
        if (shouldLog) {
            // New Relicトレース情報を追加
            String traceId = NewRelic.getAgent().getTraceMetadata().getTraceId();
            String spanId = NewRelic.getAgent().getTraceMetadata().getSpanId();
            
            MDC.put("trace.id", traceId);
            MDC.put("span.id", spanId);
            MDC.put("error_rate", String.valueOf(currentErrorRate));
            MDC.put("sampling_reason", getSamplingReason(level, currentErrorRate));
            
            logger.info(message, params);
            MDC.clear();
        }
    }
    
    private double getCurrentErrorRate() {
        long total = totalCount.get();
        return total > 0 ? (double) errorCount.get() / total : 0.0;
    }
    
    private String getSamplingReason(String level, double errorRate) {
        if ("ERROR".equals(level)) return "always_log_errors";
        if (errorRate > errorThreshold) return "high_error_rate";
        return "normal_sampling";
    }
}