Python アプリケーション向け New Relic APM 設定ガイド ​

# settings.py
import newrelic.agent

# New Relic エージェントの初期化
newrelic.agent.initialize('/path/to/newrelic.ini')

# Django設定
INSTALLED_APPS = [
    # その他のアプリ
]

# ミドルウェア設定（任意）
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    # その他のミドルウェア
]

# wsgi.py
import os
import newrelic.agent

# New Relic設定の初期化
newrelic.agent.initialize()

from django.core.wsgi import get_wsgi_application

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

# WSGIアプリケーションのラップ
application = newrelic.agent.wsgi_application()(application)

# app.py
import newrelic.agent
newrelic.agent.initialize()

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run()

# main.py
import newrelic.agent
newrelic.agent.initialize()

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"Hello": "World"}

# ASGI アプリケーションのラップ
app = newrelic.agent.asgi_application()(app)

import os
from dotenv import load_dotenv
import newrelic.agent

# .envファイルの読み込み
load_dotenv()

# 環境変数からの設定
newrelic.agent.initialize()

import newrelic.agent

@newrelic.agent.function_trace()
def important_business_logic():
    # ビジネスロジック
    pass

@newrelic.agent.background_task()
def background_process():
    # バックグラウンド処理
    pass

import newrelic.agent

def record_business_metrics(order_data):
    # カスタムメトリクスの記録
    newrelic.agent.record_custom_metric('Custom/Revenue', order_data['amount'])
    newrelic.agent.record_custom_metric('Custom/OrdersProcessed', 1)
    
    # カスタムイベントの記録
    newrelic.agent.record_custom_event('OrderCompleted', {
        'order_id': order_data['id'],
        'amount': order_data['amount']
    })

import newrelic.agent
import sys
import os

def diagnose_newrelic():
    """New Relic エージェント診断"""
    
    print("=== New Relic Python エージェント診断 ===")
    
    # バージョン確認
    print(f"Agent version: {newrelic.agent.version}")
    print(f"Python version: {sys.version}")
    
    # 設定確認
    try:
        config = newrelic.agent.global_settings()
        print(f"App name: {config.app_name}")
        print(f"License key: {'*' * 32 + config.license_key[-8:] if config.license_key else 'Not set'}")
        print(f"Monitor mode: {config.monitor_mode}")
        print(f"High security: {config.high_security}")
        print(f"Log level: {config.log_level}")
    except Exception as e:
        print(f"Configuration error: {e}")
    
    # アプリケーション状態確認
    try:
        application = newrelic.agent.application()
        print(f"Application object: {application}")
        print(f"Application name: {application.name}")
        print(f"Active: {application.active}")
    except Exception as e:
        print(f"Application error: {e}")
    
    # 環境変数確認
    print("\n=== 環境変数 ===")
    env_vars = [
        'NEW_RELIC_LICENSE_KEY',
        'NEW_RELIC_APP_NAME', 
        'NEW_RELIC_ENVIRONMENT',
        'NEW_RELIC_CONFIG_FILE',
        'NEW_RELIC_LOG_LEVEL'
    ]
    
    for var in env_vars:
        value = os.environ.get(var, 'Not set')
        if 'LICENSE_KEY' in var and value != 'Not set':
            value = '*' * 32 + value[-8:]
        print(f"{var}: {value}")

# 診断実行
if __name__ == "__main__":
    diagnose_newrelic()

# settings.py
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    # New Relic ミドルウェアは静的ファイルミドルウェアの後に配置
    'django.middleware.common.CommonMiddleware',
    'newrelic.agent.django_middleware',  # ここに配置
    # その他のミドルウェア
]

# 静的ファイルのパスを除外
import newrelic.agent

@newrelic.agent.function_trace('StaticFileExclusion')
def static_file_filter(environ, start_response):
    """静的ファイルを New Relic 監視から除外"""
    path = environ.get('PATH_INFO', '')
    
    # 静的ファイルパスの場合は監視しない
    if path.startswith('/static/') or path.startswith('/media/'):
        newrelic.agent.ignore_transaction()
    
    return app(environ, start_response)

import newrelic.agent
import asyncio
from celery import Celery

# Celery タスクの監視
app = Celery('tasks')

@app.task
@newrelic.agent.background_task()  # 必須デコレータ
def async_task(param):
    # バックグラウンドタスク処理
    newrelic.agent.record_custom_metric('Custom/BackgroundTask', 1)
    return result

# asyncio タスクの監視
@newrelic.agent.background_task()
async def async_function():
    """非同期関数の監視"""
    with newrelic.agent.FunctionTrace('AsyncOperation'):
        await some_async_operation()
        
    # カスタムメトリクスの記録
    newrelic.agent.record_custom_metric('Custom/AsyncTask', 1)

# asyncio イベントループでの実行
async def main():
    await async_function()

if __name__ == "__main__":
    asyncio.run(main())

import newrelic.agent
from functools import wraps

def performance_monitor(threshold_seconds=1.0):
    """パフォーマンス閾値監視デコレータ"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            with newrelic.agent.FunctionTrace(f'Performance/{func.__name__}'):
                import time
                start_time = time.time()
                
                try:
                    result = func(*args, **kwargs)
                    duration = time.time() - start_time
                    
                    # 閾値を超えた場合の警告
                    if duration > threshold_seconds:
                        newrelic.agent.record_custom_metric(
                            'Custom/SlowFunction',
                            duration
                        )
                        
                        newrelic.agent.record_custom_event('SlowFunction', {
                            'function_name': func.__name__,
                            'duration': duration,
                            'threshold': threshold_seconds
                        })
                    
                    return result
                    
                except Exception as e:
                    newrelic.agent.notice_error(attributes={
                        'function_name': func.__name__,
                        'error_type': type(e).__name__
                    })
                    raise
                    
        return wrapper
    return decorator

# 使用例
@performance_monitor(threshold_seconds=0.5)
def slow_database_operation():
    """データベース処理の監視"""
    # 処理内容
    pass