eventbus 0.24 → 0.26

data/lib/eventbus/common_init.rb

@@ -0,0 +1,50 @@
+require 'active_support/core_ext'
+
+module EventBus
+
+  def self.set_up_logging
+    base_logdir = ENV['EVENTBUS_LOGDIR']
+    
+    if base_logdir.nil? 
+      base_logdir = File.join(ENV['HOME'], "logs", self.PROD_LEVEL, "eventbus", self.application_id)  
+    end
+    
+    FileUtils.mkdir_p(base_logdir) unless File.directory?(base_logdir)
+        
+    filename = [File.basename($PROGRAM_NAME, File.extname($PROGRAM_NAME)), ".log"].join
+    logfile_path = File.join(base_logdir, filename)
+    
+    shift_age = ENV['EVENTBUS_LOG_SHIFT_AGE'] || "daily"
+    shift_size = ENV['EVENTBUS_LOG_SHIFT_SIZE'] || 20971520 # 20MB
+    
+    puts "Logging to #{logfile_path}."
+    self.logger = Logger.new(logfile_path, shift_age, shift_size)
+    logger.info "Logging initialized. Rotation age: #{shift_age} Rotation size: #{shift_size}" 
+  
+  end
+
+
+  # CONSTANTS
+
+  # True Constants
+  mattr_accessor :CORE_APPLICATION_ID
+  mattr_accessor :DEFAULT_APPLICATION_ID
+  mattr_accessor :DEFAULT_PROD_LEVEL
+  
+  self.CORE_APPLICATION_ID = "EVENTBUS_CORE"            
+  self.DEFAULT_APPLICATION_ID = self.CORE_APPLICATION_ID
+  self.DEFAULT_PROD_LEVEL = "development"
+
+  # Calculated Constants
+  mattr_accessor :PROD_LEVEL
+  self.PROD_LEVEL = ENV['EVENTBUS_PROD_LEVEL'] || self.DEFAULT_PROD_LEVEL
+  
+  # VARIABLES 
+  
+  mattr_accessor :application_id
+  self.application_id = ENV['EVENTBUS_APPLICATION_ID'] || self.DEFAULT_APPLICATION_ID
+  
+  mattr_accessor :logger
+  self.set_up_logging
+
+end

data/lib/eventbus/connectors/stomp/slogger.rb

@@ -0,0 +1,303 @@
+# -*- encoding: utf-8 -*-
+
+require 'eventbus/common_init'
+
+# This is taken almost directly from the Stomp gem's example 
+# logger, with minor modifications. Will work on customizing later. 
+
+# == Example STOMP call back logger class.
+#
+# Optional callback methods:
+#
+# * on_connecting: connection starting
+# * on_connected: successful connect
+# * on_connectfail: unsuccessful connect (will usually be retried)
+# * on_disconnect: successful disconnect
+#
+# * on_miscerr: on miscellaneous xmit/recv errors
+#
+# * on_publish: publish called
+# * on_subscribe: subscribe called
+# * on_unsubscribe: unsubscribe called
+#
+# * on_begin: begin called
+# * on_ack: ack called
+# * on_nack: nack called
+# * on_commit: commit called
+# * on_abort: abort called
+#
+# * on_receive: receive called and successful
+#
+# * on_ssl_connecting: SSL connection starting
+# * on_ssl_connected: successful SSL connect
+# * on_ssl_connectfail: unsuccessful SSL connect (will usually be retried)
+#
+# * on_hbread_fail: unsuccessful Heartbeat read
+# * on_hbwrite_fail: unsuccessful Heartbeat write
+# * on_hbfire: on any send or receive heartbeat
+#
+# All methods are optional, at the user's requirements.
+#
+# If a method is not provided, it is not called (of course.)
+#
+# IMPORTANT NOTE: in general, call back logging methods *SHOULD* not raise exceptions,
+# otherwise the underlying STOMP connection may fail in mysterious ways.
+#
+# There are two useful exceptions to this rule for:
+#
+# * on_connectfail
+# * on_ssl_connectfail
+#
+# These two methods can raise a Stomp::Errors::LoggerConnectionError. If this
+# exception is raised, it is passed up the chain to the caller.
+#
+# Callback parameters: are a copy of the @parameters instance variable for
+# the Stomp::Connection.
+#
+
+module EventBus
+module Connectors
+module Stomp
+
+class Slogger
+
+  # Initialize a new callback logger instance.
+  def initialize(init_parms = nil)
+    EventBus.logger.info("Logger is: #{EventBus.logger.inspect}")
+    EventBus.logger.info("Logger initialization complete.")
+  end
+
+  # Log connecting events
+  def on_connecting(parms)
+    begin
+      EventBus.logger.info "Connecting: #{info(parms)}"
+    rescue
+      EventBus.logger.debug "Connecting oops"
+    end
+  end
+
+  # Log connected events
+  def on_connected(parms)
+    begin
+      EventBus.logger.info "Connected: #{info(parms)}"
+    rescue
+      EventBus.logger.debug "Connected oops"
+    end
+  end
+
+  # Log connectfail events
+  def on_connectfail(parms)
+    begin
+      EventBus.logger.error "Connect Fail #{info(parms)}"
+    rescue
+      EventBus.logger.debug "Connect Fail oops"
+    end
+=begin
+# An example LoggerConnectionError raise
+EventBus.logger.debug "Connect Fail, will raise"
+raise Stomp::Error::LoggerConnectionError.new("quit from connect fail")
+=end
+  end
+
+  # Log disconnect events
+  def on_disconnect(parms)
+    begin
+      EventBus.logger.info "Disconnected #{info(parms)}"
+    rescue
+      EventBus.logger.debug "Disconnected oops"
+    end
+  end
+
+  # Log miscellaneous errors
+  def on_miscerr(parms, errstr)
+    begin
+      EventBus.logger.unknown "Miscellaneous Error #{info(parms)}"
+      EventBus.logger.unknown "Miscellaneous Error String #{errstr}"
+    rescue
+      EventBus.logger.debug "Miscellaneous Error oops"
+    end
+  end
+
+  # Log Subscribe
+  def on_subscribe(parms, headers)
+    begin
+      EventBus.logger.info "Subscribe Parms #{info(parms)}"
+      EventBus.logger.info "Subscribe Headers #{headers}"
+    rescue
+      EventBus.logger.debug "Subscribe oops"
+    end
+  end
+
+  # Log UnSubscribe
+  def on_unsubscribe(parms, headers)
+    begin
+      EventBus.logger.info "UnSubscribe Parms #{info(parms)}"
+      EventBus.logger.info "UnSubscribe Headers #{headers}"
+    rescue
+      EventBus.logger.debug "UnSubscribe oops"
+    end
+  end
+
+  # Log Publish
+  def on_publish(parms, message, headers)
+    begin
+      EventBus.logger.info "Publish Parms #{info(parms)}"
+      EventBus.logger.info "Publish Message #{message}"
+      EventBus.logger.info "Publish Headers #{headers}"
+    rescue
+      EventBus.logger.debug "Publish oops"
+    end
+  end
+
+  # Log Receive
+  def on_receive(parms, result)
+    begin
+      EventBus.logger.info "Receive Parms #{info(parms)}"
+      EventBus.logger.info "Receive Result #{result}"
+    rescue
+      EventBus.logger.debug "Receive oops"
+    end
+  end
+
+  # Log Begin
+  def on_begin(parms, headers)
+    begin
+      EventBus.logger.info "Begin Parms #{info(parms)}"
+      EventBus.logger.info "Begin Result #{headers}"
+    rescue
+      EventBus.logger.debug "Begin oops"
+    end
+  end
+
+  # Log Ack
+  def on_ack(parms, headers)
+    begin
+      EventBus.logger.debug "Ack Parms #{info(parms)}"
+      EventBus.logger.debug "Ack Result #{headers}"
+    rescue
+      EventBus.logger.debug "Ack oops"
+    end
+  end
+
+  # Log NAck
+  def on_nack(parms, headers)
+    begin
+      EventBus.logger.debug "NAck Parms #{info(parms)}"
+      EventBus.logger.debug "NAck Result #{headers}"
+    rescue
+      EventBus.logger.debug "NAck oops"
+    end
+  end
+
+  # Log Commit
+  def on_commit(parms, headers)
+    begin
+      EventBus.logger.info "Commit Parms #{info(parms)}"
+      EventBus.logger.info "Commit Result #{headers}"
+    rescue
+      EventBus.logger.debug "Commit oops"
+    end
+  end
+
+  # Log Abort
+  def on_abort(parms, headers)
+    begin
+      EventBus.logger.info "Abort Parms #{info(parms)}"
+      EventBus.logger.info "Abort Result #{headers}"
+    rescue
+      EventBus.logger.debug "Abort oops"
+    end
+  end
+
+  # Stomp 1.1+ - heart beat read (receive) failed.
+  def on_hbread_fail(parms, ticker_data)
+    begin
+      EventBus.logger.warn "Hbreadf Parms #{info(parms)}"
+      EventBus.logger.warn "Hbreadf Result #{ticker_data.inspect}"
+    rescue
+      EventBus.logger.debug "Hbreadf oops"
+    end
+  end
+
+  # Stomp 1.1+ - heart beat send (transmit) failed.
+  def on_hbwrite_fail(parms, ticker_data)
+    begin
+      EventBus.logger.warn "Hbwritef Parms #{info(parms)}"
+      EventBus.logger.warn "Hbwritef Result #{ticker_data.inspect}"
+    rescue
+      EventBus.logger.debug "Hbwritef oops"
+    end
+  end
+
+  # Log SSL connection start.
+  def on_ssl_connecting(parms)
+    begin
+      EventBus.logger.info "SSL Connecting Parms #{info(parms)}"
+    rescue
+      EventBus.logger.debug "SSL Connecting oops"
+    end
+  end
+
+  # Log a successful SSL connect.
+  def on_ssl_connected(parms)
+    begin
+      EventBus.logger.info "SSL Connected Parms #{info(parms)}"
+    rescue
+      EventBus.logger.debug "SSL Connected oops"
+    end
+  end
+
+  # Log an unsuccessful SSL connect.
+  def on_ssl_connectfail(parms)
+    begin
+      EventBus.logger.error "SSL Connect Fail Parms #{info(parms)}"
+      EventBus.logger.error "SSL Connect Fail Exception #{parms[:ssl_exception]}, #{parms[:ssl_exception].message}"
+    rescue
+      EventBus.logger.debug "SSL Connect Fail oops"
+    end
+=begin
+# An example LoggerConnectionError raise
+EventBus.logger.debug "SSL Connect Fail, will raise"
+raise Stomp::Error::LoggerConnectionError.new("quit from SSL connect")
+=end
+  end
+
+  # Log heart beat fires
+  def on_hbfire(parms, srind, curt)
+    begin
+      EventBus.logger.debug "HeartBeat Fire Parms #{info(parms)}"
+      EventBus.logger.debug "HeartBeat Fire Send/Receive #{srind}"
+    rescue
+      EventBus.logger.debug "HeartBeat Fire oops"
+    end
+  end
+
+  private
+
+  # Example information extract.
+  def info(parms)
+    #
+    # Available in the parms Hash:
+    # parms[:cur_host]
+    # parms[:cur_port]
+    # parms[:cur_login]
+    # parms[:cur_passcode]
+    # parms[:cur_ssl]
+    # parms[:cur_recondelay]
+    # parms[:cur_parseto]
+    # parms[:cur_conattempts]
+    # parms[:openstat]
+    #
+    # For the on_ssl_connectfail callback these are also available:
+    # parms[:ssl_exception]
+    #
+    "Host: #{parms[:cur_host]}, Port: #{parms[:cur_port]}, Login: #{parms[:cur_login]}, Passcode: #{parms[:cur_passcode]}," +
+      " ssl: #{parms[:cur_ssl]}, open: #{parms[:openstat]}"
+  end
+end
+
+
+# module ends
+end
+end
+end

data/lib/eventbus/connectors/stomp.rb

@@ -1,31 +1,73 @@
 # This module is primarily intended for use with ActiveMQ, though 
 # it should work with any Stomp-speaking broker. 
+require 'eventbus/common_init'
+require_relative 'stomp/slogger'
+require 'socket'
 require 'stomp'
 module StompConnectionDriver
 
   @@StompConnector_Connection = nil
 
   def connection_driver_initialize
-    puts "StompConnectionDriver is loaded!"
+    
   end 
 
   def get_connection
-      if @@StompConnector_Connection.nil?
-        opts = {
+  
+    opts = {
+      :hosts => [
+        {
           :host => ENV["BROKER_HOST"] || "localhost",
-          :port => ENV["BROKER_PORT"] || 61613,
-          :user => ENV["BROKER_USER"],
-          :pass => ENV["BROKER_PASS"],
-          # :logging => opts.delete(:logging) || false,
-          #:logfile => opts.delete(:logfile) || STDOUT
-        }
-      
-        stomp_url = ENV['STOMP_URL'] || 
-          "stomp://#{opts[:user]}:#{opts[:pass]}@#{opts[:host]}:#{opts[:port]}?initialReconnectDelay=5000&randomize=false&useExponentialBackOff=false"
-        @@StompConnector_Connection = Stomp::Client.new(stomp_url)
-      end
-      
-      return @@StompConnector_Connection
+          :port => ENV["BROKER_PORT"] || (ENV['EVENTBUS_STOMP_SSL'] == "false" ? 61613 : 61614),
+          :login => ENV["BROKER_USER"] || "eventbus",
+          :passcode => ENV["BROKER_PASS"] || "eventbus",
+          :ssl => ENV['EVENTBUS_STOMP_SSL'] == "false" ? false : true  # True unless specified in ENV
+      }
+      ],
+      :reliable => ENV['EVENTBUS_STOMP_RELIABLE'] == "false" ? false : true,  # True unless specified in ENV
+      :initial_reconnect_delay => 1,
+      :max_reconnect_delay => 10,
+      :use_exponential_back_off => true,
+      :back_off_multiplier => 2,
+      :closed_check => ENV['EVENTBUS_STOMP_CLOSED_CHECK'] == "false" ? false : true,
+      :hbser => true,
+      :max_hbread_fails => ENV['EVENTBUS_STOMP_MAX_HBREAD_FAILS'] || 5,
+      :max_hbrlck_fails => ENV['EVENTBUS_STOMP_MAX_HBREADLOCK_FAILS'] || 5,
+      :connect_timeout => 30,
+      :connect_headers => {
+        # Set up heartbeating to keep connection alive and notice right away when it isn't.
+        # 
+        # Value is two integer millisecond interval values, comma-delimited
+        # <interval we can send>,<interval we want to receive from server>
+        # Heartbeating can be disabled entirely or from one end by using 0 for 
+        # one or both of these values in the EVENTBUS_STOMP_HEARTBEAT_INTERVALS environment variable:
+        # 0,0     Disable all heartbeating
+        # 0,1000  Receive heartbeats from broker every 1000ms, but don't send them.
+        # 1000,0  Send heartbeats from client every 1000ms, but don't look for them from broker.
+        #
+        # This is turned on by default to keep the connection alive in some environments where they can be 
+        # dropped silently. If the heartbeat fails, it will trigger the :reliable re-connect. 
+        # Best to leave it on.
+        #
+        # For heartbeats to work properly, you must be using Stomp protocol version 1.2 or higher.
+        # Tested to work with Apache Apollo. 
+        :host => Socket.gethostname,
+        :"accept-version" => ENV['EVENTBUS_STOMP_PROTOCOL_VERSION'] || "1.2",
+        :"heart-beat" => ENV['EVENTBUS_STOMP_HEARTBEAT_INTERVALS'] || '1000,1000',  
+      },
+      :logger => ENV['EVENTBUS_STOMP_DETAILED_LOGGING'] == "true" ? EventBus::Connectors::Stomp::Slogger.new : nil,
+    }
+  
+    # If we never opened one, or if it's closed and not reliable, then open a new connection.
+    if @@StompConnector_Connection.nil? || (@@StompConnector_Connection.closed? && ! @@StompConnector_Connction.reliable?)
+      EventBus.logger.info("Connecting to STOMP with options: #{opts.to_s}")
+      @@StompConnector_Connection = Stomp::Client.new(opts)
+    end
+    
+    # I'm  not sure whether we should sleep here if the connection is closed?() but is reliable?()
+    # Assuming that the connection will do the right thing and punting until I find out different.
+    
+    return @@StompConnector_Connection
   
   end
 
@@ -48,7 +90,7 @@ module StompConnectionDriver
     # and *more useful* behavior. 
     opts[:suppress_content_length] = true if opts[:suppress_content_length].nil?
     
-    puts "Stomp sending message to: #{queue_name}"
+    EventBus.logger.info "Stomp sending message to: #{queue_name}"
     
     client = get_connection
     client.publish(queue_name, content, opts)
@@ -65,7 +107,6 @@ module StompConnectionDriver
     # processes and machines. Therefore, don't lock the queue exclusively (i.e. don't kill other clients!)
     # and only take blocks of one message rather than claiming large blocks. These assumptions should become
     # configurable at some point, but for now it's not really a concern.
-    puts "Subscribing to #{queue_name}..."
 
     client.subscribe(queue_name, {"activemq.prefetchSize" => 1, "activemq.exclusive" => false}) do |msg|
       yield msg.body

data/lib/eventbus/message.rb

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'yaml'
 require 'uuid'
+require 'eventbus/common_init'
 require 'eventbus/queue'
 
 module EventBus

data/lib/eventbus/queue.rb

@@ -1,9 +1,14 @@
+require 'eventbus/common_init'
+
 module EventBus
   
   class Queue
     
-    def Queue.calc_name(base_name, application_id = "core", prod_level = ENV['PROD_LEVEL'], opts = {})
+    def Queue.calc_name(base_name, application_id, prod_level, opts = {})
 
+      application_id ||= EventBus.application_id
+      prod_level ||= EventBus.PROD_LEVEL
+      
       global_queue = opts.delete(:global_queue) || false
       system_queue = opts.delete(:system_queue) || false
       
@@ -19,7 +24,6 @@ module EventBus
         queue_name = "#{application_id}.#{queue_name}" unless system_queue
       end
 
-      puts "Calculated queue name: #{queue_name}"
       return queue_name
     end
     

data/lib/eventbus/service.rb

@@ -1,13 +1,15 @@
 require 'logger'
+require 'eventbus/common_init'
 require 'eventbus/queue'
+require 'fileutils'
 
 module EventBus
+
 class Service
   
   attr_accessor :listen_queue
   attr_accessor :system_process
   attr_accessor :global_process
-  attr_accessor :logger
   
   # Methods expected to be overridden in subclasses
   def handle_exception(message, exception)
@@ -21,10 +23,10 @@ class Service
   end
   
   
-  def initialize(application_id = nil)
-    @listen_queue = self.class.name
-    @application_id = application_id || raise("No application ID specified!")
-    @logger = Logger.new(STDOUT)
+  def initialize(application_id = EventBus.application_id)
+    @application_id = application_id
+    
+    @listen_queue = self.class.name    
     @system_process = false
     @global_process = false
     
@@ -51,7 +53,7 @@ class Service
     opts[:system_queue] = @system_process
     opts[:global_process] = @global_process
     
-    queue_name = Queue.calc_name(listen_queue, @application_id, ENV['PROD_LEVEL'], opts)
+    queue_name = Queue.calc_name(listen_queue, @application_id, EventBus.PROD_LEVEL, opts)
     
     watch_queue(queue_name) do |message|
 
@@ -77,13 +79,23 @@ class Service
     
   end
   
+  def logger
+    EventBus.logger
+  end
+  
+  def logger=(new_logger)
+    EventBus.logger = new_logger
+  end
+  
   private
   
+
+  
   def process_message_wrapper(message)
     
     begin
-      puts "Beginning processing of message in new thread:"
-      puts message
+      logger.info "Beginning processing of message in new thread:"
+      logger.info message
       
       process_message message
     rescue
@@ -93,11 +105,11 @@ class Service
   end
   
   def handle_exception_base(message, exception)
-    puts "Caught exception. Exception Text: #{exception}"
-    puts "Backtrace:"
-    exception.backtrace.map { | frame | puts "- #{frame}"}
+    logger.error "Caught exception. Exception Text: #{exception}"
+    logger.error "Backtrace:"
+    exception.backtrace.map { | frame | logger.error "- #{frame}"}
     
-    msg = EventBus::Message.new("CORE")
+    msg = EventBus::Message.new("EVENTBUS_CORE")
     msg.load(message)
     msg.set_error exception
     
@@ -106,8 +118,10 @@ class Service
     msg.send
   end
   
+  # This shouldn't be used deliberately when it can be helped (i.e. in EventBus code), 
+  # but it re-directs puts in libs to logger.
   def puts(message) 
-    @logger.info message
+    logger.info message
   end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eventbus
 version: !ruby/object:Gem::Version
-  version: '0.24'
+  version: '0.26'
   prerelease: 
 platform: ruby
 authors:
@@ -9,24 +9,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-03 00:00:00.000000000 Z
+date: 2013-07-13 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bunny
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: amqp
   requirement: !ruby/object:Gem::Requirement
@@ -81,12 +65,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/eventbus/queue.rb
-- lib/eventbus/connectors/bunny.rb
-- lib/eventbus/connectors/stomp.rb
+- lib/eventbus/service.rb
 - lib/eventbus/connectors/amqp.rb
+- lib/eventbus/connectors/stomp.rb
+- lib/eventbus/connectors/stomp/slogger.rb
+- lib/eventbus/queue.rb
 - lib/eventbus/message.rb
-- lib/eventbus/service.rb
+- lib/eventbus/common_init.rb
 homepage: http://spadea.net/?page_id=8
 licenses: []
 post_install_message: 
@@ -110,5 +95,5 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Libraries for creating EventBus services
+summary: Libraries for creating EventBus clients and services
 test_files: []

data/lib/eventbus/connectors/bunny.rb

@@ -1,71 +0,0 @@
-# BunnyConnectionDriver is the original implementation of
-# the AMQP-based broker. I am trying to make this work with
-# straight Ruby AMQP driver, but this one is the default
-# until I get that working properly.
-
-module BunnyConnectionDriver
-
-  @@BunnyConnector_Connection = nil
-
-  def connection_driver_initialize
-    puts "BunnyConnectionDriver is loaded!"
-  end 
-
-  def get_connection
-      if @@BunnyConnector_Connection.nil?
-        new_opts = {
-          :vhost => ENV["BROKER_VHOST"] || "eventbus",
-          :host => ENV["BROKER_HOST"] || "localhost",
-          :port => ENV["BROKER_PORT"] || 5672,
-          :user => ENV["BROKER_USER"] || "eventbus",
-          :pass => ENV["BROKER_PASS"] || "eventbus",
-          # :logging => opts.delete(:logging) || false,
-          #:logfile => opts.delete(:logfile) || STDOUT
-        }
-      
-        @@BunnyConnector_Connection = Bunny.new(new_opts) 
-        @@BunnyConnector_Connection.start
-      end
-      
-      return @@BunnyConnector_Connection
-  
-  end
-
-  def send_raw(content, opts = {})
-    queue_name = opts.delete(:queue_name)
-    client = get_connection
-    
-    exchange = client.exchange('eventbus', :durable => true, :persistent => true, :immediate => false)
-    
-    puts "Declaring queue: #{queue_name}"
-    q = client.queue(queue_name, :durable => true, :persistent => true, :immediate => false)
-    q.bind('eventbus', :key => queue_name)
-    
-    puts "Publishing content to #{queue_name}: #{content}"
-    exchange.publish(content, :key => queue_name)
-    puts "Done!"
-    
-  end
-  
-  def watch_queue(listen_queue)
-  
-      b = get_connection
-      
-      @logger.info "Listening on #{listen_queue}"
-      
-      exchange = b.exchange('eventbus', :durable => true, :persistent => true, :immediate => false)
-      
-      q = b.queue(listen_queue, :durable => true, :persistent => true, :immediate => false)
-      q.bind(exchange, :key => listen_queue)
-      
-      q.pop do |msg|
-        if msg[:delivery_details].nil?
-          # Gotta figure out why this is necessary. Blech.
-          sleep 0.25
-        else
-          yield msg[:payload]
-        end
-      end
-      
-  end
-end