console_kit 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acd47ead1008fc3bcdc25b0d995b735f69d1e6f5a8d5f8442c67dc5ee86bb9a3
-  data.tar.gz: 55bd88158a92c6741eab85bda17d4b61828dd101e94cd5ab02097688f8994302
+  metadata.gz: 348d99d0b8d74a78d96ffa4e74f7ee2baf25aab659700b5d44929d2e3cd87104
+  data.tar.gz: 9c5e7514f498818e2ffe8b0a9376511cbf364e81336a266df7fe02d143a26cf4
 SHA512:
-  metadata.gz: 9d1214289e7859342493f2930557554e05ad3ccb3200e041d3ade9b2f95a710b6f111eaea9bfc40f0192e98cabd1010f7be6c71469066d2fd702a74d70a33132
-  data.tar.gz: 4564b76383af8ab6d60c6ee79644fc78a1be8633520ffe1c74a26a69936ebbacb7db8b20dd84c28c2433f532198c46c1c140ff7d31cd323d613559624fabb713
+  metadata.gz: 5e56f04db89485e9b0a3a23b667062a8998287a8ab9ad67dc793f3202730ba6f54dcf02f45ab65ff739e3aef23ec7c65574ba32c4aafe7cebc1a6dcff63c907f
+  data.tar.gz: 86d6d4457bb2ad62e8ac2ecdd22c3afc0fa72313f4625cf4b304bbd1f0436a67033e0a2c4190d995895b12aba4aef77c68465ffa1fe1dcf6815d93909f355394

data/lib/console_kit/configuration.rb

@@ -3,20 +3,23 @@
 module ConsoleKit
   # Stores ConsoleKit configurations such as tenant map and context behavior
   class Configuration
-    attr_accessor :pretty_output, :tenants, :sql_base_class
-    attr_writer :context_class
+    # Value object for storing configuration settings
+    Settings = Struct.new(:pretty_output, :tenants, :context_class, :sql_base_class, :show_dashboard)
 
     def initialize
-      @pretty_output = true
-      @tenants = nil
-      @context_class = nil
-      @sql_base_class = 'ApplicationRecord'
+      @settings = Settings.new(true, nil, nil, 'ApplicationRecord', false)
+    end
+
+    %i[pretty_output tenants context_class sql_base_class show_dashboard].each do |attr|
+      define_method(attr) { @settings.send(attr) }
+      define_method("#{attr}=") { |val| @settings.send("#{attr}=", val) }
     end
 
     def context_class
-      case @context_class
-      when String, Symbol then resolve_context_class
-      else @context_class
+      val = @settings.context_class
+      case val
+      when String, Symbol then resolve_context_class(val)
+      else val
       end
     end
 
@@ -28,17 +31,18 @@ module ConsoleKit
     end
 
     def validate!
-      raise Error, 'ConsoleKit: `tenants` is not configured.' if @tenants.blank?
-      raise Error, 'ConsoleKit: `tenants` must be a Hash.' unless @tenants.is_a?(Hash)
-      raise Error, 'ConsoleKit: `context_class` is not configured.' if @context_class.blank?
+      raise Error, 'ConsoleKit: `tenants` is not configured.' if tenants.blank?
+      raise Error, 'ConsoleKit: `tenants` must be a Hash.' unless tenants.is_a?(Hash)
+      raise Error, 'ConsoleKit: `context_class` is not configured.' if @settings.context_class.blank?
     end
 
     private
 
-    def resolve_context_class
-      @context_class.to_s.constantize
-    rescue NameError
-      raise Error, "ConsoleKit: context_class '#{@context_class}' could not be found. " \
+    def resolve_context_class(val)
+      klass = val.to_s.safe_constantize
+      return klass if klass
+
+      raise Error, "ConsoleKit: context_class '#{val}' could not be found. " \
                    'Ensure the class is defined before configuration is accessed.'
     end
   end

data/lib/console_kit/connections/base_connection_handler.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/class/subclasses'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string/filters'
+require_relative 'diagnostic_helpers'
 
 module ConsoleKit
   module Connections
     # Parent class for connection handlers
     class BaseConnectionHandler
+      include DiagnosticHelpers
+
       class << self
         def registry = descendants
       end
@@ -15,12 +20,41 @@ module ConsoleKit
       def initialize(context) = @context = context
       def connect = raise NotImplementedError, "#{self.class} must implement #connect"
       def available? = raise NotImplementedError, "#{self.class} must implement #available?"
+      def diagnostics = raise NotImplementedError, "#{self.class} must implement #diagnostics"
+
+      def safe_diagnostics(timeout: 2)
+        handler_name = self.class.name.demodulize.delete_suffix('ConnectionHandler')
+        thread, result_wrapper = spawn_diagnostic_thread(handler_name)
+
+        if thread.join(timeout)
+          result_wrapper[:value] || error_diagnostics(handler_name, StandardError.new('Unknown error'))
+        else
+          timeout_diagnostics(handler_name, timeout)
+        end
+      end
 
       private
 
-      def context_attribute(name)
-        @context.respond_to?(name, true) ? @context.send(name) : nil
+      def spawn_diagnostic_thread(handler_name)
+        wrapper = { value: nil }
+        thread = Thread.new { wrapper[:value] = run_diagnostics_safely(handler_name) { diagnostics } }
+        [thread, wrapper]
       end
+
+      def run_diagnostics_safely(name)
+        yield
+      rescue StandardError => e
+        error_diagnostics(name, e)
+      end
+
+      def measure_latency
+        start = clock_time
+        yield
+        ((clock_time - start) * 1000).round(1)
+      end
+
+      def context_attribute(name) = @context.try(name)
+      def unavailable_diagnostics(name) = { name: name, status: :unavailable, latency_ms: nil, details: {} }
     end
   end
 end

data/lib/console_kit/connections/dashboard.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'table_renderer'
+
+module ConsoleKit
+  module Connections
+    # Displays connection diagnostics as a Unicode table
+    module Dashboard
+      class << self
+        def display
+          rows = fetch_diagnostics
+          return Output.print_warning('No connections available') if rows.empty?
+
+          Output.print_header('Connection Dashboard')
+          Output.print_raw(TableRenderer.render(rows))
+        end
+
+        private
+
+        def fetch_diagnostics
+          ctx = ConsoleKit.configuration.context_class
+          handlers = ConnectionManager.available_handlers(ctx)
+          handlers.map(&:safe_diagnostics)
+        end
+      end
+    end
+  end
+end

data/lib/console_kit/connections/diagnostic_helpers.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ConsoleKit
+  module Connections
+    # Shared helper methods for connection diagnostics
+    module DiagnosticHelpers
+      module_function
+
+      def clock_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def error_diagnostics(name, error)
+        { name: name, status: :error, latency_ms: nil, details: { error: error.message.truncate(60) } }
+      end
+
+      def timeout_diagnostics(name, timeout)
+        { name: name, status: :timeout, latency_ms: nil, details: { error: "Timed out after #{timeout}s" } }
+      end
+    end
+  end
+end

data/lib/console_kit/connections/elasticsearch_connection_handler.rb

@@ -6,21 +6,64 @@ module ConsoleKit
   module Connections
     # Handles Elasticsearch connections
     class ElasticsearchConnectionHandler < BaseConnectionHandler
+      class << self
+        def elasticsearch_available?
+          return false unless defined?(Elasticsearch::Model)
+
+          Elasticsearch::Model.method(:client)
+          true
+        rescue NameError
+          false
+        end
+
+        def apply_prefix(prefix)
+          return unless defined?(Elasticsearch::Model)
+
+          Elasticsearch::Model.try(:index_name_prefix=, prefix)
+        end
+      end
+
       def connect
         prefix = context_attribute(:tenant_elasticsearch_prefix).presence
         Output.print_info(switch_message(prefix))
         Thread.current[:console_kit_elasticsearch_prefix] = prefix
-        apply_model_index_prefix(prefix)
+        self.class.apply_prefix(prefix)
       end
 
-      def available? = defined?(Elasticsearch)
+      def available? = self.class.elasticsearch_available?
+
+      def diagnostics
+        return unavailable_diagnostics('Elasticsearch') unless available?
+
+        perform_diagnostics
+      rescue StandardError => e
+        error_diagnostics('Elasticsearch', e)
+      end
 
       private
 
-      def apply_model_index_prefix(prefix)
-        return unless defined?(Elasticsearch::Model) && Elasticsearch::Model.respond_to?(:index_name_prefix=)
+      def perform_diagnostics
+        client = Elasticsearch::Model.client
+        latency = measure_latency do
+          client.ping
+        rescue StandardError
+          nil
+        end
+        health = client.cluster.health
+        build_elasticsearch_diagnostics(health['cluster_name'], health['status'], latency)
+      end
 
-        Elasticsearch::Model.index_name_prefix = prefix
+      def build_elasticsearch_diagnostics(cluster, status, latency)
+        {
+          name: 'Elasticsearch',
+          status: :connected,
+          latency_ms: latency,
+          details: {
+            prefix: context_attribute(:tenant_elasticsearch_prefix),
+            cluster: cluster,
+            health: status
+          }
+        }
       end
 
       def switch_message(prefix)

data/lib/console_kit/connections/mongo_connection_handler.rb

@@ -8,18 +8,67 @@ module ConsoleKit
     class MongoConnectionHandler < BaseConnectionHandler
       def connect
         db = context_attribute(:tenant_mongo_db).presence
-        Output.print_info(switch_message(db))
-        Mongoid.override_database(db)
+        switch_mongo(db)
       rescue NoMethodError
-        Output.print_warning('Mongoid.override_database is not available in this version of Mongoid.')
+        Output.print_warning('Mongoid client override is not available in this version of Mongoid.')
       end
 
       def available? = defined?(Mongoid)
 
+      def diagnostics
+        return unavailable_diagnostics('MongoDB') unless available?
+
+        perform_diagnostics
+      rescue StandardError => e
+        error_diagnostics('MongoDB', e)
+      end
+
       private
 
-      def switch_message(db)
-        db ? "Switching to MongoDB client: #{db}" : 'Resetting MongoDB client to default'
+      def perform_diagnostics
+        db = tenant_database
+        latency = measure_latency { db.command(ping: 1) }
+        info = db.command(buildInfo: 1).first
+        build_mongo_diagnostics(db.name, info['version'], latency)
+      end
+
+      def build_mongo_diagnostics(name, version, latency)
+        {
+          name: 'MongoDB',
+          status: :connected,
+          latency_ms: latency,
+          details: { database: name, version: version }
+        }
+      end
+
+      def tenant_database
+        override = context_attribute(:tenant_mongo_db).presence
+        client = Mongoid.default_client
+        (override ? client.use(override) : client).database
+      end
+
+      def switch_mongo(db)
+        if db.nil?
+          Output.print_info('Resetting MongoDB client to default')
+          reset_overrides
+        elsif named_client?(db)
+          Output.print_info("Switching to MongoDB client: #{db}")
+          Mongoid.override_client(db)
+        else
+          Output.print_info("Switching to MongoDB database: #{db}")
+          Mongoid.override_database(db)
+        end
+      end
+
+      def reset_overrides
+        Mongoid.override_client(nil) if Mongoid.respond_to?(:override_client)
+        Mongoid.override_database(nil)
+      end
+
+      def named_client?(name)
+        Mongoid::Config.clients.key?(name.to_s)
+      rescue StandardError
+        false
       end
     end
   end

data/lib/console_kit/connections/redis_connection_handler.rb

@@ -8,29 +8,67 @@ module ConsoleKit
     class RedisConnectionHandler < BaseConnectionHandler
       DEFAULT_REDIS_DB = 0
 
+      class << self
+        def redis_client = Redis.try(:current)
+
+        def warn_no_auto_select(db_index)
+          Output.print_warning("Redis DB #{db_index} configured but auto-select not supported with RedisClient. " \
+                               'Ensure your Redis configuration sets the correct DB.')
+        end
+      end
+
       def connect
-        db = context_attribute(:tenant_redis_db)
-        Output.print_info(switch_message(db))
-        select_redis_db(db.nil? ? DEFAULT_REDIS_DB : db)
+        db_index = context_attribute(:tenant_redis_db) || DEFAULT_REDIS_DB
+        Output.print_info(switch_message(db_index))
+        select_redis_db(db_index)
       end
 
       def available? = defined?(Redis)
 
+      def diagnostics
+        redis = self.class.redis_client if available?
+        return unavailable_diagnostics('Redis') unless redis
+
+        perform_diagnostics(redis)
+      rescue StandardError => e
+        error_diagnostics('Redis', e)
+      end
+
       private
 
-      def select_redis_db(db)
-        if Redis.respond_to?(:current) && Redis.current
-          Redis.current.select(db)
-        elsif defined?(RedisClient) && db != DEFAULT_REDIS_DB
-          Output.print_warning("Redis DB #{db} configured but auto-select not supported with RedisClient. " \
-                               'Ensure your Redis configuration sets the correct DB.')
+      def perform_diagnostics(redis)
+        latency = measure_latency { redis.ping }
+        info = redis.info
+        build_redis_diagnostics(info['redis_version'], info['used_memory_human'], latency)
+      end
+
+      def build_redis_diagnostics(version, memory, latency)
+        {
+          name: 'Redis',
+          status: :connected,
+          latency_ms: latency,
+          details: {
+            db: context_attribute(:tenant_redis_db) || DEFAULT_REDIS_DB,
+            version: version,
+            memory: memory
+          }
+        }
+      end
+
+      def select_redis_db(db_index)
+        klass = self.class
+        redis = klass.redis_client
+        if redis
+          redis.select(db_index)
+        elsif defined?(RedisClient) && db_index != DEFAULT_REDIS_DB
+          klass.warn_no_auto_select(db_index)
         end
       rescue NoMethodError
         Output.print_warning('Redis.current is not available (deprecated in Redis v5+).')
       end
 
-      def switch_message(db)
-        db ? "Switching to Redis DB: #{db}" : 'Resetting Redis connection to default'
+      def switch_message(db_index)
+        db_index ? "Switching to Redis DB: #{db_index}" : 'Resetting Redis connection to default'
       end
     end
   end

data/lib/console_kit/connections/sql_connection_handler.rb

@@ -6,28 +6,70 @@ module ConsoleKit
   module Connections
     # Handles SQL connections
     class SqlConnectionHandler < BaseConnectionHandler
+      class << self
+        def sql_version(conn)
+          conn.select_value('SELECT version()')
+        rescue StandardError
+          nil
+        end
+
+        def base_class_name = ConsoleKit.configuration.sql_base_class
+      end
+
       def connect
         shard = context_attribute(:tenant_shard).presence&.to_sym
         Output.print_info("#{connection_message(shard)} via #{base_class}")
+        disconnect_existing_pool
         shard ? base_class.establish_connection(shard) : base_class.establish_connection
       end
 
-      def available? = sql_base_class_name.to_s.safe_constantize.present?
+      def available? = self.class.base_class_name.to_s.safe_constantize.present?
+
+      def diagnostics
+        return unavailable_diagnostics('SQL') unless available?
+
+        perform_diagnostics
+      rescue StandardError => e
+        error_diagnostics('SQL', e)
+      end
 
       private
 
-      def base_class
-        klass = sql_base_class_name.to_s.safe_constantize
-        return klass if klass
+      def perform_diagnostics
+        conn = base_class.connection
+        latency = measure_latency { conn.execute('SELECT 1') }
+        build_sql_diagnostics(conn, latency)
+      end
+
+      def disconnect_existing_pool
+        pool = base_class.try(:connection_pool)
+        pool&.disconnect!
+      end
 
-        raise Error, "ConsoleKit: sql_base_class '#{sql_base_class_name}' could not be found."
+      def build_sql_diagnostics(conn, latency)
+        {
+          name: 'SQL',
+          status: :connected,
+          latency_ms: latency,
+          details: {
+            adapter: conn.adapter_name,
+            pool_size: base_class.connection_pool.size,
+            version: self.class.sql_version(conn).to_s.truncate(50)
+          }
+        }
+      end
+
+      def base_class
+        @base_class ||= begin
+          name = self.class.base_class_name
+          klass = name.to_s.safe_constantize
+          klass || raise(Error, "ConsoleKit: sql_base_class '#{name}' could not be found.")
+        end
       end
 
       def connection_message(shard)
         shard ? "Establishing SQL connection to shard: #{shard}" : 'Resetting SQL connection to default'
       end
-
-      def sql_base_class_name = ConsoleKit.configuration.sql_base_class
     end
   end
 end

data/lib/console_kit/connections/table_formatter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ConsoleKit
+  module Connections
+    # Formats raw diagnostic data for table display
+    module TableFormatter
+      class << self
+        def format_row(diag)
+          [
+            diag[:name],
+            format_status(diag[:status]),
+            format_latency(diag[:latency_ms]),
+            format_details(diag[:details])
+          ]
+        end
+
+        def format_status(status)
+          return "\u2713 Connected" if status == :connected
+          return "\u2717 Error" if %i[error timeout].include?(status)
+          return "\u2014 N/A" if status == :unavailable
+
+          '? Unknown'
+        end
+
+        def format_latency(latency_ms)
+          latency_ms ? "#{latency_ms}ms" : "\u2014"
+        end
+
+        def format_details(details)
+          return '' unless details&.any?
+
+          details.compact.map { |key, value| "#{key}: #{value}" }.join(', ')
+        end
+      end
+    end
+  end
+end

data/lib/console_kit/connections/table_renderer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'table_formatter'
+
+module ConsoleKit
+  module Connections
+    # Renders diagnostic data into a Unicode box-drawing table
+    module TableRenderer
+      class << self
+        def render(rows)
+          headers = %w[Service Status Latency Details]
+          table_rows = rows.map { |row| TableFormatter.format_row(row) }
+          widths = calculate_widths(headers, table_rows)
+
+          build_table(headers, table_rows, widths)
+        end
+
+        private
+
+        def calculate_widths(headers, rows)
+          all_rows = [headers] + rows
+          headers.each_index.map do |index|
+            column_max_width(all_rows, index)
+          end
+        end
+
+        def column_max_width(rows, index)
+          rows.map { |row| row[index].length }.max
+        end
+
+        def build_table(headers, rows, widths)
+          lines = [table_top(widths), table_line(headers, widths), table_mid(widths)]
+          rows.each { |row| lines << table_line(row, widths) }
+          lines << table_bottom(widths)
+          lines.join("\n")
+        end
+
+        def table_top(widths) = "\u250C#{widths.map { |width| "\u2500" * (width + 2) }.join("\u252C")}\u2510"
+        def table_mid(widths) = "\u251C#{widths.map { |width| "\u2500" * (width + 2) }.join("\u253C")}\u2524"
+        def table_bottom(widths) = "\u2514#{widths.map { |width| "\u2500" * (width + 2) }.join("\u2534")}\u2518"
+
+        def table_line(cells, widths)
+          content = cells.each_with_index.map { |cell, index| " #{cell.ljust(widths[index])} " }.join("\u2502")
+          "\u2502#{content}\u2502"
+        end
+      end
+    end
+  end
+end

data/lib/console_kit/console_helpers.rb

@@ -3,36 +3,62 @@
 module ConsoleKit
   # Helper methods available in the Rails console
   module ConsoleHelpers
-    def switch_tenant = ConsoleKit.reset_current_tenant
+    def switch_tenant
+      ConsoleKit.reset_current_tenant
+      self
+    end
 
     def tenant_info
       tenant = ConsoleKit::Setup.current_tenant
-      unless tenant
-        ConsoleKit::Output.print_warning('No tenant is currently configured.')
-        return
-      end
+      return no_tenant_warning unless tenant
 
-      constants = ConsoleKit.configuration.tenants[tenant]&.[](:constants) || {}
-      print_tenant_details(tenant, constants)
+      display_tenant_info(tenant)
+      nil
+    end
+
+    def dashboard
+      ConsoleKit::Connections::Dashboard.display
+      self
     end
 
     def tenants
       names = ConsoleKit.configuration.tenants&.keys || []
-      ConsoleKit::Output.print_list(names, header: 'Available Tenants')
+      print_available_tenants(names)
       names
     end
 
+    DETAIL_LABELS = {
+      'Partner' => :partner_code, 'Shard' => :shard, 'Mongo DB' => :mongo_db,
+      'Redis DB' => :redis_db, 'ES Prefix' => :elasticsearch_prefix, 'Environment' => :environment
+    }.freeze
+
     private
 
-    def print_tenant_details(tenant, constants)
-      ConsoleKit::Output.print_header("Tenant: #{tenant}")
-      {
-        'Partner' => :partner_code, 'Shard' => :shard, 'Mongo DB' => :mongo_db,
-        'Redis DB' => :redis_db, 'ES Prefix' => :elasticsearch_prefix, 'Environment' => :environment
-      }.each do |label, key|
-        ConsoleKit::Output.print_info("  #{label.ljust(13)}#{constants[key]}") unless constants[key].nil?
+    def no_tenant_warning
+      ConsoleKit::Output.print_warning('No tenant is currently configured.')
+      self
+    end
+
+    def display_tenant_info(tenant)
+      constants = ConsoleKit.configuration.tenants[tenant]&.[](:constants) || {}
+      ConsoleHelpers.print_tenant_details(tenant, constants)
+      self
+    end
+
+    def print_available_tenants(names)
+      ConsoleKit::Output.print_list(names, header: 'Available Tenants')
+      self
+    end
+
+    class << self
+      def print_tenant_details(tenant, constants)
+        ConsoleKit::Output.print_header("Tenant: #{tenant}")
+        DETAIL_LABELS.each do |label, key|
+          next unless constants.key?(key)
+
+          ConsoleKit::Output.print_info("  #{label.ljust(13)}#{constants[key]}")
+        end
       end
-      nil
     end
   end
 end