pulse_meter_core 0.4.13

data/lib/pulse_meter/observer.rb

@@ -0,0 +1,118 @@
+module PulseMeter
+  class Observer
+  extend PulseMeter::Mixins::Utils
+
+    class << self
+      # Removes observation from instance method
+      # @param klass [Class] class
+      # @param method [Symbol] instance method name
+      def unobserve_method(klass, method)
+        with_observer = method_with_observer(method)
+        if klass.method_defined?(with_observer)
+          block = unchain_block(method)
+          klass.class_eval &block
+        end
+      end
+
+      # Removes observation from class method
+      # @param klass [Class] class
+      # @param method [Symbol] class method name
+      def unobserve_class_method(klass, method)
+        with_observer = method_with_observer(method)
+        if klass.respond_to?(with_observer)
+          method_owner = metaclass(klass)
+          block = unchain_block(method)
+          method_owner.instance_eval &block
+        end
+      end
+
+      # Registeres an observer for instance method
+      # @param klass [Class] class
+      # @param method [Symbol] instance method
+      # @param sensor [Object] notifications receiver
+      # @param proc [Proc] proc to be called in context of receiver each time observed method called
+      def observe_method(klass, method, sensor, &proc)
+        with_observer = method_with_observer(method)
+        unless klass.method_defined?(with_observer)
+          block = chain_block(method, sensor, &proc)
+          klass.class_eval &block
+        end
+      end
+
+      # Registeres an observer for class method
+      # @param klass [Class] class
+      # @param method [Symbol] class method
+      # @param sensor [Object] notifications receiver
+      # @param proc [Proc] proc to be called in context of receiver each time observed method called
+      def observe_class_method(klass, method, sensor, &proc)
+        with_observer = method_with_observer(method)
+        unless klass.respond_to?(with_observer)
+          method_owner = metaclass(klass)
+          block = chain_block(method, sensor, &proc)
+          method_owner.instance_eval &block
+        end
+      end
+
+      protected
+
+      def define_instrumented_method(method_owner, method, receiver, &handler)
+        with_observer = method_with_observer(method)
+        without_observer = method_without_observer(method)
+        method_owner.send(:define_method, with_observer) do |*args, &block|
+          start_time = Time.now
+          begin
+            self.send(without_observer, *args, &block)
+          ensure
+            begin
+              delta = ((Time.now - start_time) * 1000).to_i
+              receiver.instance_exec(delta, *args, &handler)
+            rescue StandardError
+            end
+          end
+        end
+      end
+
+      private
+
+      def unchain_block(method)
+        with_observer = method_with_observer(method)
+        without_observer = method_without_observer(method)
+
+        Proc.new do
+          alias_method(method, without_observer)
+          remove_method(with_observer)
+          remove_method(without_observer)
+        end
+      end
+
+      def chain_block(method, receiver, &handler)
+        with_observer = method_with_observer(method)
+        without_observer = method_without_observer(method)
+        me = self
+
+        Proc.new do 
+          alias_method(without_observer, method)
+          method_owner = self
+          me.send(:define_instrumented_method, method_owner, method, receiver, &handler)
+          alias_method(method, with_observer)
+        end
+      end
+
+      def metaclass(klass)
+        klass.class_eval do
+          class << self
+            self
+          end
+        end
+      end
+
+      def method_with_observer(method)
+        "#{method}_with_#{underscore(self).tr('/', '_')}"
+      end
+
+      def method_without_observer(method)
+        "#{method}_without_#{underscore(self).tr('/', '_')}"
+      end
+    end
+  end
+end

data/lib/pulse_meter/observer/extended.rb

@@ -0,0 +1,32 @@
+module PulseMeter
+  class Observer::Extended < ::PulseMeter::Observer
+    class << self
+      protected
+
+      def define_instrumented_method(method_owner, method, receiver, &handler)
+        with_observer = method_with_observer(method)
+        without_observer = method_without_observer(method)
+        method_owner.send(:define_method, with_observer) do |*args, &block|
+          start_time = Time.now
+          begin
+            result = self.send(without_observer, *args, &block)
+          ensure
+            begin
+              delta = ((Time.now - start_time) * 1000).to_i
+              observe_parameters = {
+                self: self,
+                delta: delta,
+                result: result,
+                args: args,
+                exception: $!
+              }
+              receiver.instance_exec(observe_parameters, &handler)
+            rescue StandardError
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/pulse_meter/sensor.rb

@@ -0,0 +1,61 @@
+require 'pulse_meter/sensor/base'
+require 'pulse_meter/sensor/configuration'
+require 'pulse_meter/sensor/counter'
+require 'pulse_meter/sensor/indicator'
+require 'pulse_meter/sensor/hashed_counter'
+require 'pulse_meter/sensor/hashed_indicator'
+require 'pulse_meter/sensor/multi'
+require 'pulse_meter/sensor/uniq_counter'
+require 'pulse_meter/sensor/timeline_reduce'
+require 'pulse_meter/sensor/timeline'
+require 'pulse_meter/sensor/timelined/average'
+require 'pulse_meter/sensor/timelined/counter'
+require 'pulse_meter/sensor/timelined/indicator'
+require 'pulse_meter/sensor/timelined/hashed_counter'
+require 'pulse_meter/sensor/timelined/hashed_indicator'
+require 'pulse_meter/sensor/timelined/zset_based'
+require 'pulse_meter/sensor/timelined/min'
+require 'pulse_meter/sensor/timelined/max'
+require 'pulse_meter/sensor/timelined/percentile'
+require 'pulse_meter/sensor/timelined/multi_percentile'
+require 'pulse_meter/sensor/timelined/median'
+require 'pulse_meter/sensor/timelined/uniq_counter'
+
+# Top level sensor module
+module PulseMeter
+
+  # Atomic sensor data
+  SensorData = Struct.new(:start_time, :value)
+
+  # General sensor exception
+  class SensorError < StandardError; end
+
+  # Exception to be raised when sensor name is malformed
+  class BadSensorName < SensorError
+    def initialize(name, options = {})
+      super("Bad sensor name: `#{name}', only a-z letters and _ are allowed")
+    end
+  end
+
+  # Exception to be raised when Redis is not initialized
+  class RedisNotInitialized < SensorError
+    def initialize
+      super("PulseMeter.redis is not set")
+    end
+  end
+
+  # Exception to be raised when sensor cannot be dumped
+  class DumpError < SensorError; end
+
+  # Exception to be raised on attempts of using the same key for different sensors
+  class DumpConflictError < DumpError; end
+
+  # Exception to be raised when sensor cannot be restored
+  class RestoreError < SensorError; end
+
+  module Remote
+    class MessageTooLarge < PulseMeter::SensorError; end
+    class ConnectionError < PulseMeter::SensorError; end
+  end
+end
+  

data/lib/pulse_meter/sensor/base.rb

@@ -0,0 +1,88 @@
+module PulseMeter
+  module Sensor
+    # @abstract Subclass and override {#event} to implement sensor 
+    class Base
+      include PulseMeter::Mixins::Dumper
+
+      # @!attribute [rw] redis
+      #   @return [Redis] 
+      attr_accessor :redis
+      # @!attribute [r] name
+      #   @return [String] sensor name
+      attr_reader :name
+
+      # Initializes sensor and dumps it to redis
+      # @param name [String] sensor name
+      # @option options [String] :annotation Sensor annotation
+      # @raise [BadSensorName] if sensor name is malformed
+      # @raise [RedisNotInitialized] unless Redis is initialized
+      def initialize(name, options={})
+        @name = name.to_s
+        if options[:annotation]
+          annotate(options[:annotation])
+        end
+        raise BadSensorName, @name unless @name =~ /\A\w+\z/
+        raise RedisNotInitialized unless PulseMeter.redis
+        dump!
+      end
+
+      # Returns Redis instance
+      def redis
+        PulseMeter.redis
+      end
+
+      def command_aggregator
+        PulseMeter.command_aggregator
+      end
+
+      # Saves annotation to Redis
+      # @param description [String] Sensor annotation
+      def annotate(description)
+        redis.set(desc_key, description)
+      end
+
+      # Retrieves annotation from Redis
+      # @return [String] Sensor annotation
+      def annotation
+        redis.get(desc_key)
+      end
+
+      # Cleans up all sensor metadata in Redis
+      def cleanup
+        redis.del(desc_key)
+        cleanup_dump
+      end
+  
+      # Processes event
+      # @param value [Object] value produced by some kind of event
+      def event(value)
+        process_event(value)
+        true
+      rescue StandardError => e
+        false
+      end
+
+      protected
+      
+      # Forms Redis key to store annotation
+      def desc_key
+        "pulse_meter:desc:#{name}"
+      end
+      
+      # For a block
+      # @yield Executes it within Redis multi
+      def multi
+        redis.multi do
+          yield
+        end
+      end
+
+      private
+
+      def process_event(value)
+        # do nothing here
+      end
+
+    end
+  end
+end

data/lib/pulse_meter/sensor/configuration.rb

@@ -0,0 +1,106 @@
+module PulseMeter
+  module Sensor
+    # Constructs multiple sensors from configuration passed 
+    class Configuration
+      include PulseMeter::Mixins::Utils
+      include Enumerable
+
+      # Initializes sensors
+      # @param opts [Hash] sensors' configuration
+      def initialize(opts = {})
+        @opts = opts
+      end
+
+      # Returns previously initialized sensor by name
+      # @param name [Symbol] sensor name
+      # @yield [sensor] Gives sensor(if it is found) to the block
+      def sensor(name)
+        raise ArgumentError, "need a block" unless block_given?
+        with_resque do
+          s = sensors[name.to_s]
+          yield(s) if s
+        end
+      end
+
+      # Returns true value if sensor with specified name exists in configuration, false otherwise
+      # @param name [Symbol] sensor name
+      def has_sensor?(name)
+        has_sensor = false
+        with_resque do
+          has_sensor = sensors.has_key?(name)
+        end
+        has_sensor
+      end
+
+      # Adds sensor
+      # @param name [Symbol] sensor name
+      # @param opts [Hash] sensor options
+      def add_sensor(name, opts)
+        with_resque do
+          sensors[name.to_s] = create_sensor(name, opts)
+        end
+      end
+
+      # Iterates over each sensor
+      def each
+        with_resque do
+          sensors.each_value do |s|
+            yield(s)
+          end
+        end
+      end
+
+      # Invokes event(_at) for any sensor 
+      # @raise [ArgumentError] unless sensor exists
+      def method_missing(name, *args)
+        with_resque do
+          name = name.to_s
+          if sensors.has_key?(name)
+            sensors[name].event(*args)
+          elsif name =~ /\A(.*)_at\z/
+            sensor_name = $1
+            sensors[sensor_name].event_at(*args) if sensors.has_key?(sensor_name) 
+          end
+        end
+      end
+
+      private
+
+      def with_resque
+        yield
+      rescue StandardError => e
+        PulseMeter.error "Configuration error: #{e}, #{e.backtrace.join("\n")}"
+        nil
+      end
+
+
+      # Tries to create a specific sensor
+      # @param name [Symbol] sensor name
+      # @param opts [Hash] sensor options
+      def create_sensor(name, opts)
+        sensor_type = opts.respond_to?(:sensor_type) ? opts.sensor_type : opts[:sensor_type]
+        klass_s = sensor_class(sensor_type)
+        klass = constantize(klass_s)
+        raise ArgumentError, "#{klass_s} is not a valid class for a sensor" unless klass
+        args = (opts.respond_to?(:args) ? opts.args : opts[:args]) || {}
+        klass.new(name, symbolize_keys(args.to_hash))
+      end
+
+      def sensor_class(sensor_type)
+        entries = sensor_type.to_s.split('/').map do |entry|
+          entry.split('_').map(&:capitalize).join
+        end
+        entries.unshift('PulseMeter::Sensor').join('::')
+      end
+
+      # Lazy collection of sensors, specified by opts
+      # @raise [ArgumentError] unless one of the sensors exists
+      def sensors
+        @sensors ||= @opts.each_with_object({}){ |(name, opts), sensor_acc|
+          sensor_acc[name.to_s] = create_sensor(name, opts)
+        }
+      end
+
+    end
+  end
+end

data/lib/pulse_meter/sensor/counter.rb

@@ -0,0 +1,39 @@
+# Static counter
+module PulseMeter
+  module Sensor
+    class Counter < Base
+
+      # Cleans up all sensor metadata in Redis
+      def cleanup
+        redis.del(value_key)
+        super
+      end
+
+      # Increments counter value by 1
+      def incr
+        event(1)
+      end
+
+      # Gets counter value
+      # @return [Fixnum]
+      def value
+        redis.get(value_key).to_i
+      end
+      
+      # Gets redis key by which counter value is stored
+      # @return [String]
+      def value_key
+        @value_key ||= "pulse_meter:value:#{name}"
+      end
+
+      private
+
+      # Processes event by incremnting counter by given value
+      # @param value [Fixnum] increment
+      def process_event(value)
+        command_aggregator.incrby(value_key, value.to_i)
+      end
+
+    end
+  end
+end