rails-health-checker 0.1.0 → 0.2.0

data/lib/rails_health_checker/system_analyzer.rb

@@ -1,182 +0,0 @@
-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

data/lib/rails_health_checker/tasks.rb

@@ -1,63 +0,0 @@
-namespace :health do
-  desc "Run comprehensive health check"
-  task check: :environment do
-    RailsHealthChecker.check
-  end
-
-  desc "Check gem dependencies"
-  task gems: :environment do
-    analyzer = RailsHealthChecker::GemAnalyzer.new
-    results = analyzer.analyze
-    
-    puts "=== Gem Health Report ==="
-    puts "Total gems: #{results[:total]}"
-    puts "Outdated gems: #{results[:outdated]}"
-    puts "Vulnerable gems: #{results[:vulnerable]}"
-    puts "========================="
-  end
-
-  desc "Check database connectivity"
-  task database: :environment do
-    begin
-      ActiveRecord::Base.connection.active?
-      puts "✓ Database connection: healthy"
-    rescue => e
-      puts "✗ Database connection: failed (#{e.message})"
-    end
-  end
-
-  desc "Check background jobs health"
-  task jobs: :environment do
-    analyzer = RailsHealthChecker::JobAnalyzer.new
-    results = analyzer.analyze
-    
-    puts "=== Background Jobs Health ==="
-    puts "Overall Status: #{results[:status]}"
-    
-    if results[:sidekiq][:available]
-      sidekiq = results[:sidekiq]
-      puts "\nSidekiq:"
-      puts "  Status: #{sidekiq[:status]}"
-      puts "  Enqueued: #{sidekiq[:enqueued]}" unless sidekiq[:error]
-      puts "  Failed: #{sidekiq[:failed]}" unless sidekiq[:error]
-    end
-    
-    if results[:resque][:available]
-      resque = results[:resque]
-      puts "\nResque:"
-      puts "  Status: #{resque[:status]}"
-      puts "  Pending: #{resque[:pending]}" unless resque[:error]
-      puts "  Failed: #{resque[:failed]}" unless resque[:error]
-    end
-    
-    puts "============================="
-  end
-
-  desc "Generate detailed health report file"
-  task report: :environment do
-    results = RailsHealthChecker::Checker.new.run
-    report_generator = RailsHealthChecker::ReportGenerator.new(results)
-    filename = report_generator.save_to_file
-    puts "📄 Health report updated: #{filename}"
-  end
-end

data/lib/rails_health_checker/version.rb

@@ -1,3 +0,0 @@
-module RailsHealthChecker
-  VERSION = "0.1.0"
-end

data/lib/rails_health_checker.rb

@@ -1,17 +0,0 @@
-require_relative "rails_health_checker/version"
-require_relative "rails_health_checker/checker"
-require_relative "rails_health_checker/gem_analyzer"
-require_relative "rails_health_checker/job_analyzer"
-require_relative "rails_health_checker/system_analyzer"
-require_relative "rails_health_checker/health_middleware"
-require_relative "rails_health_checker/dashboard_middleware"
-require_relative "rails_health_checker/report_generator"
-require_relative "rails_health_checker/railtie" if defined?(Rails)
-
-module RailsHealthChecker
-  class Error < StandardError; end
-
-  def self.check
-    Checker.new.run
-  end
-end

data/rails_health_checker.gemspec

@@ -1,33 +0,0 @@
-require_relative "lib/rails_health_checker/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "rails-health-checker"
-  spec.version = RailsHealthChecker::VERSION
-  spec.authors = ["Arshdeep Singh"]
-  spec.email = ["arsh199820@gmail.com"]
-
-  spec.summary = "Comprehensive health checker for Rails applications and dependencies"
-  spec.description = "A Ruby gem that provides comprehensive health checking for Rails applications, including database connectivity, gem dependencies, security vulnerabilities, and system health monitoring with a web dashboard."
-  spec.homepage = "https://rails-health-checker.netlify.app"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
-
-  spec.metadata["homepage_uri"] = "https://rails-health-checker.netlify.app"
-  spec.metadata["source_code_uri"] = "https://github.com/ArshdeepGrover/rails-health-checker"
-  spec.metadata["changelog_uri"] = "https://github.com/ArshdeepGrover/rails-health-checker/blob/main/CHANGELOG.md"
-  spec.metadata["documentation_uri"] = "https://rails-health-checker.netlify.app"
-  spec.metadata["bug_tracker_uri"] = "https://github.com/ArshdeepGrover/rails-health-checker/issues"
-
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
-    end
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "rails", ">= 6.0"
-  spec.add_dependency "bundler", ">= 2.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-end

data/simple_test.rb

@@ -1,52 +0,0 @@
-#!/usr/bin/env ruby
-
-require_relative 'lib/rails_health_checker/version'
-require_relative 'lib/rails_health_checker/gem_analyzer'
-
-puts "=== Simple Gem Test ==="
-puts "Version: #{RailsHealthChecker::VERSION}"
-
-# Test gem analyzer with mocked Bundler
-module Bundler
-  def self.load
-    MockBundler.new
-  end
-end
-
-class MockBundler
-  def specs
-    [
-      MockGem.new('rails', '7.0.0'),
-      MockGem.new('rspec', '3.12.0')
-    ]
-  end
-end
-
-class MockGem
-  attr_reader :name, :version
-  
-  def initialize(name, version)
-    @name = name
-    @version = MockVersion.new(version)
-  end
-  
-  def gem_dir
-    "/path/to/#{name}"
-  end
-end
-
-class MockVersion
-  def initialize(version)
-    @version = version
-  end
-  
-  def to_s
-    @version
-  end
-end
-
-analyzer = RailsHealthChecker::GemAnalyzer.new
-results = analyzer.analyze
-
-puts "✓ Gem analysis: #{results[:total]} gems, #{results[:outdated]} outdated"
-puts "✅ Basic functionality works!"

data/test_gem.rb

@@ -1,100 +0,0 @@
-#!/usr/bin/env ruby
-
-# Simple test script to verify gem functionality
-require_relative 'lib/rails_health_checker'
-
-# Mock Rails and ActiveRecord for testing
-module Rails
-  def self.version
-    "7.0.0"
-  end
-end
-
-module ActiveRecord
-  class Base
-    def self.connection
-      MockConnection.new
-    end
-  end
-end
-
-class MockConnection
-  def active?
-    true
-  end
-end
-
-class Time
-  def self.current
-    Time.now
-  end
-end
-
-# Mock Bundler
-module Bundler
-  def self.load
-    MockBundler.new
-  end
-end
-
-class MockBundler
-  def specs
-    [
-      MockGem.new('rails', '7.0.0'),
-      MockGem.new('rspec', '3.12.0')
-    ]
-  end
-end
-
-class MockGem
-  attr_reader :name, :version
-  
-  def initialize(name, version)
-    @name = name
-    @version = MockVersion.new(version)
-  end
-  
-  def gem_dir
-    "/path/to/#{name}"
-  end
-end
-
-class MockVersion
-  def initialize(version)
-    @version = version
-  end
-  
-  def to_s
-    @version
-  end
-end
-
-# Test the gem
-puts "Testing RailsHealthChecker gem..."
-
-begin
-  # Test version
-  puts "✓ Version: #{RailsHealthChecker::VERSION}"
-  
-  # Test checker
-  checker = RailsHealthChecker::Checker.new
-  results = checker.run
-  puts "✓ Health check completed"
-  
-  # Test gem analyzer
-  analyzer = RailsHealthChecker::GemAnalyzer.new
-  gem_results = analyzer.analyze
-  puts "✓ Gem analysis completed: #{gem_results[:total]} gems found"
-  
-  # Test middleware
-  middleware = RailsHealthChecker::HealthMiddleware.new(nil)
-  env = { 'PATH_INFO' => '/health' }
-  response = middleware.call(env)
-  puts "✓ Health endpoint returns: #{response[0]} status"
-  
-  puts "\n✅ All tests passed!"
-  
-rescue => e
-  puts "❌ Test failed: #{e.message}"
-  puts e.backtrace.first(3)
-end