FDE の技術スタック — T字型プロファイルを鍛える

# app/queries/customer_usage_analysis.rb
class CustomerUsageAnalysis
  # 顧客ごとの API 利用量を分析し、
  # 前月比の成長率とランキングを算出する
  def call(tenant_id:, period_start:, period_end:)
    ActiveRecord::Base.connection.execute(<<~SQL)
      WITH daily_usage AS (
        SELECT
          customer_id,
          DATE(created_at) AS usage_date,
          COUNT(*) AS api_calls,
          SUM(tokens_consumed) AS total_tokens
        FROM api_requests
        WHERE tenant_id = '#{tenant_id}'
          AND created_at BETWEEN '#{period_start}' AND '#{period_end}'
        GROUP BY customer_id, DATE(created_at)
      ),
      monthly_summary AS (
        SELECT
          customer_id,
          DATE_TRUNC('month', usage_date) AS month,
          SUM(api_calls) AS monthly_calls,
          SUM(total_tokens) AS monthly_tokens,
          LAG(SUM(api_calls)) OVER (
            PARTITION BY customer_id
            ORDER BY DATE_TRUNC('month', usage_date)
          ) AS prev_month_calls
        FROM daily_usage
        GROUP BY customer_id, DATE_TRUNC('month', usage_date)
      )
      SELECT
        customer_id,
        month,
        monthly_calls,
        monthly_tokens,
        CASE
          WHEN prev_month_calls > 0
          THEN ROUND(
            (monthly_calls - prev_month_calls)::NUMERIC
            / prev_month_calls * 100, 1
          )
          ELSE NULL
        END AS growth_rate_pct,
        RANK() OVER (
          PARTITION BY month
          ORDER BY monthly_calls DESC
        ) AS usage_rank
      FROM monthly_summary
      ORDER BY month DESC, usage_rank ASC
    SQL
  end
end

# app/services/arclight/client.rb
module Arclight
  class Client
    BASE_URL = "https://api.arclight.ai/v1"
    MAX_RETRIES = 3
    RETRY_DELAY = 1 # 秒
 
    def initialize(api_key:, tenant_id:)
      @api_key = api_key
      @tenant_id = tenant_id
      @connection = build_connection
    end
 
    def inference(model_id:, input:, parameters: {})
      with_retry do
        response = @connection.post("/models/#{model_id}/infer") do |req|
          req.headers["X-Tenant-ID"] = @tenant_id
          req.body = {
            input: input,
            parameters: parameters
          }.to_json
        end
 
        handle_response(response)
      end
    end
 
    def embeddings(texts:, model_id: "text-embed-v3")
      with_retry do
        response = @connection.post("/embeddings") do |req|
          req.headers["X-Tenant-ID"] = @tenant_id
          req.body = {
            model: model_id,
            input: texts
          }.to_json
        end
 
        handle_response(response)
      end
    end
 
    private
 
    def build_connection
      Faraday.new(url: BASE_URL) do |f|
        f.request :json
        f.response :json
        f.response :raise_error
        f.headers["Authorization"] = "Bearer #{@api_key}"
        f.headers["Content-Type"] = "application/json"
        f.options.timeout = 30
        f.options.open_timeout = 5
      end
    end
 
    def with_retry
      retries = 0
      begin
        yield
      rescue Faraday::TooManyRequestsError => e
        retries += 1
        raise if retries > MAX_RETRIES
 
        retry_after = e.response[:headers]["Retry-After"]&.to_i || RETRY_DELAY * retries
        sleep(retry_after)
        retry
      rescue Faraday::ServerError => e
        retries += 1
        raise if retries > MAX_RETRIES
 
        sleep(RETRY_DELAY * retries)
        retry
      end
    end
 
    def handle_response(response)
      Arclight::Response.new(
        data: response.body,
        status: response.status,
        request_id: response.headers["X-Request-ID"]
      )
    end
  end
end

# app/controllers/api/v1/ai_integrations_controller.rb
module Api
  module V1
    class AiIntegrationsController < ApplicationController
      before_action :authenticate_api_key!
      before_action :set_tenant
 
      # POST /api/v1/ai/analyze
      # 顧客が自社データを送信し、AI 分析結果を受け取る
      def analyze
        input = analyze_params[:input]
        model_id = analyze_params[:model_id] || @tenant.default_model_id
 
        # 非同期ジョブに委譲（大量データの場合）
        if input.length > 10_000
          job = AiAnalysisJob.perform_later(
            tenant_id: @tenant.id,
            input: input,
            model_id: model_id,
            callback_url: analyze_params[:callback_url]
          )
          render json: {
            status: "processing",
            job_id: job.provider_job_id,
            estimated_seconds: estimate_processing_time(input)
          }, status: :accepted
        else
          result = Arclight::Client
            .new(api_key: @tenant.arclight_api_key, tenant_id: @tenant.external_id)
            .inference(model_id: model_id, input: input)
 
          render json: {
            status: "completed",
            result: result.data,
            request_id: result.request_id
          }, status: :ok
        end
      end
 
      # POST /api/v1/ai/webhook
      # Arclight AI からの非同期結果を受信する
      def webhook
        payload = verify_webhook_signature!(request)
 
        AiWebhookProcessor.new.process(
          event_type: payload["event"],
          data: payload["data"],
          tenant_id: @tenant.id
        )
 
        head :ok
      rescue InvalidWebhookSignature => e
        Rails.logger.warn("Webhook signature invalid: #{e.message}")
        head :unauthorized
      end
 
      private
 
      def analyze_params
        params.require(:ai).permit(:input, :model_id, :callback_url)
      end
 
      def set_tenant
        @tenant = Tenant.find_by!(external_id: request.headers["X-Tenant-ID"])
      rescue ActiveRecord::RecordNotFound
        render json: { error: "Invalid tenant" }, status: :forbidden
      end
 
      def verify_webhook_signature!(request)
        signature = request.headers["X-Arclight-Signature"]
        payload = request.body.read
        expected = OpenSSL::HMAC.hexdigest(
          "SHA256",
          @tenant.webhook_secret,
          payload
        )
 
        raise InvalidWebhookSignature unless ActiveSupport::SecurityUtils.secure_compare(signature, expected)
 
        JSON.parse(payload)
      end
 
      def estimate_processing_time(input)
        (input.length / 1000.0 * 2.5).ceil
      end
    end
  end
end

# lib/tasks/demo_environment.rake
namespace :demo do
  desc "新規顧客のデモ環境をプロビジョニングする"
  task :provision, [:customer_slug] => :environment do |_t, args|
    slug = args[:customer_slug]
    raise "customer_slug is required" if slug.blank?
 
    puts "=== #{slug} のデモ環境を構築中 ==="
 
    # 1. テナントレコードを作成
    tenant = Tenant.create!(
      name: slug,
      external_id: SecureRandom.uuid,
      status: "provisioning",
      database_schema: "demo_#{slug}",
      arclight_api_key: generate_scoped_api_key(slug)
    )
 
    # 2. スキーマ分離でデータベースを準備
    ActiveRecord::Base.connection.execute(
      "CREATE SCHEMA IF NOT EXISTS demo_#{slug}"
    )
 
    # 3. テナント専用テーブルをマイグレーション
    Apartment::Tenant.create(slug)
 
    # 4. シードデータを投入
    Apartment::Tenant.switch(slug) do
      DemoSeeder.new(tenant: tenant).seed!
    end
 
    # 5. S3 にデモ用アセットを配置
    DemoAssetUploader.new(
      bucket: "arclight-demo-#{slug}",
      region: "ap-northeast-1"
    ).upload_default_assets!
 
    # 6. ステータスを更新
    tenant.update!(status: "active")
 
    puts "=== #{slug} のデモ環境が完成しました ==="
    puts "  Tenant ID: #{tenant.external_id}"
    puts "  Schema:    demo_#{slug}"
    puts "  S3 Bucket: arclight-demo-#{slug}"
  end
 
  desc "デモ環境を削除する"
  task :teardown, [:customer_slug] => :environment do |_t, args|
    slug = args[:customer_slug]
    tenant = Tenant.find_by!(name: slug)
 
    puts "=== #{slug} のデモ環境を削除中 ==="
 
    Apartment::Tenant.drop(slug)
    Aws::S3::Client.new(region: "ap-northeast-1").list_objects_v2(
      bucket: "arclight-demo-#{slug}"
    ).contents.each do |obj|
      Aws::S3::Client.new(region: "ap-northeast-1").delete_object(
        bucket: "arclight-demo-#{slug}",
        key: obj.key
      )
    end
 
    tenant.update!(status: "decommissioned")
    puts "=== #{slug} のデモ環境を削除しました ==="
  end
end