backburner-allq 1.0.34 → 1.0.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58292818366f9651b49592fa7b035f4da9ab7e3682566346059033639bed4c5b
-  data.tar.gz: 2124c21a3f66a73373f68550dc9179400c00cf75431de33fc58f1123ed9eaa2b
+  metadata.gz: bb5591a73384ecba34a10ba9fb78d56c4c5d8326745f610f240080fefbd28856
+  data.tar.gz: c1c96729b87cd70c616085a8ef65f85da3f3697ac8570fb03625db41b82571cd
 SHA512:
-  metadata.gz: 5a04ae40e40defa45851012d1d4a626b113b01b1ab34d511835eca6ebcf03625df85e8620edd52c3210bd9b20f997174c1e6176a1463c8463d0c2ed7df343c31
-  data.tar.gz: f2545dac249dec91798fc81f4fae108aa8928ca6aceffe72345b5388ba5d8757d3ab4a2f6f558add05c69f10217cc98c002c84158b3875e89aef7cd119f5773a
+  metadata.gz: ab1b474fef10f4e176ffdfccbd6941c1dccb7039be183a05e065f44f6bc314bbf31785a1f8baefb760af5a806bd17a378f4ca23ab077dfec72f2c0845556e919
+  data.tar.gz: 340afa1032f1eedd5b5f441cbfe9343b6ed23d2fcdb0a09400ac365ae882bebe957a10e4e53887f8d35485d6a51cc4a0cd9de6ecf3628ece8cdd82231013c29a

data/deploy.sh

@@ -1,3 +1,3 @@
 echo "Did you update the version?"
 gem build backburner-allq.gemspec
-gem push backburner-allq-1.0.34.gem
+gem push backburner-allq-1.0.37.gem

data/lib/backburner/allq_wrapper.rb

@@ -219,9 +219,6 @@ module Backburner
 
       begin
         Timeout.timeout(10) do
-          if body && body.to_s.include?('["default"]')
-          end
-
           if is_parent
             new_job = build_new_parent_job(body, options)
             result = @client.parent_job_post(new_job)
@@ -232,18 +229,18 @@ module Backburner
           raise 'PUT returned nil' if result.nil? || result.to_s == ''
         end
       rescue Timeout::Error
-        puts('ALLQ_PUT_TIMEOUT')
+        puts('ALLQ PUT timeout, retrying...')
         sleep(5)
         retry_count += 1
         retry if retry_count < 4
-        raise 'Failed to put on allq, we are investigating the problem, please try again'
+        raise "Failed to put on allq, we are investigating the problem, please try again -> #{body}"
       rescue StandardError => e
-        puts('Failed to ALLQ PUT')
+        puts('Failed to ALLQ PUT, retrying...')
         puts(e)
         retry_count += 1
         sleep(5)
         retry if retry_count < 4
-        raise 'Failed to put on allq, we are investigating the problem, please try again'
+        raise "Failed to put on allq, we are investigating the problem, please try again: #{body}"
       end
       result
     end
@@ -257,15 +254,21 @@ module Backburner
       raw_stats = @admin.stats_get
       final_stats = {}
 
-      raw_stats.each do |agg|
+      raw_stats.each_with_index do |agg, i|
         agg.stats.each do |tube_ref|
           name = tube_ref.tube
-          final_stats[name] = {} unless final_stats[name]
+          final_stats[name] = {'avg' => 0, 'tps' => 0} unless final_stats[name]
           final_stats[name]['ready'] = final_stats[name]['ready'].to_i + tube_ref.ready.to_i
           final_stats[name]['reserved'] = final_stats[name]['reserved'].to_i + tube_ref.reserved.to_i
           final_stats[name]['delayed'] = final_stats[name]['delayed'].to_i + tube_ref.delayed.to_i
           final_stats[name]['buried'] = final_stats[name]['buried'].to_i + tube_ref.buried.to_i
           final_stats[name]['parents'] = final_stats[name]['parents'].to_i + tube_ref.parents.to_i
+
+
+          # Fancy math to calculate averages on the fly
+          # https://math.stackexchange.com/questions/106313/regular-average-calculated-accumulatively
+          final_stats[name]['avg'] += (tube_ref.avg.to_f - final_stats[name]['avg'].to_f)/(i+1).to_f
+          final_stats[name]['tps'] += (tube_ref.tps.to_f - final_stats[name]['tps'].to_f)/(i+1).to_f
         end
       end
       final_stats

data/lib/backburner/version.rb

@@ -1,3 +1,3 @@
 module Backburner
-  VERSION = "1.0.34"
+  VERSION = "1.0.37"
 end

data/lib/backburner/worker.rb

@@ -23,8 +23,13 @@ module Backburner
     # @example
     #   Backburner::Worker.enqueue NewsletterSender, [self.id, user.id], :ttr => 1000
     #
-    def self.enqueue(job_class, args=[], opts={})
-      opts[:shard_key] = opts[:shard_key].nil? ? "X" : opts[:shard_key].to_s
+    def self.enqueue(job_class, args = [], opts = {})
+      # Invoke Procs if they are sent
+      opts.each_key do |k|
+        opts[k] = opts[k].call job_class, args if opts[k].instance_of?(Proc)
+      end
+
+      opts[:shard_key] = opts[:shard_key].nil? ? 'X' : opts[:shard_key].to_s
       pri   = resolve_priority(opts[:pri] || job_class)
       delay = [0, opts[:delay].to_i].max
       ttr   = resolve_respond_timeout(opts[:ttr] || job_class)
@@ -77,7 +82,7 @@ module Backburner
     #
     # @example
     #   Worker.new(['test.job'])
-    def initialize(tube_names=nil)
+    def initialize(tube_names = nil)
       @connection = new_connection
       @tube_names = self.process_tube_names(tube_names)
       register_signal_handlers!

data/test/performable_test.rb

@@ -29,15 +29,15 @@ describe "Backburner::Performable module" do
 
   describe "for async instance method" do
     it "should invoke worker enqueue" do
-      Backburner::Worker.expects(:enqueue).with(PerformableTestObj, [56, :foo, true, false], has_entries(:pri => 5000, :queue => "foo"))
-      PerformableTestObj.new.async(:pri => 5000, :queue => "foo").foo(true, false)
+      Backburner::Worker.expects(:enqueue).with(PerformableTestObj, [56, :foo, true, false], has_entries(:pri => 5000, :queue => "foo", :shard_key => "abc"))
+      PerformableTestObj.new.async(:pri => 5000, :queue => "foo", :shard_key => "abc").foo(true, false)
     end
   end # async instance
 
   describe "for async class method" do
     it "should invoke worker enqueue" do
-      Backburner::Worker.expects(:enqueue).with(PerformableTestObj, [nil, :bar, true, false], has_entries(:pri => 5000, :queue => "foo"))
-      PerformableTestObj.async(:pri => 5000, :queue => "foo").bar(true, false)
+      Backburner::Worker.expects(:enqueue).with(PerformableTestObj, [nil, :bar, true, false], has_entries(:pri => 5000, :queue => "foo", :shard_key => "abc"))
+      PerformableTestObj.async(:pri => 5000, :queue => "foo", :shard_key => "abc").bar(true, false)
     end
   end # async class
 
@@ -53,16 +53,16 @@ describe "Backburner::Performable module" do
 
   describe "for handle_asynchronously class method" do
     it "should automagically asynchronously proxy calls to the method" do
-      Backburner::Performable.handle_asynchronously(AutomagicTestObj, :qux, :pri => 5000, :queue => "qux")
+      Backburner::Performable.handle_asynchronously(AutomagicTestObj, :qux, :pri => 5000, :queue => "qux", :shard_key => "abc")
 
-      Backburner::Worker.expects(:enqueue).with(AutomagicTestObj, [56, :qux_without_async, true, false], has_entries(:pri => 5000, :queue => "qux"))
+      Backburner::Worker.expects(:enqueue).with(AutomagicTestObj, [56, :qux_without_async, true, false], has_entries(:pri => 5000, :queue => "qux", :shard_key => "abc"))
       AutomagicTestObj.new.qux(true, false)
     end
 
     it "should work for class methods, too" do
-      Backburner::Performable.handle_static_asynchronously(AutomagicTestObj, :garply, :pri => 5000, :queue => "garply")
+      Backburner::Performable.handle_static_asynchronously(AutomagicTestObj, :garply, :pri => 5000, :queue => "garply", :shard_key => "abc")
 
-      Backburner::Worker.expects(:enqueue).with(AutomagicTestObj, [nil, :garply_without_async, true, false], has_entries(:pri => 5000, :queue => "garply"))
+      Backburner::Worker.expects(:enqueue).with(AutomagicTestObj, [nil, :garply_without_async, true, false], has_entries(:pri => 5000, :queue => "garply", :shard_key => "abc"))
       AutomagicTestObj.garply(true, false)
     end
 
@@ -74,14 +74,14 @@ describe "Backburner::Performable module" do
     end
 
     it "should be available for instance methods on any class that includes the Performable module" do
-      AsyncInstanceMethodsTestObj.handle_asynchronously :foo, pri: 5000, queue: 'qux'
-      Backburner::Worker.expects(:enqueue).with(AsyncInstanceMethodsTestObj, [56, :foo_without_async, true, false], has_entries(:pri => 5000, :queue => "qux"))
+      AsyncInstanceMethodsTestObj.handle_asynchronously :foo, pri: 5000, queue: 'qux', shard_key: "abc"
+      Backburner::Worker.expects(:enqueue).with(AsyncInstanceMethodsTestObj, [56, :foo_without_async, true, false], has_entries(:pri => 5000, :queue => "qux", :shard_key => "abc"))
       AsyncInstanceMethodsTestObj.new.foo(true, false)
     end
 
     it "should be available for class methods on any class that includes the Performable module" do
-      AsyncStaticMethodsTestObj.handle_static_asynchronously :bar, pri: 5000, queue: 'garply'
-      Backburner::Worker.expects(:enqueue).with(AsyncStaticMethodsTestObj, [nil, :bar_without_async, true, false], has_entries(:pri => 5000, :queue => "garply"))
+      AsyncStaticMethodsTestObj.handle_static_asynchronously :bar, pri: 5000, queue: 'garply', shard_key: "abc"
+      Backburner::Worker.expects(:enqueue).with(AsyncStaticMethodsTestObj, [nil, :bar_without_async, true, false], has_entries(:pri => 5000, :queue => "garply",:shard_key => "abc"))
       AsyncStaticMethodsTestObj.bar(true, false)
     end
   end

data/test/test_helper.rb

@@ -12,7 +12,7 @@ require File.expand_path('../helpers/templogger', __FILE__)
 
 # Configure Backburner
 Backburner.configure do |config|
-  config.beanstalk_url = "beanstalk://127.0.0.1"
+  config.allq_url = "allq://127.0.0.1:8091"
   config.tube_namespace = "demo.test"
 end
 
@@ -88,7 +88,7 @@ class MiniTest::Spec
   end
 
   def beanstalk_connection
-    Backburner::Connection.new(Backburner.configuration.beanstalk_url)
+    Backburner::Connection.new(Backburner.configuration.allq_url)
   end
 
   # pop_one_job(tube_name)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: backburner-allq
 version: !ruby/object:Gem::Version
-  version: 1.0.34
+  version: 1.0.37
 platform: ruby
 authors:
 - Jason Malcolm
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-21 00:00:00.000000000 Z
+date: 2022-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: allq_rest