brainzlab 0.1.2 → 0.1.3

data/lib/brainzlab/utilities/health_check.rb

@@ -25,18 +25,16 @@ module BrainzLab
           overall_healthy = true
 
           checks_to_run.each do |check|
-            begin
-              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
+            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",
+            status: overall_healthy ? 'healthy' : 'unhealthy',
             timestamp: Time.now.utc.iso8601,
             checks: results
           }
@@ -45,56 +43,56 @@ module BrainzLab
         # Quick check - just returns status
         def healthy?
           result = run
-          result[:status] == "healthy"
+          result[:status] == 'healthy'
         end
 
         # Database connectivity check
         def check_database
-          return { status: "skip", message: "ActiveRecord not loaded" } unless defined?(ActiveRecord::Base)
+          return { status: 'skip', message: 'ActiveRecord not loaded' } unless defined?(ActiveRecord::Base)
 
           start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          ActiveRecord::Base.connection.execute("SELECT 1")
+          ActiveRecord::Base.connection.execute('SELECT 1')
           latency = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round(2)
 
-          { status: "ok", latency_ms: latency }
+          { status: 'ok', latency_ms: latency }
         rescue StandardError => e
-          { status: "error", message: e.message }
+          { status: 'error', message: e.message }
         end
 
         # Redis connectivity check
         def check_redis
-          return { status: "skip", message: "Redis not configured" } unless defined?(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
+          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 }
+          { status: 'ok', latency_ms: latency }
         rescue StandardError => e
-          { status: "error", message: e.message }
+          { status: 'error', message: e.message }
         end
 
         # Rails cache check
         def check_cache
-          return { status: "skip", message: "Rails not loaded" } unless defined?(Rails)
+          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)
+          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 }
+          if value == 'ok'
+            { status: 'ok', latency_ms: latency }
           else
-            { status: "error", message: "Cache read/write failed" }
+            { status: 'error', message: 'Cache read/write failed' }
           end
         rescue StandardError => e
-          { status: "error", message: e.message }
+          { status: 'error', message: e.message }
         end
 
         # Queue system check
@@ -106,7 +104,7 @@ module BrainzLab
           elsif defined?(GoodJob)
             check_good_job
           else
-            { status: "skip", message: "No queue system detected" }
+            { status: 'skip', message: 'No queue system detected' }
           end
         end
 
@@ -115,11 +113,11 @@ module BrainzLab
           mem_info = memory_usage
 
           status = if mem_info[:percentage] > 90
-                     "warning"
+                     'warning'
                    elsif mem_info[:percentage] > 95
-                     "error"
+                     'error'
                    else
-                     "ok"
+                     'ok'
                    end
 
           {
@@ -128,7 +126,7 @@ module BrainzLab
             percentage: mem_info[:percentage]
           }
         rescue StandardError => e
-          { status: "error", message: e.message }
+          { status: 'error', message: e.message }
         end
 
         # Disk space check
@@ -136,11 +134,11 @@ module BrainzLab
           disk_info = disk_usage
 
           status = if disk_info[:percentage] > 90
-                     "warning"
+                     'warning'
                    elsif disk_info[:percentage] > 95
-                     "error"
+                     'error'
                    else
-                     "ok"
+                     'ok'
                    end
 
           {
@@ -150,7 +148,7 @@ module BrainzLab
             percentage: disk_info[:percentage]
           }
         rescue StandardError => e
-          { status: "error", message: e.message }
+          { status: 'error', message: e.message }
         end
 
         # Register a custom health check
@@ -178,54 +176,54 @@ module BrainzLab
         end
 
         def check_solid_queue
-          return { status: "skip", message: "SolidQueue not loaded" } unless defined?(SolidQueue)
+          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
+            process_count = SolidQueue::Process.where('last_heartbeat_at > ?', 5.minutes.ago).count
             {
-              status: process_count > 0 ? "ok" : "warning",
+              status: process_count.positive? ? 'ok' : 'warning',
               processes: process_count
             }
           else
-            { status: "ok", message: "SolidQueue configured" }
+            { status: 'ok', message: 'SolidQueue configured' }
           end
         rescue StandardError => e
-          { status: "error", message: e.message }
+          { status: 'error', message: e.message }
         end
 
         def check_sidekiq
-          return { status: "skip", message: "Sidekiq not loaded" } unless defined?(Sidekiq)
+          return { status: 'skip', message: 'Sidekiq not loaded' } unless defined?(Sidekiq)
 
           stats = Sidekiq::Stats.new
           {
-            status: "ok",
+            status: 'ok',
             processed: stats.processed,
             failed: stats.failed,
             queues: stats.queues,
             workers: stats.workers_size
           }
         rescue StandardError => e
-          { status: "error", message: e.message }
+          { status: 'error', message: e.message }
         end
 
         def check_good_job
-          return { status: "skip", message: "GoodJob not loaded" } unless defined?(GoodJob)
+          return { status: 'skip', message: 'GoodJob not loaded' } unless defined?(GoodJob)
 
           {
-            status: "ok",
+            status: 'ok',
             pending: GoodJob::Job.where(performed_at: nil).count,
             running: GoodJob::Job.running.count
           }
         rescue StandardError => e
-          { status: "error", message: e.message }
+          { 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 || 0
+          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
@@ -235,7 +233,7 @@ module BrainzLab
           end
 
           # Estimate percentage (based on typical container memory)
-          max_mb = ENV.fetch("MEMORY_LIMIT_MB", 512).to_i
+          max_mb = ENV.fetch('MEMORY_LIMIT_MB', 512).to_i
           percentage = ((used_mb / max_mb) * 100).round(2)
 
           { used_mb: used_mb, percentage: percentage }
@@ -262,9 +260,9 @@ module BrainzLab
           isolate_namespace BrainzLab::Utilities::HealthCheck
 
           routes.draw do
-            get "/", to: "health#show"
-            get "/live", to: "health#live"
-            get "/ready", to: "health#ready"
+            get '/', to: 'health#show'
+            get '/live', to: 'health#live'
+            get '/ready', to: 'health#ready'
           end
         end
       end
@@ -274,19 +272,19 @@ module BrainzLab
         class HealthController < ActionController::API
           def show
             result = HealthCheck.run
-            status = result[:status] == "healthy" ? :ok : :service_unavailable
+            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 }
+            render json: { status: 'ok', timestamp: Time.now.utc.iso8601 }
           end
 
           def ready
             # Readiness probe - check critical dependencies
-            result = HealthCheck.run(checks: [:database, :redis])
-            status = result[:status] == "healthy" ? :ok : :service_unavailable
+            result = HealthCheck.run(checks: %i[database redis])
+            status = result[:status] == 'healthy' ? :ok : :service_unavailable
             render json: result, status: status
           end
         end

data/lib/brainzlab/utilities/log_formatter.rb

@@ -27,21 +27,21 @@ module BrainzLab
       }.freeze
 
       SEVERITY_ICONS = {
-        "DEBUG" => "🔍",
-        "INFO" => "ℹ️ ",
-        "WARN" => "⚠️ ",
-        "ERROR" => "❌",
-        "FATAL" => "💀"
+        '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
+        '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)
@@ -53,10 +53,10 @@ module BrainzLab
       end
 
       def call(severity, timestamp, progname, msg)
-        return "" if msg.nil? || msg.to_s.strip.empty?
+        return '' if msg.nil? || msg.to_s.strip.empty?
 
         message = format_message(msg)
-        return "" if skip_message?(message)
+        return '' if skip_message?(message)
 
         formatted = build_output(severity, timestamp, progname, message)
         "#{formatted}\n"
@@ -74,9 +74,9 @@ module BrainzLab
         end
 
         # Also hook into ActiveSupport::TaggedLogging if present
-        if defined?(ActiveSupport::TaggedLogging) && Rails.logger.respond_to?(:formatter=)
-          Rails.logger.formatter = new
-        end
+        return unless defined?(ActiveSupport::TaggedLogging) && Rails.logger.respond_to?(:formatter=)
+
+        Rails.logger.formatter = new
       end
 
       private
@@ -96,16 +96,16 @@ module BrainzLab
         return false unless BrainzLab.configuration.log_formatter_hide_assets
 
         # Skip asset pipeline noise
-        message.include?("/assets/") ||
-          message.include?("Asset pipeline") ||
-          message.match?(/Started GET "\/assets\//)
+        message.include?('/assets/') ||
+          message.include?('Asset pipeline') ||
+          message.match?(%r{Started GET "/assets/})
       end
 
-      def build_output(severity, timestamp, progname, message)
+      def build_output(severity, timestamp, _progname, message)
         parts = []
 
         if @show_timestamp
-          ts = colorize(timestamp.strftime("%H:%M:%S.%L"), :gray)
+          ts = colorize(timestamp.strftime('%H:%M:%S.%L'), :gray)
           parts << ts
         end
 
@@ -116,11 +116,11 @@ module BrainzLab
 
         parts << format_content(message, severity)
 
-        parts.join(" ")
+        parts.join(' ')
       end
 
       def format_severity(severity)
-        icon = SEVERITY_ICONS[severity] || ""
+        icon = SEVERITY_ICONS[severity] || ''
         text = severity.ljust(5)
 
         if @colorize
@@ -133,11 +133,11 @@ module BrainzLab
 
       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]
+        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
@@ -148,13 +148,13 @@ module BrainzLab
           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")
+        elsif message.include?('Processing by')
           format_processing(message)
-        elsif message.include?("Parameters:")
+        elsif message.include?('Parameters:')
           format_parameters(message)
-        elsif message.include?("Rendering") || message.include?("Rendered")
+        elsif message.include?('Rendering') || message.include?('Rendered')
           format_rendering(message)
-        elsif severity == "ERROR" || severity == "FATAL"
+        elsif %w[ERROR FATAL].include?(severity)
           format_error(message)
         else
           message
@@ -220,21 +220,19 @@ module BrainzLab
         if @compact
           # Compact: just show the template name
           if (match = message.match(/Render(?:ed|ing) ([^\s]+)/))
-            template = match[1].split("/").last
+            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
-          if @colorize
-            "    #{COLORS[:dim]}#{message}#{COLORS[:reset]}"
-          else
-            "    #{message}"
-          end
+          "    #{message}"
         end
       end
 

data/lib/brainzlab/utilities/rate_limiter.rb

@@ -37,7 +37,7 @@ module BrainzLab
 
       # Check if request is allowed (doesn't consume a token)
       def allowed?
-        count, reset = get_current_count
+        count, = get_current_count
         count < @limit
       end
 
@@ -104,7 +104,7 @@ module BrainzLab
       end
 
       def get_current_count
-        bucket = current_bucket
+        current_bucket
         data = @store.get(@key) || { buckets: {}, created_at: Time.now.to_i }
 
         # Clean old buckets
@@ -147,15 +147,15 @@ module BrainzLab
         return unless BrainzLab.configuration.flux_effectively_enabled?
 
         if allowed
-          BrainzLab::Flux.increment("rate_limiter.allowed", tags: { key: sanitize_key(@key) })
+          BrainzLab::Flux.increment('rate_limiter.allowed', tags: { key: sanitize_key(@key) })
         else
-          BrainzLab::Flux.increment("rate_limiter.denied", tags: { key: sanitize_key(@key) })
+          BrainzLab::Flux.increment('rate_limiter.denied', tags: { key: sanitize_key(@key) })
         end
       end
 
       def sanitize_key(key)
         # Remove user-specific identifiers for aggregation
-        key.gsub(/:\d+/, ":*").gsub(/:[a-f0-9-]{36}/, ":*")
+        key.gsub(/:\d+/, ':*').gsub(/:[a-f0-9-]{36}/, ':*')
       end
 
       # Simple in-memory store (for development/single-instance)

data/lib/brainzlab/utilities.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "utilities/rate_limiter"
-require_relative "utilities/circuit_breaker"
-require_relative "utilities/health_check"
-require_relative "utilities/log_formatter"
+require_relative 'utilities/rate_limiter'
+require_relative 'utilities/circuit_breaker'
+require_relative 'utilities/health_check'
+require_relative 'utilities/log_formatter'
 
 module BrainzLab
   module Utilities

data/lib/brainzlab/vault/cache.rb

@@ -47,7 +47,7 @@ module BrainzLab
 
       def delete_pattern(pattern)
         @mutex.synchronize do
-          regex = Regexp.new(pattern.gsub("*", ".*"))
+          regex = Regexp.new(pattern.gsub('*', '.*'))
           @store.delete_if { |k, _| k.match?(regex) }
         end
       end