rabbit-wq 0.2.0 → 0.3.0

data/README.md

@@ -69,3 +69,24 @@ Auto-scale will set up retries at the following intervals: 1 min, 5 mins, 15 min
 
 Once a worker has thrown an exception and no retry attempts are remaining, the worker is placed on 
 the error queue with the exception type, message and backtraces.
+
+### Logging
+
+RabbitWQ provides a work logger that is available within all workers.  You must send a reference to self
+so that the #object_id may be put into the log message.
+
+    RabbitWQ.work_logger.info( self, 'Some message' )
+
+When the RabbitWQ::Worker module is mixed into a worker you can use the logging convenience methods.  You
+do not have to provide a refrence to self in this case.
+
+    class SomeWorker < Struct.new( :some_variable )
+      include RabbitWQ::Worker
+
+      def call
+        info( 'Some message' )
+        # do some work
+      end
+    end
+
+The RabbitWQ loggers provide the following log levels: debug, info, warn, error and fatal.

data/bin/rabbit-wq

@@ -1,2 +1,3 @@
 #!/usr/bin/env ruby
 require 'rabbit_wq/cli'
+RabbitWQ::Cli.new( ARGV ).run

data/lib/ansi.rb

@@ -0,0 +1,36 @@
+class ANSI
+
+  def self.resolve_text( color, &block )
+    text = nil
+    if block_given?
+      text = block.call + reset
+    end
+    "\e[#{chart[color.to_sym]}m#{text}"
+  end
+
+  def self.reset
+    "\e[0m"
+  end
+
+  def self.chart
+    {
+      black: 30,
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      magenta: 35,
+      cyan: 36,
+      white: 37
+    }
+  end
+
+  chart.keys.each do |color|
+
+    define_singleton_method color do |&block|
+      resolve_text color, &block
+    end
+
+  end
+
+end

data/lib/rabbit_wq.rb

@@ -1,16 +1,12 @@
-require "rabbit_wq/version"
+require 'ansi'
+require 'rabbit_wq/version'
 
 module RabbitWQ
 
-  APP_ID                = "rabbit-wq"
-  APP_NAME              = "Rabbit Work Queue"
-  DELAY_QUEUE_PREFIX    = "work-delay" # TODO: Make this configurable (from ENV, or file?)
-  DELAY_EXCHANGE_PREFIX = "work-delay" # TODO: Make this configurable (from ENV, or file?)
-  ERROR_QUEUE           = "work-error"
-  INT                   = "INT"
-  QUEUE                 = "work" # TODO: Make this configurable (from ENV, or file?)
+  APP_ID                = 'rabbit-wq'
+  APP_NAME              = 'Rabbit Work Queue'
+  INT                   = 'INT'
   VERSION_COPYRIGHT     = "v#{VERSION} \u00A9#{Time.now.year}"
-  WORK_EXCHANGE         = "work" # TODO: Make this configurable (from ENV, or file?)
 
   autoload :Command,        'rabbit_wq/command'
   autoload :Configuration,  'rabbit_wq/configuration'
@@ -18,20 +14,27 @@ module RabbitWQ
   autoload :Queues,         'rabbit_wq/queues'
   autoload :MessageHandler, 'rabbit_wq/message_handler'
   autoload :Server,         'rabbit_wq/server'
+  autoload :ServerDaemon,   'rabbit_wq/server_daemon'
   autoload :ServerLogging,  'rabbit_wq/server_logging'
   autoload :Work,           'rabbit_wq/work'
   autoload :Worker,         'rabbit_wq/worker'
+  autoload :WorkLogger,     'rabbit_wq/work_logger'
 
   def self.configuration
     @configuration ||= Configuration.new
   end
 
+  def self.configuration=( configuration )
+    @configuration = configuration
+  end
+
   def self.configure
     yield( configuration ) if block_given?
   end
 
   class << self
-    attr_accessor :logger
+    attr_accessor :logger,
+                  :work_logger
   end
 
 end

data/lib/rabbit_wq/cli.rb

@@ -1,10 +1,13 @@
-require 'rubygems'
+ require 'rubygems'
 require 'rabbit_wq'
 require 'trollop'
 require 'yell'
 
 module RabbitWQ
-  module Cli
+  class Cli
+
+    attr_reader :cmd,
+                :options
 
     SUB_COMMANDS = %w(
       restart
@@ -13,95 +16,114 @@ module RabbitWQ
       stop
     )
 
-    def self.start( options )
+    DEFAULT_CONFIG_PATH = "/etc/#{APP_ID}/#{APP_ID}.conf"
+    DEFAULT_LOG_PATH    = "/var/log/#{APP_ID}/#{APP_ID}.log"
+    DEFAULT_PID_PATH    = "/var/run/#{APP_ID}/#{APP_ID}.pid"
+
+    DEFAULT_NUMBER_OF_THREADS = 1
+
+    def initialize( args )
+      Trollop::options do
+        version VERSION_COPYRIGHT
+        banner <<-EOS
+#{APP_NAME} #{VERSION_COPYRIGHT}
+
+Usage:
+  #{APP_ID} [command] [options]
+
+  commands:
+#{SUB_COMMANDS.map { |sub_cmd| "    #{sub_cmd}" }.join( "\n" )}
+
+  (For help with a command: #{APP_ID} [command] -h)
+
+options:
+      EOS
+        stop_on SUB_COMMANDS
+      end
+
+      # Get the sub-command and its options
+      #
+      @cmd = ARGV.shift || ''
+      @options = case( cmd )
+        when "restart"
+          Trollop::options do
+            opt :config, "The path for the config file", :type => String, :short => '-c', :default => DEFAULT_CONFIG_PATH
+            opt :log_level, "The log level", :type => String, :default => 'info'
+            opt :log, "The path for the log file", :type => String, :short => '-l', :default => DEFAULT_LOG_PATH
+            opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
+            opt :threads, "The number of threads", :type => Integer, :default => DEFAULT_NUMBER_OF_THREADS, :short => '-t'
+          end
+        when "start"
+          Trollop::options do
+            opt :config, "The path for the config file", :type => String, :short => '-c', :default => DEFAULT_CONFIG_PATH
+            opt :interactive, "Execute the server in interactive mode", :short => '-i'
+            opt :log_level, "The log level", :type => String, :default => 'info'
+            opt :log, "The path for the log file", :type => String, :short => '-l', :default => DEFAULT_LOG_PATH
+            opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
+            opt :threads, "The number of threads", :type => Integer, :default => DEFAULT_NUMBER_OF_THREADS, :short => '-t'
+          end
+        when "status"
+          Trollop::options do
+            opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
+          end
+        when "stop"
+          Trollop::options do
+            opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
+          end
+        else
+          Trollop::die "unknown command #{cmd.inspect}"
+        end
+
+      if cmd == 'start'
+        unless options[:interactive]
+          Trollop::die( :config, "is required when running as daemon" ) unless options[:config]
+          Trollop::die( :log, "is required when running as daemon" ) unless options[:log]
+          Trollop::die( :pid, "is required when running as daemon" ) unless options[:pid]
+        end
+      end
+
+      if %w(restart status stop).include?( cmd )
+        Trollop::die( :pid, "is required" ) unless options[:pid]
+      end
+    end
+
+    def run
+      send( cmd )
+    end
+
+  protected
+
+    def start
       if options[:interactive]
-        start_interactive options
+        start_interactive
       else
-        start_daemon options
+        start_daemon
       end
     end
 
-    def self.start_interactive( options )
-      server = RabbitWQ::Server.new( options.merge( log: nil ) )
+    def start_interactive
+      server = RabbitWQ::Server.new( options.merge( log: nil ))
       server.start
     end
 
-    def self.start_daemon( options )
+    def start_daemon
       server = RabbitWQ::ServerDaemon.new( options )
       server.start
     end
 
-  end
-end
-
-DEFAULT_LOG_PATH = "/var/log/rabbit-wq/#{RabbitWQ::APP_ID}.log"
-DEFAULT_PID_PATH = "/var/run/rabbit-wq/#{RabbitWQ::APP_ID}.pid"
-
-global_opts = Trollop::options do
-  version RabbitWQ::VERSION_COPYRIGHT
-  banner <<-EOS
-#{RabbitWQ::APP_NAME} #{RabbitWQ::VERSION_COPYRIGHT}
-
-Usage:
-  #{RabbitWQ::APP_ID} [command] [options]
-
-  commands:
-#{RabbitWQ::Cli::SUB_COMMANDS.map { |cmd| "    #{cmd}" }.join( "\n" )}
-
-  (For help with a command: #{RabbitWQ::APP_ID} [command] -h)
+    def stop
+      server = RabbitWQ::ServerDaemon.new( options )
+      server.stop
+    end
 
-options:
-EOS
-  stop_on RabbitWQ::Cli::SUB_COMMANDS
-end
+    def restart
+      stop
+      start_daemon
+    end
 
-# Get the sub-command and its options
-#
-cmd = ARGV.shift || ''
-cmd_opts = case( cmd )
-  #when "restart"
-    #Trollop::options do
-      #opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
-    #end
-  when "start"
-    Trollop::options do
-      opt :interactive, "Execute the server in interactive mode", :short => '-i'
-      opt :log_level, "The log level", :type => String, :default => 'info'
-      opt :log, "The path for the log file", :type => String, :short => '-l', :default => DEFAULT_LOG_PATH
-      opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
+    def status
+      RabbitWQ::ServerDaemon.new( options ).status
     end
-  #when "status"
-    #Trollop::options do
-      #opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
-    #end
-  #when "stop"
-    #Trollop::options do
-      #opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
-    #end
-  else
-    Trollop::die "unknown command #{cmd.inspect}"
-  end
 
-if cmd == 'start'
-  unless cmd_opts[:interactive]
-    Trollop::die( :log, "is required when running as daemon" ) unless cmd_opts[:log]
-    Trollop::die( :pid, "is required when running as daemon" ) unless cmd_opts[:pid]
   end
 end
-
-if %w(restart status stop).include?( cmd )
-  Trollop::die( :pid, "is required" ) unless cmd_opts[:pid]
-end
-
-# Execute the command
-#
-case cmd
-  when "restart"
-    RabbitWQ::ServerDaemon.new( cmd_opts ).restart
-  when "start"
-    RabbitWQ::Cli.start cmd_opts
-  when "status"
-    RabbitWQ::ServerDaemon.new( cmd_opts ).status
-  when "stop"
-    RabbitWQ::ServerDaemon.new( cmd_opts ).stop
-  end

data/lib/rabbit_wq/configuration.rb

@@ -1,13 +1,67 @@
+require 'oj'
+
 module RabbitWQ
   class Configuration
 
-    #def authentication_token
-      #@authentication_token
-    #end
+    def self.attributes
+      %w(
+        delayed_exchange_prefix
+        delayed_queue_prefix
+        environment_file_path
+        env
+        error_queue
+        time_zone
+        work_exchange
+        work_queue
+      )
+    end
+
+    attr_accessor( *attributes )
+
+    def self.from_file( file_path )
+      options = Oj.load( File.read( file_path ))
+      RabbitWQ.configuration = Configuration.new
+
+      attributes.each do |c|
+        if options[c]
+          RabbitWQ.configuration.send( :"#{c}=", options[c] )
+        end
+      end
+    end
+
+    def delayed_exchange_prefix
+      @delayed_exchange_prefix || 'work-delay'
+    end
+
+    def delayed_queue_prefix
+      @delayed_queue_prefix || 'work-delay'
+    end
+
+    def env
+      @env || 'production'
+    end
+
+    def error_queue
+      @error_queue || 'work-error'
+    end
+
+    def time_zone
+      @time_zone || 'UTC'
+    end
+
+    def work_exchange
+      @work_exchange || 'work'
+    end
+
+    def work_logger( log_level, path )
+      return if RabbitWQ.work_logger
+
+      RabbitWQ.work_logger = WorkLogger.new( log_level, path )
+    end
 
-    #def authentication_token=( authentication_token )
-      #@authentication_token = authentication_token
-    #end
+    def work_queue
+      @work_queue || 'work'
+    end
 
   end
 end

data/lib/rabbit_wq/logging.rb

@@ -12,11 +12,19 @@ module RabbitWQ
     ).each do |level|
 
       define_method level do |*messages|
+        return unless RabbitWQ.logger
         messages.each do |message|
           RabbitWQ.logger.send level, message
         end
       end
 
+      define_method "worker_#{level}" do |worker, *messages|
+        return unless RabbitWQ.work_logger
+        messages.each do |message|
+          RabbitWQ.work_logger.send level, worker, message
+        end
+      end
+
     end
 
   end

data/lib/rabbit_wq/message_handler.rb

@@ -11,6 +11,8 @@ module RabbitWQ
     REQUEUE = true
 
     def call( options )
+      Time.zone = RabbitWQ.configuration.time_zone
+
       channel       = options[:channel]
       delivery_info = options[:delivery_info]
       metadata      = options[:metadata]
@@ -23,15 +25,18 @@ module RabbitWQ
       worker.call
       channel.ack delivery_info.delivery_tag
     rescue => e
-      debug e.message
-      handle_error( e, channel, delivery_info, payload, metadata )
+      handle_error( worker, e, channel, delivery_info, payload, metadata )
     end
 
   protected
 
-    def handle_error( e, channel, delivery_info, payload, metadata )
+    def handle_error( worker, e, channel, delivery_info, payload, metadata )
       headers = metadata[:headers]
 
+      error_metadata = { type: e.class.name,
+                         message: e.message,
+                         backtrace: e.backtrace }
+
       if headers['retry']
         attempt = headers.fetch( 'attempt', 1 ).to_i
 
@@ -42,15 +47,15 @@ module RabbitWQ
             retry_delay = retry_delays( attempt )
           end
 
-          Work.enqueue_payload( payload, headers.merge( delay: retry_delay, attempt: attempt + 1 ))
+          Work.enqueue_payload( payload, headers.merge( delay: retry_delay, attempt: attempt + 1 ).
+                                                 merge( error: error_metadata ))
           channel.nack delivery_info.delivery_tag
           return
         end
       end
 
-      Work.enqueue_error_payload( payload, error: { type: e.class.name,
-                                                    message: e.message,
-                                                    backtrace: e.backtrace } )
+      Work.enqueue_error_payload( payload, error: error_metadata )
+      worker_error( worker, error_metadata.inspect )
       channel.nack delivery_info.delivery_tag
       return
     end

data/lib/rabbit_wq/queues.rb

@@ -10,15 +10,17 @@ module RabbitWQ
     end
 
     def channel
-      @channel ||= mq.create_channel
+      @channel ||= mq.create_channel.tap do |c|
+        c.prefetch( 10 )
+      end
     end
 
     #def work_exchange
-      #@work_exchange ||= channel.direct( WORK_EXCHANGE, durable: true )
+      #@work_exchange ||= channel.direct( RabbitWQ.configuration.work_exchange, durable: true )
     #end
 
     #def work_queue
-      #@work_queue ||= channel.queue( QUEUE,
+      #@work_queue ||= channel.queue( RabbitWQ.configuration.work_queue,
                                      #durable: true ).
                               #bind( work_exchange )
     #end

data/lib/rabbit_wq/server.rb

@@ -1,4 +1,5 @@
 require 'bunny'
+require 'celluloid/autostart'
 
 module RabbitWQ
   class Server
@@ -13,7 +14,6 @@ module RabbitWQ
 
     def initialize( options )
       @options = options
-      options[:pool_size] ||= 2 # TODO move to external configuration
 
       configure_server
     end
@@ -35,32 +35,73 @@ module RabbitWQ
     end
 
     def work_exchange
-      @work_exchange ||= channel.direct( WORK_EXCHANGE, durable: true )
+      @work_exchange ||= channel.direct( config.work_exchange, durable: true )
     end
 
     def work_queue
-      @work_queue ||= channel.queue( QUEUE,
+      @work_queue ||= channel.queue( config.work_queue,
                                      durable: true ).
                               bind( work_exchange )
     end
 
     def pool
-      @pool ||= MessageHandler.pool( size: options[:pool_size] )
+      @pool ||= MessageHandler.pool( size: options[:threads] )
     end
 
     def run
+      if options[:threads] == 1
+        Celluloid::Actor[:message_handler] = MessageHandler.new
+      end
+
       @work_consumer = work_queue.subscribe( manual_ack: true ) do |delivery_info, metadata, payload|
         info "LISTENER RECEIVED #{payload}"
 
-        pool.async.call( payload: payload,
-                         delivery_info: delivery_info,
-                         metadata: metadata,
-                         channel: channel )
+        if options[:threads] > 1
+          pool.async.call( payload: payload,
+                           delivery_info: delivery_info,
+                           metadata: metadata,
+                           channel: channel )
+        else
+          message_handler.call( payload: payload,
+                                delivery_info: delivery_info,
+                                metadata: metadata,
+                                channel: channel )
+        end
       end
     end
 
+    def message_handler
+      Celluloid::Actor[:message_handler]
+    end
+
+    def config
+      RabbitWQ.configuration
+    end
+
     def configure_server
+      load_configuration
       initialize_loggers
+      load_environment
+    end
+
+    def load_configuration
+      if File.exists?( options[:config] )
+        options[:config_loaded] = true
+        Configuration.from_file( options[:config] )
+      end
+    end
+
+    def load_environment
+      unless environment_file_path &&
+        File.exists?( environment_file_path )
+        return
+      end
+
+      require environment_file_path
+    end
+
+    def environment_file_path
+      RabbitWQ.configuration.environment_file_path
     end
 
   end

data/lib/rabbit_wq/server_daemon.rb

@@ -0,0 +1,144 @@
+require 'rubygems'
+require 'fileutils'
+require 'timeout'
+
+module RabbitWQ
+  class ServerDaemon
+
+    attr_reader :name,
+                :options,
+                :pid,
+                :pid_path,
+                :script,
+                :timeout
+
+    def initialize( options )
+      @options  = options
+      @name     = options[:name] || APP_NAME
+      @pid_path = options[:pid] || '.'
+      @pid      = get_pid
+      @timeout  = options[:timeout] || 10
+    end
+
+    def start
+      abort "Process already running!" if process_exists?
+
+      pid = fork do
+        exit if fork
+        Process.setsid
+        exit if fork
+        store_pid( Process.pid )
+        File.umask 0000
+        redirect_output!
+        run
+      end
+
+      Process.waitpid( pid )
+    end
+
+    def run
+      Server.new( options ).start
+    end
+
+    def stop
+      kill_process
+      FileUtils.rm pid_path
+    end
+
+    def status
+      out = "#{APP_NAME} "
+      if process_exists?
+        out << "process running with PID: #{pid}"
+      else
+        out << "process does not exist"
+      end
+      $stdout.puts out
+    end
+
+   protected
+
+    #def create_pid( pid )
+    def store_pid( pid )
+      File.open( pid_path, 'w' ) do |f|
+        f.puts pid
+      end
+    rescue => e
+      $stderr.puts "Unable to open #{pid_path} for writing:\n\t(#{e.class}) #{e.message}"
+      exit!
+    end
+
+    def get_pid
+      return nil unless File.exists?( pid_path )
+      pid = nil
+      File.open( @pid_path, 'r' ) do |f|
+        pid = f.readline.to_s.gsub( /[^0-9]/, '' )
+      end
+      pid.to_i
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def remove_pidfile
+      File.unlink( pid_path )
+    rescue => e
+      $stderr.puts "Unable to unlink #{pid_path}:\n\t(#{e.class}) #{e.message}"
+      exit
+    end
+
+    def kill_process
+      abort "#{APP_NAME} process is not running" unless process_exists?
+      $stdout.write "Attempting to stop #{APP_NAME} process #{pid}..."
+      Process.kill INT, pid
+      iteration_num = 0
+      while process_exists? && iteration_num < 10
+        sleep 1
+        $stdout.write "."
+        iteration_num += 1
+      end
+      if process_exists?
+        $stderr.puts "\nFailed to stop #{APP_NAME} process #{pid}"
+      else
+        $stdout.puts "\nSuccessfuly stopped #{APP_NAME} process #{pid}"
+      end
+    rescue Errno::EPERM
+      $stderr.puts "No permission to query #{pid}!";
+    end
+
+    def process_exists?
+      return false unless pid
+      Process.kill( 0, pid )
+      true
+    rescue Errno::ESRCH, TypeError # "PID is NOT running or is zombied
+      false
+    rescue Errno::EPERM
+      $stderr.puts "No permission to query #{pid}!";
+      false
+    end
+
+    def redirect_output!
+      if log_path = options[:log]
+        #puts "redirecting to log"
+        # if the log directory doesn't exist, create it
+        FileUtils.mkdir_p( File.dirname( log_path ), :mode => 0755 )
+        # touch the log file to create it
+        FileUtils.touch( log_path )
+        # Set permissions on the log file
+        File.chmod( 0644, log_path )
+        # Reopen $stdout (NOT +STDOUT+) to start writing to the log file
+        $stdout.reopen( log_path, 'a' )
+        # Redirect $stderr to $stdout
+        $stderr.reopen $stdout
+        $stdout.sync = true
+      else
+        #puts "redirecting to /dev/null"
+        # We're not bothering to sync if we're dumping to /dev/null
+        # because /dev/null doesn't care about buffered output
+        $stdin.reopen '/dev/null'
+        $stdout.reopen '/dev/null', 'a'
+        $stderr.reopen $stdout
+      end
+      log_path = options[:log] ? options[:log] : '/dev/null'
+    end
+
+  end
+end

data/lib/rabbit_wq/server_logging.rb

@@ -8,23 +8,16 @@ module RabbitWQ
   protected
 
     def initialize_loggers
-      if options[:interactive] || options[:log].nil? || options[:log].empty?
-        RabbitWQ.logger = Yell.new do |l|
-          l.level = log_level
-          l.adapter $stdout, :level => [:debug, :info, :warn]
-          l.adapter $stderr, :level => [:error, :fatal]
-        end
-      else
-        RabbitWQ.logger = Yell.new do |l|
-          l.level = log_level
-          l.adapter :file, options[:log]
-        end
-
-        Celluloid.logger = Yell.new do |l|
-          l.level = :info
-          l.adapter :file, File.join( File.dirname( options[:log] ), "#{APP_ID}-celluloid.log" )
-        end
+      RabbitWQ.logger = Yell.new do |l|
+        l.level = log_level
+        l.adapter $stdout, :level => [:debug, :info, :warn]
+        l.adapter $stderr, :level => [:error, :fatal]
       end
+
+      #Celluloid.logger = Yell.new do |l|
+        #l.level = :info
+        #l.adapter :file, File.join( File.dirname( options[:log] ), "#{APP_ID}-celluloid.log" )
+      #end
     end
 
     def log_startup
@@ -37,12 +30,16 @@ module RabbitWQ
       [
         "",
         "***",
-        "* #{RabbitWQ::APP_NAME} started",
+        "* #{APP_NAME} started",
         "*",
         "* #{VERSION_COPYRIGHT}",
+        "*",
+        "* Configuration:",
+        (options[:config_loaded] ? "*   file: #{options[:config]}" : nil),
+        RabbitWQ::Configuration.attributes.map { |a| "*   #{a}: #{RabbitWQ.configuration.send( a )}" },
+        "*",
         "***",
-        "",
-      ]
+      ].flatten.reject( &:nil? )
     end
 
     def log_level

data/lib/rabbit_wq/version.rb

@@ -1,3 +1,3 @@
 module RabbitWQ
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/rabbit_wq/work.rb

@@ -12,37 +12,80 @@ module RabbitWQ
       delay = options.delete( :delay )
       delay = nil if delay && delay < 5000
 
-      mq = ::Bunny.new.tap { |bunny| bunny.start }
-      channel = mq.create_channel
-
       if delay
-        delay_x = channel.direct( "#{DELAY_EXCHANGE_PREFIX}-#{delay}ms", durable: true )
-        work_x  = channel.direct( WORK_EXCHANGE, durable: true )
+        with_channel do |channel|
+          delay_x = channel.direct( "#{RabbitWQ.configuration.delayed_exchange_prefix}-#{delay}ms", durable: true )
+          work_x  = channel.direct( RabbitWQ.configuration.work_exchange, durable: true )
 
-        channel.queue( "#{DELAY_QUEUE_PREFIX}-#{delay}ms",
-                       durable: true,
-                       arguments: { "x-dead-letter-exchange" => work_x.name,
-                                    "x-message-ttl" => delay } ).
-                bind( delay_x )
+          channel.queue( "#{RabbitWQ.configuration.delayed_queue_prefix}-#{delay}ms",
+                         durable: true,
+                         arguments: { "x-dead-letter-exchange" => work_x.name,
+                                      "x-message-ttl" => delay } ).
+                  bind( delay_x )
+
+          delay_x.publish( payload, durable: true,
+                                    content_type: 'application/yaml',
+                                    headers: options )
+        end
 
-        delay_x.publish( payload, durable: true,
-                                  headers: options )
         return
       end
 
-      work_q = channel.queue( QUEUE, durable: true )
-      work_q.publish( payload, durable: true,
-                               headers: options )
+      with_work_exchange do |work_x, work_q|
+        work_x.publish( payload, durable: true,
+                                 content_type: 'application/yaml',
+                                 headers: options )
+      end
     end
 
     def self.enqueue_error_payload( payload, options={} )
-      mq = ::Bunny.new.tap { |bunny| bunny.start }
-      channel = mq.create_channel
+      with_channel do |channel|
+        error_q = channel.queue( RabbitWQ.configuration.error_queue, durable: true )
+        error_q.publish( payload, durable: true,
+                                  content_type: 'application/yaml',
+                                  headers: options )
+      end
+    end
+
+    def self.with_work_exchange
+      with_channel do |channel|
+        begin
+          exchange = channel.direct( RabbitWQ.configuration.work_exchange, durable: true )
+          channel.queue( RabbitWQ.configuration.work_queue, durable: true ).tap do |q|
+            q.bind( exchange )
+            yield exchange, q
+          end
+        ensure
+        end
+      end
+    end
 
-      error_q = channel.queue( ERROR_QUEUE, durable: true )
-      error_q.publish( payload, durable: true,
-                                headers: options )
+    def self.with_channel
+      Bunny.new.tap do |b|
+        b.start
+        begin
+          b.create_channel.tap do |c|
+            yield c
+          end
+        ensure
+          b.stop
+        end
+      end
     end
 
+    #def self.with_exchange
+      #Bunny.new.tap do |b|
+        #b.start
+        #begin
+          #b.create_channel.tap do |c|
+            #queue = c.queue( 'replication', durable: true )
+            #yield c.default_exchange, queue.name
+          #end
+        #ensure
+          #b.stop
+        #end
+      #end
+    #end
+
   end
 end

data/lib/rabbit_wq/work_logger.rb

@@ -0,0 +1,47 @@
+require 'ansi'
+require 'yell'
+
+module RabbitWQ
+  class WorkLogger
+
+    def initialize( log_level, path )
+      @logger = Yell.new do |l|
+                  l.level = log_level
+                  l.adapter :file, path
+                end
+    end
+
+    %w(
+      debug
+      error
+      fatal
+      info
+      warn
+    ).each do |level|
+
+      define_method level do |*args|
+        worker, message = nil, nil
+        if args.size > 1
+          worker, message = *args
+        else
+          message = args.first
+        end
+
+        if worker
+          logger.send( level, "[" + ANSI.cyan { "#{worker.class.name}:#{worker.object_id}" } + "] #{message}" )
+        else
+          logger.send( level, message )
+        end
+      end
+
+    end
+
+    def level=( l )
+    end
+
+  protected
+
+    attr_reader :logger
+
+  end
+end

data/lib/rabbit_wq/worker.rb

@@ -1,6 +1,27 @@
 module RabbitWQ
   module Worker
 
+    def self.included( other_module )
+      other_module.class_eval do
+        %w(
+          debug
+          error
+          fatal
+          info
+          warn
+        ).each do |level|
+
+          define_method level do |*messages|
+            return unless RabbitWQ.logger
+            messages.each do |message|
+              RabbitWQ.work_logger.send level, self, message
+            end
+          end
+
+        end
+      end
+    end
+
     def work( options={} )
       RabbitWQ::Work.enqueue( self, options )
       self

data/rabbit-wq.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "bunny", "~> 1"
   spec.add_dependency "celluloid", "~> 0"
+  spec.add_dependency "oj", "~> 2"
   spec.add_dependency "trollop", "~> 2"
   spec.add_dependency "yell", "~> 1"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rabbit-wq
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-29 00:00:00.000000000 Z
+date: 2013-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,6 +75,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: trollop
   requirement: !ruby/object:Gem::Requirement
@@ -118,11 +134,11 @@ files:
 - .gitignore
 - .ruby-gemset
 - .ruby-version
-- Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/rabbit-wq
+- lib/ansi.rb
 - lib/rabbit-wq.rb
 - lib/rabbit_wq.rb
 - lib/rabbit_wq/cli.rb
@@ -132,9 +148,11 @@ files:
 - lib/rabbit_wq/message_handler.rb
 - lib/rabbit_wq/queues.rb
 - lib/rabbit_wq/server.rb
+- lib/rabbit_wq/server_daemon.rb
 - lib/rabbit_wq/server_logging.rb
 - lib/rabbit_wq/version.rb
 - lib/rabbit_wq/work.rb
+- lib/rabbit_wq/work_logger.rb
 - lib/rabbit_wq/worker.rb
 - rabbit-wq.gemspec
 homepage: ''
@@ -150,18 +168,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1504652558847638442
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1504652558847638442
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -169,3 +181,4 @@ signing_key:
 specification_version: 3
 summary: A work queue built on RabbitMQ and Celluloid.
 test_files: []
+has_rdoc: 

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in brer_rabbit.gemspec
-gemspec