キャッシュ戦略 — 速度を手に入れる

-- 1分間に1000回実行される
SELECT projects.*, COUNT(tasks.id) as task_count
FROM projects
LEFT JOIN tasks ON tasks.project_id = projects.id
WHERE projects.user_id = ?
GROUP BY projects.id
ORDER BY projects.updated_at DESC;

# Gemfile
gem 'redis'
gem 'hiredis-client'  # C拡張でさらに高速化
 
# config/environments/production.rb
config.cache_store = :redis_cache_store, {
  url: ENV['REDIS_URL'],
  expires_in: 1.hour,
  namespace: 'echo_task_cache',
  pool_size: 5,
  pool_timeout: 5
}

# シリアライズしたJSONを保存
redis = Redis.new(url: ENV['REDIS_URL'])
redis.set("user:#{user.id}:profile", user.to_json, ex: 3600)
profile = JSON.parse(redis.get("user:#{user.id}:profile"))

# プロジェクトの各フィールドを個別に更新できる
redis.hset("project:#{project.id}",
  "name",       project.name,
  "task_count", project.tasks.count,
  "updated_at", project.updated_at.to_i
)
 
# フィールド単体の取得
task_count = redis.hget("project:#{project.id}", "task_count").to_i
 
# タスク数だけ更新（プロジェクト名はそのまま）
redis.hincrby("project:#{project.id}", "task_count", 1)

# 最新の操作ログを50件だけ保持
def record_activity(user_id, activity)
  key = "user:#{user_id}:activities"
  redis.lpush(key, activity.to_json)
  redis.ltrim(key, 0, 49)   # 先頭50件のみ残す
  redis.expire(key, 86400)  # 24時間で期限切れ
end
 
def recent_activities(user_id)
  redis.lrange("user:#{user_id}:activities", 0, 9).map { |a| JSON.parse(a) }
end

# プロジェクトに付いているタグをSetで管理
def add_tag(project_id, tag)
  redis.sadd("project:#{project_id}:tags", tag)
end
 
# 特定タグを持つプロジェクトIDの積集合（AND検索）
def projects_with_all_tags(*tags)
  keys = tags.map { |t| "tag:#{t}:projects" }
  redis.sinter(*keys)
end

# タスク完了数でリーダーボードを管理
redis.zincrby("leaderboard:#{Date.today}", 1, user_id.to_s)
redis.expire("leaderboard:#{Date.today}", 86400 * 7)
top_users = redis.zrevrange("leaderboard:#{Date.today}", 0, 9, with_scores: true)

# app/models/project.rb
class Project < ApplicationRecord
  def self.for_user_with_counts(user_id)
    Rails.cache.fetch("user:#{user_id}:projects", expires_in: 5.minutes) do
      includes(:tasks)
        .where(user_id: user_id)
        .map { |p| { id: p.id, name: p.name, task_count: p.tasks.size } }
    end
  end
end

# app/controllers/api/v1/projects_controller.rb
def index
  projects = Project.for_user_with_counts(current_user.id)
  render json: projects
end

# app/models/project.rb
class Project < ApplicationRecord
  after_save :update_cache
  after_destroy :invalidate_cache
 
  private
 
  def update_cache
    Rails.cache.write(
      "project:#{id}",
      { id: id, name: name, updated_at: updated_at },
      expires_in: 1.hour
    )
    Rails.cache.delete("user:#{user_id}:projects")
  end
 
  def invalidate_cache
    Rails.cache.delete("project:#{id}")
    Rails.cache.delete("user:#{user_id}:projects")
  end
end

# app/services/cache_service.rb
class CacheService
  def self.fetch_with_lock(key, ttl:, &block)
    cached = Rails.cache.read(key)
    return cached if cached
 
    lock_key = "lock:#{key}"
    # NX=存在しない場合のみセット、EX=10秒で自動解放
    acquired = $redis.set(lock_key, "1", nx: true, ex: 10)
 
    if acquired
      begin
        data = block.call
        Rails.cache.write(key, data, expires_in: ttl)
        data
      ensure
        $redis.del(lock_key)
      end
    else
      sleep 0.05
      Rails.cache.read(key) || fetch_with_lock(key, ttl: ttl, &block)
    end
  end
end
 
# 使用例
projects = CacheService.fetch_with_lock("user:#{user_id}:projects", ttl: 5.minutes) do
  Project.for_user_with_counts(user_id)
end

# よくある失敗: 更新後もキャッシュが残る
def update
  @task.update!(task_params)
  # キャッシュを消し忘れると、古いデータが表示され続ける
end
 
# 正しい実装
def update
  @task.update!(task_params)
  Rails.cache.delete("task:#{@task.id}")
  Rails.cache.delete("project:#{@task.project_id}:tasks")
  Rails.cache.delete("user:#{current_user.id}:projects")
end

# app/models/task.rb
class Task < ApplicationRecord
  belongs_to :project, touch: true  # taskが更新されるとprojectのupdated_atも更新
 
  def cache_key_with_version
    "#{cache_key}/#{updated_at.to_i}"
  end
end
 
# app/models/project.rb
class Project < ApplicationRecord
  belongs_to :user, touch: true
 
  def cache_key_with_version
    "#{cache_key}/#{updated_at.to_i}"
  end
end
 
# キャッシュキーにupdated_atを含めることで、更新時に自動でキャッシュが無効化される
Rails.cache.fetch(project.cache_key_with_version, expires_in: 1.hour) do
  { project: project.as_json, tasks: project.tasks.map(&:as_json) }
end

# lib/tasks/cache_warmup.rake
namespace :cache do
  desc "キャッシュをウォームアップする（デプロイ後に実行）"
  task warmup: :environment do
    puts "キャッシュウォームアップ開始..."
 
    # アクティブユーザーのプロジェクト一覧をプリロード
    User.active.find_each(batch_size: 100) do |user|
      Project.for_user_with_counts(user.id)
      print "."
    end
 
    # タグ一覧（更新頻度が低い）
    Rails.cache.fetch("global:tags", expires_in: 24.hours) do
      Tag.all.order(:name).pluck(:id, :name)
    end
 
    # プラン機能フラグ
    Plan.all.each do |plan|
      Rails.cache.fetch("plan:#{plan.id}:features", expires_in: 6.hours) do
        plan.features.to_a
      end
    end
 
    puts "\nウォームアップ完了！"
  end
end

// pkg/cache/redis.go
package cache
 
import (
	"context"
	"encoding/json"
	"time"
 
	"github.com/redis/go-redis/v9"
)
 
type RedisCache struct{ client *redis.Client }
 
// GetOrSet — キャッシュHITなら即返す、MISSならfetchFnを呼んで保存
func (c *RedisCache) GetOrSet(ctx context.Context, key string, ttl time.Duration, fetchFn func() (any, error)) (any, error) {
	val, err := c.client.Get(ctx, key).Result()
	if err == nil {
		var result any
		if e := json.Unmarshal([]byte(val), &result); e == nil {
			return result, nil
		}
	}
	data, err := fetchFn()
	if err != nil {
		return nil, err
	}
	if b, e := json.Marshal(data); e == nil {
		c.client.Set(ctx, key, b, ttl)
	}
	return data, nil
}
 
// FetchWithLock — SetNX(NX=存在しなければセット)でロックを取りStampede防止
func (c *RedisCache) FetchWithLock(ctx context.Context, key string, ttl time.Duration, fetchFn func() (any, error)) (any, error) {
	lockKey := "lock:" + key
	acquired, _ := c.client.SetNX(ctx, lockKey, "1", 10*time.Second).Result()
	if acquired {
		defer c.client.Del(ctx, lockKey)
		return c.GetOrSet(ctx, key, ttl, fetchFn)
	}
	// ロック取得失敗 → 50ms待ってキャッシュを再確認
	time.Sleep(50 * time.Millisecond)
	return c.GetOrSet(ctx, key, ttl, fetchFn)
}

# app/middleware/rate_limiter.rb
class RateLimiter
  LIMITS = {
    api:    { limit: 1000, window: 1.hour },
    upload: { limit: 10,   window: 1.minute },
    login:  { limit: 5,    window: 15.minutes }
  }.freeze
 
  def self.check!(user_id, action)
    config = LIMITS[action] || LIMITS[:api]
    key = "rate_limit:#{action}:#{user_id}:#{window_key(config[:window])}"
 
    count = $redis.incr(key)
    # 初回アクセス時のみTTLをセット（EXISTSチェック不要でアトミック）
    $redis.expire(key, config[:window].to_i) if count == 1
 
    if count > config[:limit]
      ttl = $redis.ttl(key)
      raise RateLimitExceededError.new(
        "レート制限超過。#{ttl}秒後にリトライしてください。",
        retry_after: ttl
      )
    end
 
    { count: count, limit: config[:limit], remaining: config[:limit] - count }
  end
 
  private
 
  def self.window_key(window)
    (Time.current.to_i / window.to_i).to_s
  end
end

// Golangでの実装（APIゲートウェイ層）
func (c *RedisCache) CheckRateLimit(ctx context.Context, userID string, action string, limit int, window time.Duration) (bool, int, error) {
	windowKey := time.Now().Unix() / int64(window.Seconds())
	key := fmt.Sprintf("rate_limit:%s:%s:%d", action, userID, windowKey)
 
	// パイプラインでINCRとEXPIREをアトミックに実行
	pipe := c.client.Pipeline()
	incr := pipe.Incr(ctx, key)
	pipe.Expire(ctx, key, window)
	_, err := pipe.Exec(ctx)
	if err != nil {
		return false, 0, err
	}
 
	count := int(incr.Val())
	remaining := limit - count
	if remaining < 0 {
		remaining = 0
	}
 
	return count <= limit, remaining, nil
}

# ElastiCache Redis（スタンドアロン + レプリカ）CloudFormation
ElastiCacheReplicationGroup:
  Type: AWS::ElastiCache::ReplicationGroup
  Properties:
    ReplicationGroupDescription: "EchoTask Cache"
    AutomaticFailoverEnabled: true
    MultiAZEnabled: true
    CacheNodeType: cache.r7g.large   # 13.07 GiB メモリ
    Engine: redis
    EngineVersion: "7.2"
    NumCacheClusters: 2              # プライマリ + レプリカ1台
    CacheSubnetGroupName: !Ref CacheSubnetGroup
    SecurityGroupIds:
      - !Ref CacheSecurityGroup
    AtRestEncryptionEnabled: true
    TransitEncryptionEnabled: true
    SnapshotRetentionLimit: 7        # 7日間のスナップショット保持
    SnapshotWindow: "03:00-04:00"    # 日本時間 12:00-13:00 にスナップショット

# config/environments/production.rb
config.cache_store = :redis_cache_store, {
  url: ENV['ELASTICACHE_URL'],
  ssl_params: { verify_mode: OpenSSL::SSL::VERIFY_NONE },
  expires_in: 1.hour,
  namespace: "echo_task:#{Rails.env}",
  pool_size: ENV.fetch('RAILS_MAX_THREADS', 5).to_i,
  pool_timeout: 5
}

# lib/tasks/redis_monitor.rake
namespace :redis do
  desc "Redisのメモリ・ヒット率状況を確認"
  task stats: :environment do
    redis = Redis.new(url: ENV['REDIS_URL'])
    info = redis.info
 
    hits   = info['keyspace_hits'].to_i
    misses = info['keyspace_misses'].to_i
    total  = hits + misses
    hit_rate = total > 0 ? (hits.to_f / total * 100).round(2) : 0
 
    puts "=== Redis Stats ==="
    puts "Used Memory:      #{info['used_memory_human']}"
    puts "Max Memory:       #{info['maxmemory_human']}"
    puts "Evicted Keys:     #{info['evicted_keys']}"
    puts "Cache Hit Rate:   #{hit_rate}%"
    puts "Connected Clients:#{info['connected_clients']}"
    puts "Total Commands:   #{info['total_commands_processed']}"
  end
end

# TTL設計の目安
CACHE_TTL = {
  user_profile:   1.hour,      # 変わりにくい
  plan_features:  6.hours,
  tag_list:       24.hours,
  project_list:   10.minutes,  # そこそこ新鮮さが必要
  task_count:     2.minutes,
  notifications:  30.seconds,  # ほぼリアルタイム
}.freeze
 
# ジッターでStampedeを防ぐ
expires_in: CACHE_TTL[:project_list] + rand(60).seconds

class Task < ApplicationRecord
  belongs_to :project, counter_cache: true
end
 
project.tasks_count  # → tasks_countカラムを参照するだけ（SQLなし）