droid19 1.0.2

data/lib/droid/heroku.rb

@@ -0,0 +1,102 @@
+require 'droid'
+require 'droid/heroku/local_stats'
+require 'droid/heroku/logger_client'
+
+Log.configure do |c|
+	c.component = LocalStats.slot
+	c.instance_name = LocalStats.instance_name
+end
+
+Droid.log = Log
+
+class Droid
+	module Utils
+		def self.generate_name_for_instance(name)
+			"#{name}.#{LocalStats.slot}.#{LocalStats.ion_instance_id}"
+		end
+	end
+end
+
+begin
+	require 'droid/json_server'
+rescue LoadError => e
+	Droid.log.error "Could not load JSONServer", :exception => e
+end
+
+class HerokuDroid < Droid
+	attr_reader :extended_stats
+
+	def initialize(name, opts={}, &blk)
+		@extended_stats = !(opts[:extended_stats] == false)
+
+		super(name, opts) do |droid|
+			setup_standard_topics(self) unless opts[:standard_topics] == false
+			LocalStats.attach
+			blk.call(self)
+		end
+	end
+
+	def stats(&blk)
+		@stats = blk
+		out = call_stats
+		out = out.inspect unless out.kind_of?(String)
+		Log.notice out
+	end
+
+	def call_stats
+		@stats ? @stats.call : nil
+	end
+
+	def name
+		Droid.name
+	end
+
+	def ruby_path
+		if File.exists?("/usr/ruby1.8.6/bin/ruby")
+			"/usr/ruby1.8.6/bin"
+		else
+			"/usr/local/bin"
+		end
+	end
+
+	def setup_standard_topics(droid)
+		setup_ping_topic(droid)
+	end
+
+	def setup_ping_topic(droid)
+		require 'time'
+
+		droid.listener('ping').subscribe do |req|
+			Droid::Utilization.latency = (Time.now.to_f - req['departed_at']).abs
+		end
+
+		blk = Proc.new do |d|
+			begin
+				t1 = Time.now
+				response = {}.merge(LocalStats.stats)
+
+				estats = nil
+				if self.extended_stats
+					estats = droid.call_stats
+					estats = { :notes => estats } unless estats.kind_of?(Hash)
+					estats[:notes] ||= estats.map { |k, v| "#{v} #{k}" }.join(", ")
+					estats.merge!(LocalStats.extended_stats)
+				end
+
+				response.merge!({
+					:extended_stats => estats,
+					:droid_name => Droid.name,
+					:latency => Droid::Utilization.latency,
+				})
+
+				d.publish('pong', response.merge(:stat_collection => (Time.now - t1)))
+			rescue Object => e
+				log.error "Ping Block Error: #{e.class} -> #{e.message}", :exception => e
+			end
+		end
+
+		EM.add_timer(2) { blk.call(droid) }
+		EM.add_periodic_timer(50 + (rand*15).to_i) { blk.call(droid) }
+	end
+end
+

data/lib/droid/heroku/local_stats.rb

@@ -0,0 +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
+end

data/lib/droid/heroku/logger_client.rb

@@ -0,0 +1,218 @@
+# Logger Client
+# Use as a gem or Rails plugin. Example configuration:
+# 
+# Log.configure do |config|
+#   config.component = 'core'
+#   config.instance = 'userapps.123'
+#   config.failsafe = :file
+# end
+
+require 'time'
+require 'syslog'
+
+module Log; end
+
+class Log::InvalidConfiguration < RuntimeError
+  def message
+    "Invalid component. Configure with Log.configure { |c| c.component = 'myComponent' }"
+  end
+end
+
+class Log::Config
+  def initialize
+    @contents = { }
+  end
+
+  def method_missing(method, value)
+    @contents[method.to_s.gsub(/=$/, '').to_sym] = value
+  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
+end
+