karafka-web 0.7.3 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc9572e3dfbb4565361fdbc9521fb7a9a7833664f42bd8e9f0e63e940a397034
-  data.tar.gz: 07fb369bcd0d1aa6c80ef20ff96289989c38ff934a1eb795ab85f39b7adf1228
+  metadata.gz: caf2303a2e877dd3f06b738974c4093f7a9cf1bdb24b1152183ba9173432b640
+  data.tar.gz: 80b56d4efec23d589adb731c18e5b7137718862edc246fb2c32ff0baaadb84a5
 SHA512:
-  metadata.gz: 51bc23c17be963c3b19143aa8034046c0bd85df4251dc9e2e911a8ab28ae194d9ae62e2ab1d3aa0b3e2f8dba33649ad51881d9e96fe669fffbdc971f406ce3eb
-  data.tar.gz: 332247644ed57d25687af816ed850f7847b6eb8e63646bf492460424f0d5855c8dace2f1127d0d84631bffa8f6a9fb71e42a64ece7141a6acb96d5b5f987896c
+  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,19 @@
 # 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.
+
 ## 0.7.3 (2023-09-18)
 - [Improvement] Mitigate a case where a race-condition during upgrade would crash data.
 

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    karafka-web (0.7.3)
+    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/consumer.rb

@@ -26,6 +26,7 @@ module Karafka
 
           # We set this that way so we report with first batch and so we report as fast as possible
           @flushed_at = monotonic_now - @flush_interval
+          @established = false
         end
 
         # Aggregates consumers state into a single current state representation
@@ -34,10 +35,24 @@ module Karafka
 
           # If there is even one incompatible message, we need to stop
           consumers_messages.each do |message|
-            unless @schema_manager.compatible?(message)
+            case @schema_manager.call(message)
+            when :current
+              true
+            when :newer
+              @schema_manager.invalidate!
+
               dispatch
 
               raise ::Karafka::Web::Errors::Processing::IncompatibleSchemaError
+            # Older reports mean someone is in the middle of upgrade. Schema change related
+            # upgrades always should happen without a rolling-upgrade, hence we can reject those
+            # requests without significant or any impact on data quality but without having to
+            # worry about backwards compatibility. Errors are tracked independently, so it should
+            # not be a problem.
+            when :older
+              next
+            else
+              raise ::Karafka::Errors::UnsupportedCaseError
             end
 
             # We need to run the aggregations on each message in order to compensate for
@@ -45,6 +60,10 @@ module Karafka
             @state_aggregator.add(message.payload, message.offset)
             @metrics_aggregator.add_report(message.payload)
             @metrics_aggregator.add_stats(@state_aggregator.stats)
+            # Indicates that we had at least one report we used to enrich data
+            # If there were no state changes, there is no reason to flush data. This can occur
+            # when we had some messages but we skipped them for any reason on a first run
+            @established = true
 
             # Optimize memory usage in pro
             message.clean! if Karafka.pro?
@@ -59,17 +78,15 @@ module Karafka
 
         # Flush final state on shutdown
         def shutdown
-          return unless @state_aggregator
-
-          materialize
-          validate!
-          flush
+          dispatch
         end
 
         private
 
         # Flushes the state of the Web-UI to the DB
         def dispatch
+          return unless @established
+
           materialize
           validate!
           flush

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[:lag] || 0 }
+                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/schema_manager.rb

@@ -27,12 +27,8 @@ module Karafka
           end
 
           # @param message [Karafka::Messages::Message] consumer report
-          # @return [Boolean] true if all good or false if incompatible
-          #
-          # @note The state switch is one-direction only. If we encounter an incompatible message
-          #   we need to stop processing so further checks even with valid should not switch it
-          #   back to valid
-          def compatible?(message)
+          # @return [Symbol] is the given message using older, newer or current schema
+          def call(message)
             schema_version = message.payload[:schema_version]
 
             # Save on memory allocation by reusing
@@ -40,8 +36,19 @@ module Karafka
             # an object with each message
             message_version = @cache[schema_version] ||= ::Gem::Version.new(schema_version)
 
-            return true if message_version <= CURRENT_VERSION
+            return :older if message_version < CURRENT_VERSION
+            return :newer if message_version > CURRENT_VERSION
+
+            :current
+          end
 
+          # Moves the schema manager state to incompatible to indicate in the Web-UI that we
+          # cannot move forward because schema is incompatible.
+          #
+          # @note The state switch is one-direction only. If we encounter an incompatible message
+          #   we need to stop processing so further checks even with valid should not switch it
+          #   back to valid
+          def invalidate!
             @valid = false
           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