rack-ai 0.1.0 → 0.3.0

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

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Rack
+  module AI
+    module Features
+      class AnomalyDetection
+        attr_reader :name, :provider, :config
+
+        def initialize(provider, config)
+          @name = :anomaly_detection
+          @provider = provider
+          @config = config
+          @baseline_metrics = {}
+          @request_patterns = {}
+        end
+
+        def enabled?
+          @config.feature_enabled?(:anomaly_detection)
+        end
+
+        def process_response?
+          false
+        end
+
+        def process_request(env)
+          current_time = Time.now
+          client_ip = get_client_ip(env)
+          
+          # Extract request metrics
+          metrics = extract_request_metrics(env)
+          
+          # Update baseline and detect anomalies
+          anomalies = detect_anomalies(client_ip, metrics, current_time)
+          
+          # Calculate risk score
+          risk_score = calculate_risk_score(anomalies, metrics)
+          
+          # Determine action based on risk score
+          action = determine_action(risk_score)
+          
+          {
+            action: action,
+            feature: :anomaly_detection,
+            timestamp: current_time.iso8601,
+            risk_score: risk_score,
+            anomalies: anomalies,
+            metrics: metrics,
+            baseline_deviation: calculate_baseline_deviation(metrics)
+          }
+        end
+
+        private
+
+        def get_client_ip(env)
+          env['HTTP_X_FORWARDED_FOR']&.split(',')&.first&.strip ||
+            env['HTTP_X_REAL_IP'] ||
+            env['REMOTE_ADDR'] ||
+            'unknown'
+        end
+
+        def extract_request_metrics(env)
+          {
+            request_size: calculate_request_size(env),
+            header_count: env.select { |k, _| k.start_with?('HTTP_') }.size,
+            path_length: env['PATH_INFO']&.length || 0,
+            query_complexity: calculate_query_complexity(env['QUERY_STRING']),
+            user_agent_entropy: calculate_entropy(env['HTTP_USER_AGENT']),
+            request_frequency: calculate_request_frequency(get_client_ip(env)),
+            time_of_day: Time.now.hour,
+            day_of_week: Time.now.wday
+          }
+        end
+
+        def calculate_request_size(env)
+          size = 0
+          size += env['CONTENT_LENGTH'].to_i if env['CONTENT_LENGTH']
+          size += env['QUERY_STRING']&.length || 0
+          env.each { |k, v| size += k.length + v.to_s.length if k.start_with?('HTTP_') }
+          size
+        end
+
+        def calculate_query_complexity(query_string)
+          return 0 unless query_string
+          
+          params = query_string.split('&')
+          complexity = params.size
+          
+          # Add complexity for nested parameters, arrays, etc.
+          params.each do |param|
+            complexity += 1 if param.include?('[')
+            complexity += 1 if param.include?('%')
+            complexity += param.scan(/[=&]/).size
+          end
+          
+          complexity
+        end
+
+        def calculate_entropy(string)
+          return 0 unless string
+          
+          frequencies = Hash.new(0)
+          string.each_char { |char| frequencies[char] += 1 }
+          
+          entropy = 0
+          string.length.times do
+            freq = frequencies.values.shift
+            next if freq == 0
+            
+            probability = freq.to_f / string.length
+            entropy -= probability * Math.log2(probability)
+          end
+          
+          entropy
+        end
+
+        def calculate_request_frequency(client_ip)
+          current_time = Time.now
+          @request_patterns[client_ip] ||= []
+          
+          # Clean old entries (older than 1 hour)
+          @request_patterns[client_ip].reject! { |time| current_time - time > 3600 }
+          
+          # Add current request
+          @request_patterns[client_ip] << current_time
+          
+          # Return requests per minute
+          recent_requests = @request_patterns[client_ip].count { |time| current_time - time <= 60 }
+          recent_requests
+        end
+
+        def detect_anomalies(client_ip, metrics, current_time)
+          anomalies = []
+          
+          # Update baseline for this client
+          @baseline_metrics[client_ip] ||= initialize_baseline
+          baseline = @baseline_metrics[client_ip]
+          
+          metrics.each do |metric, value|
+            next unless value.is_a?(Numeric)
+            
+            # Calculate z-score
+            mean = baseline[metric][:mean]
+            std_dev = baseline[metric][:std_dev]
+            
+            if std_dev > 0
+              z_score = (value - mean).abs / std_dev
+              
+              if z_score > 3 # 3 standard deviations
+                anomalies << {
+                  metric: metric,
+                  value: value,
+                  expected_range: [mean - 2 * std_dev, mean + 2 * std_dev],
+                  z_score: z_score,
+                  severity: z_score > 5 ? :high : :medium
+                }
+              end
+            end
+            
+            # Update baseline with exponential moving average
+            alpha = 0.1
+            baseline[metric][:mean] = alpha * value + (1 - alpha) * mean
+            
+            # Update standard deviation
+            variance = baseline[metric][:variance] || 0
+            new_variance = alpha * (value - mean) ** 2 + (1 - alpha) * variance
+            baseline[metric][:variance] = new_variance
+            baseline[metric][:std_dev] = Math.sqrt(new_variance)
+          end
+          
+          anomalies
+        end
+
+        def initialize_baseline
+          Hash.new do |hash, key|
+            hash[key] = { mean: 0, variance: 0, std_dev: 1 }
+          end
+        end
+
+        def calculate_risk_score(anomalies, metrics)
+          base_score = 0
+          
+          # Score based on anomalies
+          anomalies.each do |anomaly|
+            case anomaly[:severity]
+            when :high
+              base_score += 30
+            when :medium
+              base_score += 15
+            else
+              base_score += 5
+            end
+          end
+          
+          # Additional risk factors
+          base_score += 10 if metrics[:request_frequency] > 60 # More than 1 req/sec
+          base_score += 15 if metrics[:request_size] > 1_000_000 # Large requests
+          base_score += 5 if metrics[:query_complexity] > 50 # Complex queries
+          base_score += 10 if metrics[:user_agent_entropy] < 2 # Suspicious UA
+          
+          # Time-based risk (higher risk during off-hours)
+          if metrics[:time_of_day] < 6 || metrics[:time_of_day] > 22
+            base_score += 5
+          end
+          
+          [base_score, 100].min # Cap at 100
+        end
+
+        def calculate_baseline_deviation(metrics)
+          # Simple calculation of how much current metrics deviate from expected
+          deviation_score = 0
+          
+          metrics.each do |_, value|
+            next unless value.is_a?(Numeric)
+            # Simplified deviation calculation
+            deviation_score += value > 1000 ? 1 : 0
+          end
+          
+          deviation_score
+        end
+
+        def determine_action(risk_score)
+          case risk_score
+          when 0..20
+            :allow
+          when 21..50
+            :monitor
+          when 51..80
+            :challenge
+          else
+            :block
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Rack
+  module AI
+    module Features
+      class RateLimiting
+        attr_reader :name, :provider, :config
+
+        def initialize(provider, config)
+          @name = :rate_limiting
+          @provider = provider
+          @config = config
+          @rate_store = {}
+          @cleanup_timer = Time.now
+        end
+
+        def enabled?
+          @config.feature_enabled?(:rate_limiting)
+        end
+
+        def process_response?
+          false
+        end
+
+        def process_request(env)
+          client_ip = get_client_ip(env)
+          current_time = Time.now
+          
+          # Cleanup old entries every 5 minutes
+          cleanup_old_entries if current_time - @cleanup_timer > 300
+          
+          # Get rate limit settings
+          window_size = @config.rate_limiting.window_size || 3600 # 1 hour default
+          max_requests = @config.rate_limiting.max_requests || 1000 # 1000 requests default
+          
+          # Initialize client data if not exists
+          @rate_store[client_ip] ||= { requests: [], blocked_until: nil }
+          client_data = @rate_store[client_ip]
+          
+          # Check if client is currently blocked
+          if client_data[:blocked_until] && current_time < client_data[:blocked_until]
+            return {
+              action: :block,
+              reason: "Rate limit exceeded - blocked until #{client_data[:blocked_until]}",
+              status: 429,
+              feature: :rate_limiting,
+              timestamp: current_time.iso8601,
+              retry_after: (client_data[:blocked_until] - current_time).to_i
+            }
+          end
+          
+          # Remove old requests outside the window
+          window_start = current_time - window_size
+          client_data[:requests].reject! { |timestamp| timestamp < window_start }
+          
+          # Check if rate limit is exceeded
+          if client_data[:requests].length >= max_requests
+            block_duration = @config.rate_limiting.block_duration || 3600 # 1 hour default
+            client_data[:blocked_until] = current_time + block_duration
+            
+            return {
+              action: :block,
+              reason: "Rate limit exceeded: #{client_data[:requests].length}/#{max_requests} requests in #{window_size}s",
+              status: 429,
+              feature: :rate_limiting,
+              timestamp: current_time.iso8601,
+              retry_after: block_duration,
+              requests_count: client_data[:requests].length,
+              window_size: window_size
+            }
+          end
+          
+          # Add current request
+          client_data[:requests] << current_time
+          
+          {
+            action: :allow,
+            feature: :rate_limiting,
+            timestamp: current_time.iso8601,
+            requests_count: client_data[:requests].length,
+            requests_remaining: max_requests - client_data[:requests].length,
+            window_size: window_size,
+            reset_time: (window_start + window_size).iso8601
+          }
+        end
+
+        private
+
+        def get_client_ip(env)
+          # Try various headers for real IP
+          forwarded_for = env['HTTP_X_FORWARDED_FOR']
+          return forwarded_for.split(',').first.strip if forwarded_for
+          
+          real_ip = env['HTTP_X_REAL_IP']
+          return real_ip if real_ip
+          
+          env['REMOTE_ADDR'] || 'unknown'
+        end
+
+        def cleanup_old_entries
+          current_time = Time.now
+          @rate_store.each do |ip, data|
+            # Remove clients with no recent activity and no active blocks
+            if data[:requests].empty? && 
+               (data[:blocked_until].nil? || current_time > data[:blocked_until])
+              @rate_store.delete(ip)
+            end
+          end
+          @cleanup_timer = current_time
+        end
+      end
+    end
+  end
+end

data/lib/rack/ai/middleware.rb

@@ -83,7 +83,9 @@ module Rack
           routing: Features::Routing,
           logging: Features::Logging,
           enhancement: Features::Enhancement,
-          security: Features::Security
+          security: Features::Security,
+          rate_limiting: Features::RateLimiting,
+          anomaly_detection: Features::AnomalyDetection
         }
 
         features = @config.features.map do |feature_name|
@@ -93,7 +95,7 @@ module Rack
           feature_class.new(@provider, @config)
         end
         
-        Utils::Logger.debug("Built features: #{features.map(&:name)}")
+        Utils::Logger.debug("Built features: #{features.map { |f| f.class.name.split('::').last }}")
         features
       end
 

data/lib/rack/ai/utils/enhanced_logger.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'json'
+
+module Rack
+  module AI
+    module Utils
+      class AdvancedLogger
+        LOG_LEVELS = {
+          debug: ::Logger::DEBUG,
+          info: ::Logger::INFO,
+          warn: ::Logger::WARN,
+          error: ::Logger::ERROR,
+          fatal: ::Logger::FATAL
+        }.freeze
+
+        def self.instance
+          @instance ||= new
+        end
+
+        def initialize(output = $stdout, level: :info, format: :json)
+          @logger = ::Logger.new(output)
+          @logger.level = LOG_LEVELS[level] || ::Logger::INFO
+          @format = format
+          @logger.formatter = method(:format_message)
+        end
+
+        def debug(message, context = {})
+          log(:debug, message, context)
+        end
+
+        def info(message, context = {})
+          log(:info, message, context)
+        end
+
+        def warn(message, context = {})
+          log(:warn, message, context)
+        end
+
+        def error(message, context = {})
+          log(:error, message, context)
+        end
+
+        def fatal(message, context = {})
+          log(:fatal, message, context)
+        end
+
+        def log_request(env, duration: nil, status: nil)
+          context = {
+            method: env['REQUEST_METHOD'],
+            path: env['PATH_INFO'],
+            query: env['QUERY_STRING'],
+            user_agent: env['HTTP_USER_AGENT'],
+            remote_ip: env['REMOTE_ADDR'],
+            duration_ms: duration ? (duration * 1000).round(2) : nil,
+            status: status
+          }.compact
+
+          info("HTTP Request", context)
+        end
+
+        def log_ai_processing(feature, result, duration: nil)
+          context = {
+            feature: feature,
+            action: result[:action],
+            confidence: result[:confidence],
+            duration_ms: duration ? (duration * 1000).round(2) : nil,
+            provider: result[:provider]
+          }.compact
+
+          info("AI Processing", context)
+        end
+
+        def log_error(error, context = {})
+          error_context = {
+            error_class: error.class.name,
+            error_message: error.message,
+            backtrace: error.backtrace&.first(5)
+          }.merge(context)
+
+          error("Application Error", error_context)
+        end
+
+        private
+
+        def log(level, message, context)
+          @logger.public_send(level) do
+            case @format
+            when :json
+              format_json(level, message, context)
+            when :structured
+              format_structured(level, message, context)
+            else
+              format_simple(level, message, context)
+            end
+          end
+        end
+
+        def format_message(severity, datetime, progname, msg)
+          msg
+        end
+
+        def format_json(level, message, context)
+          {
+            timestamp: Time.now.iso8601,
+            level: level.to_s.upcase,
+            message: message,
+            component: 'rack-ai',
+            **context
+          }.to_json + "\n"
+        end
+
+        def format_structured(level, message, context)
+          timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S')
+          context_str = context.empty? ? '' : " #{context.inspect}"
+          "[#{timestamp}] #{level.to_s.upcase} [rack-ai] #{message}#{context_str}\n"
+        end
+
+        def format_simple(level, message, context)
+          context_str = context.empty? ? '' : " (#{context.map { |k, v| "#{k}=#{v}" }.join(', ')})"
+          "#{message}#{context_str}\n"
+        end
+      end
+
+      # Alias for backward compatibility
+      EnhancedLogger = AdvancedLogger
+    end
+  end
+end

data/lib/rack/ai/utils/logger.rb

@@ -13,23 +13,23 @@ module Rack
           end
 
           def debug(message, metadata = {})
-            log(:debug, message, metadata)
+            puts "[DEBUG] #{message} #{metadata}" if ENV['RACK_AI_DEBUG']
           end
 
           def info(message, metadata = {})
-            log(:info, message, metadata)
+            puts "[INFO] #{message} #{metadata}"
           end
 
           def warn(message, metadata = {})
-            log(:warn, message, metadata)
+            puts "[WARN] #{message} #{metadata}"
           end
 
           def error(message, metadata = {})
-            log(:error, message, metadata)
+            puts "[ERROR] #{message} #{metadata}"
           end
 
           def fatal(message, metadata = {})
-            log(:fatal, message, metadata)
+            puts "[FATAL] #{message} #{metadata}"
           end
 
           private
@@ -106,6 +106,7 @@ module Rack
           end
         end
       end
+
     end
   end
 end

data/lib/rack/ai/version.rb

@@ -2,6 +2,6 @@
 
 module Rack
   module AI
-    VERSION = "0.1.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/rack/ai.rb

@@ -8,15 +8,18 @@ require_relative "ai/providers/openai"
 require_relative "ai/providers/huggingface"
 require_relative "ai/providers/local"
 require_relative "ai/features/classification"
+require_relative "ai/features/security"
 require_relative "ai/features/moderation"
 require_relative "ai/features/caching"
 require_relative "ai/features/routing"
 require_relative "ai/features/logging"
 require_relative "ai/features/enhancement"
-require_relative "ai/features/security"
+require_relative "ai/features/rate_limiting"
+require_relative "ai/features/anomaly_detection"
 require_relative "ai/utils/logger"
 require_relative "ai/utils/metrics"
 require_relative "ai/utils/sanitizer"
+require_relative "ai/utils/enhanced_logger"
 
 module Rack
   module AI

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-ai
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Ahmet KAHRAMAN
@@ -241,15 +241,20 @@ files:
 - ROADMAP.md
 - Rakefile
 - benchmarks/performance_benchmark.rb
+- examples/comprehensive_example.rb
 - examples/rails_integration.rb
+- examples/rails_integration_advanced.rb
 - examples/sinatra_integration.rb
+- examples/sinatra_microservice.rb
 - lib/rack/ai.rb
 - lib/rack/ai/configuration.rb
+- lib/rack/ai/features/anomaly_detection.rb
 - lib/rack/ai/features/caching.rb
 - lib/rack/ai/features/classification.rb
 - lib/rack/ai/features/enhancement.rb
 - lib/rack/ai/features/logging.rb
 - lib/rack/ai/features/moderation.rb
+- lib/rack/ai/features/rate_limiting.rb
 - lib/rack/ai/features/routing.rb
 - lib/rack/ai/features/security.rb
 - lib/rack/ai/middleware.rb
@@ -257,6 +262,7 @@ files:
 - lib/rack/ai/providers/huggingface.rb
 - lib/rack/ai/providers/local.rb
 - lib/rack/ai/providers/openai.rb
+- lib/rack/ai/utils/enhanced_logger.rb
 - lib/rack/ai/utils/logger.rb
 - lib/rack/ai/utils/metrics.rb
 - lib/rack/ai/utils/sanitizer.rb