New Relic入門 第3A部 - APM基礎：アプリケーション監視をマスターしよう ​

// Step 1: New Relic APMダッシュボードでの確認項目
1. Overview画面でのResponse Time trend確認
   - 通常: 200ms → 現在: 1.2s
   - 問題発生時刻: 2025-07-15 14:30頃
   
2. Transactionsページでのボトルネック特定
   - GET /api/products/search: 85% of total time
   - 他のエンドポイントは正常
   
3. Database queriesタブでのSlow Query特定
   - SELECT * FROM products WHERE name LIKE '%keyword%': 950ms
   - 実行回数: 1回のリクエストで平均3.2回実行

// APMダッシュボードでの確認手順
1. APM → Applications → [Your App Name]
2. "Database" タブをクリック
3. "Slow Queries" セクションで詳細を確認
4. クエリ実行時間、呼び出し頻度、影響度を分析

// カスタムメトリクスでの追跡
const newrelic = require('newrelic');

async function searchProducts(keyword) {
  const startTime = Date.now();
  
  try {
    const results = await database.search(keyword);
    
    // 検索パフォーマンスをトラッキング
    newrelic.recordMetric('Custom/Search/ResponseTime', Date.now() - startTime);
    newrelic.recordMetric('Custom/Search/ResultCount', results.length);
    
    return results;
  } catch (error) {
    newrelic.noticeError(error, {
      searchKeyword: keyword,
      searchDuration: Date.now() - startTime
    });
    throw error;
  }
}

// 🚫 メモリリークを起こすコード例
class DataProcessor {
  constructor() {
    this.cache = new Map();
    this.eventListeners = [];
  }
  
  // 問題1: キャッシュのクリアが不十分
  processData(data) {
    const cacheKey = `${data.id}_${Date.now()}`;
    this.cache.set(cacheKey, data); // キャッシュが永続的に蓄積
    
    return this.transformData(data);
  }
  
  // 問題2: イベントリスナーの解除忘れ
  setupWebSocket(ws) {
    const handler = (message) => {
      this.handleMessage(message);
    };
    
    ws.on('message', handler);
    this.eventListeners.push(handler); // 参照が残り続ける
  }
}

// ✅ 修正されたコード
class OptimizedDataProcessor {
  constructor() {
    this.cache = new Map();
    this.eventListeners = new WeakMap(); // WeakMapを使用
    this.maxCacheSize = 1000;
  }
  
  processData(data) {
    // キャッシュサイズ制限
    if (this.cache.size >= this.maxCacheSize) {
      this.cleanupOldCache();
    }
    
    const cacheKey = `${data.id}`;
    this.cache.set(cacheKey, {
      data: data,
      timestamp: Date.now(),
      ttl: 300000 // 5分でTTL
    });
    
    return this.transformData(data);
  }
  
  cleanupOldCache() {
    const now = Date.now();
    for (const [key, value] of this.cache.entries()) {
      if (now - value.timestamp > value.ttl) {
        this.cache.delete(key);
      }
    }
  }
  
  setupWebSocket(ws) {
    const handler = (message) => {
      this.handleMessage(message);
    };
    
    ws.on('message', handler);
    
    // クリーンアップ関数を提供
    const cleanup = () => {
      ws.removeListener('message', handler);
    };
    
    ws.on('close', cleanup);
    ws.on('error', cleanup);
    
    return cleanup;
  }
}

// カスタムメトリクスでメモリ使用量を追跡
const newrelic = require('newrelic');

// 定期的なメモリ監視
setInterval(() => {
  const memUsage = process.memoryUsage();
  
  newrelic.recordMetric('Custom/Memory/RSS', memUsage.rss);
  newrelic.recordMetric('Custom/Memory/HeapUsed', memUsage.heapUsed);
  newrelic.recordMetric('Custom/Memory/HeapTotal', memUsage.heapTotal);
  newrelic.recordMetric('Custom/Memory/External', memUsage.external);
  
  // メモリリークの早期警告
  const heapUsedMB = memUsage.heapUsed / 1024 / 1024;
  if (heapUsedMB > 500) { // 500MB閾値
    newrelic.addCustomAttribute('memory_warning', true);
    newrelic.recordMetric('Custom/Memory/Warning', 1);
  }
}, 30000); // 30秒間隔

// Frontend API (Node.js)
const newrelic = require('newrelic');

app.post('/api/orders', async (req, res) => {
  const transaction = newrelic.getTransaction();
  
  try {
    // 1. 認証サービス呼び出し
    const authResult = await authService.validateUser(req.headers.authorization);
    newrelic.addCustomAttribute('auth.user_id', authResult.userId);
    
    // 2. 注文処理開始
    const orderData = {
      ...req.body,
      userId: authResult.userId,
      traceId: transaction.traceId // トレースIDを伝播
    };
    
    const order = await orderService.createOrder(orderData);
    newrelic.addCustomAttribute('order.id', order.id);
    
    res.json({ success: true, orderId: order.id });
    
  } catch (error) {
    newrelic.noticeError(error, {
      service: 'frontend-api',
      endpoint: '/api/orders',
      userId: req.body.userId
    });
    res.status(500).json({ error: 'Order processing failed' });
  }
});

// Order Service (Java)
@RestController
public class OrderController {
    
    @PostMapping("/orders")
    @Trace(dispatcher = true)
    public ResponseEntity<Order> createOrder(@RequestBody OrderRequest request) {
        try {
            // 分散トレーシング情報を追加
            NewRelic.addCustomParameter("order.total", request.getTotal());
            NewRelic.addCustomParameter("order.items_count", request.getItems().size());
            
            // 在庫確認サービス呼び出し
            InventoryResponse inventory = inventoryService.checkAvailability(request);
            
            if (!inventory.isAvailable()) {
                NewRelic.recordMetric("Custom/Order/InventoryUnavailable", 1);
                throw new InventoryUnavailableException("Items not available");
            }
            
            // 決済処理
            PaymentResponse payment = paymentService.processPayment(request.getPayment());
            NewRelic.addCustomParameter("payment.transaction_id", payment.getTransactionId());
            
            // 注文作成
            Order order = orderRepository.save(new Order(request, payment.getTransactionId()));
            
            // 非同期通知（パフォーマンス改善）
            notificationService.sendOrderConfirmationAsync(order);
            
            return ResponseEntity.ok(order);
            
        } catch (Exception e) {
            NewRelic.noticeError(e);
            throw e;
        }
    }
}

// 効果的なエラー追跡の実装
const newrelic = require('newrelic');

class ErrorTracker {
  static trackError(error, context = {}) {
    // エラー分類
    const errorType = this.classifyError(error);
    
    // 詳細なコンテキスト情報
    const enrichedContext = {
      ...context,
      errorType: errorType,
      timestamp: new Date().toISOString(),
      userAgent: context.userAgent || 'unknown',
      sessionId: context.sessionId || 'anonymous',
      apiVersion: process.env.API_VERSION,
      environment: process.env.NODE_ENV
    };
    
    // New Relicにエラー送信
    newrelic.noticeError(error, enrichedContext);
    
    // カスタムメトリクス更新
    newrelic.recordMetric(`Custom/Errors/${errorType}`, 1);
    
    // 重要度に応じた追加処理
    if (this.isCriticalError(error)) {
      this.alertCriticalError(error, enrichedContext);
    }
  }
  
  static classifyError(error) {
    const errorMapping = {
      'ValidationError': 'validation',
      'AuthenticationError': 'authentication',
      'AuthorizationError': 'authorization',
      'DatabaseError': 'database',
      'NetworkError': 'network',
      'TimeoutError': 'timeout',
      'RateLimitError': 'rate_limit'
    };
    
    return errorMapping[error.constructor.name] || 'unknown';
  }
  
  static isCriticalError(error) {
    const criticalTypes = [
      'DatabaseError',
      'PaymentError',
      'SecurityError'
    ];
    
    return criticalTypes.includes(error.constructor.name);
  }
  
  static alertCriticalError(error, context) {
    // 重要なエラーの場合、追加のカスタム属性
    newrelic.addCustomAttribute('critical_error', true);
    newrelic.addCustomAttribute('alert_level', 'critical');
    newrelic.recordMetric('Custom/Errors/Critical', 1);
  }
}

// 使用例
app.use((error, req, res, next) => {
  ErrorTracker.trackError(error, {
    url: req.url,
    method: req.method,
    userAgent: req.get('User-Agent'),
    sessionId: req.session?.id,
    userId: req.user?.id
  });
  
  res.status(500).json({ error: 'Internal Server Error' });
});