karafka-web 0.10.4 → 0.11.0

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

@@ -11,122 +11,29 @@ module Karafka
 
         instance_exec(&CONTEXT_DETAILS)
 
+        # Sub-routes for given pieces of the Web UI
+        SUB_ROUTES = [
+          Routes::Assets,
+          Routes::Dashboard,
+          Routes::Consumers,
+          Routes::ProOnly,
+          Routes::Jobs,
+          Routes::Routing,
+          Routes::Cluster,
+          Routes::Errors,
+          Routes::Status,
+          Routes::Support,
+          Routes::Ux
+        ].freeze
+
+        private_constant :SUB_ROUTES
+
         route do |r|
           r.root { r.redirect root_path('dashboard') }
 
-          # Serve current version specific assets to prevent users from fetching old assets
-          # after upgrade
-          r.on 'assets', Karafka::Web::VERSION do
-            r.public
-          end
-
-          r.get 'dashboard' do
-            @breadcrumbs = false
-            controller = Controllers::DashboardController.new(params)
-            controller.index
-          end
-
-          r.on 'consumers' do
-            %w[
-              performance
-              controls
-              commands
-            ].each do |path|
-              r.get path do |_process_id|
-                raise Errors::Ui::ProOnlyError
-              end
-            end
-
-            r.get String, 'subscriptions' do |_process_id|
-              raise Errors::Ui::ProOnlyError
-            end
-
-            r.get do
-              controller = Controllers::ConsumersController.new(params)
-              controller.index
-            end
-          end
-
-          %w[
-            health
-            explorer
-            dlq
-          ].each do |route|
-            r.get route, [String, true], [String, true] do
-              raise Errors::Ui::ProOnlyError
-            end
-          end
-
-          r.on 'jobs' do
-            controller = Controllers::JobsController.new(params)
-
-            r.get 'running' do
-              controller.running
-            end
-
-            r.get 'pending' do
-              controller.pending
-            end
-
-            r.redirect root_path('jobs/running')
-          end
-
-          r.on 'routing' do
-            controller = Controllers::RoutingController.new(params)
-
-            r.get String do |topic_id|
-              controller.show(topic_id)
-            end
-
-            r.get do
-              controller.index
-            end
-          end
-
-          r.on 'cluster' do
-            controller = Controllers::ClusterController.new(params)
-
-            r.get 'brokers' do
-              controller.brokers
-            end
-
-            r.get 'replication' do
-              controller.replication
-            end
-
-            r.redirect root_path('cluster/brokers')
-          end
-
-          r.on 'topics' do
-            raise Errors::Ui::ProOnlyError
-          end
-
-          r.on 'errors' do
-            controller = Controllers::ErrorsController.new(params)
-
-            r.get Integer do |offset|
-              controller.show(offset)
-            end
-
-            r.get do
-              controller.index
-            end
-          end
-
-          r.get 'status' do
-            controller = Controllers::StatusController.new(params)
-            controller.show
-          end
-
-          r.get 'ux' do
-            controller = Controllers::UxController.new(params)
-            controller.show
-          end
+          SUB_ROUTES.each { |sub_route| sub_route.bind(self, r) }
 
-          r.get 'support' do
-            controller = Controllers::SupportController.new(params)
-            controller.show
-          end
+          nil
         end
       end
     end

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

@@ -7,6 +7,8 @@ module Karafka
       class Base < Roda
         include Helpers::PathsHelper
         include Helpers::ApplicationHelper
+        include Helpers::TimeHelper
+        include Helpers::TopicsHelper
         include Helpers::TailwindHelper
 
         # Details that need to be evaluated in the context of OSS or Pro web UI.
@@ -40,6 +42,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 +73,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|
@@ -109,9 +121,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 +136,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 +169,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 +194,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

@@ -17,7 +17,8 @@ module Karafka
               previous_offset,
               @params.current_offset,
               next_offset,
-              @error_messages.map(&:offset)
+              # If message is an array, it means it's a compacted dummy offset representation
+              @error_messages.map { |message| message.is_a?(Array) ? message.last : message.offset }
             )
 
             render
@@ -25,12 +26,20 @@ module Karafka
 
           # @param offset [Integer] given error message offset
           def show(offset)
+            @partition_id = 0
+            @offset = offset
+
+            watermark_offsets = Models::WatermarkOffsets.find(errors_topic, @partition_id)
+
             @error_message = Models::Message.find(
               errors_topic,
-              0,
-              offset
+              @partition_id,
+              offset,
+              watermark_offsets: watermark_offsets
             )
 
+            paginate(offset, watermark_offsets.low, watermark_offsets.high)
+
             render
           end
 
@@ -49,7 +58,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