rack-ai 0.1.0

data/lib/rack/ai/features/logging.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module Rack
+  module AI
+    module Features
+      class Logging
+        attr_reader :name, :provider, :config
+
+        def initialize(provider, config)
+          @name = :logging
+          @provider = provider
+          @config = config
+        end
+
+        def enabled?
+          @config.feature_enabled?(:logging)
+        end
+
+        def process_response?
+          true
+        end
+
+        def process_request(env)
+          return { processed: false, reason: "disabled" } unless enabled?
+
+          # Collect request metadata for AI analysis
+          request_summary = build_request_summary(env)
+          
+          # Generate AI insights about the request
+          insights = generate_request_insights(request_summary, env)
+
+          {
+            request_summary: request_summary,
+            ai_insights: insights,
+            feature: @name,
+            timestamp: Time.now.iso8601
+          }
+        end
+
+        def process_response(env, status, headers, body)
+          return { processed: false, reason: "disabled" } unless enabled?
+
+          # Collect response metadata
+          response_summary = build_response_summary(status, headers, body)
+          
+          # Generate AI insights about the complete request-response cycle
+          cycle_insights = generate_cycle_insights(env, response_summary)
+
+          # Log structured data for AI analysis
+          log_structured_data(env, response_summary, cycle_insights)
+
+          {
+            response_summary: response_summary,
+            cycle_insights: cycle_insights,
+            feature: "#{@name}_response",
+            timestamp: Time.now.iso8601
+          }
+        end
+
+        def generate_traffic_summary(time_window = 3600)
+          # This would be called periodically to generate AI-powered traffic summaries
+          return { processed: false, reason: "disabled" } unless enabled?
+
+          # In a real implementation, this would analyze stored log data
+          sample_data = build_sample_traffic_data(time_window)
+          
+          begin
+            summary = @provider.analyze_patterns(sample_data)
+            
+            {
+              time_window: time_window,
+              summary: summary,
+              generated_at: Time.now.iso8601
+            }
+          rescue => e
+            Utils::Logger.error("Failed to generate traffic summary", error: e.message)
+            { error: e.message, generated_at: Time.now.iso8601 }
+          end
+        end
+
+        private
+
+        def build_request_summary(env)
+          {
+            method: env["REQUEST_METHOD"],
+            path: env["PATH_INFO"],
+            query_params_count: env["QUERY_STRING"]&.split("&")&.size || 0,
+            user_agent: env["HTTP_USER_AGENT"],
+            remote_ip: env["REMOTE_ADDR"],
+            content_length: env["CONTENT_LENGTH"]&.to_i || 0,
+            content_type: env["CONTENT_TYPE"],
+            timestamp: Time.now.iso8601,
+            has_auth: !!(env["HTTP_AUTHORIZATION"] || env["HTTP_X_API_KEY"]),
+            is_ajax: env["HTTP_X_REQUESTED_WITH"] == "XMLHttpRequest",
+            referer: env["HTTP_REFERER"]
+          }
+        end
+
+        def build_response_summary(status, headers, body)
+          body_size = 0
+          if body.respond_to?(:each)
+            body.each { |chunk| body_size += chunk.bytesize }
+          end
+
+          {
+            status: status,
+            content_type: headers["Content-Type"],
+            content_length: headers["Content-Length"]&.to_i || body_size,
+            cache_control: headers["Cache-Control"],
+            has_cookies: !!headers["Set-Cookie"],
+            timestamp: Time.now.iso8601
+          }
+        end
+
+        def generate_request_insights(request_summary, env)
+          # Simple rule-based insights (in production, could use AI provider)
+          insights = []
+
+          # Analyze request patterns
+          if request_summary[:query_params_count] > 10
+            insights << { type: "performance", message: "High number of query parameters" }
+          end
+
+          if request_summary[:content_length] > 1_000_000
+            insights << { type: "performance", message: "Large request body" }
+          end
+
+          if request_summary[:user_agent].nil? || request_summary[:user_agent].empty?
+            insights << { type: "security", message: "Missing User-Agent header" }
+          end
+
+          if request_summary[:path].include?("..")
+            insights << { type: "security", message: "Potential path traversal attempt" }
+          end
+
+          # Check for API usage patterns
+          if request_summary[:path].start_with?("/api/")
+            insights << { type: "api", message: "API endpoint access" }
+          end
+
+          insights
+        end
+
+        def generate_cycle_insights(env, response_summary)
+          insights = []
+          ai_results = env["rack.ai"][:results] || {}
+
+          # Analyze response patterns
+          if response_summary[:status] >= 400
+            insights << { 
+              type: "error", 
+              message: "Error response: #{response_summary[:status]}",
+              severity: response_summary[:status] >= 500 ? "high" : "medium"
+            }
+          end
+
+          if response_summary[:content_length] > 5_000_000
+            insights << { type: "performance", message: "Large response body" }
+          end
+
+          # Correlate with AI analysis results
+          if ai_results[:classification]
+            classification = ai_results[:classification][:classification]
+            insights << {
+              type: "classification",
+              message: "Request classified as: #{classification}",
+              confidence: ai_results[:classification][:confidence]
+            }
+          end
+
+          if ai_results[:security] && ai_results[:security][:threat_level] != :low
+            insights << {
+              type: "security",
+              message: "Security threat detected: #{ai_results[:security][:threat_level]}",
+              threats: ai_results[:security][:injection_detection][:threats]
+            }
+          end
+
+          insights
+        end
+
+        def log_structured_data(env, response_summary, insights)
+          log_entry = {
+            timestamp: Time.now.iso8601,
+            request: {
+              method: env["REQUEST_METHOD"],
+              path: env["PATH_INFO"],
+              remote_ip: env["REMOTE_ADDR"],
+              user_agent: env["HTTP_USER_AGENT"]
+            },
+            response: {
+              status: response_summary[:status],
+              content_type: response_summary[:content_type],
+              content_length: response_summary[:content_length]
+            },
+            ai_results: env["rack.ai"][:results],
+            insights: insights,
+            processing_time: Time.now - env["rack.ai"][:start_time]
+          }
+
+          # In production, this would go to structured logging system
+          Utils::Logger.info("AI-Enhanced Request Log", log_entry)
+        end
+
+        def build_sample_traffic_data(time_window)
+          # In a real implementation, this would query actual log storage
+          # For demo purposes, return sample data structure
+          {
+            time_window: time_window,
+            total_requests: 1500,
+            unique_ips: 245,
+            status_codes: {
+              "200" => 1200,
+              "404" => 150,
+              "500" => 50,
+              "403" => 100
+            },
+            top_paths: [
+              { path: "/api/users", count: 300 },
+              { path: "/", count: 250 },
+              { path: "/api/posts", count: 200 }
+            ],
+            user_agents: {
+              "browser" => 1000,
+              "bot" => 300,
+              "api_client" => 200
+            },
+            geographic_distribution: {
+              "US" => 800,
+              "EU" => 400,
+              "ASIA" => 300
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rack/ai/features/moderation.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Rack
+  module AI
+    module Features
+      class Moderation
+        attr_reader :name, :provider, :config
+
+        def initialize(provider, config)
+          @name = :moderation
+          @provider = provider
+          @config = config
+        end
+
+        def enabled?
+          @config.feature_enabled?(:moderation)
+        end
+
+        def process_response?
+          @config.moderation.check_response
+        end
+
+        def process_request(env)
+          content = extract_content_from_request(env)
+          return { processed: false, reason: "no_content" } if content.empty?
+
+          result = @provider.moderate_content(content.join(" "))
+          
+          # Apply toxicity threshold
+          threshold = @config.moderation.toxicity_threshold
+          max_score = result[:category_scores]&.values&.max || 0.0
+          
+          result[:action] = if result[:flagged] && max_score > threshold
+                             @config.moderation.block_on_violation ? :block : :flag
+                           else
+                             :allow
+                           end
+
+          # Add metadata
+          result[:feature] = @name
+          result[:timestamp] = Time.now.iso8601
+          result[:content_analyzed] = content.size
+          result[:threshold] = threshold
+
+          result
+        end
+
+        def process_response(env, status, headers, body)
+          return { processed: false, reason: "disabled" } unless process_response?
+          
+          content = extract_content_from_response(body)
+          return { processed: false, reason: "no_content" } if content.empty?
+
+          result = @provider.moderate_content(content)
+          result[:feature] = "#{@name}_response"
+          result[:timestamp] = Time.now.iso8601
+
+          result
+        end
+
+        private
+
+        def extract_content_from_request(env)
+          content = []
+          
+          # Extract from query parameters
+          if env["QUERY_STRING"] && !env["QUERY_STRING"].empty?
+            content << env["QUERY_STRING"]
+          end
+
+          # Extract from form data (if POST/PUT)
+          if %w[POST PUT PATCH].include?(env["REQUEST_METHOD"])
+            input = env["rack.input"]
+            if input && input.respond_to?(:read)
+              body_content = input.read
+              input.rewind if input.respond_to?(:rewind)
+              content << body_content unless body_content.empty?
+            end
+          end
+
+          # Extract from specific headers that might contain user content
+          user_content_headers = %w[HTTP_X_COMMENT HTTP_X_MESSAGE HTTP_X_DESCRIPTION]
+          user_content_headers.each do |header|
+            content << env[header] if env[header]
+          end
+
+          content.compact.reject(&:empty?)
+        end
+
+        def extract_content_from_response(body)
+          return "" unless body.respond_to?(:each)
+          
+          content = ""
+          body.each { |chunk| content += chunk.to_s }
+          
+          # Only moderate text content
+          return "" unless content.match?(/\A[\s\p{Print}]*\z/)
+          
+          content
+        end
+      end
+    end
+  end
+end

data/lib/rack/ai/features/routing.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Rack
+  module AI
+    module Features
+      class Routing
+        attr_reader :name, :provider, :config
+
+        def initialize(provider, config)
+          @name = :routing
+          @provider = provider
+          @config = config
+        end
+
+        def enabled?
+          @config.feature_enabled?(:routing) && @config.config.routing.smart_routing_enabled
+        end
+
+        def process_response?
+          false
+        end
+
+        def process_request(env)
+          return { processed: false, reason: "disabled" } unless enabled?
+
+          # Get classification and security results from other features
+          ai_results = env["rack.ai"][:results] || {}
+          classification = ai_results[:classification]
+          security = ai_results[:security]
+
+          routing_decision = make_routing_decision(classification, security, env)
+          
+          if routing_decision[:should_route]
+            # Modify the request path for routing
+            original_path = env["PATH_INFO"]
+            new_path = routing_decision[:target_path]
+            
+            env["PATH_INFO"] = new_path
+            env["rack.ai.original_path"] = original_path
+          end
+
+          {
+            routing_decision: routing_decision,
+            original_path: env["rack.ai.original_path"],
+            new_path: env["PATH_INFO"],
+            feature: @name,
+            timestamp: Time.now.iso8601
+          }
+        end
+
+        private
+
+        def make_routing_decision(classification, security, env)
+          # Default: no routing
+          decision = {
+            should_route: false,
+            target_path: env["PATH_INFO"],
+            reason: "no_routing_needed",
+            confidence: 1.0
+          }
+
+          # Route based on classification
+          if classification
+            case classification[:classification]
+            when :suspicious
+              if classification[:confidence] > 0.8
+                decision = {
+                  should_route: true,
+                  target_path: @config.config.routing.suspicious_route,
+                  reason: "suspicious_classification",
+                  confidence: classification[:confidence]
+                }
+              end
+            when :bot
+              if classification[:confidence] > 0.9
+                decision = {
+                  should_route: true,
+                  target_path: @config.config.routing.bot_route,
+                  reason: "bot_classification",
+                  confidence: classification[:confidence]
+                }
+              end
+            when :spam
+              decision = {
+                should_route: true,
+                target_path: "/blocked",
+                reason: "spam_classification",
+                confidence: classification[:confidence]
+              }
+            end
+          end
+
+          # Override with security-based routing
+          if security && security[:threat_level] == :high
+            decision = {
+              should_route: true,
+              target_path: "/security/blocked",
+              reason: "high_security_threat",
+              confidence: 1.0
+            }
+          elsif security && security[:threat_level] == :medium
+            decision = {
+              should_route: true,
+              target_path: "/security/verify",
+              reason: "medium_security_threat",
+              confidence: 0.8
+            }
+          end
+
+          # Add load balancing logic
+          if should_load_balance?(env)
+            decision = apply_load_balancing(decision, env)
+          end
+
+          decision
+        end
+
+        def should_load_balance?(env)
+          # Simple load balancing based on request patterns
+          path = env["PATH_INFO"]
+          method = env["REQUEST_METHOD"]
+          
+          # Load balance API endpoints
+          path.start_with?("/api/") && method == "GET"
+        end
+
+        def apply_load_balancing(decision, env)
+          # Simple round-robin or least-connections logic
+          # In production, this would integrate with actual load balancer
+          
+          servers = ["server1", "server2", "server3"]
+          selected_server = servers.sample # Random for demo
+          
+          decision.merge({
+            load_balanced: true,
+            target_server: selected_server,
+            reason: "#{decision[:reason]}_with_load_balancing"
+          })
+        end
+      end
+    end
+  end
+end