beetle 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc653de6c1ae3114292d7a8b6007b45f6f9cf738
-  data.tar.gz: 6483f18188fe2440c191fd87f42238df3a735d59
+  metadata.gz: 7f35943d8dbccaf27c203a95f97bd0c07eac095e
+  data.tar.gz: 457e47a4c51befed13d5c79a9b9d30a7e34f565b
 SHA512:
-  metadata.gz: c9820af31098f5b6eccab38d3b5d463fb3a3a038ebd6def62a6799fa122deff721dd079bb3faec0f5d35465d0a5c3e293348c90491b99b47e17618c6f7f5b801
-  data.tar.gz: 0bb4d6042f238635edc3b805dc9819e2bc88d13d2c820eff9bc4f42aa71232aed829814c8d033a38981583e7e4559b81f23027a6160014546b05cefb84647668
+  metadata.gz: 3bd412cffe960ec193ce073fcefece2e7656ed4b136246ea4edf46ea57b45245736b6a00266a2f5edf8413f132790a74b6c86dfcf8c6f613b1a289cd6e284bc5
+  data.tar.gz: a88e2fbe08e0c0a2730b524e58c2a56a9f711b2bfd449bc9b9c895219a69b5f8af82a9d8715550bbe144a026e16ea45c7b569055517f8208dd2322f66c4951c5

data/RELEASE_NOTES.rdoc

@@ -1,5 +1,9 @@
 = Release Notes
 
+== Version 2.1.0
+
+* Support exponential backoff when delaying messages using 'max_delay: int' option.
+
 == Version 2.0.1
 
 * fixed incorrect computation of responsiveness threshold in

data/examples/attempts_with_dead_letter_and_exponential_backoff.rb

@@ -0,0 +1,72 @@
+# attempts_with_dead_letter_and_exponential_backoff.rb
+# ! check the examples/README.rdoc for information on starting your redis/rabbit !
+#
+# start it with ruby attempts_with_dead_letter_and_exponential_backoff.rb
+
+require "rubygems"
+require File.expand_path("../lib/beetle", File.dirname(__FILE__))
+
+# set Beetle log level to info, less noisy than debug
+Beetle.config.logger.level = Logger::INFO
+
+# setup client with dead lettering enabled
+config = Beetle::Configuration.new
+config.dead_lettering_enabled = true
+config.dead_lettering_msg_ttl = 1000 # millis
+client = Beetle::Client.new(config)
+client.register_queue(:test)
+client.register_message(:test)
+
+# purge the test queue
+client.purge(:test)
+
+# empty the dedup store
+client.deduplication_store.flushdb
+
+# setup our counter
+$completed = 0
+$exceptions_limit = 4
+
+# store the start time
+$start_time = Time.now.to_f
+
+# declare a handler class for message processing
+# handler fails on the first execution attempt, then succeeds
+class Handler < Beetle::Handler
+  # called when the handler receives the message, fails on first two attempts
+  # succeeds on the next and counts up our counter
+  def process
+    logger.info "Attempts: #{message.attempts}, Base Delay: #{message.delay}, Processed at: #{Time.now.to_f - $start_time}"
+    raise "attempt #{message.attempts} for message #{message.data}" if message.attempts < $exceptions_limit
+    logger.info "processing of message #{message.data} succeeded on attempt #{message.attempts}. completed: #{$completed += 1}"
+  end
+
+  # called when handler process raised an exception
+  def error(exception)
+    logger.info "execution failed: #{exception}"
+  end
+end
+
+# register our handler to the message, configure it to our max_attempts limit, we configure a (base) delay of 0.5
+client.register_handler(:test, Handler, exceptions: $exceptions_limit, delay: 1, max_delay: 10)
+# publish test messages
+client.publish(:test, 1) # publish returns the number of servers the message has been sent to
+puts "published 1 test message"
+
+# start the listening loop
+client.listen do
+  # catch INT-signal and stop listening
+  trap("INT") { client.stop_listening }
+  # we're adding a periodic timer to check whether all 10 messages have been processed without exceptions
+  timer = EM.add_periodic_timer(1) do
+    if $completed == 1
+      timer.cancel
+      client.stop_listening
+    end
+  end
+end
+
+puts "Handled #{$completed} messages"
+if $completed != 1
+  raise "Did not handle the correct number of messages"
+end

data/examples/attempts_with_exponential_backoff.rb

@@ -0,0 +1,72 @@
+# attempts_with_exponential_backoff.rb
+# ! check the examples/README.rdoc for information on starting your redis/rabbit !
+#
+# start it with ruby attempts_with_exponential_backoff.rb
+
+require "rubygems"
+require File.expand_path("../lib/beetle", File.dirname(__FILE__))
+
+# set Beetle log level to info, less noisy than debug
+Beetle.config.logger.level = Logger::INFO
+
+# setup client
+client = Beetle::Client.new
+client.register_queue(:test)
+client.register_message(:test)
+
+# purge the test queue
+client.purge(:test)
+
+# empty the dedup store
+client.deduplication_store.flushdb
+
+# setup our counter
+$completed = 0
+$exceptions_limit = 4
+
+# store the start time
+$start_time = Time.now.to_f
+
+# declare a handler class for message processing
+# handler fails on the first $exceptions_limit-1 execution attempts, then succeeds
+class Handler < Beetle::Handler
+
+  # called when the handler receives the message
+  # succeeds on the next and counts up our counter
+  def process
+    logger.info "Attempts: #{message.attempts}, Base Delay: #{message.delay}, Processed at: #{Time.now.to_f - $start_time}"
+    raise "Attempt #{message.attempts} for message #{message.data}" if message.attempts < $exceptions_limit
+    logger.info "Processing of message #{message.data} succeeded on attempt #{message.attempts}. completed: #{$completed += 1}"
+  end
+
+  # called when handler process raised an exception
+  def error(exception)
+    logger.info "Execution failed: #{exception}"
+  end
+end
+
+# register our handler to the message, configure it to our max_attempts limit, we configure a (base) delay of 1
+client.register_handler(:test, Handler, exceptions: $exceptions_limit, delay: 1, max_delay: 10)
+
+# publish test messages
+client.publish(:test, 1) # publish returns the number of servers the message has been sent to
+puts "Published 1 test message"
+
+# start the listening loop
+client.listen do
+  # catch INT-signal and stop listening
+  trap("INT") { client.stop_listening }
+  # we're adding a periodic timer to check whether all messages have been processed without exceptions
+  timer = EM.add_periodic_timer(1) do
+    if $completed == 1
+      timer.cancel
+      client.stop_listening
+    end
+  end
+end
+
+puts "Handled #{$completed} messages"
+if $completed != 1
+  raise "Did not handle the correct number of messages"
+end
+

data/lib/beetle/message.rb

@@ -46,6 +46,8 @@ module Beetle
     attr_reader :timeout
     # how long to wait before retrying the message handler
     attr_reader :delay
+    # maximum wait time for message handler retries (uses exponential backoff)
+    attr_reader :max_delay
     # how many times we should try to run the handler
     attr_reader :attempts_limit
     # how many exceptions we should tolerate before giving up
@@ -71,6 +73,8 @@ module Beetle
       @exceptions_limit = opts[:exceptions] || DEFAULT_EXCEPTION_LIMIT
       @attempts_limit   = @exceptions_limit + 1 if @attempts_limit <= @exceptions_limit
       @store            = opts[:store]
+      max_delay         = opts[:max_delay] || @delay
+      @max_delay        = max_delay if max_delay >= 2*@delay
     end
 
     # extracts various values from the AMQP header properties
@@ -186,7 +190,7 @@ module Beetle
 
     # store delay value in the deduplication store
     def set_delay!
-      @store.set(msg_id, :delay, now + delay)
+      @store.set(msg_id, :delay, now + next_delay(attempts))
     end
 
     # how many times we already tried running the handler
@@ -362,5 +366,13 @@ module Beetle
         @store.del_keys(msg_id)
       end
     end
+
+    def next_delay(n)
+      if max_delay
+        [delay * (2**n), max_delay].min
+      else
+        delay
+      end
+    end
   end
 end

data/lib/beetle/version.rb

@@ -1,3 +1,3 @@
 module Beetle
-  VERSION = "2.0.2"
+  VERSION = "2.1.0"
 end

data/test/beetle/message/settings_test.rb

@@ -0,0 +1,174 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+module Beetle
+  class SettingsTest < Minitest::Test
+    def setup
+      @store = DeduplicationStore.new
+      @store.flushdb
+    end
+
+    test "completed! should store the status 'complete' in the database" do
+      message = Message.new("somequeue", header_with_params, 'foo', :store => @store)
+      assert !message.completed?
+      message.completed!
+      assert message.completed?
+      assert_equal "completed", @store.get(message.msg_id, :status)
+    end
+
+    test "set_delay! should store the current time plus the delay offset in the database" do
+      message = Message.new("somequeue", header_with_params, 'foo', :delay => 2, :store => @store)
+      message.expects(:now).returns(9)
+      message.set_delay!
+      assert_equal "11", @store.get(message.msg_id, :delay)
+      message.expects(:now).returns(12)
+      assert !message.delayed?
+      message.expects(:now).returns(10)
+      assert message.delayed?
+    end
+
+    test "set_delay! should store the current time plus the exponential delay offset in the database" do
+      message = Message.new("somequeue", header_with_params, 'foo', :delay => 3, :max_delay => 30, :store => @store)
+      message.stubs(:now).returns(1)
+
+      [4, 7, 13, 25].each do |exp_delay|
+        message.set_delay!
+        assert_equal exp_delay, @store.get(message.msg_id, :delay).to_i
+        message.increment_execution_attempts!
+      end
+    end
+
+    test "set_delay! should store the current time plus the exponential delay offset in the database up to given max value" do
+      message = Message.new("somequeue", header_with_params, 'foo', :delay => 3, :max_delay => 10, :store => @store)
+      message.stubs(:now).returns(1)
+
+      [4, 7, 11, 11].each do |exp_delay|
+        message.set_delay!
+        assert_equal exp_delay, @store.get(message.msg_id, :delay).to_i
+        message.increment_execution_attempts!
+      end
+    end
+
+    test "set_delay! should store the current time plus the linear delay offset in the database" do
+      delay = 32
+      message = Message.new("somequeue", header_with_params, 'foo', :delay => delay, :store => @store)
+      [3, 5, 6].each do |now_offset|
+        message.stubs(:now).returns(now_offset)
+        message.set_delay!
+        assert_equal @store.get(message.msg_id, :delay).to_i, now_offset + delay
+        message.increment_execution_attempts!
+      end
+    end
+
+    test "set_delay! should use the default delay if the delay hasn't been set on the message instance" do
+      message = Message.new("somequeue", header_with_params, 'foo', :store => @store)
+      message.expects(:now).returns(0)
+      message.set_delay!
+      assert_equal "#{Message::DEFAULT_HANDLER_EXECUTION_ATTEMPTS_DELAY}", @store.get(message.msg_id, :delay)
+      message.expects(:now).returns(message.delay)
+      assert !message.delayed?
+      message.expects(:now).returns(0)
+      assert message.delayed?
+    end
+
+    test "set_timeout! should store the current time plus the number of timeout seconds in the database" do
+      message = Message.new("somequeue", header_with_params, 'foo', :timeout => 1, :store => @store)
+      message.expects(:now).returns(1)
+      message.set_timeout!
+      assert_equal "2", @store.get(message.msg_id, :timeout)
+      message.expects(:now).returns(2)
+      assert !message.timed_out?
+      message.expects(:now).returns(3)
+      assert message.timed_out?
+    end
+
+    test "set_timeout! should use the default timeout if the timeout hasn't been set on the message instance" do
+      message = Message.new("somequeue", header_with_params, 'foo', :store => @store)
+      message.expects(:now).returns(0)
+      message.set_timeout!
+      assert_equal "#{Message::DEFAULT_HANDLER_TIMEOUT}", @store.get(message.msg_id, :timeout)
+      message.expects(:now).returns(message.timeout)
+      assert !message.timed_out?
+      message.expects(:now).returns(Message::DEFAULT_HANDLER_TIMEOUT + 1)
+      assert message.timed_out?
+    end
+
+    test "incrementing execution attempts should increment by 1" do
+      message = Message.new("somequeue", header_with_params, 'foo', :store => @store)
+      assert_equal 1, message.increment_execution_attempts!
+      assert_equal 2, message.increment_execution_attempts!
+      assert_equal 3, message.increment_execution_attempts!
+    end
+
+    test "accessing execution attempts should return the number of execution attempts made so far" do
+      message = Message.new("somequeue", header_with_params, 'foo', :store => @store)
+      assert_equal 0, message.attempts
+      message.increment_execution_attempts!
+      assert_equal 1, message.attempts
+      message.increment_execution_attempts!
+      assert_equal 2, message.attempts
+      message.increment_execution_attempts!
+      assert_equal 3, message.attempts
+    end
+
+    test "accessing execution attempts should return 0 if none were made" do
+      message = Message.new("somequeue", header_with_params, 'foo', :store => @store)
+      assert_equal 0, message.attempts
+    end
+
+
+    test "attempts limit should be set exception limit + 1 iff the configured attempts limit is equal to or smaller than the exceptions limit" do
+      message = Message.new("somequeue", header_with_params, 'foo', :exceptions => 1, :store => @store)
+      assert_equal 2, message.attempts_limit
+      assert_equal 1, message.exceptions_limit
+      message = Message.new("somequeue", header_with_params, 'foo', :exceptions => 2, :store => @store)
+      assert_equal 3, message.attempts_limit
+      assert_equal 2, message.exceptions_limit
+      message = Message.new("somequeue", header_with_params, 'foo', :attempts => 5, :exceptions => 2, :store => @store)
+      assert_equal 5, message.attempts_limit
+      assert_equal 2, message.exceptions_limit
+    end
+
+    test "attempts limit should be reached after incrementing the attempt limit counter 'attempts limit' times" do
+      message = Message.new("somequeue", header_with_params, 'foo', :attempts =>2, :store => @store)
+      assert !message.attempts_limit_reached?
+      message.increment_execution_attempts!
+      assert !message.attempts_limit_reached?
+      message.increment_execution_attempts!
+      assert message.attempts_limit_reached?
+      message.increment_execution_attempts!
+      assert message.attempts_limit_reached?
+    end
+
+    test "incrementing exception counts should increment by 1" do
+      message = Message.new("somequeue", header_with_params, 'foo', :store => @store)
+      assert_equal 1, message.increment_exception_count!
+      assert_equal 2, message.increment_exception_count!
+      assert_equal 3, message.increment_exception_count!
+    end
+
+    test "default exceptions limit should be reached after incrementing the attempt limit counter 1 time" do
+      message = Message.new("somequeue", header_with_params, 'foo', :store => @store)
+      assert !message.exceptions_limit_reached?
+      message.increment_exception_count!
+      assert message.exceptions_limit_reached?
+    end
+
+    test "exceptions limit should be reached after incrementing the attempt limit counter 'exceptions limit + 1' times" do
+      message = Message.new("somequeue", header_with_params, 'foo', :exceptions => 1, :store => @store)
+      assert !message.exceptions_limit_reached?
+      message.increment_exception_count!
+      assert !message.exceptions_limit_reached?
+      message.increment_exception_count!
+      assert message.exceptions_limit_reached?
+      message.increment_exception_count!
+      assert message.exceptions_limit_reached?
+    end
+
+    test "failure to aquire a mutex should delete it from the database" do
+      message = Message.new("somequeue", header_with_params, 'foo', :store => @store)
+      assert message.aquire_mutex!
+      assert !message.aquire_mutex!
+      assert !@store.exists(message.msg_id, :mutex)
+    end
+  end
+end

data/test/beetle/message_test.rb

@@ -677,159 +677,6 @@ module Beetle
     end
   end
 
-  class SettingsTest < Minitest::Test
-    def setup
-      @store = DeduplicationStore.new
-      @store.flushdb
-    end
-
-    test "completed! should store the status 'complete' in the database" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :store => @store)
-      assert !message.completed?
-      message.completed!
-      assert message.completed?
-      assert_equal "completed", @store.get(message.msg_id, :status)
-    end
-
-    test "set_delay! should store the current time plus the number of delayed seconds in the database" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :delay => 1, :store => @store)
-      message.expects(:now).returns(1)
-      message.set_delay!
-      assert_equal "2", @store.get(message.msg_id, :delay)
-      message.expects(:now).returns(2)
-      assert !message.delayed?
-      message.expects(:now).returns(0)
-      assert message.delayed?
-    end
-
-    test "set_delay! should use the default delay if the delay hasn't been set on the message instance" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :store => @store)
-      message.expects(:now).returns(0)
-      message.set_delay!
-      assert_equal "#{Message::DEFAULT_HANDLER_EXECUTION_ATTEMPTS_DELAY}", @store.get(message.msg_id, :delay)
-      message.expects(:now).returns(message.delay)
-      assert !message.delayed?
-      message.expects(:now).returns(0)
-      assert message.delayed?
-    end
-
-    test "set_timeout! should store the current time plus the number of timeout seconds in the database" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :timeout => 1, :store => @store)
-      message.expects(:now).returns(1)
-      message.set_timeout!
-      assert_equal "2", @store.get(message.msg_id, :timeout)
-      message.expects(:now).returns(2)
-      assert !message.timed_out?
-      message.expects(:now).returns(3)
-      assert message.timed_out?
-    end
-
-    test "set_timeout! should use the default timeout if the timeout hasn't been set on the message instance" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :store => @store)
-      message.expects(:now).returns(0)
-      message.set_timeout!
-      assert_equal "#{Message::DEFAULT_HANDLER_TIMEOUT}", @store.get(message.msg_id, :timeout)
-      message.expects(:now).returns(message.timeout)
-      assert !message.timed_out?
-      message.expects(:now).returns(Message::DEFAULT_HANDLER_TIMEOUT+1)
-      assert message.timed_out?
-    end
-
-    test "incrementing execution attempts should increment by 1" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :store => @store)
-      assert_equal 1, message.increment_execution_attempts!
-      assert_equal 2, message.increment_execution_attempts!
-      assert_equal 3, message.increment_execution_attempts!
-    end
-
-    test "accessing execution attempts should return the number of execution attempts made so far" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :store => @store)
-      assert_equal 0, message.attempts
-      message.increment_execution_attempts!
-      assert_equal 1, message.attempts
-      message.increment_execution_attempts!
-      assert_equal 2, message.attempts
-      message.increment_execution_attempts!
-      assert_equal 3, message.attempts
-    end
-
-    test "accessing execution attempts should return 0 if none were made" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :store => @store)
-      assert_equal 0, message.attempts
-    end
-
-
-    test "attempts limit should be set exception limit + 1 iff the configured attempts limit is equal to or smaller than the exceptions limit" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :exceptions => 1, :store => @store)
-      assert_equal 2, message.attempts_limit
-      assert_equal 1, message.exceptions_limit
-      message = Message.new("somequeue", header, 'foo', :exceptions => 2, :store => @store)
-      assert_equal 3, message.attempts_limit
-      assert_equal 2, message.exceptions_limit
-      message = Message.new("somequeue", header, 'foo', :attempts => 5, :exceptions => 2, :store => @store)
-      assert_equal 5, message.attempts_limit
-      assert_equal 2, message.exceptions_limit
-    end
-
-    test "attempts limit should be reached after incrementing the attempt limit counter 'attempts limit' times" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :attempts =>2, :store => @store)
-      assert !message.attempts_limit_reached?
-      message.increment_execution_attempts!
-      assert !message.attempts_limit_reached?
-      message.increment_execution_attempts!
-      assert message.attempts_limit_reached?
-      message.increment_execution_attempts!
-      assert message.attempts_limit_reached?
-    end
-
-    test "incrementing exception counts should increment by 1" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :store => @store)
-      assert_equal 1, message.increment_exception_count!
-      assert_equal 2, message.increment_exception_count!
-      assert_equal 3, message.increment_exception_count!
-    end
-
-    test "default exceptions limit should be reached after incrementing the attempt limit counter 1 time" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :store => @store)
-      assert !message.exceptions_limit_reached?
-      message.increment_exception_count!
-      assert message.exceptions_limit_reached?
-    end
-
-    test "exceptions limit should be reached after incrementing the attempt limit counter 'exceptions limit + 1' times" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :exceptions => 1, :store => @store)
-      assert !message.exceptions_limit_reached?
-      message.increment_exception_count!
-      assert !message.exceptions_limit_reached?
-      message.increment_exception_count!
-      assert message.exceptions_limit_reached?
-      message.increment_exception_count!
-      assert message.exceptions_limit_reached?
-    end
-
-    test "failure to aquire a mutex should delete it from the database" do
-      header = header_with_params({})
-      message = Message.new("somequeue", header, 'foo', :store => @store)
-      assert message.aquire_mutex!
-      assert !message.aquire_mutex!
-      assert !@store.exists(message.msg_id, :mutex)
-    end
-  end
-
-
   class RoutingKeyTest < Minitest::Test
     test "returns the routing key" do
       header = header_with_params({})

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: beetle
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Stefan Kaes
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-25 00:00:00.000000000 Z
+date: 2017-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uuid4r
@@ -314,6 +314,8 @@ files:
 - beetle.gemspec
 - examples/README.rdoc
 - examples/attempts.rb
+- examples/attempts_with_dead_letter_and_exponential_backoff.rb
+- examples/attempts_with_exponential_backoff.rb
 - examples/consume_many_messages_and_shutdown_randomly.rb
 - examples/handler_class.rb
 - examples/handling_exceptions.rb
@@ -361,6 +363,7 @@ files:
 - test/beetle/dead_lettering_test.rb
 - test/beetle/deduplication_store_test.rb
 - test/beetle/handler_test.rb
+- test/beetle/message/settings_test.rb
 - test/beetle/message_test.rb
 - test/beetle/publisher_test.rb
 - test/beetle/r_c_test.rb
@@ -389,7 +392,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.7
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 3
 summary: High Availability AMQP Messaging with Redundant Queues
@@ -402,6 +405,7 @@ test_files:
 - test/beetle/dead_lettering_test.rb
 - test/beetle/deduplication_store_test.rb
 - test/beetle/handler_test.rb
+- test/beetle/message/settings_test.rb
 - test/beetle/message_test.rb
 - test/beetle/publisher_test.rb
 - test/beetle/r_c_test.rb