eventq_rabbitmq 1.14.1 → 1.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 05af6776f6c83b5d478ad6529e2a708ae3858dca
-  data.tar.gz: 6fac859ffda2279c6713c8af66124d50d90fb43c
+  metadata.gz: ff2c405a89063fc287c9786d515af313b0384121
+  data.tar.gz: b3931296591bbc43c9eca5de61179d7307084f62
 SHA512:
-  metadata.gz: ef1f6a7ea8383bf86de6d03475f5e87fe8bb4510b89d67d2fc0d28ff4efbb9481a18c3ab1a340230e86bb645e702394a31323483a6b557b5be0c4b645b9f2efe
-  data.tar.gz: a072f13174b6fb61cc8bbd1236aba9ccf6857d948eb623ac7dab9b1fd2b8f3dc3e322c4f26a1d449e2af44ebc2e7a9bb6d5492e543789b71b7288f27e4159774
+  metadata.gz: d5f6294cb4a4c2b25f1256ed9c8c45b5fd50bb951d0e09ad9d93b3a5a7158fbc0960693adb002f9c46c7fe0c39755f2cd83cb750f58f7ad1bcf697c2b68bde4a
+  data.tar.gz: 93c89113d36f8de45c0f6ab53c5541c07b18aeb76ae15e6028a4401770de993dad90abfd561d8589bf92d5588b7988792658868b6aa782c907253e893382f3d5

data/lib/eventq_rabbitmq/rabbitmq_eventq_client.rb

@@ -33,7 +33,11 @@ module EventQ
         true
       end
 
-      def raise_event(event_type, event)
+      def publish(topic:, event:, context: {})
+        raise_event(topic, event, context)
+      end
+
+      def raise_event(event_type, event, context = {})
         register_event(event_type)
 
         _event_type = EventQ.create_event_type(event_type)
@@ -41,7 +45,7 @@ module EventQ
         with_connection do |channel|
           exchange = @queue_manager.get_exchange(channel, @event_raised_exchange)
 
-          message = serialized_message(_event_type, event)
+          message = serialized_message(_event_type, event, context)
 
           exchange.publish(message, routing_key: _event_type)
 
@@ -51,7 +55,7 @@ module EventQ
         end
       end
 
-      def raise_event_in_queue(event_type, event, queue, delay)
+      def raise_event_in_queue(event_type, event, queue, delay, context = {})
         register_event(event_type)
 
         _event_type = EventQ.create_event_type(event_type)
@@ -69,7 +73,7 @@ module EventQ
           q = channel.queue(_queue_name, durable: @queue_manager.durable)
           q.bind(exchange, routing_key: _event_type)
 
-          message = serialized_message(_event_type, event)
+          message = serialized_message(_event_type, event, context)
 
           delay_exchange.publish(message, routing_key: _event_type)
 
@@ -101,10 +105,11 @@ module EventQ
         true
       end
 
-      def serialized_message(event_type, event)
+      def serialized_message(event_type, event, context)
         qm = new_message
         qm.content = event
         qm.type = event_type
+        qm.context = context
 
         if EventQ::Configuration.signature_secret != nil
           provider = @signature_manager.get_provider(EventQ::Configuration.signature_provider)

data/lib/eventq_rabbitmq/rabbitmq_queue_manager.rb

@@ -59,13 +59,13 @@ module EventQ
 
         if queue.allow_retry_back_off == true
 
-          EventQ.log(:debug, "[#{self.class}] - Requesting retry queue. x-dead-letter-exchange: #{subscriber_exchange.name} | x-message-ttl: #{queue.max_retry_delay}")
+          EventQ.logger.debug { "[#{self.class}] - Requesting retry queue. x-dead-letter-exchange: #{subscriber_exchange.name} | x-message-ttl: #{queue.max_retry_delay}" }
 
           return channel.queue("#{_queue_name}.r", :durable => @durable, :arguments => { X_DEAD_LETTER_EXCHANGE => subscriber_exchange.name, X_MESSAGE_TTL => queue.max_retry_delay })
 
         else
 
-          EventQ.log(:debug, "[#{self.class}] - Requesting retry queue. x-dead-letter-exchange: #{subscriber_exchange.name} | x-message-ttl: #{queue.retry_delay}")
+          EventQ.logger.debug { "[#{self.class}] - Requesting retry queue. x-dead-letter-exchange: #{subscriber_exchange.name} | x-message-ttl: #{queue.retry_delay}" }
 
           return channel.queue("#{_queue_name}.r", :durable => @durable, :arguments => { X_DEAD_LETTER_EXCHANGE => subscriber_exchange.name, X_MESSAGE_TTL => queue.retry_delay })
 

data/lib/eventq_rabbitmq/rabbitmq_queue_worker.rb

@@ -22,7 +22,7 @@ module EventQ
 
       def start(queue, options = {}, &block)
 
-        EventQ.log(:info, "[#{self.class}] - Preparing to start listening for messages.")
+        EventQ.logger.info("[#{self.class}] - Preparing to start listening for messages.")
 
         configure(queue, options)
 
@@ -32,7 +32,7 @@ module EventQ
           raise "[#{self.class}] - :client (QueueClient) must be specified."
         end
 
-        EventQ.log(:info, "[#{self.class}] - Listening for messages.")
+        EventQ.logger.info("[#{self.class}] - Listening for messages.")
         EventQ.logger.debug do
           "[#{self.class} #start] - Listening for messages on queue: #{EventQ.create_queue_name(queue.name)}"
         end
@@ -100,7 +100,7 @@ module EventQ
                 has_received_message = thread_process_iteration(channel, manager, queue, block)
 
               rescue => e
-                EventQ.log(:error, "An unhandled error occurred. Error: #{e} | Backtrace: #{e.backtrace}")
+                EventQ.logger.error("An unhandled error occurred. Error: #{e} | Backtrace: #{e.backtrace}")
                 call_on_error_block(error: e)
               end
 
@@ -111,9 +111,9 @@ module EventQ
               gc_flush
 
               if !has_received_message
-                EventQ.log(:debug, "[#{self.class}] - No message received.")
+                EventQ.logger.debug { "[#{self.class}] - No message received." }
                 if @sleep > 0
-                  EventQ.log(:debug, "[#{self.class}] - Sleeping for #{@sleep} seconds")
+                  EventQ.logger.debug { "[#{self.class}] - Sleeping for #{@sleep} seconds" }
                   sleep(@sleep)
                 end
               end
@@ -136,14 +136,14 @@ module EventQ
 
       def call_on_error_block(error:, message: nil)
         if @on_error_block
-          EventQ.log(:debug, "[#{self.class}] - Executing on_error block.")
+          EventQ.logger.debug { "[#{self.class}] - Executing on_error block." }
           begin
             @on_error_block.call(error, message)
           rescue => e
-            EventQ.log(:error, "[#{self.class}] - An error occurred executing the on_error block. Error: #{e}")
+            EventQ.logger.error("[#{self.class}] - An error occurred executing the on_error block. Error: #{e}")
           end
         else
-          EventQ.log(:debug, "[#{self.class}] - No on_error block specified to execute.")
+          EventQ.logger.debug { "[#{self.class}] - No on_error block specified to execute." }
         end
       end
 
@@ -182,7 +182,7 @@ module EventQ
           end
 
         rescue => e
-          EventQ.log(:error, "[#{self.class}] - An error occurred attempting to process a message. Error: #{e} | Backtrace: #{e.backtrace}")
+          EventQ.logger.error("[#{self.class}] - An error occurred attempting to process a message. Error: #{e} | Backtrace: #{e.backtrace}")
           call_on_error_block(error: e)
         end
 
@@ -230,64 +230,64 @@ module EventQ
 
       def call_on_retry_exceeded_block(message)
         if @retry_exceeded_block != nil
-          EventQ.log(:debug, "[#{self.class}] - Executing on_retry_exceeded block.")
+          EventQ.logger.debug { "[#{self.class}] - Executing on_retry_exceeded block." }
           begin
             @retry_exceeded_block.call(message)
           rescue => e
-            EventQ.log(:error, "[#{self.class}] - An error occurred executing the on_retry_exceeded block. Error: #{e}")
+            EventQ.logger.error("[#{self.class}] - An error occurred executing the on_retry_exceeded block. Error: #{e}")
           end
         else
-          EventQ.log(:debug, "[#{self.class}] - No on_retry_exceeded block specified.")
+          EventQ.logger.debug { "[#{self.class}] - No on_retry_exceeded block specified." }
         end
       end
 
       def call_on_retry_block(message)
         if @on_retry_block
-          EventQ.log(:debug, "[#{self.class}] - Executing on_retry block.")
+          EventQ.logger.debug { "[#{self.class}] - Executing on_retry block." }
           begin
             @on_retry_block.call(message, abort)
           rescue => e
-            EventQ.log(:error, "[#{self.class}] - An error occurred executing the on_retry block. Error: #{e}")
+            EventQ.logger.error("[#{self.class}] - An error occurred executing the on_retry block. Error: #{e}")
           end
         else
-          EventQ.log(:debug, "[#{self.class}] - No on_retry block specified.")
+          EventQ.logger.debug { "[#{self.class}] - No on_retry block specified." }
         end
       end
 
       def reject_message(channel, message, delivery_info, retry_exchange, queue, abort)
 
-        EventQ.log(:info, "[#{self.class}] - Message rejected removing from queue.")
+        EventQ.logger.info("[#{self.class}] - Message rejected removing from queue.")
         #reject the message to remove from queue
         channel.reject(delivery_info.delivery_tag, false)
 
         #check if the message retry limit has been exceeded
         if message.retry_attempts >= queue.max_retry_attempts
 
-          EventQ.log(:info, "[#{self.class}] - Message retry attempt limit exceeded. Msg: #{serialize_message(message)}")
+          EventQ.logger.info("[#{self.class}] - Message retry attempt limit exceeded. Msg: #{serialize_message(message)}")
 
           call_on_retry_exceeded_block(message)
 
         #check if the message is allowed to be retried
         elsif queue.allow_retry
 
-          EventQ.log(:debug, "[#{self.class}] - Incrementing retry attempts count.")
+          EventQ.logger.debug { "[#{self.class}] - Incrementing retry attempts count." }
           message.retry_attempts += 1
 
           if queue.allow_retry_back_off == true
-            EventQ.log(:debug, "[#{self.class}] - Calculating message back off retry delay. Attempts: #{message.retry_attempts} * Retry Delay: #{queue.retry_delay}")
+            EventQ.logger.debug { "[#{self.class}] - Calculating message back off retry delay. Attempts: #{message.retry_attempts} * Retry Delay: #{queue.retry_delay}" }
             message_ttl = message.retry_attempts * queue.retry_delay
             if (message.retry_attempts * queue.retry_delay) > queue.max_retry_delay
-              EventQ.log(:debug, "[#{self.class}] - Max message back off retry delay reached.")
+              EventQ.logger.debug { "[#{self.class}] - Max message back off retry delay reached." }
               message_ttl = queue.max_retry_delay
             end
           else
-            EventQ.log(:debug, "[#{self.class}] - Setting fixed retry delay for message.")
+            EventQ.logger.debug { "[#{self.class}] - Setting fixed retry delay for message." }
             message_ttl = queue.retry_delay
           end
 
-          EventQ.log(:debug, "[#{self.class}] - Sending message for retry. Message TTL: #{message_ttl}")
+          EventQ.logger.debug { "[#{self.class}] - Sending message for retry. Message TTL: #{message_ttl}" }
           retry_exchange.publish(serialize_message(message), :expiration => message_ttl)
-          EventQ.log(:debug, "[#{self.class}] - Published message to retry exchange.")
+          EventQ.logger.debug { "[#{self.class}] - Published message to retry exchange." }
 
           call_on_retry_block(message)
 
@@ -323,7 +323,7 @@ module EventQ
           @gc_flush_interval = options[:gc_flush_interval]
         end
 
-        EventQ.log(:info, "[#{self.class}] - Configuring. Process Count: #{@fork_count} | Thread Count: #{@thread_count} | Interval Sleep: #{@sleep}.")
+        EventQ.logger.info("[#{self.class}] - Configuring. Process Count: #{@fork_count} | Thread Count: #{@thread_count} | Interval Sleep: #{@sleep}.")
 
         return true
 
@@ -336,14 +336,14 @@ module EventQ
         error = false
         message = deserialize_message(payload)
 
-        EventQ.log(:info, "[#{self.class}] - Message received. Retry Attempts: #{message.retry_attempts}")
+        EventQ.logger.info("[#{self.class}] - Message received. Retry Attempts: #{message.retry_attempts}")
 
         @signature_provider_manager.validate_signature(message: message, queue: queue)
 
-        message_args = EventQ::MessageArgs.new(message.type, message.retry_attempts)
+        message_args = EventQ::MessageArgs.new(message.type, message.retry_attempts, message.context)
 
         if(!EventQ::NonceManager.is_allowed?(message.id))
-          EventQ.log(:info, "[#{self.class}] - Duplicate Message received. Dropping message.")
+          EventQ.logger.info("[#{self.class}] - Duplicate Message received. Dropping message.")
           channel.acknowledge(delivery_info.delivery_tag, false)
           return false
         end
@@ -354,15 +354,15 @@ module EventQ
 
           if message_args.abort == true
             abort = true
-            EventQ.log(:info, "[#{self.class}] - Message aborted.")
+            EventQ.logger.info("[#{self.class}] - Message aborted.")
           else
             #accept the message as processed
             channel.acknowledge(delivery_info.delivery_tag, false)
-            EventQ.log(:info, "[#{self.class}] - Message acknowledged.")
+            EventQ.logger.info("[#{self.class}] - Message acknowledged.")
           end
 
         rescue => e
-          EventQ.log(:error, "[#{self.class}] - An unhandled error happened attempting to process a queue message. Error: #{e} | Backtrace: #{e.backtrace}")
+          EventQ.logger.error("[#{self.class}] - An unhandled error happened attempting to process a queue message. Error: #{e} | Backtrace: #{e.backtrace}")
           error = true
           call_on_error_block(error: e, message: message)
         end

data/lib/eventq_rabbitmq/version.rb

@@ -1,3 +1,3 @@
 module EventqRabbitmq
-  VERSION = "1.14.1"
+  VERSION = "1.15.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eventq_rabbitmq
 version: !ruby/object:Gem::Version
-  version: 1.14.1
+  version: 1.15.0
 platform: ruby
 authors:
 - vaughanbrittonsage
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-27 00:00:00.000000000 Z
+date: 2017-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler