fluyenta-ruby 0.1.14

data/lib/brainzlab/utilities/health_check.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Utilities
+    # Health check utility for application health endpoints
+    # Provides checks for database, cache, queues, and external services
+    #
+    # @example Basic usage in Rails routes
+    #   # config/routes.rb
+    #   mount BrainzLab::Utilities::HealthCheck::Engine => "/health"
+    #
+    # @example Manual usage
+    #   result = BrainzLab::Utilities::HealthCheck.run
+    #   result[:status]  # => "healthy" or "unhealthy"
+    #   result[:checks]  # => { database: { status: "ok", latency_ms: 5 }, ... }
+    #
+    class HealthCheck
+      CHECKS = %i[database redis cache queue memory disk].freeze
+
+      class << self
+        # Run all configured health checks
+        def run(checks: nil)
+          checks_to_run = checks || CHECKS
+          results = {}
+          overall_healthy = true
+
+          checks_to_run.each do |check|
+            result = send("check_#{check}")
+            results[check] = result
+            overall_healthy = false if result[:status] != 'ok'
+          rescue StandardError => e
+            results[check] = { status: 'error', message: e.message }
+            overall_healthy = false
+          end
+
+          {
+            status: overall_healthy ? 'healthy' : 'unhealthy',
+            timestamp: Time.now.utc.iso8601,
+            checks: results
+          }
+        end
+
+        # Quick check - just returns status
+        def healthy?
+          result = run
+          result[:status] == 'healthy'
+        end
+
+        # Database connectivity check
+        def check_database
+          return { status: 'skip', message: 'ActiveRecord not loaded' } unless defined?(ActiveRecord::Base)
+
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          ActiveRecord::Base.connection.execute('SELECT 1')
+          latency = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round(2)
+
+          { status: 'ok', latency_ms: latency }
+        rescue StandardError => e
+          { status: 'error', message: e.message }
+        end
+
+        # Redis connectivity check
+        def check_redis
+          return { status: 'skip', message: 'Redis not configured' } unless defined?(Redis)
+
+          redis = find_redis_connection
+          return { status: 'skip', message: 'No Redis connection found' } unless redis
+
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          redis.ping
+          latency = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round(2)
+
+          { status: 'ok', latency_ms: latency }
+        rescue StandardError => e
+          { status: 'error', message: e.message }
+        end
+
+        # Rails cache check
+        def check_cache
+          return { status: 'skip', message: 'Rails not loaded' } unless defined?(Rails)
+
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          key = "brainzlab_health_check_#{SecureRandom.hex(4)}"
+          Rails.cache.write(key, 'ok', expires_in: 10.seconds)
+          value = Rails.cache.read(key)
+          Rails.cache.delete(key)
+          latency = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round(2)
+
+          if value == 'ok'
+            { status: 'ok', latency_ms: latency }
+          else
+            { status: 'error', message: 'Cache read/write failed' }
+          end
+        rescue StandardError => e
+          { status: 'error', message: e.message }
+        end
+
+        # Queue system check
+        def check_queue
+          if defined?(SolidQueue)
+            check_solid_queue
+          elsif defined?(Sidekiq)
+            check_sidekiq
+          elsif defined?(GoodJob)
+            check_good_job
+          else
+            { status: 'skip', message: 'No queue system detected' }
+          end
+        end
+
+        # Memory usage check
+        def check_memory
+          mem_info = memory_usage
+
+          status = if mem_info[:percentage] > 90
+                     'warning'
+                   elsif mem_info[:percentage] > 95
+                     'error'
+                   else
+                     'ok'
+                   end
+
+          {
+            status: status,
+            used_mb: mem_info[:used_mb],
+            percentage: mem_info[:percentage]
+          }
+        rescue StandardError => e
+          { status: 'error', message: e.message }
+        end
+
+        # Disk space check
+        def check_disk
+          disk_info = disk_usage
+
+          status = if disk_info[:percentage] > 90
+                     'warning'
+                   elsif disk_info[:percentage] > 95
+                     'error'
+                   else
+                     'ok'
+                   end
+
+          {
+            status: status,
+            used_gb: disk_info[:used_gb],
+            available_gb: disk_info[:available_gb],
+            percentage: disk_info[:percentage]
+          }
+        rescue StandardError => e
+          { status: 'error', message: e.message }
+        end
+
+        # Register a custom health check
+        def register(name, &block)
+          custom_checks[name.to_sym] = block
+        end
+
+        def custom_checks
+          @custom_checks ||= {}
+        end
+
+        private
+
+        def find_redis_connection
+          # Try common Redis connection sources
+          if defined?(Redis.current) && Redis.current
+            Redis.current
+          elsif defined?(Sidekiq) && Sidekiq.respond_to?(:redis)
+            Sidekiq.redis { |conn| return conn }
+          elsif defined?(Rails) && Rails.application.config.respond_to?(:redis)
+            Rails.application.config.redis
+          end
+        rescue StandardError
+          nil
+        end
+
+        def check_solid_queue
+          return { status: 'skip', message: 'SolidQueue not loaded' } unless defined?(SolidQueue)
+
+          # Check if processes are running
+          if defined?(SolidQueue::Process)
+            process_count = SolidQueue::Process.where('last_heartbeat_at > ?', 5.minutes.ago).count
+            {
+              status: process_count.positive? ? 'ok' : 'warning',
+              processes: process_count
+            }
+          else
+            { status: 'ok', message: 'SolidQueue configured' }
+          end
+        rescue StandardError => e
+          { status: 'error', message: e.message }
+        end
+
+        def check_sidekiq
+          return { status: 'skip', message: 'Sidekiq not loaded' } unless defined?(Sidekiq)
+
+          stats = Sidekiq::Stats.new
+          {
+            status: 'ok',
+            processed: stats.processed,
+            failed: stats.failed,
+            queues: stats.queues,
+            workers: stats.workers_size
+          }
+        rescue StandardError => e
+          { status: 'error', message: e.message }
+        end
+
+        def check_good_job
+          return { status: 'skip', message: 'GoodJob not loaded' } unless defined?(GoodJob)
+
+          {
+            status: 'ok',
+            pending: GoodJob::Job.where(performed_at: nil).count,
+            running: GoodJob::Job.running.count
+          }
+        rescue StandardError => e
+          { status: 'error', message: e.message }
+        end
+
+        def memory_usage
+          # Use /proc/self/status on Linux, ps on macOS
+          if File.exist?('/proc/self/status')
+            status = File.read('/proc/self/status')
+            vm_rss = status.match(/VmRSS:\s+(\d+)\s+kB/)&.captures&.first.to_i
+            used_mb = (vm_rss / 1024.0).round(2)
+          else
+            # macOS fallback
+            pid = Process.pid
+            output = `ps -o rss= -p #{pid}`.strip
+            used_mb = (output.to_i / 1024.0).round(2)
+          end
+
+          # Estimate percentage (based on typical container memory)
+          max_mb = ENV.fetch('MEMORY_LIMIT_MB', 512).to_i
+          percentage = ((used_mb / max_mb) * 100).round(2)
+
+          { used_mb: used_mb, percentage: percentage }
+        end
+
+        def disk_usage
+          output = `df -k /`.split("\n").last.split
+          total = output[1].to_i / 1024 / 1024.0
+          used = output[2].to_i / 1024 / 1024.0
+          available = output[3].to_i / 1024 / 1024.0
+          percentage = ((used / total) * 100).round(2)
+
+          {
+            used_gb: used.round(2),
+            available_gb: available.round(2),
+            percentage: percentage
+          }
+        end
+      end
+
+      # Rails Engine for mounting health endpoints
+      if defined?(::Rails::Engine)
+        class Engine < ::Rails::Engine
+          isolate_namespace BrainzLab::Utilities::HealthCheck
+
+          routes.draw do
+            get '/', to: 'health#show'
+            get '/live', to: 'health#live'
+            get '/ready', to: 'health#ready'
+          end
+        end
+      end
+
+      # Controller for health endpoints
+      if defined?(ActionController::API)
+        class HealthController < ActionController::API
+          def show
+            result = HealthCheck.run
+            status = result[:status] == 'healthy' ? :ok : :service_unavailable
+            render json: result, status: status
+          end
+
+          def live
+            # Liveness probe - just check if the app is running
+            render json: { status: 'ok', timestamp: Time.now.utc.iso8601 }
+          end
+
+          def ready
+            # Readiness probe - check critical dependencies
+            result = HealthCheck.run(checks: %i[database redis])
+            status = result[:status] == 'healthy' ? :ok : :service_unavailable
+            render json: result, status: status
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/utilities/log_formatter.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Utilities
+    # Beautiful log formatter for Rails development
+    # Provides colorized, structured output with request timing
+    #
+    # @example Usage in Rails
+    #   # config/environments/development.rb
+    #   config.log_formatter = BrainzLab::Utilities::LogFormatter.new
+    #
+    #   # Or use the Rails integration
+    #   BrainzLab::Utilities::LogFormatter.install!
+    #
+    class LogFormatter < ::Logger::Formatter
+      COLORS = {
+        debug: "\e[36m",    # Cyan
+        info: "\e[32m",     # Green
+        warn: "\e[33m",     # Yellow
+        error: "\e[31m",    # Red
+        fatal: "\e[35m",    # Magenta
+        reset: "\e[0m",
+        dim: "\e[2m",
+        bold: "\e[1m",
+        blue: "\e[34m",
+        gray: "\e[90m"
+      }.freeze
+
+      SEVERITY_ICONS = {
+        'DEBUG' => '🔍',
+        'INFO' => 'ℹ️ ',
+        'WARN' => '⚠️ ',
+        'ERROR' => '❌',
+        'FATAL' => '💀'
+      }.freeze
+
+      HTTP_METHODS = {
+        'GET' => "\e[32m",     # Green
+        'POST' => "\e[33m",    # Yellow
+        'PUT' => "\e[34m",     # Blue
+        'PATCH' => "\e[34m",   # Blue
+        'DELETE' => "\e[31m",  # Red
+        'HEAD' => "\e[36m",    # Cyan
+        'OPTIONS' => "\e[36m"  # Cyan
+      }.freeze
+
+      def initialize(colorize: nil, show_timestamp: true, show_severity: true, compact: false)
+        super()
+        @colorize = colorize.nil? ? $stdout.tty? : colorize
+        @show_timestamp = show_timestamp
+        @show_severity = show_severity
+        @compact = compact
+      end
+
+      def call(severity, timestamp, progname, msg)
+        return '' if msg.nil? || msg.to_s.strip.empty?
+
+        message = format_message(msg)
+        return '' if skip_message?(message)
+
+        formatted = build_output(severity, timestamp, progname, message)
+        "#{formatted}\n"
+      end
+
+      # Install as Rails logger formatter
+      def self.install!
+        return unless defined?(Rails)
+
+        Rails.application.configure do
+          config.log_formatter = BrainzLab::Utilities::LogFormatter.new(
+            colorize: BrainzLab.configuration.log_formatter_colors,
+            compact: BrainzLab.configuration.log_formatter_compact_assets
+          )
+        end
+
+        # Also hook into ActiveSupport::TaggedLogging if present
+        return unless defined?(ActiveSupport::TaggedLogging) && Rails.logger.respond_to?(:formatter=)
+
+        Rails.logger.formatter = new
+      end
+
+      private
+
+      def format_message(msg)
+        case msg
+        when String
+          msg
+        when Exception
+          "#{msg.class}: #{msg.message}\n#{msg.backtrace&.first(10)&.join("\n")}"
+        else
+          msg.inspect
+        end
+      end
+
+      def skip_message?(message)
+        return false unless BrainzLab.configuration.log_formatter_hide_assets
+
+        # Skip asset pipeline noise
+        message.include?('/assets/') ||
+          message.include?('Asset pipeline') ||
+          message.match?(%r{Started GET "/assets/})
+      end
+
+      def build_output(severity, timestamp, _progname, message)
+        parts = []
+
+        if @show_timestamp
+          ts = colorize(timestamp.strftime('%H:%M:%S.%L'), :gray)
+          parts << ts
+        end
+
+        if @show_severity
+          sev = format_severity(severity)
+          parts << sev
+        end
+
+        parts << format_content(message, severity)
+
+        parts.join(' ')
+      end
+
+      def format_severity(severity)
+        icon = SEVERITY_ICONS[severity] || ''
+        text = severity.ljust(5)
+
+        if @colorize
+          color = severity_color(severity)
+          "#{icon}#{color}#{text}#{COLORS[:reset]}"
+        else
+          "#{icon}[#{text}]"
+        end
+      end
+
+      def severity_color(severity)
+        case severity
+        when 'DEBUG' then COLORS[:debug]
+        when 'INFO' then COLORS[:info]
+        when 'WARN' then COLORS[:warn]
+        when 'ERROR' then COLORS[:error]
+        when 'FATAL' then COLORS[:fatal]
+        else COLORS[:reset]
+        end
+      end
+
+      def format_content(message, severity)
+        # Handle Rails request log patterns
+        if (request_match = message.match(/Started (GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS) "([^"]+)"/))
+          format_request_started(request_match[1], request_match[2])
+        elsif (completed_match = message.match(/Completed (\d+) .+ in (\d+(?:\.\d+)?)ms/))
+          format_request_completed(completed_match[1].to_i, completed_match[2].to_f)
+        elsif message.include?('Processing by')
+          format_processing(message)
+        elsif message.include?('Parameters:')
+          format_parameters(message)
+        elsif message.include?('Rendering') || message.include?('Rendered')
+          format_rendering(message)
+        elsif %w[ERROR FATAL].include?(severity)
+          format_error(message)
+        else
+          message
+        end
+      end
+
+      def format_request_started(method, path)
+        method_color = HTTP_METHODS[method] || COLORS[:reset]
+
+        if @colorize
+          "#{COLORS[:bold]}→#{COLORS[:reset]} #{method_color}#{method}#{COLORS[:reset]} #{path}"
+        else
+          "→ #{method} #{path}"
+        end
+      end
+
+      def format_request_completed(status, duration)
+        status_color = case status
+                       when 200..299 then COLORS[:info]
+                       when 300..399 then COLORS[:blue]
+                       when 400..499 then COLORS[:warn]
+                       when 500..599 then COLORS[:error]
+                       else COLORS[:reset]
+                       end
+
+        duration_color = case duration
+                         when 0..100 then COLORS[:info]
+                         when 100..500 then COLORS[:warn]
+                         else COLORS[:error]
+                         end
+
+        if @colorize
+          "#{COLORS[:bold]}←#{COLORS[:reset]} #{status_color}#{status}#{COLORS[:reset]} #{duration_color}#{duration.round(1)}ms#{COLORS[:reset]}"
+        else
+          "← #{status} #{duration.round(1)}ms"
+        end
+      end
+
+      def format_processing(message)
+        if (match = message.match(/Processing by (\w+)#(\w+)/))
+          controller, action = match.captures
+          if @colorize
+            "  #{COLORS[:dim]}#{controller}##{action}#{COLORS[:reset]}"
+          else
+            "  #{controller}##{action}"
+          end
+        else
+          "  #{message}"
+        end
+      end
+
+      def format_parameters(message)
+        return message unless BrainzLab.configuration.log_formatter_show_params
+
+        if @colorize
+          "  #{COLORS[:dim]}#{message}#{COLORS[:reset]}"
+        else
+          "  #{message}"
+        end
+      end
+
+      def format_rendering(message)
+        if @compact
+          # Compact: just show the template name
+          if (match = message.match(/Render(?:ed|ing) ([^\s]+)/))
+            template = match[1].split('/').last
+            if @colorize
+              "    #{COLORS[:gray]}#{template}#{COLORS[:reset]}"
+            else
+              "    #{template}"
+            end
+          else
+            ''
+          end
+        elsif @colorize
+          "    #{COLORS[:dim]}#{message}#{COLORS[:reset]}"
+        else
+          "    #{message}"
+        end
+      end
+
+      def format_error(message)
+        if @colorize
+          "#{COLORS[:error]}#{message}#{COLORS[:reset]}"
+        else
+          message
+        end
+      end
+
+      def colorize(text, color)
+        return text unless @colorize
+
+        "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+      end
+    end
+  end
+end