queue-bus 0.9.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f35ec72b2a6256350aabd9f2f6fa6591a1b625f404a3013ea73fb24876fb9e3
-  data.tar.gz: 00eb73580e6160d3932f43110c182832163ab5d3f9db34d44980b831cf4f7fdc
+  metadata.gz: 511b1d30315adbfe76e6fa303aaba3158d56d39bea93355a0d28c18c8b0578cb
+  data.tar.gz: ba55e76505d56b98a416ff60c64c2c384734cd18af332768f6631e490caf4ed5
 SHA512:
-  metadata.gz: 887ddce8443a1c17bc4db578a8d6b51d1a81906287db94ccd1f47681f30032cf485e1ed30e1a0feb56cc05b17162fae8f2ce28d07bad4b943a6dce7b40302c40
-  data.tar.gz: 34394be52205690b867bc2402563a9e970fa899250009481ed460f4b4909b8b8f3782bb4c5915d33eaccf6bebf2eebcedf8961628e539af6cde08646517f792f
+  metadata.gz: b0f0d47e2be417d33b1f396043fd604ff936d9a1f258550b725673b4a9649d6e6153edaca77a064996ab3f0c43b59849ab04a66c49f3afb4f2d058a7c788f1e3
+  data.tar.gz: 941c73b6e35945a181651bb03746fff2022947fe89102daebd76f72e211150dfd2382ebd41bbd35857b1c5b9a2f099389b25392ba8e0c210615b624ef5898fb0

data/CHANGELOG.md

@@ -6,6 +6,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.13.0]
+
+### Added
+
+- Adds `Dispatch#on_heartbeat` which is a helper function for specifying heartbeat subscriptions.
+
+## [0.12.0]
+
+### Changed
+- Pipelines fetching all queue subscriptions when using `QueueBus::Application.all`
+
+## [0.11.0]
+
+### Added
+
+- Adds `QueueBus.in_context` method. Useful when working with a multithreaded environment to add a description for all events published within this scope.
+
+## [0.10.0]
+
+### Added
+- Ability to unsubscribe from specific queues in an application (`Application#unsubscribe_queue`).
+- `rake queuebus:unsubscribe` can now take two parameters to unsubscribe from specific queues, e.g. `rake queuebus:unsubscribe[my_app_key, my_queue_name]`.
+
 ## [0.9.1]
 
 ### Added

data/README.mdown

@@ -63,6 +63,16 @@ QueueBus.dispatch("app_b") do
   subscribe "my_key", { "user_id" => :present, "page" => "homepage"} do
     Mixpanel.homepage_action!(attributes["action"])
   end
+
+  # You may also declare a subscription to heartbeat events. This is a helper function
+  # that works along with subscribe to make scheduling regular events easier.
+  #
+  #   minute_interval: Executes every n minutes
+  #   hour_interval:   Executes every n hours
+  #   minute:          Executes on this minute
+  #   hour:            Executes on this hour
+  on_heartbeat "my_heartbeat_event", minute_interval: 5 do |attributes|
+  end
 end
 ```
 
@@ -141,13 +151,16 @@ event to the appropriate code block.
 You can also say `QueueBus.local_mode = :suppress` to turn off publishing altogether.
 This can be helpful inside some sort of migration, for example.
 
-#### Thread Safe Local Modes
+#### Thread Safe Options
 
 **!! This is important if you are using workers that utilize multiple threads, such as Sidekiq !!**
 
 The above setting is global to the ruby process and modifying it will impact all threads that are
 currently using QueueBus. If you want to isolate a thread or block of code from QueueBus, you can
-use the method `with_local_mode`:
+use the methods `with_local_mode` or `in_context`:
+
+
+With local mode
 
 ```ruby
 QueueBus.with_local_mode(:suppress) do
@@ -155,7 +168,16 @@ QueueBus.with_local_mode(:suppress) do
 end
 ```
 
-The previous value of `local_mode` will be restored after the block exits.
+In context
+
+```ruby
+QueueBus.in_context('some_context') do
+  # Context attribute will be set for all events published within this scope.
+end
+```
+
+
+The previous values will be restored after the block exits.
 
 ### TODO
 

data/lib/queue-bus.rb

@@ -43,7 +43,8 @@ module QueueBus
                    :hostname=, :hostname,
                    :adapter=, :adapter, :has_adapter?,
                    :incoming_queue=, :incoming_queue,
-                   :redis, :worker_middleware_stack
+                   :redis, :worker_middleware_stack,
+                   :context=, :context, :in_context
 
     def_delegators :_dispatchers, :dispatch, :dispatchers, :dispatcher_by_key, :dispatcher_execute
 

data/lib/queue_bus/application.rb

@@ -7,7 +7,22 @@ module QueueBus
     class << self
       def all
         # note the names arent the same as we started with
-        ::QueueBus.redis { |redis| redis.smembers(app_list_key).collect { |val| new(val) } }
+        ::QueueBus.redis do |redis|
+          app_keys = redis.smembers(app_list_key)
+          apps = app_keys.collect { |val| new(val) }
+
+          hashes = redis.pipelined do
+            apps.each do |app|
+              redis.hgetall(app.redis_key)
+            end
+          end
+
+          apps.zip(hashes).each do |app, hash|
+            app._hydrate_redis_hash(hash)
+          end
+
+          apps
+        end
       end
     end
 
@@ -32,6 +47,7 @@ module QueueBus
 
       ::QueueBus.redis do |redis|
         redis_hash = subscription_list.to_redis
+
         redis_hash.each do |key, hash|
           redis.hset(temp_key, key, QueueBus::Util.encode(hash))
         end
@@ -46,8 +62,17 @@ module QueueBus
       true
     end
 
+    def unsubscribe_queue(queue)
+      # Filters out all subscriptions that match the supplied queue name.
+      ::QueueBus.redis do |redis|
+        read_redis_hash.each do |key, hash_details|
+          redis.hdel(redis_key, key) if queue == hash_details["queue_name"]
+        end
+      end
+    end
+
     def unsubscribe
-      # TODO: clean up known queues?
+      # Remove everything.
       ::QueueBus.redis do |redis|
         redis.srem(self.class.app_list_key, app_key)
         redis.del(redis_key)
@@ -80,6 +105,10 @@ module QueueBus
       out
     end
 
+    def _hydrate_redis_hash(hash)
+      @raw_redis_hash = hash
+    end
+
     protected
 
     def self.normalize(val)
@@ -104,16 +133,24 @@ module QueueBus
 
     def read_redis_hash
       out = {}
-      ::QueueBus.redis do |redis|
-        redis.hgetall(redis_key).each do |key, val|
-          begin
-            out[key] = ::QueueBus::Util.decode(val)
-          rescue ::QueueBus::Util::DecodeException
-            out[key] = val
-          end
+      raw_redis_hash.each do |key, val|
+        begin
+          out[key] = ::QueueBus::Util.decode(val)
+        rescue ::QueueBus::Util::DecodeException
+          out[key] = val
         end
       end
       out
     end
+
+    private
+
+    def raw_redis_hash
+      return @raw_redis_hash if @raw_redis_hash
+
+      ::QueueBus.redis do |redis|
+        redis.hgetall(redis_key)
+      end
+    end
   end
 end

data/lib/queue_bus/config.rb

@@ -9,7 +9,7 @@ module QueueBus
     attr_accessor :default_queue, :hostname, :incoming_queue, :logger
 
     attr_reader :worker_middleware_stack
-    attr_writer :local_mode
+    attr_writer :local_mode, :context
 
     def initialize
       @worker_middleware_stack = QueueBus::Middleware::Stack.new
@@ -24,6 +24,7 @@ module QueueBus
     Wrap = Struct.new(:value)
 
     LOCAL_MODE_VAR = :queue_bus_local_mode
+    CONTEXT_VAR = :queue_bus_context
 
     # Returns the current local mode of QueueBus
     def local_mode
@@ -34,6 +35,15 @@ module QueueBus
       end
     end
 
+    # Returns the current context of QueueBus
+    def context
+      if Thread.current.thread_variable_get(CONTEXT_VAR).is_a?(Wrap)
+        Thread.current.thread_variable_get(CONTEXT_VAR).value
+      else
+        @context
+      end
+    end
+
     # Overrides the current local mode for the duration of a block. This is a threadsafe
     # implementation. After, the global setting will be resumed.
     #
@@ -46,6 +56,17 @@ module QueueBus
       Thread.current.thread_variable_set(LOCAL_MODE_VAR, previous)
     end
 
+    # Overrides the current bus context (if any) for the duration of a block, adding a
+    # `bus_context` attribute set to this value for all events published in this scope. 
+    # This is a threadsafe implementation. After, the global setting will be resumed.
+    def in_context(context)
+      previous = Thread.current.thread_variable_get(CONTEXT_VAR)
+      Thread.current.thread_variable_set(CONTEXT_VAR, Wrap.new(context))
+      yield if block_given?
+    ensure
+      Thread.current.thread_variable_set(CONTEXT_VAR, previous)
+    end
+
     def adapter=(val)
       raise "Adapter already set to #{@adapter_instance.class.name}" if has_adapter?
 

data/lib/queue_bus/dispatch.rb

@@ -16,6 +16,39 @@ module QueueBus
       @subscriptions.size
     end
 
+    def on_heartbeat(key, minute: nil, hour: nil, minute_interval: nil, hour_interval: nil, &block) # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/ParameterLists, Metrics/CyclomaticComplexity, Metrics/AbcSize
+      if minute_interval && !minute_interval.positive?
+        raise ArgumentError, 'minute_interval must be a positive integer'
+      end
+
+      if hour_interval && !hour_interval.positive?
+        raise ArgumentError, 'hour_interval must be a positive integer'
+      end
+
+      matcher = { bus_event_type: :heartbeat_minutes }
+
+      if minute
+        raise ArgumentError, 'minute must be a positive integer' unless minute.positive?
+
+        matcher['minute'] = minute
+      end
+
+      if hour
+        raise ArgumentError, 'hour must be a positive integer' unless hour.positive?
+
+        matcher['hour'] = hour
+      end
+
+      subscribe(key, matcher) do |event|
+        if (minute_interval.nil? || (event['minute'] % minute_interval).zero?) &&
+           (hour_interval.nil? || (event['hour'] % hour_interval).zero?)
+
+          # Yield the block passed in.
+          block.call
+        end
+      end
+    end
+
     def subscribe(key, matcher_hash = nil, &block)
       dispatch_event('default', key, matcher_hash, block)
     end

data/lib/queue_bus/publishing.rb

@@ -30,6 +30,7 @@ module QueueBus
       bus_attr = { 'bus_published_at' => Time.now.to_i, 'bus_event_type' => event_type }
       bus_attr['bus_id']           = "#{Time.now.to_i}-#{generate_uuid}"
       bus_attr['bus_app_hostname'] = ::QueueBus.hostname
+      bus_attr['bus_context'] = ::QueueBus.context unless ::QueueBus.context.nil?
       if defined?(I18n) && I18n.respond_to?(:locale) && I18n.locale
         bus_attr['bus_locale']       = I18n.locale.to_s
       end

data/lib/queue_bus/task_manager.rb

@@ -24,6 +24,13 @@ module QueueBus
       count
     end
 
+    def unsubscribe_queue!(app_key, queue)
+      log "Unsubcribing #{queue} from #{app_key}"
+      app = ::QueueBus::Application.new(app_key)
+      app.unsubscribe_queue(queue)
+      log "  ...done"
+    end
+
     def unsubscribe!
       count = 0
       ::QueueBus.dispatchers.each do |dispatcher|

data/lib/queue_bus/tasks.rb

@@ -12,11 +12,19 @@ namespace :queuebus do
     raise 'No subscriptions created' if count == 0
   end
 
-  desc 'Unsubscribes this application from QueueBus events'
-  task unsubscribe: [:preload] do
+  desc "Unsubscribes this application from QueueBus events"
+  task :unsubscribe, [:app_key, :queue] => [ :preload ] do |task, args|
+    app_key = args[:app_key]
+    queue = args[:queue]
     manager = ::QueueBus::TaskManager.new(true)
-    count = manager.unsubscribe!
-    puts 'No subscriptions unsubscribed' if count == 0
+
+    if app_key && queue
+      manager.unsubscribe_queue!(app_key, queue)
+    else
+      manager = ::QueueBus::TaskManager.new(true)
+      count = manager.unsubscribe!
+      puts "No subscriptions unsubscribed" if count == 0
+    end
   end
 
   desc 'List QueueBus queues that need worked'

data/lib/queue_bus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module QueueBus
-  VERSION = '0.9.1'
+  VERSION = '0.13.0'
 end

data/spec/application_spec.rb

@@ -102,16 +102,58 @@ module QueueBus
       end
     end
 
-    describe '#unsubscribe' do
-      it 'should remove items' do
-        QueueBus.redis { |redis| redis.sadd('bus_apps', 'myapp') }
-        QueueBus.redis { |redis| redis.sadd('bus_apps', 'other') }
-        QueueBus.redis { |redis| redis.hset('bus_app:myapp', 'event_one', 'myapp_default') }
+    describe "#unsubscribe" do
+      context "when a queue is not specified" do
+        it "removes all subscriptions" do
+          myapp_list = SubscriptionList.new
+          other_list = SubscriptionList.new
+
+          subscription_1 = Subscription.new("myapp_default", "key1", "MyClass1", {"bus_event_type" => "event_one"})
+          subscription_2 = Subscription.new("myapp_default", "key2", "MyClass2", {"bus_event_type" => "event_two"})
+          subscription_3 = Subscription.new("myapp_other_queue", "key1", "MyClass1", {"bus_event_type" => "event_one"})
+
+          myapp_list.add(subscription_1)
+          myapp_list.add(subscription_2)
+          other_list.add(subscription_3)
+
+          Application.new("myapp").subscribe(myapp_list)
+          Application.new("other").subscribe(other_list)
+
+          expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({
+            "key1" => "{\"queue_name\":\"myapp_default\",\"key\":\"key1\",\"class\":\"MyClass1\",\"matcher\":{\"bus_event_type\":\"event_one\"}}",
+            "key2" => "{\"queue_name\":\"myapp_default\",\"key\":\"key2\",\"class\":\"MyClass2\",\"matcher\":{\"bus_event_type\":\"event_two\"}}"
+          })
+
+          Application.new("myapp").unsubscribe
+
+          expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to eq(["other"])
+          expect(QueueBus.redis { |redis| redis.hlen("bus_app:myapp") }).to eq(0)
+          expect(QueueBus.redis { |redis| redis.hlen("bus_app:other") }).to eq(1)
+        end
+      end
 
-        Application.new('myapp').unsubscribe
+      context "when a queue is specified" do
+        it "removes only that key" do
+          list = SubscriptionList.new
 
-        expect(QueueBus.redis { |redis| redis.smembers('bus_apps') }).to eq(['other'])
-        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
+          subscription_1 = Subscription.new("myapp_default", "key1", "MyClass1", {"bus_event_type" => "event_one"})
+          subscription_2 = Subscription.new("myapp_other_queue", "key2", "MyClass2", {"bus_event_type" => "event_two"})
+
+          list.add(subscription_1)
+          list.add(subscription_2)
+
+          Application.new("myapp").subscribe(list)
+
+          expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({
+            "key1" => "{\"queue_name\":\"myapp_default\",\"key\":\"key1\",\"class\":\"MyClass1\",\"matcher\":{\"bus_event_type\":\"event_one\"}}",
+            "key2" => "{\"queue_name\":\"myapp_other_queue\",\"key\":\"key2\",\"class\":\"MyClass2\",\"matcher\":{\"bus_event_type\":\"event_two\"}}"
+          })
+
+          Application.new("myapp").unsubscribe_queue("myapp_default")
+
+          expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to eq(["myapp"])
+          expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({"key2" => "{\"queue_name\":\"myapp_other_queue\",\"key\":\"key2\",\"class\":\"MyClass2\",\"matcher\":{\"bus_event_type\":\"event_two\"}}"})
+        end
       end
     end
 

data/spec/config_spec.rb

@@ -61,6 +61,41 @@ describe 'QueueBus config' do
     end
   end
 
+  describe '#in_context' do
+    it 'sets the context on the thread' do
+      QueueBus.in_context(:batch_processing) do
+        expect(QueueBus.context).to eq(:batch_processing)
+        Thread.new { expect(QueueBus.context).to eq nil }.join
+      end
+    end
+
+    it 'supports nesting' do
+      QueueBus.in_context(:batch_processing) do
+        expect(QueueBus.context).to eq :batch_processing
+        QueueBus.in_context(:processing) do
+          expect(QueueBus.context).to eq :processing
+        end
+        expect(QueueBus.context).to eq :batch_processing
+      end
+    end
+
+    it 'respects an override of nil' do
+      QueueBus.context = :batch_processing
+      QueueBus.in_context(nil) do
+        expect(QueueBus.context).to eq nil
+      end
+      QueueBus.context = :batch_processing
+    end
+
+    it 'resets to the original context after the block' do
+      expect(QueueBus.context).to eq nil
+      QueueBus.in_context(:batch_processing) do
+        expect(QueueBus.context).to eq :batch_processing
+      end
+      expect(QueueBus.context).to eq nil
+    end
+  end
+
   it 'sets the hostname' do
     expect(QueueBus.hostname).not_to eq(nil)
     QueueBus.hostname = 'whatever'

data/spec/dispatch_spec.rb

@@ -28,6 +28,137 @@ module QueueBus
       end.not_to raise_error
     end
 
+    describe '#on_heartbeat' do
+      let(:dispatch) { Dispatch.new('heartbeat') }
+      let(:event) { { bus_event_type: :heartbeat_minutes } }
+      let(:event_name) { 'my-event' }
+
+      context 'when not declaring anything' do
+        before do
+          dispatch.on_heartbeat event_name do |_event|
+            Runner2.run({})
+          end
+        end
+
+        it 'runs on every heart beat' do
+          (0..24).each do |hour|
+            (0..60).each do |minute|
+              expect do
+                dispatch.execute(
+                  event_name, event.merge('hour' => hour, 'minute' => minute)
+                )
+              end.to change(Runner2, :value).by(1)
+            end
+          end
+        end
+      end
+
+      context 'when running on hour 8' do
+        before do
+          dispatch.on_heartbeat event_name, hour: 8 do |_event|
+            Runner2.run({})
+          end
+        end
+
+        it 'subscribes to hour 8' do
+          expect(dispatch.subscriptions.all.first.matcher.filters).to eq('bus_event_type' => 'heartbeat_minutes', 'hour' => '8')
+        end
+      end
+
+      context 'when running on minute 4' do
+        before do
+          dispatch.on_heartbeat event_name, minute: 4 do |_event|
+            Runner2.run({})
+          end
+        end
+
+        it 'subscribes to minute 4' do
+          expect(dispatch.subscriptions.all.first.matcher.filters).to eq('bus_event_type' => 'heartbeat_minutes', 'minute' => '4')
+        end
+      end
+
+      context 'when running on minute 4 and hour 8' do
+        before do
+          dispatch.on_heartbeat event_name, hour: 8, minute: 4 do |_event|
+            Runner2.run({})
+          end
+        end
+
+        it 'subscribes to minute 4 and hour 8' do
+          expect(dispatch.subscriptions.all.first.matcher.filters)
+            .to eq('bus_event_type' => 'heartbeat_minutes', 'minute' => '4', 'hour' => '8')
+        end
+      end
+
+      context 'when declaring minute intervals' do
+        before do
+          dispatch.on_heartbeat event_name, minute_interval: 5 do |_event|
+            Runner2.run({})
+          end
+        end
+
+        it 'runs the runner when the minute buzzes (modulos to 5)' do
+          (0..60).each do |minute|
+            if minute % 5 == 0
+              expect { dispatch.execute(event_name, event.merge('minute' => minute)) }
+                .to change(Runner2, :value).by(1)
+            else
+              expect { dispatch.execute(event_name, event.merge('minute' => minute)) }
+                .not_to change(Runner2, :value)
+            end
+          end
+        end
+      end
+
+      context 'when declaring hour intervals' do
+        before do
+          dispatch.on_heartbeat event_name, hour_interval: 3 do |_event|
+            Runner2.run({})
+          end
+        end
+
+        it 'runs the runner when the hour fizzes (modulos to 3)' do
+          (0..60).each do |hour|
+            if hour % 3 == 0
+              expect { dispatch.execute(event_name, event.merge('hour' => hour)) }
+                .to change(Runner2, :value).by(1)
+            else
+              expect { dispatch.execute(event_name, event.merge('hour' => hour)) }
+                .not_to change(Runner2, :value)
+            end
+          end
+        end
+      end
+
+      context 'when declaring hour and minute intervals' do
+        before do
+          dispatch.on_heartbeat event_name, minute_interval: 5, hour_interval: 3 do |_event|
+            Runner2.run({})
+          end
+        end
+
+        it 'runs the runner when the time fizzbuzzes (modulos to 3 and 5)' do
+          (0..24).each do |hour|
+            (0..60).each do |minute|
+              if hour % 3 == 0 && minute % 5 == 0
+                expect do
+                  dispatch.execute(
+                    event_name, event.merge('hour' => hour, 'minute' => minute)
+                  )
+                end.to change(Runner2, :value).by(1)
+              else
+                expect do
+                  dispatch.execute(
+                    event_name, event.merge('hour' => hour, 'minute' => minute)
+                  )
+                end.not_to change(Runner2, :value)
+              end
+            end
+          end
+        end
+      end
+    end
+
     describe 'Top Level' do
       before(:each) do
         QueueBus.dispatch('testit') do

data/spec/publish_spec.rb

@@ -71,6 +71,28 @@ describe 'Publishing an event' do
     expect(myval).to eq(1)
   end
 
+  it 'should add context metadata if wrapping publisher with in_context' do
+    expect(QueueBus.context).to be_nil
+
+    bus_context = 'batch_processing'
+    hash = { :one => 1, 'two' => 'here', 'bus_id' => 'app-given' }
+
+    event_name = 'event_name'
+    
+    QueueBus.in_context(:batch_processing) do
+      QueueBus.publish(event_name, hash)
+    end
+    
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
+    hash = JSON.parse(val)
+
+    att = JSON.parse(hash['args'].first)
+    expect(att['bus_context']).to eq(bus_context)
+
+    expect(QueueBus.context).to be_nil
+
+  end
+
   it 'should set the timezone and locale if available' do
     expect(defined?(I18n)).to be_nil
     expect(Time.respond_to?(:zone)).to eq(false)

data/spec/subscription_list_spec.rb

@@ -48,5 +48,31 @@ module QueueBus
                            'key2' => { 'queue_name' => 'else_ok', 'key' => 'key2', 'class' => 'MyClass', 'matcher' => { 'bus_event_type' => 'event_two' } })
       end
     end
+
+    context "when modifying the subscription" do
+      let(:list) { SubscriptionList.new }
+      let(:subscription_1) { Subscription.new("default", "key1", "MyClass", {"bus_event_type" => "event_one"}) }
+      let(:subscription_2) { Subscription.new("else_ok", "key2", "MyClass", {"bus_event_type" => "event_two"}) }
+
+      context "when adding subscriptions" do
+        it "adds the subscription successfully" do
+          list.add(subscription_1)
+          list.add(subscription_2)
+
+          expect(list.to_redis).to eq(
+            {
+              "key1" => {"queue_name" => "default", "key" => "key1", "class" => "MyClass", "matcher" => {"bus_event_type" => "event_one"}},
+              "key2" => {"queue_name" => "else_ok", "key" => "key2", "class" => "MyClass", "matcher" => {"bus_event_type" => "event_two"}}
+            }
+          )
+        end
+
+        it "errors if the subscription already exists" do
+          list.add(subscription_1)
+
+          expect { list.add(subscription_1) }.to raise_exception(RuntimeError, /Duplicate key/)
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: queue-bus
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.13.0
 platform: ruby
 authors:
 - Brian Leonard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-16 00:00:00.000000000 Z
+date: 2021-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json