rack-ai 0.1.0

data/examples/rails_integration.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+# Rails Integration Example for Rack::AI
+# 
+# This example shows how to integrate Rack::AI with a Rails application
+# for AI-powered request processing, security, and content enhancement.
+
+require "rails"
+require "rack/ai"
+
+class Application < Rails::Application
+  # Basic Rack::AI configuration
+  config.middleware.use Rack::AI::Middleware,
+    provider: :openai,
+    api_key: ENV["OPENAI_API_KEY"],
+    features: [:classification, :moderation, :security, :caching],
+    fail_safe: true,
+    async_processing: true
+
+  # Configure AI features
+  config.before_initialize do
+    Rack::AI.configure do |config|
+      # Provider settings
+      config.provider = :openai
+      config.api_key = ENV["OPENAI_API_KEY"]
+      config.timeout = 30
+      config.retries = 3
+
+      # Feature configuration
+      config.features = [:classification, :moderation, :security, :caching, :logging]
+      config.fail_safe = true
+      config.async_processing = true
+
+      # Security settings
+      config.sanitize_logs = true
+      config.allowed_data_types = [:headers, :query_params]
+
+      # Classification settings
+      config.classification.confidence_threshold = 0.8
+      config.classification.categories = [:spam, :bot, :human, :suspicious]
+
+      # Moderation settings
+      config.moderation.toxicity_threshold = 0.7
+      config.moderation.check_response = false
+      config.moderation.block_on_violation = true
+
+      # Caching settings
+      config.caching.predictive_enabled = true
+      config.caching.redis_url = ENV["REDIS_URL"] || "redis://localhost:6379"
+
+      # Routing settings
+      config.routing.smart_routing_enabled = true
+      config.routing.suspicious_route = "/security/verify"
+      config.routing.bot_route = "/api/bot"
+
+      # Logging and monitoring
+      config.log_level = :info
+      config.metrics_enabled = true
+      config.explain_decisions = Rails.env.development?
+    end
+  end
+end
+
+# Example Rails controller that uses AI results
+class ApplicationController < ActionController::Base
+  before_action :check_ai_results
+
+  private
+
+  def check_ai_results
+    ai_results = request.env["rack.ai"]&.dig(:results) || {}
+    
+    # Handle classification results
+    if ai_results[:classification]
+      classification = ai_results[:classification]
+      
+      case classification[:classification]
+      when :spam
+        render json: { error: "Request blocked as spam" }, status: 403
+        return
+      when :suspicious
+        # Log suspicious activity
+        Rails.logger.warn("Suspicious request detected", {
+          ip: request.remote_ip,
+          path: request.path,
+          confidence: classification[:confidence]
+        })
+      when :bot
+        # Set special headers for bot requests
+        response.headers["X-Bot-Detected"] = "true"
+      end
+    end
+
+    # Handle security results
+    if ai_results[:security]
+      security = ai_results[:security]
+      
+      if security[:threat_level] == :high
+        render json: { error: "Security threat detected" }, status: 403
+        return
+      elsif security[:threat_level] == :medium
+        # Add security headers
+        response.headers["X-Security-Alert"] = "medium"
+      end
+    end
+
+    # Handle moderation results
+    if ai_results[:moderation] && ai_results[:moderation][:flagged]
+      render json: { error: "Content moderation violation" }, status: 400
+      return
+    end
+  end
+end
+
+# Example API controller with AI-enhanced responses
+class Api::V1::BaseController < ApplicationController
+  before_action :authenticate_api_key
+  after_action :add_ai_headers
+
+  private
+
+  def authenticate_api_key
+    api_key = request.headers["X-API-Key"]
+    
+    # Use AI classification to detect suspicious API usage
+    ai_results = request.env["rack.ai"]&.dig(:results) || {}
+    
+    if ai_results[:classification]&.dig(:classification) == :suspicious
+      # Require additional verification for suspicious requests
+      head :unauthorized unless verify_additional_auth
+    end
+  end
+
+  def add_ai_headers
+    ai_results = request.env["rack.ai"]&.dig(:results) || {}
+    
+    if ai_results[:classification]
+      response.headers["X-AI-Classification"] = ai_results[:classification][:classification].to_s
+      response.headers["X-AI-Confidence"] = ai_results[:classification][:confidence].to_s
+    end
+
+    if ai_results[:caching] && ai_results[:caching][:should_prefetch]
+      response.headers["X-AI-Prefetch-Recommended"] = "true"
+    end
+  end
+
+  def verify_additional_auth
+    # Additional authentication logic for suspicious requests
+    true
+  end
+end
+
+# Example model that uses AI insights for analytics
+class RequestAnalytics
+  def self.process_ai_insights(env)
+    ai_results = env["rack.ai"]&.dig(:results) || {}
+    
+    # Store classification data
+    if ai_results[:classification]
+      create_classification_record(env, ai_results[:classification])
+    end
+
+    # Store security events
+    if ai_results[:security] && ai_results[:security][:threat_level] != :low
+      create_security_event(env, ai_results[:security])
+    end
+
+    # Update traffic patterns for caching optimization
+    if ai_results[:caching]
+      update_traffic_patterns(env, ai_results[:caching])
+    end
+  end
+
+  private
+
+  def self.create_classification_record(env, classification)
+    # Store in database for analytics
+    ClassificationLog.create!(
+      ip_address: env["REMOTE_ADDR"],
+      path: env["PATH_INFO"],
+      classification: classification[:classification],
+      confidence: classification[:confidence],
+      user_agent: env["HTTP_USER_AGENT"],
+      timestamp: Time.current
+    )
+  end
+
+  def self.create_security_event(env, security)
+    SecurityEvent.create!(
+      ip_address: env["REMOTE_ADDR"],
+      path: env["PATH_INFO"],
+      threat_level: security[:threat_level],
+      threats: security[:injection_detection][:threats],
+      timestamp: Time.current
+    )
+  end
+
+  def self.update_traffic_patterns(env, caching)
+    # Update Redis with traffic patterns for AI caching
+    pattern_key = "traffic_pattern:#{env['PATH_INFO']}"
+    
+    Redis.current.hincrby(pattern_key, "requests", 1)
+    Redis.current.hset(pattern_key, "last_access", Time.current.to_i)
+    
+    if caching[:should_prefetch]
+      Redis.current.sadd("prefetch_candidates", env["PATH_INFO"])
+    end
+  end
+end
+
+# Example middleware for custom AI processing
+class CustomAIMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    # Custom pre-processing
+    add_custom_ai_context(env)
+    
+    status, headers, body = @app.call(env)
+    
+    # Custom post-processing with AI results
+    process_ai_results(env)
+    
+    [status, headers, body]
+  end
+
+  private
+
+  def add_custom_ai_context(env)
+    # Add custom context for AI processing
+    env["rack.ai.custom"] = {
+      user_tier: extract_user_tier(env),
+      api_version: extract_api_version(env),
+      client_type: detect_client_type(env)
+    }
+  end
+
+  def process_ai_results(env)
+    ai_results = env["rack.ai"]&.dig(:results) || {}
+    
+    # Custom business logic based on AI results
+    if ai_results[:classification]&.dig(:classification) == :bot
+      # Track bot usage for billing
+      BotUsageTracker.increment(env["HTTP_X_API_KEY"])
+    end
+
+    # Store analytics
+    RequestAnalytics.process_ai_insights(env)
+  end
+
+  def extract_user_tier(env)
+    # Extract user tier from headers or database
+    env["HTTP_X_USER_TIER"] || "free"
+  end
+
+  def extract_api_version(env)
+    env["HTTP_X_API_VERSION"] || "v1"
+  end
+
+  def detect_client_type(env)
+    user_agent = env["HTTP_USER_AGENT"] || ""
+    
+    return "mobile" if user_agent.match?(/Mobile|Android|iPhone/i)
+    return "browser" if user_agent.match?(/Mozilla|Chrome|Safari/i)
+    return "api_client" if user_agent.match?(/curl|HTTPie|Postman/i)
+    
+    "unknown"
+  end
+end
+
+# Configuration for different environments
+case Rails.env
+when "development"
+  # Development-specific AI configuration
+  Rack::AI.configure do |config|
+    config.explain_decisions = true
+    config.log_level = :debug
+    config.provider = :local  # Use local AI for development
+    config.api_url = "http://localhost:8080"
+  end
+
+when "test"
+  # Test-specific configuration
+  Rack::AI.configure do |config|
+    config.features = []  # Disable AI features in tests
+    config.fail_safe = true
+  end
+
+when "production"
+  # Production-specific configuration
+  Rack::AI.configure do |config|
+    config.provider = :openai
+    config.api_key = ENV["OPENAI_API_KEY"]
+    config.timeout = 10  # Shorter timeout in production
+    config.retries = 2
+    config.explain_decisions = false
+    config.sanitize_logs = true
+  end
+end