drone 0.0.3 → 1.0.1

data/lib/drone/metrics/meter.rb

@@ -1,47 +1,67 @@
 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 metric which measures mean throughput and one-, five-, and
+    ##
+    # A meter measures mean throughput and one-, five-, and
     # fifteen-minute exponentially-weighted moving average throughputs.
-    class Meter
+    # 
+    class Meter < Metric
       INTERVAL = 5
       
-      attr_reader :count, :name
-      
       def initialize(name)
-        @name = name
-        @start_time = Time.now
-        @count = 0
+        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,
-          5   => EWMA.five_minutes_ewma,
-          15  => EWMA.fifteen_minutes_ewma
+          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){ tick() }
+        Drone::schedule_periodic(INTERVAL) do
+          Fiber.new{ tick() }.resume
+        end
       end
 
       def tick
-        @rates.values.each(&: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 += events
+        @count.inc(events)
         @rates.each do |_, r|
           r.update(events)
         end
       end
+      
+      def count
+        @count.get
+      end
 
       def mean_rate
-        if @count == 0
+        count = @count.get
+        if count == 0
           0.0
         else
-          elapsed = Time.now.to_f - @start_time.to_f
-          @count / elapsed
+          count / (Time.now.to_f - @start_time.get.to_f)
         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

@@ -1,48 +1,55 @@
-
+require 'forwardable'
 require File.expand_path('../histogram', __FILE__)
-require File.expand_path('..//meter', __FILE__)
+require File.expand_path('../meter', __FILE__)
+require File.expand_path('../metric', __FILE__)
 
 module Drone
   module Metrics
-    class Timer
-      attr_reader :name
+    ##
+    # 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 = 'calls')
-        @name = name
-        @histogram = Histogram.new(Histogram::TYPE_BIASED)
-        clear()
+      def initialize(name)
+        super(name)
+        
+        @histogram = Histogram.new("#{name}:histogram", :biased)
       end
       
       def count
         @histogram.count
       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
+      ##
+      # 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)
+        update((Time.now.to_f - started_at.to_f) * 1000)
       end
       
     end

data/lib/drone/monitoring.rb

@@ -31,7 +31,7 @@ module Drone
           raise(TypeError, "metric #{name} is already defined as #{rate.class}")
         end
         
-        Drone::register_meter(meter)
+        Drone::register_metric(meter)
         @_rate_waiting = meter
       end
       
@@ -49,7 +49,7 @@ module Drone
         unless timer.is_a?(Metrics::Timer)
           raise(TypeError, "metric #{name} is already defined as #{rate.class}")
         end
-        Drone::register_meter(timer)
+        Drone::register_metric(timer)
         @_timer_waiting = timer
       end
       

data/lib/drone/storage/base.rb

@@ -0,0 +1,122 @@
+module Drone
+  module Storage
+    
+    ##
+    # Represents a number but procide a specific api
+    # allowing this number to shared anywhere
+    # 
+    class SharedNumber
+      ##
+      # Constructor
+      # 
+      # @param [Number] initial_value The initial value
+      # 
+      def initialize(initial_value)
+        raise "needs to be redefined"
+      end
+      
+      ##
+      # Increment the value
+      # 
+      # @param [Number] n Increment by n
+      # 
+      def inc(n = 1)
+        raise "needs to be redefined"
+      end
+      
+      ##
+      # Decrement the value
+      # 
+      # @param [Number] n Decrement by n
+      # 
+      def dec(n = 1)
+        raise "needs to be redefined"
+      end
+      
+      ##
+      # Set the value
+      # 
+      # @param [Number] n The new value
+      # 
+      def set(n)
+        raise "needs to be redefined"
+      end
+      
+      ##
+      # Get the current value
+      # 
+      # @return [Number] The current value
+      # 
+      def get
+        raise "needs to be redefined"
+      end
+      
+      ##
+      # Set a new value and return the old one
+      # 
+      # @param [Number] n The new value
+      # 
+      # @return [Number] The old value
+      # 
+      def get_and_set(n)
+        raise "needs to be redefined"
+      end
+      
+      ##
+      # Set the new value but only if the current value
+      # is equal to expected.
+      # 
+      # @param [Number] expected The expected current value
+      # @param [Number] new_value The new value
+      # 
+      def compare_and_set(expected, new_value)
+        raise "needs to be redefined"
+      end
+      
+    end
+    
+    class Base
+      
+      ##
+      # Request a fixed size array.
+      # 
+      # @param [String] id Any string which makes sense in the context
+      # @param [Number] size The Array size
+      # @param [Number] initial_value The default value for the cells
+      # 
+      # @return [Object] Returns an object which share the same external interface as
+      #   the Array class
+      # 
+      def request_fixed_size_array(id, size, initial_value = nil)
+        raise "needs to be redefined"
+      end
+      
+      ##
+      # Request a hash.
+      # 
+      # @param [String] id Any string which makes sense in the context
+      # 
+      # @return [Object] Returns an object which share the same external interface as
+      #   the Hash class
+      # 
+      def request_hash(id)
+        raise "needs to be redefined"
+      end
+      
+      ##
+      # Request a number "slot".
+      # 
+      # @param [String] id Any string which makes sense in the context
+      # @param [Number] initial_value The intial value
+      # 
+      # @return [SharedNumber] An intance of a class inheriting SharedNumber
+      # 
+      # @see SharedNumber
+      # 
+      def request_number(id, initial_value = 0)
+        raise "needs to be redefined"
+      end
+    end
+    
+  end
+end

data/lib/drone/storage/memory.rb

@@ -0,0 +1,58 @@
+require File.expand_path('../base', __FILE__)
+
+module Drone
+  module Storage
+    
+    class Memory < Base
+      
+      class MemorySharedNumber
+        def initialize(initial_value)
+          @store = initial_value
+        end
+        
+        def inc(n = 1)
+          @store += n
+        end
+        
+        def dec(n = 1)
+          @store -= n
+        end
+        
+        def set(n)
+          @store = n
+        end
+        
+        def get
+          @store
+        end
+        
+        def get_and_set(n)
+          ret = @store
+          set(n)
+          ret
+        end
+        
+        def compare_and_set(expected, new_value)
+          # dummy implementation, with memory storage nothing can
+          # happen to our data
+          set(new_value)
+        end
+        
+      end
+      
+      def request_fixed_size_array(id, size, initial_value = nil)
+        Array.new(size, initial_value)
+      end
+      
+      def request_hash(id)
+        Hash.new
+      end
+      
+      def request_number(id, initial_value = 0)
+        MemorySharedNumber.new(initial_value)
+      end
+      
+    end
+    
+  end
+end

data/lib/drone/utils/ewma.rb

@@ -1,50 +1,55 @@
-# 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
+require File.expand_path('../../core', __FILE__)
+
+module Drone
+  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(id)
+      new(id, M1_ALPHA, 5000)
+    end
   
-  def self.five_minutes_ewma
-    new(M5_ALPHA, 5000)
-  end
+    def self.five_minutes_ewma(id)
+      new(id, M5_ALPHA, 5000)
+    end
   
-  def self.fifteen_minutes_ewma
-    new(M15_ALPHA, 5000)
-  end
+    def self.fifteen_minutes_ewma(id)
+      new(id, M15_ALPHA, 5000)
+    end
   
   
-  # interval: in ms
-  def initialize(alpha, interval)
-    @alpha = alpha
-    @interval = interval.to_f # * (1000*1000)
-    @uncounted = 0
-    @rate = nil
-  end
+    # interval: in ms
+    def initialize(name, alpha, interval)
+      @alpha = alpha
+      @interval = interval.to_f # * (1000*1000)
+      @uncounted = Drone::request_number("#{name}:uncounted", 0)
+      @rate = Drone::request_number("#{name}:rate", nil)
+    end
   
-  def update(n)
-    @uncounted += n
-  end
+    def update(n)
+      @uncounted.inc(n)
+    end
   
-  def tick()
-    count = @uncounted
-    @uncounted = 0
-    instant_rate = count / @interval
-    if @rate
-      @rate += (@alpha * (instant_rate - @rate))
-    else
-      @rate = instant_rate
+    def tick()
+      count = @uncounted.get_and_set(0)
+      
+      instant_rate = count / @interval
+      rate = @rate.get
+      
+      if rate
+        @rate.inc( @alpha * (instant_rate - rate) )
+      else
+        @rate.set( instant_rate )
+      end
     end
-  end
   
-  def rate(as = :seconds)
-    case as
-    when :ms        then  @rate
-    when :seconds   then  @rate * 1000
+    def rate(as = :seconds)
+      case as
+      when :ms        then  @rate.get
+      when :seconds   then  @rate.get * 1000
+      end
     end
-  end
   
+  end
 end