queue-bus 0.8.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86f211839cfb0c4e6e037abcfd1d73a91bbbe38ae8a08138f2bbad0723e092c7
-  data.tar.gz: d0474b7d0763983dd5bd54759023e0fe017ced93aa8ecee0b3b599b34ab4e5fd
+  metadata.gz: 139511a2de01b9ffb7e58b63ecf62cbc01ae94fe38896282de2ae0dbb13178de
+  data.tar.gz: 0e481639105b4dceff9991ee448f378923fdb3ae5820294f954602e96a177243
 SHA512:
-  metadata.gz: 4c467c372844f04cdb4fd6d8d827fcbc56427936181f4bd08571da0f82c12014e0c9d6db282df17625e1102b7c0cf604af606478affeee51d1b769583a824fe2
-  data.tar.gz: 8d16570fa8441b83288790a052d0e09511039b72d6f44a0f9c9c4578d5668a8af04e49836c580f1a9e750602a11a1b607d8db5844e879249a41378a4c2a512f7
+  metadata.gz: 3ce3ebbeee0e6be7513af1ed093f5612877a6293a78bad68da502817c10f205ddf69bbc3071ef497f48baef2e66f2823311ef80e579805dbeedccec9b0794bef
+  data.tar.gz: 8b93e84ff4b5d6801d6b490560af46532c729eb7ff2b32b0d88e565bd620388d029f1a010027b9032e56731aef936945922bf7afc642453aeb9db9cbeacd0bcd

data/.circleci/config.yml

@@ -0,0 +1,21 @@
+version: 2.1
+orbs:
+  ruby: circleci/ruby@0.1.2
+
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.6.3-stretch-node
+      - image: circleci/redis:4.0.12-alpine
+    executor: ruby/default
+    steps:
+      - checkout
+      - run:
+          name: Which bundler?
+          command: bundle -v
+      - ruby/bundle-install
+      - run:
+          name: Run tests
+          environment:
+            REDIS_URL: redis://127.0.0.1:6379
+          command: bundle exec rspec spec

data/CHANGELOG.md

@@ -6,6 +6,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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
+- Documented some of the major classes and modules
+
+### Fixed
+- Ran the rubocop autocorrect on the entire codebase.
+- Fixed issue that prevented heartbeat events from firing under certain conditions
+
+## [0.9.0]
+
+### Added
+- Adds rake tasks to list scheduled jobs as csv
+
+## [0.8.1]
+
+### Fixed
+- `with_local_mode` breaks subsequent calls to `local_mode` on versions less than 2.6.
+
 ## [0.8.0]
 
 ### Added

data/Gemfile

@@ -1,5 +1,7 @@
-source "http://rubygems.org"
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
 
 gemspec
 
-gem "rake"
+gem 'rake'

data/README.mdown

@@ -141,13 +141,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 +158,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/Rakefile

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.unshift 'lib'

data/lib/queue-bus.rb

@@ -1,8 +1,11 @@
-require "queue_bus/version"
-require "forwardable"
+# frozen_string_literal: true
 
-module QueueBus
+require 'queue_bus/version'
+require 'forwardable'
 
+# The main QueueBus module. Most operations you will need to execute should be executed
+# on this top level domain.
+module QueueBus
   autoload :Application,      'queue_bus/application'
   autoload :Config,           'queue_bus/config'
   autoload :Dispatch,         'queue_bus/dispatch'
@@ -22,25 +25,26 @@ module QueueBus
   autoload :Util,             'queue_bus/util'
   autoload :Worker,           'queue_bus/worker'
 
+  # A module for all adapters, current and future.
   module Adapters
     autoload :Base,           'queue_bus/adapters/base'
     autoload :Data,           'queue_bus/adapters/data'
   end
 
   class << self
-
     include Publishing
     extend Forwardable
 
     def_delegators :config, :default_app_key=, :default_app_key,
-                            :default_queue=, :default_queue,
-                            :local_mode=, :local_mode, :with_local_mode,
-                            :before_publish=, :before_publish_callback,
-                            :logger=, :logger, :log_application, :log_worker,
-                            :hostname=, :hostname,
-                            :adapter=, :adapter, :has_adapter?,
-                            :incoming_queue=, :incoming_queue,
-                            :redis, :worker_middleware_stack
+                   :default_queue=, :default_queue,
+                   :local_mode=, :local_mode, :with_local_mode,
+                   :before_publish=, :before_publish_callback,
+                   :logger=, :logger, :log_application, :log_worker,
+                   :hostname=, :hostname,
+                   :adapter=, :adapter, :has_adapter?,
+                   :incoming_queue=, :incoming_queue,
+                   :redis, :worker_middleware_stack,
+                   :context=, :context, :in_context
 
     def_delegators :_dispatchers, :dispatch, :dispatchers, :dispatcher_by_key, :dispatcher_execute
 

data/lib/queue_bus/adapters/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module QueueBus
   module Adapters
     class Base
@@ -19,12 +21,12 @@ module QueueBus
         raise NotImplementedError
       end
 
-      def enqueue(queue_name, klass, json)
+      def enqueue(_queue_name, _klass, _json)
         # enqueue the given class (Driver/Rider) in your queue
         raise NotImplementedError
       end
 
-      def enqueue_at(epoch_seconds, queue_name, klass, json)
+      def enqueue_at(_epoch_seconds, _queue_name, _klass, _json)
         # enqueue the given class (Publisher) in your queue to run at given time
         raise NotImplementedError
       end

data/lib/queue_bus/adapters/data.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # a base adapter just for publishing and redis connection
 module QueueBus
   module Adapters
@@ -6,17 +8,16 @@ module QueueBus
         # nothing to do
       end
 
-      def redis=(client)
-        @redis = client
-      end
+      attr_writer :redis
 
       def redis(&block)
-        raise "no redis instance set" unless @redis
+        raise 'no redis instance set' unless @redis
+
         block.call(@redis)
       end
 
       def enqueue(queue_name, klass, json)
-        push(queue_name, :class => klass.to_s, :args => [json])
+        push(queue_name, class: klass.to_s, args: [json])
       end
 
       def enqueue_at(epoch_seconds, queue_name, klass, json)
@@ -24,7 +25,7 @@ module QueueBus
         delayed_push(epoch_seconds, item)
       end
 
-      def setup_heartbeat!(queue_name)
+      def setup_heartbeat!(_queue_name)
         raise NotImplementedError
       end
 
@@ -32,13 +33,13 @@ module QueueBus
 
       def push(queue, item)
         watch_queue(queue)
-        self.redis { |redis| redis.rpush "queue:#{queue}", ::QueueBus::Util.encode(item) }
+        redis { |redis| redis.rpush "queue:#{queue}", ::QueueBus::Util.encode(item) }
       end
 
       # Used internally to keep track of which queues we've created.
       # Don't call this directly.
       def watch_queue(queue)
-        self.redis { |redis| redis.sadd(:queues, queue.to_s) }
+        redis { |redis| redis.sadd(:queues, queue.to_s) }
       end
 
       # Used internally to stuff the item into the schedule sorted list.
@@ -46,7 +47,7 @@ module QueueBus
       # Insertion if O(log(n)).
       # Returns true if it's the first job to be scheduled at that time, else false
       def delayed_push(timestamp, item)
-        self.redis do |redis|
+        redis do |redis|
           # First add this item to the list for this timestamp
           redis.rpush("delayed:#{timestamp.to_i}", ::QueueBus::Util.encode(item))
 
@@ -56,9 +57,9 @@ module QueueBus
           redis.zadd :delayed_queue_schedule, timestamp.to_i, timestamp.to_i
         end
       end
-      
+
       def delayed_job_to_hash_with_queue(queue, klass, args)
-        {:class => klass.to_s, :args => args, :queue => queue}
+        { class: klass.to_s, args: args, queue: queue }
       end
     end
   end

data/lib/queue_bus/application.rb

@@ -1,36 +1,38 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # An Application is the top level unifier for a number of subscriptions. It allows for
+  # the toggling of an entire applications subscriptions.
   class Application
-
     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 { |redis| redis.smembers(app_list_key).collect { |val| new(val) } }
       end
     end
 
     attr_reader :app_key, :redis_key
 
-
     def initialize(app_key)
       @app_key = self.class.normalize(app_key)
       @redis_key = "#{self.class.app_single_key}:#{@app_key}"
       # raise error if only other chars
-      raise "Invalid application name" if @app_key.gsub("_", "").size == 0
+      raise 'Invalid application name' if @app_key.gsub('_', '').empty?
     end
 
     def subscribe(subscription_list, log = false)
       @subscriptions = nil
 
-      if subscription_list == nil || subscription_list.size == 0
+      if subscription_list.nil? || subscription_list.empty?
         unsubscribe
         return true
       end
 
-      temp_key = "temp_#{redis_key}:#{rand(999999999)}"
+      temp_key = "temp_#{redis_key}:#{rand(999_999_999)}"
 
       ::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
@@ -39,16 +41,23 @@ module QueueBus
         redis.rename(temp_key, redis_key)
         redis.sadd(self.class.app_list_key, app_key)
 
-        if log
-          redis.hgetall(redis_key).inspect
-        end
+        redis.hgetall(redis_key).inspect if log
       end
 
       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)
@@ -68,7 +77,7 @@ module QueueBus
     def subscription_matches(attributes)
       out = subscriptions.matches(attributes)
       out.each do |sub|
-        sub.app_key = self.app_key
+        sub.app_key = app_key
       end
       out
     end
@@ -84,15 +93,15 @@ module QueueBus
     protected
 
     def self.normalize(val)
-      val.to_s.gsub(/\W/, "_").downcase
+      val.to_s.gsub(/\W/, '_').downcase
     end
 
     def self.app_list_key
-      "bus_apps"
+      'bus_apps'
     end
 
     def self.app_single_key
-      "bus_app"
+      'bus_app'
     end
 
     def event_queues
@@ -116,6 +125,5 @@ module QueueBus
       end
       out
     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,16 +24,26 @@ 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
-      if Thread.current.thread_variable?(LOCAL_MODE_VAR)
+      if Thread.current.thread_variable_get(LOCAL_MODE_VAR).is_a?(Wrap)
         Thread.current.thread_variable_get(LOCAL_MODE_VAR).value
       else
         @local_mode
       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

@@ -1,23 +1,25 @@
+# frozen_string_literal: true
+
 # Creates a DSL for apps to define their blocks to run for event_types
 
 module QueueBus
+  # A Dispatch object can be used to declare an application along with it's various subscriptions.
   class Dispatch
-
     attr_reader :app_key, :subscriptions
-    
+
     def initialize(app_key)
       @app_key = Application.normalize(app_key)
       @subscriptions = SubscriptionList.new
     end
-    
+
     def size
       @subscriptions.size
     end
-    
+
     def subscribe(key, matcher_hash = nil, &block)
-      dispatch_event("default", key, matcher_hash, block)
+      dispatch_event('default', key, matcher_hash, block)
     end
-    
+
     # allows definitions of other queues
     def method_missing(method_name, *args, &block)
       if args.size == 1 && block
@@ -28,7 +30,7 @@ module QueueBus
         super
       end
     end
-    
+
     def execute(key, attributes)
       sub = subscriptions.key(key)
       if sub
@@ -41,17 +43,17 @@ module QueueBus
     def subscription_matches(attributes)
       out = subscriptions.matches(attributes)
       out.each do |sub|
-        sub.app_key = self.app_key
+        sub.app_key = app_key
       end
       out
     end
-    
+
     def dispatch_event(queue, key, matcher_hash, block)
       # if not matcher_hash, assume key is a event_type regex
-      matcher_hash ||= { "bus_event_type" => key }
-      add_subscription("#{app_key}_#{queue}", key, "::QueueBus::Rider", matcher_hash, block)
+      matcher_hash ||= { 'bus_event_type' => key }
+      add_subscription("#{app_key}_#{queue}", key, '::QueueBus::Rider', matcher_hash, block)
     end
-    
+
     def add_subscription(queue_name, key, class_name, matcher_hash = nil, block)
       sub = Subscription.register(queue_name, key, class_name, matcher_hash, block)
       subscriptions.add(sub)