metricize 0.4.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e9a9c558536848b9cabca975cdff4c4c985d41a4
+  data.tar.gz: 692614a119d59aca4dc08bfcfeb88a4aff12387e
+SHA512:
+  metadata.gz: d9cf9019f8ad81f81203a665068536f8424c927f07c54fc3f83be073a0dc41eb491b1999e7ea2567164891ac493ddce5881c3cb9474f4b2d2f501d6dc35b514b
+  data.tar.gz: 5cf0995e784a3874906c05c1dc6b306148620654bd91334490c47e4ee305a328f3430345693aa3da942871fc2374c6f43eae0a2d65b4e7b8ac168c85d1df7624

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rbenv-version

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in metricize.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Matt McNeil
+
+MIT License
+
+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/README.md

@@ -0,0 +1,52 @@
+# Metricize
+
+Simple in-memory server to receive metrics, aggregate them, and send them to a stats service
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'metricize'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install metricize
+
+## Usage
+
+    # start server in its own Ruby process (eg using lib/tasks/metrics.rake)
+    Metricize::Server.new(username: 'name@example.com', password: 'api_key').start
+
+    # start appropriate client (eg from config/initializers/metrics.rb)
+    if Rails.env == 'production'
+      client_config = { prefix:     "app_name.#{Rails.env}",
+                        queue_host: 'localhost',
+                        queue_name: "app_name.#{Rails.env}.metrics_queue",
+                        logger:     Rails.logger }
+
+      METRICS = Metricize::Client.new(client_config)
+
+    else
+      METRICS = Metricize::NullClient
+    end
+
+    # use client interface to send metrics from the app
+    METRICS.increment('content_post.make') # increment by default value of 1
+    METRICS.increment('bucket.make', by: 5) # increment counter by 5
+    METRICS.measure('worker_processes', 45) # send a snapshot of a current value (eg 45)
+    METRICS.time('facebook.request_content') do  # record the execution time of a slow block
+      # make API call...
+    end
+    METRICS.measure('stat', 45, source: 'my_source') # break out stat by subgrouping
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/lib/metricize.rb

@@ -0,0 +1,14 @@
+require "metricize/version"
+
+require 'thread'
+require 'rest-client'
+require 'json'
+require 'logger'
+require 'redis'
+require 'ascii_charts'
+
+require "metricize/shared"
+require "metricize/forwarder"
+require "metricize/client"
+require "metricize/stats"
+require "metricize/null_client"

data/lib/metricize/client.rb

@@ -0,0 +1,62 @@
+module Metricize
+  class Client
+    include SharedMethods
+
+    def initialize(options = {})
+      @prefix = options[:prefix]
+      establish_logger(options)
+      initialize_redis(options)
+      establish_redis_connection
+    end
+
+    def increment(name, options = {})
+      count = options.delete(:by) || 1
+      enqueue_count(name, count, options)
+    end
+
+    def measure(name, value, options = {})
+      enqueue_value(name, value, options)
+    end
+
+    def time(name, options = {})
+      raise ArgumentError, "must be invoked with a block to time" unless block_given?
+      start_time = Time.now
+      block_result = yield
+      measure(name + '.time', time_delta_ms(start_time))
+      return block_result
+    end
+
+    private
+
+    def enqueue_count(name, count, options)
+      push_to_queue(build_metric_name(name) + '.count', count, options)
+    end
+
+    def enqueue_value(name, value, options)
+      raise ArgumentError, "no numeric value provided in measure call" unless value.kind_of?(Numeric)
+      push_to_queue(build_metric_name(name), round(value, 4), options)
+    end
+
+    def push_to_queue(name, value, options)
+      data = prepare_metric(name, value, options).to_json
+      @redis.lpush(@queue_name, data)
+      msg = "#{name.gsub('.', '_')}=#{value}" # splunk chokes on dots in field names
+      msg << ", metric_source=#{options[:source].gsub('.', '_')}" if options[:source]
+      log_message msg, :info
+    end
+
+    def build_metric_name(name)
+      [ @prefix, sanitize(name) ].compact.join('.')
+    end
+
+    def sanitize(name)
+      name.to_s.strip.downcase.gsub(' ', '_').gsub(/[^a-z0-9._]/, '')
+    end
+
+    def prepare_metric(name, value, options)
+      options[:source] = sanitize(options[:source]) if options[:source]
+      options.merge(:name => name, :value => value)
+    end
+
+  end
+end

data/lib/metricize/forwarder.rb

@@ -0,0 +1,140 @@
+module Metricize
+  class Forwarder
+    include Metricize::SharedMethods
+
+    def initialize(options)
+      @password          = options.fetch(:password)
+      @username          = options.fetch(:username)
+      @remote_url        = options[:remote_url]     || 'metrics-api.librato.com/v1/metrics'
+      @remote_timeout    = options[:remote_timeout] || 10
+      establish_logger(options)
+      initialize_redis(options)
+    end
+
+    def go!
+      establish_redis_connection
+      process_metric_queue
+    end
+
+    private
+
+    def process_metric_queue
+      queue = retrieve_queue_contents
+      return if queue.empty?
+      store_metrics(add_aggregate_info(queue))
+      clear_queue
+    rescue RuntimeError => e
+      log_message "Error: " + e.message, :error
+    end
+
+    def retrieve_queue_contents
+      log_message "checking... queue_length=#{queue_length = @redis.llen(@queue_name)}", :info
+      return [] unless queue_length > 0
+      queue = @redis.lrange(@queue_name, 0, -1)
+      queue.map {|metric| JSON.parse(metric, :symbolize_names => true) }
+    end
+
+    def clear_queue
+      log_message "clearing queue"
+      @redis.del @queue_name if @redis
+    end
+
+    def store_metrics(data)
+      log_message "remote_data_sent='#{data}'"
+      start_time = Time.now
+      RestClient.post("https://#{@username.sub('@','%40')}:#{@password}@#{@remote_url}",
+                      data.to_json,
+                      :timeout      => @remote_timeout,
+                      :content_type => 'application/json')
+      log_message "remote_data_sent_chars=#{data.to_s.length}, remote_request_duration_ms=#{time_delta_ms(start_time)}", :info
+    end
+
+    def add_aggregate_info(metrics)
+      counters, measurements = metrics.partition {|metric| metric.fetch(:name) =~ /.count$/ }
+      counters = consolidate_counts(counters)
+      measurements = add_value_stats(measurements)
+      measurements << add_stat_by_key(@queue_name + '.counters', counters.size)
+      { :gauges => counters + measurements, :measure_time => Time.now.to_i }
+    end
+
+    def consolidate_counts(counters)
+      aggregated_counts = {}
+      counters.each_with_index do |metric,i|
+        # collect aggregate stats for each name+source combination
+        key = [metric.fetch(:name), metric[:source]].join('|')
+        aggregated_counts[key] = aggregated_counts[key].to_i + metric[:value]
+      end
+      aggregated_counts.map do | key, count |
+        add_stat_by_key(key, count).merge(counter_attributes)
+      end
+    end
+
+    def counter_attributes
+      { :attributes => {:source_aggregate => true, :summarize_function => 'sum'} }
+    end
+
+    def add_value_stats(gauges)
+      value_groups = {}
+      gauges.each do | metric |
+        key = [metric.fetch(:name), metric[:source]].join('|')
+        value_groups[key] ||= []
+        value_groups[key] << metric[:value]
+      end
+      value_groups.each do |key, values|
+        print_histogram(key, values)
+        gauges << add_stat_by_key(key, values.size, '.count').merge(counter_attributes)
+        gauges << add_stat_by_key(key, values.max, ".max")
+        gauges << add_stat_by_key(key, values.min, ".min")
+        [0.25, 0.50, 0.75, 0.95].each do |p|
+          percentile = values.extend(Stats).calculate_percentile(p)
+          gauges << add_stat_by_key(key, percentile, ".#{(p*100).to_i}e")
+        end
+      end
+      gauges << add_stat_by_key(@queue_name + '.measurements', value_groups.size)
+      gauges
+    end
+
+    def print_histogram(name, values)
+      return if values.size < 5
+
+      num_bins = [25, values.size].min.to_f
+      bin_width = (values.max - values.min)/num_bins
+      bin_width = 1 if bin_width == 0
+
+      bins = (values.min...values.max).step(bin_width).to_a
+      freqs = bins.map {| bin | values.select{|x| x >= bin && x <= (bin+bin_width) }.count }
+
+      name = name.gsub('|','.').sub(/\.$/, '')
+
+      values.extend(Stats)
+      chart_data    = bins.map!(&:floor).zip(freqs)
+      chart_options = { :bar       => true,
+                        :title     => "\nHistogram for #{name} at #{Time.now}",
+                        :hide_zero => true }
+      chart_output  = AsciiCharts::Cartesian.new(chart_data, chart_options).draw +
+                       "\n#{name}.count=#{values.count}\n" +
+                       "#{name}.min=#{round(values.min, 2)}\n" +
+                       "#{name}.max=#{round(values.max, 2)}\n" +
+                       "#{name}.mean=#{round(values.mean, 2)}\n" +
+                       "#{name}.stddev=#{round(values.standard_deviation, 2)}\n"
+      log_message(chart_output, :info)
+    rescue => e
+      log_message("#{e}: Could not print histogram for #{name} with these input values: #{values.inspect}", :error)
+    end
+
+    def add_stat_by_key(key, value, suffix = "")
+      metric = { :name         => key.split('|')[0] + suffix,
+                 :value        => value }
+      metric.merge!(:source => key.split('|')[1]) if key.split('|')[1]
+      metric
+    end
+
+    def calculate_percentile(values, percentile)
+      return values.first if values.size == 1
+      values_sorted = values.sort
+      k = (percentile*(values_sorted.length-1)+1).floor - 1
+      values_sorted[k]
+    end
+
+  end
+end

data/lib/metricize/null_client.rb

@@ -0,0 +1,14 @@
+module Metricize
+
+  class NullClient
+    def self.increment(*args); end
+    def self.measure(*args); end
+    def self.time(*args); yield; end
+    def self.establish_redis_connection; end
+  end
+
+  class NullForwarder
+    def self.go!; end
+  end
+
+end

data/lib/metricize/shared.rb

@@ -0,0 +1,38 @@
+module Metricize
+  module SharedMethods
+
+    def establish_redis_connection
+      log_message "metricize_version=#{VERSION} connecting to Redis at #{@queue_host}:#{@queue_port}", :info
+      @redis = Redis.connect(:host => @queue_host, :port => @queue_port)
+      @redis.ping
+    end
+
+    private
+
+    def initialize_redis(options)
+      @queue_host  = options[:queue_host] || '127.0.0.1'
+      @queue_port  = options[:queue_port] || 6379
+      @queue_name  = options[:queue_name] || 'metricize_queue'
+    end
+
+    def establish_logger(options)
+      @logger = options[:logger] || Logger.new(STDOUT)
+    end
+
+    def log_message(message, level = :debug)
+      message = "[#{self.class} #{Process.pid}] " + message
+      @logger.send(level.to_sym, message)
+    end
+
+    def time_delta_ms(start_time)
+      (((Time.now - start_time) * 100000.0).round) / 100.0
+    end
+
+    def round(value, num_places)
+      factor = 10.0**num_places
+      ((value * factor).round) / factor
+    end
+
+  end
+end
+

data/lib/metricize/stats.rb

@@ -0,0 +1,30 @@
+module Metricize
+  module Stats
+
+    def sum
+      return self.inject(0){|accum, i| accum + i }
+    end
+
+    def mean
+      return self.sum / self.length.to_f
+    end
+
+    def sample_variance
+      m = self.mean
+      sum = self.inject(0){|accum, i| accum + (i - m) ** 2 }
+      return sum / (self.length - 1).to_f
+    end
+
+    def standard_deviation
+      return Math.sqrt(self.sample_variance)
+    end
+
+    def calculate_percentile(percentile)
+      return self.first if self.size == 1
+      values_sorted = self.sort
+      k = (percentile*(values_sorted.length-1)+1).floor - 1
+      values_sorted[k]
+    end
+
+  end
+end

data/lib/metricize/version.rb

@@ -0,0 +1,3 @@
+module Metricize
+  VERSION = "0.4.4"
+end

data/metricize.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'metricize/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "metricize"
+  spec.version       = Metricize::VERSION
+  spec.authors       = ["Matt McNeil"]
+  spec.email         = ["mmcneil@liveworld.com"]
+  spec.description   = %q{Simple client/forwarder system to aggregate metrics and periodically send them to a stats service}
+  spec.summary       = %q{Collect, aggregate, and send metrics to a stats service}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "timecop"
+  spec.add_development_dependency "fakeredis"
+  spec.add_development_dependency "simplecov"
+
+  spec.add_runtime_dependency "rest-client"
+  spec.add_runtime_dependency "json"
+  spec.add_runtime_dependency "redis"
+  spec.add_runtime_dependency "ascii_charts"
+
+end

data/spec/lib/metricize_spec.rb

@@ -0,0 +1,245 @@
+require "spec_helper"
+
+describe Metricize do
+  let(:logger) { double.as_null_object }
+  let(:forwarder) { Metricize::Forwarder.new( :password => 'api_key',
+                                             :username => 'name@example.com',
+                                             :logger   => logger) }
+
+  let(:client) { Metricize::Client.new( :prefix => 'prefix', :logger => logger ) }
+
+  before do
+    Timecop.freeze(Time.at(1234))
+    RestClient.stub(:post)
+  end
+
+  after do
+    Timecop.return
+    forwarder.send(:clear_queue)
+  end
+
+  it "provides null object implementations to allow for easily disabling metrics functionality" do
+    expect(Metricize::NullClient).to respond_to(:new, :increment, :measure, :time)
+    expect(Metricize::NullForwarder).to respond_to(:new, :go!)
+  end
+
+  it "properly uses the remote API to send gauge stats" do
+    client.increment('stat.name', :source => 'my_source')
+    RestClient.should_receive(:post).with do | api_url, post_data, request_params |
+      expect(api_url).to eq("https://name%40example.com:api_key@metrics-api.librato.com/v1/metrics")
+      first_gauge = JSON.parse(post_data)['gauges'].first
+      expect(first_gauge['name']).to eq "prefix.stat.name.count"
+      expect(first_gauge['source']).to eq "my_source"
+      expect(first_gauge['attributes']).to eq("source_aggregate" => true, "summarize_function" => "sum")
+      expect(request_params).to eq( :timeout => 10, :content_type => "application/json" )
+    end
+    forwarder.go!
+  end
+
+  it "sends stats when requested with go!" do
+    client.measure('value_stat', 777)
+    RestClient.should_receive(:post)
+    forwarder.go!
+  end
+
+  it "does not send stats if none have been recorded" do
+    RestClient.should_not_receive(:post)
+    forwarder.go!
+  end
+
+  it "clears queue and does not send again after a successful request" do
+    client.increment('stat.name')
+    forwarder.go!
+    RestClient.should_not_receive(:post)
+    forwarder.go!
+  end
+
+  it "removes special characters and spaces and converts the metric names and sources to dotted decimal snake_case" do
+    client.increment(' My UNRULY stat!@#$%^&*\(\) ')
+    RestClient.should_receive(:post).with(anything, /my_unruly_stat/, anything)
+    forwarder.go!
+    client.increment('test', :source => ' My UNRULY source!@#$%^&*\(\) ')
+    RestClient.should_receive(:post).with(anything, /my_unruly_source/, anything)
+    forwarder.go!
+  end
+
+  it "converts passed in objects to string before using them as metric or source names" do
+    client.increment(Numeric, :source => Integer)
+    RestClient.should_receive(:post).with do | _, post_data |
+      expect(post_data).to match( /prefix.numeric.count/ )
+      expect(post_data).to match( /source":"integer"/ )
+    end
+    forwarder.go!
+  end
+
+  it "sends all stats in a batch with the same timestamp" do
+    client.measure('value1', 5)
+    RestClient.should_receive(:post).with(anything, /measure_time":1234\D/, anything)
+    forwarder.go!
+  end
+
+  it "adds subgrouping information if present" do
+    client.increment('counter1', :source => 'my_source')
+    RestClient.should_receive(:post).with(anything, /"source":"my_source"/, anything)
+    forwarder.go!
+  end
+
+  it "consolidates repeated counts into an aggregate total before sending" do
+    client.increment('counter1')
+    client.increment('counter1', :by => 5)
+    RestClient.should_receive(:post).with do | _, post_data |
+      expect(post_data).to match( /"value":6/ )
+      expect(post_data).to match( /"name":"prefix.counter1.count"/ )
+      expect(post_data).to match( /source_aggregate":true/ )
+      expect(post_data).to match( /summarize_function":"sum"/ )
+    end
+    forwarder.go!
+  end
+
+  it "aggregates requests from multiple clients" do
+    client.increment('counter1')
+    client2 = Metricize::Client.new( :prefix => 'prefix', :logger => logger )
+    client2.increment('counter1', :by => 5)
+    RestClient.should_receive(:post).with do | _, post_data |
+      expect(post_data).to match( /"value":6/ )
+      expect(post_data).to match( /"name":"prefix.counter1.count"/ )
+    end
+    forwarder.go!
+  end
+
+  it "sends value stats when asked to measure something" do
+    client.measure('value1', 10)
+    client.measure('value2', 20)
+    RestClient.should_receive(:post).with do | _, post_data |
+      gauges = JSON.parse(post_data)['gauges']
+      expect(gauges[1]['name']).to eq "prefix.value1"
+      expect(gauges[1]['value']).to eq 10.0
+      expect(gauges[0]['name']).to eq "prefix.value2"
+      expect(gauges[0]['value']).to eq 20.0
+    end
+    forwarder.go!
+  end
+
+  it "raises an error when measure is called without a numeric value" do
+    expect { client.measure('boom', {}) }.to raise_error(ArgumentError, /no numeric value provided in measure call/)
+    expect { client.measure('boom', 'NaN') }.to raise_error(ArgumentError, /no numeric value provided in measure call/)
+  end
+
+  it "rounds value stats to 4 decimals" do
+    client.measure('value1', 1.0/7.0)
+    RestClient.should_receive(:post).with(anything, /value":0.1429/, anything)
+    forwarder.go!
+  end
+
+  describe "adding aggregate stats based on all instances of each value stat in this time interval" do
+
+    it "splits out aggregate stats for each subgrouping for values with multiple sources" do
+      [4,5,6].each { |value| client.measure('value1', value, :source => 'source1') }
+      [1,2,3].each { |value| client.measure('value1', value, :source => 'source2') }
+      RestClient.should_receive(:post).with do | url, post_data |
+        gauges = JSON.parse(post_data)['gauges']
+        expect(gauges).to include("name"=>"prefix.value1.50e", "source"=> "source1", "value"=>5.0)
+        expect(gauges).to include("name"=>"prefix.value1.50e", "source"=> "source2", "value"=>2.0)
+      end
+      forwarder.go!
+    end
+
+    it "asks for server aggregation on the count of value stats" do
+      client.measure('value_stat1', 7)
+      RestClient.should_receive(:post).with do | url, post_data |
+        gauges = JSON.parse(post_data)['gauges']
+        expect(gauges).to include("name"=>"prefix.value_stat1.count", "value"=>1, "attributes"=>{"source_aggregate"=>true, "summarize_function"=>"sum"})
+      end
+      forwarder.go!
+    end
+
+    it "adds min, max, and count" do
+      [4,5,6].each { |value| client.measure('value1', value) }
+      RestClient.should_receive(:post).with do | url, post_data |
+        gauges = JSON.parse(post_data)['gauges']
+        expect(gauges).to include("name"=>"prefix.value1.count", "value"=>3, "attributes"=>{"source_aggregate"=>true, "summarize_function"=>"sum"})
+        expect(gauges).to include("name"=>"prefix.value1.max", "value"=>6)
+        expect(gauges).to include("name"=>"prefix.value1.min", "value"=>4)
+      end
+      forwarder.go!
+    end
+
+    it "adds metadata about the entire batch of stats" do
+      (1..4).each { |index| client.measure("value_stat#{index}", 0) }
+      (1..7).each { |index| client.increment("counter_stat#{index}") }
+      RestClient.should_receive(:post).with do | url, post_data |
+        gauges = JSON.parse(post_data)['gauges']
+        expect(gauges).to include("name"=>"metricize_queue.measurements", "value"=>4)
+        expect(gauges).to include("name"=>"metricize_queue.counters", "value"=>7)
+      end
+      forwarder.go!
+    end
+
+    it "calculates standard deviation and mean" do
+      values = [1,2,3,4,5,6].extend(Metricize::Stats)
+      expect(values.mean).to eq(3.5)
+      expect(values.standard_deviation).to be_within(0.01).of(1.87083)
+    end
+
+    it "adds percentile stats for each value stat" do
+      (1..20).each { |value| client.measure('value_stat1', value) }
+      client.measure('value_stat2', 7)
+      RestClient.should_receive(:post).with do | _, post_data |
+        gauges = JSON.parse(post_data)['gauges']
+        expect(gauges).to include("name"=>"prefix.value_stat1.25e", "value"=>5.0)
+        expect(gauges).to include("name"=>"prefix.value_stat1.50e", "value"=>10.0)
+        expect(gauges).to include("name"=>"prefix.value_stat1.75e", "value"=>15.0)
+        expect(gauges).to include("name"=>"prefix.value_stat1.95e", "value"=>19.0)
+        expect(gauges).to include("name"=>"prefix.value_stat2.95e", "value"=>7.0)
+      end
+      forwarder.go!
+    end
+
+    it "logs a histogram for value stats with more than 5 measurements" do
+      2.times { logger.should_receive(:info) }
+      [10,10,15,15,15,19].each { |value| client.measure('value_stat1', value) }
+      #3|          *
+      #2| *        *
+      #1| *        *     *
+      #0+------------------
+       # 10 11 13 14 16 17
+      logger.should_receive(:info).with(/10 11 13 14 16 17/m)
+      forwarder.go!
+    end
+
+    it "doesn't log a histogram for value stats with less than 5 measurements" do
+      [10,10,15].each { |value| client.measure('value_stat1', value) }
+      2.times { logger.should_receive(:info) }
+      logger.should_not_receive(:info).with(/Histogram/)
+      forwarder.go!
+    end
+
+    it "handles cases where all values are the same" do
+      [10,10,10,10,10,10].each { |value| client.measure('value_stat1', value) }
+      logger.should_not_receive(:error)
+      forwarder.go!
+    end
+
+  end
+
+  it "times and reports the execution of a block of code in milliseconds" do
+    client.time('my_slow_code') do
+      Timecop.travel(5) # simulate 5000 milliseconds of runtime
+    end
+    RestClient.should_receive(:post).with do | _, post_data |
+      first_gauge = JSON.parse(post_data)['gauges'].first
+      expect(first_gauge['name']).to eq('prefix.my_slow_code.time')
+      expect(first_gauge['value']).to be_within(0.2).of(5000)
+    end
+    forwarder.go!
+  end
+
+  it "retries sending if it encounters an error" do
+    client.increment('counter1')
+    RestClient.stub(:post).and_raise(RestClient::Exception)
+    forwarder.go!
+    RestClient.should_receive(:post)
+    forwarder.go!
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'bundler/setup'
+require 'simplecov'
+SimpleCov.start
+require 'metricize'
+require 'timecop'
+require 'fakeredis'

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification
+name: metricize
+version: !ruby/object:Gem::Version
+  version: 0.4.4
+platform: ruby
+authors:
+- Matt McNeil
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ascii_charts
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple client/forwarder system to aggregate metrics and periodically
+  send them to a stats service
+email:
+- mmcneil@liveworld.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/metricize.rb
+- lib/metricize/client.rb
+- lib/metricize/forwarder.rb
+- lib/metricize/null_client.rb
+- lib/metricize/shared.rb
+- lib/metricize/stats.rb
+- lib/metricize/version.rb
+- metricize.gemspec
+- spec/lib/metricize_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Collect, aggregate, and send metrics to a stats service
+test_files:
+- spec/lib/metricize_spec.rb
+- spec/spec_helper.rb