ruby-metrics 0.9.0 → 0.9.4

data/lib/ruby-metrics/reporters/ganglia.rb

@@ -0,0 +1,80 @@
+require 'ruby-metrics/version'
+require 'ruby-metrics'
+
+require 'gmetric'
+
+module Metrics
+  module Reporters
+    class GangliaReporter
+
+      attr_reader :host_ip, :host_port
+
+      def initialize(options = {})
+        @host_ip = options[:host_ip]
+        @host_port = options[:host_port] 
+      end
+
+      def send_data(data)
+        puts "Sending data: #{data.inspect}"
+        data_type =
+          case data[:value]
+          Fixnum
+            "uint32"
+          Float
+            "float"
+          String
+            "string"
+          else
+            "unknown"
+          end
+
+        Ganglia::GMetric.send(@host_ip, @host_port.to_i,
+           :spoof => 0,
+           :name => data[:name],
+           :units => data[:units],
+           :type => data_type,
+           :value => data[:value],
+           :tmax => 60,
+           :dmax => 300,
+        )
+      end
+
+      def report(agent)
+        agent.instruments.each do |name, instrument|
+          case instrument
+          when Metrics::Instruments::Counter
+            send_data :name  => name,
+                      :value => instrument.to_i,
+                      :units => instrument.units
+          when Metrics::Instruments::Gauge
+            if instrument.get.is_a? Hash
+              instrument.get.each do |key, value|
+                send_data :name  => "#{name}_#{key}",
+                          :value => value,
+                          :units => instrument.units
+              end
+            else
+              send_data :name  => name,
+                        :value => instrument.get,
+                        :units => instrument.units
+            end
+          when Metrics::Instruments::Timer
+            [:count, :fifteen_minute_rate, :five_minute_rate, :one_minute_rate, :min, :max, :mean].each do |attribute|
+              send_data :name  => "#{name}_#{attribute}",
+                        :value => instrument.send(attribute),
+                        :units => instrument.units
+            end
+          when Metrics::Instruments::Meter
+            [:count, :fifteen_minute_rate, :five_minute_rate, :one_minute_rate, :mean_rate].each do |attribute|
+              send_data :name  => "#{name_attribute}",
+                        :value => instrument.send(attribute),
+                        :units => instrument.units
+            end
+          else
+            puts "Unhandled instrument"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby-metrics/reporters/librato.rb

@@ -0,0 +1,85 @@
+require 'net/https'
+require 'ruby-metrics/version'
+require 'ruby-metrics'
+
+module Metrics
+  module Reporters
+    class Librato
+      attr_reader :api_token
+      attr_reader :user
+
+      API_URL = "https://metrics-api.librato.com/v1"
+
+      def initialize(options = {})
+        @api_token = options[:api_token]
+        @user = options[:user] 
+        @headers = {
+          'User-Agent' => "ruby-metrics #{Metrics::VERSION}"
+        }
+      end
+
+      def send_data(post_url, post_data)
+        url = URI.parse(post_url)
+        req = Net::HTTP::Post.new(url.path)
+        req.basic_auth @user, @api_token
+        @headers.each do |k,v|
+          req.add_field(k, v)
+        end
+        req.set_form_data(post_data)
+        https = Net::HTTP.new(url.host, url.port)
+        https.use_ssl = true
+        #https.set_debug_output($stdout)
+            
+        https.start do |http| 
+          result = http.request(req) 
+          case result
+          when Net::HTTPCreated
+            # OK
+            puts "SENT!"
+          else
+            puts "FAILED TO SEND: #{https.inspect}"
+          end
+        end
+      end
+
+      def report(agent)
+        agent.instruments.each do |name, instrument|
+          measure_time = Time.now.to_i
+
+          case instrument
+          when Metrics::Instruments::Counter
+            send_data "#{API_URL}/counters/#{name}.json",
+                      :measure_time => measure_time,
+                      :value        => instrument.to_i
+
+          when Metrics::Instruments::Gauge
+            post_url = "#{API_URL}/gauges/#{name}.json"
+            if instrument.get.is_a? Hash
+              instrument.get.each do |key, value|
+                send_data post_url,
+                          :measure_time => measure_time,
+                          :source       => key,
+                          :value        => value
+              end
+            else
+              send_data post_url,
+                        :measure_time => measure_time,
+                        :value        => instrument.get
+            end
+
+          when Metrics::Instruments::Timer
+            [:count, :fifteen_minute_rate, :five_minute_rate, :one_minute_rate, :min, :max, :mean].each do |attribute|
+              send_data "#{API_URL}/gauges/#{name}.json",
+                        :measure_time => measure_time,
+                        :source       => attribute,
+                        :value        => instrument.send(attribute)
+            end
+
+          else
+            puts "Unhandled instrument"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby-metrics/statistics/exponential_sample.rb

@@ -1,24 +1,23 @@
 module Metrics
   module Statistics
     class ExponentialSample
+      RESCALE_WINDOW_SECONDS = 60 * 60 # 1 hour
+
       def initialize(size = 1028, alpha = 0.015)
-        @values = Hash.new
-        @count  = 0
         @size   = size
         @alpha  = alpha
-        @rescale_window = 3600  #seconds -- 1 hour
-        self.clear
+        clear
       end
       
       def clear
-        @values           = Hash.new
+        @values           = { }
         @start_time       = tick
-        @next_scale_time  = Time.now.to_f + @rescale_window
+        @next_scale_time  = Time.now.to_f + RESCALE_WINDOW_SECONDS
         @count            = 0
       end
       
       def size
-        [@values.keys.length, @count].min
+        [@values.size, @count].min
       end
       
       def tick
@@ -32,59 +31,50 @@ module Metrics
       def update_with_timestamp(value, timestamp)
         priority = weight(timestamp.to_f - @start_time.to_f) / rand
         @count += 1
-        newcount = @count
-        if (newcount <= @size)
+        if @count <= @size
           @values[priority] = value
         else
-          firstkey = @values.keys[0]
-          if firstkey && (firstkey < priority)
+          first_key = @values.keys.first
+          if first_key && first_key < priority
             @values[priority] = value
             
-            while(@values.delete(firstkey) == nil)
-              firstkey = @values.keys[0]
+            while values.any? && @values.delete(first_key).nil?
+              first_key = @values.keys.first
             end
           end
         end
         
         now = Time.now.to_f
-        next_scale_time = @next_scale_time
-        
-        if (now >= next_scale_time)
-          self.rescale(now, next_scale_time)
+
+        if now >= @next_scale_time
+          rescale(now + RESCALE_WINDOW_SECONDS)
         end
       end
-      
-      
-      def rescale(now, next_scale_time)
-        if @next_scale_time == next_scale_time
-          # writelock
-          @next_scale_time = now + @rescale_window
-          old_start_time = @start_time
-          @start_time = tick
-          time_delta = @start_time - old_start_time
-          keys = @values.keys
-          keys.each do |key|
-            value = @values.delete(key)
-            new_key = (key * Math.exp(-@alpha * time_delta))
-            @values[new_key] = value
-          end
-          # unlock
-        end  
-      end
-      
-      def weight(factor)
-        return @alpha.to_f * factor.to_f
-      end
-      
+
       def values
         # read-lock?
-        result = Array.new
-        keys = @values.keys.sort
-        keys.each do |key|
-          result << @values[key]
+        @values.keys.sort.map do |key|
+          @values[key]
         end
-        
-        result
+      end
+
+    private
+      def rescale(next_scale_time)
+        # writelock
+        @next_scale_time = next_scale_time
+        old_start_time = @start_time
+        @start_time = tick
+        time_delta = @start_time - old_start_time
+        @values.keys.each do |key|
+          value = @values.delete(key)
+          new_key = key * Math.exp(-@alpha * time_delta)
+          @values[new_key] = value
+        end
+        # unlock
+      end
+      
+      def weight(factor)
+        @alpha.to_f * factor.to_f
       end
     end
   end

data/lib/ruby-metrics/statistics/uniform_sample.rb

@@ -3,22 +3,21 @@ module Metrics
     class UniformSample
       def initialize(size = 1028)
         @values = Array.new(size)
-        @count = 0
         @size = size
-        self.clear
+        clear
       end
-      
+
       def clear
-        (0..@values.length-1).each do |i|
+        (0...@values.size).each do |i|
           @values[i] = 0
         end
         @count = 0
       end
-      
+
       def size
-        @values.length
+        @values.size
       end
-      
+
       def update(value)
         if @count < @values.length
           @values[@count] = value
@@ -28,10 +27,10 @@ module Metrics
           @values[index] = value
         end
       end
-      
+
       def values
         @values.dup
       end
     end
   end
-end
+end

data/lib/ruby-metrics/time_units.rb

@@ -1,42 +1,36 @@
 module Metrics
-  
-  class TimeUnit 
-    def self.to_nsec(mult = 1)
-      raise NotImplementedError
-    end
-  end
-  
-  class Nanoseconds < TimeUnit
+
+  module Nanoseconds
     def self.to_nsec(mult = 1)
       mult
     end
   end
   
-  class Microseconds < TimeUnit
+  module Microseconds
     def self.to_nsec(mult = 1)
       1000 * mult
     end
   end
   
-  class Milliseconds < TimeUnit
+  module Milliseconds
     def self.to_nsec(mult = 1)
       1000000 * mult
     end
   end
   
-  class Seconds < TimeUnit
+  module Seconds
     def self.to_nsec(mult = 1)
       1000000000 * mult
     end
   end
   
-  class Minutes < TimeUnit
+  module Minutes
     def self.to_nsec(mult = 1)
       60000000000 * mult
     end
   end
   
-  class Hours < TimeUnit
+  module Hours
     def self.to_nsec(mult = 1)
       3600000000000 * mult
     end
@@ -53,11 +47,11 @@ module Metrics
     }
   
     def convert_to_ns(value, unit)
-      (UNITS[unit].to_nsec.to_f * value.to_f)
+      UNITS[unit].to_nsec.to_f * value.to_f
     end
 
     def scale_time_units(source, dest)
-      (UNITS[source].to_nsec.to_f) / (UNITS[dest].to_nsec.to_f)
+      UNITS[source].to_nsec.to_f / UNITS[dest].to_nsec.to_f
     end
   end
 end

data/lib/ruby-metrics/version.rb

@@ -1,3 +1,3 @@
 module Metrics
-  VERSION = '0.9.0'
+  VERSION = '0.9.4'
 end

data/ruby-metrics-opentsdb.gemspec

@@ -16,6 +16,6 @@ Gem::Specification.new do |s|
   s.files         = ['lib/ruby-metrics/reporters/opentsdb.rb']
   s.require_paths = ["lib"]
 
-  s.add_dependency "opentsdb", '0.1.0'
+  s.add_dependency "opentsdb", '~> 0.1', '>= 0.1.0'
   s.add_dependency 'ruby-metrics', Metrics::VERSION
 end

data/ruby-metrics.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
   s.description = %q{A Ruby implementation of metrics inspired by @coda's JVM metrics for those of us in Ruby land}
   s.license     = 'MIT'
 
-  s.add_dependency 'json', '~> 1.5', '>= 1.5.5'
+  s.add_dependency 'json', '~> 2.3', '>= 2.3.0'
 
   s.add_development_dependency 'rspec', '~> 2.14', '>= 2.14.0'
   s.add_development_dependency 'simplecov', '~> 0.3', '>= 0.3.8'

data/spec/instruments/counter_spec.rb

@@ -1,78 +1,88 @@
 require 'spec_helper'
 
 describe Metrics::Instruments::Counter do
-  before(:each) do
-    @counter = Metrics::Instruments::Counter.new
+  let(:counter) {
+    Metrics::Instruments::Counter.new
+  }
+
+  it 'can be tagged' do
+    counter.tag(:foo, 'bar')
+    expect(counter.tags.keys).to include(:foo)
+    expect(counter.tags.values).to include('bar')
+  end
+
+  it 'does not need to be tagged' do
+    expect(counter.tags.keys.size).to be 0
   end
   
-  it "should create a new entity with zero as its value" do
-    @counter.to_i.should == 0
+  it 'should create a new entity with zero as its value' do
+    counter.to_i.should == 0
   end
   
   it "should increment its counter by the value specified" do
     value = 1
     lambda do
-      @counter.inc(value)
-    end.should change{ @counter.to_i }.by(value)
+      counter.inc(value)
+    end.should change{ counter.to_i }.by(value)
   end
   
   it "should increment its counter by one by default" do
     lambda do
-      @counter.inc
-    end.should change{ @counter.to_i }.by(1)
+      counter.inc
+    end.should change{ counter.to_i }.by(1)
   end
   
   it "should decrement its counter by the value specified" do
     value = 1
     lambda do
-      @counter.dec(value)
-    end.should change{ @counter.to_i }.by(-value)
+      counter.dec(value)
+    end.should change{ counter.to_i }.by(-value)
   end
   
   it "should decrement its counter by one by default" do
     lambda do
-      @counter.dec
-    end.should change{ @counter.to_i }.by(-1)
+      counter.dec
+    end.should change{ counter.to_i }.by(-1)
   end
   
   it "should alias #incr to #inc" do
     lambda do
-      @counter.incr
-    end.should change{ @counter.to_i }.by(1)
+      counter.incr
+    end.should change{ counter.to_i }.by(1)
   end
   
   it "should alias #decr to #dec" do
     lambda do
-      @counter.decr
-    end.should change{ @counter.to_i }.by(-1)
+      counter.decr
+    end.should change{ counter.to_i }.by(-1)
   end
   
   it "should clear the counter correctly" do 
-    @counter.clear
-    @counter.to_i.should == 0
+    counter.clear
+    counter.to_i.should == 0
   end
   
   it "should correctly represent the value as a string" do 
-    @counter.clear
-    @counter.to_i.should == 0
-    @counter.to_s.should == "0"
+    counter.clear
+    counter.to_i.should == 0
+    counter.to_s.should == "0"
   end
   
   it "should return the new count when incrementing" do
-    count = @counter.to_i
-    @counter.inc(value = 1).should == count + value
+    count = counter.to_i
+    counter.inc(value = 1).should == count + value
   end
   
   it "should return the new count when decrementing" do
     lambda do
-      @counter.dec(1)
-    end.should change{ @counter.to_i }.by(-1)
+      counter.dec(1)
+    end.should change{ counter.to_i }.by(-1)
   end
   
   context "to_json" do
-    let(:json) { @counter.to_json }
+    let(:json) { counter.to_json }
     it "should serialize to its current value" do
-      json.should == @counter.to_s
+      json.should == counter.to_s
     end
   end
   

data/spec/instruments/histogram_spec.rb

@@ -71,7 +71,7 @@ describe Metrics::Instruments::Histogram do
 
       it "should clear data correctly" do
         sample = Metrics::Statistics::UniformSample.new    
-        sample.should_receive(:clear)
+        sample.should_receive(:clear).twice
         Metrics::Statistics::UniformSample.should_receive(:new).and_return sample
 
         histogram = Metrics::Instruments::Histogram.new

data/spec/instruments/timer_spec.rb

@@ -29,7 +29,7 @@ describe Metrics::Instruments::Timer do
     end
     
     it "should have quantiles of zero" do
-      @timer.quantiles.should == {0.99=>0.0, 0.97=>0.0, 0.95=>0.0, 0.75=>0.0, 0.5=>0.0, 0.25=>0.0}
+      @timer.quantiles.should == {0.25=>0.0, 0.50=>0.0, 0.75=>0.0, 0.95=>0.0, 0.97=>0.0, 0.98=>0.0, 0.99=>0.0 }
     end
     
     it "should have a mean rate of zero" do
@@ -85,7 +85,7 @@ describe Metrics::Instruments::Timer do
     end
     
     it "should accurately calculate percentiles" do 
-      @timer.quantiles.should == {0.99=>39.6, 0.97=>38.8, 0.95=>38.0, 0.75=>30.0, 0.5=>20.0, 0.25=>20.0}
+      @timer.quantiles.should == {0.25=>20.0, 0.5=>20.0, 0.75=>30.0, 0.95=>38.0, 0.97=>38.8, 0.98=>39.2, 0.99=>39.6}
     end
     
     it "should contain the series added" do

data/spec/integration/rack_middleware_spec.rb

@@ -54,7 +54,7 @@ describe Metrics::Integration::Rack::Middleware do
       it "should count all requests" do
         lambda do
           get '/'
-        end.should change{ app.requests.count }.by(1)
+        end.should change{ app.agent.timer(:_requests).count }.by(1)
       end
       
       it "should count uncaught exceptions" do
@@ -63,22 +63,22 @@ describe Metrics::Integration::Rack::Middleware do
           lambda do
             get '/'
           end.should raise_error
-        end.should change{ app.uncaught_exceptions.to_i }.by(1)
+        end.should change{ app.agent.counter(:_uncaught_exceptions).to_i }.by(1)
       end
       
       it "should time request length" do
         length = 0.1
         @app = lambda{ |env| sleep(length); [200, {}, ['']] }
         get '/'
-        app.requests.mean.should be_within(length / 10).of(length)
+        app.agent.timer(:_requests).mean.should be_within(length / 10).of(length)
       end
-      
-      [ 200, 304, 404, 500].each do |status|
+
+      [200, 304, 404, 500].each do |status|
         it "should count #{status} HTTP status code as #{status / 100}xx" do
           @app = lambda{ |env| [status, {}, []] }
           lambda do
             get '/'
-          end.should change{ app.status_codes[status / 100].to_i }.by(1)
+          end.should change{ app.agent.counter(:"_status_#{status / 100}xx").to_i }.by(1)
         end
       end
       

data/spec/reporter_spec.rb

@@ -0,0 +1,27 @@
+require 'ruby-metrics/agent'
+require 'ruby-metrics/reporter'
+require 'ruby-metrics/reporters/opentsdb'
+
+module Metrics
+  describe 'Reporter' do
+    let(:mock_reporter) {
+      double(Metrics::Reporters::OpenTSDBReporter)
+    }
+
+    let(:agent) {
+      agent = Metrics::Agent.new
+      agent.report_to 'opentsdb', mock_reporter
+      agent
+    }
+
+    it 'should report three times in 4 seconds with a 1 second interval' do
+      expect(mock_reporter).to receive(:report).exactly(3).times
+      agent.report_periodically(1)
+      puts "Sleeping"
+      sleep(4)
+      puts "Stopping..."
+      agent.stop_reporting
+    end
+
+  end
+end