karafka-web 0.7.4 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a31ebcde158ca18cc353d3fefad976b7dfb8d9fe3b3114ea8f43b533229434a
-  data.tar.gz: f9870e5268ebebb38c838dc8a220030beaebfe30d4d53cd63537c5c2f442e2d4
+  metadata.gz: caf2303a2e877dd3f06b738974c4093f7a9cf1bdb24b1152183ba9173432b640
+  data.tar.gz: 80b56d4efec23d589adb731c18e5b7137718862edc246fb2c32ff0baaadb84a5
 SHA512:
-  metadata.gz: '02152094838c0be1606f49b4963e7d0791f1800bc7b7fbf71240866ed84e73bc264322415b48272faf46c715d70568fc054fc7183406d182d3c95eeb664019db'
-  data.tar.gz: 787a16d7f91f7ccb907a3cbea0599337bd7525b1f2982f023b639227df1b52511afcc763422c71d0e2bf34216d3f3a4fe6794ae8824abeea9302b84071de8ca5
+  metadata.gz: 0b28806d2442202259c3c7c4cf3e9d2193e47c2a6b2113f31a5906019f94f4fb2f342ef170721e63ff8ff0e037f1c574509b9be0a98f0c3b8b5b9ff289bd4fbc
+  data.tar.gz: 9c6b42c67d4f305517e42c7446278ba7f5a65f7ad9c4ac52657ebc3231fe92619e6d2b6a35b857bb03b0e29568cfeb596ff4153bcd023ee30e0e235e0917af99

data/.github/workflows/ci.yml

@@ -20,6 +20,7 @@ jobs:
       fail-fast: false
       matrix:
         ruby:
+          - '3.3.0-preview2'
           - '3.2'
           - '3.1'
           - '3.0'
@@ -28,18 +29,19 @@ jobs:
           - ruby: '3.2'
             coverage: 'true'
     steps:
-      - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4
+      - uses: actions/checkout@v4
       - name: Install package dependencies
         run: "[ -e $APT_DEPS ] || sudo apt-get install -y --no-install-recommends $APT_DEPS"
 
       - name: Start Kafka with docker-compose
         run: |
-          docker-compose up -d
+          docker-compose up -d || (sleep 5 && docker-compose up -d)
 
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{matrix.ruby}}
+          bundler-cache: true
 
       - name: Install latest bundler
         run: |
@@ -51,6 +53,10 @@ jobs:
           bundle config set without development
           bundle install --jobs 4 --retry 3
 
+      - name: Wait for Kafka
+        run: |
+          bundle exec bin/wait_for_kafka
+
       - name: Run all tests
         env:
           GITHUB_COVERAGE: ${{matrix.coverage}}
@@ -62,7 +68,7 @@ jobs:
     strategy:
       fail-fast: false
     steps:
-      - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4
+      - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4
         with:
           fetch-depth: 0
 
@@ -83,7 +89,7 @@ jobs:
     strategy:
       fail-fast: false
     steps:
-      - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4
+      - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4
         with:
           fetch-depth: 0
       - name: Run Coditsu

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Karafka Web changelog
 
+## 0.7.5 (2023-09-29)
+- [Enhancement] Update order of topics creation for the setup of Web to support zero-downtime setup of Web in running Karafka projects.
+- [Enhancement] Add space delimiter to counters numbers to make them look better.
+- [Improvement] Normalize per-process job tables and health tables structure (topic name on top).
+- [Fix] Fix a case where charts aggregated data would not include all topics.
+- [Fix] Make sure, that most recent per partition data for Health is never overwritten by an old state from a previous partition owner.
+- [Fix] Cache assets for 1 year instead of 7 days.
+- [Fix] Remove source maps pointing to non-existing locations.
+- [Maintenance] Include license and copyrights notice for `timeago.js` that was missing in the JS min file. 
+
 ## 0.7.4 (2023-09-19)
 - [Improvement] Skip aggregations on older schemas during upgrades. This only skips process-reports (that are going to be rolled) on the 5s window in case of an upgrade that should not be a rolling one anyhow. This simplifies the operations and minimizes the risk on breaking upgrades.
 - [Fix] Fix not working `ps` for macOS.

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    karafka-web (0.7.4)
+    karafka-web (0.7.5)
       erubi (~> 1.4)
-      karafka (>= 2.2.3, < 3.0.0)
+      karafka (>= 2.2.6, < 3.0.0)
       karafka-core (>= 2.2.2, < 3.0.0)
       roda (~> 3.68, >= 3.69)
       tilt (~> 2.0)
@@ -26,7 +26,7 @@ GEM
     ffi (1.15.5)
     i18n (1.14.1)
       concurrent-ruby (~> 1.0)
-    karafka (2.2.3)
+    karafka (2.2.6)
       karafka-core (>= 2.2.2, < 2.3.0)
       thor (>= 0.20)
       waterdrop (>= 2.6.6, < 3.0.0)

data/bin/wait_for_kafka

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+# Waits for Kafka to be ready
+# Useful in CI where Kafka needs to be fully started before we run any tests
+
+require 'karafka'
+
+Karafka::App.setup do |config|
+  config.kafka[:'bootstrap.servers'] = '127.0.0.1:9092'
+end
+
+60.times do
+  begin
+    # Stop if we can connect to the cluster and get info
+    exit if Karafka::Admin.cluster_info
+  rescue Rdkafka::RdkafkaError
+    puts "Kafka not available, retrying..."
+    sleep(1)
+  end
+end
+
+puts 'Kafka not available!'
+
+exit 1

data/docker-compose.yml

@@ -1,22 +1,23 @@
 version: '2'
-services:
-  zookeeper:
-    container_name: karafka_web_21_zookeeper
-    image: wurstmeister/zookeeper
-    restart: on-failure
-    ports:
-      - '2181:2181'
 
+services:
   kafka:
-    container_name: karafka_web_21_kafka
-    image: wurstmeister/kafka
+    container_name: kafka
+    image: confluentinc/cp-kafka:7.5.0
+
     ports:
-      - '9092:9092'
+      - 9092:9092
+
     environment:
-      KAFKA_ADVERTISED_HOST_NAME: localhost
-      KAFKA_ADVERTISED_PORT: 9092
-      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
+      CLUSTER_ID: kafka-docker-cluster-1
+      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
+      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
+      KAFKA_PROCESS_ROLES: broker,controller
+      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
+      KAFKA_LISTENERS: PLAINTEXT://:9092,CONTROLLER://:9093
+      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
+      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://127.0.0.1:9092
+      KAFKA_BROKER_ID: 1
+      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@127.0.0.1:9093
+      ALLOW_PLAINTEXT_LISTENER: 'yes'
       KAFKA_AUTO_CREATE_TOPICS_ENABLE: 'true'
-    volumes:
-      - /var/run/docker.sock:/var/run/docker.sock
-    restart: on-failure

data/karafka-web.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.licenses    = %w[LGPL-3.0 Commercial]
 
   spec.add_dependency 'erubi', '~> 1.4'
-  spec.add_dependency 'karafka', '>= 2.2.3', '< 3.0.0'
+  spec.add_dependency 'karafka', '>= 2.2.6', '< 3.0.0'
   spec.add_dependency 'karafka-core', '>= 2.2.2', '< 3.0.0'
   spec.add_dependency 'roda', '~> 3.68', '>= 3.69'
   spec.add_dependency 'tilt', '~> 2.0'

data/lib/karafka/web/errors.rb

@@ -17,9 +17,18 @@ module Karafka
         # If you see this error, it probably means, that you did not bootstrap Web-UI correctly
         MissingConsumersStateError = Class.new(BaseError)
 
-        # Similar to the above. It should be created during install
+        # Raised when we try to materialize the state but the consumers states topic does not
+        # exist and we do not have a way to get the initial state.
+        # It differs from the above because above indicates that the topic exists but that there
+        # is no initial state, while this indicates, that there is no consumers states topic.
+        MissingConsumersStatesTopicError = Class.new(BaseError)
+
+        # Similar to the above. It should be created during install / migration
         MissingConsumersMetricsError = Class.new(BaseError)
 
+        # Similar to the one related to consumers states
+        MissingConsumersMetricsTopicError = Class.new(BaseError)
+
         # This error occurs when consumer running older version of the web-ui tries to materialize
         # states from newer versions. Karafka Web-UI provides only backwards compatibility, so
         # you need to have an up-to-date consumer materializing reported states.

data/lib/karafka/web/installer.rb

@@ -18,7 +18,7 @@ module Karafka
         puts 'Creating necessary topics and populating state data...'
         puts
         Management::CreateTopics.new.call(replication_factor)
-        puts
+        wait_for_topics
         Management::CreateInitialStates.new.call
         puts
         Management::ExtendBootFile.new.call
@@ -36,6 +36,7 @@ module Karafka
         puts 'Creating necessary topics and populating state data...'
         puts
         Management::CreateTopics.new.call(replication_factor)
+        wait_for_topics
         Management::CreateInitialStates.new.call
         puts
         puts("Migration #{green('completed')}. Have fun!")
@@ -51,7 +52,7 @@ module Karafka
         Management::DeleteTopics.new.call
         puts
         Management::CreateTopics.new.call(replication_factor)
-        puts
+        wait_for_topics
         Management::CreateInitialStates.new.call
         puts
         puts("Resetting #{green('completed')}. Have fun!")
@@ -74,6 +75,30 @@ module Karafka
       def enable!
         Management::Enable.new.call
       end
+
+      private
+
+      # Waits with a message, that we are waiting on topics
+      # This is not doing much, just waiting as there are some cases that it takes a bit of time
+      # for Kafka to actually propagate new topics knowledge across the cluster. We give it that
+      # bit of time just in case.
+      def wait_for_topics
+        puts
+        print 'Waiting for the topics to synchronize in the cluster'
+        wait(5)
+        puts
+      end
+
+      # Waits for given number of seconds and prints `.` every second.
+      # @param time_in_seconds [Integer] time of wait
+      def wait(time_in_seconds)
+        time_in_seconds.times do
+          sleep(1)
+          print '.'
+        end
+
+        print "\n"
+      end
     end
   end
 end

data/lib/karafka/web/management/create_topics.rb

@@ -9,54 +9,36 @@ module Karafka
         # Runs the creation process
         #
         # @param replication_factor [Integer] replication factor for Web-UI topics
+        #
+        # @note The order of creation of those topics is important. In order to support the
+        #   zero-downtime bootstrap, we use the presence of the states topic and its initial state
+        #   existence as an indicator that the setup went as expected. It the consumers states
+        #   topic exists and contains needed data, it means all went as expected and that
+        #   topics created before it also exist (as no error).
         def call(replication_factor)
           consumers_states_topic = ::Karafka::Web.config.topics.consumers.states
           consumers_metrics_topic = ::Karafka::Web.config.topics.consumers.metrics
           consumers_reports_topic = ::Karafka::Web.config.topics.consumers.reports
           errors_topic = ::Karafka::Web.config.topics.errors
 
-          # Create only if needed
-          if existing_topics_names.include?(consumers_states_topic)
-            exists(consumers_states_topic)
-          else
-            creating(consumers_states_topic)
-            # This topic needs to have one partition
-            ::Karafka::Admin.create_topic(
-              consumers_states_topic,
-              1,
-              replication_factor,
-              # We care only about the most recent state, previous are irrelevant. So we can easily
-              # compact after one minute. We do not use this beyond the most recent collective
-              # state, hence it all can easily go away. We also limit the segment size to at most
-              # 100MB not to use more space ever.
-              {
-                'cleanup.policy': 'compact',
-                'retention.ms': 60 * 60 * 1_000,
-                'segment.ms': 24 * 60 * 60 * 1_000, # 1 day
-                'segment.bytes': 104_857_600 # 100MB
-              }
-            )
-            created(consumers_states_topic)
-          end
-
-          if existing_topics_names.include?(consumers_metrics_topic)
-            exists(consumers_metrics_topic)
+          if existing_topics_names.include?(errors_topic)
+            exists(errors_topic)
           else
-            creating(consumers_metrics_topic)
-            # This topic needs to have one partition
-            # Same as states - only most recent is relevant as it is a materialized state
+            creating(errors_topic)
+            # All the errors will be dispatched here
+            # This topic can have multiple partitions but we go with one by default. A single Ruby
+            # process should not crash that often and if there is an expectation of a higher volume
+            # of errors, this can be changed by the end user
             ::Karafka::Admin.create_topic(
-              consumers_metrics_topic,
+              errors_topic,
               1,
               replication_factor,
+              # Remove really old errors (older than 3 months just to preserve space)
               {
-                'cleanup.policy': 'compact',
-                'retention.ms': 60 * 60 * 1_000, # 1h
-                'segment.ms': 24 * 60 * 60 * 1_000, # 1 day
-                'segment.bytes': 104_857_600 # 100MB
+                'retention.ms': 3 * 31 * 24 * 60 * 60 * 1_000 # 3 months
               }
             )
-            created(consumers_metrics_topic)
+            created(errors_topic)
           end
 
           if existing_topics_names.include?(consumers_reports_topic)
@@ -81,24 +63,48 @@ module Karafka
             created(consumers_reports_topic)
           end
 
-          if existing_topics_names.include?(errors_topic)
-            exists(errors_topic)
+          if existing_topics_names.include?(consumers_metrics_topic)
+            exists(consumers_metrics_topic)
           else
-            creating(errors_topic)
-            # All the errors will be dispatched here
-            # This topic can have multiple partitions but we go with one by default. A single Ruby
-            # process should not crash that often and if there is an expectation of a higher volume
-            # of errors, this can be changed by the end user
+            creating(consumers_metrics_topic)
+            # This topic needs to have one partition
+            # Same as states - only most recent is relevant as it is a materialized state
             ::Karafka::Admin.create_topic(
-              errors_topic,
+              consumers_metrics_topic,
               1,
               replication_factor,
-              # Remove really old errors (older than 3 months just to preserve space)
               {
-                'retention.ms': 3 * 31 * 24 * 60 * 60 * 1_000 # 3 months
+                'cleanup.policy': 'compact',
+                'retention.ms': 60 * 60 * 1_000, # 1h
+                'segment.ms': 24 * 60 * 60 * 1_000, # 1 day
+                'segment.bytes': 104_857_600 # 100MB
               }
             )
-            created(errors_topic)
+            created(consumers_metrics_topic)
+          end
+
+          # Create only if needed
+          if existing_topics_names.include?(consumers_states_topic)
+            exists(consumers_states_topic)
+          else
+            creating(consumers_states_topic)
+            # This topic needs to have one partition
+            ::Karafka::Admin.create_topic(
+              consumers_states_topic,
+              1,
+              replication_factor,
+              # We care only about the most recent state, previous are irrelevant. So we can easily
+              # compact after one minute. We do not use this beyond the most recent collective
+              # state, hence it all can easily go away. We also limit the segment size to at most
+              # 100MB not to use more space ever.
+              {
+                'cleanup.policy': 'compact',
+                'retention.ms': 60 * 60 * 1_000,
+                'segment.ms': 24 * 60 * 60 * 1_000, # 1 day
+                'segment.bytes': 104_857_600 # 100MB
+              }
+            )
+            created(consumers_states_topic)
           end
         end
 

data/lib/karafka/web/processing/consumers/aggregators/metrics.rb

@@ -86,65 +86,75 @@ module Karafka
 
             # Materializes the current state of consumers group data
             #
-            # At the moment we report only topics lags but the format we are using supports
-            # extending this information in the future if it would be needed.
-            #
             # @return [Hash] hash with nested consumers and their topics details structure
             # @note We do **not** report on a per partition basis because it would significantly
             #   increase needed storage.
             def materialize_consumers_groups_current_state
               cgs = {}
 
-              @active_reports.each do |_, details|
-                details.fetch(:consumer_groups).each do |group_name, group_details|
-                  group_details.fetch(:subscription_groups).each do |_sg_name, sg_details|
-                    sg_details.fetch(:topics).each do |topic_name, topic_details|
-                      partitions_data = topic_details.fetch(:partitions).values
+              iterate_partitions_data do |group_name, topic_name, partitions_data|
+                lags = partitions_data
+                       .map { |p_details| p_details.fetch(:lag, -1) }
+                       .reject(&:negative?)
+
+                lags_stored = partitions_data
+                              .map { |p_details| p_details.fetch(:lag_stored, -1) }
+                              .reject(&:negative?)
 
-                      lags = partitions_data
-                             .map { |p_details| p_details.fetch(:lag, -1) }
+                offsets_hi = partitions_data
+                             .map { |p_details| p_details.fetch(:hi_offset, -1) }
                              .reject(&:negative?)
 
-                      lags_stored = partitions_data
-                                    .map { |p_details| p_details.fetch(:lag_stored, -1) }
-                                    .reject(&:negative?)
-
-                      offsets_hi = partitions_data
-                                   .map { |p_details| p_details.fetch(:hi_offset, -1) }
-                                   .reject(&:negative?)
-
-                      # Last stable offsets freeze durations - we pick the max freeze to indicate
-                      # the longest open transaction that potentially may be hanging
-                      ls_offsets_fd = partitions_data
-                                      .map { |p_details| p_details.fetch(:ls_offset_fd, 0) }
-                                      .reject(&:negative?)
-
-                      # If there is no lag that would not be negative, it means we did not mark
-                      # any messages as consumed on this topic in any partitions, hence we cannot
-                      # compute lag easily
-                      # We do not want to initialize any data for this topic, when there is nothing
-                      # useful we could present
-                      #
-                      # In theory lag stored must mean that lag must exist but just to be sure we
-                      # check both here
-                      next if lags.empty? || lags_stored.empty?
-
-                      cgs[group_name] ||= {}
-                      cgs[group_name][topic_name] = {
-                        lag_stored: lags_stored.sum,
-                        lag: lags.sum,
-                        pace: offsets_hi.sum,
-                        # Take max last stable offset duration without any change. This can
-                        # indicate a hanging transaction, because the offset will not move forward
-                        # and will stay with a growing freeze duration when stuck
-                        ls_offset_fd: ls_offsets_fd.max
-                      }
+                # Last stable offsets freeze durations - we pick the max freeze to indicate
+                # the longest open transaction that potentially may be hanging
+                ls_offsets_fd = partitions_data
+                                .map { |p_details| p_details.fetch(:ls_offset_fd, 0) }
+                                .reject(&:negative?)
+
+                cgs[group_name] ||= {}
+                cgs[group_name][topic_name] = {
+                  lag_stored: lags_stored.sum,
+                  lag: lags.sum,
+                  pace: offsets_hi.sum,
+                  # Take max last stable offset duration without any change. This can
+                  # indicate a hanging transaction, because the offset will not move forward
+                  # and will stay with a growing freeze duration when stuck
+                  ls_offset_fd: ls_offsets_fd.max || 0
+                }
+              end
+
+              cgs
+            end
+
+            # Converts our reports data into an iterator per partition
+            # Compensates for a case where same partition data would be available for a short
+            # period of time in multiple processes reports due to rebalances.
+            def iterate_partitions_data
+              cgs_topics = Hash.new { |h, v| h[v] = Hash.new { |h2, v2| h2[v2] = {} } }
+
+              # We need to sort them in case we have same reports containing data about same
+              # topics partitions. Mostly during shutdowns and rebalances
+              @active_reports
+                .values
+                .sort_by { |report| report.fetch(:dispatched_at) }
+                .map { |details| details.fetch(:consumer_groups) }
+                .each do |consumer_groups|
+                  consumer_groups.each do |group_name, group_details|
+                    group_details.fetch(:subscription_groups).each_value do |sg_details|
+                      sg_details.fetch(:topics).each do |topic_name, topic_details|
+                        topic_details.fetch(:partitions).each do |partition_id, partition_data|
+                          cgs_topics[group_name][topic_name][partition_id] = partition_data
+                        end
+                      end
                     end
                   end
                 end
-              end
 
-              cgs
+              cgs_topics.each do |group_name, topics_data|
+                topics_data.each do |topic_name, partitions_data|
+                  yield(group_name, topic_name, partitions_data.values)
+                end
+              end
             end
           end
         end

data/lib/karafka/web/processing/consumers/metrics.rb

@@ -20,6 +20,10 @@ module Karafka
               return metrics_message.payload if metrics_message
 
               raise(::Karafka::Web::Errors::Processing::MissingConsumersMetricsError)
+            rescue Rdkafka::RdkafkaError => e
+              raise(e) unless e.code == :unknown_partition
+
+              raise(::Karafka::Web::Errors::Processing::MissingConsumersMetricsTopicError)
             end
           end
         end

data/lib/karafka/web/processing/consumers/state.rb

@@ -20,6 +20,10 @@ module Karafka
               return state_message.payload if state_message
 
               raise(::Karafka::Web::Errors::Processing::MissingConsumersStateError)
+            rescue Rdkafka::RdkafkaError => e
+              raise(e) unless e.code == :unknown_partition
+
+              raise(::Karafka::Web::Errors::Processing::MissingConsumersStatesTopicError)
             end
           end
         end

data/lib/karafka/web/processing/time_series_tracker.rb

@@ -116,9 +116,12 @@ module Karafka
             # available
             times << values.last unless values.empty?
 
+            # Keep the most recent state out of many that would come from the same time moment
+            # Squash in case there would be two events from the same time
+            times.reverse!
             times.uniq!(&:first)
+            times.reverse!
 
-            # Squash in case there would be two events from the same time
             times.sort_by!(&:first)
 
             @historicals[range_name] = times.last(limit)

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

@@ -16,7 +16,7 @@ module Karafka
 
           # Serve current version specific assets to prevent users from fetching old assets
           # after upgrade
-          r.on(:assets, Karafka::Web::VERSION) do
+          r.on 'assets', Karafka::Web::VERSION do
             r.public
           end
 

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

@@ -16,7 +16,7 @@ module Karafka
             root: Karafka::Web.gem_root.join('lib/karafka/web/ui/public'),
             # Cache all static files for the end user for as long as possible
             # We can do it because we ship per version assets so they invalidate with gem bumps
-            headers: { 'Cache-Control' => 'max-age=604800' }
+            headers: { 'Cache-Control' => 'max-age=31536000, immutable' }
           )
           plugin :render_each
           plugin :partials

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

@@ -101,12 +101,13 @@ module Karafka
 
           # Converts number to a more friendly delimiter based version
           # @param number [Numeric]
+          # @param delimiter [String] delimiter (comma by default)
           # @return [String] number with delimiter
-          def number_with_delimiter(number)
+          def number_with_delimiter(number, delimiter = ',')
             return '' unless number
 
             parts = number.to_s.to_str.split('.')
-            parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, '\1,')
+            parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
             parts.join('.')
           end
 

data/lib/karafka/web/ui/models/health.rb

@@ -62,7 +62,11 @@ module Karafka
             #
             # @param state [State]
             def iterate_partitions(state)
-              processes = Processes.active(state)
+              # By default processes are sort by name and this is not what we want here
+              # We want to make sure that the newest data is processed the last, so we get
+              # the most accurate state in case of deployments and shutdowns, etc without the
+              # expired processes partitions data overwriting the newly created processes
+              processes = Processes.active(state).sort_by!(&:dispatched_at)
 
               processes.each do |process|
                 process.consumer_groups.each do |consumer_group|

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

@@ -36,7 +36,7 @@ module Karafka
 
             # Serve current version specific assets to prevent users from fetching old assets
             # after upgrade
-            r.on(:assets, Karafka::Web::VERSION) do
+            r.on 'assets', Karafka::Web::VERSION do
               r.public
             end