karafka-web 1.0.0 → 1.0.1

data/lib/karafka/web/pro/ui/views/topics/configs/index.erb

@@ -22,27 +22,18 @@
 
 <%== partial 'topics/topics/tabs' %>
 
-<div class="data-table-wrapper">
-  <table class="data-table">
-    <thead>
-      <tr>
-        <th><%== sort_link(:name) %></th>
-        <th><%== sort_link(:value) %></th>
-        <th><%== sort_link(:default?) %></th>
-        <th><%== sort_link(:sensitive?) %></th>
-        <th><%== sort_link(:read_only?) %></th>
-        <th class="options">Options</th>
-      </tr>
-    </thead>
-    <tbody>
-      <%==
-        each_partial(
-          @configs,
-          'topics/configs/config'
-        )
-      %>
-    </tbody>
-  </table>
-</div>
+<% if filtering? || !@configs.empty? %>
+  <div class="col-span-12 mb-3">
+    <%== filter_box %>
+  </div>
+<% end %>
+
+<% if filtering? && @configs.empty? %>
+  <div class="col-span-12">
+    <%== partial 'shared/no_filter_results' %>
+  </div>
+<% else %>
+  <%== partial 'topics/configs/configs_table' %>
+<% end %>
 
 <%== partial 'topics/configs/delete_button' %>

data/lib/karafka/web/pro/ui/views/topics/replications/_partition.erb

@@ -28,9 +28,9 @@
     <%= partition[:leader] %>
   </td>
   <td>
-    <%= partition[:replica_count] %>
+    <%== partition_replica_brokers(partition, link: true) %>
   </td>
   <td>
-    <%= partition[:in_sync_replica_brokers] %>
+    <%== partition_in_sync_brokers(partition, link: true) %>
   </td>
 </tr>

data/lib/karafka/web/pro/ui/views/topics/replications/show.erb

@@ -24,14 +24,24 @@
 
 <%== partial 'topics/replications/replication_info' %>
 
+<div class="mb-3 flex justify-end">
+  <small class="text-muted">
+    Broker roles:
+    <span class="badge badge-primary">leader</span>
+    <span class="badge badge-info">replica</span>
+    <span class="badge badge-success">in-sync</span>
+    <span class="badge badge-warning">out-of-sync</span>
+  </small>
+</div>
+
 <div class="data-table-wrapper">
   <table class="data-table">
     <thead>
       <tr>
         <th><%== sort_link(:partition_id) %></th>
         <th><%== sort_link(:leader) %></th>
-        <th><%== sort_link(:replica_count) %></th>
-        <th><%== sort_link('In Sync Brokers', :in_sync_replica_brokers) %></th>
+        <th><%== sort_link('Replicas', :replica_count) %></th>
+        <th><%== sort_link('In-Sync (ISR)', :in_sync_replica_brokers) %></th>
       </tr>
     </thead>
     <tbody>

data/lib/karafka/web/pro/ui/views/topics/topics/index.erb

@@ -22,8 +22,16 @@
 
 <%== partial 'topics/topics/create_button' %>
 
-<% if @topics.empty? %>
+<% if filtering? || !@topics.empty? %>
+  <div class="col-span-12 mb-3">
+    <%== filter_box %>
+  </div>
+<% end %>
+
+<% if @topics.empty? && !filtering? %>
   <%== partial 'explorer/explorer/no_topics' %>
+<% elsif @topics.empty? %>
+  <%== partial 'shared/no_filter_results' %>
 <% else %>
   <div class="topic-tiles">
     <%==

data/lib/karafka/web/tracking/consumers/listeners/errors.rb

@@ -18,20 +18,11 @@ module Karafka
             #
             # @param event [Karafka::Core::Monitoring::Event]
             def on_error_occurred(event)
-              caller_ref = event[:caller]
-
-              # Collect extra info if it was a consumer related error.
-              # Those come from user code
-              details = case caller_ref
-              when Karafka::BaseConsumer
-                extract_consumer_info(caller_ref)
-              when Karafka::Connection::Client
-                extract_client_info(caller_ref)
-              when Karafka::Connection::Listener
-                extract_listener_info(caller_ref)
-              else
-                {}
-              end
+              # Error details come from two independent sources that we merge together:
+              # - the caller: the user code context in which the error happened
+              # - the error type: extra diagnostics some error types carry in the event payload
+              details = extract_caller_details(event[:caller])
+                .merge(extract_type_details(event))
 
               error_class, error_message, backtrace = extract_error_info(event[:error])
 
@@ -72,6 +63,38 @@ module Karafka
 
             private
 
+            # Collects error details based on who reported the error, that is the user code
+            # context in which it happened (consumer, client or listener).
+            #
+            # @param caller_ref [Object] object that reported the error
+            # @return [Hash] hash with caller specific info for details of error
+            def extract_caller_details(caller_ref)
+              case caller_ref
+              when Karafka::BaseConsumer
+                extract_consumer_info(caller_ref)
+              when Karafka::Connection::Client
+                extract_client_info(caller_ref)
+              when Karafka::Connection::Listener
+                extract_listener_info(caller_ref)
+              else
+                {}
+              end
+            end
+
+            # Collects error details based on the error type. Some error types carry extra
+            # diagnostics in the event payload that do not come from the caller.
+            #
+            # @param event [Karafka::Core::Monitoring::Event]
+            # @return [Hash] hash with type specific info for details of error
+            def extract_type_details(event)
+              case event[:type]
+              when "app.stopping.error"
+                extract_forceful_shutdown_info(event)
+              else
+                {}
+              end
+            end
+
             # @param consumer [::Karafka::BaseConsumer]
             # @return [Hash] hash with consumer specific info for details of error
             def extract_consumer_info(consumer)
@@ -111,6 +134,49 @@ module Karafka
                 id: listener.id
               }
             end
+
+            # Extracts details about what was still blocking when Karafka forcefully terminated.
+            # Karafka publishes the listeners that were still active and the jobs that were still
+            # in the processing pipeline alongside the forceful shutdown error.
+            #
+            # The lists are formatted into readable strings so they render as regular rows in the
+            # generic error details table (same presentation as every other error).
+            #
+            # @param event [Karafka::Core::Monitoring::Event]
+            # @return [Hash] hash with forceful shutdown diagnostics for details of error
+            def extract_forceful_shutdown_info(event)
+              active_listeners = event[:active_listeners] || []
+              alive_workers = event[:alive_workers] || []
+              in_processing = event[:in_processing] || {}
+
+              listeners = active_listeners.map do |listener|
+                "#{listener.id} (#{listener.subscription_group.id})"
+              end
+
+              jobs = in_processing.flat_map do |group_id, group_jobs|
+                group_jobs.map { |job| format_in_processing_job(group_id, job) }
+              end
+
+              # Only include the listener/job lists when there is something to show, so we do not
+              # render empty rows in the error details table
+              details = { alive_workers: alive_workers.size }
+              details[:active_listeners] = listeners.join(", ") unless listeners.empty?
+              details[:in_processing] = jobs.join("; ") unless jobs.empty?
+              details
+            end
+
+            # Formats a single job that was still in processing into a readable description.
+            #
+            # @param group_id [String] subscription group id the job belongs to
+            # @param job [Object] job that was still in the processing pipeline
+            # @return [String] readable job description
+            def format_in_processing_job(group_id, job)
+              status = job.non_blocking? ? "non-blocking" : "blocking"
+              job_type = job.class.name.split("::").last
+
+              "#{job_type} #{job.executor.topic.name}/#{job.executor.partition} " \
+                "(#{group_id}, #{status})"
+            end
           end
         end
       end

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

@@ -7,6 +7,10 @@ module Karafka
       class Base < Roda
         include Helpers::PathsHelper
         include Helpers::ApplicationHelper
+        include Helpers::BadgesHelper
+        include Helpers::FormattingHelper
+        include Helpers::PartitionsHelper
+        include Helpers::SortingHelper
         include Helpers::TimeHelper
         include Helpers::TopicsHelper
         include Helpers::TailwindHelper

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

@@ -132,7 +132,7 @@ module Karafka
 
           # @param resources [Hash, Array, Lib::HashProxy] object for sorting
           # @return [Hash, Array, Lib::HashProxy] sorted results
-          def refine(resources)
+          def sort(resources)
             Lib::Sorter.new(
               @params.current_sort,
               allowed_attributes: self.class.sortable_attributes

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

@@ -22,27 +22,15 @@ module Karafka
 
           # Lists available brokers in the cluster
           def brokers
-            @brokers = refine(cluster_info.brokers)
+            @brokers = sort(Models::ClusterInfo.fetch.brokers)
 
             render
           end
 
           # List partitions replication details
           def replication
-            partitions_total = []
-
-            displayable_topics(cluster_info).each do |topic|
-              topic[:partitions].each do |partition|
-                partitions_total << partition.merge(
-                  topic: topic,
-                  # Will allow sorting by name
-                  topic_name: topic.fetch(:topic_name)
-                )
-              end
-            end
-
             @partitions, last_page = Paginators::Arrays.call(
-              refine(partitions_total),
+              sort(replication_partitions),
               @params.current_page
             )
 
@@ -53,16 +41,27 @@ module Karafka
 
           private
 
-          # @return [Array] whole cluster info
-          def cluster_info
-            @cluster_info ||= Models::ClusterInfo.fetch
+          # Expands the displayable cluster topics into one flat row per partition, which the
+          # replication table renders, sorts and paginates. Each row is a partition carrying its
+          # topic (and topic name, so it can be sorted/filtered by name).
+          #
+          # @return [Array<Hash>] partition rows
+          def replication_partitions
+            displayable_topics.flat_map do |topic|
+              topic[:partitions].map do |partition|
+                partition.merge(
+                  topic: topic,
+                  topic_name: topic.fetch(:topic_name)
+                )
+              end
+            end
           end
 
-          # @param cluster_info [Rdkafka::Metadata] cluster metadata
-          # @return [Array<Hash>] array with topics to be displayed sorted in an alphabetical
-          #   order
-          def displayable_topics(cluster_info)
-            all = cluster_info
+          # @return [Array<Hash>] cluster topics to display in an alphabetical order, with internal
+          #   topics excluded unless the visibility config allows them
+          def displayable_topics
+            all = Models::ClusterInfo
+              .fetch
               .topics
               .sort_by { |topic| topic[:topic_name] }
 

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

@@ -18,7 +18,7 @@ module Karafka
             @current_state = Models::ConsumersState.current!
             @counters = Models::Counters.new(@current_state)
             @processes, last_page = Paginators::Arrays.call(
-              refine(Models::Processes.active(@current_state)),
+              sort(Models::Processes.active(@current_state)),
               @params.current_page
             )
 

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

@@ -16,56 +16,52 @@ module Karafka
 
           # Lists running jobs
           def running
-            current_state = Models::ConsumersState.current!
-            processes = Models::Processes.active(current_state)
-
-            @jobs_counters = count_jobs_types(processes)
-
-            # Aggregate jobs and inject the process info into them for better reporting
-            jobs_total = processes.flat_map do |process|
-              process.jobs.running.map do |job|
-                job.to_h[:process] = process
-                job
-              end
-            end
-
-            @jobs, last_page = Paginators::Arrays.call(
-              refine(jobs_total),
-              @params.current_page
-            )
-
-            paginate(@params.current_page, !last_page)
+            paginate_jobs(build_jobs(:running))
 
             render
           end
 
           # Lists pending jobs
           def pending
+            paginate_jobs(build_jobs(:pending))
+
+            render
+          end
+
+          private
+
+          # Aggregates jobs of a given type across all active processes, injecting the process info
+          # into each job for better reporting.
+          #
+          # @param type [Symbol] `:running` or `:pending`
+          # @return [Array] aggregated jobs
+          def build_jobs(type)
             current_state = Models::ConsumersState.current!
             processes = Models::Processes.active(current_state)
 
             @jobs_counters = count_jobs_types(processes)
 
-            # Aggregate jobs and inject the process info into them for better reporting
-            jobs_total = processes.flat_map do |process|
-              process.jobs.pending.map do |job|
+            processes.flat_map do |process|
+              process.jobs.public_send(type).map do |job|
                 job.to_h[:process] = process
                 job
               end
             end
+          end
 
+          # Sorts and paginates the aggregated jobs into `@jobs`. This is the seam a Pro subclass
+          # overrides to also apply filtering (a Pro-only feature); OSS only sorts.
+          #
+          # @param jobs_total [Array] aggregated jobs
+          def paginate_jobs(jobs_total)
             @jobs, last_page = Paginators::Arrays.call(
-              refine(jobs_total),
+              sort(jobs_total),
               @params.current_page
             )
 
             paginate(@params.current_page, !last_page)
-
-            render
           end
 
-          private
-
           # @param processes [Array<Process>]
           # @return [Lib::HashProxy] particular type jobs count
           def count_jobs_types(processes)

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

@@ -78,6 +78,11 @@ module Karafka
             #
             # @param action_name [Symbol] the method name being invoked
             def run_before_hooks(action_name)
+              # Track the dispatched action so controllers can resolve per-action configuration
+              # (e.g. `filterable_attributes`) from within the hooks and their action body, before
+              # `render` is ever reached
+              @current_action_name = action_name
+
               self.class.before_hooks.each do |actions, block|
                 instance_exec(&block) if actions.empty? || actions.include?(action_name)
               end

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

@@ -9,6 +9,7 @@ module Karafka
           self.sortable_attributes = %w[
             name
             active?
+            value
           ].freeze
 
           # Routing list
@@ -16,7 +17,7 @@ module Karafka
             @routes = Karafka::App.routes
 
             @routes.each do |consumer_group|
-              refine(consumer_group.topics)
+              sort(consumer_group.topics)
             end
 
             render
@@ -30,8 +31,21 @@ module Karafka
 
             @topic || not_found!(topic_id)
 
+            # Present the routing settings as a flat, sortable list of name/value rows
+            @details = sort(topic_detail_rows(@topic))
+
             render
           end
+
+          private
+
+          # @param topic [Karafka::Routing::Topic] topic we present the routing details for
+          # @return [Array<Hash>] `{ name:, value: }` rows for every routing setting
+          def topic_detail_rows(topic)
+            rows = Lib::HashFlattener.call(topic.subscription_group.kafka, "kafka")
+            rows.merge!(Lib::HashFlattener.call(topic.to_h.except(:kafka)))
+            rows.map { |name, value| { name: name.to_s, value: value } }
+          end
         end
       end
     end