New Relic 分散トレーシング設定ガイド ​

import requests
import newrelic.agent

class OrderService:
    def process_payment(self, order):
        headers = {}
        
        # 分散トレーシング ヘッダーの追加
        newrelic.agent.insert_distributed_trace_headers(headers)
        
        response = requests.post(
            'http://payment-service/process',
            json={'amount': order.total_amount},
            headers=headers
        )
        
        return response.json()

from flask import Flask, request
import newrelic.agent

app = Flask(__name__)

@app.route('/api/payments/process', methods=['POST'])
def process_payment():
    # 分散トレーシング ヘッダーの受信
    headers = dict(request.headers)
    newrelic.agent.accept_distributed_trace_headers(headers)
    
    # ペイメント処理
    payment_data = request.get_json()
    result = payment_service.process(payment_data)
    
    return result

import newrelic.agent

class UserRepository:
    @newrelic.agent.datastore_trace('PostgreSQL', 'users', 'select')
    def find_user(self, user_id):
        with newrelic.agent.DatabaseTrace('PostgreSQL', 'SELECT', 'users'):
            # データベースクエリの実行
            cursor = self.connection.cursor()
            cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
            return cursor.fetchone()
    
    @newrelic.agent.datastore_trace('PostgreSQL', 'users', 'insert')
    def create_user(self, user_data):
        with newrelic.agent.DatabaseTrace('PostgreSQL', 'INSERT', 'users'):
            cursor = self.connection.cursor()
            cursor.execute(
                "INSERT INTO users (name, email) VALUES (%s, %s)",
                (user_data['name'], user_data['email'])
            )
            self.connection.commit()

import pika
import newrelic.agent

class MessageProducer:
    def __init__(self):
        self.connection = pika.BlockingConnection(
            pika.ConnectionParameters('localhost')
        )
        self.channel = self.connection.channel()
    
    def publish_message(self, queue_name, message):
        # 分散トレーシング ヘッダーの準備
        headers = {}
        newrelic.agent.insert_distributed_trace_headers(headers)
        
        properties = pika.BasicProperties(headers=headers)
        
        self.channel.basic_publish(
            exchange='',
            routing_key=queue_name,
            body=message,
            properties=properties
        )

class MessageConsumer:
    def __init__(self):
        self.connection = pika.BlockingConnection(
            pika.ConnectionParameters('localhost')
        )
        self.channel = self.connection.channel()
    
    def consume_messages(self, queue_name):
        def callback(ch, method, properties, body):
            # 分散トレーシング ヘッダーの受信
            headers = properties.headers or {}
            newrelic.agent.accept_distributed_trace_headers(headers)
            
            # メッセージ処理
            self.process_message(body.decode())
            
            ch.basic_ack(delivery_tag=method.delivery_tag)
        
        self.channel.basic_consume(
            queue=queue_name,
            on_message_callback=callback
        )
        
        self.channel.start_consuming()
    
    @newrelic.agent.background_task()
    def process_message(self, message):
        # メッセージ処理ロジック
        print(f"Processing message: {message}")

# Python でのOpenTelemetry統合
from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

# New Relic OTLP エンドポイント設定
otlp_exporter = OTLPSpanExporter(
    endpoint="https://otlp.nr-data.net:4317",
    headers={"api-key": "YOUR_LICENSE_KEY"}
)

# トレーサープロバイダーの設定
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

span_processor = BatchSpanProcessor(otlp_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# カスタムスパンの作成
def process_order(order_data):
    with tracer.start_as_current_span("order.process") as span:
        span.set_attribute("order.id", order_data["id"])
        span.set_attribute("order.amount", order_data["amount"])
        
        # 詳細な処理
        with tracer.start_as_current_span("order.validate"):
            validate_order(order_data)
        
        with tracer.start_as_current_span("order.save"):
            save_order(order_data)

# Python での効率的なトレース管理
import newrelic.agent
from functools import wraps

class TraceOptimizer:
    """トレース最適化管理クラス"""
    
    CRITICAL_OPERATIONS = {'payment', 'order', 'checkout', 'auth'}
    SKIP_OPERATIONS = {'health', 'metrics', 'status'}
    
    @classmethod
    def should_trace(cls, operation_name: str, error_occurred: bool = False) -> bool:
        """トレース対象判定"""
        if error_occurred:
            return True  # エラー時は常にトレース
            
        if any(skip in operation_name.lower() for skip in cls.SKIP_OPERATIONS):
            return False  # スキップ対象
            
        if any(critical in operation_name.lower() for critical in cls.CRITICAL_OPERATIONS):
            return True  # 重要な操作は常にトレース
            
        # その他は10%の確率
        import random
        return random.random() < 0.1

def intelligent_trace(operation_name: str):
    """インテリジェントトレースデコレータ"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            error_occurred = False
            
            try:
                result = func(*args, **kwargs)
                return result
            except Exception as e:
                error_occurred = True
                raise
            finally:
                # トレース対象判定
                if TraceOptimizer.should_trace(operation_name, error_occurred):
                    newrelic.agent.record_custom_event('OperationTrace', {
                        'operation_name': operation_name,
                        'error_occurred': error_occurred,
                        'traced': True
                    })
                    
        return wrapper
    return decorator

# 使用例
@intelligent_trace('payment_processing')
@newrelic.agent.function_trace()
def process_payment(payment_data):
    # 支払い処理ロジック
    pass