drone 0.0.1

data/lib/drone/schedulers/eventmachine.rb

@@ -0,0 +1,61 @@
+require 'eventmachine'
+
+module Drone
+  module Schedulers
+    module EMScheduler
+      
+      @started = false
+      @timers_once = []
+      @timers_periodic = []
+      
+      ##
+      # Schedule a block to be called immediatly and after
+      # that at a specified interval
+      # 
+      # @param [Number] delay the interval
+      # 
+      def self.schedule_periodic(delay, &block)
+        raise "Block required" unless block
+        if @started
+          block.call()
+          EM::add_periodic_timer(delay, &block)
+        else
+          @timers_periodic << [delay, block]
+        end
+      end
+      
+      
+      ##
+      # Schedule a block to be called after a specified
+      # delay
+      # 
+      # @param [Number] delay the interval
+      # 
+      def self.schedule_once(delay, &block)
+        raise "Block required" unless block
+        if @started
+          EM::add_timer(delay, &block)
+        else
+          @timers_once << [delay, block]
+        end
+      end
+      
+      
+      ##
+      # Start the timers.
+      # 
+      def self.start
+        @started = true
+        @timers_once.each do |(delay, block)|
+          schedule_once(delay, &block)
+        end
+        
+        @timers_periodic.each do |(delay, block)|
+          schedule_periodic(delay, &block)
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/drone/utils/ewma.rb

@@ -0,0 +1,50 @@
+# ruby adaptation of the metrics library version by Coda Hale
+class EWMA
+  M1_ALPHA  = (1 - Math.exp(-5 / 60.0)).freeze
+  M5_ALPHA  = (1 - Math.exp(-5 / 60.0 / 5)).freeze
+  M15_ALPHA = (1 - Math.exp(-5 / 60.0 / 15)).freeze
+  
+  def self.one_minute_ewma
+    new(M1_ALPHA, 5000)
+  end
+  
+  def self.five_minutes_ewma
+    new(M5_ALPHA, 5000)
+  end
+  
+  def self.fifteen_minutes_ewma
+    new(M15_ALPHA, 5000)
+  end
+  
+  
+  # interval: in ms
+  def initialize(alpha, interval)
+    @alpha = alpha
+    @interval = interval.to_f # * (1000*1000)
+    @uncounted = 0
+    @rate = nil
+  end
+  
+  def update(n)
+    @uncounted += n
+  end
+  
+  def tick()
+    count = @uncounted
+    @uncounted = 0
+    instant_rate = count / @interval
+    if @rate
+      @rate += (@alpha * (instant_rate - @rate))
+    else
+      @rate = instant_rate
+    end
+  end
+  
+  def rate(as = :seconds)
+    case as
+    when :ms        then  @rate
+    when :seconds   then  @rate * 1000
+    end
+  end
+  
+end

data/lib/drone/utils/exponentially_decaying_sample.rb

@@ -0,0 +1,71 @@
+
+class ExponentiallyDecayingSample
+  # 1 hour in ms
+  RESCALE_THRESHOLD = (1 * 60 * 60 * 1000).freeze
+  
+  def initialize(reservoir_size, alpha)
+    @values = {}
+    @alpha = alpha
+    @reservoir_size = reservoir_size
+    clear()
+  end
+  
+  def clear
+    @values.clear()
+    @count = 0
+    @start_time = Time.now
+    @next_scale_time = current_time() + RESCALE_THRESHOLD
+  end
+  
+  def size
+    (@values.size < @count) ? @values.size : @count
+  end
+  
+  
+  def update(val, time = Time.now)
+    priority = weight(time - @start_time) / rand()
+    @count += 1
+    if @count <= @reservoir_size
+      @values[priority] = val
+    else
+      first = @values.keys.min
+      if first < priority
+        @values[priority] = val
+        while @values.delete(first) == nil
+          first = @values.keys.min
+        end
+      end
+    end
+    
+    now = current_time()
+    if now >= @next_scale_time
+      rescale(now, @next_scale_time)
+    end
+  end
+  
+  def values
+    @values.values
+  end
+  
+  def rescale(now)
+    @next_scale_time = current_time() + RESCALE_THRESHOLD
+    old_start = @start_time
+    @start_time = Time.now
+    
+    @values = Hash[ @values.map{ |k,v|
+        [k * Math.exp(-@alpha * (@start_time - old_start)), v]
+      }]
+    
+  end
+  
+private
+  
+  def current_time
+    Time.now.to_f * 1000
+  end
+  
+  def weight(n)
+    Math.exp(@alpha * n)
+  end
+  
+end

data/lib/drone/utils/uniform_sample.rb

@@ -0,0 +1,37 @@
+class UniformSample
+  
+  def initialize(size)
+    @values = Array.new(size)
+    clear()
+  end
+  
+  def clear
+    @values.size.times do |n|
+      @values[n] = 0
+    end
+    
+    @count = 0
+  end
+  
+  def size
+    (@count > @values.size) ? @values.size : @count
+  end
+  
+  def update(val)
+    @count += 1
+    if @count <= @values.size
+      @values[@count - 1] = val
+    else
+      r = rand(2**64 - 1) % @count
+      if r < @values.size
+        @values[r] = val
+      end
+    end
+  end
+  
+  def values
+    # only return @count elements
+    @values[0,@count]
+  end
+  
+end

data/lib/drone/version.rb

@@ -0,0 +1,3 @@
+module Drone
+  VERSION = "0.0.1"
+end

data/specs/common.rb

@@ -0,0 +1,63 @@
+$:.reject! { |e| e.include? 'TextMate' }
+
+require 'rubygems'
+
+puts "Testing with ruby #{RUBY_VERSION} and rubygems #{Gem::VERSION}"
+
+require 'bundler/setup'
+
+if (RUBY_VERSION >= "1.9") && ENV['COVERAGE']
+  require 'simplecov'
+  ROOT = File.expand_path('../../', __FILE__)
+  
+  puts "[[  SimpleCov enabled  ]]"
+  
+  SimpleCov.start do
+    add_filter '/gems/'
+    add_filter '/specs/'
+    
+    root(ROOT)
+  end
+end
+
+require 'bacon'
+require 'mocha'
+require 'delorean'
+require 'em-spec/bacon'
+EM.spec_backend = EventMachine::Spec::Bacon
+
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+module Bacon
+  module MochaRequirementsCounter
+    def self.increment
+      Counter[:requirements] += 1
+    end
+  end
+  
+  class Context
+    include Mocha::API
+    
+    alias_method :it_before_mocha, :it
+    
+    def it(description)
+      it_before_mocha(description) do
+        begin
+          mocha_setup
+          yield
+          mocha_verify(MochaRequirementsCounter)
+        rescue Mocha::ExpectationError => e
+          raise Error.new(:failed, "#{e.message}\n#{e.backtrace[0...10].join("\n")}")
+        ensure
+          mocha_teardown
+        end
+      end
+    end
+  end
+end
+
+def focus(test_label)
+  Bacon.const_set(:RestrictName, %r{#{test_label}})
+end
+
+Bacon.summary_on_exit()

data/specs/metrics/counter_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../../common', __FILE__)
+
+require 'drone/metrics/counter'
+include Drone
+
+describe 'Counter Metrics' do
+  before do
+    @counter = Metrics::Counter.new('something')
+  end
+
+  should "start at zero" do
+    @counter.value.should == 0
+  end
+
+  should "increment by one" do
+    @counter.inc()
+    @counter.value.should == 1
+  end
+
+  should "increment by an arbitrary delta" do
+    @counter.inc(3)
+    @counter.value.should == 3
+  end
+
+  should "decrement by one" do
+    @counter.dec()
+    @counter.value.should == -1
+  end
+
+  should "decrement by an arbitrary delta" do
+    @counter.dec(3)
+    @counter.value.should == -3
+  end
+
+  should "be zero after being cleared" do
+    @counter.inc(3)
+    @counter.clear()
+    @counter.value.should == 0
+  end
+  
+end

data/specs/metrics/gauge_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../../common', __FILE__)
+
+require 'drone/metrics/gauge'
+include Drone
+
+describe 'Geuge Metric' do
+  before do
+    @n = 0
+    @gauge = Metrics::Gauge.new("temperature"){ @n+= 1 }
+  end
+  
+  should 'require a block' do
+    err = proc{
+      Metrics::Gauge.new('dummy')
+    }.should.raise(RuntimeError)
+    
+    err.message.should.include?('Block expected')
+  end
+  
+  should 'call block when value is asked' do
+    @n.should == 0
+    @gauge.value.should == 1
+    @n.should == 1
+    
+    @gauge.value.should == 2
+  end
+  
+end

data/specs/metrics/meter_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../../common', __FILE__)
+
+require 'drone/metrics/meter'
+
+include Drone
+
+EM.describe 'Meter Metrics' do
+  before do
+    Drone::init_drone()
+  end
+  
+  describe "A meter metric with no events" do
+    before do
+      @meter = Metrics::Meter.new("thangs")
+    end
+
+    should "have a count of zero" do
+      @meter.count.should == 0
+      done
+    end
+
+    should "have a mean rate of 0 events/sec" do
+      @meter.mean_rate.should == 0.0
+      done
+    end
+  end
+
+  describe "A meter metric with three events" do
+    before do
+      @meter = Metrics::Meter.new("thangs")
+      @meter.mark(3)
+    end
+
+    should "have a count of three" do
+      @meter.count.should == 3
+      done
+    end
+  end
+  
+end

data/specs/metrics/timer_spec.rb

@@ -0,0 +1,131 @@
+require File.expand_path('../../common', __FILE__)
+
+require 'drone/metrics/timer'
+include Drone
+
+EM.describe 'Timer Metrics' do
+  before do
+    Drone::init_drone()
+    Drone::start_monitoring()
+  end
+  
+  describe "A blank timer" do
+    before do
+      @timer = Metrics::Timer.new()
+    end
+
+    should "have a max of zero" do
+      @timer.max.should.be.close?(0, 0.001)
+      done
+    end
+
+    should "have a min of zero" do
+      @timer.min.should.be.close?(0, 0.001)
+      done
+    end
+
+    should "have a mean of zero" do
+      @timer.mean.should.be.close?(0, 0.001)
+      done
+    end
+
+    should "have a count of zero" do
+      @timer.count.should == 0
+      done
+    end
+
+    should "have a standard deviation of zero" do
+      @timer.stdDev.should.be.close?(0, 0.001)
+      done
+    end
+
+    should "have a median/p95/p98/p99/p999 of zero" do
+      median, p95, p98, p99, p999 = @timer.percentiles(0.5, 0.95, 0.98, 0.99, 0.999)
+      median.should.be.close?(0, 0.001)
+      p95.should.be.close?(0, 0.001)
+      p98.should.be.close?(0, 0.001)
+      p99.should.be.close?(0, 0.001)
+      p999.should.be.close?(0, 0.001)
+      done
+    end
+
+    should "have a mean rate of zero" do
+      @timer.mean_rate.should.be.close?(0, 0.001)
+      done
+    end
+    
+    should "have a one-minute rate of zero" do
+      @timer.one_minute_rate.should.be.close?(0, 0.001)
+      done
+    end
+    
+    should "have a five-minute rate of zero" do
+      @timer.five_minutes_rate.should.be.close?(0, 0.001)
+      done
+    end
+    
+    should "have a fifteen-minute rate of zero" do
+      @timer.fifteen_minutes_rate.should.be.close?(0, 0.001)
+      done
+    end
+    
+    should "have no values" do
+      @timer.values.should == []
+      done
+    end
+  end
+  
+  
+  
+  describe "Timing a series of events" do
+    before do
+      @timer = Metrics::Timer.new()
+      @timer.update(10)
+      @timer.update(20)
+      @timer.update(20)
+      @timer.update(30)
+      @timer.update(40)
+    end
+
+    should "record the count" do
+      @timer.count.should == 5
+      done
+    end
+
+    should "calculate the minimum duration" do
+      @timer.min.should.be.close?(10, 0.001)
+      done
+    end
+
+    should "calclate the maximum duration" do
+      @timer.max.should.be.close?(40, 0.001)
+      done
+    end
+
+    should "calclate the mean duration" do
+      @timer.mean.should.be.close?(24, 0.001)
+      done
+    end
+
+    should "calclate the standard deviation" do
+      @timer.stdDev.should.be.close?(11.401, 0.001)
+      done
+    end
+
+    should "calculate the median/p95/p98/p99/p999" do
+      median, p95, p98, p99, p999 = @timer.percentiles(0.5, 0.95, 0.98, 0.99, 0.999)
+      median.should.be.close?(20, 0.001)
+      p95.should.be.close?(40, 0.001)
+      p98.should.be.close?(40, 0.001)
+      p99.should.be.close?(40, 0.001)
+      p999.should.be.close?(40, 0.001)
+      done
+    end
+
+    should "have a series of values" do
+      @timer.values.sort.should == [10, 20, 20, 30, 40]
+      done
+    end
+  end
+  
+end