simple_metrics 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create 1.9.3@simple_metrics

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in simple-metrics-server.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,127 @@
+SimpleMetrics
+=============
+
+SimpleMetrics makes it easy to collect and aggregate data (specifically counters, timers and events).
+
+It is heavily inspired by Statsd (https://github.com/etsy/statsd) from Etsy. Read the "Measure Anything, measure Everything" blog post (http://codeascraft.etsy.com/2011/02/15/measure-anything-measure-everything/) which did it for me.
+
+Technically speaking it provides a simple UDP interface to send data to an Eventmachine based UDP Server. The data is stored in MongoDB using a Round Robin Database (RRD) scheme.
+
+SimpleMetrics is written in Ruby and packaged as a gem.
+
+The current version is considered ALPHA.
+
+SimpleMetrics Client
+--------------------
+
+Commandline client:
+
+Send a count of 5 for data point "module.test1":
+
+		simple_metrics_client module.test1 -counter 5
+
+Send a timing of 100ms:
+
+		simple_metrics_client module.test1 -timing 100
+
+doing the same, but since we expect a lot of calls we sample the data (10%):
+
+		simple_metrics_client module.test1 -timing 100 --sample_rate 0.1
+
+more info:
+	
+		simple_metrics_client --help
+
+Ruby client API
+---------------
+
+Initialize client:
+
+		client = SimpleMetrics::Client.new("localhost")
+
+sends "com.example.test1:1|c" via UDP:
+
+		client.increment("com.example.test1")
+
+sends "com.example.test1:-1|c":
+
+		client.decrement("com.example.test1")
+
+sends "com.example.test1:5|c" (a counter with a relative value of 5):
+
+		client.count("com.example.test1", 5)
+
+sends "com.example.test1:5|c|@0.1" with a sample rate of 10%:
+
+		client.count("com.example.test1", 5, 0.1)
+
+sends "com.example.test1:5|g" (meaning gauge, an absolute value of 5):
+
+		client.count("com.example.test1", 5)
+
+sends "com.example.test1:100|ms":
+
+		client.timing("com.example.test1")
+
+More examples in the examples/ directory.
+
+SimpleMetrics Server
+--------------------
+
+We provide a simple commandline wrapper using daemons gem (http://daemons.rubyforge.org/).
+
+Start Server as background daemond:
+
+		simple_metrics_server start
+
+Start in foreground:
+
+		simple_metrics_server start -t
+
+Show Help:
+
+		simple_metrics_server --help
+
+Round Robin Database Principles in MongoDB
+------------------------------------------
+
+We use 4 collections in MongoDB each with more coarse timestamp buckets:
+* 10 sec
+* 1 min
+* 10 min
+* 1 day
+
+The 10s and 1m collections are capped collections and have a fixed size. The other will store the data as long as we have sufficient disc space.
+
+How can we map these times to graphs?
+
+* 10 sec, near real-time graph  (ttl: several hours)
+* 1 min, last hour       (ttl: several days)
+* 10 min, whole day view  (ttl: forever)
+* 1 day , week view       (ttl: forever)
+
+License 
+-------
+
+(The MIT License)
+
+Copyright (c) 2012 Frederik Dietz <fdietz@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new 
+task :default  => :spec
+task :test  => :spec
+

data/bin/simple_metrics_client

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "bundler/setup"
+
+require 'optparse'
+require "simple_metrics"
+
+options = {
+	:host        => 'localhost',
+	:port        => 8125,
+	:sample_rate => 1
+}
+
+parser ||= OptionParser.new do |opts|
+  opts.banner = "Usage Example: simple_metrics_send com.test.mymetric -c5"
+
+  opts.separator ""
+  opts.separator "Client options:"
+
+  opts.on("-c", "--counter VALUE", "Counter, a relative value") do |value|
+  	options[:type] = 'c'
+  	options[:stat] = value.to_i
+  end
+  opts.on("-g", "--gauge VALUE", "Gauge, an absolute value ") do |value|
+  	options[:type] = 'g'
+  	options[:stat] = value.to_i
+  end
+  opts.on("-t", "--timing VALUE", "A timing in ms") do |value|
+  	options[:type] = 'ms'
+  	options[:stat] = value.to_i
+  end
+  opts.on("-s", "--sample_rate VALUE", "An optional sample rate between 0 and 1 (example: 0.2)") do |value|
+  	options[:sample_rate] = value.to_f || 1
+  end
+
+  opts.separator ""
+
+  opts.on("-a", "--address HOST", "bind to HOST address (default: #{options[:host]})") do |host| 
+  	options[:host] = host
+  end
+
+  opts.on("-p", "--port PORT", "use PORT (default: #{options[:port]})") do |port|
+  	options[:port] = port.to_i
+  end
+
+  opts.separator ""
+  opts.on_tail("-h", "--help", "Show this message") { puts opts; exit }
+  opts.on_tail('-v', '--version', "Show version") { puts SimpleMetrics::VERSION; exit }
+
+end.parse!(ARGV)
+
+command    = ARGV.shift
+arguments  = ARGV
+client = SimpleMetrics::Client.new(options[:host])
+
+case options[:type]
+when'c' 
+	client.count(command, options[:stat], options[:sample_rate])
+when 'g'
+	client.gauge(command, options[:stat], options[:sample_rate])
+when 'ms'
+	client.timing(command, options[:stat], options[:sample_rate])
+end

data/bin/simple_metrics_server

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "bundler/setup"
+require "simple_metrics"
+require "daemons"
+
+options = {
+	:backtrace  => true,
+	:log_output => true,
+	:dir_mode   => :script
+}
+
+Daemons.run_proc("simple_metrics", options) do
+	SimpleMetrics::Server.new.start
+end
+
+

data/example/increment.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+require "rubygems"
+require "bundler/setup"
+require "simple_metrics"
+
+client = SimpleMetrics::Client.new("localhost")
+# com.example.test1:1|c
+client.increment("com.example.test1")

data/lib/simple_metrics.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+require "logger"
+
+require "simple_metrics/version"
+require "simple_metrics/client"
+require "simple_metrics/server"
+require "simple_metrics/stats"
+require "simple_metrics/bucket"
+require "simple_metrics/mongo"
+
+module SimpleMetrics
+  extend self
+    
+  def logger
+    @@logger ||= Logger.new(STDOUT)
+  end
+  
+  def logger=(logger)
+    @@logger = logger
+  end
+
+  CONFIG_DEFAULTS = {
+    :host           => 'localhost',
+    :port           => 8125,
+    :flush_interval => 10
+  }.freeze
+
+  def config
+    @@config ||= CONFIG_DEFAULTS
+  end
+
+  def config=(options)
+    @@config = CONFIG_DEFAULTS.merge(options)
+  end
+
+  BUCKETS_DEFAULTS = [
+    { 
+      :name    => 'stats_per_10s',
+      :seconds => 10,
+      :capped  => true,
+      :size    => 100_100_100
+    },
+    {
+      :name    => 'stats_per_1min',
+      :seconds => 60,
+      :capped  => true,
+      :size    => 1_100_100_100
+    },
+    {
+      :name    => 'stats_per_10min',
+      :seconds => 600,
+      :size    => 0 ,
+      :capped  => false
+    },
+    {
+      :name    => 'stats_per_day',
+      :seconds => 86400,
+      :size    => 0,
+      :capped  => false
+    }
+  ].freeze
+
+  def buckets_config
+    @@buckets ||= BUCKETS_DEFAULTS
+  end
+
+  def buckets_config=(buckets)
+    @@buckets = buckets
+  end
+
+  MONGODB_DEFAULTS = {
+    :pool_size => 5, 
+    :timeout   => 5,
+    :strict    => true
+  }.freeze
+
+  DB_CONFIG_DEFAULTS = {
+    :host      => 'localhost',
+    :prefix    => 'development'
+  }.freeze
+
+  def db_config=(options)
+    @@db_config = {
+      :host    => options.delete(:host),
+      :db_name => "simple_metrics_#{options.delete(:prefix)}",
+      :options => MONGODB_DEFAULTS.merge(options)
+    }
+  end
+
+  def db_config
+    @@db_config ||= DB_CONFIG_DEFAULTS.merge(
+      :db_name => "simple_metrics_#{DB_CONFIG_DEFAULTS[:prefix]}",
+      :options => MONGODB_DEFAULTS
+    )
+  end
+
+end

data/lib/simple_metrics/bucket.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+module SimpleMetrics
+  class Bucket
+
+    class << self
+
+      def all
+        @@all ||= SimpleMetrics.buckets_config.map { |r| Bucket.new(r) }
+      end
+
+      def first
+        all.first
+      end
+      alias :finest :first
+
+      def [](index)
+        all[index]
+      end
+
+      def coarse_buckets
+        Bucket.all.sort_by! { |r| r.seconds }[1..-1]
+      end
+
+      def flush_stats(stats)
+        return if stats.empty?
+        SimpleMetrics.logger.info "#{Time.now} Flushing #{stats.count} counters to MongoDB"
+
+        ts = Time.now.utc.to_i
+        bucket = Bucket.first
+        stats.each { |data| bucket.save(data, ts) }
+        
+        self.aggregate_all(ts)
+      end
+
+      def aggregate_all(ts)
+        ts_bucket = self.first.ts_bucket(ts)
+
+        coarse_buckets.each do |bucket|
+          current_ts = bucket.ts_bucket(ts_bucket)
+          previous_ts = bucket.previous_ts_bucket(ts_bucket)
+          SimpleMetrics.logger.debug "Aggregating #{bucket.name} #{previous_ts}....#{current_ts} (#{humanized_timestamp(previous_ts)}..#{humanized_timestamp(current_ts)})"
+
+          unless bucket.stats_exist_in_previous_ts?(previous_ts)
+            stats_coll = self.first.find_all_in_ts_range(previous_ts, current_ts)
+            stats_coll.group_by { |stats| stats.name }.each_pair do |name,stats_array|
+              stats = Stats.aggregate(stats_array)
+              bucket.save(stats, previous_ts)
+            end
+          end
+        end
+      end
+
+      private
+
+      def humanized_timestamp(ts)
+        Time.at(ts).utc
+      end
+    end
+
+    attr_reader :name, :capped
+
+    def initialize(attributes)
+      @name    = attributes[:name]
+      @seconds = attributes[:seconds]
+      @capped  = attributes[:capped]
+      @size    = attributes[:size]
+    end
+
+    def seconds
+      @seconds.to_i
+    end
+
+    def size
+      @size.to_i
+    end
+
+    def ts_bucket(ts)
+      ts / seconds * seconds
+    end
+
+    def next_ts_bucket(ts)
+      ts_bucket(ts) + seconds
+    end
+
+    def previous_ts_bucket(ts)
+      ts_bucket(ts) - seconds
+    end
+
+    def find(id)
+      mongo_result = mongo_coll.find_one({ :_id => id })
+      Stats.create_from_db(mongo_result)
+    end
+
+    def find_all_by_name(name)
+      mongo_result = mongo_coll.find({ :name => name })
+      mongo_result.inject([]) { |result, a| result << Stats.create_from_db(a) }
+    end
+
+    def find_all_in_ts(ts)
+      mongo_result = mongo_coll.find({ :ts => ts_bucket(ts) })
+      mongo_result.inject([]) { |result, a| result << Stats.create_from_db(a) }
+    end
+
+    def find_all_in_ts_by_name(ts, name)
+      mongo_result = mongo_coll.find({ :ts => ts_bucket(ts), :name => name })
+      mongo_result.inject([]) { |result, a| result << Stats.create_from_db(a) }
+    end
+
+    def find_all_in_ts_range(previous_ts, current_ts)
+      mongo_result = mongo_coll.find({ :ts => { "$gte" => previous_ts, "$lt" => current_ts }}).to_a
+      mongo_result.inject([]) { |result, a| result << Stats.create_from_db(a) }
+    end
+
+    def stats_exist_in_previous_ts?(ts)
+      mongo_coll.find({ :ts => ts }).count > 0
+    end
+
+    def save(stats, ts)
+      stats.ts = ts_bucket(ts)
+      result = mongo_coll.insert(stats.attributes)
+      SimpleMetrics.logger.debug "SERVER: MongoDB - insert in #{name}: #{stats.inspect}, result: #{result}"
+    end
+
+    def mongo_coll
+      Mongo.collection(name)
+    end
+
+    def capped?
+      @capped == true
+    end
+
+  end
+end

data/lib/simple_metrics/client.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+require "socket"
+
+module SimpleMetrics
+
+  class Client
+    VERSION = "0.0.1"
+    
+    def initialize(host, port = 8125)
+      @host, @port = host, port
+    end
+
+    # send relative value
+    def increment(stat, sample_rate = 1)
+      count(stat, 1, sample_rate)
+    end
+
+    # send relative value
+    def decrement(stat, sample_rate = 1)
+      count(stat, -1, sample_rate)
+    end
+
+    # send relative value
+    def count(stat, count, sample_rate = 1)
+      send_data( stat, count, 'c', sample_rate)
+    end
+
+    # send absolute value
+    # TODO: check if this is actually supported by Statsd server
+    def gauge(stat, value)
+      send_data(stat, value, 'g')
+    end
+
+    # Sends a timing (in ms) (glork)
+    def timing(stat, ms, sample_rate = 1)
+      send_data(stat, ms, 'ms', sample_rate)
+    end
+
+    # Sends a timing (in ms) block based
+    def time(stat, sample_rate = 1, &block)
+      start = Time.now
+      result = block.call
+      timing(stat, ((Time.now - start) * 1000).round, sample_rate)
+      result
+    end
+
+    private
+
+    def sampled(sample_rate, &block)
+      if sample_rate < 1
+        block.call if rand <= sample_rate
+      else
+        block.call
+      end
+    end
+
+    def send_data(stat, delta, type, sample_rate = 1)
+      sampled(sample_rate) do
+        data = "#{stat}:#{delta}|#{type}" # TODO: check stat is valid
+        data << "|@#{sample_rate}" if sample_rate < 1
+        send_to_socket(data)
+      end
+    end
+
+    def send_to_socket(data)
+      logger.debug "SimpleMetrics Client send: #{data}"
+      socket.send(data, 0, @host, @port)
+    rescue Exception => e
+      puts e.backtrace
+      logger.error "SimpleMetrics Client error: #{e}"
+    end
+
+    def socket
+      @socket ||= UDPSocket.new 
+    end
+
+    def logger
+      @logger ||= SimpleMetrics.logger
+    end
+
+  end
+
+end

data/lib/simple_metrics/mongo.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+require "mongo"
+
+module SimpleMetrics
+  module Mongo
+    extend self
+
+    def ensure_collections_exist
+      SimpleMetrics.logger.debug "SERVER: MongoDB - found following collections: #{db.collection_names.inspect}"
+      Bucket.all.each do |bucket|
+        unless db.collection_names.include?(bucket.name)
+          db.create_collection(bucket.name, :capped => bucket.capped, :size => bucket.size) 
+          SimpleMetrics.logger.debug "SERVER: MongoDB - created collection #{bucket.name}, capped: #{bucket.capped}, size: #{bucket.size}"
+        end
+        db.collection(bucket.name).ensure_index([['ts', ::Mongo::ASCENDING]])
+        SimpleMetrics.logger.debug "SERVER: MongoDB - ensure index on column ts for collection #{bucket.name}"
+      end 
+    end
+
+    def truncate_collections
+      Bucket.all.each do |bucket|
+        if db.collection_names.include?(bucket.name)
+          if bucket.capped?
+            collection(bucket.name).drop # capped collections can't remove elements, drop it instead
+          else
+            collection(bucket.name).remove
+          end
+          SimpleMetrics.logger.debug "SERVER: MongoDB - truncated collection #{bucket.name}"
+        end
+      end
+    end
+
+    @@collection = {}
+    def collection(name)
+      @@collection[name] ||= db.collection(name)
+    end
+
+    def connection
+      @@connection ||= ::Mongo::Connection.new(SimpleMetrics.db_config[:host])
+    end
+
+    def db
+      @@db ||= connection.db(SimpleMetrics.db_config[:db_name], SimpleMetrics.db_config[:options])
+    end
+
+  end
+end

data/lib/simple_metrics/server.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+require "eventmachine"
+
+module SimpleMetrics
+
+  module ClientHandler
+
+    @@stats = []
+
+    class << self
+      def get_and_clear_stats
+        stats = @@stats.dup
+        @@stats = []
+        stats
+      end
+    end
+
+    def stats
+      @@stats
+    end
+
+    def post_init
+      SimpleMetrics.logger.info "ClientHandler entering post_init"
+    end
+
+    def receive_data(data)
+      SimpleMetrics.logger.debug "received_data: #{data.inspect}"
+
+      @@stats ||= []
+      @@stats << Stats.parse(data)
+    rescue Stats::ParserError => e
+      SimpleMetrics.logger.debug "Invalid Data skipped: #{data}"
+    end
+  end
+
+  class Server
+
+    attr_reader :db, :connection
+
+    def start
+      SimpleMetrics.logger.info "SERVER: starting up on #{SimpleMetrics.config[:host]}:#{SimpleMetrics.config[:port]}..."
+
+      Mongo.ensure_collections_exist
+
+      EM.run do
+        EM.open_datagram_socket(SimpleMetrics.config[:host], SimpleMetrics.config[:port], SimpleMetrics::ClientHandler) do |con|
+          EventMachine::add_periodic_timer(SimpleMetrics.config[:flush_interval]) do
+            SimpleMetrics.logger.debug "SERVER: period timer triggered after #{SimpleMetrics.config[:flush_interval]} seconds"
+
+            EM.defer { Bucket.flush_stats(ClientHandler.get_and_clear_stats) } 
+          end
+        end
+      end
+    end
+
+    def stop
+      SimpleMetrics.logger.info "EventMachine stop"
+      EM.stop
+    end
+    
+    def to_s
+      "#{SimpleMetrics.config[:host]}:#{SimpleMetrics.config[:port]}"
+    end
+
+  end
+end

data/lib/simple_metrics/stats.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+module SimpleMetrics
+
+  class Stats
+
+    class NonMatchingTypesError < Exception; end
+    class ParserError           < Exception; end
+
+    # examples:
+    # com.example.test1:1|c
+    # com.example.test2:-1|c
+    # com.example.test2:50|g
+    # com.example.test3:5|c|@0.1
+    # com.example.test4:44|ms
+    REGEXP = /^([\d\w_.]*):(-?[\d]*)\|(c|g|ms){1}(\|@([.\d]+))?$/i
+
+    class << self
+
+      def parse(str)
+        if str =~ REGEXP
+          name, value, type, sample_rate = $1, $2, $3, $5
+          if type == "ms"
+            # TODO: implement sample_rate handling
+            create_timing(:name => name, :value => value)
+          elsif type == "g"
+            create_gauge(:name => name, :value => (value.to_i || 1) * (1.0 / (sample_rate || 1).to_f) )
+          elsif type == "c"
+            create_counter(:name => name, :value => (value.to_i || 1) * (1.0 / (sample_rate || 1).to_f) )
+          end
+        else
+          raise ParserError, "Parser Error - Invalid Stat: #{str}"
+        end
+      end
+
+      def create_counter(attributes)
+        Stats.new(attributes.merge(:type => 'c'))
+      end
+
+      def create_gauge(attributes)
+        Stats.new(attributes.merge(:type => 'g'))
+      end
+
+      def create_timing(attributes)
+        Stats.new(attributes.merge(:type => 'ms'))
+      end
+
+      def aggregate(stats_array)
+        raise NonMatchingTypesError unless stats_array.group_by { |stats| stats.type }.size == 1
+
+        result_stat = stats_array.first.dup
+        result_stat.value = stats_array.map { |stats| stats.value }.inject(0) { |result, value| result += value }
+        result_stat
+      end
+
+      def create_from_db(attributes)
+        Stats.new(:name => attributes["name"], :value => attributes["value"], :ts => attributes["ts"], :type => attributes["type"])
+      end
+    end
+
+    attr_accessor :name, :ts, :type, :value
+
+    def initialize(attributes)
+      @name  = attributes[:name]
+      @value = attributes[:value]
+      @ts    = attributes[:ts]
+      @type  = attributes[:type]
+    end
+
+    def counter?
+      type == 'c'
+    end
+
+    def gauge?
+      type == 'g'
+    end
+
+    def timing?
+      type == 'ms'
+    end
+
+    def timestamp
+      ts
+    end
+
+    def value
+      @value.to_i
+    end
+
+    def attributes
+      { 
+        :name  => name,
+        :value => value,
+        :ts    => ts,
+        :type  => type
+      }
+    end
+
+  end
+end

data/lib/simple_metrics/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module SimpleMetrics
+  VERSION = "0.0.1"
+end

data/simple_metrics.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "simple_metrics/version"
+
+Gem::Specification.new do |s|
+  s.name        = "simple_metrics"
+  s.version     = SimpleMetrics::VERSION
+  s.authors     = ["Frederik Dietz"]
+  s.email       = ["fdietz@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{SimpleMetrics}
+  s.description = %q{SimpleMetrics}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rr"
+
+  s.add_dependency "eventmachine"
+  s.add_dependency "daemons"
+  s.add_dependency "mongo"
+  s.add_dependency "bson_ext"
+end

data/spec/bucket_spec.rb

@@ -0,0 +1,181 @@
+# encoding: utf-8
+require "spec_helper"
+
+module SimpleMetrics
+
+  describe Bucket do
+
+    let(:bucket) do
+      Bucket.first
+    end
+
+    let(:sec) do
+      bucket.seconds
+    end
+
+    let(:ts) do
+      Time.now.utc.to_i
+    end
+
+    describe "#ts_bucket" do
+      it "calculates timestamp for current bucket" do
+        bucket.ts_bucket(ts).should == ts/sec*sec
+      end
+    end
+
+    describe "#next_ts_bucket" do
+      it "calculates timestamp for next bucket" do
+        bucket.next_ts_bucket(ts).should == ts/sec*sec+sec
+      end
+    end
+
+    describe "#previous_ts_bucket" do
+      it "calculates timestamp for previous bucket" do
+        bucket.previous_ts_bucket(ts).should == ts/sec*sec-sec
+      end
+    end
+
+    describe "#save" do
+      before do
+        Mongo.truncate_collections
+        Mongo.ensure_collections_exist
+        bucket.save(stats, ts)
+      end
+
+      let(:stats) do
+        Stats.create_counter(:name => "key1", :value => 5)
+      end
+
+      it "saves given data in bucket" do
+        results = bucket.find_all_by_name("key1")
+        results.should have(1).item
+        result = results.first
+        result.name.should  == stats.name
+        result.value.should == stats.value
+        result.type.should  == stats.type
+      end
+
+      it "saves data in correct timestamp" do
+        result = bucket.find_all_by_name("key1").first
+        result.ts.should == ts/sec*sec
+      end
+
+    end # describe "#save" do
+
+    describe "finder methods" do
+
+      before do
+        Mongo.truncate_collections
+        Mongo.ensure_collections_exist
+      end
+
+      describe "#find_all_by_name" do
+        it "returns all stats for given name" do
+          stats_same1 =  Stats.create_counter(:name => "key1", :value => 5)
+          stats_same2 =  Stats.create_counter(:name => "key1", :value => 3)
+          stats_different = Stats.create_counter(:name => "key2", :value => 3)
+
+          bucket.save(stats_same1, ts)
+          bucket.save(stats_same2, ts)
+          bucket.save(stats_different, ts)
+
+          results = bucket.find_all_by_name("key1")
+          results.should have(2).items
+          results.first.name.should == stats_same1.name
+        end
+      end
+
+      describe "#find_all_in_ts" do
+        it "returns all stats in given timestamp" do
+          stats1  =  Stats.create_counter(:name => "key1", :value => 5)
+          stats2  =  Stats.create_counter(:name => "key2", :value => 3)
+
+          bucket.save(stats1, ts)
+          bucket.save(stats2, bucket.next_ts_bucket(ts))
+
+          result1 = bucket.find_all_in_ts(ts).first
+          result1.name.should == stats1.name
+          result1.value.should == stats1.value
+
+          result2 = bucket.find_all_in_ts(bucket.next_ts_bucket(ts)).first
+          result2.name.should == stats2.name
+          result2.value.should == stats2.value
+        end
+      end
+
+      describe "#find_all_in_ts_by_name" do
+        it "returns all stats for given name and timestamp" do
+          stats1a  =  Stats.create_counter(:name => "key1", :value => 5)
+          stats1b  =  Stats.create_counter(:name => "key1", :value => 7)
+          stats2   =  Stats.create_counter(:name => "key2", :value => 7)
+          stats1_different_ts   =  Stats.create_counter(:name => "key1", :value => 3)
+
+          bucket.save(stats1a, ts)
+          bucket.save(stats1b, ts)
+          bucket.save(stats2, ts)
+          bucket.save(stats1_different_ts, bucket.next_ts_bucket(ts))
+
+          results = bucket.find_all_in_ts_by_name(ts, "key1")
+          results.should have(2).items
+          results.first.name.should == "key1"
+          results.last.name.should == "key1"
+        end
+      end
+
+    end # describe "finder methods"
+
+    describe "#aggregate_all" do
+      before do
+        Mongo.truncate_collections
+        Mongo.ensure_collections_exist
+      end
+
+      it "aggregates all stats" do
+        stats1a  =  Stats.create_counter(:name => "key1", :value => 5)
+        stats1b  =  Stats.create_counter(:name => "key1", :value => 7)
+        stats2   =  Stats.create_counter(:name => "key2", :value => 3)
+
+        bucket2 = Bucket[1]
+        ts_at_insert = bucket2.previous_ts_bucket(ts)
+        bucket.save(stats1a, ts_at_insert)
+        bucket.save(stats1b, ts_at_insert)
+        bucket.save(stats2, ts_at_insert)
+
+        Bucket.aggregate_all(ts)
+
+        results = bucket2.find_all_in_ts(ts_at_insert)
+        results.should have(2).items
+
+        key1_result = results.find {|stat| stat.name == "key1"}
+        key1_result.value.should == 12
+        key1_result.should be_counter
+
+        key2_result = results.find {|stat| stat.name == "key2"}
+        key2_result.value.should == 3
+        key2_result.should be_counter
+      end
+    end # describe "#aggregate_all"
+
+    describe "#flush_stats" do
+      before do
+        stats1 = Stats.create_counter(:name => "key1", :value => 5)
+        stats2 = Stats.create_counter(:name => "key1", :value => 7)
+        stats3 = Stats.create_counter(:name => "key2", :value => 3)
+        @stats = [stats1, stats2, stats3]
+      end
+
+      it "saves all stats in finest/first bucket" do
+        Bucket.flush_stats(@stats)
+
+        results = bucket.find_all_in_ts(ts)
+        results.should have(3).items
+      end
+
+      it "calls aggregate_all afterwards" do
+        mock(Bucket).aggregate_all(ts)
+        Bucket.flush_stats(@stats)
+      end
+    end # describe "#flush_stats"
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require "simple_metrics"
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end
+
+SimpleMetrics.logger = Logger.new('/dev/null')
+SimpleMetrics.db_config = { :host => 'localhost', :prefix => 'test' }
+
+

data/spec/stats_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+require "spec_helper"
+
+module SimpleMetrics
+
+  describe Bucket do
+
+    describe "#parse" do
+
+      it "parses increment counter" do
+        stats = Stats.parse("com.example.test1:1|c")
+        stats.name.should == "com.example.test1"
+        stats.value.should == 1
+        stats.should be_counter
+      end
+
+      it "parses decrement counter" do
+        stats = Stats.parse("com.example.test1:-1|c")
+        stats.name.should == "com.example.test1"
+        stats.value.should == -1
+        stats.should be_counter
+      end
+
+      it "parses counter with sample rate" do
+        stats = Stats.parse("com.example.test2:5|c|@0.1")
+        stats.name.should == "com.example.test2"
+        stats.value.should == 50
+        stats.should be_counter
+      end
+
+      it "parses increment gauge" do
+        stats = Stats.parse("com.example.test3:5|g")
+        stats.name.should == "com.example.test3"
+        stats.value.should == 5
+        stats.should be_gauge
+      end
+
+      it "parses increment gauge with sample rate" do
+        stats = Stats.parse("com.example.test3:5|g|@0.1")
+        stats.name.should == "com.example.test3"
+        stats.value.should == 50
+        stats.should be_gauge
+      end
+
+      it "parses increment timing" do
+        stats = Stats.parse("com.example.test4:44|ms")
+        stats.name.should == "com.example.test4"
+        stats.value.should == 44
+        stats.should be_timing
+      end
+
+      it "parses increment timing with sample rate" do
+      end
+    end
+
+
+    describe "create_counter" do
+    end
+  end
+
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: simple_metrics
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Frederik Dietz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70244480135940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70244480135940
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70244480135460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70244480135460
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: &70244480135020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70244480135020
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70244480134600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70244480134600
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: &70244480134180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70244480134180
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: &70244480133740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70244480133740
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: &70244480133300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70244480133300
+description: SimpleMetrics
+email:
+- fdietz@gmail.com
+executables:
+- simple_metrics_client
+- simple_metrics_server
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.markdown
+- Rakefile
+- bin/simple_metrics_client
+- bin/simple_metrics_server
+- example/increment.rb
+- lib/simple_metrics.rb
+- lib/simple_metrics/bucket.rb
+- lib/simple_metrics/client.rb
+- lib/simple_metrics/mongo.rb
+- lib/simple_metrics/server.rb
+- lib/simple_metrics/stats.rb
+- lib/simple_metrics/version.rb
+- simple_metrics.gemspec
+- spec/bucket_spec.rb
+- spec/spec_helper.rb
+- spec/stats_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: SimpleMetrics
+test_files:
+- spec/bucket_spec.rb
+- spec/spec_helper.rb
+- spec/stats_spec.rb