droid 1.0.0 → 1.0.1

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.0.1

data/droid.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{droid}
-  s.version = "1.0.0"
+  s.version = "1.0.1"
 
   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.date = %q{2010-11-12}
   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}

data/lib/droid/heroku/local_stats.rb

@@ -1,145 +1,145 @@
 require 'rest_client'
 
 module LocalStats
-	extend self
-
-	def load_avg
-		File.read('/proc/loadavg').split(' ', 2).first.to_f
-	end
-
-	def memory_info
-		info = {}
-		File.read('/proc/meminfo').split("\n").each do |line|
-			name, value = line.split(/:\s+/, 2)
-			info[name] = value.to_i
-		end
-		info
-	end
-
-	def memory_use
-		info = memory_info
-		used = info['MemTotal'] - info['MemFree'] - info['Cached'] - info['Buffers']
-		(100 * used / info['MemTotal']).to_i
-	end
-
-	def swap_use
-		_, total, use, _ = `free | grep Swap:`.strip.split
-		return 0 if total.to_i == 0
-		(100 * use.to_i / total.to_i).to_i
-	end
-
-	def local_ip
-		@local_ip ||= fetch_local_ip
-	end
-
-	def fetch_local_ip
-		`/sbin/ifconfig eth0 | grep inet | awk '{print $2}'`.gsub('addr:', '').strip
-	end
-
-	def public_ip
-		retries = 0
-		@public_ip ||= begin
-			RestClient.get("http://169.254.169.254/latest/meta-data/public-ipv4").to_s.strip
-		rescue RestClient::RequestTimeout => e
-			retries += 1
-			raise if retries > 5
-			sleep 1
-			retry
-		end
-	end
-
-	def disk_stats
-		raw = `df -P | grep -v tmpfs | grep -v udev | grep -v slugs | awk '{print $1 " ## " $6 " ##  " $5}'`.split("\n").collect { |d| d }
-		raw.shift
-		raw.collect do |d|
-			tokens = d.split("##").collect { |t| t.strip }
-			{
-				:device => tokens[0],
-				:path => tokens[1],
-				:usage => tokens[2].gsub('%','').to_i
-			}
-		end
-	end
-
-	def ion_instance_id
-		@ion_instance_id ||= File.read('/etc/heroku/ion_instance_id').strip rescue nil
-	end
-
-	def slot
-		@slot ||= File.read('/etc/heroku/slot').strip.gsub(/64$/,'').split('-').first rescue nil
-	end
-
-	def instance_name
-		return nil if slot.nil? or ion_instance_id.nil?
-		"#{slot}.#{ion_instance_id}"
-	end
-
-	alias :this_instance_name :instance_name
-
-	def stats
-		{
-			:slot            => slot,
-			:ion_id          => ion_instance_id,
-			:load_avg        => load_avg,
-			:memory_use      => memory_use,
-			:swap_use        => swap_use,
-			:local_ip        => local_ip,
-			:instance_name   => this_instance_name,
-			:public_ip       => public_ip,
-			:net_in_rate     => receive_rate,
-			:net_out_rate    => transmit_rate
-		}
-	end
-
-	def extended_stats
-		{
-			:disk_stats => disk_stats
-		}
-	end
-
-	# sample ifstat every 30 seconds
-	IFSTAT_INTERVAL = 30
-
-	# bytes received per second and bytes transmitted per
-	# second as a two tuple
-	def transfer_rates
-		[receive_rate, transmit_rate]
-	end
-
-	# bytes received per second
-	def receive_rate
-		@rxrate || 0
-	end
-
-	# bytes transmitted per second
-	def transmit_rate
-		@txrate || 0
-	end
-
-	# sample the current RX and TX bytes from ifconfig and
-	# return as a two-tuple.
-	def sample
-		data = ifconfig.match(/RX bytes:(\d+).*TX bytes:(\d+)/)
-		[data[1].to_i, data[2].to_i]
-	rescue => boom
-		Log.notice "error sampling network rate: #{boom.class} #{boom.message}"
-	end
-
-	def update_counters
-		rx, tx = sample
-		@rxrate = (rx - @rx) / IFSTAT_INTERVAL if @rx
-		@txrate = (tx - @tx) / IFSTAT_INTERVAL if @tx
-		@rx, @tx = rx, tx
-	end
-
-	# called when a droid starts up - setup timers and whatnot
-	def attach
-		@rx, @tx, @rxrate, @txrate = nil
-		update_counters
-		EM.add_periodic_timer(IFSTAT_INTERVAL) { update_counters }
-	end
-
-	def ifconfig
-		`/sbin/ifconfig eth0`
-	end
+  extend self
+
+  def load_avg
+    File.read('/proc/loadavg').split(' ', 2).first.to_f
+  end
+
+  def memory_info
+    info = {}
+    File.read('/proc/meminfo').split("\n").each do |line|
+      name, value = line.split(/:\s+/, 2)
+      info[name] = value.to_i
+    end
+    info
+  end
+
+  def memory_use
+    info = memory_info
+    used = info['MemTotal'] - info['MemFree'] - info['Cached'] - info['Buffers']
+    (100 * used / info['MemTotal']).to_i
+  end
+
+  def swap_use
+    _, total, use, _ = `free | grep Swap:`.strip.split
+    return 0 if total.to_i == 0
+    (100 * use.to_i / total.to_i).to_i
+  end
+
+  def local_ip
+    @local_ip ||= fetch_local_ip
+  end
+
+  def fetch_local_ip
+    `/sbin/ifconfig eth0 | grep inet | awk '{print $2}'`.gsub('addr:', '').strip
+  end
+
+  def public_ip
+    retries = 0
+    @public_ip ||= begin
+      RestClient.get("http://169.254.169.254/latest/meta-data/public-ipv4").to_s.strip
+    rescue RestClient::RequestTimeout => e
+      retries += 1
+      raise if retries > 5
+      sleep 1
+      retry
+    end
+  end
+
+  def disk_stats
+    raw = `df -P | grep -v tmpfs | grep -v udev | grep -v slugs | awk '{print $1 " ## " $6 " ##  " $5}'`.split("\n").collect { |d| d }
+    raw.shift
+    raw.collect do |d|
+      tokens = d.split("##").collect { |t| t.strip }
+      {
+        :device => tokens[0],
+        :path => tokens[1],
+        :usage => tokens[2].gsub('%','').to_i
+      }
+    end
+  end
+
+  def ion_instance_id
+    @ion_instance_id ||= File.read('/etc/heroku/ion_instance_id').strip rescue nil
+  end
+
+  def slot
+    @slot ||= File.read('/etc/heroku/slot').strip.gsub(/64$/,'').split('-').first rescue nil
+  end
+
+  def instance_name
+    return nil if slot.nil? or ion_instance_id.nil?
+    "#{slot}.#{ion_instance_id}"
+  end
+
+  alias :this_instance_name :instance_name
+
+  def stats
+    {
+      :slot            => slot,
+      :ion_id          => ion_instance_id,
+      :load_avg        => load_avg,
+      :memory_use      => memory_use,
+      :swap_use        => swap_use,
+      :local_ip        => local_ip,
+      :instance_name   => this_instance_name,
+      :public_ip       => public_ip,
+      :net_in_rate     => receive_rate,
+      :net_out_rate    => transmit_rate
+    }
+  end
+
+  def extended_stats
+    {
+      :disk_stats => disk_stats
+    }
+  end
+
+  # sample ifstat every 30 seconds
+  IFSTAT_INTERVAL = 30
+
+  # bytes received per second and bytes transmitted per
+  # second as a two tuple
+  def transfer_rates
+    [receive_rate, transmit_rate]
+  end
+
+  # bytes received per second
+  def receive_rate
+    @rxrate || 0
+  end
+
+  # bytes transmitted per second
+  def transmit_rate
+    @txrate || 0
+  end
+
+  # sample the current RX and TX bytes from ifconfig and
+  # return as a two-tuple.
+  def sample
+    data = ifconfig.match(/RX bytes:(\d+).*TX bytes:(\d+)/)
+    [data[1].to_i, data[2].to_i]
+  rescue => boom
+    Log.notice "error sampling network rate: #{boom.class} #{boom.message}"
+  end
+
+  def update_counters
+    rx, tx = sample
+    @rxrate = (rx - @rx) / IFSTAT_INTERVAL if @rx
+    @txrate = (tx - @tx) / IFSTAT_INTERVAL if @tx
+    @rx, @tx = rx, tx
+  end
+
+  # called when a droid starts up - setup timers and whatnot
+  def attach
+    @rx, @tx, @rxrate, @txrate = nil
+    update_counters
+    EM.add_periodic_timer(IFSTAT_INTERVAL) { update_counters }
+  end
+
+  def ifconfig
+    `/sbin/ifconfig eth0`
+  end
 end

data/lib/droid/heroku/logger_client.rb

@@ -13,206 +13,206 @@ require 'syslog'
 module Log; end
 
 class Log::InvalidConfiguration < RuntimeError
-	def message
-		"Invalid component. Configure with Log.configure { |c| c.component = 'myComponent' }"
-	end
+  def message
+    "Invalid component. Configure with Log.configure { |c| c.component = 'myComponent' }"
+  end
 end
 
 class Log::Config
-	def initialize
-		@contents = { }
-	end
+  def initialize
+    @contents = { }
+  end
 
-	def method_missing(method, value)
-		@contents[method.to_s.gsub(/=$/, '').to_sym] = value
-	end
+  def method_missing(method, value)
+    @contents[method.to_s.gsub(/=$/, '').to_sym] = value
+  end
 
-	def to_hash
-		@contents
-	end
+  def to_hash
+    @contents
+  end
 end
 
 module Log
-	extend self
-
-	unless defined? SyslogConvertion
-		SyslogConvertion = {
-			'error'   => 3,
-			'warning' => 4,
-			'notice'  => 5,
-			'debug'   => 7,
-		}
-	end
-
-	def debug(msg, options={})
-		log msg, options.merge(:level => 'debug')
-	end
-
-	def notice(msg, options={})
-		log msg, options.merge(:level => 'notice')
-	end
-
-	alias :info :notice
-
-	def warning(msg, options={})
-		log msg, options.merge(:level => 'warning')
-	end
-
-	def error(msg, options={})
-		# Fake an exception for error messages with no exception object
-		# so that we get a backtrace.
-		if options[:exception].nil?
-			begin
-				raise StandardError, msg
-			rescue => error
-				error.backtrace.shift
-				options[:exception] = error
-			end
-		end
-
-		log msg, options.merge(:level => 'error')
-	end
-
-	##########
-
-	def log(msg, options={})
-		console_log(msg)
-		syslog(msg, options)
-	rescue InvalidConfiguration => e
-		raise e
-	end
-
-	def default_error(e)
-		# avoid backtrace in /usr or vendor if possible
-		system, app = e.backtrace.partition { |b| b =~ /(^\/usr\/|vendor)/ }
-		reordered_backtrace = app + system
-
-		# avoid "/" as the method name (we want the controller action)
-		row = 0
-		row = 1 if reordered_backtrace[row].match(/in `\/'$/)
-
-		# get file and method name
-		begin
-			file, method = reordered_backtrace[row].match(/(.*):in `(.*)'$/)[1..2]
-			file.gsub!(/.*\//, '')
-			self.log "#{e.class} in #{file} #{method}: #{e.message}", :exception => e, :level => 'error'
-		rescue
-			self.log "#{e.class} in #{e.backtrace.first}: #{e.message}", :exception => e, :level => 'error'
-		end
-	end
-
-	def web_error(args)
-		e = args[:exception]
-		summary = "#{e.class} processing #{args[:url]}"
-
-		body = []
-		body << "\tURL: #{args[:url]}"
-		body << "\tParams: #{args[:params].inspect}"
-		body << "\tUser: #{args[:user]}" if args[:user]
-		body << "\tBacktrace:"
-		body << "\t\t#{e.class} (#{e.message}):"
-		body += e.backtrace.map { |l| "\t\t#{l}" }
-		body = body.join("\n")
-
-		log "#{summary}\n#{body}", :level => 'error'
-	end
-
-	def console_puts(*args)
-		$stderr.puts(*args)
-	end
-
-	def exception(e)
-		msg = "Exception #{e.class} -> #{e.message}\n"
-		msg += filtered_backtrace(e.backtrace)
-		Log.error e.message, :exception => e
-	end
-
-	def filtered_backtrace(backtrace)
-		backtrace.select do |line|
-			!line.match(/^\/usr/)
-		end.map do |line|
-			"   #{line}\n"
-		end.join
-	end
-
-	def event(name, options = {})
-		console_log("EVENT: #{name} begins")
-		result = yield
-		console_log("EVENT: #{name} complete")
-		result
-	end
-
-	def context(options)
-		prev_options = default_options.dup
-		default_options.merge!(options)
-		yield
-		@@default_options = prev_options
-	end
-
-	def configure
-		config = Config.new
-		yield(config)
-		set_default_options(config.to_hash)
-	end
-
-	def set_default_options(options)
-		default_options.merge!(options)
-	end
-
-	def default_options
-		@@default_options ||= { :console_log => true }
-	end
-
-	def failsafe(params)
-		case default_options[:failsafe]
-			when :file
-				dir = defined?(RAILS_ROOT) ? RAILS_ROOT : '.'
-				File.open("#{dir}/failsafe.log", "a") do |f|
-					f.puts "#{Time.now} #{params[:log][:level]} : #{params[:log][:message]}"
-				end
-			when :console, nil
-				console_log(params[:log][:message])
-		end
-	end
-
-	def console_log(msg)
-		console_puts "#{Time.now.iso8601} #{msg}" if default_options[:console_log]
-	end
-
-	def syslog(msg, opts = {})
-		@retried = false
-		begin
-			level = SyslogConvertion[opts[:level]]
-			if opts[:exception]
-				msg += "\n" + format_syslog_exception(opts[:exception])
-			end
-			syslog_resource.log(level, '%s', trim_syslog_msg(msg))
-		rescue Exception => e
-			failsafe(:log => { :level => 'error', :message => "could not log to syslog: #{e.class.name} #{e.message}"})
-			unless @retried
-				@retried = true
-				@@syslog.close rescue nil
-				@@syslog = Syslog.open(default_options[:component]) rescue nil
-				retry
-			end
-		end
-	end
-
-	def format_syslog_exception(e)
-		if e.respond_to?(:backtrace)
-			"\t#{e.class}: #{e.message}\n" + e.backtrace.map { |t| "\t#{t}" }.join("\n")
-		else
-			"\t#{e.class}: #{e.message}"
-		end
-	end
-
-	def trim_syslog_msg(msg)
-		return msg if msg.size < 800
-		msg[0, 796] + " ..."
-	end
-
-	def syslog_resource
-		@@syslog ||= Syslog.open(default_options[:component].to_s, Syslog::LOG_PID | Syslog::LOG_CONS, default_options[:syslog_facility] || Syslog::LOG_USER)
-	end
+  extend self
+
+  unless defined? SyslogConvertion
+    SyslogConvertion = {
+      'error'   => 3,
+      'warning' => 4,
+      'notice'  => 5,
+      'debug'   => 7,
+    }
+  end
+
+  def debug(msg, options={})
+    log msg, options.merge(:level => 'debug')
+  end
+
+  def notice(msg, options={})
+    log msg, options.merge(:level => 'notice')
+  end
+
+  alias :info :notice
+
+  def warning(msg, options={})
+    log msg, options.merge(:level => 'warning')
+  end
+
+  def error(msg, options={})
+    # Fake an exception for error messages with no exception object
+    # so that we get a backtrace.
+    if options[:exception].nil?
+      begin
+        raise StandardError, msg
+      rescue => error
+        error.backtrace.shift
+        options[:exception] = error
+      end
+    end
+
+    log msg, options.merge(:level => 'error')
+  end
+
+  ##########
+
+  def log(msg, options={})
+    console_log(msg)
+    syslog(msg, options)
+  rescue InvalidConfiguration => e
+    raise e
+  end
+
+  def default_error(e)
+    # avoid backtrace in /usr or vendor if possible
+    system, app = e.backtrace.partition { |b| b =~ /(^\/usr\/|vendor)/ }
+    reordered_backtrace = app + system
+
+    # avoid "/" as the method name (we want the controller action)
+    row = 0
+    row = 1 if reordered_backtrace[row].match(/in `\/'$/)
+
+    # get file and method name
+    begin
+      file, method = reordered_backtrace[row].match(/(.*):in `(.*)'$/)[1..2]
+      file.gsub!(/.*\//, '')
+      self.log "#{e.class} in #{file} #{method}: #{e.message}", :exception => e, :level => 'error'
+    rescue
+      self.log "#{e.class} in #{e.backtrace.first}: #{e.message}", :exception => e, :level => 'error'
+    end
+  end
+
+  def web_error(args)
+    e = args[:exception]
+    summary = "#{e.class} processing #{args[:url]}"
+
+    body = []
+    body << "\tURL: #{args[:url]}"
+    body << "\tParams: #{args[:params].inspect}"
+    body << "\tUser: #{args[:user]}" if args[:user]
+    body << "\tBacktrace:"
+    body << "\t\t#{e.class} (#{e.message}):"
+    body += e.backtrace.map { |l| "\t\t#{l}" }
+    body = body.join("\n")
+
+    log "#{summary}\n#{body}", :level => 'error'
+  end
+
+  def console_puts(*args)
+    $stderr.puts(*args)
+  end
+
+  def exception(e)
+    msg = "Exception #{e.class} -> #{e.message}\n"
+    msg += filtered_backtrace(e.backtrace)
+    Log.error e.message, :exception => e
+  end
+
+  def filtered_backtrace(backtrace)
+    backtrace.select do |line|
+      !line.match(/^\/usr/)
+    end.map do |line|
+      "   #{line}\n"
+    end.join
+  end
+
+  def event(name, options = {})
+    console_log("EVENT: #{name} begins")
+    result = yield
+    console_log("EVENT: #{name} complete")
+    result
+  end
+
+  def context(options)
+    prev_options = default_options.dup
+    default_options.merge!(options)
+    yield
+    @@default_options = prev_options
+  end
+
+  def configure
+    config = Config.new
+    yield(config)
+    set_default_options(config.to_hash)
+  end
+
+  def set_default_options(options)
+    default_options.merge!(options)
+  end
+
+  def default_options
+    @@default_options ||= { :console_log => true }
+  end
+
+  def failsafe(params)
+    case default_options[:failsafe]
+      when :file
+        dir = defined?(RAILS_ROOT) ? RAILS_ROOT : '.'
+        File.open("#{dir}/failsafe.log", "a") do |f|
+          f.puts "#{Time.now} #{params[:log][:level]} : #{params[:log][:message]}"
+        end
+      when :console, nil
+        console_log(params[:log][:message])
+    end
+  end
+
+  def console_log(msg)
+    console_puts "#{Time.now.iso8601} #{msg}" if default_options[:console_log]
+  end
+
+  def syslog(msg, opts = {})
+    @retried = false
+    begin
+      level = SyslogConvertion[opts[:level]]
+      if opts[:exception]
+        msg += "\n" + format_syslog_exception(opts[:exception])
+      end
+      syslog_resource.log(level, '%s', trim_syslog_msg(msg))
+    rescue Exception => e
+      failsafe(:log => { :level => 'error', :message => "could not log to syslog: #{e.class.name} #{e.message}"})
+      unless @retried
+        @retried = true
+        @@syslog.close rescue nil
+        @@syslog = Syslog.open(default_options[:component]) rescue nil
+        retry
+      end
+    end
+  end
+
+  def format_syslog_exception(e)
+    if e.respond_to?(:backtrace)
+      "\t#{e.class}: #{e.message}\n" + e.backtrace.map { |t| "\t#{t}" }.join("\n")
+    else
+      "\t#{e.class}: #{e.message}"
+    end
+  end
+
+  def trim_syslog_msg(msg)
+    return msg if msg.size < 800
+    msg[0, 796] + " ..."
+  end
+
+  def syslog_resource
+    @@syslog ||= Syslog.open(default_options[:component].to_s, Syslog::LOG_PID | Syslog::LOG_CONS, default_options[:syslog_facility] || Syslog::LOG_USER)
+  end
 end
 

data/lib/droid/heroku/memcache_cluster.rb

@@ -6,124 +6,147 @@ require 'digest/sha1'
 # outside of the reactor - it does not account for asynchronous access
 # to the server list.
 module MemcacheCluster
-	extend self
-
-	HEROKU_NAMESPACE = '0Xfa15837Z' # heroku's internal memcache namespace
-
-	# A MemCache object configured with heroku's internal memcache namespace.
-	def heroku
-		cache(HEROKU_NAMESPACE)
-	end
-
-	def cache_retry(prefix, opts={})
-		opts[:retries] ||= 5
-		opts[:delay] ||= 0.5
-
-		retried = 0
-		begin
-			c = cache(prefix)
-			yield c if block_given?
-		rescue MemCache::MemCacheError => e
-			Log.error "#{e.class} -> #{e.message}", :exception => e
-			raise if retried > opts[:retries]
-			retried += 1
-			sleep opts[:delay]
-			@caches = { }
-			retry
-		end
-	end
-
-	def set(prefix, *args)
-		res = nil
-		cache_retry(prefix) do |c|
-			res = c.set(*args)
-		end
-		res
-	end
-
-	def get(prefix, *args)
-		res = nil
-		cache_retry(prefix) do |c|
-			res = c.get(*args)
-		end
-		res
-	end
-
-	# Create listeners for standard memcache cluster related topics.
-	def attach(droid, file='memcached.yml')
-		load_from_file(file)
-
-		droid.listen4('memcache.up', :queue => "memcache.up.#{LocalStats.this_instance_name}.#$$") { |msg| add(msg['address'], msg['port']) }
-		droid.listen4('instance.down', :queue => "instance.down.#{LocalStats.this_instance_name}.#$$") { |msg| remove(msg['local_ip']) if msg['slot'] == 'memcache' }
-		EM.add_timer(1) { droid.publish('memcache.needed', {}) }
-	end
-
-	# A MemCache object configured with the given prefix.
-	def cache(prefix, options={})
-		caches[prefix] ||=
-			MemCache.new(servers, options.merge(:namespace => prefix))
-	end
-
-	alias_method :[], :cache
-
-	def caches
-		reload_if_stale
-		@caches ||= {}
-	end
-
-	def servers
-		reload_if_stale
-		@servers ||= []
-	end
-
-	def add(ip, port)
-		host = [ip, port].join(':')
-		return if servers.include?(host)
-
-		log { "#{host} added" }
-		@servers.push host
-		@servers.sort!
-		@caches = {}
-		write_to_file
-		@last_read = Time.now
-	end
-
-	def remove(host)
-		if servers.reject!{ |s| s =~ /^#{host}/ }
-			log { "#{host} removed" }
-			caches.clear
-			write_to_file
-		end
-	end
-
-	def reload_if_stale
-		if @last_read &&
-			(Time.now - @last_read) > 5 &&
-			File.mtime(@file) > @last_read
-			log { "server list modified. reloading." }
-			load_from_file(@file)
-		end
-	rescue => boom
-		# ignore errors accessing/reading file.
-	end
-
-	def load_from_file(file)
-		@file = file
-		@last_read = Time.now
-		@servers = YAML.load(File.read(file)) rescue []
-		@caches = {}
-	end
-
-	def write_to_file
-		log { "writing server list: #{@file}" }
-		File.open(@file, 'w') do |f|
-			f.flock(File::LOCK_EX)
-			f.write YAML.dump(@servers)
-			f.flock(File::LOCK_UN)
-		end
-	end
-
-	def log(type=:debug)
-		Log.send(type, "memcached: #{yield}")
-	end
+  extend self
+
+  HEROKU_NAMESPACE = '0Xfa15837Z' # heroku's internal memcache namespace
+
+  class Proxy
+    def initialize(name, options={})
+      @name = name
+      @options = options
+    end
+
+    def set(*args)
+      MemcacheCluster.cache_internal(@name, @options).set(*args)
+    end
+
+    def get(*args)
+      MemcacheCluster.cache_internal(@name, @options).get(*args)
+    end
+
+    def method_missing(method_name, *args)
+      MemcacheCluster.cache_internal(@name, @options).send(method_name, *args)
+    end
+  end
+
+  # A MemCache object configured with heroku's internal memcache namespace.
+  def heroku
+    cache(HEROKU_NAMESPACE)
+  end
+
+  def cache_retry(prefix, opts={})
+    opts[:retries] ||= 5
+    opts[:delay] ||= 0.5
+
+    retried = 0
+    begin
+      c = cache_internal(prefix)
+      yield c if block_given?
+    rescue MemCache::MemCacheError => e
+      Log.error "#{e.class} -> #{e.message}", :exception => e
+      raise if retried > opts[:retries]
+      retried += 1
+      sleep opts[:delay]
+      @caches = { }
+      retry
+    end
+  end
+
+  def set(prefix, *args)
+    res = nil
+    cache_retry(prefix) do |c|
+      res = c.set(*args)
+    end
+    res
+  end
+
+  def get(prefix, *args)
+    res = nil
+    cache_retry(prefix) do |c|
+      res = c.get(*args)
+    end
+    res
+  end
+
+  # Create listeners for standard memcache cluster related topics.
+  def attach(droid, file='memcached.yml')
+    load_from_file(file)
+
+    droid.listen4('memcache.up', :queue => "memcache.up.#{LocalStats.this_instance_name}.#$$") { |msg| add(msg['address'], msg['port']) }
+    droid.listen4('instance.down', :queue => "instance.down.#{LocalStats.this_instance_name}.#$$") { |msg| remove(msg['local_ip']) if msg['slot'] == 'memcache' }
+    EM.add_timer(1) { droid.publish('memcache.needed', {}) }
+  end
+
+  # A MemCache object configured with the given prefix.
+  def cache_internal(prefix, options={})
+    caches[prefix] ||=
+      MemCache.new(servers, options.merge(:namespace => prefix))
+  end
+
+  def cache(prefix, options={})
+    Proxy.new(prefix, options)
+  end
+
+  alias_method :[], :cache
+
+  def caches
+    reload_if_stale
+    @caches ||= {}
+  end
+
+  def servers
+    reload_if_stale
+    @servers ||= []
+  end
+
+  def add(ip, port)
+    host = [ip, port].join(':')
+    return if servers.include?(host)
+
+    log { "action=added server=#{host}" }
+    @servers.push host
+    @servers.sort!
+    @caches = {}
+    write_to_file
+    @last_read = Time.now.to_i
+  end
+
+  def remove(host)
+    if servers.reject!{ |s| s =~ /^#{host}/ }
+      log { "action=remove server=#{host}" }
+      caches.clear
+      write_to_file
+    end
+  end
+
+  def reload_if_stale
+    if @last_read &&
+      (Time.now.to_i - @last_read) > 20 &&
+      File.mtime(@file).to_i > @last_read
+      load_from_file(@file)
+    end
+  rescue => e
+    log { "action=error file=#{@file} error_class='#{e.class}' error_message='#{e.message}'" }
+  end
+
+  def load_from_file(file)
+    @file = file
+    @last_read = Time.now.to_i
+    @servers = YAML.load(File.read(file)) rescue []
+    @caches = {}
+    log { "action=load file=#{@file} servers=#{@servers.join(',')}" }
+  end
+
+  def write_to_file
+    log { "action=write file=#{@file} servers=#{@servers.join(',')}" }
+    File.open(@file, 'w') do |f|
+      f.flock(File::LOCK_EX)
+      f.write YAML.dump(@servers)
+      f.flock(File::LOCK_UN)
+    end
+  end
+
+  def log(type=:notice)
+    Log.send(type, "memcache_cluster #{yield}")
+  end
 end

data/lib/droid/heroku/stats.rb

@@ -1,30 +1,30 @@
 module Stats
-	# The MemCache instance used to manipulate stats.
-	def cache
-		MemcacheCluster.cache("heroku:stats")
-	end
+  # The MemCache instance used to manipulate stats.
+  def cache
+    @@cache ||= MemcacheCluster.cache("heroku:stats")
+  end
 
-	# Increment a stat counter. If the counter does not exist,
-	# yield to the block and use the result as the current counter
-	# value. With no block, the counter will be started at zero.
-	def increment(key, amount=1)
-		if (value = cache.incr(key, amount)).nil?
-			value = yield if block_given?
-			value = (value || 0) + amount
-			cache.add(key, value.to_s, 0, true)
-		end
-	rescue => boom
-		Log.default_error(boom)
-		nil
-	end
+  # Increment a stat counter. If the counter does not exist,
+  # yield to the block and use the result as the current counter
+  # value. With no block, the counter will be started at zero.
+  def increment(key, amount=1)
+    if (value = cache.incr(key, amount)).nil?
+      value = yield if block_given?
+      value = (value || 0) + amount
+      cache.add(key, value.to_s, 0, true)
+    end
+  rescue => boom
+    Log.default_error(boom)
+    nil
+  end
 
-	# Set the stat counter to a specific value.
-	def sample(key, value)
-		cache.set(key, value.to_s, 0, true)
-	rescue => boom
-		Log.default_error(boom)
-		nil
-	end
+  # Set the stat counter to a specific value.
+  def sample(key, value)
+    cache.set(key, value.to_s, 0, true)
+  rescue => boom
+    Log.default_error(boom)
+    nil
+  end
 
-	extend self
+  extend self
 end

data/lib/droid/utilization.rb

@@ -6,7 +6,7 @@ class Droid
 		def latency=(val); @latency = val; end
 		def latency; @latency; end
 
-		@@start = Time.now
+		@@start = Time.now.getutc
 		@@data = { }
 
 		def start
@@ -14,7 +14,7 @@ class Droid
 		end
 
 		def reinit
-			@@start = Time.now
+			@@start = Time.now.getutc
 			@@data = { }
 		end
 
@@ -39,7 +39,7 @@ class Droid
 		def calc_utilization(topic, t2=nil)
 			d = data(topic)
 			t1 = @@start
-			t2 ||= Time.now
+			t2 ||= Time.now.getutc.to_i
 			secs = (t2 - t1)
 			secs = 1 if secs <= 0.0
 			if d['msgs'] == 0
@@ -60,18 +60,18 @@ class Droid
 		def monitor(topic, opts={})
 			topic = 'temporary' if opts[:temp]
 
-			t1 = Time.now
+			t1 = Time.now.getutc
 			begin
 				yield if block_given?
 			ensure
-				t2 = Time.now
+				t2 = Time.now.getutc
 				record(topic, t2 - t1)
 			end
 		end
 
 		def report_data
 			data = {}
-			t2 = Time.now
+			t2 = Time.now.getutc
 			topics.each do |topic|
 				data[topic] = calc_utilization(topic, t2)
 			end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Ricardo Chimal, Jr.
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-21 00:00:00 -07:00
+date: 2010-11-12 00:00:00 -08:00
 default_executable: bleedq
 dependencies: 
 - !ruby/object:Gem::Dependency