drone 1.0.2 → 1.0.4

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_metric(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_metric(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("#{m}_with_meter") do |*args, &block|
+          rate.mark()
+          send("#{m}_without_meter", *args, &block)
+        end
+        
+        alias_method "#{m}_without_meter", m
+        alias_method m, "#{m}_with_meter"
+      end
+      
+      ##
+      # @private
+      # 
+      def ma_timer_meter(m)
+        timer = @_timer_waiting
+        @_timer_waiting = nil
+        
+        define_method("#{m}_with_timer") do |*args, &block|
+          timer.time do
+            send("#{m}_without_timer", *args, &block)
+          end
+        end
+        
+        alias_method "#{m}_without_timer", m
+        alias_method m, "#{m}_with_timer"
+      end
+      
+    end
+    
+  end
+end

data/lib/drone/schedulers/eventmachine.rb

@@ -0,0 +1,70 @@
+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
+      
+      ##
+      # @private
+      # 
+      def self.reset
+        @timers_once.clear()
+        @timers_periodic.clear()
+        @started = false
+      end
+      
+    end
+  end
+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

@@ -0,0 +1,55 @@
+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(id)
+      new(id, M5_ALPHA, 5000)
+    end
+  
+    def self.fifteen_minutes_ewma(id)
+      new(id, M15_ALPHA, 5000)
+    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.inc(n)
+    end
+  
+    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
+  
+    def rate(as = :seconds)
+      case as
+      when :ms        then  @rate.get
+      when :seconds   then  @rate.get * 1000
+      end
+    end
+  
+  end
+end

data/lib/drone/utils/exponentially_decaying_sample.rb

@@ -0,0 +1,81 @@
+require File.expand_path('../../core', __FILE__)
+
+module Drone
+  class ExponentiallyDecayingSample
+    # 1 hour in ms
+    RESCALE_THRESHOLD = (1 * 60 * 60 * 1000).freeze
+  
+    def initialize(id, reservoir_size, alpha)
+      @id = id
+      @values = Drone::request_hash("#{@id}:values")
+      @count = Drone::request_number("#{@id}:count", 0)
+      @start_time = Drone::request_number("#{@id}:start_time", current_time())
+      @next_scale_time = Drone::request_number("#{@id}:next_scale_time", current_time() + RESCALE_THRESHOLD)
+      
+      @alpha = alpha
+      @reservoir_size = reservoir_size
+    end
+  
+    def clear
+      @values.clear()
+      @count.set(0)
+      @start_time.set(current_time())
+      @next_scale_time.set( current_time() + RESCALE_THRESHOLD )
+    end
+  
+    def size
+      count =  @count.get
+      (@values.size < count) ? @values.size : count
+    end
+  
+  
+    def update(val, time = current_time)
+      priority = weight(time - @start_time.get) / rand()
+      count = @count.inc
+      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.get
+        rescale(now)
+      end
+    end
+  
+    def values
+      @values.keys.sort.inject([]) do |buff, key|
+        buff << @values[key]
+      end
+    end
+  
+    def rescale(now)
+      @next_scale_time.set( current_time() + RESCALE_THRESHOLD )
+      new_start = current_time()
+      old_start = @start_time.get_and_set(new_start)
+    
+      @values = Hash[ @values.map{ |k,v|
+          [k * Math.exp(-@alpha * (new_start - old_start)), v]
+        }]
+    
+    end
+  
+  private
+  
+    def current_time
+      Time.now.to_f * 1000
+    end
+  
+    def weight(n)
+      Math.exp(@alpha * n)
+    end
+  
+  end
+end