karafka-web 1.0.0 → 1.0.1

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

@@ -38,15 +38,23 @@ module Karafka
             self.sortable_attributes = %w[
               name
               active?
+              value
             ].freeze
 
+            # The list is filtered by topic/consumer group (at the view level), while the per-topic
+            # details page filters its flat attribute/value rows
+            self.filterable_attributes = {
+              index: %i[topic consumer_group],
+              show: %i[name value]
+            }.freeze
+
             # Routing list
             def index
               detect_patterns_routes
 
               @routes = Karafka::App.routes
               @routes.each do |consumer_group|
-                refine(consumer_group.topics)
+                sort(consumer_group.topics)
               end
 
               current_state = Models::ConsumersState.current
@@ -80,11 +88,25 @@ module Karafka
 
               @topic || not_found!(topic_id)
 
+              # Present the routing settings as a flat, sortable + filterable list of name/value rows
+              @details = sort(filter(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 (including
+            #   the Pro multiplexing settings)
+            def topic_detail_rows(topic)
+              flattener = Web::Ui::Lib::HashFlattener
+              rows = flattener.call(topic.subscription_group.kafka, "kafka")
+              rows.merge!(flattener.call(topic.to_h.except(:kafka)))
+              rows.merge!(flattener.call(topic.subscription_group.multiplexing.to_h, "multiplexing"))
+              rows.map { |name, value| { name: name.to_s, value: value } }
+            end
+
             # Detect routes defined as patterns
             def detect_patterns_routes
               Lib::PatternsDetector.new.call

data/lib/karafka/web/pro/ui/controllers/scheduled_messages/schedules_controller.rb

@@ -36,6 +36,10 @@ module Karafka
           module ScheduledMessages
             # Controller to display list of schedules (groups) and details about each
             class SchedulesController < BaseController
+              self.filterable_attributes = %w[
+                topic_name
+              ].freeze
+
               # Displays list of groups
               def index
                 topics = Models::Topic.all
@@ -54,6 +58,8 @@ module Karafka
 
                 @topics = topics.select { |topic| candidates.include?(topic.topic_name) }
 
+                @topics = filter(@topics)
+
                 render
               end
 

data/lib/karafka/web/pro/ui/controllers/topics/configs_controller.rb

@@ -44,13 +44,18 @@ module Karafka
                 read_only?
               ].freeze
 
+              self.filterable_attributes = %i[
+                name
+                value
+              ].freeze
+
               # Displays requested topic config details
               #
               # @param topic_name [String] topic we're interested in
               def index(topic_name)
                 @topic = Models::Topic.find(topic_name)
 
-                @configs = refine(@topic.configs)
+                @configs = filter(sort(@topic.configs))
 
                 render
               end

data/lib/karafka/web/pro/ui/controllers/topics/distributions_controller.rb

@@ -62,7 +62,7 @@ module Karafka
 
                 @aggregated, distribution = @topic.distribution(@active_partitions)
 
-                @distribution = refine(distribution)
+                @distribution = sort(distribution)
 
                 next_page = @active_partitions.last < @topic.partition_count - 1
                 paginate(@params.current_page, next_page)

data/lib/karafka/web/pro/ui/controllers/topics/offsets_controller.rb

@@ -66,7 +66,7 @@ module Karafka
                   }
                 end
 
-                @offsets = refine(offsets)
+                @offsets = sort(offsets)
 
                 next_page = @active_partitions.last < @topic.partition_count - 1
                 paginate(@params.current_page, next_page)

data/lib/karafka/web/pro/ui/controllers/topics/replications_controller.rb

@@ -49,7 +49,7 @@ module Karafka
               def show(topic_name)
                 @topic = Models::Topic.find(topic_name)
 
-                @partitions = refine(@topic[:partitions])
+                @partitions = sort(@topic[:partitions])
 
                 # Extract replication factor from the first partition (same for all partitions)
                 # The partitions data is an array of hashes with :replica_count key

data/lib/karafka/web/pro/ui/controllers/topics/topics_controller.rb

@@ -38,6 +38,10 @@ module Karafka
             class TopicsController < BaseController
               self.sortable_attributes = [].freeze
 
+              self.filterable_attributes = %w[
+                topic_name
+              ].freeze
+
               after(:create, :delete) { cache.clear }
 
               # Displays list of topics we can work with
@@ -48,6 +52,8 @@ module Karafka
                   @topics.delete_if { |topic| topic[:topic_name].start_with?("__") }
                 end
 
+                @topics = filter(@topics)
+
                 render
               end
 

data/lib/karafka/web/pro/ui/helpers/filtering_helper.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+# Karafka Pro - Source Available Commercial Software
+# Copyright (c) 2017-present Maciej Mensfeld. All rights reserved.
+#
+# This software is NOT open source. It is source-available commercial software
+# requiring a paid license for use. It is NOT covered by LGPL.
+#
+# The author retains all right, title, and interest in this software,
+# including all copyrights, patents, and other intellectual property rights.
+# No patent rights are granted under this license.
+#
+# PROHIBITED:
+# - Use without a valid commercial license
+# - Redistribution, modification, or derivative works without authorization
+# - Reverse engineering, decompilation, or disassembly of this software
+# - Use as training data for AI/ML models or inclusion in datasets
+# - Scraping, crawling, or automated collection for any purpose
+#
+# PERMITTED:
+# - Reading, referencing, and linking for personal or commercial use
+# - Runtime retrieval by AI assistants, coding agents, and RAG systems
+#   for the purpose of providing contextual help to Karafka users
+#
+# Receipt, viewing, or possession of this software does not convey or
+# imply any license or right beyond those expressly stated above.
+#
+# License: https://karafka.io/docs/Pro-License-Comm/
+# Contact: contact@karafka.io
+
+module Karafka
+  module Web
+    module Pro
+      module Ui
+        # Namespace for the Pro-only Web UI view helpers.
+        module Helpers
+          # Helpers for rendering the keyword filtering (search) box on data tables. Companion
+          # to the [[SortingHelper]]: sorting reorders a listing, filtering narrows it down.
+          module FilteringHelper
+            # @return [Boolean] true if a filtering keyword is currently active. Filtering
+            #   (search) is a Pro-only feature, so this is always false in OSS.
+            def filtering?
+              return false unless ::Karafka.pro?
+
+              !params.current_filter.empty?
+            end
+
+            # Renders a filtering form for the current listing.
+            #
+            # The form submits via GET to the current path, preserving every other query parameter
+            # (most importantly the current sort) as hidden fields while resetting pagination, so
+            # filtering always starts from the first page.
+            #
+            # It renders as a full-width search field with a "Search" submit button and a "Reset"
+            # button (always present, but disabled when there is nothing to reset, so the layout
+            # does not shift). When the controller exposes a `{ field => label }` map of filterable
+            # fields (via `filter`), a field selector is fused into the left of the field so the
+            # user can pick which attribute to filter on.
+            #
+            # The placeholder is intentionally a single generic default across every listing: a
+            # field selector always accompanies the input and already tells the user which
+            # attribute is being filtered, so a per-view placeholder would be redundant (and would
+            # look stale until the form is submitted, since it is server-rendered and does not
+            # follow the select live).
+            #
+            # @param labels [Hash] per-view overrides for the field selector labels, e.g.
+            #   `labels: { id: "Task ID" }`. Anything not overridden falls back to the shared
+            #   {FILTER_NAMES} map (and then to a humanized attribute name).
+            # @return [String] html of the filtering form
+            def filter_box(labels: {})
+              # Filtering (search) is a Pro-only feature, so we render nothing in OSS.
+              return "" unless ::Karafka.pro?
+
+              # A field is either a plain attribute name or a key-alias descriptor; the selector only
+              # cares about its name. We render the field selector whenever the controller exposes
+              # any filterable field, so every search looks consistent (even single-field listings
+              # show a one-option select).
+              fields = Array(@filterable_fields).map { |field| filter_field_name(field) }
+              fielded = fields.any?
+
+              partial(
+                "shared/filter_box",
+                locals: {
+                  fields: fields,
+                  fielded: fielded,
+                  selected: fielded ? selected_filter_field(fields) : nil,
+                  labels: labels,
+                  value_name: fielded ? "filter[value]" : "filter",
+                  keyword: params.current_filter,
+                  hidden_params: preserved_filter_params,
+                  active: filtering?,
+                  clear_path: filter_clear_path
+                }
+              )
+            end
+
+            # Human friendly labels for the attributes we allow filtering on. Attributes not listed
+            # here fall back to a humanized version of their name (see {#filter_field_label}), so
+            # controllers only need to declare bare attribute names in `filterable_attributes`.
+            FILTER_NAMES = {
+              id: "Process ID",
+              subscribed_topics: "Subscriptions",
+              tags: "Tags",
+              topic: "Topic",
+              topic_name: "Topic",
+              consumer_group: "Consumer group",
+              subscription_group: "Subscription group",
+              consumer: "Consumer",
+              type: "Type",
+              name: "Name",
+              value: "Value",
+              cron: "Cron",
+              broker_name: "Broker"
+            }.freeze
+
+            private_constant :FILTER_NAMES
+
+            private
+
+            # @param field [String, Symbol, #name] a filterable field: a plain attribute name or a
+            #   key-alias descriptor
+            # @return [String] the field's name
+            def filter_field_name(field)
+              field.respond_to?(:path) ? field.name.to_s : field.to_s
+            end
+
+            # @param attribute [String, Symbol] filterable attribute name
+            # @param overrides [Hash] per-view label overrides (keyed by attribute)
+            # @return [String] human friendly label for the attribute: a per-view override if given,
+            #   otherwise the shared {FILTER_NAMES} entry, otherwise a humanized attribute name
+            def filter_field_label(attribute, overrides = {})
+              key = attribute.to_sym
+
+              overrides.transform_keys(&:to_sym).fetch(key) do
+                FILTER_NAMES.fetch(key) do
+                  attribute.to_s.tr("_", " ").split.map(&:capitalize).join(" ")
+                end
+              end
+            end
+
+            # @param fields [Array<String, Symbol>] filterable attributes
+            # @return [String] the currently selected filter field, defaulting to the first one when
+            #   nothing (valid) is selected
+            def selected_filter_field(fields)
+              selected = params.current_filter_field
+
+              fields.map(&:to_s).include?(selected) ? selected : fields.first.to_s
+            end
+
+            # Builds the path used by the "clear" control: the current path with all filtering and
+            # pagination parameters removed.
+            #
+            # @return [String] path without any filter/page query parameters
+            def filter_clear_path
+              query = URI.encode_www_form(preserved_filter_params)
+
+              query.empty? ? request.path : "#{request.path}?#{query}"
+            end
+
+            # @return [Hash] current request query parameters that we want to carry over when
+            #   submitting the filtering form (everything except the filtering parameters themselves
+            #   and the pagination, which we intentionally reset)
+            def preserved_filter_params
+              flatten_params("", request.params).reject do |key, _value|
+                key == "filter" || key.start_with?("filter[") || key == "page"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/web/pro/ui/helpers/topics_filtering_helper.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# Karafka Pro - Source Available Commercial Software
+# Copyright (c) 2017-present Maciej Mensfeld. All rights reserved.
+#
+# This software is NOT open source. It is source-available commercial software
+# requiring a paid license for use. It is NOT covered by LGPL.
+#
+# The author retains all right, title, and interest in this software,
+# including all copyrights, patents, and other intellectual property rights.
+# No patent rights are granted under this license.
+#
+# PROHIBITED:
+# - Use without a valid commercial license
+# - Redistribution, modification, or derivative works without authorization
+# - Reverse engineering, decompilation, or disassembly of this software
+# - Use as training data for AI/ML models or inclusion in datasets
+# - Scraping, crawling, or automated collection for any purpose
+#
+# PERMITTED:
+# - Reading, referencing, and linking for personal or commercial use
+# - Runtime retrieval by AI assistants, coding agents, and RAG systems
+#   for the purpose of providing contextual help to Karafka users
+#
+# Receipt, viewing, or possession of this software does not convey or
+# imply any license or right beyond those expressly stated above.
+#
+# License: https://karafka.io/docs/Pro-License-Comm/
+# Contact: contact@karafka.io
+
+module Karafka
+  module Web
+    module Pro
+      module Ui
+        module Helpers
+          # View-level filtering of topic collections for the routing and per-process subscriptions
+          # views. Unlike the generic {FilteringHelper} (which renders the search box) and the
+          # [[Filter]] engine (which prunes per-request structures in place), this narrows the live
+          # `Karafka::App.routes` / process subscriptions non-destructively, since those must never
+          # be mutated.
+          module TopicsFilteringHelper
+            # Non-destructively narrows a topics collection (routing or a consumer subscription)
+            # down to the ones matching the current filter.
+            #
+            # It is field aware: when the `topic` field is selected only topic names are matched;
+            # when `consumer_group`/`subscription_group` is selected the whole collection is kept or
+            # dropped based on that group's name. With no explicit field (plain keyword) a topic is
+            # kept when its own name matches or when any of the provided group labels match.
+            #
+            # It always returns a new array and leaves the source untouched.
+            #
+            # @param topics [Enumerable] topics of a subscription/consumer group
+            # @param consumer_group [String, nil] the consumer group name shown as the section title
+            # @param subscription_group [String, nil] the subscription group name (subscriptions)
+            # @return [Array] all topics when no filtering is active, otherwise only matching ones
+            def visible_topics(topics, consumer_group: nil, subscription_group: nil)
+              return topics.to_a unless filtering?
+
+              keyword = params.current_filter.downcase
+              by_name = -> { topics.select { |topic| topic.name.to_s.downcase.include?(keyword) } }
+              label_match = ->(label) { label.to_s.downcase.include?(keyword) }
+
+              case params.current_filter_field
+              when "consumer_group"
+                label_match.call(consumer_group) ? topics.to_a : []
+              when "subscription_group"
+                label_match.call(subscription_group) ? topics.to_a : []
+              when "topic"
+                by_name.call
+              else
+                # Plain keyword: match the topic name or any of the group labels
+                [consumer_group, subscription_group].any?(&label_match) ? topics.to_a : by_name.call
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/web/pro/ui/lib/filtering.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+# Karafka Pro - Source Available Commercial Software
+# Copyright (c) 2017-present Maciej Mensfeld. All rights reserved.
+#
+# This software is NOT open source. It is source-available commercial software
+# requiring a paid license for use. It is NOT covered by LGPL.
+#
+# The author retains all right, title, and interest in this software,
+# including all copyrights, patents, and other intellectual property rights.
+# No patent rights are granted under this license.
+#
+# PROHIBITED:
+# - Use without a valid commercial license
+# - Redistribution, modification, or derivative works without authorization
+# - Reverse engineering, decompilation, or disassembly of this software
+# - Use as training data for AI/ML models or inclusion in datasets
+# - Scraping, crawling, or automated collection for any purpose
+#
+# PERMITTED:
+# - Reading, referencing, and linking for personal or commercial use
+# - Runtime retrieval by AI assistants, coding agents, and RAG systems
+#   for the purpose of providing contextual help to Karafka users
+#
+# Receipt, viewing, or possession of this software does not convey or
+# imply any license or right beyond those expressly stated above.
+#
+# License: https://karafka.io/docs/Pro-License-Comm/
+# Contact: contact@karafka.io
+
+module Karafka
+  module Web
+    module Pro
+      module Ui
+        module Lib
+          # Filtering (search) is a Pro-only feature, so all of its wiring lives in this concern and
+          # is mixed only into Pro controllers. OSS controllers never gain filtering.
+          #
+          # It is included by the Pro base controller (covering every standalone Pro controller)
+          # and, because a few Pro controllers inherit OSS controllers directly (and thus bypass
+          # the Pro base controller), by those explicitly.
+          module Filtering
+            # Descriptor for a filterable field that matches nested hash KEYS at a position in the
+            # structure, rather than an attribute on the records. Used for tree-shaped data whose
+            # meaningful labels are keys (e.g. the health stats, where consumer group and topic
+            # names are keys). See {Web::Ui::Lib::Filter} for how the engine consumes it.
+            #
+            # @!attribute name
+            #   @return [String] the field name (shown in the selector, matched against the request)
+            # @!attribute path
+            #   @return [Array] keys to descend from each container before matching that hash's keys
+            KeyField = Struct.new(:name, :path)
+
+            # Builds a {KeyField} descriptor for use in `filterable_attributes`.
+            #
+            # @param name [Symbol, String] field name
+            # @param under [Symbol, String, Array, nil] key(s) to descend before matching keys; nil
+            #   matches the container's own keys
+            # @return [KeyField]
+            def self.key(name, under: nil)
+              KeyField.new(name.to_s, Array(under))
+            end
+
+            # @param base [Class] the controller including this concern
+            def self.included(base)
+              # Attributes on which we can filter in a given controller. Since we can filter on
+              # method invocations, this needs to be limited and provided on a per controller basis
+              # (same contract as `sortable_attributes`).
+              #
+              # It is either a flat list applied to every action, or a `{ action => fields }` hash
+              # with an optional `:default` entry for controllers whose actions render different
+              # columns (e.g. cluster brokers vs configs). See {#filterable_fields} for the
+              # resolution.
+              base.singleton_class.attr_accessor :filterable_attributes
+
+              # Expose the per-action filterable fields to the view so the filtering box (and the
+              # view-level filtering helpers) can render the field selector. Resolved from the
+              # controller's `filterable_attributes` declaration on every request, so no action has
+              # to wire this up by hand.
+              base.before { @filterable_fields = filterable_fields }
+            end
+
+            private
+
+            # Filters the provided resources in place based on the current filtering keyword and the
+            # fields allowed for filtering.
+            #
+            # The allowed fields default to `@filterable_fields`, which the before hook resolves
+            # from the controller's `filterable_attributes` declaration for the current action and
+            # exposes to the view. Pass `fields` only when the engine's match set must differ from
+            # the fields shown in the selector (e.g. the health views scope the selector by
+            # topic/consumer group but keyword-match against the leaf partition id); it overrides
+            # matching only and does not change the exposed selector.
+            #
+            # @param resources [Hash, Array, Web::Ui::Lib::HashProxy] object for filtering
+            # @param fields [Array<Symbol>, nil] explicit engine allow-list for matching, overriding
+            #   `@filterable_fields`
+            # @return [Hash, Array, Web::Ui::Lib::HashProxy] filtered results
+            # @note It mutates the provided resources in place, so it must not be used on shared
+            #   structures like the app routing.
+            def filter(resources, fields: nil)
+              Web::Ui::Lib::Filter.new(
+                @params.current_filter,
+                allowed_attributes: fields || @filterable_fields,
+                field: @params.current_filter_field
+              ).call(resources)
+            end
+
+            # Resolves the fields the current action can be filtered on from the controller's
+            # `filterable_attributes` declaration. The declaration is either a flat list (applied to
+            # every action) or a `{ action => fields }` hash with an optional `:default` entry used
+            # for the actions not listed explicitly.
+            #
+            # @return [Array<Symbol>, Array<String>] fields for the current action (empty when the
+            #   action is not filterable)
+            def filterable_fields
+              attributes = self.class.filterable_attributes
+
+              return Array(attributes) unless attributes.is_a?(Hash)
+
+              Array(attributes[@current_action_name] || attributes[:default])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/web/pro/ui/lib/search/matchers/base.rb

@@ -40,10 +40,10 @@ module Karafka
               # Base class for all the search matchers
               # Each matcher needs to have a class `#name` method and needs to respond to `#call`
               class Base
-                # @param phrase [String] string phrase for search
                 # @param message [Karafka::Messages::Message] message in which we search
+                # @param phrase [String] string phrase for search
                 # @return [Boolean] true if found, otherwise false
-                def call(phrase, message)
+                def call(message, phrase)
                   raise NotImplementedError, "Implement in a subclass"
                 end
 

data/lib/karafka/web/pro/ui/routes/cluster.rb

@@ -40,8 +40,6 @@ module Karafka
                 controller = build(Controllers::ClusterController)
 
                 r.get "replication" do
-                  # We use the non-pro controller here because this action is the same
-                  controller = build(Ui::Controllers::ClusterController)
                   controller.replication
                 end
 

data/lib/karafka/web/pro/ui/views/cluster/_brokers_table.erb

@@ -0,0 +1,41 @@
+<%# Karafka Pro - Source Available Commercial Software %>
+<%# Copyright (c) 2017-present Maciej Mensfeld. All rights reserved. %>
+<%# This software is NOT open source. It is source-available commercial software %>
+<%# requiring a paid license for use. It is NOT covered by LGPL. %>
+<%# The author retains all right, title, and interest in this software, %>
+<%# including all copyrights, patents, and other intellectual property rights. %>
+<%# No patent rights are granted under this license. %>
+<%# PROHIBITED: Use without a valid commercial license %>
+<%# PROHIBITED: Redistribution, modification, or derivative works without authorization %>
+<%# PROHIBITED: Reverse engineering, decompilation, or disassembly of this software %>
+<%# PROHIBITED: Use as training data for AI/ML models or inclusion in datasets %>
+<%# PROHIBITED: Scraping, crawling, or automated collection for any purpose %>
+<%# PERMITTED: Reading, referencing, and linking for personal or commercial use %>
+<%# PERMITTED: Runtime retrieval by AI assistants, coding agents, and RAG systems %>
+<%# PERMITTED: for the purpose of providing contextual help to Karafka users %>
+<%# Receipt, viewing, or possession of this software does not convey or %>
+<%# imply any license or right beyond those expressly stated above. %>
+<%# License: https://karafka.io/docs/Pro-License-Comm/ %>
+<%# Contact: contact@karafka.io %>
+
+<div class="col-span-12 mb-3">
+  <div class="data-table-wrapper">
+    <table class="data-table">
+      <thead>
+        <tr>
+          <th><%== sort_link('Node ID', :id) %></th>
+          <th><%== sort_link(:name) %></th>
+          <th><%== sort_link(:port) %></th>
+        </tr>
+      </thead>
+      <tbody>
+        <%==
+          each_partial(
+            @brokers,
+            'cluster/broker'
+          )
+        %>
+      </tbody>
+    </table>
+  </div>
+</div>

data/lib/karafka/web/pro/ui/views/cluster/_configs_table.erb

@@ -0,0 +1,41 @@
+<%# Karafka Pro - Source Available Commercial Software %>
+<%# Copyright (c) 2017-present Maciej Mensfeld. All rights reserved. %>
+<%# This software is NOT open source. It is source-available commercial software %>
+<%# requiring a paid license for use. It is NOT covered by LGPL. %>
+<%# The author retains all right, title, and interest in this software, %>
+<%# including all copyrights, patents, and other intellectual property rights. %>
+<%# No patent rights are granted under this license. %>
+<%# PROHIBITED: Use without a valid commercial license %>
+<%# PROHIBITED: Redistribution, modification, or derivative works without authorization %>
+<%# PROHIBITED: Reverse engineering, decompilation, or disassembly of this software %>
+<%# PROHIBITED: Use as training data for AI/ML models or inclusion in datasets %>
+<%# PROHIBITED: Scraping, crawling, or automated collection for any purpose %>
+<%# PERMITTED: Reading, referencing, and linking for personal or commercial use %>
+<%# PERMITTED: Runtime retrieval by AI assistants, coding agents, and RAG systems %>
+<%# PERMITTED: for the purpose of providing contextual help to Karafka users %>
+<%# Receipt, viewing, or possession of this software does not convey or %>
+<%# imply any license or right beyond those expressly stated above. %>
+<%# License: https://karafka.io/docs/Pro-License-Comm/ %>
+<%# Contact: contact@karafka.io %>
+
+<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>
+      </tr>
+    </thead>
+    <tbody>
+      <%==
+        each_partial(
+          @configs,
+          'cluster/config'
+        )
+      %>
+    </tbody>
+  </table>
+</div>

data/lib/karafka/web/pro/ui/views/cluster/_partition.erb

@@ -35,9 +35,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>