reputable 0.1.0

data/lib/reputable/connection.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "redis"
+require "connection_pool"
+require "timeout"
+
+module Reputable
+  # Redis connection pool manager with robust error handling
+  class Connection
+    # Track if we're in a degraded state (failed recently)
+    @circuit_open = false
+    @circuit_opened_at = nil
+    @failure_count = 0
+    
+    # Circuit breaker settings
+    CIRCUIT_THRESHOLD = 5       # Failures before opening circuit
+    CIRCUIT_TIMEOUT = 30        # Seconds before trying again
+    
+    class << self
+      attr_accessor :circuit_open, :circuit_opened_at, :failure_count
+
+      def pool
+        @pool ||= ConnectionPool.new(
+          size: Reputable.configuration.pool_size,
+          timeout: Reputable.configuration.pool_timeout
+        ) do
+          build_redis_client
+        end
+      end
+
+      # Safe wrapper that handles all errors gracefully
+      # @param default [Object] Value to return on failure
+      # @param context [String] Description for error logging
+      # @yield Block to execute with Redis connection
+      # @return [Object] Result of block or default value
+      def safe_with(default: nil, context: "redis_operation")
+        return default unless Reputable.enabled?
+        return default if circuit_open?
+        
+        result = Timeout.timeout(operation_timeout) do
+          pool.with do |redis|
+            yield redis
+          end
+        end
+        
+        record_success
+        result
+      rescue Timeout::Error, ConnectionPool::TimeoutError => e
+        record_failure(e, context)
+        default
+      rescue Redis::BaseError, Errno::ECONNREFUSED, Errno::ETIMEDOUT, 
+             Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ECONNRESET,
+             Errno::EPIPE, SocketError, IOError => e
+        record_failure(e, context)
+        default
+      rescue OpenSSL::SSL::SSLError, OpenSSL::OpenSSLError => e
+        # Catch all SSL/TLS errors - certificate issues, handshake failures, etc.
+        record_failure(e, context)
+        default
+      rescue StandardError => e
+        # Catch-all for any unexpected errors
+        record_failure(e, context)
+        default
+      end
+
+      # Legacy method for backward compatibility
+      def with(&block)
+        safe_with(default: nil, context: "legacy_with", &block)
+      end
+
+      def reset!
+        @pool&.shutdown(&:close)
+        @pool = nil
+        @circuit_open = false
+        @circuit_opened_at = nil
+        @failure_count = 0
+      end
+
+      # Check if circuit breaker is open (we should skip operations)
+      def circuit_open?
+        return false unless @circuit_open
+        
+        # Check if enough time has passed to try again
+        if @circuit_opened_at && (Time.now - @circuit_opened_at) > CIRCUIT_TIMEOUT
+          @circuit_open = false
+          @failure_count = 0
+          Reputable.logger&.info("Reputable circuit breaker: attempting reconnection")
+          return false
+        end
+        
+        true
+      end
+
+      private
+
+      def operation_timeout
+        # Total timeout for an operation (connect + read + write + pool checkout)
+        config = Reputable.configuration
+        config.connect_timeout + config.read_timeout + config.pool_timeout + 0.5
+      end
+
+      def record_success
+        @failure_count = 0
+        if @circuit_open
+          @circuit_open = false
+          Reputable.logger&.info("Reputable circuit breaker: closed (connection restored)")
+        end
+      end
+
+      def record_failure(error, context)
+        @failure_count += 1
+        
+        Reputable.logger&.warn(
+          "Reputable #{context} error (#{@failure_count}/#{CIRCUIT_THRESHOLD}): #{error.class} - #{error.message}"
+        )
+        
+        # Notify via callback if configured
+        Reputable.configuration.on_error&.call(error, context)
+        
+        # Open circuit breaker if too many failures
+        if @failure_count >= CIRCUIT_THRESHOLD && !@circuit_open
+          @circuit_open = true
+          @circuit_opened_at = Time.now
+          Reputable.logger&.warn(
+            "Reputable circuit breaker: OPEN (#{CIRCUIT_THRESHOLD} failures, will retry in #{CIRCUIT_TIMEOUT}s)"
+          )
+        end
+      end
+
+      def build_redis_client
+        config = Reputable.configuration
+        url = config.redis_url
+        options = config.redis_options.dup
+
+        # Set timeouts
+        options[:connect_timeout] = config.connect_timeout
+        options[:read_timeout] = config.read_timeout
+        options[:write_timeout] = config.write_timeout
+
+        # Handle TLS URLs (rediss://)
+        if config.tls?
+          options[:ssl] = true
+          options[:ssl_params] = config.effective_ssl_params
+        end
+
+        Redis.new(url: url, **options)
+      end
+    end
+  end
+end

data/lib/reputable/middleware.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+module Reputable
+  # Rack middleware for automatic request tracking
+  #
+  # RESILIENCE: This middleware is designed to NEVER break your application.
+  # - Disable entirely via ENV: REPUTABLE_ENABLED=false
+  # - All errors are caught and logged silently
+  # - Circuit breaker prevents repeated failures from impacting performance
+  # - Async mode (default) runs tracking in a separate thread
+  #
+  # @example Basic usage in config.ru
+  #   require 'reputable'
+  #   use Reputable::Middleware
+  #
+  # @example With options
+  #   use Reputable::Middleware,
+  #     skip_paths: ['/health', '/assets'],
+  #     skip_if: ->(env) { env['HTTP_X_INTERNAL'] == 'true' },
+  #     tag_builder: ->(env) { ["custom:tag"] }
+  #
+  class Middleware
+    DEFAULT_SKIP_PATHS = %w[
+      /health
+      /healthz
+      /ready
+      /readyz
+      /live
+      /livez
+      /metrics
+      /favicon.ico
+    ].freeze
+
+    DEFAULT_SKIP_EXTENSIONS = %w[
+      .js .css .png .jpg .jpeg .gif .svg .ico .woff .woff2 .ttf .eot .map
+    ].freeze
+
+    def initialize(app, options = {})
+      @app = app
+      @skip_paths = options.fetch(:skip_paths, DEFAULT_SKIP_PATHS)
+      @skip_extensions = options.fetch(:skip_extensions, DEFAULT_SKIP_EXTENSIONS)
+      @skip_if = options[:skip_if]
+      @tag_builder = options[:tag_builder]
+      @async = options.fetch(:async, true)
+    end
+
+    def call(env)
+      # ALWAYS process the request first - tracking must never block
+      status, headers, response = @app.call(env)
+
+      # Only attempt tracking if enabled and not skipped
+      # All tracking is wrapped in rescue to ensure it never fails
+      safe_track_request(env)
+
+      [status, headers, response]
+    end
+
+    private
+
+    def safe_track_request(env)
+      # Skip if disabled globally
+      return unless Reputable.enabled?
+      
+      # Skip if this request should be skipped
+      return if skip_request?(env)
+      
+      track_request(env)
+    rescue StandardError => e
+      # NEVER let tracking errors propagate - just log and continue
+      Reputable.logger&.debug("Reputable middleware: #{e.class} - #{e.message}")
+    end
+
+    def skip_request?(env)
+      return true if @skip_if&.call(env)
+
+      path = env["PATH_INFO"] || "/"
+
+      # Skip exact path matches
+      return true if @skip_paths.include?(path)
+
+      # Skip by extension
+      ext = File.extname(path).downcase
+      return true if @skip_extensions.include?(ext)
+
+      false
+    rescue StandardError
+      # If skip logic fails, default to skipping (safer)
+      true
+    end
+
+    def track_request(env)
+      params = build_params(env)
+      return unless params
+
+      if @async
+        Tracker.track_request_async(**params)
+      else
+        Tracker.track_request(**params)
+      end
+    rescue StandardError => e
+      Reputable.logger&.debug("Reputable track_request: #{e.class} - #{e.message}")
+    end
+
+    def build_params(env)
+      request = Rack::Request.new(env)
+
+      {
+        ip: extract_ip(env),
+        path: request.path,
+        query: request.query_string.empty? ? nil : request.query_string,
+        method: request.request_method,
+        session_id: extract_session_id(env),
+        session_present: session_present?(env),
+        user_agent: env["HTTP_USER_AGENT"],
+        referer: env["HTTP_REFERER"],
+        tags: build_tags(env)
+      }.compact
+    rescue StandardError => e
+      Reputable.logger&.debug("Reputable build_params: #{e.class} - #{e.message}")
+      nil
+    end
+
+    def extract_ip(env)
+      config = Reputable.configuration
+      
+      # Try each header in priority order
+      config.ip_header_priority.each do |header|
+        value = env[header]
+        next if value.nil? || value.empty?
+        
+        # X-Forwarded-For and Forwarded can contain multiple IPs
+        if header == "HTTP_X_FORWARDED_FOR"
+          ip = extract_from_xff(value)
+          return ip if ip
+        elsif header == "HTTP_FORWARDED"
+          ip = extract_from_forwarded(value)
+          return ip if ip
+        else
+          # Single IP headers
+          ip = value.to_s.strip
+          return ip unless ip.empty?
+        end
+      end
+
+      # Ultimate fallback
+      "0.0.0.0"
+    rescue StandardError
+      "0.0.0.0"
+    end
+
+    # Extract real client IP from X-Forwarded-For header
+    # X-Forwarded-For: client, proxy1, proxy2
+    # We want the leftmost non-private IP
+    def extract_from_xff(xff)
+      return nil if xff.nil? || xff.empty?
+      
+      config = Reputable.configuration
+      ips = xff.split(",").map(&:strip)
+      
+      # Find the first (leftmost) public IP
+      ips.each do |ip|
+        next if ip.empty?
+        next if config.private_ip?(ip)
+        return ip
+      end
+      
+      # If all IPs are private, return the first one
+      ips.first&.strip
+    rescue StandardError
+      nil
+    end
+
+    # Extract client IP from RFC 7239 Forwarded header
+    # Forwarded: for=192.0.2.60;proto=http;by=203.0.113.43
+    def extract_from_forwarded(forwarded)
+      return nil if forwarded.nil? || forwarded.empty?
+      
+      # Parse the "for" directive
+      forwarded.split(";").each do |directive|
+        key, value = directive.split("=", 2).map(&:strip)
+        if key&.downcase == "for" && value
+          # Remove quotes and brackets (IPv6)
+          ip = value.gsub(/["'\[\]]/, "").strip
+          return ip unless ip.empty?
+        end
+      end
+      
+      nil
+    rescue StandardError
+      nil
+    end
+
+    def extract_session_id(env)
+      # Try rack.session.id first
+      return env["rack.session.id"] if env["rack.session.id"]
+
+      # Try to get from rack.session
+      session = env["rack.session"]
+      return session.id.to_s if session.respond_to?(:id)
+
+      nil
+    rescue StandardError
+      nil
+    end
+
+    def session_present?(env)
+      return true if env["rack.session.id"]
+      return true if env["rack.session"]&.any?
+      return true if env["HTTP_COOKIE"]&.include?("_session")
+
+      false
+    rescue StandardError
+      false
+    end
+
+    def build_tags(env)
+      tags = []
+
+      # Add custom tags from tag_builder
+      if @tag_builder
+        begin
+          custom_tags = @tag_builder.call(env)
+          tags.concat(Array(custom_tags))
+        rescue StandardError
+          # Ignore tag builder errors
+        end
+      end
+
+      # Add source tag based on referer
+      if (referer = env["HTTP_REFERER"])
+        tag = categorize_referer(referer)
+        tags << tag if tag
+      end
+
+      tags.compact
+    rescue StandardError
+      []
+    end
+
+    def categorize_referer(referer)
+      uri = URI.parse(referer) rescue nil
+      return nil unless uri&.host
+
+      host = uri.host.downcase
+
+      case host
+      when /google\./
+        "trust:channel:search"
+      when /bing\./
+        "trust:channel:search"
+      when /facebook\./, /fb\./
+        "trust:channel:social"
+      when /twitter\./, /t\.co/
+        "trust:channel:social"
+      when /instagram\./
+        "trust:channel:social"
+      when /linkedin\./
+        "trust:channel:social"
+      else
+        nil
+      end
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/reputable/rails.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Reputable
+  # Rails-specific integration
+  module Rails
+    # Railtie for automatic Rails integration
+    class Railtie < ::Rails::Railtie
+      initializer "reputable.configure_rails_initialization" do
+        # Auto-configure from Rails credentials or ENV
+        Reputable.configure do |config|
+          # Try Rails credentials first
+          if defined?(::Rails.application.credentials)
+            creds = ::Rails.application.credentials.reputable rescue nil
+            if creds
+              config.redis_url = creds[:redis_url] if creds[:redis_url]
+              config.tenant_id = creds[:tenant_id] if creds[:tenant_id]
+            end
+          end
+        end
+      end
+
+      initializer "reputable.insert_middleware" do |app|
+        # Only insert middleware if explicitly enabled
+        if ENV["REPUTABLE_AUTO_MIDDLEWARE"] == "true"
+          app.middleware.use Reputable::Middleware
+        end
+      end
+    end
+
+    # Helper methods for controllers
+    module ControllerHelpers
+      extend ActiveSupport::Concern
+
+      # Track the current request with optional extra tags
+      def track_reputable_request(tags: [], **options)
+        Reputable::Tracker.track_request(
+          ip: request.remote_ip,
+          path: request.path,
+          query: request.query_string,
+          method: request.method,
+          session_id: session.id.to_s,
+          session_present: session.any?,
+          user_agent: request.user_agent,
+          referer: request.referer,
+          tags: tags,
+          **options
+        )
+      end
+
+      # Trust the current user's IP (e.g., after payment)
+      def trust_current_ip(reason:, **metadata)
+        Reputable::Reputation.trust_ip(
+          request.remote_ip,
+          reason: reason,
+          **metadata
+        )
+      end
+
+      # Trust the current user
+      def trust_current_user(reason:, **metadata)
+        return false unless respond_to?(:current_user) && current_user
+
+        Reputable::Reputation.trust_user(
+          current_user.id,
+          reason: reason,
+          **metadata
+        )
+      end
+
+      # Trust the current session
+      def trust_current_session(reason:, **metadata)
+        Reputable::Reputation.trust_session(
+          session.id.to_s,
+          reason: reason,
+          **metadata
+        )
+      end
+
+      # Challenge the current IP
+      def challenge_current_ip(reason:, **metadata)
+        Reputable::Reputation.challenge_ip(
+          request.remote_ip,
+          reason: reason,
+          **metadata
+        )
+      end
+
+      # Block the current IP
+      def block_current_ip(reason:, **metadata)
+        Reputable::Reputation.block_ip(
+          request.remote_ip,
+          reason: reason,
+          **metadata
+        )
+      end
+
+      # ========================================
+      # Lookup methods (O(1) Redis lookups)
+      # ========================================
+
+      # Check if current IP is trusted
+      # @return [Boolean]
+      def current_ip_trusted?
+        Reputable::Reputation.trusted_ip?(request.remote_ip)
+      end
+
+      # Check if current IP is blocked
+      # @return [Boolean]
+      def current_ip_blocked?
+        Reputable::Reputation.blocked_ip?(request.remote_ip)
+      end
+
+      # Check if current IP should be challenged
+      # @return [Boolean]
+      def current_ip_challenged?
+        Reputable::Reputation.challenged_ip?(request.remote_ip)
+      end
+
+      # Get full reputation data for current IP
+      # @return [Hash, nil]
+      def current_ip_reputation
+        Reputable::Reputation.lookup(:ip, request.remote_ip)
+      end
+
+      # Get reputation status for current IP
+      # @return [String, nil]
+      def current_ip_status
+        Reputable::Reputation.lookup_ip(request.remote_ip)
+      end
+
+      # Check if current user is trusted
+      # @return [Boolean]
+      def current_user_trusted?
+        return false unless respond_to?(:current_user) && current_user
+        
+        Reputable::Reputation.trusted_user?(current_user.id)
+      end
+
+      # Check if current session is trusted
+      # @return [Boolean]
+      def current_session_trusted?
+        Reputable::Reputation.trusted_session?(session.id.to_s)
+      end
+    end
+  end
+end
+
+# Auto-load Railtie if Rails is present
+if defined?(::Rails::Railtie)
+  require_relative "rails/railtie"
+end