queue-bus 0.9.0 → 0.9.1

data/lib/queue_bus/heartbeat.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module QueueBus
-  # publishes event about the current time
+  # When run, will calculate all of the heartbeats that need to be sent and then broadcasts
+  # those events out for execution. By always backfilling it ensures that no heartbeat is
+  # ever missed.
   class Heartbeat
-
     class << self
-
       def lock_key
-        "bus:heartbeat:lock"
+        'bus:heartbeat:lock'
       end
 
       def lock_seconds
@@ -38,71 +40,71 @@ module QueueBus
         ::QueueBus.redis { |redis| redis.del(lock_key) }
       end
 
-
       def redis_key
-        "bus:heartbeat:timestamp"
+        'bus:heartbeat:timestamp'
       end
 
       def environment_name
-        ENV["RAILS_ENV"] || ENV["RACK_ENV"] || ENV["BUS_ENV"]
+        ENV['RAILS_ENV'] || ENV['RACK_ENV'] || ENV['BUS_ENV']
       end
 
       def get_saved_minute!
         key = ::QueueBus.redis { |redis| redis.get(redis_key) }
         return nil if key.nil?
+
         case environment_name
         when 'development', 'test'
           # only 3 minutes in development; otherwise, TONS of events if not run in a while
-          three_ago = Time.now.to_i - 3*60*60
+          three_ago = Time.now.to_i / 60 - 3
           key = three_ago if key.to_i < three_ago
         end
-        return key.to_i
+        key.to_i
       end
 
       def set_saved_minute!(epoch_minute)
         ::QueueBus.redis { |redis| redis.set(redis_key, epoch_minute) }
       end
 
-      def perform(*args)
+      def perform(*_args)
         real_now = Time.now.to_i
         run_until = lock! - 2
         return if run_until < real_now
 
-        while((real_now = Time.now.to_i) < run_until)
+        while (real_now = Time.now.to_i) < run_until
           minutes = real_now.to_i / 60
           last = get_saved_minute!
           if last
             break if minutes <= last
+
             minutes = last + 1
           end
 
-          seconds = minutes * (60)
-          hours   = minutes / (60)
-          days    = minutes / (60*24)
+          seconds = minutes * 60
+          hours   = minutes / 60
+          days    = minutes / (60 * 24)
 
-          now     = Time.at(seconds)
+          now = Time.at(seconds)
 
           attributes = {}
-          attributes["epoch_seconds"] = seconds
-          attributes["epoch_minutes"] = minutes
-          attributes["epoch_hours"]   = hours
-          attributes["epoch_days"]    = days
-
-          attributes["minute"] = now.min
-          attributes["hour"]   = now.hour
-          attributes["day"]    = now.day
-          attributes["month"]  = now.month
-          attributes["year"]   = now.year
-          attributes["yday"]   = now.yday
-          attributes["wday"]   = now.wday
-
-          ::QueueBus.publish("heartbeat_minutes", attributes)
+          attributes['epoch_seconds'] = seconds
+          attributes['epoch_minutes'] = minutes
+          attributes['epoch_hours']   = hours
+          attributes['epoch_days']    = days
+
+          attributes['minute'] = now.min
+          attributes['hour']   = now.hour
+          attributes['day']    = now.day
+          attributes['month']  = now.month
+          attributes['year']   = now.year
+          attributes['yday']   = now.yday
+          attributes['wday']   = now.wday
+
+          ::QueueBus.publish('heartbeat_minutes', attributes)
           set_saved_minute!(minutes)
         end
 
         unlock!
       end
     end
-
   end
 end

data/lib/queue_bus/local.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 module QueueBus
   # only process local queues
   class Local
-
     class << self
       def publish(attributes = {})
         if ::QueueBus.local_mode == :suppress
           ::QueueBus.log_worker("Suppressed: #{attributes.inspect}")
-          return  # not doing anything
+          return # not doing anything
         end
 
         # To json and back to simlulate enqueueing
@@ -17,15 +18,15 @@ module QueueBus
 
         # looking for subscriptions, not queues
         subscription_matches(attributes).each do |sub|
-          bus_attr = {  "bus_driven_at" => Time.now.to_i,
-                        "bus_rider_queue" => sub.queue_name,
-                        "bus_rider_app_key" => sub.app_key,
-                        "bus_rider_sub_key" => sub.key,
-                        "bus_rider_class_name" => sub.class_name}
+          bus_attr = {  'bus_driven_at' => Time.now.to_i,
+                        'bus_rider_queue' => sub.queue_name,
+                        'bus_rider_app_key' => sub.app_key,
+                        'bus_rider_sub_key' => sub.key,
+                        'bus_rider_class_name' => sub.class_name }
           to_publish = bus_attr.merge(attributes || {})
           if ::QueueBus.local_mode == :standalone
             ::QueueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr.merge(attributes || {}))
-          else  # defaults to inline mode
+          else # defaults to inline mode
             sub.execute!(to_publish)
           end
         end
@@ -41,6 +42,5 @@ module QueueBus
         out
       end
     end
-
   end
 end

data/lib/queue_bus/matcher.rb

@@ -1,70 +1,80 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # Tests whether a field on a bus event matches a filter.
   class Matcher
-    SPECIAL_PREPEND = "bus_special_value_"
+    SPECIAL_PREPEND = 'bus_special_value_'
     attr_reader :filters
     def initialize(hash)
       @filters = encode(hash)
     end
-    
+
     def to_redis
       @filters
     end
-    
+
     def match?(attribute_name, attributes)
       mine = filters[attribute_name].to_s
-      return false if mine.size == 0
-      
+      return false if mine.empty?
+
       given = attributes[attribute_name]
       case mine
       when "#{SPECIAL_PREPEND}key"
-        return true if attributes.has_key?(attribute_name)
+        return true if attributes.key?(attribute_name)
+
         return false
       when "#{SPECIAL_PREPEND}blank"
-        return true if given.to_s.strip.size == 0
+        return true if given.to_s.strip.empty?
+
         return false
       when "#{SPECIAL_PREPEND}empty"
-        return false if given == nil
-        return true if given.to_s.size == 0
+        return false if given.nil?
+        return true if given.to_s.empty?
+
         return false
       when "#{SPECIAL_PREPEND}nil"
-        return true if given == nil
+        return true if given.nil?
+
         return false
       when "#{SPECIAL_PREPEND}value"
-        return false if given == nil
+        return false if given.nil?
+
         return true
       when "#{SPECIAL_PREPEND}present"
-        return true if given.to_s.strip.size > 0
+        return true unless given.to_s.strip.empty?
+
         return false
       end
-      
+
       given = given.to_s
-      
+
       return true if mine == given
+
       begin
         # if it's already a regex, don't mess with it
         # otherwise, it should have start and end line situation
-        if mine[0..6] == "(?-mix:"
-          regex = Regexp.new(mine)
-        else
-          regex = Regexp.new("^#{mine}$")
-        end
+        regex = if mine[0..6] == '(?-mix:'
+                  Regexp.new(mine)
+                else
+                  Regexp.new("^#{mine}$")
+                end
         return !!regex.match(given)
-      rescue
+      rescue StandardError
         return false
       end
     end
-    
+
     def matches?(attributes)
       return false if filters.empty?
-      return false if attributes == nil
-      
+      return false if attributes.nil?
+
       filters.keys.each do |key|
         return false unless match?(key, attributes)
       end
-      
+
       true
     end
-    
+
     def encode(hash)
       out = {}
       hash.each do |key, value|
@@ -73,9 +83,8 @@ module QueueBus
           value = "#{SPECIAL_PREPEND}#{value}"
         end
         out[key.to_s] = value.to_s
-      end      
+      end
       out
     end
   end
 end
-

data/lib/queue_bus/publisher.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 module QueueBus
-  # publishes on a delay
+  # A simple publishing worker for QueueBus. Makes publishing asynchronously possible since
+  # it may be enqueued to the background worker with a delay. This will allow the event to
+  # be published at a later time.
   class Publisher
-
     class << self
       def perform(attributes)
-        event_type = attributes["bus_event_type"]
+        event_type = attributes['bus_event_type']
         ::QueueBus.log_worker("Publisher running: #{event_type} - #{attributes.inspect}")
         ::QueueBus.publish(event_type, attributes)
       end
     end
-
   end
-end
+end

data/lib/queue_bus/publishing.rb

@@ -1,18 +1,22 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # The publishing mixin provides the main interactions that users will use
+  # to interact with the queue bus. This module is not interacted with directly and instead
+  # is included inte the `QueueBus` module.
   module Publishing
-
     def with_global_attributes(attributes)
       original_timezone = false
       original_locale   = false
 
-      if attributes["bus_locale"] && defined?(I18n) && I18n.respond_to?(:locale=)
+      if attributes['bus_locale'] && defined?(I18n) && I18n.respond_to?(:locale=)
         original_locale = I18n.locale if I18n.respond_to?(:locale)
-        I18n.locale = attributes["bus_locale"]
+        I18n.locale = attributes['bus_locale']
       end
 
-      if attributes["bus_timezone"] && defined?(Time) && Time.respond_to?(:zone=)
+      if attributes['bus_timezone'] && defined?(Time) && Time.respond_to?(:zone=)
         original_timezone = Time.zone if Time.respond_to?(:zone)
-        Time.zone = attributes["bus_timezone"]
+        Time.zone = attributes['bus_timezone']
       end
 
       yield
@@ -21,13 +25,17 @@ module QueueBus
       Time.zone   = original_timezone unless original_timezone == false
     end
 
-    def publish_metadata(event_type, attributes={})
+    def publish_metadata(event_type, attributes = {})
       # TODO: "bus_app_key" => application.app_key ?
-      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_locale"]       = I18n.locale.to_s if defined?(I18n) && I18n.respond_to?(:locale) && I18n.locale
-      bus_attr["bus_timezone"]     = Time.zone.name   if defined?(Time) && Time.respond_to?(:zone)   && Time.zone
+      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
+      if defined?(I18n) && I18n.respond_to?(:locale) && I18n.locale
+        bus_attr['bus_locale']       = I18n.locale.to_s
+      end
+      if defined?(Time) && Time.respond_to?(:zone) && Time.zone
+        bus_attr['bus_timezone']     = Time.zone.name
+      end
       out = bus_attr.merge(attributes || {})
       ::QueueBus.before_publish_callback(out)
       out
@@ -35,15 +43,14 @@ module QueueBus
 
     def generate_uuid
       require 'securerandom' unless defined?(SecureRandom)
-      return SecureRandom.uuid
-
-      rescue Exception => e
-        # secure random not there
-        # big random number a few times
-        n_bytes = [42].pack('i').size
-        n_bits = n_bytes * 8
-        max = 2 ** (n_bits - 2) - 1
-        return "#{rand(max)}-#{rand(max)}-#{rand(max)}"
+      SecureRandom.uuid
+    rescue Exception => e
+      # secure random not there
+      # big random number a few times
+      n_bytes = [42].pack('i').size
+      n_bits = n_bytes * 8
+      max = 2**(n_bits - 2) - 1
+      "#{rand(max)}-#{rand(max)}-#{rand(max)}"
     end
 
     def publish(event_type, attributes = {})
@@ -59,9 +66,9 @@ module QueueBus
 
     def publish_at(timestamp_or_epoch, event_type, attributes = {})
       to_publish = publish_metadata(event_type, attributes)
-      to_publish["bus_delayed_until"] ||= timestamp_or_epoch.to_i
-      to_publish.delete("bus_published_at") unless attributes["bus_published_at"] # will be put on when it actually does it
-      to_publish["bus_class_proxy"] = ::QueueBus::Publisher.name.to_s
+      to_publish['bus_delayed_until'] ||= timestamp_or_epoch.to_i
+      to_publish.delete('bus_published_at') unless attributes['bus_published_at'] # will be put on when it actually does it
+      to_publish['bus_class_proxy'] = ::QueueBus::Publisher.name.to_s
 
       ::QueueBus.log_application("Event published:#{event_type} #{to_publish.inspect} publish_at: #{timestamp_or_epoch.to_i}")
       delayed_enqueue_to(timestamp_or_epoch.to_i, incoming_queue, ::QueueBus::Worker, to_publish)
@@ -69,7 +76,7 @@ module QueueBus
 
     def enqueue_to(queue_name, class_name, hash)
       class_name = class_name.name if class_name.is_a?(Class)
-      hash = hash.merge("bus_class_proxy" => class_name.to_s)
+      hash = hash.merge('bus_class_proxy' => class_name.to_s)
       ::QueueBus.adapter.enqueue(queue_name, ::QueueBus::Worker, ::QueueBus::Util.encode(hash || {}))
     end
 

data/lib/queue_bus/rider.rb

@@ -1,27 +1,31 @@
+# frozen_string_literal: true
+
 module QueueBus
-  # queue'd in each
+  # The Rider is meant to execute subscriptions.
+  #
+  # When your application has subscriptions to an event we still need to enqueue some executor that
+  # will execute the block that was registered. The Rider will effectively ride the bus for your
+  # subscribed event. One Rider is launched for each subscription on an event.
   class Rider
+    def self.perform(attributes = {})
+      sub_key = attributes['bus_rider_sub_key']
+      app_key = attributes['bus_rider_app_key']
+      raise 'No application key passed' if app_key.to_s == ''
+      raise 'No subcription key passed' if sub_key.to_s == ''
+
+      attributes ||= {}
+
+      ::QueueBus.log_worker("Rider received: #{app_key} #{sub_key} #{attributes.inspect}")
+
+      # attributes that should be available
+      # attributes["bus_event_type"]
+      # attributes["bus_app_key"]
+      # attributes["bus_published_at"]
+      # attributes["bus_driven_at"]
 
-    class << self
-      def perform(attributes = {})
-        sub_key = attributes["bus_rider_sub_key"]
-        app_key = attributes["bus_rider_app_key"]
-        raise "No application key passed" if app_key.to_s == ""
-        raise "No subcription key passed" if sub_key.to_s == ""
-        
-        attributes ||= {}
-        
-        ::QueueBus.log_worker("Rider received: #{app_key} #{sub_key} #{attributes.inspect}")
-        
-        # attributes that should be available
-        # attributes["bus_event_type"]
-        # attributes["bus_app_key"]
-        # attributes["bus_published_at"]
-        # attributes["bus_driven_at"]
-        
-        # (now running with the real app that subscribed)
-        ::QueueBus.dispatcher_execute(app_key, sub_key, attributes.merge("bus_executed_at" => Time.now.to_i))
-      end
+      # (now running with the real app that subscribed)
+      ::QueueBus.dispatcher_execute(app_key, sub_key,
+                                    attributes.merge('bus_executed_at' => Time.now.to_i))
     end
   end
-end
+end