rails-health-checker 0.1.0

data/lib/rails_health_checker/report_generator.rb

@@ -0,0 +1,499 @@
+module RailsHealthChecker
+  class ReportGenerator
+    def initialize(results)
+      @results = results
+      @timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      @gem_details = fetch_gem_changelogs
+    end
+
+    def generate_markdown
+      <<~MARKDOWN
+        # Rails Health Check Report
+
+        **Generated:** #{@timestamp}
+        **Project:** #{project_name}
+
+        ## 📊 Summary
+
+        | Component | Status | Details |
+        |-----------|--------|---------|
+        | Rails | #{status_emoji(@results[:rails_version][:status])} #{@results[:rails_version][:status]} | v#{@results[:rails_version][:current]} |
+        | Ruby | #{status_emoji(@results[:ruby_version][:status])} #{@results[:ruby_version][:status]} | v#{@results[:ruby_version][:current]} |
+        | Database | #{status_emoji(@results[:database][:status])} #{@results[:database][:status]} | #{@results[:database][:connected] ? 'Connected' : 'Disconnected'} |
+        | Gems | #{gem_status_emoji} #{gem_status_text} | #{@results[:gems][:total]} total, #{@results[:gems][:outdated]} outdated |
+        | Security | #{status_emoji(@results[:security][:status])} #{@results[:security][:status]} | #{@results[:security][:outdated_count]} outdated gems |
+        | Background Jobs | #{status_emoji(@results[:jobs][:status])} #{@results[:jobs][:status]} | #{job_summary_text} |
+
+        ## 🔧 Rails Environment
+
+        - **Rails Version:** #{@results[:rails_version][:current]}
+        - **Ruby Version:** #{@results[:ruby_version][:current]}
+        - **Environment:** #{Rails.env rescue 'Unknown'}
+        - **Cache Store:** #{@results[:system][:server_requirements][:cache_store][:type].split('::').last}
+          - #{@results[:system][:server_requirements][:cache_store][:explanation]}
+          - 💡 **Recommendation:** #{@results[:system][:server_requirements][:cache_store][:recommendation]}
+
+        ## 💾 Database
+
+        - **Status:** #{@results[:database][:status]}
+        - **Connected:** #{@results[:database][:connected] ? '✅ Yes' : '❌ No'}
+        #{database_error_section}
+
+        ## 📦 Gem Dependencies
+
+        - **Total Gems:** #{@results[:gems][:total]}
+        - **Outdated Gems:** #{@results[:gems][:outdated]}
+        - **Vulnerable Gems:** #{@results[:gems][:vulnerable]}
+
+        #{outdated_gems_section}
+
+        ## 🔒 Security Analysis
+
+        - **Status:** #{@results[:security][:status]}
+        - **Outdated Packages:** #{@results[:security][:outdated_count]}
+
+        #{security_recommendations}
+
+        ## ⚙️ Background Jobs
+
+        #{background_jobs_section}
+
+        ## 📋 Detailed Gem Analysis
+
+        #{detailed_gem_analysis}
+
+        ## 📝 Changelog & Benefits
+
+        #{changelog_section}
+
+        ## ⚡ Performance Impact
+
+        #{performance_analysis}
+
+        ## 🎯 Priority Actions
+
+        #{priority_actions}
+
+        ## 📈 Recommendations
+
+        #{generate_recommendations}
+
+        ## 📊 Health Score
+
+        #{calculate_health_score}
+
+        ---
+        *Report generated by RailsHealthChecker v#{RailsHealthChecker::VERSION}*
+      MARKDOWN
+    end
+
+    def save_to_file(filename = nil)
+      filename ||= "rails_health_report.md"
+      File.write(filename, generate_markdown)
+      filename
+    end
+
+    private
+
+    def project_name
+      File.basename(Dir.pwd)
+    end
+
+    def status_emoji(status)
+      case status.to_s
+      when 'healthy', 'secure' then '✅'
+      when 'outdated', 'needs_attention' then '⚠️'
+      when 'unhealthy' then '❌'
+      else '❓'
+      end
+    end
+
+    def gem_status_emoji
+      @results[:gems][:outdated] > 0 ? '⚠️' : '✅'
+    end
+
+    def gem_status_text
+      @results[:gems][:outdated] > 0 ? 'needs_attention' : 'healthy'
+    end
+
+    def database_error_section
+      return '' unless @results[:database][:error]
+      "\n- **Error:** #{@results[:database][:error]}"
+    end
+
+    def outdated_gems_section
+      return '' if @results[:gems][:outdated] == 0
+      
+      "\n### Outdated Gems Details\n\n" +
+      @results[:gems][:details].select { |gem| gem[:outdated] }
+        .map { |gem| "- **#{gem[:name]}** (#{gem[:version]})" }
+        .join("\n")
+    end
+
+    def security_recommendations
+      if @results[:security][:outdated_count] > 0
+        "\n⚠️ **Action Required:** Update outdated gems to latest versions"
+      else
+        "\n✅ **Good:** All gems are up to date"
+      end
+    end
+
+    def generate_recommendations
+      recommendations = []
+      
+      recommendations << "- Update Rails to latest version" if @results[:rails_version][:status] == 'outdated'
+      recommendations << "- Update Ruby to latest version" if @results[:ruby_version][:status] == 'outdated'
+      recommendations << "- Fix database connection issues" if @results[:database][:status] == 'unhealthy'
+      recommendations << "- Run `bundle update` to update outdated gems" if @results[:gems][:outdated] > 0
+      recommendations << "- Review and update security-vulnerable packages" if @results[:security][:outdated_count] > 0
+      
+      recommendations.empty? ? "✅ **Excellent!** Your Rails application is healthy." : recommendations.join("\n")
+    end
+
+    def fetch_gem_changelogs
+      outdated_gems = @results[:gems][:details].select { |gem| gem[:outdated] }
+      outdated_gems.map do |gem|
+        {
+          name: gem[:name],
+          current_version: gem[:version],
+          benefits: get_update_benefits(gem[:name]),
+          changelog_url: get_changelog_url(gem[:name])
+        }
+      end
+    end
+
+    def get_update_benefits(gem_name)
+      benefits = {
+        'rails' => ['Security patches', 'Performance improvements', 'New features', 'Bug fixes'],
+        'pg' => ['Database performance', 'Connection stability', 'Security updates'],
+        'puma' => ['Server performance', 'Memory usage optimization', 'Security fixes'],
+        'bootsnap' => ['Faster boot times', 'Reduced memory usage'],
+        'turbo-rails' => ['Better SPA experience', 'Performance improvements'],
+        'stimulus-rails' => ['Enhanced JavaScript framework', 'Better DOM manipulation']
+      }
+      benefits[gem_name] || ['Security updates', 'Bug fixes', 'Performance improvements']
+    end
+
+    def get_changelog_url(gem_name)
+      "https://github.com/search?q=#{gem_name}+changelog&type=repositories"
+    end
+
+    def detailed_gem_analysis
+      return "All gems are up to date! ✅" if @results[:gems][:outdated] == 0
+      
+      analysis = []
+      critical_gems = ['rails', 'pg', 'puma', 'bootsnap']
+      
+      @results[:gems][:details].select { |gem| gem[:outdated] }.each do |gem|
+        priority = critical_gems.include?(gem[:name]) ? '🔴 HIGH' : '🟡 MEDIUM'
+        analysis << "### #{gem[:name]} #{priority}"
+        analysis << "- **Current Version:** #{gem[:version]}"
+        analysis << "- **Status:** Outdated"
+        analysis << "- **Impact:** #{get_gem_impact(gem[:name])}"
+        analysis << ""
+      end
+      
+      analysis.join("\n")
+    end
+
+    def get_gem_impact(gem_name)
+      impacts = {
+        'rails' => 'Core framework - affects entire application',
+        'pg' => 'Database connectivity and performance',
+        'puma' => 'Web server performance and stability',
+        'bootsnap' => 'Application boot time and caching',
+        'turbo-rails' => 'Frontend performance and user experience',
+        'stimulus-rails' => 'JavaScript functionality'
+      }
+      impacts[gem_name] || 'General application functionality'
+    end
+
+    def changelog_section
+      return "No outdated gems found. ✅" if @gem_details.empty?
+      
+      changelog = []
+      @gem_details.each do |gem|
+        changelog << "### #{gem[:name]}"
+        changelog << "**Benefits of updating:**"
+        gem[:benefits].each { |benefit| changelog << "- #{benefit}" }
+        changelog << "**Changelog:** [View on GitHub](#{gem[:changelog_url]})"
+        changelog << ""
+      end
+      
+      changelog.join("\n")
+    end
+
+    def performance_analysis
+      score = calculate_performance_score
+      
+      analysis = []
+      analysis << "**Overall Performance Score:** #{score}/100"
+      analysis << ""
+      
+      if @results[:rails_version][:status] == 'outdated'
+        analysis << "- ⚠️ **Rails Version Impact:** Outdated Rails may have performance penalties"
+      end
+      
+      if @results[:gems][:outdated] > 10
+        analysis << "- ⚠️ **Gem Dependencies:** High number of outdated gems may impact performance"
+      end
+      
+      if @results[:database][:status] == 'unhealthy'
+        analysis << "- ❌ **Database Performance:** Connection issues will severely impact performance"
+      end
+      
+      analysis << "- ✅ **Optimization Tip:** Keep gems updated for best performance" if @results[:gems][:outdated] > 0
+      
+      analysis.join("\n")
+    end
+
+    def calculate_performance_score
+      score = 100
+      score -= 20 if @results[:rails_version][:status] == 'outdated'
+      score -= 15 if @results[:ruby_version][:status] == 'outdated'
+      score -= 30 if @results[:database][:status] == 'unhealthy'
+      score -= (@results[:gems][:outdated] * 2) # 2 points per outdated gem
+      score -= (@results[:security][:outdated_count] * 3) # 3 points per security issue
+      [score, 0].max
+    end
+
+    def priority_actions
+      actions = []
+      
+      if @results[:database][:status] == 'unhealthy'
+        actions << "🔴 **CRITICAL:** Fix database connection immediately"
+      end
+      
+      if @results[:rails_version][:status] == 'outdated'
+        actions << "🟠 **HIGH:** Update Rails framework"
+      end
+      
+      if @results[:security][:outdated_count] > 5
+        actions << "🟠 **HIGH:** Address security vulnerabilities"
+      end
+      
+      if @results[:gems][:outdated] > 10
+        actions << "🟡 **MEDIUM:** Update outdated gems"
+      end
+      
+      if @results[:ruby_version][:status] == 'outdated'
+        actions << "🟡 **MEDIUM:** Consider Ruby version upgrade"
+      end
+      
+      actions.empty? ? "✅ No critical actions required!" : actions.join("\n")
+    end
+
+    def calculate_health_score
+      score = calculate_performance_score
+      reasons = get_score_reasons
+      
+      status = case score
+               when 90..100 then "✅ Excellent"
+               when 70..89 then "🟡 Good"
+               when 50..69 then "🟠 Needs Attention"
+               else "🔴 Critical"
+               end
+      
+      result = "🏆 **Overall Health Score: #{score}/100 (#{status})**\n\n"
+      
+      if score < 70
+        result += "**⚠️ Critical Issues Detected:**\n#{reasons[:critical].join("\n")}\n\n" unless reasons[:critical].empty?
+        result += "**🟡 Warning Issues:**\n#{reasons[:warnings].join("\n")}\n\n" unless reasons[:warnings].empty?
+      end
+      
+      result += "**Score Breakdown:**\n" +
+      "- Rails Version: #{@results[:rails_version][:status] == 'healthy' ? '+20' : '-20'} #{rails_score_reason}\n" +
+      "- Ruby Version: #{@results[:ruby_version][:status] == 'healthy' ? '+15' : '-15'} #{ruby_score_reason}\n" +
+      "- Database: #{@results[:database][:status] == 'healthy' ? '+30' : '-30'} #{database_score_reason}\n" +
+      "- Gem Dependencies: -#{@results[:gems][:outdated] * 2} (#{@results[:gems][:outdated]} outdated gems)\n" +
+      "- Security: -#{@results[:security][:outdated_count] * 3} (#{@results[:security][:outdated_count]} security issues)\n" +
+      "- Background Jobs: #{job_score_impact} #{job_score_reason}\n\n" +
+      "**Improvement Suggestions:**\n#{get_improvement_suggestions.join("\n")}"
+      
+      result
+    end
+
+    def job_summary_text
+      jobs = @results[:jobs]
+      return 'Not configured' if jobs[:status] == 'not_configured'
+      return 'Error' if jobs[:status] == 'error'
+      
+      parts = []
+      parts << "Sidekiq: #{jobs[:sidekiq][:status]}" if jobs[:sidekiq][:available]
+      parts << "Resque: #{jobs[:resque][:status]}" if jobs[:resque][:available]
+      parts << "ActiveJob: #{jobs[:active_job][:status]}" if jobs[:active_job][:available]
+      
+      parts.empty? ? 'Not configured' : parts.join(', ')
+    end
+
+    def background_jobs_section
+      jobs = @results[:jobs]
+      return "No background job systems detected." if jobs[:status] == 'not_configured'
+      
+      sections = []
+      
+      if jobs[:sidekiq][:available]
+        sections << sidekiq_section(jobs[:sidekiq])
+      end
+      
+      if jobs[:resque][:available]
+        sections << resque_section(jobs[:resque])
+      end
+      
+      if jobs[:active_job][:available]
+        sections << active_job_section(jobs[:active_job])
+      end
+      
+      sections.join("\n\n")
+    end
+
+    def sidekiq_section(sidekiq)
+      return "### Sidekiq\n- **Status:** Error (#{sidekiq[:error]})" if sidekiq[:error]
+      
+      <<~SECTION
+        ### Sidekiq
+        - **Status:** #{sidekiq[:status].capitalize}
+        - **Processed Jobs:** #{sidekiq[:processed]}
+        - **Failed Jobs:** #{sidekiq[:failed]}
+        - **Enqueued Jobs:** #{sidekiq[:enqueued]}
+        - **Retry Queue:** #{sidekiq[:retry_size]}
+        - **Dead Queue:** #{sidekiq[:dead_size]}
+        - **Active Workers:** #{sidekiq[:workers]}
+        - **Queues:** #{sidekiq[:queues].size}
+      SECTION
+    end
+
+    def resque_section(resque)
+      return "### Resque\n- **Status:** Error (#{resque[:error]})" if resque[:error]
+      
+      <<~SECTION
+        ### Resque
+        - **Status:** #{resque[:status].capitalize}
+        - **Pending Jobs:** #{resque[:pending]}
+        - **Processed Jobs:** #{resque[:processed]}
+        - **Failed Jobs:** #{resque[:failed]}
+        - **Workers:** #{resque[:workers]}
+        - **Working:** #{resque[:working]}
+        - **Queues:** #{resque[:queues]}
+      SECTION
+    end
+
+    def active_job_section(active_job)
+      return "### ActiveJob\n- **Status:** Error (#{active_job[:error]})" if active_job[:error]
+      
+      <<~SECTION
+        ### ActiveJob
+        - **Status:** #{active_job[:status].capitalize}
+        - **Adapter:** #{active_job[:adapter]}
+      SECTION
+    end
+
+    def job_score_impact
+      case @results[:jobs][:status]
+      when 'critical' then '-15'
+      when 'warning' then '-10'
+      when 'error' then '-20'
+      when 'not_configured' then '+0'
+      else '+5'
+      end
+    end
+
+    def get_score_reasons
+      critical = []
+      warnings = []
+      
+      # Critical issues (major score impact)
+      if @results[:database][:status] == 'unhealthy'
+        critical << "❌ **Database Connection Failed** - Application cannot function without database access"
+      end
+      
+      if @results[:jobs][:status] == 'critical'
+        critical << "❌ **Background Jobs System Critical** - Job processing is severely impacted"
+      end
+      
+      if @results[:rails_version][:status] == 'outdated'
+        critical << "⚠️ **Outdated Rails Version** - Security and performance risks"
+      end
+      
+      # Warning issues (moderate score impact)
+      if @results[:gems][:outdated] > 20
+        warnings << "🟡 **Many Outdated Gems** - #{@results[:gems][:outdated]} gems need updates"
+      end
+      
+      if @results[:security][:outdated_count] > 10
+        warnings << "🟡 **Security Vulnerabilities** - #{@results[:security][:outdated_count]} potential security issues"
+      end
+      
+      if @results[:ruby_version][:status] == 'outdated'
+        warnings << "🟡 **Outdated Ruby Version** - Consider upgrading for better performance"
+      end
+      
+      { critical: critical, warnings: warnings }
+    end
+
+    def rails_score_reason
+      case @results[:rails_version][:status]
+      when 'healthy' then '(Current and supported)'
+      when 'outdated' then '(Outdated - security risk)'
+      else '(Unknown status)'
+      end
+    end
+
+    def ruby_score_reason
+      case @results[:ruby_version][:status]
+      when 'healthy' then '(Current and supported)'
+      when 'outdated' then '(Outdated - performance impact)'
+      else '(Unknown status)'
+      end
+    end
+
+    def database_score_reason
+      case @results[:database][:status]
+      when 'healthy' then '(Connected and responsive)'
+      when 'unhealthy' then '(Connection failed - critical issue)'
+      else '(Unknown status)'
+      end
+    end
+
+    def job_score_reason
+      case @results[:jobs][:status]
+      when 'healthy' then '(All job systems operational)'
+      when 'warning' then '(High queue sizes detected)'
+      when 'critical' then '(Job system failures detected)'
+      when 'error' then '(Job system errors)'
+      when 'not_configured' then '(No background job system)'
+      else '(Unknown status)'
+      end
+    end
+
+    def get_improvement_suggestions
+      suggestions = []
+      
+      if @results[:database][:status] == 'unhealthy'
+        suggestions << "1. 🔴 **URGENT**: Fix database connection - check credentials, network, and database server status"
+      end
+      
+      if @results[:rails_version][:status] == 'outdated'
+        suggestions << "2. 🟠 **HIGH**: Update Rails to latest stable version for security patches"
+      end
+      
+      if @results[:gems][:outdated] > 10
+        suggestions << "3. 🟡 **MEDIUM**: Run 'bundle update' to update outdated gems"
+      end
+      
+      if @results[:security][:outdated_count] > 5
+        suggestions << "4. 🟡 **MEDIUM**: Review and update gems with security vulnerabilities"
+      end
+      
+      if @results[:jobs][:status] == 'critical'
+        suggestions << "5. 🔴 **URGENT**: Check background job system configuration and restart workers"
+      end
+      
+      if suggestions.empty?
+        suggestions << "✅ **Great!** Your application is in excellent health. Keep monitoring regularly."
+      end
+      
+      suggestions
+    end
+  end
+end

data/lib/rails_health_checker/system_analyzer.rb

@@ -0,0 +1,182 @@
+module RailsHealthChecker
+  class SystemAnalyzer
+    def analyze
+      {
+        rails_info: rails_system_info,
+        required_libs: check_required_libraries,
+        optional_libs: check_optional_libraries,
+        server_requirements: check_server_requirements,
+        cable_info: check_action_cable,
+        environment_info: environment_details
+      }
+    end
+
+    private
+
+    def rails_system_info
+      {
+        version: Rails.version,
+        environment: Rails.env,
+        root: Rails.root.to_s,
+        config_loaded: Rails.application.config.loaded?,
+        eager_load: Rails.application.config.eager_load,
+        cache_classes: Rails.application.config.cache_classes
+      }
+    rescue => e
+      { error: e.message }
+    end
+
+    def check_required_libraries
+      required = {
+        'bundler' => { required: true, available: defined?(Bundler), purpose: 'Dependency management' },
+        'rack' => { required: true, available: defined?(Rack), purpose: 'Web server interface' },
+        'activerecord' => { required: true, available: defined?(ActiveRecord), purpose: 'Database ORM' },
+        'actionpack' => { required: true, available: defined?(ActionPack), purpose: 'Web framework core' },
+        'activesupport' => { required: true, available: defined?(ActiveSupport), purpose: 'Core extensions' }
+      }
+      
+      required.each do |name, info|
+        info[:status] = info[:available] ? 'loaded' : 'missing'
+        info[:version] = get_gem_version(name) if info[:available]
+      end
+      
+      required
+    end
+
+    def check_optional_libraries
+      optional = {
+        'sidekiq' => { available: defined?(Sidekiq), purpose: 'Background job processing' },
+        'resque' => { available: defined?(Resque), purpose: 'Background job processing' },
+        'redis' => { available: defined?(Redis), purpose: 'In-memory data store' },
+        'puma' => { available: defined?(Puma), purpose: 'Web server' },
+        'unicorn' => { available: defined?(Unicorn), purpose: 'Web server' },
+        'passenger' => { available: defined?(PhusionPassenger), purpose: 'Web server' },
+        'devise' => { available: defined?(Devise), purpose: 'Authentication' },
+        'cancancan' => { available: defined?(CanCan), purpose: 'Authorization' },
+        'turbo-rails' => { available: defined?(Turbo), purpose: 'SPA-like experience' },
+        'stimulus-rails' => { available: defined?(Stimulus), purpose: 'JavaScript framework' },
+        'bootsnap' => { available: defined?(Bootsnap), purpose: 'Boot optimization' },
+        'sprockets' => { available: defined?(Sprockets), purpose: 'Asset pipeline' }
+      }
+      
+      optional.each do |name, info|
+        info[:status] = info[:available] ? 'loaded' : 'not_loaded'
+        info[:version] = get_gem_version(name) if info[:available]
+      end
+      
+      optional
+    end
+
+    def check_server_requirements
+      {
+        web_server: detect_web_server,
+        database: detect_database_adapter,
+        cache_store: detect_cache_store,
+        session_store: detect_session_store,
+        asset_host: (Rails.application.config.asset_host rescue nil)
+      }
+    end
+
+    def check_action_cable
+      return { available: false } unless defined?(ActionCable)
+      
+      {
+        available: true,
+        adapter: (ActionCable.server.config.cable[:adapter] rescue 'unknown'),
+        url: (ActionCable.server.config.cable[:url] rescue nil),
+        allowed_request_origins: (ActionCable.server.config.allowed_request_origins rescue []),
+        status: action_cable_status
+      }
+    end
+
+    def environment_details
+      {
+        ruby_version: RUBY_VERSION,
+        ruby_platform: RUBY_PLATFORM,
+        rails_env: Rails.env,
+        rack_env: ENV['RACK_ENV'],
+        database_url: ENV['DATABASE_URL'] ? 'configured' : 'not_set',
+        redis_url: ENV['REDIS_URL'] ? 'configured' : 'not_set',
+        secret_key_base: ENV['SECRET_KEY_BASE'] ? 'configured' : 'not_set'
+      }
+    end
+
+    def get_gem_version(gem_name)
+      Gem.loaded_specs[gem_name]&.version&.to_s || 'unknown'
+    rescue
+      'unknown'
+    end
+
+    def detect_web_server
+      return 'puma' if defined?(Puma)
+      return 'unicorn' if defined?(Unicorn)
+      return 'passenger' if defined?(PhusionPassenger)
+      return 'thin' if defined?(Thin)
+      return 'webrick' if defined?(WEBrick)
+      'unknown'
+    end
+
+    def detect_database_adapter
+      ActiveRecord::Base.connection.adapter_name
+    rescue
+      'unknown'
+    end
+
+    def detect_cache_store
+      cache_class = Rails.cache.class.name
+      {
+        type: cache_class,
+        explanation: get_cache_explanation(cache_class),
+        recommendation: get_cache_recommendation(cache_class)
+      }
+    rescue
+      {
+        type: 'unknown',
+        explanation: 'Unable to detect cache store',
+        recommendation: 'Check Rails cache configuration'
+      }
+    end
+
+    def detect_session_store
+      Rails.application.config.session_store.name
+    rescue
+      'unknown'
+    end
+
+    def action_cable_status
+      return 'healthy' if ActionCable.server.config.cable[:adapter] != 'test'
+      'not_configured'
+    rescue
+      'error'
+    end
+
+    def get_cache_explanation(cache_class)
+      explanations = {
+        'ActiveSupport::Cache::NullStore' => 'No caching (common in development)',
+        'ActiveSupport::Cache::MemoryStore' => 'In-memory caching (single process)',
+        'ActiveSupport::Cache::FileStore' => 'File-based caching (disk storage)',
+        'ActiveSupport::Cache::RedisStore' => 'Redis-based caching (recommended for production)',
+        'ActiveSupport::Cache::MemCacheStore' => 'Memcached-based caching (production ready)',
+        'ActiveSupport::Cache::RedisCacheStore' => 'Redis caching with Rails 5.2+ features'
+      }
+      explanations[cache_class] || 'Custom or unknown cache store'
+    end
+
+    def get_cache_recommendation(cache_class)
+      case cache_class
+      when 'ActiveSupport::Cache::NullStore'
+        Rails.env.production? ? 'Configure Redis or Memcached for production' : 'OK for development'
+      when 'ActiveSupport::Cache::MemoryStore'
+        'Consider Redis/Memcached for multi-server deployments'
+      when 'ActiveSupport::Cache::FileStore'
+        'Consider Redis/Memcached for better performance'
+      when 'ActiveSupport::Cache::RedisStore', 'ActiveSupport::Cache::RedisCacheStore'
+        'Excellent choice for production'
+      when 'ActiveSupport::Cache::MemCacheStore'
+        'Good choice for production'
+      else
+        'Verify cache store configuration'
+      end
+    end
+  end
+end