New Relic APM入門 第5.1章 - APMの基本と高度な機能 ​

# 問題：ユーザー認証が断続的に失敗
# 従来監視：「認証サービスは正常稼働」
# APMでの発見：認証サービス→ユーザーデータベース→キャッシュ層の連鎖遅延

# APMで可視化された問題
"""
User Request → API Gateway (2ms) → Auth Service (1500ms) → User DB (3000ms)
                                                        → Cache (timeout)
"""

# 解決策：APMデータに基づく最適化
def get_user_with_caching(user_id):
    """APM推奨のキャッシング戦略"""
    # レベル1：メモリキャッシュ（1ms未満）
    user = memory_cache.get(f"user:{user_id}")
    if user:
        return user
    
    # レベル2：Redisキャッシュ（2-5ms）  
    user = redis_client.get(f"user:{user_id}")
    if user:
        memory_cache.set(f"user:{user_id}", user, ttl=60)
        return json.loads(user)
    
    # レベル3：データベース（50-200ms）
    user = database.get_user(user_id)
    if user:
        redis_client.set(f"user:{user_id}", json.dumps(user), ex=300)
        memory_cache.set(f"user:{user_id}", user, ttl=60)
        return user

# 外部依存関係の監視設定例
external_dependencies = {
    "payment_gateway": {
        "provider": "Stripe/PayPal",
        "sla": "決済処理3秒以内",
        "error_handling": "タイムアウト時の代替処理",
        "monitoring": {
            "response_time": "平均1秒以下",
            "error_rate": "0.5%以下",
            "availability": "99.9%以上"
        }
    },
    
    "recommendation_api": {
        "provider": "機械学習推薦システム",
        "sla": "推薦取得500ms以内",
        "fallback": "キャッシュされた人気商品表示",
        "monitoring": {
            "cache_hit_rate": "80%以上",
            "ml_model_accuracy": "クリック率5%以上"
        }
    },
    
    "inventory_service": {
        "type": "内部マイクロサービス",
        "sla": "在庫チェック200ms以内",
        "critical_impact": "在庫切れ表示の遅延 → 顧客体験悪化"
    }
}

# New Relic Code-Level Metricsの例
@newrelic.agent.function_trace()  # 関数レベルの監視
def calculate_recommendation(user_id, product_category):
    """商品推薦計算（重い処理の監視例）"""
    
    # ステップ1：ユーザー行動履歴取得（監視対象）
    with newrelic.agent.FunctionTrace('get_user_behavior'):
        user_behavior = get_user_behavior_data(user_id)
    
    # ステップ2：機械学習推薦計算（監視対象）
    with newrelic.agent.FunctionTrace('ml_recommendation'):
        ml_results = ml_recommendation_engine.predict(
            user_behavior, product_category
        )
    
    # ステップ3：ビジネスルール適用（監視対象）
    with newrelic.agent.FunctionTrace('apply_business_rules'):
        final_recommendations = apply_business_rules(ml_results)
    
    return final_recommendations

# New Relicが自動的に以下を監視・記録：
monitoring_data = {
    "function_name": "calculate_recommendation",
    "execution_time": "245ms",
    "call_count": "1,247 times/hour", 
    "slowest_trace": {
        "duration": "3.2s",
        "bottleneck": "ml_recommendation_engine.predict",  # ボトルネック特定
        "stack_trace": "完全なスタックトレース",
        "sql_queries": ["SELECT * FROM user_behaviors...", "..."]
    }
}

# requirements.txt
newrelic==9.2.0

# Django settings.py
import newrelic.agent

# New Relic設定
INSTALLED_APPS = [
    # ... 他のアプリ
    'newrelic',
]

# ミドルウェア設定
MIDDLEWARE = [
    'newrelic.agent.django_middleware',  # 最初に配置
    # ... 他のミドルウェア
]

# wsgi.py（デプロイ時の設定）
import os
import newrelic.agent
from django.core.wsgi import get_wsgi_application

# New Relic初期化
newrelic.agent.initialize('/path/to/newrelic.ini')

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myapp.settings')
application = get_wsgi_application()

# New Relic WSGI監視
application = newrelic.agent.wsgi_application()(application)

# views.py - ビジネスロジック監視
from django.shortcuts import render
from django.http import JsonResponse
import newrelic.agent

class CheckoutView(View):
    @newrelic.agent.function_trace('checkout_process')
    def post(self, request):
        # カスタム属性追加
        newrelic.agent.add_custom_attribute('user.id', request.user.id)
        newrelic.agent.add_custom_attribute('checkout.amount', request.POST.get('amount'))
        
        try:
            # 重要なビジネス処理
            order = self.process_order(request.POST)
            
            # 成功メトリクス
            newrelic.agent.record_custom_metric('Custom/Checkout/Success', 1)
            
            return JsonResponse({
                'success': True,
                'order_id': order.id
            })
            
        except PaymentError as e:
            # エラー詳細記録
            newrelic.agent.notice_error(
                error_class='PaymentError',
                message=str(e),
                attributes={
                    'payment.method': request.POST.get('payment_method'),
                    'payment.amount': request.POST.get('amount')
                }
            )
            return JsonResponse({'error': 'Payment failed'}, status=400)
    
    @newrelic.agent.background_task('order_processing')  # バックグラウンドタスク監視
    def process_order(self, order_data):
        """注文処理（重い処理の監視例）"""
        
        # ステップ1：在庫チェック（監視）
        with newrelic.agent.FunctionTrace('inventory_check'):
            inventory_ok = self.check_inventory(order_data['items'])
        
        # ステップ2：決済処理（監視）
        with newrelic.agent.FunctionTrace('payment_process'):
            payment_result = self.process_payment(order_data)
        
        # ステップ3：注文保存（監視）
        with newrelic.agent.FunctionTrace('order_creation'):
            order = Order.objects.create(**order_data)
        
        return order

# Flask アプリケーション
from flask import Flask, request, jsonify
import newrelic.agent

# New Relic初期化
newrelic.agent.initialize('/path/to/newrelic.ini')

app = Flask(__name__)

# Flask アプリケーション監視有効化
app = newrelic.agent.wsgi_application()(app)

@app.route('/api/checkout', methods=['POST'])
@newrelic.agent.function_trace('api_checkout')
def checkout():
    """チェックアウトAPI（パフォーマンス重要）"""
    
    # リクエスト情報をカスタム属性として記録
    newrelic.agent.add_custom_attribute('checkout.user_id', request.json.get('user_id'))
    newrelic.agent.add_custom_attribute('checkout.item_count', len(request.json.get('items', [])))
    
    try:
        # ビジネスロジック実行
        result = process_checkout(request.json)
        
        # 成功メトリクス
        newrelic.agent.record_custom_metric('Custom/API/Checkout/Success', 1)
        
        return jsonify({
            'status': 'success',
            'transaction_id': result['transaction_id']
        })
        
    except Exception as e:
        # エラー詳細記録
        newrelic.agent.notice_error(
            attributes={
                'error.context': 'checkout_api',
                'request.data': str(request.json)
            }
        )
        
        newrelic.agent.record_custom_metric('Custom/API/Checkout/Error', 1)
        
        return jsonify({'error': 'Internal server error'}), 500

# バックグラウンドタスク監視（Celery等）
@newrelic.agent.background_task('email_notification')
def send_order_confirmation(order_id):
    """注文確認メール送信（バックグラウンド処理）"""
    
    newrelic.agent.add_custom_attribute('email.order_id', order_id)
    
    try:
        order = get_order(order_id)
        send_email(order.customer_email, generate_confirmation_email(order))
        
        # 成功メトリクス
        newrelic.agent.record_custom_metric('Custom/Email/Confirmation/Sent', 1)
        
    except Exception as e:
        newrelic.agent.notice_error()
        newrelic.agent.record_custom_metric('Custom/Email/Confirmation/Failed', 1)

# Django でのエラー監視・処理例
import newrelic.agent
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
import logging

logger = logging.getLogger(__name__)

class ErrorMonitoringMixin:
    """エラー監視共通機能"""
    
    def record_error(self, error, context=None):
        """エラーを New Relic とログに記録"""
        
        # エラー分類
        error_type = type(error).__name__
        error_category = self.classify_error(error)
        
        # New Relic カスタム属性
        attributes = {
            'error.category': error_category,
            'error.type': error_type,
            'error.message': str(error)
        }
        
        if context:
            attributes.update(context)
        
        # New Relic エラー記録
        newrelic.agent.notice_error(attributes=attributes)
        
        # カスタムメトリクス
        newrelic.agent.record_custom_metric(f'Custom/Error/{error_category}', 1)
        
        # 構造化ログ
        logger.error("Application error occurred", extra={
            'error_type': error_type,
            'error_category': error_category,
            'error_message': str(error),
            'context': context
        })
    
    def classify_error(self, error):
        """エラーの分類"""
        
        if isinstance(error, ValidationError):
            return "validation"
        elif isinstance(error, PaymentError):
            return "payment"
        elif isinstance(error, DatabaseError):
            return "database"
        elif isinstance(error, TimeoutError):
            return "timeout"
        else:
            return "unknown"

@csrf_exempt
def checkout_api(request):
    """チェックアウトAPI（エラー処理強化版）"""
    
    error_monitor = ErrorMonitoringMixin()
    
    try:
        # リクエストバリデーション
        if not request.POST.get('amount'):
            raise ValidationError("Amount is required")
        
        amount = float(request.POST.get('amount'))
        if amount <= 0:
            raise ValidationError("Amount must be positive")
        
        # ビジネスロジック実行
        result = process_payment(amount, request.POST.get('payment_method'))
        
        # 成功メトリクス
        newrelic.agent.record_custom_metric('Custom/Checkout/Success', 1)
        
        return JsonResponse({
            'success': True,
            'transaction_id': result['id']
        })
        
    except ValidationError as e:
        # バリデーションエラー（ユーザー起因）
        error_monitor.record_error(e, {
            'request.amount': request.POST.get('amount'),
            'request.payment_method': request.POST.get('payment_method')
        })
        
        return JsonResponse({
            'error': 'Invalid request',
            'details': str(e)
        }, status=400)
        
    except PaymentError as e:
        # 決済エラー（外部サービス起因）
        error_monitor.record_error(e, {
            'payment.method': request.POST.get('payment_method'),
            'payment.amount': amount
        })
        
        return JsonResponse({
            'error': 'Payment processing failed',
            'retry_allowed': e.is_retryable()
        }, status=402)
        
    except Exception as e:
        # 予期しないエラー（システム起因）
        error_monitor.record_error(e, {
            'request.data': dict(request.POST),
            'user.id': getattr(request.user, 'id', None)
        })
        
        return JsonResponse({
            'error': 'Internal server error'
        }, status=500)

# SaaSアプリケーションのビジネスメトリクス
import newrelic.agent
from datetime import datetime, timedelta

class SaaSBusinessMetrics:
    
    def record_user_engagement(self, user_id, action):
        """ユーザーエンゲージメント監視"""
        
        # アクション別記録
        newrelic.agent.record_custom_metric(f'Custom/Engagement/{action}', 1)
        
        # ユーザー属性追加
        user = self.get_user(user_id)
        newrelic.agent.add_custom_attribute('user.plan', user.subscription_plan)
        newrelic.agent.add_custom_attribute('user.signup_date', user.created_at.isoformat())
        
        # DAU/MAU 計算
        self.update_active_users(user_id)
    
    def record_subscription_metrics(self, subscription_event):
        """サブスクリプション監視"""
        
        event_type = subscription_event['type']
        plan = subscription_event['plan']
        amount = subscription_event.get('amount', 0)
        
        # イベント別記録
        newrelic.agent.record_custom_metric(f'Custom/Subscription/{event_type}', 1)
        newrelic.agent.record_custom_metric(f'Custom/Subscription/{event_type}/{plan}', 1)
        
        # 収益影響
        if event_type == 'upgrade':
            newrelic.agent.record_custom_metric('Custom/Revenue/Expansion', amount)
        elif event_type == 'downgrade':
            newrelic.agent.record_custom_metric('Custom/Revenue/Contraction', amount)
        elif event_type == 'churn':
            newrelic.agent.record_custom_metric('Custom/Revenue/Churn', amount)
    
    def record_feature_usage(self, user_id, feature_name, usage_count=1):
        """機能利用状況監視"""
        
        newrelic.agent.record_custom_metric(f'Custom/Feature/{feature_name}', usage_count)
        
        # プラン別利用状況
        user = self.get_user(user_id)
        newrelic.agent.record_custom_metric(
            f'Custom/Feature/{feature_name}/Plan/{user.plan}', 
            usage_count
        )
        
        # 利用限界近接アラート
        monthly_usage = self.get_monthly_usage(user_id, feature_name)
        usage_limit = self.get_usage_limit(user.plan, feature_name)
        
        if monthly_usage / usage_limit > 0.8:  # 80%超過
            newrelic.agent.record_custom_metric('Custom/Usage/NearLimit', 1)
    
    def calculate_business_health_score(self):
        """ビジネス健全性スコア計算"""
        
        # チャーン率
        churn_rate = self.calculate_churn_rate()
        newrelic.agent.record_custom_metric('Custom/Business/ChurnRate', churn_rate)
        
        # 月次経常収益（MRR）
        mrr = self.calculate_mrr()
        newrelic.agent.record_custom_metric('Custom/Business/MRR', mrr)
        
        # 顧客獲得コスト（CAC）
        cac = self.calculate_cac()
        newrelic.agent.record_custom_metric('Custom/Business/CAC', cac)
        
        # 顧客生涯価値（LTV）
        ltv = self.calculate_ltv()
        newrelic.agent.record_custom_metric('Custom/Business/LTV', ltv)
        
        # LTV/CAC比率（健全性指標）
        ltv_cac_ratio = ltv / cac if cac > 0 else 0
        newrelic.agent.record_custom_metric('Custom/Business/LTV_CAC_Ratio', ltv_cac_ratio)
        
        # 健全性アラート
        if ltv_cac_ratio < 3:  # 3倍未満は危険
            newrelic.agent.record_custom_metric('Custom/Business/Health/Poor', 1)

# Django ビューでの使用例
class FeatureUsageView(APIView):
    
    @newrelic.agent.function_trace('feature_usage_api')
    def post(self, request):
        saas_metrics = SaaSBusinessMetrics()
        
        # 技術的監視
        newrelic.agent.add_custom_attribute('api.endpoint', 'feature_usage')
        newrelic.agent.add_custom_attribute('user.id', request.user.id)
        
        try:
            feature_name = request.data['feature']
            usage_data = request.data['usage']
            
            # ビジネス監視
            saas_metrics.record_user_engagement(request.user.id, 'feature_use')
            saas_metrics.record_feature_usage(
                request.user.id, 
                feature_name, 
                usage_data.get('count', 1)
            )
            
            # 技術的成功メトリクス
            newrelic.agent.record_custom_metric('Custom/API/FeatureUsage/Success', 1)
            
            return Response({'status': 'recorded'})
            
        except Exception as e:
            # エラー監視
            newrelic.agent.notice_error(attributes={
                'api.endpoint': 'feature_usage',
                'user.plan': request.user.subscription_plan
            })
            
            return Response({'error': 'Failed to record usage'}, status=500)

# インシデント自動対応システム
import newrelic.agent
from datetime import datetime
import json

class IncidentResponseAutomation:
    
    def __init__(self):
        self.escalation_rules = self.load_escalation_rules()
        self.auto_remediation = AutoRemediation()
    
    def handle_alert(self, alert_data):
        """アラート受信時の自動対応"""
        
        # インシデント分類
        severity = self.classify_incident_severity(alert_data)
        incident_id = self.create_incident_record(alert_data, severity)
        
        # New Relic記録
        newrelic.agent.add_custom_attribute('incident.id', incident_id)
        newrelic.agent.add_custom_attribute('incident.severity', severity)
        
        # 自動復旧試行（P3以下のみ）
        if severity in ['P3', 'P4']:
            remediation_result = self.attempt_auto_remediation(alert_data)
            
            if remediation_result['success']:
                newrelic.agent.record_custom_metric('Custom/Incident/AutoResolved', 1)
                return self.mark_incident_resolved(incident_id, remediation_result)
        
        # エスカレーション実行
        self.escalate_incident(incident_id, severity, alert_data)
        
        return incident_id
    
    def attempt_auto_remediation(self, alert_data):
        """自動復旧処理"""
        
        alert_type = alert_data.get('condition_name', '')
        remediation_actions = []
        
        try:
            # データベース接続問題
            if 'database' in alert_type.lower():
                result = self.auto_remediation.restart_db_connections()
                remediation_actions.append(result)
            
            # メモリ不足問題  
            elif 'memory' in alert_type.lower():
                result = self.auto_remediation.clear_cache_and_restart()
                remediation_actions.append(result)
            
            # 外部API問題
            elif 'external' in alert_type.lower():
                result = self.auto_remediation.enable_fallback_service()
                remediation_actions.append(result)
            
            # 高CPU使用率
            elif 'cpu' in alert_type.lower():
                result = self.auto_remediation.scale_out_instances()
                remediation_actions.append(result)
            
            return {
                'success': all(action['success'] for action in remediation_actions),
                'actions': remediation_actions
            }
            
        except Exception as e:
            newrelic.agent.notice_error(e, {
                'context': 'auto_remediation',
                'alert_type': alert_type
            })
            
            return {'success': False, 'error': str(e)}
    
    def escalate_incident(self, incident_id, severity, alert_data):
        """インシデントエスカレーション"""
        
        escalation_config = self.escalation_rules[severity]
        
        # 通知送信
        for channel in escalation_config['notification_channels']:
            self.send_notification(channel, {
                'incident_id': incident_id,
                'severity': severity,
                'alert_data': alert_data,
                'dashboard_url': self.generate_dashboard_url(alert_data),
                'runbook_url': self.get_runbook_url(alert_data['condition_name'])
            })
        
        # タイマー設定（エスカレーション継続）
        if escalation_config.get('escalation_delay'):
            self.schedule_escalation(incident_id, escalation_config['escalation_delay'])
    
    def generate_context_rich_alert(self, alert_data):
        """コンテキスト豊富なアラート情報生成"""
        
        context = {
            'basic_info': alert_data,
            'recent_deployments': self.get_recent_deployments(),
            'related_incidents': self.get_related_incidents(alert_data),
            'system_health': self.get_system_health_snapshot(),
            'business_impact': self.calculate_business_impact(alert_data)
        }
        
        # 推奨アクション生成
        context['recommended_actions'] = self.generate_recommended_actions(alert_data, context)
        
        return context

class AutoRemediation:
    """自動復旧処理クラス"""
    
    def restart_db_connections(self):
        """データベース接続再起動"""
        try:
            # 接続プール再起動
            db_pool.restart()
            
            # ヘルスチェック実行
            health_check = self.verify_db_health()
            
            newrelic.agent.record_custom_metric('Custom/Remediation/DB/Restart', 1)
            
            return {
                'success': health_check['healthy'],
                'action': 'database_connection_restart',
                'details': health_check
            }
            
        except Exception as e:
            return {'success': False, 'error': str(e)}
    
    def clear_cache_and_restart(self):
        """キャッシュクリア＆再起動"""
        try:
            # Redis キャッシュクリア
            redis_client.flushdb()
            
            # アプリケーションキャッシュクリア
            app_cache.clear()
            
            # Graceful restart
            os.kill(os.getpid(), signal.SIGUSR1)
            
            newrelic.agent.record_custom_metric('Custom/Remediation/Cache/Clear', 1)
            
            return {
                'success': True,
                'action': 'cache_clear_restart',
                'cleared_items': ['redis_cache', 'app_cache']
            }
            
        except Exception as e:
            return {'success': False, 'error': str(e)}
    
    def enable_fallback_service(self):
        """フォールバックサービス有効化"""
        try:
            # サーキットブレーカー有効化
            circuit_breaker.open()
            
            # キャッシュされた結果を返すよう設定
            fallback_service.enable()
            
            newrelic.agent.record_custom_metric('Custom/Remediation/Fallback/Enabled', 1)
            
            return {
                'success': True,
                'action': 'fallback_service_enabled',
                'fallback_type': 'cached_responses'
            }
            
        except Exception as e:
            return {'success': False, 'error': str(e)}