drone 1.0.2 → 1.0.4

data/lib/drone/interfaces/base.rb

@@ -0,0 +1,17 @@
+module Drone
+  module Interfaces
+    
+    class Base
+      def initialize(period)
+        @period = period
+        Drone::schedule_periodic(period){ output() }
+      end
+      
+      def output
+        raise "Uninmplemented"
+      end
+      
+    end
+    
+  end
+end

data/lib/drone/interfaces/console.rb

@@ -0,0 +1,82 @@
+require File.expand_path('../base', __FILE__)
+
+module Drone
+  module Interfaces
+    ##
+    # This interface is meant for debug mainly, it will
+    # simply output all the available metrics at a regular
+    # interval on the console.
+    # 
+    # @example
+    #   require 'drone'
+    #   Drone::init_drone()
+    #   Drone::add_output(:console, 1)
+    #
+    class Console < Base
+            
+      def output()
+        puts ""
+        puts "[#{Time.now.strftime('%M:%S')}] Drone report:"
+        Drone::each_metric do |m|
+          case m
+          when Metrics::Gauge
+            puts "[Gauge] #{m.name} : #{m.value}"
+            
+          when Metrics::Counter
+            puts "[Counter] #{m.name} : #{m.value}"
+            
+          when Metrics::Timer
+            puts "[Timer] #{m.name}"
+            print_histogram(m)
+            
+          when Metrics::Meter
+            puts "[Meter] #{m.name}"
+            print_meter(m)
+          
+          when Metrics::Histogram
+            puts "[Histogram] #{m.name}"
+            print_histogram(m)
+            
+          else
+            puts "Unknown metric: #{m}"
+          end
+        end
+      end
+      
+      
+    private
+      def print_meter(m)
+        puts format("%20s : %d", "count", m.count)
+        
+        {
+          'mean rate'     => m.mean_rate,
+          '1-minute rate' => m.one_minute_rate,
+          '5-minute rate' => m.five_minutes_rate,
+          '15-minute rate' => m.fifteen_minutes_rate
+        }.each do |label, value|
+          puts format("%20s : %2.2f", label, value)
+        end
+      end
+      
+      def print_histogram(m)
+        percentiles = m.percentiles(0.5, 0.75, 0.95, 0.98, 0.99, 0.999)
+        {
+          'min'     => m.min,
+          'max'     => m.max,
+          'mean'    => m.mean,
+          'stddev'  => m.stdDev,
+          'median'  => percentiles[0],
+          '75%'     => percentiles[1],
+          '%95'     => percentiles[2],
+          '%98'     => percentiles[3],
+          '%99'     => percentiles[4],
+          '%99.9'   => percentiles[5]
+        }.each do |label, value|
+          puts format("%20s : %2.2f", label, value)
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/drone/metrics/counter.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../metric', __FILE__)
+
+module Drone
+  module Metrics
+    
+    ##
+    # A Counter store a number which can go up or down,
+    # the counter can change a counter value with
+    # the methods increment and decrement aliased
+    # as inc and dec
+    # 
+    class Counter < Metric
+    
+      def initialize(name, initial_value = 0)
+        super(name)
+        
+        @value = Drone::request_number("#{name}:value", initial_value)
+      end
+      
+      def value
+        @value.get
+      end
+    
+      def increment(n = 1)
+        @value.inc(n)
+      end
+      alias :inc :increment
+    
+      def decrement(n = 1)
+        @value.dec(n)
+      end
+      alias :dec :decrement
+    
+      def clear
+        @value.set(0)
+      end
+    end
+    
+  end
+end

data/lib/drone/metrics/gauge.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../metric', __FILE__)
+
+module Drone
+  module Metrics
+    
+    ##
+    # Gauge are linked to a block of code which
+    # will be called when the value is asked, the block
+    # is expected to return a number
+    # 
+    class Gauge < Metric
+    
+      def initialize(name, &block)
+        raise "Block expected" unless block
+        super(name)
+        @block = block
+      end
+    
+      def value
+        @block.call()
+      end
+    end
+    
+  end
+end

data/lib/drone/metrics/histogram.rb

@@ -0,0 +1,153 @@
+require File.expand_path('../../utils/uniform_sample', __FILE__)
+require File.expand_path('../../utils/exponentially_decaying_sample', __FILE__)
+require File.expand_path('../metric', __FILE__)
+
+module Drone
+  
+  ##
+  # An Histogram store a list of values (1028) and can
+  # compute on demand statistics on those values:
+  # - min/max
+  # - mean
+  # - stddev
+  # - percentiles
+  # 
+  class Histogram < Metric    
+    MIN = (-(2**63)).freeze
+    MAX = ((2**64) - 1).freeze
+    
+    def initialize(name, sample_or_type = :uniform)
+      super(name)
+      
+      if sample_or_type.is_a?(Symbol)
+        case sample_or_type
+        when :uniform   then  @sample = UniformSample.new("#{name}:sample", 1028)
+        when :biased    then  @sample = ExponentiallyDecayingSample.new("#{name}:sample", 1028, 0.015)
+        else
+          raise ArgumentError, "unknown type: #{sample_or_type}"
+        end
+      else
+        @sample = sample_or_type
+      end
+      
+      @count = Drone::request_number("#{name}:count", 0)
+      @_min = Drone::request_number("#{name}:min", MAX)
+      @_max = Drone::request_number("#{name}:max", MIN)
+      @_sum = Drone::request_number("#{name}:max", 0)
+      @varianceM = Drone::request_number("#{name}:varianceM", -1)
+      @varianceS = Drone::request_number("#{name}:varianceS", 0)
+      
+    end
+    
+    def clear
+      @sample.clear()
+      @count = 0
+      @_min = MAX
+      @_max = MIN
+      @_sum = 0
+      @varianceM = -1
+      @varianceS = 0
+    end
+    
+    def update(val)
+      @count.inc
+      @sample.update(val)
+      set_max(val);
+      set_min(val);
+      @_sum.inc(val)
+      update_variance(val)
+    end
+    
+    def count
+      @count.get
+    end
+    
+    def max
+      (@count.get > 0) ? @_max.get : 0.0
+    end
+    
+    def min
+      (@count.get > 0) ? @_min.get : 0.0
+    end
+    
+    def mean
+      (@count.get > 0) ? @_sum.get.to_f / @count.get : 0.0
+    end
+    
+    def stdDev
+      (@count.get > 0) ? Math.sqrt( variance() ) : 0.0
+    end
+    
+    def percentiles(*percentiles)
+      scores = Array.new(percentiles.size, 0)
+      if @count.get > 0
+        values = @sample.values.sort
+        percentiles.each.with_index do |p, i|
+          pos = p * (values.size + 1)
+          if pos < 1
+            scores[i] = values[0]
+          elsif pos >= values.size
+            scores[i] = values[-1]
+          else
+            lower = values[pos - 1]
+            upper = values[pos]
+            scores[i] = lower + (pos - pos.floor) * (upper - lower)
+          end
+        end
+      end
+      
+      scores
+    end
+    
+    def values
+      @sample.values
+    end
+    
+  private
+  
+    def doubleToLongBits(n)      
+      [n].pack('D').unpack('q')[0]
+    end
+    
+    def longBitsToDouble(n)
+      [n].pack('q').unpack('D')[0]
+    end
+    
+    def update_variance(val)
+      if @varianceM.get == -1
+        @varianceM.set( doubleToLongBits(val) )
+      else
+        oldMCas = @varianceM.get
+        oldM = longBitsToDouble(oldMCas)
+        newM = oldM + ((val - oldM) / count())
+        
+        oldSCas = @varianceS.get
+        oldS = longBitsToDouble(oldSCas)
+        newS = oldS + ((val - oldM) * (val - newM))
+        
+        @varianceM.set( doubleToLongBits(newM) )
+        @varianceS.set( doubleToLongBits(newS) )
+      end
+    end
+    
+    def variance
+      count = @count.get
+      if count <= 1
+        0.0
+      else
+        longBitsToDouble(@varianceS.get) / (count - 1)
+      end
+    end
+    
+    def set_max(val)
+      (@_max.get >= val) || @_max.set(val)
+    end
+    
+    def set_min(val)
+      (@_min.get <= val) || @_min.set(val)
+    end
+    
+    
+    
+  end
+end

data/lib/drone/metrics/meter.rb

@@ -0,0 +1,82 @@
+require 'eventmachine'
+
+require File.expand_path('../metric', __FILE__)
+require File.expand_path('../../core', __FILE__)
+require File.expand_path('../../utils/ewma', __FILE__)
+
+module Drone
+  module Metrics
+    ##
+    # A meter measures mean throughput and one-, five-, and
+    # fifteen-minute exponentially-weighted moving average throughputs.
+    # 
+    class Meter < Metric
+      INTERVAL = 5
+      
+      def initialize(name)
+        super(name)
+        @start_time = Drone::request_number("#{name}:start_time", Time.now)
+        @next_tick = Drone::request_number("#{name}:next_tick_lock", 1)
+        
+        @count = Drone::request_number("#{name}:count", 0)
+        @rates = {
+          1   => EWMA.one_minute_ewma("#{name}:rate1"),
+          5   => EWMA.five_minutes_ewma("#{name}:rate5"),
+          15  => EWMA.fifteen_minutes_ewma("#{name}:rate15")
+        }
+        
+        Drone::schedule_periodic(INTERVAL) do
+          Fiber.new{ tick() }.resume
+        end
+      end
+
+      def tick
+        # init if required
+        @local_next_tick ||= @next_tick.get
+        
+        # ensure only one process will trigger the tick
+        if @next_tick.compare_and_set(@local_next_tick, @local_next_tick + 1)
+          @rates.values.each(&:tick)
+          @local_next_tick += 1
+        else
+          # reset the tick counter to give a chance to this
+          # process to trigger the next tick
+          @local_next_tick = @next_tick.get()
+        end
+      end
+
+      def mark(events = 1)
+        @count.inc(events)
+        @rates.each do |_, r|
+          r.update(events)
+        end
+      end
+      
+      def count
+        @count.get
+      end
+
+      def mean_rate
+        count = @count.get
+        if count == 0
+          0.0
+        else
+          count / (Time.now.to_f - @start_time.get.to_f)
+        end
+      end
+
+      def one_minute_rate
+        @rates[1].rate()
+      end
+
+      def five_minutes_rate
+        @rates[5].rate()
+      end
+
+      def fifteen_minutes_rate
+        @rates[15].rate()
+      end
+      
+    end
+  end
+end

data/lib/drone/metrics/metric.rb

@@ -0,0 +1,16 @@
+module Drone
+  class Metric
+    ##
+    # Every metric must have a name to be referenced by
+    # 
+    # @attr_reader [String] name The metric's name
+    #   (which is also its id)
+    # 
+    attr_reader :name
+    
+    def initialize(name)
+      @name = name
+    end
+    
+  end
+end

data/lib/drone/metrics/timer.rb

@@ -0,0 +1,57 @@
+require 'forwardable'
+require File.expand_path('../histogram', __FILE__)
+require File.expand_path('../meter', __FILE__)
+require File.expand_path('../metric', __FILE__)
+
+module Drone
+  module Metrics
+    ##
+    # The timer metric will record the time spent in a given method
+    # or any block of code.
+    # 
+    # All the times are in milliseconds.
+    # 
+    class Timer < Metric
+      extend Forwardable
+      
+      def_delegators :@histogram, :count, :min, :max, :mean, :stdDev, :percentiles, :values
+      
+      def initialize(name)
+        super(name)
+        
+        @histogram = Histogram.new("#{name}:histogram", :biased)
+      end
+      
+      def count
+        @histogram.count
+      end
+      
+      def clear
+        @histogram.clear()
+      end
+      
+      ##
+      # Method used to record a new duration
+      # 
+      # @param [Float] duration A duration in milliseconds
+      # 
+      def update(duration)
+        if duration >= 0
+          @histogram.update(duration)
+        end
+      end
+      
+      ##
+      # time and record the duration of the block
+      # @yield [] The block to time
+      # 
+      def time
+        started_at = Time.now.to_f
+        yield()
+      ensure
+        update((Time.now.to_f - started_at.to_f) * 1000)
+      end
+      
+    end
+  end
+end