console_kit 1.4.0 → 1.5.1

data/lib/console_kit/errors.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative 'connections/diagnostic_helpers'
+
+module ConsoleKit
+  PROGRAMMING_ERRORS = [NameError, ArgumentError, TypeError].freeze
+
+  class << self
+    def programming_error?(error) = PROGRAMMING_ERRORS.any? { |klass| error.is_a?(klass) }
+  end
+
+  class Error < StandardError; end
+
+  class ConfigurationError < Error; end
+
+  class TenantNotFoundError < ConfigurationError; end
+
+  class UnsupportedBackendError < Error; end
+
+  class ConnectionError < Error
+    attr_reader :backend, :tenant, :operation
+
+    def initialize(message = nil, backend: nil, tenant: nil, operation: nil)
+      @backend = backend
+      @tenant = tenant
+      @operation = operation
+      super(message || "#{backend} #{operation} failed for tenant #{tenant.inspect}")
+    end
+  end
+
+  class ConnectionVerificationError < ConnectionError
+    attr_reader :expected, :actual
+
+    def initialize(message = nil, expected: nil, actual: nil, **opts)
+      @expected = expected
+      @actual = actual
+      super(message || default_message(opts[:backend]), operation: :verify, **opts)
+    end
+
+    private
+
+    def default_message(backend)
+      "#{backend} verification failed. Expected #{expected.inspect}, got #{actual.inspect}"
+    end
+  end
+
+  class RollbackError < Error
+    attr_reader :failures
+
+    def initialize(failures)
+      @failures = failures
+      super("Rollback failed for: #{failures.map { |failure| failure[:backend] }.join(', ')}")
+    end
+  end
+
+  class TenantSwitchError < Error
+    attr_reader :from_tenant, :to_tenant, :backend, :original_error, :rollback_failures
+
+    def initialize(from_tenant:, to_tenant:, original_error:, backend: nil, rollback_failures: [])
+      @from_tenant = from_tenant
+      @to_tenant = to_tenant
+      @backend = backend
+      @original_error = original_error
+      @rollback_failures = rollback_failures
+      super(build_message)
+    end
+
+    def rollback_succeeded? = rollback_failures.empty?
+
+    private
+
+    def build_message
+      [headline, scrub(original_error.message), rollback_summary].compact.join("\n")
+    end
+
+    def scrub(message) = Connections::DiagnosticHelpers.scrub(message)
+
+    def headline
+      scope = backend ? " (#{backend})" : nil
+      "Failed to switch tenant from #{from_tenant.inspect} to #{to_tenant.inspect}#{scope}:"
+    end
+
+    def rollback_summary
+      return "\nPrevious tenant state was restored successfully." if rollback_succeeded?
+
+      "\nWARNING: rollback did not fully succeed:\n#{formatted_failures}"
+    end
+
+    def formatted_failures
+      rollback_failures.map { |failure| "  - #{failure[:backend]}: #{scrub(failure[:error].message)}" }.join("\n")
+    end
+  end
+end

data/lib/console_kit/instrumentation.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'connections/diagnostic_helpers'
+
+module ConsoleKit
+  module Instrumentation
+    class << self
+      def subscribe(&block)
+        mutex.synchronize { subscribers << block }
+        block
+      end
+
+      def clear!
+        mutex.synchronize do
+          subscribers.clear
+          counters.clear
+        end
+      end
+
+      def counters = @counters ||= Hash.new(0)
+
+      def counts = mutex.synchronize { counters.dup }
+
+      def increment(name)
+        mutex.synchronize { counters[name] += 1 }
+      end
+
+      def instrument(name, payload = {})
+        start = Connections::DiagnosticHelpers.clock_time
+        yield.tap { publish(name, start, payload.merge(status: :ok)) }
+      rescue StandardError, NotImplementedError => e
+        publish(name, start, payload.merge(error: e.class.name, status: :error))
+        raise
+      end
+
+      private
+
+      def publish(name, start, payload)
+        increment(name)
+        duration_ms = elapsed_ms(start)
+        each_subscriber { |sub| sub.call(name, duration_ms, payload) }
+      end
+
+      def each_subscriber
+        mutex.synchronize { subscribers.dup }.each do |sub|
+          yield(sub)
+        rescue StandardError
+          nil
+        end
+      end
+
+      def elapsed_ms(start) = ((Connections::DiagnosticHelpers.clock_time - start) * 1000).round(2)
+      def subscribers = @subscribers ||= []
+      def mutex = @mutex ||= Mutex.new
+    end
+  end
+end

data/lib/console_kit/output.rb

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
 module ConsoleKit
-  # Handles Console outputs
   module Output
     PREFIX = '[ConsoleKit]'
     TYPES = {
       error: { symbol: '[✗]', color: '1;31' },
       success: { symbol: '[✓]', color: '1;32' },
       warning: { symbol: '[!]', color: '1;33' },
-      prompt: { symbol: nil,   color: '1;36' },
-      header: { symbol: nil,   color: '1;34' },
+      prompt: { symbol: nil, color: '1;36' },
+      header: { symbol: nil, color: '1;34' },
       trace: { symbol: nil, color: '0;90' },
       info: { symbol: nil, color: nil }
     }.freeze
@@ -34,7 +33,8 @@ module ConsoleKit
           return if silent
 
           formatted = (type == :header ? "\n--- #{text} ---" : text)
-          print_with(type, formatted, timestamp: timestamp, newline: newline)
+          message = build_formatted_message(type, formatted, timestamp)
+          newline ? puts(message) : print(message)
         end
       end
 
@@ -54,20 +54,11 @@ module ConsoleKit
       def print_backtrace(exception)
         return if silent
 
-        exception&.backtrace&.each do |line|
-          print_with(:trace, "    #{line}", timestamp: true)
-        end
+        exception&.backtrace&.each { |line| print_trace("    #{line}", timestamp: true) }
       end
 
       private
 
-      def print_with(type, text, options = {})
-        opts = options.is_a?(Hash) ? options : { timestamp: options }
-        message = build_formatted_message(type, text, opts[:timestamp])
-
-        opts.fetch(:newline, true) ? puts(message) : print(message)
-      end
-
       def build_formatted_message(type, text, timestamp)
         meta = TYPES.fetch(type)
         message = build_message(text, meta[:symbol], timestamp)

data/lib/console_kit/prompt.rb

@@ -1,46 +1,34 @@
 # frozen_string_literal: true
 
 module ConsoleKit
-  # Sets the console prompt to show the current tenant
   module Prompt
+    module IrbLabel
+      def prompt_i = Prompt.labelled(super)
+      def prompt_s = Prompt.labelled(super)
+      def prompt_c = Prompt.labelled(super)
+    end
+
     class << self
       def apply
-        apply_irb_prompt if defined?(IRB)
-        apply_pry_prompt if defined?(Pry)
+        require 'irb' unless defined?(Pry)
+        IRB::Context.prepend(IrbLabel) if defined?(IRB::Context) && !IRB::Context.include?(IrbLabel)
+        Pry.config.prompt = pry_prompt if defined?(Pry)
       end
 
-      private
+      def labelled(prompt) = prompt && "#{label.gsub('%', '%%')} #{prompt}"
 
-      def tenant_label
-        tenant = ConsoleKit::Setup.current_tenant
+      def label
+        tenant = StateStore.tenant_key
         tenant ? "[#{tenant}]" : '[no-tenant]'
       end
 
-      def apply_irb_prompt
-        conf = IRB.conf
-        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* ",
-          RETURN: "=> %s\n"
-        }
-        conf[:PROMPT_MODE] = :CONSOLE_KIT
-      end
-
-      def apply_pry_prompt
-        procs = pry_prompt_procs(tenant_label)
-        Pry.config.prompt = build_pry_prompt(procs)
-      end
+      private
 
-      def pry_prompt_procs(label)
-        [
-          proc { |obj, nest, _| "#{label} (#{obj}):#{nest}> " },
-          proc { |obj, nest, _| "#{label} (#{obj}):#{nest}* " }
+      def pry_prompt
+        procs = [
+          proc { |obj, nest, _| "#{ConsoleKit::Prompt.label} (#{obj}):#{nest}> " },
+          proc { |obj, nest, _| "#{ConsoleKit::Prompt.label} (#{obj}):#{nest}* " }
         ]
-      end
-
-      def build_pry_prompt(procs)
         return procs unless defined?(Pry::Prompt)
 
         Pry::Prompt.try(:new, 'console_kit', 'ConsoleKit tenant prompt', procs) || procs

data/lib/console_kit/railtie.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
 module ConsoleKit
-  # Railtie for integrating ConsoleKit with Rails console.
   class Railtie < Rails::Railtie
     console do
-      ConsoleKit::Setup.setup
+      ConsoleKit::TenantOrchestrator.run
       ConsoleKit::Prompt.apply
       if defined?(IRB::ExtendCommandBundle) && !defined?(Pry)
         IRB::ExtendCommandBundle.include(ConsoleKit::ConsoleHelpers)
@@ -13,6 +12,6 @@ module ConsoleKit
       end
     end
 
-    config.to_prepare { ConsoleKit::Setup.reapply if defined?(Rails::Console) }
+    config.to_prepare { ConsoleKit::TenantOrchestrator.reapply if defined?(Rails::Console) }
   end
 end

data/lib/console_kit/setup.rb

@@ -1,27 +1,80 @@
 # frozen_string_literal: true
 
-require_relative 'tenant_selector'
-require_relative 'tenant_configurator'
-require_relative 'output'
-require_relative 'setup_ui'
+require_relative 'configuration'
 require_relative 'tenant_orchestrator'
 
-# Core Logic for initial Setup
 module ConsoleKit
-  # Does the initial setup
+  module Deprecation
+    class << self
+      def call(name, replacement)
+        warned = (@warned ||= {})
+        unless warned[name]
+          warned[name] = true
+          Kernel.warn("ConsoleKit: #{name} is deprecated and will be removed in 2.0. Use #{replacement} instead.")
+        end
+        yield
+      end
+    end
+  end
+
   module Setup
     class << self
-      def current_tenant = Thread.current[:console_kit_current_tenant]
+      def setup = Deprecation.call('Setup.setup', 'TenantOrchestrator.run') { TenantOrchestrator.run }
+
+      def current_tenant
+        Deprecation.call('Setup.current_tenant', 'ConsoleKit.current_tenant') { ConsoleKit.current_tenant }
+      end
 
       def current_tenant=(val)
-        Thread.current[:console_kit_current_tenant] = val
+        Deprecation.call('Setup.current_tenant=', 'ConsoleKit.switch_tenant') do
+          TenantOrchestrator.current_tenant = val
+        end
+      end
+
+      def tenant_setup_successful?
+        Deprecation.call('Setup.tenant_setup_successful?', 'ConsoleKit.current_tenant') do
+          !ConsoleKit.current_tenant.to_s.empty?
+        end
+      end
+
+      def reapply = Deprecation.call('Setup.reapply', 'TenantOrchestrator.reapply') { TenantOrchestrator.reapply }
+
+      def reset_current_tenant
+        Deprecation.call('Setup.reset_current_tenant', 'ConsoleKit.reset_current_tenant') do
+          ConsoleKit.reset_current_tenant
+        end
       end
 
-      def setup = TenantOrchestrator.run
-      def tenant_setup_successful? = !current_tenant.to_s.empty?
-      def reapply = TenantOrchestrator.reapply
-      def reset_current_tenant = TenantOrchestrator.reset
-      def auto_select? = TenantOrchestrator.auto_select?
+      def auto_select?
+        Deprecation.call('Setup.auto_select?', 'TenantOrchestrator.auto_select?') { TenantOrchestrator.auto_select? }
+      end
+    end
+  end
+
+  class << self
+    %i[pretty_output context_class show_dashboard].each do |name|
+      define_method(name) do
+        Deprecation.call("ConsoleKit.#{name}", "ConsoleKit.configuration.#{name}") { configuration.public_send(name) }
+      end
+    end
+
+    %i[pretty_output tenants context_class show_dashboard].each do |name|
+      define_method(:"#{name}=") do |val|
+        Deprecation.call("ConsoleKit.#{name}=", "ConsoleKit.configuration.#{name}=") do
+          configuration.public_send(:"#{name}=", val)
+        end
+      end
+    end
+  end
+
+  class Configuration
+    def validate
+      Deprecation.call('Configuration#validate', 'Configuration#validate!') do
+        validate!
+        true
+      rescue Error
+        false
+      end
     end
   end
 end

data/lib/console_kit/setup_ui.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module ConsoleKit
-  # UI helpers for Setup
   module SetupUI
     ENVIRONMENT_WARNINGS = {
       'production' => -> { Output.print_error('!!! CAUTION: YOU ARE IN PRODUCTION ENVIRONMENT !!!') },
@@ -26,9 +25,7 @@ module ConsoleKit
 
       def print_active_connections
         ctx = ConsoleKit.configuration.context_class
-        active = Connections::ConnectionManager.available_handlers(ctx).map do |handler|
-          handler.class.name.demodulize.delete_suffix('ConnectionHandler')
-        end
+        active = Connections::ConnectionManager.available_handlers(ctx).map(&:display_name)
 
         Output.print_info("Active connections: #{active.join(', ')}") if active.any?
       end

data/lib/console_kit/tenant_configurator/context_wrapper.rb

@@ -2,14 +2,9 @@
 
 module ConsoleKit
   module TenantConfigurator
-    # Encapsulates context and attributes to resolve DataClump smells
     class ContextWrapper
-      HANDLER_ATTRIBUTES = {
-        Connections::SqlConnectionHandler => :tenant_shard,
-        Connections::MongoConnectionHandler => :tenant_mongo_db,
-        Connections::RedisConnectionHandler => :tenant_redis_db,
-        Connections::ElasticsearchConnectionHandler => :tenant_elasticsearch_prefix
-      }.freeze
+      UNREADABLE = :'#<console_kit unreadable>'
+      UNREADABLE_MESSAGE = 'Previous value of %s could not be read, so it was left as the new tenant set it.'
 
       attr_reader :ctx, :attributes
 
@@ -22,15 +17,13 @@ module ConsoleKit
 
         def detect_attributes(ctx)
           methods = ctx.public_methods
-          partner_attrs(methods) + handler_attrs(methods)
-        end
-
-        def partner_attrs(methods)
-          methods.include?(:partner_identifier=) ? [:partner_identifier] : []
+          partner = methods.include?(:partner_identifier=) ? [:partner_identifier] : []
+          partner + handler_attrs(methods)
         end
 
         def handler_attrs(methods)
-          HANDLER_ATTRIBUTES.each_with_object([]) do |(handler, attr), list|
+          Connections::BaseConnectionHandler.registry.each_with_object([]) do |handler, list|
+            attr = handler.context_attribute
             next unless methods.include?(:"#{attr}=")
             next unless handler_available?(handler)
 
@@ -54,25 +47,60 @@ module ConsoleKit
         attributes.any? { |attr| ctx.public_send(attr).present? }
       end
 
-      def reset
-        attributes.each { |attr| ctx.public_send("#{attr}=", nil) }
+      def current_values = attributes.to_h { |attr| [attr, safe_read(attr)] }
+
+      def restore(values)
+        failures = values.filter_map { |attr, value| restore_attribute(attr, value) }
+        raise_restore_failure(failures) if failures.any?
+
+        values
       end
 
       def assign(constant, mapping)
-        attributes.map do |attr|
-          existing = safe_read(attr)
-          new_value = constant[mapping[attr]]
-          ctx.public_send("#{attr}=", new_value)
-          [attr, existing, new_value]
-        end
+        attributes.to_h { |attr| [attr, write_attribute(attr, constant[mapping[attr]])] }
       end
 
       private
 
+      def restore_attribute(attr, value)
+        return [attr, Error.new(format(UNREADABLE_MESSAGE, attr))] if value == UNREADABLE
+
+        ctx.public_send(:"#{attr}=", value)
+        nil
+      rescue StandardError, NotImplementedError => e
+        [attr, e]
+      end
+
+      def write_attribute(attr, new_value)
+        existing = safe_read(attr)
+        ctx.public_send(:"#{attr}=", new_value)
+        warn_case_mismatch(attr, existing, new_value)
+        new_value
+      end
+
+      def raise_restore_failure(failures)
+        detail = failures.map { |attr, error| "#{attr} (#{error.class})" }.join(', ')
+        raise Error, "Could not restore context attributes: #{detail}. " \
+                     'Those attributes are still set to the tenant the switch failed to reach.'
+      end
+
+      def warn_case_mismatch(attr, existing, configured)
+        return unless existing.is_a?(String) && configured.is_a?(String) &&
+                      existing != configured && existing.casecmp(configured).zero?
+
+        Output.print_warning(
+          "#{attr} case mismatch: context had '#{existing}', config set '#{configured}'. " \
+          'Check your ConsoleKit tenant configuration.'
+        )
+      end
+
       def safe_read(attr)
         ctx.public_send(attr)
-      rescue StandardError
-        nil
+      rescue StandardError, NotImplementedError => e
+        Output.print_warning(
+          "Could not read context attribute #{attr}: #{e.class}. Rollback will not be able to restore it."
+        )
+        UNREADABLE
       end
     end
   end

data/lib/console_kit/tenant_configurator.rb

@@ -1,127 +1,89 @@
 # frozen_string_literal: true
 
 require_relative 'output'
+require_relative 'errors'
+require_relative 'tenant_state'
 require_relative 'connections/connection_manager'
 require_relative 'connections/dashboard'
 require_relative 'tenant_configurator/context_wrapper'
+require_relative 'tenant_switch'
 
 module ConsoleKit
-  # For tenant configuration
   module TenantConfigurator
-    CONTEXT_MAPPING = {
-      partner_identifier: :partner_code,
-      tenant_shard: :shard,
-      tenant_mongo_db: :mongo_db,
-      tenant_redis_db: :redis_db,
-      tenant_elasticsearch_prefix: :elasticsearch_prefix
-    }.freeze
-
     class << self
-      def configuration_success = Thread.current[:console_kit_configuration_success]
+      def context_mapping
+        { partner_identifier: :partner_code }.merge(backend_context_mapping)
+      end
+
+      def configuration_success? = StateStore.configured?
+      alias configuration_success configuration_success?
 
       def configuration_success=(val)
-        Thread.current[:console_kit_configuration_success] = val
+        StateStore.clear! unless val
       end
 
-      def current_tenant_key = Thread.current[:console_kit_current_tenant_key]
+      def current_tenant_key = StateStore.tenant_key
 
       def current_tenant_key=(val)
-        Thread.current[:console_kit_current_tenant_key] = val
+        StateStore.clear! if val.nil?
       end
 
       def configure_tenant(key)
-        return true if key == current_tenant_key && configuration_success
-
-        attempt_configuration(key)
-      rescue StandardError => e
-        handle_error?(e, key)
+        switch_unless_current(key)
+        true
+      rescue StandardError, NotImplementedError => e
+        report_failure(e, key)
+        false
       end
 
       def clear
         ctx = ConsoleKit.configuration.context_class
         return unless ctx
 
-        perform_clear(ContextWrapper.for_context(ctx))
+        perform_clear(ctx, ContextWrapper.for_context(ctx))
       end
 
       private
 
-      def attempt_configuration(key)
-        constants = ConsoleKit.configuration.tenants[key]&.[](:constants)
-        return missing_config_error?(key) unless constants
+      def backend_context_mapping
+        Connections::BaseConnectionHandler.registry.to_h { |handler| [handler.context_attribute, handler.constants_key] }
+      end
+
+      def switch_unless_current(key)
+        return if key == current_tenant_key && configuration_success
 
-        execute_configuration(key, constants)
-        configuration_success
+        TenantSwitch.call(key)
       end
 
-      def perform_clear(wrapper)
+      def perform_clear(ctx, wrapper)
         return unless configuration_success || wrapper.any_set?
 
-        reset_tenant(wrapper)
+        TenantSwitch.clear(context: ctx)
         Output.print_info('Tenant context has been cleared.')
         true
       end
 
-      def reset_tenant(wrapper)
-        self.configuration_success = false
-        self.current_tenant_key = nil
-        wrapper.reset
-        setup_connections(wrapper.ctx)
-      end
+      def report_failure(error, key)
+        return print_missing_config(key) if tenant_missing?(error)
 
-      def validate_constants!(constants)
-        missing = %i[shard partner_code] - constants.keys
-        raise Error, "Tenant constants missing keys: #{missing.join(', ')}" unless missing.empty?
+        print_error_details(error, key)
       end
 
-      def missing_config_error?(key)
-        self.configuration_success = false
-        Output.print_error("No configuration found for tenant: #{key}")
-        false
+      def tenant_missing?(error)
+        error.is_a?(TenantNotFoundError) ||
+          (error.is_a?(TenantSwitchError) && error.original_error.is_a?(TenantNotFoundError))
       end
 
-      def execute_configuration(key, constants)
-        validate_constants!(constants)
-        apply_context(constants)
-        mark_success(key)
-      end
-
-      def apply_context(constant)
-        wrapper = ContextWrapper.for_context(ConsoleKit.configuration.context_class)
-        wrapper.assign(constant, CONTEXT_MAPPING).each do |attr, existing, configured|
-          warn_case_mismatch(attr, existing, configured) if case_mismatch?(existing, configured)
-        end
-        setup_connections(wrapper.ctx)
-      end
-
-      def case_mismatch?(existing, new_value)
-        existing.is_a?(String) && new_value.is_a?(String) &&
-          existing != new_value &&
-          existing.casecmp(new_value).zero?
-      end
-
-      def setup_connections(context)
-        Connections::ConnectionManager.available_handlers(context).each(&:connect)
-      end
-
-      def mark_success(key)
-        Output.print_success("Tenant set to: #{key}")
-        self.configuration_success = true
-        self.current_tenant_key = key
-      end
-
-      def warn_case_mismatch(attr, existing, configured)
-        Output.print_warning(
-          "#{attr} case mismatch: context had '#{existing}', config set '#{configured}'. " \
-          'Check your ConsoleKit tenant configuration.'
-        )
+      def print_missing_config(key)
+        Output.print_error("No configuration found for tenant: #{key}")
+        nil
       end
 
-      def handle_error?(error, key)
-        self.configuration_success = false
-        Output.print_error("Failed to configure tenant '#{key}': #{error.message}")
+      def print_error_details(error, key)
+        message = Connections::DiagnosticHelpers.scrub(error.message)
+        Output.print_error("Failed to configure tenant '#{key}': #{message}")
         Output.print_backtrace(error)
-        false
+        nil
       end
     end
   end