droid 0.9.5 → 1.0.0

data/.gitignore

@@ -0,0 +1,2 @@
+*.swp
+pkg/

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'rake'
+
+begin
+	require 'jeweler'
+	Jeweler::Tasks.new do |gem|
+		gem.name = "droid"
+		gem.summary = %Q{AMQP Wrapper Library}
+		gem.description = %Q{Easy to use AMQP Library with constructs for typical usage patterns}
+		gem.email = "ricardo@heroku.com"
+		gem.homepage = "http://heroku.com"
+		gem.authors = ["Ricardo Chimal, Jr."]
+
+		gem.add_development_dependency "baconmocha", ">= 0"
+
+		# gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+		gem.add_dependency 'json_pure', '>= 1.2.0'
+		gem.add_dependency 'rest-client', '>= 1.2.0'
+		gem.add_dependency 'amqp', '0.6.7'
+		gem.add_dependency 'bunny', '~> 0.6.0'
+		gem.add_dependency 'SystemTimer', '~> 1.2.0'
+		gem.add_dependency 'eventmachine_httpserver', '0.2.0'
+	end
+	Jeweler::GemcutterTasks.new
+rescue LoadError
+	puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:spec) do |spec|
+	spec.libs << 'lib' << 'spec'
+	spec.pattern = 'spec/**/*_spec.rb'
+	spec.verbose = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/bin/bleedq

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'pp'
+require 'droid/sync'
+
+queue_name = ARGV.shift or fail "usage: #{File.basename($0)} <queue>"
+
+b = Droid.bunny
+q = b.queue(queue_name)
+
+puts "Bleeding queue #{queue_name}"
+
+while ((msg = q.pop)[:payload] != :queue_empty) do
+	pp msg
+end
+
+puts "done."

data/droid.gemspec

@@ -0,0 +1,100 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{droid}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ricardo Chimal, Jr."]
+  s.date = %q{2010-10-21}
+  s.default_executable = %q{bleedq}
+  s.description = %q{Easy to use AMQP Library with constructs for typical usage patterns}
+  s.email = %q{ricardo@heroku.com}
+  s.executables = ["bleedq"]
+  s.files = [
+    ".gitignore",
+     "Rakefile",
+     "VERSION",
+     "bin/bleedq",
+     "droid.gemspec",
+     "examples/async_reply.rb",
+     "examples/heroku_async_reply.rb",
+     "examples/sync.rb",
+     "examples/worker.rb",
+     "lib/droid.rb",
+     "lib/droid/em.rb",
+     "lib/droid/heroku.rb",
+     "lib/droid/heroku/local_stats.rb",
+     "lib/droid/heroku/logger_client.rb",
+     "lib/droid/heroku/memcache_cluster.rb",
+     "lib/droid/heroku/stats.rb",
+     "lib/droid/json_server.rb",
+     "lib/droid/monkey.rb",
+     "lib/droid/publish.rb",
+     "lib/droid/queue.rb",
+     "lib/droid/request.rb",
+     "lib/droid/sync.rb",
+     "lib/droid/utilization.rb",
+     "lib/droid/utils.rb",
+     "lib/heroku_droid.rb",
+     "lib/local_stats.rb",
+     "lib/memcache_cluster.rb",
+     "lib/stats.rb",
+     "spec/publish_spec.rb",
+     "spec/response_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/utils_spec.rb",
+     "spec/wait_for_port_spec.rb"
+  ]
+  s.homepage = %q{http://heroku.com}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{AMQP Wrapper Library}
+  s.test_files = [
+    "spec/publish_spec.rb",
+     "spec/response_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/utils_spec.rb",
+     "spec/wait_for_port_spec.rb",
+     "examples/async_reply.rb",
+     "examples/heroku_async_reply.rb",
+     "examples/sync.rb",
+     "examples/worker.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<baconmocha>, [">= 0"])
+      s.add_runtime_dependency(%q<json_pure>, [">= 1.2.0"])
+      s.add_runtime_dependency(%q<rest-client>, [">= 1.2.0"])
+      s.add_runtime_dependency(%q<amqp>, ["= 0.6.7"])
+      s.add_runtime_dependency(%q<bunny>, ["~> 0.6.0"])
+      s.add_runtime_dependency(%q<SystemTimer>, ["~> 1.2.0"])
+      s.add_runtime_dependency(%q<eventmachine_httpserver>, ["= 0.2.0"])
+    else
+      s.add_dependency(%q<baconmocha>, [">= 0"])
+      s.add_dependency(%q<json_pure>, [">= 1.2.0"])
+      s.add_dependency(%q<rest-client>, [">= 1.2.0"])
+      s.add_dependency(%q<amqp>, ["= 0.6.7"])
+      s.add_dependency(%q<bunny>, ["~> 0.6.0"])
+      s.add_dependency(%q<SystemTimer>, ["~> 1.2.0"])
+      s.add_dependency(%q<eventmachine_httpserver>, ["= 0.2.0"])
+    end
+  else
+    s.add_dependency(%q<baconmocha>, [">= 0"])
+    s.add_dependency(%q<json_pure>, [">= 1.2.0"])
+    s.add_dependency(%q<rest-client>, [">= 1.2.0"])
+    s.add_dependency(%q<amqp>, ["= 0.6.7"])
+    s.add_dependency(%q<bunny>, ["~> 0.6.0"])
+    s.add_dependency(%q<SystemTimer>, ["~> 1.2.0"])
+    s.add_dependency(%q<eventmachine_httpserver>, ["= 0.2.0"])
+  end
+end
+

data/examples/async_reply.rb

@@ -0,0 +1,25 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'droid'
+
+def log
+	Droid.log
+end
+
+Droid.new('Example Reply') do |droid|
+	droid.worker('example.target').subscribe do |req|
+		log.debug "headers: #{req.header.headers.inspect}"
+		log.debug "event_hash should be woot -> #{req.droid_headers[:event_hash]}"
+		req.reply(:target_received_at => Time.now.to_i)
+		req.ack
+	end
+
+	droid.listener('example.check.target').subscribe do |req|
+		req.publish('example.target', { :checking => Time.now.to_i }) do |req2|
+			log.debug "event_hash should be woot -> #{req2.droid_headers[:event_hash]}"
+			log.info "We're done checking!"
+			Droid.stop_safe
+		end
+	end
+
+	droid.timer(2) {  Droid.publish('example.check.target', {:sent_at => Time.now.to_i}, {:event_hash => "woot"}) }
+end

data/examples/heroku_async_reply.rb

@@ -0,0 +1,22 @@
+$:.unshift File.dirname(__FILE__) + '/../lib/'
+require 'heroku_droid'
+
+def log
+	Droid.log
+end
+
+HerokuDroid.new('Example Reply') do |droid|
+	droid.worker('example.target').subscribe do |req|
+		req.reply(:target_received_at => Time.now.to_i)
+		req.ack
+	end
+
+	droid.listener('example.check.target').subscribe do |req|
+		req.publish('example.target', { :checking => Time.now.to_i }) do |req2|
+			log.info "We're done checking!"
+			Droid.stop_safe
+		end
+	end
+
+	EM.add_timer(2) { Droid.publish('example.check.target', :sent_at => Time.now.to_i ) }
+end

data/examples/sync.rb

@@ -0,0 +1,32 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'droid'
+
+def log
+	Droid.log
+end
+
+if ARGV[0] == 'listen'
+	Droid.new('Example Worker') do |droid|
+		droid.worker('example.bunny.worker').subscribe do |req|
+			req.ack
+			log.info "Work done, replying..."
+			req.reply(:t => Time.now.to_i)
+		end
+
+		droid.listener('example.bunny.listener').subscribe do |req|
+			log.info "I heard #{req['t']}"
+		end
+	end
+	exit(0)
+end
+
+
+require 'droid/sync'
+
+log.info "publishing to example.bunny.listener.."
+Droid.publish('example.bunny.listener', :t => Time.now.to_i)
+
+log.info "publishing to example.bunner.worker, expecting a result..."
+res = Droid.call('example.bunny.worker', :t => Time.now.to_i)
+log.info "received #{res.inspect}"
+

data/examples/worker.rb

@@ -0,0 +1,58 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'droid'
+
+def log
+	Droid.log
+end
+
+@gum_chews = 0
+@toffee_chews = 0
+
+Droid.new('Example Worker') do |droid|
+
+	# auto acks the message
+	@gum = droid.worker('example.chew.gum').subscribe do |req|
+		log.info "flavor: #{req['flavor']}, packs: #{req['packs']}"
+		log.info req.msg.inspect
+		log.info req.droid_headers
+
+		@gum_chews += 1
+	end
+
+	# explicit ack
+	@toffee = droid.worker('example.chew.toffee').subscribe(:auto_ack => false) do |req|
+		log.info "flavor: #{req['flavor']}"
+		log.info req.msg.inspect
+		log.info req.droid_headers
+
+		req.ack
+
+		@toffee_chews += 1
+	end
+
+	droid.periodic_timer(2) do
+		log.debug "checking gum & toffee chews"
+
+		if @gum_chews == 3 && @gum
+			@gum.destroy
+			@gum = nil
+		end
+
+		if @toffee_chews == 2 && @toffee
+			@toffee.destroy
+			@toffee = nil
+		end
+
+		if @toffee.nil? && @gum.nil?
+			Droid.stop_safe
+		end
+	end
+
+	droid.timer(2) do
+		droid.publish('example.chew.gum', :flavor => 'spearmint', :packs => 2)
+		droid.publish('example.chew.gum', :flavor => 'bubblegum', :packs => 3)
+		droid.publish('example.chew.gum', :flavor => 'peppermint', :packs => 1)
+		droid.publish('example.chew.toffee', :flavor => 'caramel')
+		droid.publish('example.chew.toffee', :flavor => 'licorish')
+	end
+end

data/lib/droid.rb

@@ -1,529 +1,141 @@
-require 'socket'
-require 'digest/md5'
-require File.dirname(__FILE__) + '/../vendor/logger_client/init'
-
-$:.unshift *Dir[File.dirname(__FILE__) + '/../vendor/*/lib']
-require 'json'
+require 'uri'
+require 'amqp'
 require 'mq'
-require 'time'
-require 'bunny'
-
-require File.dirname(__FILE__) + '/utilization'
-
-class Droid
-	DEFAULT_TTL = 300
-
-	class BadPayload < RuntimeError; end
-
-## basic ops
-## ######
-## publish / broadcast
-## listen / subscribe
-
-	def self.con_type
-		Thread.current['con_type'] ||= :sync
-	end
-
-	def self.con_type=(type)
-		Thread.current['con_type'] = type
-	end
 
-	def self.async?
-		return @@async == true rescue false
-	end
+if !defined?(JSON) && !defined?(JSON_LOADED)
+	require 'json/pure'
+end
 
-	def self.async(&blk)
-		ensure_con_type(:async, &blk)
-	end
+require 'droid/monkey'
 
-	def self.sync(&blk)
-		ensure_con_type(:sync, &blk)
-	end
-
-	def self.ensure_con_type(type, &blk)
-		old_type = con_type
-		self.con_type = type
-		begin
-			blk.call
-		ensure
-			self.con_type = old_type
-		end
-	end
+require 'droid/utils'
+require 'droid/publish'
+require 'droid/request'
+require 'droid/utilization'
+require 'droid/queue'
+require 'droid/em'
 
-	def self.new_event_hash
-		s = Time.now.to_s + self.object_id.to_s + rand(100).to_s
-		Digest::MD5.hexdigest(s)
+class Droid
+	def self.version
+		@@version ||= File.read(File.dirname(__FILE__) + '/../VERSION').strip
 	end
 
-	def self.queue(name, options = {})
-		reconnect_on_error do
-			if con_type == :async
-				MQ.queue(name, options)
-			else
-					bunny.queue(name, options)
-			end
-		end
+	def self.name
+		@@name
 	end
 
-	if defined? Bunny::Client   # the blog below doesn't work with newer versions of bunny
-		# Disable bunny's 1 second socket connect timeout since the
-		# reconnect_on_error method sets up a separate 10 second timeout.
-		# Using a timeout of zero sets an "infinite" timeout and has the nice
-		# benefit of not starting up another thread.
-		::Bunny::Client.send(:remove_const, :CONNECT_TIMEOUT)
-		::Bunny::Client::CONNECT_TIMEOUT = 0
+	def self.name=(name)
+		@@name = name
 	end
 
-	def self.reconnect_on_error
-		Timeout::timeout(20) do
-			begin
-				yield
-			rescue Bunny::ProtocolError
-				sleep 0.5
-				retry
-			rescue Bunny::ConnectionError
-				sleep 0.5
-				@@bunny = nil
-				retry
-			rescue Bunny::ServerDownError
-				sleep 0.5
-				@@bunny = nil
-				retry
-			end
-		end
+	def self.log=(log)
+		@@log = log
 	end
 
-	def self.call(key, payload, options={})
-		sync do
-			reply_to = key + '.reply.' + Droid.gensym
-			@q = nil
-			begin
-				reconnect_on_error do
-
-					## this is retarded - i shouldn't be binding here - just popping the queue - need to teach hermes/em
-					@q = queue(reply_to, :auto_delete => true)
-					@q.bind(exchange, :key => reply_to)
-
-					payload[:reply_to] = reply_to
-					publish(key, payload, options)
+	def self.log
+		@@log ||= begin
+			require 'logger'
+			Logger.class_eval <<EORUBY
+				alias_method :notice, :info
 
-					pop(reply_to)
+				alias_method :error_og, :error
+				def error(err, opts={})
+					e = opts[:exception]
+					if e.respond_to?(:backtrace)
+						err += "\n" + e.backtrace.join("\n  ")
+					end
+					error_og(err)
 				end
-			ensure
-				# for some reason the auto_delete flag is not working correctly with Bunny
-				# so we're deleting the queue manually here
-				@q.delete if @q
-			end
-		end
-	end
-
-	def self.pop(queue)
-		loop do
-			raise "POP must be sync" unless con_type == :sync
-			result = queue(queue).pop
-			result = result[:payload] if result.is_a?(Hash)
-			return JSON.parse(result) unless result == :queue_empty
-			sleep 0.1
-		end
-	end
-
-	def self.push(queue_name, payload, options={})
-		reconnect_on_error do
-			queue(queue_name).publish(payload_to_data(payload, options))
-		end
-	end
-
-	def self.payload_to_data(payload, options)
-		raise BadPayload unless payload.is_a?(Hash)
-
-		payload[:event_hash] ||= new_event_hash
-		payload[:published_on] = options[:published_on] || Time.now.getgm.to_i
-		payload[:ttl] ||= (options[:ttl] || DEFAULT_TTL).to_i
-
-		payload.to_json
-	end
-
-	def self.publish(key, payload, options={})
-		payload[:message_id] = new_event_hash
-		res =
-			reconnect_on_error do
-				exchange.publish(payload_to_data(payload, options), :key => key, :immediate => options[:immediate])
-			end
-
-		unless options[:log] == false
-			Log.notice "amqp_message action=published key=#{key} #{payload_summary(payload)}"
-		end
-
-		res
-	end
-
-	def self.header_keys
-		@header_keys ||= [:exchange, :delivery_mode, :delivery_tag, :redelivered, :consumer_tag, :content_type, :key, :priority]
-	end
-
-	def self.payload_summary(payload)
-		payload = payload.select do |k, v|
-			!header_keys.include?(k.to_sym)
+EORUBY
+			Logger.new($stderr)
 		end
-		return ' -> (empty payload)' if payload.empty?
-		resume = payload.map do |k, v|
-			v = v.to_s
-			v = v[0..37] + '...' if v.size > 40
-			"#{k}=#{v}"
-		end.join(", ")
-		" -> #{resume}"
 	end
 
-	def self.exchange
-		if con_type == :async
-			MQ.topic('amq.topic')
-		else
-			bunny.exchange("amq.topic")
-		end
-	end
-
-	def self.default_options
-      uri = URI.parse(ENV["AMQP_URI"] || 'rabbit://guest:guest@localhost:5672/')
-      raise "invalid AMQP_URI [#{uri.to_s}]" unless uri.scheme == "rabbit"
-      {
-         :vhost => uri.path,
-         :host => uri.host,
-         :user => uri.user,
-         :port => uri.port,
-         :pass => uri.password
-      }
-   end
-
 	def self.default_config
-		default_options
+		uri = URI.parse(ENV["AMQP_URL"] || 'amqp://guest:guest@localhost:5672/')
+		{
+			:vhost => uri.path,
+			:host => uri.host,
+			:user => uri.user,
+			:port => uri.port || 5672,
+			:pass => uri.password
+		}
+	rescue Object => e
+		raise "invalid AMQP_URL: (#{uri.inspect}) #{e.class} -> #{e.message}"
 	end
 
-	def self.new_bunny
-		b = Bunny.new(default_options)
-		b.start
-		b
-	end
+	def self.start(opts={})
+		config = opts[:config] || self.default_config
 
-	def self.bunny
-		@@bunny ||= new_bunny
-	end
+		wait_for_tcp_port(config[:host], config[:port])
 
-	def self.start(options = nil, &blk)
-		async do
-			begin
-				Signal.trap('INT') { AMQP.stop{ EM.stop } }
-				Signal.trap('TERM'){ AMQP.stop{ EM.stop } }
-				EM.run do
-					AMQP.start(options || default_options)
-					blk.call if blk
-				end
-			rescue AMQP::Error => e
-				STDERR.puts "Caught #{e.class}, sleeping to avoid inittab thrashing"
-				sleep 5
-				STDERR.puts "Done."
-				raise
+		begin
+			::Signal.trap('INT') { ::AMQP.stop{ ::EM.stop } }
+			::Signal.trap('TERM'){ ::AMQP.stop{ ::EM.stop } }
+
+			::AMQP.start(config) do
+				yield if block_given?
 			end
+		rescue ::AMQP::Error => e
+			log.debug "Caught #{e.class}, sleeping to avoid inittab thrashing"
+			sleep 5
+			log.debug "Done."
+			raise
 		end
 	end
 
 	def self.stop_safe
-		EM.add_timer(1) { AMQP.stop { EM.stop }}
+		::EM.add_timer(0.2) { ::AMQP.stop { ::EM.stop } }
 	end
 
-	def self.gen_queue(droid, key)
-		dn = droid
-		dn = dn.name if dn.respond_to?(:name)
-		dn ||= "d"
-		dn.gsub!(" ", "")
-		"#{self.gen_instance_queue(key)}.#{dn}"
+	def self.closing?
+		::AMQP.closing?
 	end
 
-	def self.gen_instance_queue(key)
-		"#{key}.#{LocalStats.slot}.#{LocalStats.ion_instance_id}"
+	def self.handle_error(err)
+		log.error "#{err.class}: #{err.message}", :exception => err
 	end
 
-	def self.gensym
-		values = [
-			rand(0x0010000),
-			rand(0x0010000),
-			rand(0x0010000),
-			rand(0x0010000),
-			rand(0x0010000),
-			rand(0x1000000),
-			rand(0x1000000),
-		]
-		"%04x%04x%04x%04x%04x%06x%06x" % values
-	end
+	def self.wait_for_tcp_port(host, port, opts={})
+		require 'system_timer'
+		require 'socket'
 
-	def self.wait_for_tcp_port(host, port, options={:retries => 5, :timeout => 5})
-		require 'timeout'
-		options[:retries].times do
+		opts[:retries] ||= 6
+		opts[:timeout] ||= 5
+
+		opts[:retries].times do
 			begin
-				Timeout::timeout(options[:timeout]) {
+				SystemTimer::timeout(opts[:timeout]) do
 					TCPSocket.new(host.to_s, port).close
-				}
+				end
 				return
-			rescue Object
-				Log.notice "#{host}:#{port} not available, waiting..."
+			rescue Object => e
+				log.info "#{host}:#{port} not available, waiting... #{e.class}: #{e.message}"
 				sleep 1
 			end
 		end
 
-		raise "#{host}:#{port} did not come up after #{options[:retries]} retries"
+		raise "#{host}:#{port} did not come up after #{opts[:retries]} retries"
 	end
 
-	# Trap exceptions leaving the block and log them. Do not re-raise.
-	def self.trap_exceptions
-		yield
-	rescue => boom
-		Log.default_error boom
-	end
-
-	# Add a one-shot timer.
-	def self.timer(duration, &bk)
-		EM.add_timer(duration) { trap_exceptions(&bk) }
-	end
-
-	# Add a periodic timer. If the now argument is true, run the block
-	# immediately in addition to scheduling the periodic timer.
-	def self.periodic_timer(duration, now=false, &bk)
-		timer(1, &bk) if now
-		EM.add_periodic_timer(duration) { trap_exceptions(&bk) }
-	end
+	def initialize(name, opts={})
+		log.info "=== #{name} droid initializing"
 
-	def timer(duration, &bk) ; self.class.timer(duration, &bk) ; end
-	def periodic_timer(duration, now=false, &bk) ; self.class.periodic_timer(duration, now, &bk) ; end
-
-	class Basic
-		def initialize(droid, options={})
-			@droid = droid
-		end
-
-		def exchange
-			Droid.exchange
-		end
-
-		def headers
-			@headers ||= { :event_hash => self.event_hash }
-		end
-
-		def event_hash
-			@event_hash ||= Droid.new_event_hash
-		end
-
-		def publish(key, payload, options={}, &blk)
-			raise BadPayload unless payload.is_a?(Hash)
-
-			result =if blk
-				headers[:reply_to] = key + '.reply.' + Droid.gensym
-				@droid.listen4(headers[:reply_to], { :temp => true }, &blk)
-			end
-
-			Droid.publish(key, headers.merge(payload), {:log => true}.merge(options))
-
-			result
-		end
-
-		def payload_summary(payload)
-			Droid.payload_summary(payload)
+		self.class.name = name
+		self.class.start do
+			yield self if block_given?
 		end
 	end
 
-	class Listener < Basic
-		attr_accessor :params
-
-		def initialize(droid, key, options={})
-			@key     = key
-			@options = options
-			queue    = @options.delete(:queue) || Droid.gen_queue(droid, key)
-			auto_delete = @options.has_key?(:auto_delete) ? !!@options.delete(:auto_delete) : true
-			@mq      = MQ.new
-			@prefetch = !!@options[:prefetch]
-			@mq.prefetch(@options[:prefetch]) if @prefetch
-			@q       = @mq.queue(queue, :auto_delete => auto_delete)
-			super(droid, options)
-		end
-
-		def destroy
-			@q.unsubscribe
-			@mq.close
-		end
-
-		def mq
-			@mq
-		end
-
-		def exchange
-			Droid.exchange
-		end
-
-		def error(e)
-			begin
-				publish("event.error", :event_hash => headers[:event_hash])	# hermes fail whale
-				msg = "#{e.class}: #{e.message}\n	#{e.backtrace.join("\n	")}\n"
-				stderr_puts "About to log error #{headers[:event_hash]}"
-				stderr_puts e.message
-				stderr_puts msg
-				Log.error "amqp_message action=error class='#{e.class}' message='#{e.message}'", :exception => e
-				@droid.error_handler.call(@message, e, self) if @droid.error_handler
-			rescue Exception => e
-				stderr_puts "error handling error! #{e.inspect}"
-			end
-		end
-
-		def stderr_puts(msg)
-			STDERR.puts msg
-		end
-
-		def defer(&blk)
-			EM.defer(lambda do
-				begin
-					blk.call
-				 rescue => e
-					 error(e)
-				 end
-			 end)
-		end
-
-		def reply(payload, options={})
-			publish(headers[:reply_to], payload, options)
-		end
-
-		def listen(opts={}, &blk)
-			opts[:temp] = opts[:temp] === true
-			opts[:ack] = opts[:ack] === true
-
-			if @prefetch
-				opts[:ack] = true   # we must ack messages received in order for prefetch to work
-				opts[:temp] = false # doesn't make sense for it to be temporary if we're setting prefetch
-			end
-			@q.bind(exchange, :key => @key ).subscribe(:ack => opts[:ack]) do |info, data|
-				Utilization.monitor(@key, :temp => opts[:temp]) do
-					begin
-						parse(info, data)
-
-						if opts[:detail]
-							callargs = [self.dup, info, data]
-						else
-							callargs = [self.dup]
-						end
-
-						ttl = headers[:ttl]
-						start = Time.now.getgm.to_i
-						published_on = headers[:published_on]
-						age = start - published_on
-
-						Log.notice "amqp_message action=received key=#{@key} ttl=#{ttl} age=#{age} #{payload_summary(params)}"
-
-						if (ttl == -1) or (age <= ttl)
-							@droid.before_filter.call(*callargs) if @droid.before_filter
-							blk.call(*callargs)
-
-							finished = Time.now.getgm.to_i
-							Log.notice "amqp_message action=processed key=#{@key} elapsed=#{finished-start} ttl=#{ttl} age=#{age} #{payload_summary(params)}"
-						else
-							Log.error "amqp_message action=timeout key=#{@key} ttl=#{ttl} age=#{age} #{payload_summary(params)}"
-							info.ack if opts[:ack]
-						end
-					rescue => e
-						error(e)
-					ensure
-						if opts[:temp]
-							@q.unbind(exchange)
-							@q.delete
-						end
-					end
-				end
-			end
-
-			self
-		end
-
-		def requeue(opts={})
-			opts[:ttl] ||= 10
-
-			now = Time.now.getgm.to_i
-
-			payload = @params.merge(extra_headers)
-			payload.delete('ttl')
-			payload[:ttl] = opts[:ttl]
-
-			newpayload = Droid.payload_to_data(payload, :published_on => (headers[:published_on] || now))
-			Log.notice("droid_requeue key=#{@key} #{payload_summary(newpayload)}")
-			@q.publish(newpayload)
-		end
-
-		def parse(info, data)
-			@headers = nil
-			@params = JSON.parse(data)
-
-			headers[:event_hash]   = @params.delete('event_hash') if @params['event_hash']
-			headers[:reply_to]     = @params.delete('reply_to') if @params['reply_to']
-			headers[:published_on] = @params.delete('published_on').to_i rescue 0
-			headers[:ttl]          = @params.delete('ttl').to_i rescue -1
-			headers[:ttl] = -1 if headers[:ttl] == 0
-			headers.merge!(info.properties) # add protocol headers
-		end
-
-		def extra_headers
-			extra = {}
-			[:event_hash, :reply_to, :published_on].each do |key|
-				extra[key] = headers[key]
-			end
-			extra
-		end
-
-		def [](key)
-			@params[key.to_s]
-		end
-
-		def unsubscribe
-			@q.unsubscribe
-		end
+	def publish(*args)
+		Droid.publish(*args)
 	end
 
-	attr_accessor :name
-	attr_reader	 :error_handler, :before_filter
-
-	def initialize(name, credentials, &blk)
-		Log.notice "=== #{name} droid initializing"
-		credentials[:port] ||= 5672
-		self.class.wait_for_tcp_port(credentials[:host], credentials[:port], :retries => 6) # retry for 30s before giving up
-
-		@name = name
-		Log.notice "=== #{name} droid starting"
-		self.class.start(credentials) do
-			blk.call(self)
-		end
-		self
-	end
-
-	def publish(key, payload={}, options={}, &blk)
-		Basic.new(self, options).publish(key, payload, options, &blk)
+	def log
+		self.class.log
 	end
 
-	def listen4(key, options={}, &blk)
-		Listener.new(self, key, options).listen({
-			:temp => options.delete(:temp),
-			:detail => options.delete(:detail),
-			:ack => options.delete(:ack),
-			}, &blk)
-	end
-
-	def on_error(&blk)
-		@error_handler = blk
-	end
-
-	def before_filter(&blk)
-		blk ? @before_filter = blk : @before_filter
-	end
-
-	def stats(&blk)
-		@stats = blk
-		Log.notice call_stats
-	end
-
-	def call_stats
-		@stats ? @stats.call : nil
-	end
+	include Droid::QueueMethods
+	include Droid::BackwardsCompatibleMethods
+	include Droid::EMTimerUtils
 end