drone 0.0.1

data/lib/drone/interfaces/console.rb

@@ -0,0 +1,83 @@
+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_meter(m)
+            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,28 @@
+module Drone
+  module Metrics
+    
+    class Counter
+      attr_reader :value, :name
+    
+      def initialize(name, initial_value = 0)
+        @name = name
+        @value = initial_value
+      end
+    
+      def increment(n = 1)
+        @value += n
+      end
+      alias :inc :increment
+    
+      def decrement(n = 1)
+        @value -= n
+      end
+      alias :dec :decrement
+    
+      def clear
+        @value = 0
+      end
+    end
+    
+  end
+end

data/lib/drone/metrics/gauge.rb

@@ -0,0 +1,24 @@
+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
+      attr_reader :name
+    
+      def initialize(name, &block)
+        raise "Block expected" unless block
+        @name = name
+        @block = block
+      end
+    
+      def value
+        @block.call()
+      end
+    end
+    
+  end
+end

data/lib/drone/metrics/histogram.rb

@@ -0,0 +1,132 @@
+require File.expand_path('../../utils/uniform_sample', __FILE__)
+require File.expand_path('../../utils/exponentially_decaying_sample', __FILE__)
+
+module Drone
+  class Histogram
+    TYPE_UNIFORM  = lambda{ UniformSample.new(1028) }
+    TYPE_BIASED   = lambda{ ExponentiallyDecayingSample.new(1028, 0.015) }
+    
+    MIN = (-(2**63)).freeze
+    MAX = ((2**64) - 1).freeze
+    
+    def initialize(sample_or_type = TYPE_UNIFORM)
+      if sample_or_type.is_a?(Proc)
+        @sample = sample_or_type.call()
+      else
+        @sample = sample_or_type
+      end
+      
+      clear()
+    end
+    
+    def clear
+      @sample.clear()
+      @count = 0
+      @_min = MAX
+      @_max = MIN
+      @_sum = 0
+      @varianceM = -1
+      @varianceS = 0
+    end
+    
+    def update(val)
+      @count += 1
+      @sample.update(val)
+      set_max(val);
+      set_min(val);
+      @_sum += val
+      update_variance(val)
+    end
+    
+    def count
+      @count
+    end
+    
+    def max
+      (@count > 0) ? @_max : 0.0
+    end
+    
+    def min
+      (@count > 0) ? @_min : 0.0
+    end
+    
+    def mean
+      (@count > 0) ? @_sum.to_f / @count : 0.0
+    end
+    
+    def stdDev
+      (@count > 0) ? Math.sqrt( variance() ) : 0.0
+    end
+    
+    def percentiles(*percentiles)
+      scores = Array.new(percentiles.size, 0)
+      if @count > 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 == -1
+        @varianceM = doubleToLongBits(val)
+      else
+        oldMCas = @varianceM
+        oldM = longBitsToDouble(oldMCas)
+        newM = oldM + ((val - oldM) / count())
+        
+        oldSCas = @varianceS
+        oldS = longBitsToDouble(oldSCas)
+        newS = oldS + ((val - oldM) * (val - newM))
+        
+        @varianceM = doubleToLongBits(newM)
+        @varianceS = doubleToLongBits(newS)
+      end
+    end
+    
+    def variance
+      if @count <= 1
+        0.0
+      else
+        longBitsToDouble(@varianceS) / (count() - 1)
+      end
+    end
+    
+    def set_max(val)
+      (@_max >= val) || @_max = val
+    end
+    
+    def set_min(val)
+      (@_min <= val) || @_min = val
+    end
+    
+    
+    
+  end
+end

data/lib/drone/metrics/meter.rb

@@ -0,0 +1,62 @@
+require 'eventmachine'
+
+require File.expand_path('../../core', __FILE__)
+require File.expand_path('../../utils/ewma', __FILE__)
+
+module Drone
+  module Metrics
+    # A meter metric which measures mean throughput and one-, five-, and
+    # fifteen-minute exponentially-weighted moving average throughputs.
+    class Meter
+      INTERVAL = 5
+      
+      attr_reader :count, :name
+      
+      def initialize(name)
+        @name = name
+        @start_time = Time.now
+        @count = 0
+        @rates = {
+          1   => EWMA.one_minute_ewma,
+          5   => EWMA.five_minutes_ewma,
+          15  => EWMA.fifteen_minutes_ewma
+        }
+        
+        Drone::schedule_periodic(INTERVAL){ tick() }
+      end
+
+      def tick
+        @rates.values.each(&:tick)
+      end
+
+      def mark(events = 1)
+        @count += events
+        @rates.each do |_, r|
+          r.update(events)
+        end
+      end
+
+      def mean_rate
+        if @count == 0
+          0.0
+        else
+          elapsed = Time.now.to_f - @start_time.to_f
+          @count / elapsed
+        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/timer.rb

@@ -0,0 +1,62 @@
+
+require File.expand_path('../histogram', __FILE__)
+require File.expand_path('..//meter', __FILE__)
+
+module Drone
+  module Metrics
+    class Timer
+      def initialize(name = 'calls')
+        @histogram = Histogram.new(Histogram::TYPE_BIASED)
+        @meter = Meter.new(name)
+        clear()
+      end
+      
+      def count
+        @histogram.count
+      end
+      
+      [:fifteen_minutes_rate, :five_minutes_rate, :mean_rate, :one_minute_rate].each do |attr_name|
+        define_method(attr_name) do
+          @meter.send(attr_name)
+        end
+      end
+      
+      # may requires a conversion... or not
+      [:count, :min, :max, :mean, :stdDev, :percentiles, :values].each do |attr_name|
+        define_method(attr_name) do |*args|
+          @histogram.send(attr_name, *args)
+        end
+      end
+      
+      def clear
+        @histogram.clear()
+      end
+      
+      #
+      # duration: milliseconds
+      def update(duration)
+        if duration >= 0
+          @histogram.update(duration)
+          @meter.mark()
+        end
+      end
+      
+      #
+      # time and record the duration of the block
+      def time
+        started_at = Time.now.to_f
+        yield()
+      ensure
+        update(Time.now.to_f - started_at.to_f)
+      end
+      
+      
+      
+      
+      def name
+        @meter.name
+      end
+      
+    end
+  end
+end

data/lib/drone/monitoring.rb

@@ -0,0 +1,107 @@
+require File.expand_path('../metrics/meter', __FILE__)
+require File.expand_path('../metrics/timer', __FILE__)
+
+module Drone
+  ##
+  # This module contains what is needed to instruments
+  # class methods easily
+  # 
+  module Monitoring
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+      
+      Drone::register_monitored_class(base)
+    end
+    
+    module ClassMethods
+    # external API
+      
+      ##
+      # Monitor the call rate of the following method
+      # 
+      # @param [String] name metric name, it must be unique and will be shared
+      #                       among all the objects of this class
+      # @api public
+      # 
+      def monitor_rate(name)
+        meter = Drone::find_metric(name) || Metrics::Meter.new(name)
+        unless meter.is_a?(Metrics::Meter)
+          raise(TypeError, "metric #{name} is already defined as #{rate.class}")
+        end
+        
+        Drone::register_meter(meter)
+        @_rate_waiting = meter
+      end
+      
+      ##
+      # Monitor the time of execution as well as the
+      # call rate
+      # 
+      # @param [String] name metric name, it must be unique and will be shared
+      #                       among all the objects of this class
+      # 
+      # @api public
+      # 
+      def monitor_time(name)
+        timer = Drone::find_metric(name) || Metrics::Timer.new(name)
+        unless timer.is_a?(Metrics::Timer)
+          raise(TypeError, "metric #{name} is already defined as #{rate.class}")
+        end
+        Drone::register_meter(timer)
+        @_timer_waiting = timer
+      end
+      
+      
+    # internals
+      
+      ##
+      # @private
+      # 
+      def method_added(m)
+        return if @_ignore_added
+        
+        @_ignore_added = true
+        ma_rate_meter(m) if @_rate_waiting
+        ma_timer_meter(m) if @_timer_waiting
+        @_ignore_added = false
+      end
+      
+      ##
+      # @private
+      # 
+      def ma_rate_meter(m)
+        rate = @_rate_waiting
+        @_rate_waiting = nil
+        
+        define_method("instrumented_#{m}") do |*args, &block|
+          rate.mark()
+          send("original_#{m}", *args, &block)
+        end
+        
+        alias_method "original_#{m}", m
+        alias_method m, "instrumented_#{m}"
+      end
+      
+      ##
+      # @private
+      # 
+      def ma_timer_meter(m)
+        timer = @_timer_waiting
+        @_timer_waiting = nil
+        
+        define_method("instrumented_#{m}") do |*args, &block|
+          timer.time do
+            send("original_#{m}", *args, &block)
+          end
+        end
+        
+        alias_method "original_#{m}", m
+        alias_method m, "instrumented_#{m}"
+      end
+      
+    end
+    
+  end
+end