pulse-meter 0.4.9 → 0.4.11

data/lib/pulse-meter/observer.rb

@@ -1,120 +0,0 @@
-require 'pulse-meter'
-
-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

@@ -1,34 +0,0 @@
-require 'pulse-meter'
-
-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

@@ -1,61 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,39 +0,0 @@
-# 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