// tracing.ts - アプリケーション起動前にインポート
import { NodeSDK } from '@opentelemetry/sdk-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { Resource } from '@opentelemetry/resources';
import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';

const traceExporter = new OTLPTraceExporter({
  url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318/v1/traces',
});

const sdk = new NodeSDK({
  resource: new Resource({
    [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || 'order-service',
    [ATTR_SERVICE_VERSION]: process.env.APP_VERSION || '1.0.0',
    'deployment.environment': process.env.NODE_ENV || 'development',
  }),
  spanProcessors: [new BatchSpanProcessor(traceExporter)],
  instrumentations: [
    getNodeAutoInstrumentations({
      '@opentelemetry/instrumentation-http': { enabled: true },
      '@opentelemetry/instrumentation-express': { enabled: true },
      '@opentelemetry/instrumentation-pg': { enabled: true },
    }),
  ],
});

sdk.start();

process.on('SIGTERM', () => {
  sdk.shutdown().then(() => process.exit(0));
});

export { sdk };

// index.ts
import './tracing'; // 最初にインポート
import express from 'express';
// ... アプリケーションコード

import { trace, SpanStatusCode, SpanKind } from '@opentelemetry/api';

const tracer = trace.getTracer('order-service', '1.0.0');

async function createOrder(input: OrderInput): Promise<Order> {
  return tracer.startActiveSpan('order.create', {
    kind: SpanKind.INTERNAL,
    attributes: {
      'order.items_count': input.items.length,
      'order.customer_id': input.customerId,
    },
  }, async (span) => {
    try {
      // バリデーション
      await tracer.startActiveSpan('order.validate', async (validateSpan) => {
        validateOrderInput(input);
        validateSpan.end();
      });

      // 在庫確認
      const stockAvailable = await tracer.startActiveSpan('order.checkInventory', async (invSpan) => {
        const result = await inventoryService.checkStock(input.items);
        invSpan.setAttribute('inventory.all_available', result.allAvailable);
        invSpan.end();
        return result;
      });

      // 注文保存
      const order = await tracer.startActiveSpan('order.save', async (saveSpan) => {
        const result = await orderRepository.create(input);
        saveSpan.setAttribute('order.id', result.id);
        saveSpan.setAttribute('order.total', result.total);
        saveSpan.end();
        return result;
      });

      // 決済処理
      await tracer.startActiveSpan('order.processPayment', async (paySpan) => {
        paySpan.setAttribute('payment.amount', order.total);
        await paymentService.charge(order);
        paySpan.end();
      });

      span.setAttribute('order.id', order.id);
      span.setAttribute('order.total', order.total);
      span.setStatus({ code: SpanStatusCode.OK });
      return order;

    } catch (error) {
      span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
      span.recordException(error);
      throw error;
    } finally {
      span.end();
    }
  });
}

import { context, propagation, trace, SpanKind } from '@opentelemetry/api';

const tracer = trace.getTracer('order-service');

// HTTP呼び出し時のコンテキスト伝搬
async function callPaymentService(orderId: string, amount: number): Promise<PaymentResult> {
  return tracer.startActiveSpan('http.client.POST /charge', {
    kind: SpanKind.CLIENT,
    attributes: {
      'http.method': 'POST',
      'http.url': 'http://payment-service:8082/charge',
      'peer.service': 'payment-service',
    },
  }, async (span) => {
    // 現在のコンテキストからHTTPヘッダーに注入
    const headers: Record<string, string> = {
      'Content-Type': 'application/json',
    };
    propagation.inject(context.active(), headers);

    try {
      const response = await fetch('http://payment-service:8082/charge', {
        method: 'POST',
        headers,
        body: JSON.stringify({ orderId, amount }),
      });

      span.setAttribute('http.status_code', response.status);

      if (!response.ok) {
        throw new Error(`Payment failed: ${response.status}`);
      }

      span.setStatus({ code: SpanStatusCode.OK });
      return await response.json();
    } catch (error) {
      span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
      span.recordException(error);
      throw error;
    } finally {
      span.end();
    }
  });
}

// 受信側: Expressミドルウェアでコンテキストを抽出
// (自動計装を使えば不要だが、仕組みの理解として)
function traceContextMiddleware(req: Request, res: Response, next: NextFunction) {
  const extractedContext = propagation.extract(context.active(), req.headers);
  context.with(extractedContext, () => {
    next();
  });
}

// サンプリング戦略設計書
const samplingStrategy = {
  approach: 'Tail-based sampling (OTel Collector)',

  rules: [
    { condition: 'エラーが発生したトレース', sampleRate: '100%', reason: '障害調査に必須' },
    { condition: 'レスポンス2秒以上のトレース', sampleRate: '100%', reason: 'ボトルネック分析に必須' },
    { condition: 'ヘルスチェック (/health)', sampleRate: '0%', reason: 'ノイズ排除' },
    { condition: 'その他の正常リクエスト', sampleRate: '5%', reason: 'コスト最適化' },
  ],

  estimatedVolume: {
    totalRequests: '1000 req/s',
    errorRate: '0.5% → 5 traces/s (100%)',
    slowRequests: '1% → 10 traces/s (100%)',
    normalSampled: '985 req/s × 5% → ~49 traces/s',
    totalTraces: '~64 traces/s',
    storageEstimate: '~5.5M traces/day → ~55GB/day',
  },

  collectorConfig: `
    processors:
      tail_sampling:
        decision_wait: 10s
        policies:
          - name: errors
            type: status_code
            status_code: { status_codes: [ERROR] }
          - name: slow-requests
            type: latency
            latency: { threshold_ms: 2000 }
          - name: health-check-drop
            type: string_attribute
            string_attribute:
              key: http.target
              values: ["/health", "/ready"]
              enabled_regex_matching: false
              invert_match: true
          - name: probabilistic
            type: probabilistic
            probabilistic: { sampling_percentage: 5 }
  `,
};

# ボトルネック分析レポート

## 問題1: 外部API遅延（critical）
- **箇所**: payment.charge → stripe.api (3750ms / 4200ms = 89%)
- **原因**: Stripe APIのレスポンスが極端に遅い
- **改善案**:
  1. タイムアウトを3秒に設定
  2. サーキットブレーカーを導入
  3. Stripe APIの代替プロバイダをフォールバックとして用意

## 問題2: N+1 + 直列呼び出し（warning）
- **箇所**: inventory.check が4回個別に呼ばれている (合計155ms)
- **原因**: カート内アイテムごとに在庫チェックを直列実行
- **改善案**:
  1. バッチAPI (POST /inventory/check-batch) を作成
  2. 1回のリクエストで全アイテムの在庫を確認 → 40ms程度に短縮

## 問題3: 通知の同期実行（info）
- **箇所**: notification.send (50ms)
- **原因**: 注文作成のレスポンスに通知完了を含めている
- **改善案**:
  1. メッセージキューに非同期化
  2. レスポンスタイムを50ms短縮

## 改善後の予想レスポンスタイム
- 現在: 4200ms
- payment改善後: ~450ms (タイムアウト3s設定、正常時)
- inventory改善後: -115ms
- notification改善後: -50ms
- 目標: ~300ms (正常時)

const serviceMap = {
  services: [
    { name: 'api-gateway', type: 'internal', criticality: 'critical' },
    { name: 'auth-service', type: 'internal', criticality: 'critical' },
    { name: 'order-service', type: 'internal', criticality: 'critical' },
    { name: 'payment-service', type: 'internal', criticality: 'critical' },
    { name: 'inventory-service', type: 'internal', criticality: 'high' },
    { name: 'notification-service', type: 'internal', criticality: 'low' },
    { name: 'stripe-api', type: 'external', criticality: 'critical' },
  ],

  riskAnalysis: {
    singlePointOfFailure: [
      'auth-service: 全リクエストが通過 → キャッシュ+レプリカで対策',
      'stripe-api: 外部依存 → フォールバック決済プロバイダを用意',
    ],
    cascadeFailure: [
      'stripe障害 → payment障害 → order障害 → 全注文停止',
      '対策: サーキットブレーカー + タイムアウト + フォールバック',
    ],
    degradation: [
      'notification障害時: 注文は成功、通知は後で再送',
      'inventory障害時: 楽観的に注文受付、後で在庫確認',
    ],
  },
};