karafka 1.4.12 → 2.2.10

data/lib/karafka/pro/processing/strategies/dlq/ftr_vp.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# This Karafka component is a Pro component under a commercial license.
+# This Karafka component is NOT licensed under LGPL.
+#
+# All of the commercial components are present in the lib/karafka/pro directory of this
+# repository and their usage requires commercial license agreement.
+#
+# Karafka has also commercial-friendly license, commercial support and commercial components.
+#
+# By sending a pull request to the pro components, you are agreeing to transfer the copyright of
+# your code to Maciej Mensfeld.
+
+module Karafka
+  module Pro
+    module Processing
+      module Strategies
+        module Dlq
+          # - DLQ
+          # - Ftr
+          # - VPs
+          #
+          # Behaves same as non-VP due to coordinator lock
+          module FtrVp
+            include Strategies::Vp::Default
+            include Strategies::Dlq::Vp
+            include Strategies::Dlq::Ftr
+
+            # Features for this strategy
+            FEATURES = %i[
+              dead_letter_queue
+              filtering
+              virtual_partitions
+            ].freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/strategies/dlq/lrj.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# This Karafka component is a Pro component under a commercial license.
+# This Karafka component is NOT licensed under LGPL.
+#
+# All of the commercial components are present in the lib/karafka/pro directory of this
+# repository and their usage requires commercial license agreement.
+#
+# Karafka has also commercial-friendly license, commercial support and commercial components.
+#
+# By sending a pull request to the pro components, you are agreeing to transfer the copyright of
+# your code to Maciej Mensfeld.
+
+module Karafka
+  module Pro
+    module Processing
+      module Strategies
+        module Dlq
+          # DLQ enabled
+          # Long-Running Job enabled
+          module Lrj
+            # Order here matters, lrj needs to be second
+            include Strategies::Dlq::Default
+            include Strategies::Lrj::Default
+
+            # Features for this strategy
+            FEATURES = %i[
+              dead_letter_queue
+              long_running_job
+            ].freeze
+
+            # LRJ standard flow after consumption with DLQ dispatch
+            def handle_after_consume
+              coordinator.on_finished do |last_group_message|
+                if coordinator.success?
+                  coordinator.pause_tracker.reset
+
+                  return if coordinator.manual_pause?
+
+                  mark_as_consumed(last_group_message) unless revoked?
+                  # We should not overwrite user manual seel request with our seek
+                  seek(coordinator.seek_offset, false) unless revoked? || coordinator.manual_seek?
+
+                  resume
+                elsif coordinator.pause_tracker.attempt <= topic.dead_letter_queue.max_retries
+                  retry_after_pause
+                else
+                  coordinator.pause_tracker.reset
+
+                  return resume if revoked?
+
+                  skippable_message, = find_skippable_message
+                  dispatch_to_dlq(skippable_message) if dispatch_to_dlq?
+                  mark_as_consumed(skippable_message)
+                  pause(coordinator.seek_offset, nil, false)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/strategies/dlq/lrj_mom.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# This Karafka component is a Pro component under a commercial license.
+# This Karafka component is NOT licensed under LGPL.
+#
+# All of the commercial components are present in the lib/karafka/pro directory of this
+# repository and their usage requires commercial license agreement.
+#
+# Karafka has also commercial-friendly license, commercial support and commercial components.
+#
+# By sending a pull request to the pro components, you are agreeing to transfer the copyright of
+# your code to Maciej Mensfeld.
+
+module Karafka
+  module Pro
+    module Processing
+      module Strategies
+        module Dlq
+          # Strategy for supporting DLQ with Mom and LRJ enabled
+          module LrjMom
+            # This strategy needs to pause and revoke same way as DlqLrj but without the offset
+            # management
+            include Strategies::Dlq::Lrj
+
+            # Features for this strategy
+            FEATURES = %i[
+              dead_letter_queue
+              long_running_job
+              manual_offset_management
+            ].freeze
+
+            # LRJ standard flow after consumption with DLQ dispatch and no offset management
+            def handle_after_consume
+              coordinator.on_finished do |last_group_message|
+                if coordinator.success?
+                  coordinator.pause_tracker.reset
+
+                  return if coordinator.manual_pause?
+
+                  unless revoked? || coordinator.manual_seek?
+                    seek(last_group_message.offset + 1, false)
+                  end
+
+                  resume
+                elsif coordinator.pause_tracker.attempt <= topic.dead_letter_queue.max_retries
+                  retry_after_pause
+                else
+                  coordinator.pause_tracker.reset
+
+                  return resume if revoked?
+
+                  skippable_message, _marked = find_skippable_message
+                  dispatch_to_dlq(skippable_message) if dispatch_to_dlq?
+
+                  coordinator.seek_offset = skippable_message.offset + 1
+                  pause(coordinator.seek_offset, nil, false)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/strategies/dlq/lrj_mom_vp.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# This Karafka component is a Pro component under a commercial license.
+# This Karafka component is NOT licensed under LGPL.
+#
+# All of the commercial components are present in the lib/karafka/pro directory of this
+# repository and their usage requires commercial license agreement.
+#
+# Karafka has also commercial-friendly license, commercial support and commercial components.
+#
+# By sending a pull request to the pro components, you are agreeing to transfer the copyright of
+# your code to Maciej Mensfeld.
+
+module Karafka
+  module Pro
+    module Processing
+      module Strategies
+        module Dlq
+          # Strategy for supporting DLQ with Mom, LRJ and VP enabled
+          module LrjMomVp
+            # Feature set for this strategy
+            FEATURES = %i[
+              dead_letter_queue
+              long_running_job
+              manual_offset_management
+              virtual_partitions
+            ].freeze
+
+            include Strategies::Dlq::Vp
+            include Strategies::Dlq::LrjMom
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/strategies/dlq/lrj_vp.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# This Karafka component is a Pro component under a commercial license.
+# This Karafka component is NOT licensed under LGPL.
+#
+# All of the commercial components are present in the lib/karafka/pro directory of this
+# repository and their usage requires commercial license agreement.
+#
+# Karafka has also commercial-friendly license, commercial support and commercial components.
+#
+# By sending a pull request to the pro components, you are agreeing to transfer the copyright of
+# your code to Maciej Mensfeld.
+
+module Karafka
+  module Pro
+    module Processing
+      module Strategies
+        module Dlq
+          # Dead-Letter Queue enabled
+          # Long-Running Job enabled
+          # Virtual Partitions enabled
+          module LrjVp
+            # Same flow as the Dlq Lrj because VP collapses on errors, so DlqLrj can kick in
+            include Strategies::Vp::Default
+            include Strategies::Dlq::Vp
+            include Strategies::Dlq::Lrj
+
+            # Features for this strategy
+            FEATURES = %i[
+              dead_letter_queue
+              long_running_job
+              virtual_partitions
+            ].freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/strategies/dlq/mom.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# This Karafka component is a Pro component under a commercial license.
+# This Karafka component is NOT licensed under LGPL.
+#
+# All of the commercial components are present in the lib/karafka/pro directory of this
+# repository and their usage requires commercial license agreement.
+#
+# Karafka has also commercial-friendly license, commercial support and commercial components.
+#
+# By sending a pull request to the pro components, you are agreeing to transfer the copyright of
+# your code to Maciej Mensfeld.
+
+module Karafka
+  module Pro
+    module Processing
+      module Strategies
+        module Dlq
+          # Strategy for supporting DLQ with Mom enabled
+          module Mom
+            # The broken message lookup is the same in this scenario
+            include Strategies::Dlq::Default
+
+            # Features for this strategy
+            FEATURES = %i[
+              dead_letter_queue
+              manual_offset_management
+            ].freeze
+
+            # When manual offset management is on, we do not mark anything as consumed
+            # automatically and we rely on the user to figure things out
+            def handle_after_consume
+              coordinator.on_finished do
+                return if revoked?
+
+                if coordinator.success?
+                  coordinator.pause_tracker.reset
+                elsif coordinator.pause_tracker.attempt <= topic.dead_letter_queue.max_retries
+                  retry_after_pause
+                # If we've reached number of retries that we could, we need to skip the first
+                # message that was not marked as consumed, pause and continue, while also moving
+                # this message to the dead topic.
+                #
+                # For a Mom setup, this means, that user has to manage the checkpointing by
+                # himself. If no checkpointing is ever done, we end up with an endless loop.
+                else
+                  # We reset the pause to indicate we will now consider it as "ok".
+                  coordinator.pause_tracker.reset
+
+                  skippable_message, = find_skippable_message
+                  dispatch_to_dlq(skippable_message) if dispatch_to_dlq?
+
+                  # Save the next offset we want to go with after moving given message to DLQ
+                  # Without this, we would not be able to move forward and we would end up
+                  # in an infinite loop trying to un-pause from the message we've already processed
+                  # Of course, since it's a MoM a rebalance or kill, will move it back as no
+                  # offsets are being committed
+                  coordinator.seek_offset = skippable_message.offset + 1
+                  pause(coordinator.seek_offset, nil, false)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/strategies/dlq/mom_vp.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# This Karafka component is a Pro component under a commercial license.
+# This Karafka component is NOT licensed under LGPL.
+#
+# All of the commercial components are present in the lib/karafka/pro directory of this
+# repository and their usage requires commercial license agreement.
+#
+# Karafka has also commercial-friendly license, commercial support and commercial components.
+#
+# By sending a pull request to the pro components, you are agreeing to transfer the copyright of
+# your code to Maciej Mensfeld.
+
+module Karafka
+  module Pro
+    module Processing
+      module Strategies
+        module Dlq
+          # Dead-Letter Queue enabled
+          # MoM enabled
+          # Virtual Partitions enabled
+          module MomVp
+            include Strategies::Dlq::Vp
+            include Strategies::Dlq::Mom
+
+            # Features for this strategy
+            FEATURES = %i[
+              dead_letter_queue
+              manual_offset_management
+              virtual_partitions
+            ].freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/strategies/dlq/vp.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# This Karafka component is a Pro component under a commercial license.
+# This Karafka component is NOT licensed under LGPL.
+#
+# All of the commercial components are present in the lib/karafka/pro directory of this
+# repository and their usage requires commercial license agreement.
+#
+# Karafka has also commercial-friendly license, commercial support and commercial components.
+#
+# By sending a pull request to the pro components, you are agreeing to transfer the copyright of
+# your code to Maciej Mensfeld.
+
+module Karafka
+  module Pro
+    module Processing
+      module Strategies
+        module Dlq
+          # Dead Letter Queue enabled
+          # Virtual Partitions enabled
+          #
+          # In general because we collapse processing in virtual partitions to one on errors, there
+          # is no special action that needs to be taken because we warranty that even with VPs
+          # on errors a retry collapses into a single state and from this single state we can
+          # mark as consumed the message that we are moving to the DLQ.
+          module Vp
+            # Features for this strategy
+            FEATURES = %i[
+              dead_letter_queue
+              virtual_partitions
+            ].freeze
+
+            include Strategies::Dlq::Default
+            include Strategies::Vp::Default
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/strategies/ftr/default.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# This Karafka component is a Pro component under a commercial license.
+# This Karafka component is NOT licensed under LGPL.
+#
+# All of the commercial components are present in the lib/karafka/pro directory of this
+# repository and their usage requires commercial license agreement.
+#
+# Karafka has also commercial-friendly license, commercial support and commercial components.
+#
+# By sending a pull request to the pro components, you are agreeing to transfer the copyright of
+# your code to Maciej Mensfeld.
+
+module Karafka
+  module Pro
+    module Processing
+      module Strategies
+        # Filtering related init strategies
+        module Ftr
+          # Only filtering enabled
+          module Default
+            include Strategies::Default
+
+            # Just filtering enabled
+            FEATURES = %i[
+              filtering
+            ].freeze
+
+            # Empty run when running on idle means we need to filter
+            def handle_idle
+              handle_post_filtering
+            end
+
+            # Standard flow without any features
+            def handle_after_consume
+              coordinator.on_finished do |last_group_message|
+                return if revoked?
+
+                if coordinator.success?
+                  coordinator.pause_tracker.reset
+
+                  # Do not mark last message if pause happened. This prevents a scenario where
+                  # pause is overridden upon rebalance by marking
+                  return if coordinator.manual_pause?
+
+                  mark_as_consumed(last_group_message)
+
+                  handle_post_filtering
+                else
+                  retry_after_pause
+                end
+              end
+            end
+
+            # Throttles by pausing for an expected time period if throttling is needed or seeks
+            # in case the throttle expired. Throttling may expire because we throttle before
+            # processing starts and we need to compensate for processing time. It may turn out
+            # that we don't have to pause but we need to move the offset because we skipped some
+            # messages due to throttling filtering.
+            # @return [Boolean] was any form of throttling operations (pause or seek) needed
+            def handle_post_filtering
+              filter = coordinator.filter
+
+              # We pick the timeout before the action because every action takes time. This time
+              # may then mean we end up having throttle time equal to zero when pause is needed
+              # and this should not happen
+              throttle_timeout = filter.timeout
+
+              case filter.action
+              when :skip
+                nil
+              when :seek
+                # User direct actions take priority over automatic operations
+                # If we've already seeked we can just resume operations, nothing extra needed
+                return resume if coordinator.manual_seek?
+
+                throttle_message = filter.cursor
+
+                Karafka.monitor.instrument(
+                  'filtering.seek',
+                  caller: self,
+                  message: throttle_message
+                ) do
+                  seek(throttle_message.offset, false)
+                end
+
+                resume
+              when :pause
+                # User direct actions take priority over automatic operations
+                return nil if coordinator.manual_pause?
+
+                throttle_message = filter.cursor
+
+                Karafka.monitor.instrument(
+                  'filtering.throttled',
+                  caller: self,
+                  message: throttle_message,
+                  timeout: throttle_timeout
+                ) do
+                  pause(throttle_message.offset, throttle_timeout, false)
+                end
+              else
+                raise Karafka::Errors::UnsupportedCaseError filter.action
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/strategies/ftr/vp.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# This Karafka component is a Pro component under a commercial license.
+# This Karafka component is NOT licensed under LGPL.
+#
+# All of the commercial components are present in the lib/karafka/pro directory of this
+# repository and their usage requires commercial license agreement.
+#
+# Karafka has also commercial-friendly license, commercial support and commercial components.
+#
+# By sending a pull request to the pro components, you are agreeing to transfer the copyright of
+# your code to Maciej Mensfeld.
+
+module Karafka
+  module Pro
+    module Processing
+      module Strategies
+        # Filtering related init strategies
+        module Ftr
+          # Filtering enabled
+          # VPs enabled
+          #
+          # VPs should operate without any problems with filtering because virtual partitioning
+          # happens on the limited set of messages and collective filtering applies the same
+          # way as for default cases
+          module Vp
+            # Filtering + VPs
+            FEATURES = %i[
+              filtering
+              virtual_partitions
+            ].freeze
+
+            include Strategies::Vp::Default
+            include Strategies::Ftr::Default
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/strategies/lrj/default.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# This Karafka component is a Pro component under a commercial license.
+# This Karafka component is NOT licensed under LGPL.
+#
+# All of the commercial components are present in the lib/karafka/pro directory of this
+# repository and their usage requires commercial license agreement.
+#
+# Karafka has also commercial-friendly license, commercial support and commercial components.
+#
+# By sending a pull request to the pro components, you are agreeing to transfer the copyright of
+# your code to Maciej Mensfeld.
+
+module Karafka
+  module Pro
+    module Processing
+      module Strategies
+        module Lrj
+          # Long-Running Job enabled
+          module Default
+            include Strategies::Default
+
+            # Pause for tops 31 years
+            MAX_PAUSE_TIME = 1_000_000_000_000
+
+            # Features for this strategy
+            FEATURES = %i[
+              long_running_job
+            ].freeze
+
+            # We always need to pause prior to doing any jobs for LRJ
+            def handle_before_enqueue
+              super
+
+              # This ensures that when running LRJ with VP, things operate as expected run only
+              # once for all the virtual partitions collectively
+              coordinator.on_enqueued do
+                # Pause and continue with another batch in case of a regular resume.
+                # In case of an error, the `#retry_after_pause` will move the offset to the first
+                # message out of this batch.
+                pause(:consecutive, MAX_PAUSE_TIME, false)
+              end
+            end
+
+            # LRJ standard flow after consumption
+            def handle_after_consume
+              coordinator.on_finished do |last_group_message|
+                if coordinator.success?
+                  coordinator.pause_tracker.reset
+
+                  return if coordinator.manual_pause?
+
+                  mark_as_consumed(last_group_message) unless revoked?
+                  seek(coordinator.seek_offset, false) unless revoked? || coordinator.manual_seek?
+
+                  resume
+                else
+                  # If processing failed, we need to pause
+                  # For long running job this will overwrite the default never-ending pause and
+                  # will cause the processing to keep going after the error backoff
+                  retry_after_pause
+                end
+              end
+            end
+
+            # We do not un-pause on revokations for LRJ
+            def handle_revoked
+              coordinator.on_revoked do
+                # We do not want to resume on revocation in case of a LRJ.
+                # For LRJ we resume after the successful processing or do a backoff pause in case
+                # of a failure. Double non-blocking resume could cause problems in coordination.
+                coordinator.revoke
+              end
+
+              Karafka.monitor.instrument('consumer.revoke', caller: self)
+              Karafka.monitor.instrument('consumer.revoked', caller: self) do
+                revoked
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end