pulse-meter 0.1.10 → 0.1.11

data/README.md

@@ -44,6 +44,7 @@ following static sensors are available:
 
   * Counter
   * Hashed Counter
+  * Unique Counter
   * Indicator
 
 They have no web visualisation interface and they are assumed to be used by external visualisation tools.
@@ -64,6 +65,7 @@ The following timeline sensors are available:
   * Min value
   * Median value
   * Percentile
+  * Unique counter
 
 There are several caveats with timeline sensors:
 
@@ -140,6 +142,63 @@ Just create sensor objects and write data. Some examples below.
     # prints somewhat like
     # 2012-05-24 11:07:00 +0400: 3.0
     # 2012-05-24 11:08:00 +0400: 7.0
+ 
+ There is also an alternative and a bit more DRY way for sensor creation, management and usage using <tt>PulseMeter::Sensor::Configuration</tt> class. It is also convenient for creating a bunch of sensors from some configuration data.  
+ 
+	require 'pulse-meter'
+	PulseMeter.redis = Redis.new
+	
+	sensors = PulseMeter::Sensor::Configuration.new(
+	  my_counter: {sensor_type: 'counter'},
+	  my_value: {sensor_type: 'indicator'},
+	  my_h_counter: {sensor_type: 'hashed_counter'},
+	  my_t_counter: {
+	    sensor_type: 'timelined/counter',
+	    args: {
+	      interval: 60,         # count for each minute
+	      ttl: 24 * 60 * 60     # keep data one day
+	    }
+	  },
+	  my_t_max: {
+	    sensor_type: 'timelined/max',
+	    args: {
+	      interval: 60,         # count for each minute
+	      ttl: 24 * 60 * 60     # keep data one day
+	    }
+	  }
+	)
+	
+	sensors.my_counter(1)
+	sensors.my_counter(2)
+	puts sensors.sensor(:my_counter).value
+	
+	sensors.my_value(3.14)
+	sensors.my_value(2.71)
+	puts sensors.sensor(:my_value).value
+	
+	sensors.my_h_counter(:x => 1)
+	sensors.my_h_counter(:y => 5)
+	sensors.my_h_counter(:y => 1)
+	p sensors.sensor(:my_h_counter).value
+	
+	sensors.my_t_counter(1)
+	sensors.my_t_counter(1)
+	sleep(60)
+	sensors.my_t_counter(1)
+	sensors.sensor(:my_t_counter).timeline(2 * 60).each do |v|
+	  puts "#{v.start_time}: #{v.value}"
+	end
+	
+	sensors.my_t_max(3)
+	sensors.my_t_max(1)
+	sensors.my_t_max(2)
+	sleep(60)
+	sensors.my_t_max(5)
+	sensors.my_t_max(7)
+	sensors.my_t_max(6)
+	sensors.sensor(:my_t_max).timeline(2 * 60).each do |v|
+	  puts "#{v.start_time}: #{v.value}"
+	end
 
 ## Command line interface
 
@@ -219,84 +278,103 @@ It can be found in <tt>examples/full</tt> folder. To run it, execute
 at project root and visit
 <tt>http://localhost:9292</tt> at your browser.
 
-<tt>client.rb</tt> imitating users visiting some imaginary site
+<tt>client.rb</tt> imitating users visiting some imaginary site.
 
     require "pulse-meter"
 
     PulseMeter.redis = Redis.new
 
-    requests_per_minute = PulseMeter::Sensor::Timelined::Counter.new(:requests_per_minute,
-      :annotation => 'Requests per minute',
-      :interval => 60,
-      :ttl => 60 * 60 * 24    # keep data one day
-    )
-
-    requests_per_hour =  PulseMeter::Sensor::Timelined::Counter.new(:requests_per_hour,
-      :annotation => 'Requests per hour',
-      :interval => 60 * 60,
-      :ttl => 60 * 60 * 24 * 30    # keep data 30 days
+    sensors = PulseMeter::Sensor::Configuration.new(
+      requests_per_minute: {
+        sensor_type: 'timelined/counter',
+        args: {
+          annotation: 'Requests per minute',
+          interval: 60,
+          ttl: 60 * 60 * 24    # keep data one day
+        }
+      },
+      requests_per_hour: {
+        sensor_type: 'timelined/counter',
+        args: {
+          annotation: 'Requests per hour',
+          interval: 60 * 60,
+          ttl: 60 * 60 * 24 * 30    # keep data 30 days
+        }
+      },
       # when ActiveSupport extentions are loaded, a better way is to write just
       # :interval => 1.hour,
       # :ttl => 30.days
-    )
-
-    errors_per_minute = PulseMeter::Sensor::Timelined::Counter.new(:errors_per_minute,
-      :annotation => 'Errors per minute',
-      :interval => 60,
-      :ttl => 60 * 60 * 24
-    )
-
-    errors_per_hour =  PulseMeter::Sensor::Timelined::Counter.new(:errors_per_hour,
-      :annotation => 'Errors per hour',
-      :interval => 60 * 60,
-      :ttl => 60 * 60 * 24 * 30
-    )
-
-    longest_minute_request = PulseMeter::Sensor::Timelined::Max.new(:longest_minute_request,
-      :annotation => 'Longest minute requests',
-      :interval => 60,
-      :ttl => 60 * 60 * 24
-    )
-
-    shortest_minute_request = PulseMeter::Sensor::Timelined::Min.new(:shortest_minute_request,
-      :annotation => 'Shortest minute requests',
-      :interval => 60,
-      :ttl => 60 * 60 * 24
-    )
-
-    perc90_minute_request = PulseMeter::Sensor::Timelined::Percentile.new(:perc90_minute_request,
-      :annotation => 'Minute request 90-percent percentile',
-      :interval => 60,
-      :ttl => 60 * 60 * 24,
-      :p => 0.9
+      errors_per_minute: {
+        sensor_type: 'timelined/counter',
+        args: {
+          annotation: 'Errors per minute',
+          interval: 60,
+          ttl: 60 * 60 * 24
+        }
+      },
+      errors_per_hour: {
+        sensor_type: 'timelined/counter',
+        args: {
+          annotation: 'Errors per hour',
+          interval: 60 * 60,
+          ttl: 60 * 60 * 24 * 30
+        }
+      },
+      longest_minute_request: {
+        sensor_type: 'timelined/max',
+        args: {
+          annotation: 'Longest minute requests',
+          interval: 60,
+          ttl: 60 * 60 * 24
+        }
+      },
+      shortest_minute_request: {
+        sensor_type: 'timelined/min',
+        args: {
+          annotation: 'Shortest minute requests',
+          interval: 60,
+          ttl: 60 * 60 * 24
+        }
+      },
+      perc90_minute_request: {
+        sensor_type: 'timelined/percentile',
+        args: {
+          annotation: 'Minute request 90-percent percentile',
+          interval: 60,
+          ttl: 60 * 60 * 24,
+          p: 0.9
+        }
+      }
     )
 
     agent_names = [:ie, :firefox, :chrome, :other]
-    hour_agents = agent_names.each_with_object({}) do |agent, h|
-      h[agent] = PulseMeter::Sensor::Timelined::Counter.new(agent,
-        :annotation => "Requests from #{agent} browser",
-        :interval => 60 * 60,
-        :ttl => 60 * 60 * 24 * 30
+    agent_names.each do |agent|
+      sensors.add_sensor(agent,
+        sensor_type: 'timelined/counter',
+        args: {
+          annotation: "Requests from #{agent} browser",
+          interval: 60 * 60,
+          ttl: 60 * 60 * 24 * 30
+        }
       )
     end
 
-
     while true
-      requests_per_minute.event(1)
-      requests_per_hour.event(1)
+      sensors.requests_per_minute(1)
+      sensors.requests_per_hour(1)
 
       if Random.rand(10) < 1 # let "errors" sometimes occur
-        errors_per_minute.event(1)
-        errors_per_hour.event(1)
+        sensors.errors_per_minute(1)
+        sensors.errors_per_hour(1)
       end
 
       request_time = 0.1 + Random.rand
 
-      longest_minute_request.event(request_time)
-      shortest_minute_request.event(request_time)
-      perc90_minute_request.event(request_time)
+      sensors.longest_minute_request(request_time)
+      sensors.shortest_minute_request(request_time)
+      sensors.perc90_minute_request(request_time)
 
-      agent_counter = hour_agents[agent_names.shuffle.first]
+      agent_counter = sensors.sensor(agent_names.shuffle.first)
       agent_counter.event(1)
 
       sleep(Random.rand / 10)

data/examples/full/Procfile

@@ -1,2 +1,2 @@
 web: bundle exec rackup server.ru
-sensor_data_generator: bundle exec ruby client.rb
+sensor_data_generator: bundle exec ruby client.rb

data/examples/full/client.rb

@@ -4,78 +4,97 @@ require "pulse-meter"
 
 PulseMeter.redis = Redis.new
 
-requests_per_minute = PulseMeter::Sensor::Timelined::Counter.new(:requests_per_minute,
-  :annotation => 'Requests per minute',
-  :interval => 60,
-  :ttl => 60 * 60 * 24    # keep data one day
-)
-
-requests_per_hour =  PulseMeter::Sensor::Timelined::Counter.new(:requests_per_hour,
-  :annotation => 'Requests per hour',
-  :interval => 60 * 60,
-  :ttl => 60 * 60 * 24 * 30    # keep data 30 days
+sensors = PulseMeter::Sensor::Configuration.new(
+  requests_per_minute: {
+    sensor_type: 'timelined/counter',
+    args: {
+      annotation: 'Requests per minute',
+      interval: 60,
+      ttl: 60 * 60 * 24    # keep data one day
+    }
+  },
+  requests_per_hour: {
+    sensor_type: 'timelined/counter',
+    args: {
+      annotation: 'Requests per hour',
+      interval: 60 * 60,
+      ttl: 60 * 60 * 24 * 30    # keep data 30 days
+    }
+  },
   # when ActiveSupport extentions are loaded, a better way is to write just
   # :interval => 1.hour,
   # :ttl => 30.days
-)
-
-errors_per_minute = PulseMeter::Sensor::Timelined::Counter.new(:errors_per_minute,
-  :annotation => 'Errors per minute',
-  :interval => 60,
-  :ttl => 60 * 60 * 24
-)
-
-errors_per_hour =  PulseMeter::Sensor::Timelined::Counter.new(:errors_per_hour,
-  :annotation => 'Errors per hour',
-  :interval => 60 * 60,
-  :ttl => 60 * 60 * 24 * 30
-)
-
-longest_minute_request = PulseMeter::Sensor::Timelined::Max.new(:longest_minute_request,
-  :annotation => 'Longest minute requests',
-  :interval => 60,
-  :ttl => 60 * 60 * 24
-)
-
-shortest_minute_request = PulseMeter::Sensor::Timelined::Min.new(:shortest_minute_request,
-  :annotation => 'Shortest minute requests',
-  :interval => 60,
-  :ttl => 60 * 60 * 24
-)
-
-perc90_minute_request = PulseMeter::Sensor::Timelined::Percentile.new(:perc90_minute_request,
-  :annotation => 'Minute request 90-percent percentile',
-  :interval => 60,
-  :ttl => 60 * 60 * 24,
-  :p => 0.9
+  errors_per_minute: {
+    sensor_type: 'timelined/counter',
+    args: {
+      annotation: 'Errors per minute',
+      interval: 60,
+      ttl: 60 * 60 * 24
+    }
+  },
+  errors_per_hour: {
+    sensor_type: 'timelined/counter',
+    args: {
+      annotation: 'Errors per hour',
+      interval: 60 * 60,
+      ttl: 60 * 60 * 24 * 30
+    }
+  },
+  longest_minute_request: {
+    sensor_type: 'timelined/max',
+    args: {
+      annotation: 'Longest minute requests',
+      interval: 60,
+      ttl: 60 * 60 * 24
+    }
+  },
+  shortest_minute_request: {
+    sensor_type: 'timelined/min',
+    args: {
+      annotation: 'Shortest minute requests',
+      interval: 60,
+      ttl: 60 * 60 * 24
+    }
+  },
+  perc90_minute_request: {
+    sensor_type: 'timelined/percentile',
+    args: {
+      annotation: 'Minute request 90-percent percentile',
+      interval: 60,
+      ttl: 60 * 60 * 24,
+      p: 0.9
+    }
+  }
 )
 
 agent_names = [:ie, :firefox, :chrome, :other]
-hour_agents = agent_names.each_with_object({}) do |agent, h|
-  h[agent] = PulseMeter::Sensor::Timelined::Counter.new(agent,
-    :annotation => "Requests from #{agent} browser",
-    :interval => 60 * 60,
-    :ttl => 60 * 60 * 24 * 30
+agent_names.each do |agent|
+  sensors.add_sensor(agent,
+    sensor_type: 'timelined/counter',
+    args: {
+      annotation: "Requests from #{agent} browser",
+      interval: 60 * 60,
+      ttl: 60 * 60 * 24 * 30
+    }
   )
 end
 
-
 while true
-  requests_per_minute.event(1)
-  requests_per_hour.event(1)
+  sensors.requests_per_minute(1)
+  sensors.requests_per_hour(1)
 
   if Random.rand(10) < 1 # let "errors" sometimes occur
-    errors_per_minute.event(1)
-    errors_per_hour.event(1)
+    sensors.errors_per_minute(1)
+    sensors.errors_per_hour(1)
   end
 
   request_time = 0.1 + Random.rand
 
-  longest_minute_request.event(request_time)
-  shortest_minute_request.event(request_time)
-  perc90_minute_request.event(request_time)
+  sensors.longest_minute_request(request_time)
+  sensors.shortest_minute_request(request_time)
+  sensors.perc90_minute_request(request_time)
 
-  agent_counter = hour_agents[agent_names.shuffle.first]
+  agent_counter = sensors.sensor(agent_names.shuffle.first)
   agent_counter.event(1)
 
   sleep(Random.rand / 10)

data/examples/readme_client_conf.rb

@@ -0,0 +1,59 @@
+$: << File.join(File.absolute_path(__FILE__), '..', 'lib')
+
+require 'pulse-meter'
+PulseMeter.redis = Redis.new
+
+# static sensor examples
+
+sensors = PulseMeter::Sensor::Configuration.new(
+  my_counter: {sensor_type: 'counter'},
+  my_value: {sensor_type: 'indicator'},
+  my_h_counter: {sensor_type: 'hashed_counter'},
+  my_t_counter: {
+    sensor_type: 'timelined/counter',
+    args: {
+      interval: 60,         # count for each minute
+      ttl: 24 * 60 * 60     # keep data one day
+    }
+  },
+  my_t_max: {
+    sensor_type: 'timelined/max',
+    args: {
+      interval: 60,         # count for each minute
+      ttl: 24 * 60 * 60     # keep data one day
+    }
+  }
+)
+
+sensors.my_counter(1)
+sensors.my_counter(2)
+puts sensors.sensor(:my_counter).value
+
+sensors.my_value(3.14)
+sensors.my_value(2.71)
+puts sensors.sensor(:my_value).value
+
+sensors.my_h_counter(:x => 1)
+sensors.my_h_counter(:y => 5)
+sensors.my_h_counter(:y => 1)
+p sensors.sensor(:my_h_counter).value
+
+sensors.my_t_counter(1)
+sensors.my_t_counter(1)
+sleep(60)
+sensors.my_t_counter(1)
+sensors.sensor(:my_t_counter).timeline(2 * 60).each do |v|
+  puts "#{v.start_time}: #{v.value}"
+end
+
+sensors.my_t_max(3)
+sensors.my_t_max(1)
+sensors.my_t_max(2)
+sleep(60)
+sensors.my_t_max(5)
+sensors.my_t_max(7)
+sensors.my_t_max(6)
+sensors.sensor(:my_t_max).timeline(2 * 60).each do |v|
+  puts "#{v.start_time}: #{v.value}"
+end
+

data/lib/cmd.rb

@@ -2,6 +2,29 @@ require 'thor'
 require 'terminal-table'
 require 'time'
 require 'json'
+require 'csv'
+
+module Enumerable
+  def convert_time
+    map do |el|
+      if el.is_a?(Time)
+        el.to_i
+      else
+        el
+      end
+    end
+  end
+
+  def to_table(format = nil)
+    if "csv" == format
+      CSV.generate(:col_sep => ';') do |csv|
+        self.each {|row| csv << row.convert_time}
+      end
+    else
+      self.each_with_object(Terminal::Table.new) {|row, table| table << row}
+    end
+  end
+end
 
 module Cmd
   class All < Thor
@@ -25,18 +48,19 @@ module Cmd
         PulseMeter::Sensor::Timeline.list_objects
       end
 
-      def all_sensors_table(title = nil)
-        table = Terminal::Table.new :title => title
-        table << ["Name", "Class", "ttl", "raw data ttl", "interval", "reduce delay"]
-        table << :separator
+      def all_sensors_table(format = nil)
+        data = [
+          ["Name", "Class", "ttl", "raw data ttl", "interval", "reduce delay"],
+        ]
+        data << :separator unless format == 'csv'
         all_sensors.each do |s|
           if s.kind_of? PulseMeter::Sensor::Timeline
-            table << [s.name, s.class, s.ttl, s.raw_data_ttl, s.interval, s.reduce_delay]
+            data << [s.name, s.class, s.ttl, s.raw_data_ttl, s.interval, s.reduce_delay]
           else
-            table << [s.name, s.class] + ['-'] * 4
+            data << [s.name, s.class] + [''] * 4
           end
         end
-        table
+        data.to_table(format)
       end
 
       def fail!(description = nil)
@@ -53,15 +77,17 @@ module Cmd
 
     desc "sensors", "List all sensors available"
     common_options
+    method_option :format, :default => :table, :desc => "Output format: table or csv"
     def sensors
-      with_redis {puts all_sensors_table('Registered sensors')}
+      with_redis {puts all_sensors_table(options[:format])}
     end
 
     desc "reduce", "Execute reduction for all sensors' raw data"
     common_options
     def reduce
       with_redis do
-        puts all_sensors_table('Registered sensors to be reduced')
+        puts 'Registered sensors to be reduced'
+        puts all_sensors_table
         PulseMeter::Sensor::Timeline.reduce_all_raw
         puts "DONE"
       end
@@ -79,24 +105,25 @@ module Cmd
 
     desc "timeline NAME SECONDS", "Get sensor's NAME timeline for last SECONDS"
     common_options
+    method_option :format, :default => :table, :desc => "Output format: table or csv"
     def timeline(name, seconds)
       with_safe_restore_of(name) do |sensor|
-        table = Terminal::Table.new
-        sensor.timeline(seconds).each {|data| table << [data.start_time, data.value || '-']}
-        puts table
+        puts sensor.
+          timeline(seconds).
+          map {|data| [data.start_time, data.value || '']}.
+          to_table(options[:format])
       end
     end
 
     desc "timeline_within NAME FROM TILL", "Get sensor's NAME timeline in interval. Time format: YYYY-MM-DD HH:MM:SS"
     common_options
+    method_option :format, :default => :table, :desc => "Output format: table or csv"
     def timeline_within(name, from, till)
       with_safe_restore_of(name) do |sensor|
-        table = Terminal::Table.new
-        sensor.timeline_within(
-          Time.parse(from),
-          Time.parse(till)
-        ).each {|data| table << [data.start_time, data.value || '-']}
-        puts table
+        puts sensor.
+          timeline_within(Time.parse(from), Time.parse(till)).
+          map {|data| [data.start_time, data.value || '']}.
+          to_table(options[:format])
       end
     end
 
@@ -146,5 +173,21 @@ module Cmd
       end
     end
 
+    desc "drop NAME DATE_FROM(YYYYmmddHHMMSS) DATE_TO(YYYYmmddHHMMSS)", "Drop timeline data of a particular sensor"
+    common_options
+    def drop(name, from, to)
+      time_from, time_to = [from, to].map do |str|
+        str.match(/\A(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\z/) do |m|
+          Time.gm(*m.captures.map(&:to_i))
+        end
+      end
+      fail! "DATE_FROM is not a valid timestamp" unless time_from.is_a?(Time)
+      fail! "DATE_TO is not a valid timestamp" unless time_to.is_a?(Time)
+      with_safe_restore_of(name) do |sensor|
+        fail! "Sensor #{name} has no drop_within method" unless sensor.respond_to?(:drop_within)
+        sensor.drop_within(time_from, time_to)
+      end
+    end
+
   end
 end

data/lib/pulse-meter.rb

@@ -1,4 +1,5 @@
 require "redis"
+require "logger"
 require "pulse-meter/version"
 require "pulse-meter/mixins/dumper"
 require "pulse-meter/mixins/utils"

data/lib/pulse-meter/sensor.rb

@@ -2,6 +2,8 @@ require 'pulse-meter/sensor/base'
 require 'pulse-meter/sensor/counter'
 require 'pulse-meter/sensor/hashed_counter'
 require 'pulse-meter/sensor/indicator'
+require 'pulse-meter/sensor/remote'
+require 'pulse-meter/sensor/uniq_counter'
 require 'pulse-meter/sensor/timeline'
 require 'pulse-meter/sensor/timelined/average'
 require 'pulse-meter/sensor/timelined/counter'
@@ -10,6 +12,7 @@ require 'pulse-meter/sensor/timelined/min'
 require 'pulse-meter/sensor/timelined/max'
 require 'pulse-meter/sensor/timelined/percentile'
 require 'pulse-meter/sensor/timelined/median'
+require 'pulse-meter/sensor/timelined/uniq_counter'
 
 # Top level sensor module
 module PulseMeter
@@ -43,5 +46,9 @@ module PulseMeter
   # 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

@@ -65,9 +65,9 @@ module PulseMeter
       # For a block
       # @yield Executes it within Redis multi
       def multi
-        redis.multi 
-        yield
-        redis.exec
+        redis.multi do
+          yield
+        end
       end
 
     end

data/lib/pulse-meter/sensor/remote.rb

@@ -0,0 +1,60 @@
+require 'socket'
+require 'json'
+
+module PulseMeter
+  module Sensor
+
+    # Remote sensor, i.e. a simple UDP proxy for sending data without
+    # taking in account backend performance issues
+    class Remote < Base
+
+      DEFAULT_PORT = 27182
+      DEFAULT_HOST = 'localhost'
+
+      # @!attribute [r] name
+      #   @return [String] sensor name
+      attr_reader :name
+
+      # Initializes sensor and creates UDP socket
+      # @param name [String] sensor name
+      # @option options [Symbol] :host host for remote pulse-meter daemon
+      # @option options [Symbol] :port port for remote pulse-meter daemon
+      # @raise [BadSensorName] if sensor name is malformed
+      # @raise [ConnectionError] if invalid host or port are provided
+      def initialize(name, options={})
+        @name = name.to_s
+        raise BadSensorName, @name unless @name =~ /\A\w+\z/
+        @host = options[:host].to_s || DEFAULT_HOST
+        @port = options[:port].to_i || DEFAULT_PORT
+        @socket = UDPSocket.new
+      end
+
+      # Send value to remote sensor
+      # @param value value for remote sensor
+      # @raise [ConnectionError] if remote daemon is not available
+      # @raise [MessageTooLarge] if event data is too large to be serialized into a UDP datagram
+      def event(value)
+        events(name => value)
+      end
+
+      # Send values to multiple remote sensors
+      # @param event_data hash with remote sensor names as keys end event value for each value as sensor
+      def events(event_data)
+        raise ArgumentError unless event_data.is_a?(Hash)
+        socket_action do
+          @socket.send(event_data.to_json, 0, @host, @port)
+        end
+      end
+
+      private
+
+      def socket_action
+        yield
+      rescue SocketError, Errno::EADDRNOTAVAIL, Errno::EINVAL => exc
+        raise PulseMeter::Remote::ConnectionError, exc.to_s
+      rescue Errno::EMSGSIZE => exc
+        raise PulseMeter::Remote::MessageTooLarge, exc.to_s
+      end
+    end
+  end
+end

data/lib/pulse-meter/sensor/timeline.rb

@@ -149,7 +149,6 @@ module PulseMeter
         res_interval
       end
 
-
       # Returns sensor data for given interval making in-memory summarization
       #   and returns calculated value
       # @param interval_id [Fixnum]
@@ -160,6 +159,27 @@ module PulseMeter
         SensorData.new(Time.at(interval_id), nil)
       end
 
+      # Drops sensor data within given time
+      # @param from [Time] lower bound
+      # @param till [Time] upper bound
+      # @raise ArgumentError if argumets are not valid time objects
+      def drop_within(from, till)
+        raise ArgumentError unless from.kind_of?(Time) && till.kind_of?(Time)
+        start_time, end_time = from.to_i, till.to_i
+        current_interval_id = get_interval_id(start_time) + interval
+        keys = []
+        while current_interval_id < end_time
+          keys << data_key(current_interval_id)
+          keys << raw_data_key(current_interval_id)
+          current_interval_id += interval
+        end
+        if keys.empty?
+          0
+        else
+          redis.del(*keys)
+        end
+      end
+
       # Returns Redis key by which raw data for current interval is stored
       def current_raw_data_key
         raw_data_key(current_interval_id)

data/lib/pulse-meter/sensor/timelined/uniq_counter.rb

@@ -0,0 +1,16 @@
+module PulseMeter
+  module Sensor
+    module Timelined
+      # Counts unique events per interval
+      class UniqCounter < Timeline
+        def aggregate_event(key, value)
+          redis.sadd(key, value)
+        end
+
+        def summarize(key)
+          redis.scard(key)
+        end
+      end
+    end
+  end
+end

data/lib/pulse-meter/sensor/uniq_counter.rb

@@ -0,0 +1,22 @@
+require 'json'
+
+# Static counter to count unique values
+module PulseMeter
+  module Sensor
+    class UniqCounter < Counter
+
+      # Processes event
+      # @param name [String] value to be counted
+      def event(name)
+        redis.sadd(value_key, name)
+      end
+
+      # Returs number of unique values ever sent to counter
+      # @return [Fixnum]
+      def value
+        redis.scard(value_key)
+      end
+
+    end
+  end
+end

data/lib/pulse-meter/version.rb

@@ -1,3 +1,3 @@
 module PulseMeter
-  VERSION = "0.1.10"
+  VERSION = "0.1.11"
 end

data/lib/pulse-meter/visualize/series_extractor.rb

@@ -52,16 +52,25 @@ module PulseMeter
           data.keys.map do |k|
             {
               y: to_float(data[k]),
-              name: k
+              name: series_title(k)
             }
           end
         end
 
+        def series_title(key)
+          annotation = @sensor.annotation
+          if annotation && !annotation.empty?
+            "#{annotation}: #{key}"
+          else
+            key
+          end
+        end
+
         def series_data(timeline_data)
           series_data = {}
           parsed_data = timeline_data.map do |sd|
             data = parse_data(sd.value)
-            data.keys.each{|k| series_data[k] ||= {name: k, data: []}}
+            data.keys.each{|k| series_data[k] ||= {name: series_title(k), data: []}}
             [sd.start_time.to_i*1000, data]
           end
 

data/spec/pulse_meter/sensor/remote_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+describe PulseMeter::Sensor::Remote do
+
+  def data_sent_to(host, port)
+    socket = UDPSocket.new
+    socket.bind(host, port)
+    yield
+    data, _ = socket.recvfrom(65000)
+    socket.close
+    data
+  end
+
+  let(:host){'localhost'}
+  let(:port){56789}
+  let(:sensor){described_class.new(:some_remote_sensor, host: host, port: port)}
+
+  describe "#new" do
+    it "should raise exception if sensor name is bad" do
+      expect{described_class.new("aa bb")}.to raise_exception(PulseMeter::BadSensorName)
+    end
+  end
+
+  describe "#event" do
+    it "should send event data to remote host and port" do
+      data_sent_to(host, port) {
+        sensor.event(123)
+      }.should_not be_empty
+    end
+
+    it "should use sensor name as a single key and sent data as its value" do
+      data = data_sent_to(host, port) do
+        sensor.event(123)
+      end
+      JSON.parse(data).should == {sensor.name => 123}
+    end
+
+    it "should raise MessageTooLarge if message is too long" do
+      expect{ sensor.event("123" * 100000) }.to raise_exception(PulseMeter::Remote::MessageTooLarge)
+    end
+
+
+    it "should raise PulseMeter::Remote::ConnectionError if remote host is invalid" do
+      expect{described_class.new("xxx", host: "bad host").event(123)}.to raise_exception(PulseMeter::Remote::ConnectionError)
+    end
+
+    it "should raise PulseMeter::Remote::ConnectionError if remote port is invalid" do
+      expect{described_class.new("xxx", port: -123).event(123)}.to raise_exception(PulseMeter::Remote::ConnectionError)
+      expect{described_class.new("xxx", port: 'bad port').event(123)}.to raise_exception(PulseMeter::Remote::ConnectionError)
+    end
+
+  end
+
+  describe "#events" do
+    it "should send event data to remote host and port" do
+      data_sent_to(host, port) {
+        sensor.events(a: 1, b: 2)
+      }.should_not be_empty
+    end
+
+    it "should use sensor name as a single key and sent data as its value" do
+      data = data_sent_to(host, port) do
+        sensor.events(a: 1, b: 2)
+      end
+      JSON.parse(data).should == {"a" => 1, "b" => 2}
+    end
+
+    it "should raise ArgumentError if argument is not a hash" do
+      expect{ sensor.events(1213) }.to raise_exception(ArgumentError)
+    end
+
+    it "should raise MessageTooLarge if message is too long" do
+      expect{ sensor.events(a: "x" * 100000) }.to raise_exception(PulseMeter::Remote::MessageTooLarge)
+    end
+
+    it "should raise PulseMeter::Remote::ConnectionError if remote host is invalid" do
+      expect{described_class.new("xxx", host: "bad host").events(a: 123)}.to raise_exception(PulseMeter::Remote::ConnectionError)
+    end
+
+    it "should raise PulseMeter::Remote::ConnectionError if remote port is invalid" do
+      expect{described_class.new("xxx", port: -123).events(a: 123)}.to raise_exception(PulseMeter::Remote::ConnectionError)
+      expect{described_class.new("xxx", port: 'bad port').events(a: 123)}.to raise_exception(PulseMeter::Remote::ConnectionError)
+    end
+  end
+
+end

data/spec/pulse_meter/sensor/timelined/uniq_counter_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::Timelined::UniqCounter do
+  it_should_behave_like "timeline sensor"
+  it_should_behave_like "timelined subclass", [:foo, :bar], 2
+  it_should_behave_like "timelined subclass", [:foo, :bar, :foo], 2
+  data = (1..100).map {rand(200)}
+  it_should_behave_like "timelined subclass", data, data.uniq.count
+end

data/spec/pulse_meter/sensor/uniq_counter_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe PulseMeter::Sensor::UniqCounter do
+  let(:name){ :some_counter }
+  let(:sensor){ described_class.new(name) }
+  let(:redis){ PulseMeter.redis }
+
+  describe "#event" do
+    it "should count unique values" do
+      expect{ sensor.event(:first) }.to change{sensor.value}.to(1)
+      expect{ sensor.event(:first) }.not_to change{sensor.value}
+      expect{ sensor.event(:second) }.to change{sensor.value}.from(1).to(2)
+    end
+  end
+
+  describe "#value" do
+    it "should have initial value 0" do
+      sensor.value.should == 0
+    end
+
+    it "should return count of unique values" do
+      data = (1..100).map {rand(200)}
+      data.each {|e| sensor.event(e)}
+      sensor.value.should == data.uniq.count
+    end
+  end
+
+end

data/spec/pulse_meter/visualize/series_extractor_spec.rb

@@ -50,8 +50,8 @@ describe PulseMeter::Visualize::SeriesExtractor do
 
     it "should create point data correctly" do
       extractor.point_data('{"x": 123, "y": 321}').should == [
-        {y: 123, name: 'x'},
-        {y: 321, name: 'y'}
+        {y: 123, name: 'hashed sensor: x'},
+        {y: 321, name: 'hashed sensor: y'}
       ]
     end
 
@@ -62,15 +62,15 @@ describe PulseMeter::Visualize::SeriesExtractor do
       ]
       extractor.series_data(tl_data).should == [
         {
-          name: 'a',
+          name: 'hashed sensor: a',
           data: [{x: 1000, y: 5}, {x: 2000, y: nil}]
         },
         {
-          name: 'b',
+          name: 'hashed sensor: b',
           data: [{x: 1000, y: 6}, {x: 2000, y: 6}]
         },
         {
-          name: 'c',
+          name: 'hashed sensor: c',
           data: [{x: 1000, y: nil}, {x: 2000, y: 7}]
         }
       ]

data/spec/shared_examples/timeline_sensor.rb

@@ -163,7 +163,7 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
   end
 
   describe "#timeline_within" do
-    it "shoulde raise exception unless both arguments are Time objects" do
+    it "should raise exception unless both arguments are Time objects" do
       [:q, nil, -1].each do |bad_value|
         expect{ sensor.timeline_within(Time.now, bad_value) }.to raise_exception(ArgumentError)
         expect{ sensor.timeline_within(bad_value, Time.now) }.to raise_exception(ArgumentError)
@@ -244,6 +244,72 @@ shared_examples_for "timeline sensor" do |extra_init_values, default_event|
     end
   end
 
+  describe "#drop_within" do
+    it "should raise exception unless both arguments are Time objects" do
+      [:q, nil, -1].each do |bad_value|
+        expect{ sensor.drop_within(Time.now, bad_value) }.to raise_exception(ArgumentError)
+        expect{ sensor.drop_within(bad_value, Time.now) }.to raise_exception(ArgumentError)
+      end
+    end
+
+    it "should drop as many raw results as there are sensor interval beginnings in the passed interval" do
+      Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
+      Timecop.freeze(@start_of_interval + interval){ sensor.event(sample_event) }
+
+      future = @start_of_interval + interval * 3
+      Timecop.freeze(future) do
+        sensor.drop_within(
+          Time.at(@start_of_interval + interval - 1),
+            Time.at(@start_of_interval + interval + 1)
+        ).should == 1
+
+        data = sensor.timeline_within(
+          Time.at(@start_of_interval + interval - 1),
+            Time.at(@start_of_interval + interval + 1)
+        )
+        data.size.should == 1
+        data.first.value.should be_nil # since data is dropped
+
+      end
+
+      Timecop.freeze(@start_of_interval + interval + 2) do
+        sensor.drop_within(
+          Time.at(@start_of_interval + interval + 1),
+            Time.at(@start_of_interval + interval + 2)
+        ).should == 0
+      end
+    end
+
+    it "should drop as many reduced results as there are sensor interval beginnings in the passed interval" do
+      Timecop.freeze(@start_of_interval){ sensor.event(sample_event) }
+      Timecop.freeze(@start_of_interval + interval){ sensor.event(sample_event) }
+
+      future = @start_of_interval
+      Timecop.freeze(future) do
+        sensor.reduce_all_raw
+        sensor.drop_within(
+          Time.at(@start_of_interval + interval - 1),
+            Time.at(@start_of_interval + interval + 1)
+        ).should == 1
+
+        data = sensor.timeline_within(
+          Time.at(@start_of_interval + interval - 1),
+            Time.at(@start_of_interval + interval + 1)
+        )
+        data.size.should == 1
+        data.first.value.should be_nil # since data is dropped
+
+      end
+
+      Timecop.freeze(@start_of_interval + interval + 2) do
+        sensor.drop_within(
+          Time.at(@start_of_interval + interval + 1),
+            Time.at(@start_of_interval + interval + 2)
+        ).should == 0
+      end
+    end
+  end
+
   describe "SensorData value for an interval" do
     def check_sensor_data(sensor, value)
       data = sensor.timeline(2).first

data/spec/spec_helper.rb

@@ -16,7 +16,9 @@ Dir['spec/support/**/*.rb'].each{|f| require File.join(ROOT, f) }
 Dir['spec/shared_examples/**/*.rb'].each{|f| require File.join(ROOT,f)}
 
 RSpec.configure do |config|
-  config.before(:each) { PulseMeter.redis = MockRedis.new }
+  config.before(:each) do
+    PulseMeter.redis = MockRedis.new
+  end
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
   config.include(Matchers)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pulse-meter
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-08 00:00:00.000000000 Z
+date: 2012-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gon-sinatra
@@ -312,7 +312,9 @@ files:
 - examples/minimal/Procfile
 - examples/minimal/client.rb
 - examples/minimal/server.ru
-- examples/readme_client_example.rb
+- examples/readme_client.rb
+- examples/readme_client_conf.rb
+- examples/server_config.yml
 - lib/cmd.rb
 - lib/pulse-meter.rb
 - lib/pulse-meter/mixins/dumper.rb
@@ -323,6 +325,7 @@ files:
 - lib/pulse-meter/sensor/counter.rb
 - lib/pulse-meter/sensor/hashed_counter.rb
 - lib/pulse-meter/sensor/indicator.rb
+- lib/pulse-meter/sensor/remote.rb
 - lib/pulse-meter/sensor/timeline.rb
 - lib/pulse-meter/sensor/timelined/average.rb
 - lib/pulse-meter/sensor/timelined/counter.rb
@@ -331,6 +334,12 @@ files:
 - lib/pulse-meter/sensor/timelined/median.rb
 - lib/pulse-meter/sensor/timelined/min.rb
 - lib/pulse-meter/sensor/timelined/percentile.rb
+- lib/pulse-meter/sensor/timelined/uniq_counter.rb
+- lib/pulse-meter/sensor/uniq_counter.rb
+- lib/pulse-meter/server.rb
+- lib/pulse-meter/server/command_line_options.rb
+- lib/pulse-meter/server/config_options.rb
+- lib/pulse-meter/server/sensors.rb
 - lib/pulse-meter/version.rb
 - lib/pulse-meter/visualize/app.rb
 - lib/pulse-meter/visualize/dsl.rb
@@ -368,6 +377,7 @@ files:
 - spec/pulse_meter/sensor/counter_spec.rb
 - spec/pulse_meter/sensor/hashed_counter_spec.rb
 - spec/pulse_meter/sensor/indicator_spec.rb
+- spec/pulse_meter/sensor/remote_spec.rb
 - spec/pulse_meter/sensor/timeline_spec.rb
 - spec/pulse_meter/sensor/timelined/average_spec.rb
 - spec/pulse_meter/sensor/timelined/counter_spec.rb
@@ -376,6 +386,8 @@ files:
 - spec/pulse_meter/sensor/timelined/median_spec.rb
 - spec/pulse_meter/sensor/timelined/min_spec.rb
 - spec/pulse_meter/sensor/timelined/percentile_spec.rb
+- spec/pulse_meter/sensor/timelined/uniq_counter_spec.rb
+- spec/pulse_meter/sensor/uniq_counter_spec.rb
 - spec/pulse_meter/visualize/app_spec.rb
 - spec/pulse_meter/visualize/dsl/layout_spec.rb
 - spec/pulse_meter/visualize/dsl/page_spec.rb
@@ -410,6 +422,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1712600594864838902
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -425,6 +440,7 @@ test_files:
 - spec/pulse_meter/sensor/counter_spec.rb
 - spec/pulse_meter/sensor/hashed_counter_spec.rb
 - spec/pulse_meter/sensor/indicator_spec.rb
+- spec/pulse_meter/sensor/remote_spec.rb
 - spec/pulse_meter/sensor/timeline_spec.rb
 - spec/pulse_meter/sensor/timelined/average_spec.rb
 - spec/pulse_meter/sensor/timelined/counter_spec.rb
@@ -433,6 +449,8 @@ test_files:
 - spec/pulse_meter/sensor/timelined/median_spec.rb
 - spec/pulse_meter/sensor/timelined/min_spec.rb
 - spec/pulse_meter/sensor/timelined/percentile_spec.rb
+- spec/pulse_meter/sensor/timelined/uniq_counter_spec.rb
+- spec/pulse_meter/sensor/uniq_counter_spec.rb
 - spec/pulse_meter/visualize/app_spec.rb
 - spec/pulse_meter/visualize/dsl/layout_spec.rb
 - spec/pulse_meter/visualize/dsl/page_spec.rb