karafka-web 0.10.4 → 0.11.0.beta1

data/lib/karafka/web/ui/base.rb

@@ -40,6 +40,7 @@ module Karafka
         plugin :capture_erb
         plugin :content_for
         plugin :inject_erb
+        plugin :all_verbs
 
         # Based on
         # https://github.com/sidekiq/sidekiq/blob/ae6ca119/lib/sidekiq/web/application.rb#L8
@@ -70,7 +71,16 @@ module Karafka
           # Map redirect flashes (if any) to Roda flash messages
           result.flashes.each { |key, value| flash[key] = value }
 
-          response.redirect result.back? ? request.referer : root_path(result.path)
+          path = case result.path
+                 when :back
+                   session[:current_path]
+                 when :previous
+                   session[:previous_path]
+                 else
+                   root_path(result.path)
+                 end
+
+          response.redirect path || root_path
         end
 
         handle_block_result Controllers::Responses::File do |result|
@@ -84,7 +94,8 @@ module Karafka
           ::Rdkafka::RdkafkaError,
           Errors::Ui::NotFoundError,
           Errors::Ui::ProOnlyError,
-          Errors::Ui::ForbiddenError
+          Errors::Ui::ForbiddenError,
+          Errors::Ui::IncompatibleSchemaError
         ] do |e|
           @error = true
 
@@ -95,6 +106,9 @@ module Karafka
           when Errors::Ui::ForbiddenError
             response.status = 403
             view 'shared/exceptions/not_allowed'
+          when Errors::Ui::IncompatibleSchemaError
+            response.status = 422
+            view 'shared/exceptions/incompatible_schema'
           else
             response.status = 404
             view 'shared/exceptions/not_found'
@@ -109,9 +123,11 @@ module Karafka
 
         before do
           check_csrf!
+          store_paths_history(request, session)
         end
 
         plugin :class_matchers
+        plugin :symbol_matchers
 
         # Time matcher with optional hours, minutes and seconds
         TIME_MATCHER = %r{(\d{4}-\d{2}-\d{2}/?(\d{2})?(:\d{2})?(:\d{2})?)}
@@ -122,12 +138,22 @@ module Karafka
         # @note In case the date-time is invalid, raise and render 404
         # @note The time component is optional as `Time#parse` will fallback to lowest time
         #   available, so we can build only date based lookups
-        class_matcher(Time, TIME_MATCHER) do |datetime|
-          [Time.parse(datetime)]
+        class_matcher(Time, TIME_MATCHER) do |*datetime|
+          [Time.parse(datetime[0])]
         rescue ArgumentError
           raise Errors::Ui::NotFoundError
         end
 
+        # Partitions ids cannot be bigger than 32 bit C int. We use this matcher to ensure we
+        # only support that big partition numbers. Otherwise librdkafka would crash.
+        symbol_matcher :partition_id, /(\d{1,14})/ do |value|
+          int_value = value.to_i
+
+          raise Errors::Ui::NotFoundError unless int_value.between?(0, 2_147_483_647)
+
+          [int_value]
+        end
+
         # Allows us to build current path with additional params + it merges existing params into
         # the query data. Query data takes priority over request params.
         # @param query_data [Hash] query params we want to add to the current path
@@ -145,6 +171,14 @@ module Karafka
           [request.path, query_string].compact.join('?')
         end
 
+        # Builds a consumer instance with all needed details
+        # @param consumer_class [Class]
+        def build(consumer_class)
+          Controllers::Requests::ExecutionWrapper.new(
+            consumer_class.new(params, session)
+          )
+        end
+
         # Sets appropriate template variables based on the response object and renders the
         # expected view
         # @param response [Karafka::Web::Ui::Controllers::Responses::Data] response data object
@@ -162,6 +196,31 @@ module Karafka
         def params
           Controllers::Requests::Params.new(request.params)
         end
+
+        private
+
+        # Stores history about visited paths. Useful for redirecting users back when needed.
+        # @param request [Karafka::Web::Ui::App::RodaRequest]
+        # @param session [Object] session object (Rails or Rack)
+        def store_paths_history(request, session)
+          # Code below tracks previous paths so we can use it to redirect users back
+          return unless request.get?
+          return unless request.env['HTTP_ACCEPT']&.include?('text/html')
+
+          requested_path = request.path
+
+          if session[:current_path].nil?
+            session[:current_path] = requested_path
+
+            return
+          end
+
+          return if request.path == session[:current_path]
+
+          # When navigating to a different page
+          session[:previous_path] = session[:current_path]
+          session[:current_path] = requested_path
+        end
       end
     end
   end

data/lib/karafka/web/ui/controllers/base_controller.rb

@@ -8,6 +8,9 @@ module Karafka
         # Base controller from which all the controllers should inherit.
         class BaseController
           include Web::Ui::Lib::Paginations
+          include Requests::Hookable
+
+          attr_reader :params, :session
 
           # Alias for easier referencing
           Models = Web::Ui::Models
@@ -19,9 +22,31 @@ module Karafka
 
           self.sortable_attributes = []
 
+          # Detect that the state of the cache has changed
+          before do
+            cache.clear_if_needed(
+              session[:cache_hash],
+              session[:cache_timestamp].to_i
+            )
+          end
+
+          after do
+            next unless cache.exist?
+
+            session[:cache_hash] = cache.hash
+            session[:cache_timestamp] = cache.timestamp.to_i
+          end
+
           # @param params [Karafka::Web::Ui::Controllers::Requests::Params] request parameters
-          def initialize(params)
+          # @param session [Request::Session] request session (Rails or other framework)
+          def initialize(params, session)
             @params = params
+            @session = session
+          end
+
+          # @return [Karafka::Web::Ui::Lib::Cache] per-process cache instance
+          def cache
+            Karafka::Web.config.ui.cache
           end
 
           private
@@ -50,6 +75,9 @@ module Karafka
 
             attributes[:breadcrums_scope] = scope
 
+            @current_action_name = action.to_sym
+            @current_controller_name = base.join('-')
+
             instance_variables.each do |iv|
               next if iv.to_s.start_with?('@_')
               next if iv.to_s.start_with?('@params')
@@ -72,6 +100,20 @@ module Karafka
             Responses::Redirect.new(path, flashes)
           end
 
+          # Wraps the provided arguments inside a message with a `<strong>` tag to simplify flash
+          # messages building.
+          #
+          # @param message [String] message with `?` to be replaced.
+          # @param args [Array<Object>] arguments to use to replace `?` with strong
+          # @return [String] formatted string
+          def format_flash(message, *args)
+            args.each do |arg|
+              message = message.sub('?', "<strong>#{arg}</strong>")
+            end
+
+            message
+          end
+
           # Builds a file response object that will be used as a base to dispatch the file
           #
           # @param content [String] Payload we want to dispatch as a file

data/lib/karafka/web/ui/controllers/cluster_controller.rb

@@ -17,6 +17,9 @@ module Karafka
             in_sync_replica_brokers
           ].freeze
 
+          # Cluster state should always be fresh and not from cache
+          before { cache.clear }
+
           # Lists available brokers in the cluster
           def brokers
             @brokers = refine(cluster_info.brokers)
@@ -50,9 +53,9 @@ module Karafka
 
           private
 
-          # Make sure, that for the cluster view we always get the most recent cluster state
+          # @return [Array] whole cluster info
           def cluster_info
-            @cluster_info ||= Models::ClusterInfo.fetch(cached: false)
+            @cluster_info ||= Models::ClusterInfo.fetch
           end
 
           # @param cluster_info [Rdkafka::Metadata] cluster metadata

data/lib/karafka/web/ui/controllers/errors_controller.rb

@@ -49,7 +49,7 @@ module Karafka
 
           # @return [String] errors topic
           def errors_topic
-            ::Karafka::Web.config.topics.errors
+            ::Karafka::Web.config.topics.errors.name
           end
         end
       end

data/lib/karafka/web/ui/controllers/requests/execution_wrapper.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Web
+    module Ui
+      module Controllers
+        module Requests
+          # @note This class is used internally by the Web UI to wrap controllers
+          #   and inject execution hooks around any method call (before/after filters).
+          #
+          # ExecutionWrapper delegates all method calls to the provided controller instance.
+          # Before and after each invocation, it runs the controller's registered hooks.
+          #
+          # This allows for cleaner separation of concerns and reusable hook logic.
+          #
+          # @example
+          #   controller = SomeController.new
+          #   wrapper = ExecutionWrapper.new(controller)
+          #   wrapper.call # will run before(:call), call, then after(:call)
+          class ExecutionWrapper
+            # @param controller [Object] a controller instance responding to method calls
+            def initialize(controller)
+              @controller = controller
+            end
+
+            # Delegates any method call to the controller and wraps it with before/after hooks
+            #
+            # @param method_name [Symbol] the name of the method being called
+            # @param args [Array] arguments passed to the method
+            # @param block [Proc] optional block passed to the method
+            # @return [Object] the result of the delegated controller method for Roda to operate on
+            def method_missing(method_name, *args, &block)
+              @controller.run_before_hooks(method_name)
+              result = @controller.public_send(method_name, *args, &block)
+              @controller.run_after_hooks(method_name)
+              result
+            end
+
+            # Properly supports respond_to? checks by delegating to the controller
+            #
+            # @param method_name [Symbol] the method name to check
+            # @param include_private [Boolean] whether to include private methods
+            # @return [Boolean] true if controller responds to the method
+            def respond_to_missing?(method_name, include_private = false)
+              @controller.respond_to?(method_name, include_private)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/web/ui/controllers/requests/hookable.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Web
+    module Ui
+      module Controllers
+        module Requests
+          # Adds before/after hook support for controller methods.
+          #
+          # This module allows registering callbacks that run before and after
+          # any named method (e.g., `call`, `show`) or for all methods.
+          #
+          # Hooks are inherited from parent controllers, making it easy to
+          # define shared behavior across a hierarchy.
+          #
+          # @example Adding hooks to a controller
+          #   class MyController
+          #     include Hookable
+          #
+          #     before(:call) { puts "before call" }
+          #     after(:call)  { puts "after call" }
+          #
+          #     def call
+          #       run_before_hooks(:call)
+          #       # actual logic
+          #       run_after_hooks(:call)
+          #     end
+          #   end
+          module Hookable
+            # Hook into class inclusion to extend DSL
+            #
+            # @param base [Class] the class including this module
+            def self.included(base)
+              base.extend(ClassMethods)
+            end
+
+            # DSL methods for defining and inheriting hooks
+            module ClassMethods
+              # Inherit parent hooks into subclass
+              #
+              # @param subclass [Class] the subclass inheriting from base controller
+              def inherited(subclass)
+                super
+                subclass.before_hooks.concat(before_hooks)
+                subclass.after_hooks.concat(after_hooks)
+              end
+
+              # @return [Array] accumulated before hooks
+              def before_hooks
+                @before_hooks ||= []
+              end
+
+              # @return [Array] accumulated after hooks
+              def after_hooks
+                @after_hooks ||= []
+              end
+
+              # Register a before hook
+              #
+              # @param actions [Array<Symbol>] optional action names to match (e.g., :call)
+              # @param block [Proc]
+              # @yield a block to execute before matched actions
+              def before(*actions, &block)
+                before_hooks << [actions, block]
+              end
+
+              # Register an after hook
+              #
+              # @param actions [Array<Symbol>] optional action names to match (e.g., :call)
+              # @param block [Proc]
+              # @yield a block to execute after matched actions
+              def after(*actions, &block)
+                after_hooks << [actions, block]
+              end
+            end
+
+            # Run all before hooks matching the action
+            #
+            # @param action_name [Symbol] the method name being invoked
+            def run_before_hooks(action_name)
+              self.class.before_hooks.each do |actions, block|
+                instance_exec(&block) if actions.empty? || actions.include?(action_name)
+              end
+            end
+
+            # Run all after hooks matching the action
+            #
+            # @param action_name [Symbol] the method name being invoked
+            def run_after_hooks(action_name)
+              self.class.after_hooks.each do |actions, block|
+                instance_exec(&block) if actions.empty? || actions.include?(action_name)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/web/ui/controllers/requests/params.rb

@@ -17,13 +17,51 @@ module Karafka
               days
             ].freeze
 
-            private_constant :ALLOWED_RANGES
+            # What string values true can be in params
+            ALLOWED_BOOLEAN_TRUE = %w[
+              on
+              yes
+              true
+            ].freeze
+
+            private_constant :ALLOWED_RANGES, :ALLOWED_BOOLEAN_TRUE
 
             # @param request_params [Hash] raw hash with params
             def initialize(request_params)
               @request_params = request_params
             end
 
+            # @param key [String, Symbol] params key
+            # @return [Object] value of the requested param
+            def [](key)
+              fetch(key.to_s)
+            end
+
+            # @param args [Symbol, Object] key we want to fetch and other args for `Hash#fetch`
+            # @return [Object] fetched object
+            def fetch(*args)
+              args[0] = args[0].to_s
+              @request_params.fetch(*args)
+            end
+
+            # @param key [String, Symbol] params key
+            # @return [Integer] integer value of the key
+            def int(key)
+              self[key].to_i
+            end
+
+            # @param key [String, Symbol] params key
+            # @return [Boolean] boolean key value
+            def bool(key)
+              ALLOWED_BOOLEAN_TRUE.include?(self[key])
+            end
+
+            # @param key [String, Symbol] params key
+            # @return [String] stringified key value
+            def str(key)
+              self[key].to_s
+            end
+
             # @return [Hash] current search or empty if no search query present
             def current_search
               return @current_search if @current_search

data/lib/karafka/web/ui/controllers/responses/redirect.rb

@@ -16,11 +16,6 @@ module Karafka
               @path = path
               @flashes = flashes
             end
-
-            # @return [Boolean] are we going back via referer and not explicit path
-            def back?
-              @path == :back
-            end
           end
         end
       end

data/lib/karafka/web/ui/controllers/status_controller.rb

@@ -10,6 +10,9 @@ module Karafka
         # page where we check that everything is as expected and if not, we can provide some
         # helpful instructions on how to fix the issues.
         class StatusController < BaseController
+          # Fresh state is needed to generate always correct status
+          before { cache.clear }
+
           # Displays the Web UI setup status
           def show
             @status = Models::Status.new

data/lib/karafka/web/ui/helpers/application_helper.rb

@@ -223,13 +223,22 @@ module Karafka
               title = 'Not available until first offset commit'
               %(<span class="badge badge-secondary" title="#{title}">N/A</span>)
             elsif explore
-              path = explorer_path(topic_name, partition_id, offset)
+              path = explorer_topics_path(topic_name, partition_id, offset)
               %(<a href="#{path}">#{offset}</a>)
             else
               offset.to_s
             end
           end
 
+          # Normalizes the metric value for display. Negative values coming from statistics usually
+          #   mean, that the value is not (yet) available.
+          #
+          # @param value [Integer]
+          # @return [String] input value if not negative or N/A
+          def normalized_metric(value)
+            value.negative? ? 'N/A' : value.to_s
+          end
+
           # @param details [::Karafka::Web::Ui::Models::Partition] partition information with
           #   lso risk state info
           # @return [String] background classes for row marking

data/lib/karafka/web/ui/helpers/paths_helper.rb

@@ -6,6 +6,15 @@ module Karafka
       module Helpers
         # Helper for web ui paths builders
         module PathsHelper
+          # Method that can be used to have conditions in breadcrumbs, etc based on the action
+          # we're in
+          #
+          # @param args [Array<Symbol>] action names we want to check
+          # @return [Boolean] true if any matches the current action name
+          def action?(*args)
+            args.include?(@current_action_name)
+          end
+
           # Helper method to flatten nested hashes and arrays
           # @param prefix [String] The prefix for nested keys, initially an empty string.
           # @param hash [Hash, Array] The nested hash or array to be flattened.
@@ -54,16 +63,51 @@ module Karafka
 
           # Helps build explorer paths. We often link offsets to proper messages, etc so this
           # allows us to short-track this
-          # @param topic_name [String, nil] name of the topic where we want to go within the
-          #   explorer or nil if we want to just go to the explorer root
-          # @param partition_id [Integer, nil] partition we want to display in the explorer or nil
-          #   if we want to go to the topic root
-          # @param offset [Integer, nil] offset of particular message or nil of we want to just go
-          #   to the partition root
-          # @param action [String, nil] specific routed action or nil
+          # @param args [Array<String>] sub-paths
           # @return [String] path to the expected location
-          def explorer_path(topic_name = nil, partition_id = nil, offset = nil, action = nil)
-            root_path(*['explorer', topic_name, partition_id, offset, action].compact)
+          def explorer_path(*args)
+            root_path(*['explorer', args.compact].flatten)
+          end
+
+          # Generates routes for explorer topics paths
+          #
+          # @param args [Array<String>] sub-paths
+          # @return explorer topics path
+          def explorer_topics_path(*args)
+            explorer_path(*['topics', args.compact].flatten)
+          end
+
+          # Generates routes for explorer messages paths
+          #
+          # @param args [Array<String>] sub-paths
+          # @return [String] explorer messages path
+          def explorer_messages_path(*args)
+            explorer_path(*['messages', args.compact].flatten)
+          end
+
+          # Helps build topics paths
+          #
+          # @param args [Array<String>] path params for the topics scope
+          # @return [String] topics scope path
+          def topics_path(*args)
+            root_path('topics', *args)
+          end
+
+          # Helps build consumers paths
+          #
+          # @param args [Array<String>] path params for consumers scope
+          # @return [String] consumers scope path
+          def consumers_path(*args)
+            root_path('consumers', *args)
+          end
+
+          # Helps build per-consumer scope paths
+          #
+          # @param consumer_id [String] consumer process id
+          # @param args [Array<String>] other path components
+          # @return [String] per consumer specific path
+          def consumer_path(consumer_id, *args)
+            consumers_path(consumer_id, *args)
           end
 
           # Helps build scheduled messages paths.
@@ -80,7 +124,7 @@ module Karafka
             action = nil
           )
             root_path(
-              *['scheduled_messages', 'explorer', topic_name, partition_id, offset, action].compact
+              *['scheduled_messages', 'explorer', 'topics', topic_name, partition_id, offset, action].compact
             )
           end
         end

data/lib/karafka/web/ui/lib/admin.rb

@@ -17,7 +17,7 @@ module Karafka
           class << self
             extend Forwardable
 
-            def_delegators ::Karafka::Admin, :read_watermark_offsets, :cluster_info
+            def_delegators ::Karafka::Admin, :read_watermark_offsets, :cluster_info, :topic_info
 
             # Allows us to read messages from the topic
             #