エピローグ — スケーリングの判断基準

# app/services/scaling_signal_detector.rb
class ScalingSignalDetector
  THRESHOLDS = {
    response_time_p95:     1000,   # P95 が 1秒を超えたら
    response_time_p99:     3000,   # P99 が 3秒を超えたら
    error_rate:            0.01,   # エラー率が 1% を超えたら
    cpu_utilization:         70,   # CPU が 70% を超えたら
    memory_utilization:      80,   # メモリが 80% を超えたら
    db_connection_usage:     80,   # DB接続が 80% を超えたら
    cache_hit_rate:          80,   # キャッシュヒット率が 80% を下回ったら
    queue_depth:         10_000,   # キュー深度が 10,000 を超えたら
    slow_query_count:        100   # スロークエリが 100/分 を超えたら
  }
 
  def self.check_all
    signals = {
      response_time: check_response_time,
      error_rate:    check_error_rate,
      db:            check_db_connections,
      cache:         check_cache_hit_rate,
      queue:         check_queue_depth
    }
 
    alerts = signals.filter_map do |metric, data|
      data[:alert] ? "[ALERT] #{metric}: #{data[:message]}" : nil
    end
 
    result = { healthy: alerts.empty?, signals: signals, alerts: alerts }
 
    # Slackに通知
    if alerts.any?
      SlackNotifier.alert(
        channel: '#eng-alerts',
        message: "Scaling signals detected:\n#{alerts.join("\n")}"
      )
    end
 
    result
  end
 
  # CloudWatch から P95 を取得
  def self.check_response_time
    cloudwatch = Aws::CloudWatch::Client.new(region: ENV['AWS_REGION'])
 
    response = cloudwatch.get_metric_statistics(
      namespace:   'AWS/ApplicationELB',
      metric_name: 'TargetResponseTime',
      statistics:  ['p95'],
      period:      300,
      start_time:  5.minutes.ago,
      end_time:    Time.current,
      dimensions:  [{ name: 'LoadBalancer', value: ENV['ALB_ARN_SUFFIX'] }]
    )
 
    p95_ms = (response.datapoints.last&.extended_statistics&.[]('p95') || 0) * 1000
 
    {
      value:     p95_ms.round,
      threshold: THRESHOLDS[:response_time_p95],
      alert:     p95_ms > THRESHOLDS[:response_time_p95],
      message:   "P95 レスポンスタイム #{p95_ms.round}ms（閾値: #{THRESHOLDS[:response_time_p95]}ms）"
    }
  end
 
  # エラー率（5xx / 全リクエスト）
  def self.check_error_rate
    cloudwatch = Aws::CloudWatch::Client.new(region: ENV['AWS_REGION'])
 
    dim = [{ name: 'LoadBalancer', value: ENV['ALB_ARN_SUFFIX'] }]
    opts = { period: 300, start_time: 5.minutes.ago, end_time: Time.current, dimensions: dim }
 
    errors_5xx = cloudwatch.get_metric_statistics(
      namespace: 'AWS/ApplicationELB', metric_name: 'HTTPCode_Target_5XX_Count',
      statistics: ['Sum'], **opts
    ).datapoints.sum(&:sum)
 
    total = cloudwatch.get_metric_statistics(
      namespace: 'AWS/ApplicationELB', metric_name: 'RequestCount',
      statistics: ['Sum'], **opts
    ).datapoints.sum(&:sum)
 
    rate = total.positive? ? errors_5xx / total.to_f : 0.0
 
    {
      value:     (rate * 100).round(3),
      threshold: THRESHOLDS[:error_rate] * 100,
      alert:     rate > THRESHOLDS[:error_rate],
      message:   "エラー率 #{(rate * 100).round(2)}%（閾値: #{THRESHOLDS[:error_rate] * 100}%）"
    }
  end
 
  # RDS接続数使用率
  def self.check_db_connections
    cloudwatch = Aws::CloudWatch::Client.new(region: ENV['AWS_REGION'])
 
    current = cloudwatch.get_metric_statistics(
      namespace:   'AWS/RDS',
      metric_name: 'DatabaseConnections',
      statistics:  ['Average'],
      period:      300,
      start_time:  5.minutes.ago,
      end_time:    Time.current,
      dimensions:  [{ name: 'DBClusterIdentifier', value: ENV['AURORA_CLUSTER_ID'] }]
    ).datapoints.last&.average || 0
 
    max_connections = 1000  # db.r7g.large の max_connections
    usage_pct = (current / max_connections.to_f * 100).round
 
    {
      value:     usage_pct,
      threshold: THRESHOLDS[:db_connection_usage],
      alert:     usage_pct > THRESHOLDS[:db_connection_usage],
      message:   "DB接続使用率 #{usage_pct}%（#{current.round}/#{max_connections}）"
    }
  end
 
  # Redis キャッシュヒット率
  def self.check_cache_hit_rate
    info = $redis.info('stats')
    hits   = info['keyspace_hits'].to_i
    misses = info['keyspace_misses'].to_i
    total  = hits + misses
 
    hit_rate = total.positive? ? (hits / total.to_f * 100).round : 100.0
 
    {
      value:     hit_rate,
      threshold: THRESHOLDS[:cache_hit_rate],
      alert:     hit_rate < THRESHOLDS[:cache_hit_rate],
      message:   "キャッシュヒット率 #{hit_rate}%（閾値: #{THRESHOLDS[:cache_hit_rate]}%以上）"
    }
  end
 
  # Sidekiq キュー深度
  def self.check_queue_depth
    stats = Sidekiq::Stats.new
    total_enqueued = stats.enqueued
 
    {
      value:     total_enqueued,
      threshold: THRESHOLDS[:queue_depth],
      alert:     total_enqueued > THRESHOLDS[:queue_depth],
      message:   "キュー深度 #{total_enqueued}（閾値: #{THRESHOLDS[:queue_depth]}）"
    }
  end
end

# app/jobs/scaling_monitor_job.rb
class ScalingMonitorJob < ApplicationJob
  queue_as :monitoring
 
  def perform
    result = ScalingSignalDetector.check_all
 
    # CloudWatch カスタムメトリクスとして送信
    cloudwatch = Aws::CloudWatch::Client.new(region: ENV['AWS_REGION'])
 
    metric_data = result[:signals].map do |name, data|
      {
        metric_name: "BuzzScalingSignal_#{name}",
        value:       data[:value].to_f,
        unit:        'None',
        timestamp:   Time.current,
        dimensions:  [{ name: 'Environment', value: Rails.env }]
      }
    end
 
    cloudwatch.put_metric_data(
      namespace:   'Buzz/Scaling',
      metric_data: metric_data
    )
  end
end
 
# config/sidekiq.yml
:schedule:
  scaling_monitor:
    cron: '* * * * *'   # 毎分
    class: ScalingMonitorJob

# app/services/scaling_cost_calculator.rb
class ScalingCostCalculator
  # 各スケーリング手法の月額コスト試算
  AWS_PRICING = {
    # EC2 / Fargate
    fargate_vcpu_hour:     0.04048,  # vCPU/時間
    fargate_gb_hour:       0.004445, # GB/時間
 
    # RDS / Aurora
    aurora_r7g_large_hour:  0.260,
    aurora_r7g_xlarge_hour: 0.520,
 
    # ElastiCache
    elasticache_r7g_large_hour: 0.182,
 
    # 転送料金
    data_transfer_gb:       0.020,   # リージョン間
 
    # OpenSearch
    opensearch_r7g_medium_hour: 0.111
  }
 
  def self.compare_options(current_rps:, target_rps:)
    scale_factor = (target_rps.to_f / current_rps).ceil
 
    {
      option_a_optimize_code: {
        description: "コード最適化（N+1解消・クエリ改善）",
        monthly_cost: 0,  # エンジニアコストは別
        rps_gain:    "2〜5倍（現状による）",
        implementation_days: 3,
        risk: :low,
        note: "最初に試みること。お金がかからない"
      },
 
      option_b_add_cache: {
        description: "ElastiCacheノード追加",
        monthly_cost: (AWS_PRICING[:elasticache_r7g_large_hour] * 24 * 30).round,
        rps_gain:    "3〜10倍（キャッシュヒット率次第）",
        implementation_days: 1,
        risk: :low,
        note: "読み取り重視のワークロードに有効"
      },
 
      option_c_add_read_replica: {
        description: "Aurora Read Replica 追加",
        monthly_cost: (AWS_PRICING[:aurora_r7g_large_hour] * 24 * 30).round,
        rps_gain:    "2〜3倍（読み取りが多い場合）",
        implementation_days: 1,
        risk: :low,
        note: "読み取り: 書き込み = 9:1 以上なら特に有効"
      },
 
      option_d_scale_out_fargate: {
        description: "Fargateタスク数を#{scale_factor}倍に増やす",
        monthly_cost: (
          AWS_PRICING[:fargate_vcpu_hour] * 2 * scale_factor * 24 * 30 +
          AWS_PRICING[:fargate_gb_hour]   * 4 * scale_factor * 24 * 30
        ).round,
        rps_gain:    "#{scale_factor}倍（ほぼ線形）",
        implementation_days: 0,  # Auto Scalingが自動でやる
        risk: :low,
        note: "アプリがステートレスなら簡単。ボトルネックがDBの場合は効果なし"
      },
 
      option_e_vertical_aurora: {
        description: "Aurora を r7g.large → r7g.xlarge にスケールアップ",
        monthly_cost: (
          (AWS_PRICING[:aurora_r7g_xlarge_hour] - AWS_PRICING[:aurora_r7g_large_hour]) * 24 * 30
        ).round,
        rps_gain:    "1.5〜2倍（CPUバウンドの場合）",
        implementation_days: 0,  # 数分でダウンタイムなし変更可
        risk: :low,
        note: "Aurora は停止なしでインスタンスタイプ変更可能"
      },
 
      option_f_sharding: {
        description: "データベースの水平シャーディング",
        monthly_cost: (AWS_PRICING[:aurora_r7g_large_hour] * 24 * 30 * 3).round,  # 3クラスター追加
        rps_gain:    "4倍以上（理論上は無制限）",
        implementation_days: 90,  # 3ヶ月の大型プロジェクト
        risk: :high,
        note: "最後の手段。クロスシャードクエリが不可能になる。技術的負債が大きい"
      }
    }
  end
 
  def self.recommend(current_rps:, target_rps:, bottleneck:)
    options = compare_options(current_rps: current_rps, target_rps: target_rps)
 
    case bottleneck
    when :slow_queries
      puts "推奨: まずコード最適化（option_a）、次にRead Replica追加（option_c）"
      [options[:option_a_optimize_code], options[:option_c_add_read_replica]]
    when :high_cpu
      puts "推奨: Fargateスケールアウト（option_d）"
      [options[:option_d_scale_out_fargate]]
    when :cache_miss
      puts "推奨: ElastiCacheノード追加（option_b）"
      [options[:option_b_add_cache]]
    when :db_write_iops
      puts "推奨: Aurora スケールアップ（option_e）、長期的にはシャーディング（option_f）"
      [options[:option_e_vertical_aurora], options[:option_f_sharding]]
    else
      puts "ボトルネックを特定してください。計測から始めてください。"
      []
    end
  end
end

# 判断ログを記録（なぜこの変更をしたか残す）
class ScalingDecisionLog
  def self.record(decision:, reason:, signal_data:, expected_impact:)
    DecisionLog.create!(
      decision:        decision,
      reason:          reason,
      signal_data:     signal_data.to_json,
      expected_impact: expected_impact,
      decided_by:      Current.user&.email || 'system',
      decided_at:      Time.current
    )
 
    # Slackにも通知
    SlackNotifier.info(
      channel: '#eng-scaling',
      message: <<~MSG
        Scaling Decision Recorded:
        Decision: #{decision}
        Reason: #{reason}
        Expected: #{expected_impact}
        By: #{Current.user&.email || 'system'}
      MSG
    )
  end
end
 
# 使い方:
# ScalingDecisionLog.record(
#   decision: "Aurora Reader を 2台 → 4台に増加",
#   reason: "DB接続使用率が85%を超えた（閾値: 80%）",
#   signal_data: { db_connection_pct: 85, current_readers: 2 },
#   expected_impact: "DB接続使用率を45%程度まで低下させる"
# )

# アンチパターン1: 不要な非同期化
# ────────────────────────────────
# ユーザー登録メールは同期で送っても100ms程度。非同期にする必要なし。
# 非同期にすると: 失敗時のリトライ、冪等性、デッドレター管理が必要になる
 
class RegistrationsController < ApplicationController
  def create
    @user = User.create!(user_params)
 
    # NG: 「なんとなく非同期」
    # WelcomeMailJob.perform_later(@user.id)
 
    # OK: 同期で十分、エラーはそのままユーザーに返せる
    WelcomeMailer.welcome(@user).deliver_now
 
    redirect_to dashboard_path
  end
end
 
# アンチパターン2: 管理画面のキャッシュ
# ────────────────────────────────────
# 管理者が一日数回見る統計ページをキャッシュしても意味はない
# キャッシュを入れると: キャッシュ無効化のバグ、古いデータ表示などの問題が発生
 
class Admin::StatsController < ApplicationController
  def index
    # NG: 管理者は1人、1日数回しか見ない
    # @stats = Rails.cache.fetch('admin:daily_stats', expires_in: 1.hour) do
    #   calculate_heavy_stats
    # end
 
    # OK: 複雑でもDBから直接取得で十分
    @stats = calculate_heavy_stats
  end
end
 
# アンチパターン3: 早すぎるマイクロサービス化
# ─────────────────────────────────────────
# Shopify は $100B 企業でも「Modular Monolith」
# Netflix でさえ最初はモノリスだった
 
# NG: 100万ユーザー未満でマイクロサービスへ分割
#   → デプロイが複雑、ネットワーク遅延、サービス間認証、分散トレーシング必要
#   → エンジニア10人未満では管理コストが開発コストを上回る
 
# OK: 「Vertical Slice」でモノリス内を論理分割
# app/
#   domains/
#     posts/      # 投稿ドメイン
#       models/
#       services/
#       controllers/
#     users/      # ユーザードメイン
#     notifications/ # 通知ドメイン
#
# これで十分。1000万ユーザーまではモノリスで戦える。
 
# アンチパターン4: 「念のため」のインフラ
# ────────────────────────────────────
# 「いつか使うかも」でコストをかけない
 
# NG: 最初からKinesisを入れる
#   → 10万イベント/日 = SQSで十分、Kinesisは不要
#   → 5,000万イベント/日 を超えてから検討する
 
# OK: SQS → Kinesis の段階的な移行

# lib/scaling_philosophy.rb
# Buzzが1年で学んだスケーリングの哲学をコードに
 
module ScalingPhilosophy
  # 計測なき最適化はギャンブル
  def measure_first
    before = benchmark { yield }
    result = yield
    after  = benchmark { yield }
 
    Rails.logger.info "Performance: #{before.real.round(3)}s → #{after.real.round(3)}s"
    result
  end
 
  # シンプルから始める
  def simple_first
    # 複雑な解決策を実装する前に、シンプルな方法を試す
    # バグはシンプルなコードに少ない
    # シンプルなコードは修正が速い
    yield
  rescue => e
    # シンプルな方法が失敗したら、複雑な方法を検討する
    raise ScalingRequired, "Simple approach failed: #{e.message}"
  end
 
  # 問題が起きてから解決する
  def scale_when_needed(threshold:)
    result = yield
    signal = ScalingSignalDetector.check_all
 
    if signal[:alerts].any?
      Rails.logger.warn "Scaling signal detected: #{signal[:alerts].join(', ')}"
      # 自動スケーリングが起動する（ECS Auto Scaling）
    end
 
    result
  end
end
 
# この哲学の実践:
# 1. コードを書く前に計測する
# 2. シンプルな解決策を試す
# 3. 問題が起きてから最適化する
# 4. 最適化の効果を計測する
# 5. 繰り返す

# 本番環境へのデプロイ（GitHub Actions経由）
# .github/workflows/terraform.yml からのみ実行される
 
# ステージング
cd terraform/environments/staging
terraform plan -out=tfplan
terraform apply tfplan
 
# 本番（東京）
cd terraform/environments/production/ap-northeast-1
terraform plan -out=tfplan
# → Pull Request でレビュー後にマージしてapply