console_kit 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e392416a4b0f32756b184aefa7431d71ce45a733479e477f9c54f9e14affcd6
-  data.tar.gz: 3b15e7006400dc93794f84e7e14828f573639c67452c0ccb4922ece8fcab9c89
+  metadata.gz: ee9784d78350655db23efa1080d49d5e2527e1b6530ef7a1c2772974e57a89ec
+  data.tar.gz: 2edbd66f104e2a2e549d11991fbbdbd1f77118227dfad56122bb58baefd4ee72
 SHA512:
-  metadata.gz: c6f6b2d49d2c2e2d776af957764804dfbebb397a7fbb52449013a77bed92d1ff817672154d546a304bbc92c9c385f14e5402bee250046e8b001564169f52881d
-  data.tar.gz: e9c24b447c674eb693a05b9552484e293a483b547e04620e78145f9c865010c27b45f487ab16b453bce8bd9a7bb8c4c180c9464abef3cda20f7e5678fdc932bd
+  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
@@ -14,7 +19,48 @@ module ConsoleKit
 
       def initialize(context) = @context = context
       def connect = raise NotImplementedError, "#{self.class} must implement #connect"
-      def available? = false
+      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/connection_manager.rb

@@ -2,6 +2,8 @@
 
 require_relative 'sql_connection_handler'
 require_relative 'mongo_connection_handler'
+require_relative 'redis_connection_handler'
+require_relative 'elasticsearch_connection_handler'
 
 module ConsoleKit
   module Connections
@@ -12,6 +14,8 @@ module ConsoleKit
           handler_classes.filter_map do |klass|
             handler = klass.new(context)
             handler if handler.available?
+          rescue NotImplementedError
+            nil
           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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'base_connection_handler'
+
+module ConsoleKit
+  module Connections
+    # Handles Elasticsearch connections
+    class ElasticsearchConnectionHandler < BaseConnectionHandler
+      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)
+      end
+
+      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)
+        return unless Elasticsearch::Model.respond_to?(:index_name_prefix=)
+
+        Elasticsearch::Model.index_name_prefix = prefix
+      end
+
+      def switch_message(prefix)
+        prefix ? "Setting Elasticsearch index prefix: #{prefix}" : 'Resetting Elasticsearch index prefix to default'
+      end
+    end
+  end
+end

data/lib/console_kit/connections/mongo_connection_handler.rb

@@ -1,28 +1,56 @@
 # frozen_string_literal: true
 
-require 'forwardable'
 require_relative 'base_connection_handler'
 
 module ConsoleKit
   module Connections
     # Handles MongoDB connections
     class MongoConnectionHandler < BaseConnectionHandler
-      extend Forwardable
-
-      def_delegator :@context, :tenant_mongo_db
-
       def connect
-        db = tenant_mongo_db.presence
+        db = context_attribute(:tenant_mongo_db).presence
         Output.print_info(switch_message(db))
-        Mongoid.override_client(db)
+        Mongoid.override_database(db)
       rescue NoMethodError
-        Output.print_warning('Mongoid.override_client is not defined.')
+        Output.print_warning('Mongoid.override_database is not available in this version of Mongoid.')
       end
 
       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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'base_connection_handler'
+
+module ConsoleKit
+  module Connections
+    # Handles Redis connections
+    class RedisConnectionHandler < BaseConnectionHandler
+      DEFAULT_REDIS_DB = 0
+
+      def connect
+        db = context_attribute(:tenant_redis_db) || DEFAULT_REDIS_DB
+        Output.print_info(switch_message(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)
+        redis = fetch_redis_client
+        if redis
+          redis.select(db)
+        elsif defined?(RedisClient) && db != DEFAULT_REDIS_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
+    end
+  end
+end

data/lib/console_kit/connections/sql_connection_handler.rb

@@ -1,28 +1,59 @@
 # frozen_string_literal: true
 
-require 'forwardable'
 require_relative 'base_connection_handler'
 
 module ConsoleKit
   module Connections
     # Handles SQL connections
     class SqlConnectionHandler < BaseConnectionHandler
-      extend Forwardable
-
-      def_delegator :@context, :tenant_shard
-
       def connect
-        shard = tenant_shard.presence&.to_sym
-        msg = shard ? "Establishing SQL connection to shard: #{shard}" : 'Resetting SQL connection to default'
-
-        Output.print_info("#{msg} via #{base_class}")
-        base_class.establish_connection(shard)
+        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
@@ -30,6 +61,10 @@ module ConsoleKit
         raise Error, "ConsoleKit: sql_base_class '#{sql_base_class_name}' could not be found."
       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

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ConsoleKit
+  # Helper methods available in the Rails console
+  module ConsoleHelpers
+    def switch_tenant = ConsoleKit.reset_current_tenant
+
+    def tenant_info
+      tenant = ConsoleKit::Setup.current_tenant
+      unless tenant
+        ConsoleKit::Output.print_warning('No tenant is currently configured.')
+        return
+      end
+
+      constants = ConsoleKit.configuration.tenants[tenant]&.[](:constants) || {}
+      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}")
+      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
+  end
+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, newline: true)
+      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)
-        output(message, meta[:color], newline: newline)
+        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,13 +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 output(message, color, newline: true)
-        method = newline ? :puts : :print
-        return send(method, message) unless ConsoleKit.configuration.pretty_output && color
-
-        send(method, "\e[#{color}m#{message}\e[0m")
-      end
     end
   end
 end