rack-ai 0.1.0

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "logger"
+require "json"
+
+module Rack
+  module AI
+    module Utils
+      class Logger
+        class << self
+          def logger
+            @logger ||= build_logger
+          end
+
+          def debug(message, metadata = {})
+            log(:debug, message, metadata)
+          end
+
+          def info(message, metadata = {})
+            log(:info, message, metadata)
+          end
+
+          def warn(message, metadata = {})
+            log(:warn, message, metadata)
+          end
+
+          def error(message, metadata = {})
+            log(:error, message, metadata)
+          end
+
+          def fatal(message, metadata = {})
+            log(:fatal, message, metadata)
+          end
+
+          private
+
+          def log(level, message, metadata)
+            log_entry = {
+              timestamp: Time.now.iso8601,
+              level: level.to_s.upcase,
+              message: message,
+              component: "rack-ai",
+              metadata: sanitize_metadata(metadata)
+            }
+
+            logger.public_send(level, log_entry.to_json)
+          end
+
+          def build_logger
+            logger = ::Logger.new($stdout)
+            logger.level = log_level_from_env
+            logger.formatter = proc do |severity, datetime, progname, msg|
+              "#{datetime.iso8601} [#{severity}] #{progname}: #{msg}\n"
+            end
+            logger
+          end
+
+          def log_level_from_env
+            case ENV["RACK_AI_LOG_LEVEL"]&.downcase
+            when "debug"
+              ::Logger::DEBUG
+            when "info"
+              ::Logger::INFO
+            when "warn"
+              ::Logger::WARN
+            when "error"
+              ::Logger::ERROR
+            when "fatal"
+              ::Logger::FATAL
+            else
+              ::Logger::INFO
+            end
+          end
+
+          def sanitize_metadata(metadata)
+            return {} unless metadata.is_a?(Hash)
+
+            sanitized = {}
+            metadata.each do |key, value|
+              sanitized[key] = sanitize_value(value)
+            end
+            sanitized
+          end
+
+          def sanitize_value(value)
+            case value
+            when String
+              # Truncate very long strings and sanitize sensitive data
+              sanitized = value.length > 1000 ? "#{value[0..997]}..." : value
+              sanitize_sensitive_data(sanitized)
+            when Hash
+              sanitize_metadata(value)
+            when Array
+              value.map { |v| sanitize_value(v) }
+            else
+              value
+            end
+          end
+
+          def sanitize_sensitive_data(text)
+            # Remove potential API keys, tokens, passwords
+            text.gsub(/\b[A-Za-z0-9]{20,}\b/, "[REDACTED]")
+                .gsub(/password[=:]\s*\S+/i, "password=[REDACTED]")
+                .gsub(/token[=:]\s*\S+/i, "token=[REDACTED]")
+                .gsub(/key[=:]\s*\S+/i, "key=[REDACTED]")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Rack
+  module AI
+    module Utils
+      class Metrics
+        class << self
+          def initialize_metrics
+            @metrics = {}
+            @counters = {}
+            @histograms = {}
+            @gauges = {}
+          end
+
+          def record(metric_name, value, tags = {})
+            initialize_metrics unless @metrics
+            
+            @metrics[metric_name] ||= []
+            @metrics[metric_name] << {
+              value: value,
+              timestamp: Time.now.to_f,
+              tags: tags
+            }
+
+            # Keep only last 1000 measurements per metric
+            @metrics[metric_name] = @metrics[metric_name].last(1000)
+          end
+
+          def increment(counter_name, value = 1, tags = {})
+            initialize_metrics unless @counters
+            
+            key = build_key(counter_name, tags)
+            @counters[key] ||= 0
+            @counters[key] += value
+          end
+
+          def decrement(counter_name, value = 1, tags = {})
+            increment(counter_name, -value, tags)
+          end
+
+          def histogram(metric_name, value, tags = {})
+            initialize_metrics unless @histograms
+            
+            key = build_key(metric_name, tags)
+            @histograms[key] ||= []
+            @histograms[key] << value
+
+            # Keep only last 1000 values per histogram
+            @histograms[key] = @histograms[key].last(1000)
+          end
+
+          def gauge(metric_name, value, tags = {})
+            initialize_metrics unless @gauges
+            
+            key = build_key(metric_name, tags)
+            @gauges[key] = {
+              value: value,
+              timestamp: Time.now.to_f,
+              tags: tags
+            }
+          end
+
+          def get_counter(counter_name, tags = {})
+            return 0 unless @counters
+            
+            key = build_key(counter_name, tags)
+            @counters[key] || 0
+          end
+
+          def get_histogram_stats(metric_name, tags = {})
+            return {} unless @histograms
+            
+            key = build_key(metric_name, tags)
+            values = @histograms[key] || []
+            return {} if values.empty?
+
+            sorted_values = values.sort
+            {
+              count: values.length,
+              min: sorted_values.first,
+              max: sorted_values.last,
+              mean: values.sum.to_f / values.length,
+              median: percentile(sorted_values, 50),
+              p95: percentile(sorted_values, 95),
+              p99: percentile(sorted_values, 99)
+            }
+          end
+
+          def get_gauge(metric_name, tags = {})
+            return nil unless @gauges
+            
+            key = build_key(metric_name, tags)
+            @gauges[key]
+          end
+
+          def get_metrics_summary
+            {
+              counters: @counters&.keys&.length || 0,
+              histograms: @histograms&.keys&.length || 0,
+              gauges: @gauges&.keys&.length || 0,
+              metrics: @metrics&.keys&.length || 0,
+              timestamp: Time.now.iso8601
+            }
+          end
+
+          def export_prometheus_format
+            lines = []
+            
+            # Export counters
+            @counters&.each do |key, value|
+              metric_name, tags = parse_key(key)
+              tags_str = format_prometheus_tags(tags)
+              lines << "# TYPE #{metric_name} counter"
+              lines << "#{metric_name}#{tags_str} #{value}"
+            end
+
+            # Export gauges
+            @gauges&.each do |key, data|
+              metric_name, tags = parse_key(key)
+              tags_str = format_prometheus_tags(tags)
+              lines << "# TYPE #{metric_name} gauge"
+              lines << "#{metric_name}#{tags_str} #{data[:value]}"
+            end
+
+            # Export histogram summaries
+            @histograms&.each do |key, values|
+              next if values.empty?
+              
+              metric_name, tags = parse_key(key)
+              stats = calculate_histogram_stats(values)
+              tags_str = format_prometheus_tags(tags)
+              
+              lines << "# TYPE #{metric_name} histogram"
+              lines << "#{metric_name}_count#{tags_str} #{stats[:count]}"
+              lines << "#{metric_name}_sum#{tags_str} #{stats[:sum]}"
+              
+              [0.5, 0.9, 0.95, 0.99].each do |quantile|
+                quantile_tags = tags.merge(quantile: quantile)
+                quantile_tags_str = format_prometheus_tags(quantile_tags)
+                lines << "#{metric_name}#{quantile_tags_str} #{stats[:"p#{(quantile * 100).to_i}"]}"
+              end
+            end
+
+            lines.join("\n")
+          end
+
+          def reset_metrics!
+            @metrics = {}
+            @counters = {}
+            @histograms = {}
+            @gauges = {}
+          end
+
+          private
+
+          def build_key(metric_name, tags)
+            return metric_name.to_s if tags.empty?
+            
+            tag_string = tags.map { |k, v| "#{k}=#{v}" }.sort.join(",")
+            "#{metric_name}|#{tag_string}"
+          end
+
+          def parse_key(key)
+            parts = key.split("|", 2)
+            metric_name = parts[0]
+            
+            if parts[1]
+              tags = {}
+              parts[1].split(",").each do |tag_pair|
+                k, v = tag_pair.split("=", 2)
+                tags[k.to_sym] = v
+              end
+              [metric_name, tags]
+            else
+              [metric_name, {}]
+            end
+          end
+
+          def percentile(sorted_values, percentile)
+            return 0 if sorted_values.empty?
+            
+            index = (percentile / 100.0) * (sorted_values.length - 1)
+            
+            if index == index.to_i
+              sorted_values[index.to_i]
+            else
+              lower = sorted_values[index.floor]
+              upper = sorted_values[index.ceil]
+              lower + (upper - lower) * (index - index.floor)
+            end
+          end
+
+          def calculate_histogram_stats(values)
+            sorted_values = values.sort
+            {
+              count: values.length,
+              sum: values.sum,
+              min: sorted_values.first,
+              max: sorted_values.last,
+              p50: percentile(sorted_values, 50),
+              p90: percentile(sorted_values, 90),
+              p95: percentile(sorted_values, 95),
+              p99: percentile(sorted_values, 99)
+            }
+          end
+
+          def format_prometheus_tags(tags)
+            return "" if tags.empty?
+            
+            tag_pairs = tags.map { |k, v| "#{k}=\"#{v}\"" }
+            "{#{tag_pairs.join(",")}}"
+          end
+        end
+
+        # Initialize on first load
+        initialize_metrics
+      end
+    end
+  end
+end

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Rack
+  module AI
+    module Utils
+      class Sanitizer
+        SENSITIVE_PATTERNS = [
+          # API Keys and tokens
+          /\b[A-Za-z0-9]{20,}\b/,
+          /sk-[A-Za-z0-9]{48}/,  # OpenAI API keys
+          /xoxb-[A-Za-z0-9-]+/,  # Slack tokens
+          /ghp_[A-Za-z0-9]{36}/,  # GitHub tokens
+          
+          # Credit card numbers
+          /\b(?:\d{4}[-\s]?){3}\d{4}\b/,
+          
+          # Social Security Numbers
+          /\b\d{3}-\d{2}-\d{4}\b/,
+          
+          # Email addresses (partial)
+          /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/,
+          
+          # Phone numbers
+          /\b\d{3}-\d{3}-\d{4}\b/,
+          /\(\d{3}\)\s*\d{3}-\d{4}/,
+          
+          # IP addresses (private ranges)
+          /\b(?:10\.|172\.(?:1[6-9]|2[0-9]|3[01])\.|192\.168\.)\d{1,3}\.\d{1,3}\b/
+        ].freeze
+
+        SENSITIVE_HEADERS = %w[
+          authorization
+          x-api-key
+          x-auth-token
+          cookie
+          set-cookie
+          x-session-id
+          x-csrf-token
+        ].freeze
+
+        class << self
+          def sanitize_request_data(env)
+            sanitized_env = {}
+            
+            env.each do |key, value|
+              if sensitive_header?(key)
+                sanitized_env[key] = "[REDACTED]"
+              elsif key == "rack.input" && value.respond_to?(:read)
+                # Don't include request body in sanitized data
+                sanitized_env[key] = "[REQUEST_BODY]"
+              else
+                sanitized_env[key] = sanitize_value(value)
+              end
+            end
+            
+            sanitized_env
+          end
+
+          def sanitize_response_data(headers, body)
+            sanitized_headers = {}
+            headers.each do |key, value|
+              if sensitive_header?(key.downcase)
+                sanitized_headers[key] = "[REDACTED]"
+              else
+                sanitized_headers[key] = sanitize_value(value)
+              end
+            end
+
+            sanitized_body = sanitize_body(body)
+            
+            {
+              headers: sanitized_headers,
+              body: sanitized_body
+            }
+          end
+
+          def sanitize_for_ai_processing(data)
+            case data
+            when Hash
+              sanitized = {}
+              data.each do |key, value|
+                sanitized[key] = sanitize_for_ai_processing(value)
+              end
+              sanitized
+            when Array
+              data.map { |item| sanitize_for_ai_processing(item) }
+            when String
+              sanitize_string_for_ai(data)
+            else
+              data
+            end
+          end
+
+          def extract_safe_content(content, max_length = 1000)
+            return "" if content.nil? || content.empty?
+            
+            # Remove sensitive patterns
+            safe_content = sanitize_string_for_ai(content.to_s)
+            
+            # Truncate if too long
+            if safe_content.length > max_length
+              safe_content = safe_content[0..max_length-4] + "..."
+            end
+            
+            safe_content
+          end
+
+          def redact_pii(text)
+            return text unless text.is_a?(String)
+            
+            redacted = text.dup
+            
+            # Redact email addresses
+            redacted.gsub!(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/, "[EMAIL]")
+            
+            # Redact phone numbers
+            redacted.gsub!(/\b\d{3}-\d{3}-\d{4}\b/, "[PHONE]")
+            redacted.gsub!(/\(\d{3}\)\s*\d{3}-\d{4}/, "[PHONE]")
+            
+            # Redact SSN
+            redacted.gsub!(/\b\d{3}-\d{2}-\d{4}\b/, "[SSN]")
+            
+            # Redact credit card numbers
+            redacted.gsub!(/\b(?:\d{4}[-\s]?){3}\d{4}\b/, "[CREDIT_CARD]")
+            
+            redacted
+          end
+
+          private
+
+          def sensitive_header?(header_name)
+            normalized = header_name.to_s.downcase.gsub(/^http_/, "").gsub(/_/, "-")
+            SENSITIVE_HEADERS.include?(normalized)
+          end
+
+          def sanitize_value(value)
+            case value
+            when String
+              sanitize_string(value)
+            when Hash
+              value.transform_values { |v| sanitize_value(v) }
+            when Array
+              value.map { |v| sanitize_value(v) }
+            else
+              value
+            end
+          end
+
+          def sanitize_string(str)
+            return str if str.length < 10  # Skip very short strings
+            
+            sanitized = str.dup
+            SENSITIVE_PATTERNS.each do |pattern|
+              sanitized.gsub!(pattern, "[REDACTED]")
+            end
+            sanitized
+          end
+
+          def sanitize_string_for_ai(str)
+            return str if str.length < 10
+            
+            # More aggressive sanitization for AI processing
+            sanitized = str.dup
+            
+            # Remove all potential sensitive patterns
+            SENSITIVE_PATTERNS.each do |pattern|
+              sanitized.gsub!(pattern, "[REDACTED]")
+            end
+            
+            # Remove common password/key patterns
+            sanitized.gsub!(/password[=:]\s*\S+/i, "password=[REDACTED]")
+            sanitized.gsub!(/token[=:]\s*\S+/i, "token=[REDACTED]")
+            sanitized.gsub!(/key[=:]\s*\S+/i, "key=[REDACTED]")
+            sanitized.gsub!(/secret[=:]\s*\S+/i, "secret=[REDACTED]")
+            
+            # Remove base64 encoded data (potential tokens)
+            sanitized.gsub!(/[A-Za-z0-9+\/]{40,}={0,2}/, "[BASE64_DATA]")
+            
+            sanitized
+          end
+
+          def sanitize_body(body)
+            return "[EMPTY_BODY]" unless body
+            
+            if body.respond_to?(:each)
+              content = ""
+              body.each { |chunk| content += chunk.to_s }
+            else
+              content = body.to_s
+            end
+            
+            # Only include first 500 chars of body for logging
+            truncated = content.length > 500 ? "#{content[0..497]}..." : content
+            sanitize_string_for_ai(truncated)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/ai/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rack
+  module AI
+    VERSION = "0.1.0"
+  end
+end

data/lib/rack/ai.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "ai/version"
+require_relative "ai/configuration"
+require_relative "ai/middleware"
+require_relative "ai/providers/base"
+require_relative "ai/providers/openai"
+require_relative "ai/providers/huggingface"
+require_relative "ai/providers/local"
+require_relative "ai/features/classification"
+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/utils/logger"
+require_relative "ai/utils/metrics"
+require_relative "ai/utils/sanitizer"
+
+module Rack
+  module AI
+    class Error < StandardError; end
+    class ConfigurationError < Error; end
+    class ProviderError < Error; end
+    class FeatureError < Error; end
+
+    class << self
+      # Global configuration
+      def configure
+        yield(configuration)
+      end
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def reset_configuration!
+        @configuration = nil
+      end
+
+      # Convenience method for creating middleware
+      def middleware(**options)
+        Middleware.new(nil, **options)
+      end
+    end
+  end
+end

data/rack-ai.gemspec

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "lib/rack/ai/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "rack-ai"
+  spec.version = Rack::AI::VERSION
+  spec.authors = ["Ahmet KAHRAMAN"]
+  spec.email = ["ahmetxhero@gmail.com"]
+
+  spec.summary = "AI-powered middleware for Rack applications"
+  spec.description = "Extends Rack with AI capabilities including request classification, content moderation, smart caching, and security features"
+  spec.homepage = "https://github.com/ahmetxhero/rack-ai"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/ahmetxhero/rack-ai"
+  spec.metadata["changelog_uri"] = "https://github.com/ahmetxhero/rack-ai/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Dependencies
+  spec.add_dependency "rack", ">= 2.0", "< 4.0"
+  spec.add_dependency "concurrent-ruby", "~> 1.1"
+  spec.add_dependency "dry-configurable", "~> 1.0"
+  spec.add_dependency "dry-validation", "~> 1.10"
+  spec.add_dependency "faraday", "~> 2.0"
+  spec.add_dependency "faraday-retry", "~> 2.0"
+  spec.add_dependency "redis", "~> 5.0"
+
+  # Development dependencies
+  spec.add_development_dependency "rspec", "~> 3.12"
+  spec.add_development_dependency "rack-test", "~> 2.0"
+  spec.add_development_dependency "webmock", "~> 3.18"
+  spec.add_development_dependency "benchmark-ips", "~> 2.12"
+  spec.add_development_dependency "rubocop", "~> 1.50"
+  spec.add_development_dependency "rubocop-rspec", "~> 2.20"
+  spec.add_development_dependency "simplecov", "~> 0.22"
+  spec.add_development_dependency "yard", "~> 0.9"
+end