// structured-logger.ts — 構造化ログの実装
import { pino } from 'pino';
 
// 構造化ログの基本設定
const logger = pino({
  level: process.env.LOG_LEVEL ?? 'info',
  formatters: {
    level(label) {
      return { level: label };
    },
  },
  timestamp: pino.stdTimeFunctions.isoTime,
  base: {
    service: 'user-service',
    version: process.env.APP_VERSION ?? 'unknown',
    environment: process.env.NODE_ENV ?? 'development',
  },
  // 本番では JSON、開発では見やすい形式
  transport: process.env.NODE_ENV !== 'production'
    ? { target: 'pino-pretty', options: { colorize: true } }
    : undefined,
});
 
// リクエストコンテキスト付きの子ロガー
function createRequestLogger(req: {
  id: string;
  method: string;
  url: string;
  userId?: string;
}) {
  return logger.child({
    requestId: req.id,
    method: req.method,
    url: req.url,
    userId: req.userId,
  });
}
 
// 使用例
const reqLogger = createRequestLogger({
  id: 'req-abc123',
  method: 'POST',
  url: '/api/orders',
  userId: 'user-456',
});
 
reqLogger.info({ orderId: 'order-789' }, 'Order created successfully');
// 出力 (JSON):
// {
//   "level": "info",
//   "time": "2025-03-15T10:30:00.000Z",
//   "service": "user-service",
//   "version": "1.2.3",
//   "environment": "production",
//   "requestId": "req-abc123",
//   "method": "POST",
//   "url": "/api/orders",
//   "userId": "user-456",
//   "orderId": "order-789",
//   "msg": "Order created successfully"
// }
 
reqLogger.error(
  { err: new Error('Payment failed'), orderId: 'order-789' },
  'Failed to process payment'
);

// request-logging-middleware.ts — リクエスト/レスポンスログ
import { Request, Response, NextFunction } from 'express';
import { pino } from 'pino';
import { v4 as uuidv4 } from 'uuid';
 
const logger = pino({
  level: process.env.LOG_LEVEL ?? 'info',
  base: { service: 'api-gateway' },
});
 
// センシティブデータのマスキング
function maskSensitiveHeaders(headers: Record<string, string>): Record<string, string> {
  const masked = { ...headers };
  const sensitiveKeys = ['authorization', 'cookie', 'x-api-key'];
 
  for (const key of sensitiveKeys) {
    if (masked[key]) {
      masked[key] = '***REDACTED***';
    }
  }
  return masked;
}
 
// リクエストログミドルウェア
export function requestLogger(req: Request, res: Response, next: NextFunction) {
  // リクエストID の生成/伝播
  const requestId = req.headers['x-request-id'] as string ?? uuidv4();
  req.headers['x-request-id'] = requestId;
  res.setHeader('x-request-id', requestId);
 
  const startTime = process.hrtime.bigint();
 
  // 子ロガーの作成
  const reqLogger = logger.child({
    requestId,
    method: req.method,
    url: req.url,
    userAgent: req.headers['user-agent'],
    ip: req.ip,
  });
 
  // リクエスト開始ログ
  reqLogger.info(
    { headers: maskSensitiveHeaders(req.headers as Record<string, string>) },
    'Request received'
  );
 
  // レスポンス完了時のログ
  res.on('finish', () => {
    const durationNs = process.hrtime.bigint() - startTime;
    const durationMs = Number(durationNs) / 1_000_000;
 
    const logData = {
      statusCode: res.statusCode,
      duration: Math.round(durationMs * 100) / 100,
      contentLength: res.getHeader('content-length'),
    };
 
    if (res.statusCode >= 500) {
      reqLogger.error(logData, 'Request failed (5xx)');
    } else if (res.statusCode >= 400) {
      reqLogger.warn(logData, 'Request failed (4xx)');
    } else {
      reqLogger.info(logData, 'Request completed');
    }
  });
 
  next();
}

# structured_logger.py — Python での構造化ログ
import logging
import json
import sys
import uuid
from datetime import datetime, timezone
from contextvars import ContextVar
from fastapi import FastAPI, Request, Response
from starlette.middleware.base import BaseHTTPMiddleware
import time
 
# コンテキスト変数でリクエストIDを伝播
request_id_var: ContextVar[str] = ContextVar('request_id', default='')
 
class JSONFormatter(logging.Formatter):
    """JSON 形式のログフォーマッター"""
 
    def format(self, record: logging.LogRecord) -> str:
        log_data = {
            'timestamp': datetime.now(timezone.utc).isoformat(),
            'level': record.levelname.lower(),
            'message': record.getMessage(),
            'service': 'order-service',
            'logger': record.name,
            'request_id': request_id_var.get(''),
        }
 
        # エラー情報の追加
        if record.exc_info:
            log_data['error'] = {
                'type': record.exc_info[0].__name__ if record.exc_info[0] else None,
                'message': str(record.exc_info[1]) if record.exc_info[1] else None,
            }
 
        # 追加フィールド
        if hasattr(record, 'extra_fields'):
            log_data.update(record.extra_fields)
 
        return json.dumps(log_data, ensure_ascii=False)
 
 
def setup_logger(name: str = 'app') -> logging.Logger:
    """構造化ログのセットアップ"""
    logger = logging.getLogger(name)
    logger.setLevel(logging.DEBUG)
 
    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(JSONFormatter())
    logger.addHandler(handler)
 
    return logger
 
 
class RequestLoggingMiddleware(BaseHTTPMiddleware):
    """リクエストログミドルウェア"""
 
    def __init__(self, app: FastAPI):
        super().__init__(app)
        self.logger = setup_logger('http')
 
    async def dispatch(self, request: Request, call_next) -> Response:
        request_id = request.headers.get('x-request-id', str(uuid.uuid4()))
        request_id_var.set(request_id)
 
        start_time = time.perf_counter()
 
        self.logger.info(
            'Request received',
            extra={'extra_fields': {
                'method': request.method,
                'url': str(request.url),
                'client_ip': request.client.host if request.client else None,
            }}
        )
 
        response = await call_next(request)
        duration_ms = (time.perf_counter() - start_time) * 1000
 
        response.headers['x-request-id'] = request_id
 
        self.logger.info(
            'Request completed',
            extra={'extra_fields': {
                'method': request.method,
                'url': str(request.url),
                'status_code': response.status_code,
                'duration_ms': round(duration_ms, 2),
            }}
        )
 
        return response

// otel-setup.ts — OpenTelemetry の初期化
import { NodeSDK } from '@opentelemetry/sdk-node';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
import { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
import { Resource } from '@opentelemetry/resources';
import {
  ATTR_SERVICE_NAME,
  ATTR_SERVICE_VERSION,
} from '@opentelemetry/semantic-conventions';
 
const sdk = new NodeSDK({
  resource: new Resource({
    [ATTR_SERVICE_NAME]: 'order-service',
    [ATTR_SERVICE_VERSION]: process.env.APP_VERSION ?? '0.0.0',
    'deployment.environment': process.env.NODE_ENV ?? 'development',
    'service.namespace': 'myapp',
    'host.name': process.env.HOSTNAME ?? 'unknown',
  }),
 
  // トレースのエクスポーター
  traceExporter: new OTLPTraceExporter({
    url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? 'http://localhost:4318/v1/traces',
  }),
 
  // メトリクスのエクスポーター
  metricReader: new PeriodicExportingMetricReader({
    exporter: new OTLPMetricExporter({
      url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? 'http://localhost:4318/v1/metrics',
    }),
    exportIntervalMillis: 60000, // 60秒ごとにエクスポート
  }),
 
  // ログのエクスポーター
  logRecordProcessor: new BatchLogRecordProcessor(
    new OTLPLogExporter({
      url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? 'http://localhost:4318/v1/logs',
    })
  ),
 
  // 自動計装 (HTTP, Express, pg, redis 等)
  instrumentations: [
    getNodeAutoInstrumentations({
      '@opentelemetry/instrumentation-fs': { enabled: false },
      '@opentelemetry/instrumentation-http': {
        ignoreIncomingRequestHook: (req) => {
          // ヘルスチェックはトレースしない
          return req.url === '/health' || req.url === '/readyz';
        },
      },
    }),
  ],
});
 
sdk.start();
console.log('OpenTelemetry SDK initialized');
 
// シャットダウン処理
process.on('SIGTERM', async () => {
  await sdk.shutdown();
  console.log('OpenTelemetry SDK shut down');
  process.exit(0);
});

// custom-spans.ts — カスタムスパンの作成
import { trace, SpanStatusCode, Span } from '@opentelemetry/api';
import { metrics } from '@opentelemetry/api';
 
const tracer = trace.getTracer('order-service');
 
// カスタムメトリクスの定義
const meter = metrics.getMeter('order-service');
 
const orderCounter = meter.createCounter('orders.created', {
  description: '作成された注文の総数',
  unit: '1',
});
 
const orderDuration = meter.createHistogram('orders.processing_duration', {
  description: '注文処理にかかった時間',
  unit: 'ms',
});
 
const activeOrders = meter.createUpDownCounter('orders.active', {
  description: '処理中の注文数',
  unit: '1',
});
 
const orderValue = meter.createHistogram('orders.value', {
  description: '注文金額の分布',
  unit: 'JPY',
});
 
// カスタムスパン付きのビジネスロジック
async function createOrder(input: OrderInput): Promise<Order> {
  return tracer.startActiveSpan('createOrder', async (span: Span) => {
    const startTime = Date.now();
    activeOrders.add(1);
 
    try {
      span.setAttribute('order.customer_id', input.customerId);
      span.setAttribute('order.item_count', input.items.length);
      span.setAttribute('order.payment_method', input.paymentMethod);
 
      // 在庫確認スパン
      const inventory = await tracer.startActiveSpan(
        'checkInventory',
        async (inventorySpan) => {
          const result = await inventoryService.check(input.items);
          inventorySpan.setAttribute('inventory.available', result.available);
          inventorySpan.setAttribute('inventory.items_checked', input.items.length);
          inventorySpan.end();
          return result;
        }
      );
 
      if (!inventory.available) {
        span.setStatus({ code: SpanStatusCode.ERROR, message: 'Out of stock' });
        throw new Error('在庫不足');
      }
 
      // 決済処理スパン
      const payment = await tracer.startActiveSpan(
        'processPayment',
        async (paymentSpan) => {
          paymentSpan.setAttribute('payment.method', input.paymentMethod);
          paymentSpan.setAttribute('payment.amount', input.totalAmount);
          const result = await paymentService.charge(input);
          paymentSpan.setAttribute('payment.transaction_id', result.transactionId);
          paymentSpan.end();
          return result;
        }
      );
 
      const order = await orderRepository.save({
        ...input,
        transactionId: payment.transactionId,
        status: 'confirmed',
      });
 
      // メトリクス記録
      orderCounter.add(1, {
        status: 'success',
        payment_method: input.paymentMethod,
      });
      orderDuration.record(Date.now() - startTime, { status: 'success' });
      orderValue.record(input.totalAmount, {
        payment_method: input.paymentMethod,
      });
 
      span.setAttribute('order.id', order.id);
      span.setStatus({ code: SpanStatusCode.OK });
 
      return order;
    } catch (error) {
      span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
      span.recordException(error as Error);
      orderCounter.add(1, { status: 'failure' });
      orderDuration.record(Date.now() - startTime, { status: 'failure' });
      throw error;
    } finally {
      activeOrders.add(-1);
      span.end();
    }
  });
}

// context-propagation.ts — サービス間のコンテキスト伝播
import { context, propagation, trace } from '@opentelemetry/api';
 
// HTTP クライアントでのコンテキスト伝播 (送信側)
async function callExternalService(url: string, body: object): Promise<Response> {
  const headers: Record<string, string> = {
    'Content-Type': 'application/json',
  };
 
  // 現在のコンテキストからトレースヘッダーを注入
  // W3C Trace Context: traceparent, tracestate
  propagation.inject(context.active(), headers);
 
  // ヘッダーに以下が追加される:
  // traceparent: 00-<trace-id>-<span-id>-01
  // tracestate: vendor=value
 
  return fetch(url, {
    method: 'POST',
    headers,
    body: JSON.stringify(body),
  });
}
 
// HTTP サーバーでのコンテキスト抽出 (受信側)
function extractContext(req: Request): void {
  // リクエストヘッダーからトレースコンテキストを抽出
  const extractedContext = propagation.extract(context.active(), req.headers);
 
  // このコンテキスト内でスパンを作成すると
  // 親スパンと自動的にリンクされる
  const tracer = trace.getTracer('my-service');
  const span = tracer.startSpan('handleRequest', {}, extractedContext);
 
  // 処理...
  span.end();
}

# otel-collector-config.yaml
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318
 
  # ホストメトリクスの自動収集
  hostmetrics:
    collection_interval: 30s
    scrapers:
      cpu:
      memory:
      disk:
      network:
 
  # Prometheus メトリクスのスクレイプ
  prometheus:
    config:
      scrape_configs:
        - job_name: 'app-metrics'
          scrape_interval: 15s
          static_configs:
            - targets: ['app:3000']
 
processors:
  batch:
    timeout: 10s
    send_batch_size: 1024
 
  memory_limiter:
    check_interval: 5s
    limit_mib: 512
    spike_limit_mib: 128
 
  attributes:
    actions:
      - key: environment
        value: production
        action: upsert
 
  # センシティブデータのフィルタリング
  attributes/remove-sensitive:
    actions:
      - key: http.request.header.authorization
        action: delete
      - key: http.request.header.cookie
        action: delete
      - key: db.statement
        action: hash  # SQL をハッシュ化
 
  # テールサンプリング (エラーと遅いリクエストを優先)
  tail_sampling:
    decision_wait: 10s
    num_traces: 100
    policies:
      - name: errors
        type: status_code
        status_code:
          status_codes: [ERROR]
      - name: slow-requests
        type: latency
        latency:
          threshold_ms: 1000
      - name: random-sample
        type: probabilistic
        probabilistic:
          sampling_percentage: 10
 
exporters:
  otlp/jaeger:
    endpoint: jaeger:4317
    tls:
      insecure: true
 
  prometheus:
    endpoint: 0.0.0.0:8889
    namespace: myapp
 
  loki:
    endpoint: http://loki:3100/loki/api/v1/push
 
  debug:
    verbosity: detailed
 
service:
  extensions: [health_check, pprof, zpages]
  pipelines:
    traces:
      receivers: [otlp]
      processors: [memory_limiter, tail_sampling, batch, attributes]
      exporters: [otlp/jaeger]
    metrics:
      receivers: [otlp, hostmetrics, prometheus]
      processors: [memory_limiter, batch]
      exporters: [prometheus]
    logs:
      receivers: [otlp]
      processors: [memory_limiter, attributes/remove-sensitive, batch]
      exporters: [loki]
 
  telemetry:
    logs:
      level: info
    metrics:
      address: 0.0.0.0:8888

# docker-compose.observability.yml
version: "3.8"
 
services:
  # OpenTelemetry Collector
  otel-collector:
    image: otel/opentelemetry-collector-contrib:0.96.0
    command: ["--config=/etc/otel-collector-config.yaml"]
    volumes:
      - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml
    ports:
      - "4317:4317"   # OTLP gRPC
      - "4318:4318"   # OTLP HTTP
      - "8889:8889"   # Prometheus exporter
    depends_on:
      - jaeger
      - loki
 
  # Jaeger (分散トレーシング)
  jaeger:
    image: jaegertracing/all-in-one:1.54
    ports:
      - "16686:16686"  # UI
      - "14250:14250"  # gRPC
    environment:
      - COLLECTOR_OTLP_ENABLED=true
 
  # Prometheus (メトリクス)
  prometheus:
    image: prom/prometheus:v2.50.0
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
 
  # Loki (ログ集約)
  loki:
    image: grafana/loki:2.9.0
    ports:
      - "3100:3100"
 
  # Grafana (可視化)
  grafana:
    image: grafana/grafana:10.3.0
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
      - GF_AUTH_ANONYMOUS_ENABLED=true
    volumes:
      - ./grafana/provisioning:/etc/grafana/provisioning
    depends_on:
      - prometheus
      - jaeger
      - loki

// slo-definitions.ts — SLI/SLO の定義例
interface SLI {
  name: string;
  description: string;
  query: string;        // PromQL クエリ
  unit: string;
}
 
interface BurnRateAlert {
  severity: string;
  shortWindow: string;
  longWindow: string;
  factor: number;
}
 
interface SLO {
  name: string;
  sli: SLI;
  target: number;       // 例: 0.999 = 99.9%
  window: string;       // 例: '30d'
  burnRateAlerts: BurnRateAlert[];
}
 
// 可用性 SLI
const availabilitySLI: SLI = {
  name: 'availability',
  description: 'HTTP リクエストの成功率',
  query: `
    sum(rate(http_requests_total{status!~"5.."}[5m]))
    /
    sum(rate(http_requests_total[5m]))
  `,
  unit: 'ratio',
};
 
// レイテンシ SLI
const latencySLI: SLI = {
  name: 'latency',
  description: 'p99 レイテンシが 500ms 以内のリクエスト割合',
  query: `
    sum(rate(http_request_duration_seconds_bucket{le="0.5"}[5m]))
    /
    sum(rate(http_request_duration_seconds_count[5m]))
  `,
  unit: 'ratio',
};
 
// スループット SLI
const throughputSLI: SLI = {
  name: 'throughput',
  description: '1秒あたりの処理リクエスト数',
  query: `sum(rate(http_requests_total[5m]))`,
  unit: 'requests/sec',
};
 
// SLO 定義
const apiAvailabilitySLO: SLO = {
  name: 'API Availability',
  sli: availabilitySLI,
  target: 0.999,  // 99.9%
  window: '30d',  // 30日間のローリングウィンドウ
  burnRateAlerts: [
    { severity: 'critical', shortWindow: '5m', longWindow: '1h', factor: 14.4 },
    { severity: 'warning',  shortWindow: '30m', longWindow: '6h', factor: 6 },
    { severity: 'ticket',   shortWindow: '6h', longWindow: '3d', factor: 1 },
  ],
};
 
const apiLatencySLO: SLO = {
  name: 'API Latency',
  sli: latencySLI,
  target: 0.99,  // 99%
  window: '30d',
  burnRateAlerts: [
    { severity: 'critical', shortWindow: '5m', longWindow: '1h', factor: 14.4 },
    { severity: 'warning',  shortWindow: '30m', longWindow: '6h', factor: 6 },
  ],
};

# grafana/dashboards/slo-dashboard.json (概要)
# SLO ダッシュボードに含めるべきパネル:
#
# 1. 現在の SLI 値 (Stat パネル)
#    - 可用性: 99.95% (目標: 99.9%)
#    - レイテンシ p99: 350ms (目標: 500ms)
#
# 2. エラーバジェット残量 (Gauge パネル)
#    - 残り: 65% (28分)
#
# 3. エラーバジェットの推移 (Time series パネル)
#    - 30日間のバーンダウンチャート
#
# 4. バーンレート (Time series パネル)
#    - 1h, 6h, 3d のウィンドウでのバーンレート
#
# 5. SLI の時系列推移 (Time series パネル)
#    - 可用性とレイテンシの推移グラフ

# SLO ダッシュボード用 PromQL クエリ
 
# 1. 現在の可用性 (30日ローリング)
1 - (
  sum(increase(http_requests_total{status=~"5.."}[30d]))
  /
  sum(increase(http_requests_total[30d]))
)
 
# 2. エラーバジェット残量 (%)
(
  1 - (
    sum(increase(http_requests_total{status=~"5.."}[30d]))
    /
    sum(increase(http_requests_total[30d]))
  )
  - 0.999
) / 0.001 * 100
 
# 3. バーンレート (1時間ウィンドウ)
(
  sum(rate(http_requests_total{status=~"5.."}[1h]))
  /
  sum(rate(http_requests_total[1h]))
) / 0.001
 
# 4. p99 レイテンシ
histogram_quantile(0.99,
  sum(rate(http_request_duration_seconds_bucket[5m])) by (le)
)

// 悪い例: 非構造化ログ
console.log('User ' + userId + ' created order ' + orderId + ' at ' + new Date());
console.log('Error: ' + err.message);
 
// → 検索困難、パース不能、コンテキスト不足
 
// 良い例: 構造化ログ
logger.info({
  event: 'order_created',
  userId,
  orderId,
  timestamp: new Date().toISOString(),
}, 'Order created successfully');
 
logger.error({
  event: 'order_failed',
  err,
  userId,
  orderId,
}, 'Failed to create order');
 
// → JSON で構造化、フィールドで検索・フィルタ可能

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md