console_kit 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acd47ead1008fc3bcdc25b0d995b735f69d1e6f5a8d5f8442c67dc5ee86bb9a3
-  data.tar.gz: 55bd88158a92c6741eab85bda17d4b61828dd101e94cd5ab02097688f8994302
+  metadata.gz: ee9784d78350655db23efa1080d49d5e2527e1b6530ef7a1c2772974e57a89ec
+  data.tar.gz: 2edbd66f104e2a2e549d11991fbbdbd1f77118227dfad56122bb58baefd4ee72
 SHA512:
-  metadata.gz: 9d1214289e7859342493f2930557554e05ad3ccb3200e041d3ade9b2f95a710b6f111eaea9bfc40f0192e98cabd1010f7be6c71469066d2fd702a74d70a33132
-  data.tar.gz: 4564b76383af8ab6d60c6ee79644fc78a1be8633520ffe1c74a26a69936ebbacb7db8b20dd84c28c2433f532198c46c1c140ff7d31cd323d613559624fabb713
+  metadata.gz: 92d30809eba5bb236130e2e472cb2ae8fc34f9ea0bd69b3a5c67334199cc34a9894666797ebe66c52489f8a2c22a403d1f65e097bfafdba89e3d3d9d5ec8d5b9
+  data.tar.gz: db949d61fdcff82557532b163dd1df0487e6e3fb6c3f0901eb172fa83b6adc87f70b191b59dca6405b76c90fad67c3b2c58aaff21161e441ae295e3dbdea116b

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,17 @@ 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
+    def resolve_context_class(val)
+      val.to_s.constantize
     rescue NameError
-      raise Error, "ConsoleKit: context_class '#{@context_class}' could not be found. " \
+      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,47 @@ 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
+          thread.kill
+          timeout_diagnostics(handler_name, timeout)
+        end
+      end
 
       private
 
+      def spawn_diagnostic_thread(handler_name)
+        wrapper = { value: nil }
+        thread = Thread.new { wrapper[:value] = run_diagnostics_safely(handler_name) }
+        [thread, wrapper]
+      end
+
+      def run_diagnostics_safely(name)
+        diagnostics
+      rescue StandardError => e
+        error_diagnostics(name, e)
+      end
+
       def context_attribute(name)
         @context.respond_to?(name, true) ? @context.send(name) : nil
       end
+
+      def measure_latency
+        start = clock_time
+        yield
+        ((clock_time - start) * 1000).round(1)
+      end
+
+      def unavailable_diagnostics(name)
+        { name: name, status: :unavailable, latency_ms: nil, details: {} }
+      end
     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

@@ -13,12 +13,43 @@ module ConsoleKit
         apply_model_index_prefix(prefix)
       end
 
-      def available? = defined?(Elasticsearch)
+      def available?
+        !!(defined?(Elasticsearch::Model) && Elasticsearch::Model.respond_to?(:client))
+      end
+
+      def diagnostics
+        name = 'Elasticsearch'
+        return unavailable_diagnostics(name) unless available?
+
+        client = Elasticsearch::Model.client
+        latency = measure_latency { client.ping }
+        build_elasticsearch_diagnostics(client, latency)
+      rescue StandardError => e
+        error_diagnostics(name, e)
+      end
 
       private
 
+      def build_elasticsearch_diagnostics(client, latency)
+        {
+          name: 'Elasticsearch',
+          status: :connected,
+          latency_ms: latency,
+          details: elasticsearch_details(client.cluster.health)
+        }
+      end
+
+      def elasticsearch_details(health)
+        {
+          prefix: context_attribute(:tenant_elasticsearch_prefix),
+          cluster: health['cluster_name'],
+          health: health['status']
+        }
+      end
+
       def apply_model_index_prefix(prefix)
-        return unless defined?(Elasticsearch::Model) && Elasticsearch::Model.respond_to?(:index_name_prefix=)
+        return unless defined?(Elasticsearch::Model)
+        return unless Elasticsearch::Model.respond_to?(:index_name_prefix=)
 
         Elasticsearch::Model.index_name_prefix = prefix
       end

data/lib/console_kit/connections/mongo_connection_handler.rb

@@ -16,8 +16,41 @@ module ConsoleKit
 
       def available? = defined?(Mongoid)
 
+      def diagnostics
+        name = 'MongoDB'
+        return unavailable_diagnostics(name) unless available?
+
+        db = tenant_database
+        latency = measure_latency { db.command(ping: 1) }
+        build_mongo_diagnostics(db, latency)
+      rescue StandardError => e
+        error_diagnostics(name, e)
+      end
+
       private
 
+      def tenant_database
+        override = context_attribute(:tenant_mongo_db).presence
+        client = Mongoid.default_client
+        return client.database unless override
+
+        client.use(override).database
+      end
+
+      def build_mongo_diagnostics(database, latency)
+        build_info = database.command(buildInfo: 1).first
+        {
+          name: 'MongoDB',
+          status: :connected,
+          latency_ms: latency,
+          details: mongo_details(database.name, build_info['version'])
+        }
+      end
+
+      def mongo_details(name, version)
+        { database: name, version: version }
+      end
+
       def switch_message(db)
         db ? "Switching to MongoDB client: #{db}" : 'Resetting MongoDB client to default'
       end

data/lib/console_kit/connections/redis_connection_handler.rb

@@ -9,26 +9,65 @@ module ConsoleKit
       DEFAULT_REDIS_DB = 0
 
       def connect
-        db = context_attribute(:tenant_redis_db)
+        db = context_attribute(:tenant_redis_db) || DEFAULT_REDIS_DB
         Output.print_info(switch_message(db))
-        select_redis_db(db.nil? ? DEFAULT_REDIS_DB : db)
+        select_redis_db(db)
       end
 
       def available? = defined?(Redis)
 
+      def diagnostics
+        name = 'Redis'
+        return unavailable_diagnostics(name) unless available?
+
+        redis = fetch_redis_client
+        return unavailable_diagnostics(name) unless redis
+
+        latency = measure_latency { redis.ping }
+        build_redis_diagnostics(redis.info, latency)
+      rescue StandardError => e
+        error_diagnostics(name, e)
+      end
+
       private
 
+      def fetch_redis_client
+        Redis.respond_to?(:current) && Redis.current
+      end
+
+      def build_redis_diagnostics(info, latency)
+        {
+          name: 'Redis',
+          status: :connected,
+          latency_ms: latency,
+          details: redis_details(info)
+        }
+      end
+
+      def redis_details(info)
+        {
+          db: context_attribute(:tenant_redis_db) || DEFAULT_REDIS_DB,
+          version: info['redis_version'],
+          memory: info['used_memory_human']
+        }
+      end
+
       def select_redis_db(db)
-        if Redis.respond_to?(:current) && Redis.current
-          Redis.current.select(db)
+        redis = fetch_redis_client
+        if redis
+          redis.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.')
+          warn_about_redis_client(db)
         end
       rescue NoMethodError
         Output.print_warning('Redis.current is not available (deprecated in Redis v5+).')
       end
 
+      def warn_about_redis_client(db)
+        Output.print_warning("Redis DB #{db} configured but auto-select not supported with RedisClient. " \
+                             'Ensure your Redis configuration sets the correct DB.')
+      end
+
       def switch_message(db)
         db ? "Switching to Redis DB: #{db}" : 'Resetting Redis connection to default'
       end

data/lib/console_kit/connections/sql_connection_handler.rb

@@ -9,13 +9,51 @@ module ConsoleKit
       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 diagnostics
+        name = 'SQL'
+        return unavailable_diagnostics(name) unless available?
+
+        conn = base_class.connection
+        latency = measure_latency { conn.execute('SELECT 1') }
+        build_sql_diagnostics(conn, latency)
+      rescue StandardError => e
+        error_diagnostics(name, e)
+      end
+
       private
 
+      def disconnect_existing_pool
+        return unless base_class.respond_to?(:connection_pool)
+
+        pool = base_class.connection_pool
+        pool&.disconnect!
+      end
+
+      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: fetch_sql_version(conn).to_s.truncate(50)
+          }
+        }
+      end
+
+      def fetch_sql_version(conn)
+        conn.select_value('SELECT version()')
+      rescue StandardError
+        nil
+      end
+
       def base_class
         klass = sql_base_class_name.to_s.safe_constantize
         return klass if klass

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

@@ -16,21 +16,30 @@ module ConsoleKit
       print_tenant_details(tenant, constants)
     end
 
+    def dashboard = ConsoleKit::Connections::Dashboard.display
+
     def tenants
       names = ConsoleKit.configuration.tenants&.keys || []
       ConsoleKit::Output.print_list(names, header: 'Available Tenants')
       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?
+      DETAIL_LABELS.each do |label, key|
+        constants.fetch(key, :missing).then do |val|
+          case val
+          when :missing then next
+          else ConsoleKit::Output.print_info("  #{label.ljust(13)}#{val}")
+          end
+        end
       end
       nil
     end

data/lib/console_kit/output.rb

@@ -34,7 +34,7 @@ module ConsoleKit
           return if silent
 
           formatted = (type == :header ? "\n--- #{text} ---" : text)
-          print_with(type, formatted, timestamp, { newline: newline })
+          print_with(type, formatted, timestamp: timestamp, newline: newline)
         end
       end
 
@@ -51,19 +51,24 @@ module ConsoleKit
         puts text
       end
 
-      # Backtrace prints always with timestamp, no param
       def print_backtrace(exception)
         return if silent
 
-        exception&.backtrace&.each { |line| print_with(:trace, "    #{line}", true, { newline: true }) }
+        exception&.backtrace&.each do |line|
+          print_with(:trace, "    #{line}", timestamp: true)
+        end
       end
 
       private
 
-      def print_with(type, text, timestamp, opts = {})
+      def print_with(type, text, options = {})
+        opts = options.is_a?(Hash) ? options : { timestamp: options }
         meta = TYPES.fetch(type)
-        message = build_message(text, meta[:symbol], timestamp)
-        emit(message, meta[:color], opts.fetch(:newline, true))
+        message = build_message(text, meta[:symbol], opts[:timestamp])
+        color = meta[:color]
+        formatted = ConsoleKit.configuration.pretty_output && color ? "\e[#{color}m#{message}\e[0m" : message
+
+        opts.fetch(:newline, true) ? puts(formatted) : print(formatted)
       end
 
       def build_message(text, symbol, timestamp)
@@ -73,12 +78,6 @@ module ConsoleKit
       def prefix_for(value) = value ? yield(value) : ''
       def timestamp_prefix(timestamp) = prefix_for(timestamp) { Time.current.strftime('[%Y-%m-%d %H:%M:%S] ') }
       def symbol_prefix(symbol) = prefix_for(symbol) { |sym| "#{sym} " }
-
-      def emit(message, color, newline)
-        writer = newline ? :puts : :print
-        formatted = ConsoleKit.configuration.pretty_output && color ? "\e[#{color}m#{message}\e[0m" : message
-        send(writer, formatted)
-      end
     end
   end
 end

data/lib/console_kit/prompt.rb

@@ -18,8 +18,8 @@ module ConsoleKit
 
       def apply_irb_prompt
         conf = IRB.conf
-        conf[:PROMPT] ||= {}
-        conf[:PROMPT][:CONSOLE_KIT] = {
+        prompt = conf[:PROMPT] ||= {}
+        prompt[:CONSOLE_KIT] = {
           PROMPT_I: "#{tenant_label} %N(%m):%03n> ",
           PROMPT_S: "#{tenant_label} %N(%m):%03n%l ",
           PROMPT_C: "#{tenant_label} %N(%m):%03n* ",
@@ -29,14 +29,23 @@ module ConsoleKit
       end
 
       def apply_pry_prompt
-        Pry.config.prompt = Pry::Prompt.new(
-          'console_kit',
-          'ConsoleKit tenant prompt',
-          [
-            proc { |obj, nest_level, _pry_instance| "#{Prompt.send(:tenant_label)} (#{obj}):#{nest_level}> " },
-            proc { |obj, nest_level, _pry_instance| "#{Prompt.send(:tenant_label)} (#{obj}):#{nest_level}* " }
-          ]
-        )
+        procs = pry_prompt_procs(tenant_label)
+        Pry.config.prompt = build_pry_prompt(procs)
+      end
+
+      def pry_prompt_procs(label)
+        [
+          proc { |obj, nest, _| "#{label} (#{obj}):#{nest}> " },
+          proc { |obj, nest, _| "#{label} (#{obj}):#{nest}* " }
+        ]
+      end
+
+      def build_pry_prompt(procs)
+        if defined?(Pry::Prompt) && Pry::Prompt.respond_to?(:new)
+          Pry::Prompt.new('console_kit', 'ConsoleKit tenant prompt', procs)
+        else
+          procs
+        end
       end
     end
   end

data/lib/console_kit/railtie.rb

@@ -6,10 +6,10 @@ module ConsoleKit
     console do
       ConsoleKit::Setup.setup
       ConsoleKit::Prompt.apply
-      if defined?(Pry)
-        TOPLEVEL_BINDING.receiver.extend(ConsoleKit::ConsoleHelpers)
-      elsif defined?(IRB::ExtendCommandBundle)
+      if defined?(IRB::ExtendCommandBundle) && !defined?(Pry)
         IRB::ExtendCommandBundle.include(ConsoleKit::ConsoleHelpers)
+      else
+        TOPLEVEL_BINDING.receiver.extend(ConsoleKit::ConsoleHelpers)
       end
     end