ruby-metrics 0.9.0 → 0.9.1

data/Rakefile

@@ -15,13 +15,13 @@ task :build do
   FileUtils.mv(Dir['*.gem'], 'pkg')
 end
 
-desc 'Tags version, pushes to remote, and pushes gem'
+desc "Tags version as #{Metrics::VERSION}, pushes to remote, and pushes gem"
 task :release => :build do
   puts "Releasing v#{Metrics::VERSION}"
   sh 'git', 'tag', '-m', "Version #{Metrics::VERSION}",  "v#{Metrics::VERSION}"
   sh "git push origin master"
   sh "git push origin v#{Metrics::VERSION}"
-  #sh "ls pkg/*.gem | xargs -n 1 gem push"
+  sh "ls pkg/*.gem | xargs -n 1 gem push"
 end
 
 RSpec::Core::RakeTask.new do |t|

data/lib/ruby-metrics/agent.rb

@@ -67,6 +67,10 @@ module Metrics
       @reporter = Reporter.new({:agent => self, :delay => delay})
     end
 
+    def stop_reporting
+      @reporter.stop
+    end
+
     def as_json(*_)
       @instruments
     end

data/lib/ruby-metrics/instruments/counter.rb

@@ -1,11 +1,14 @@
+require_relative 'instrument'
+
 module Metrics
   module Instruments
-    class Counter
+    class Counter < Instrument
 
       attr_reader :units
 
       def initialize(options = {})
         @value = 0
+        @units = options[:units]
       end
 
       def inc(value = 1)

data/lib/ruby-metrics/instruments/gauge.rb

@@ -1,6 +1,8 @@
+require_relative 'instrument'
+
 module Metrics
   module Instruments
-    class Gauge
+    class Gauge < Instrument
       attr_reader :units
 
       def initialize(options = {}, &block)

data/lib/ruby-metrics/instruments/histogram.rb

@@ -1,9 +1,10 @@
+require_relative 'instrument'
 require 'ruby-metrics/statistics/uniform_sample'
 require 'ruby-metrics/statistics/exponential_sample'
 
 module Metrics
   module Instruments
-    class Histogram
+    class Histogram < Instrument
 
       def initialize(type = :uniform)
         @count = 0

data/lib/ruby-metrics/instruments/instrument.rb

@@ -0,0 +1,14 @@
+module Metrics
+  module Instruments
+    class Instrument
+      def tags
+        @tags ||= {}
+      end
+
+      def tag(key, value)
+        @tags ||= {}
+        @tags[key] = value
+      end
+    end
+  end
+end

data/lib/ruby-metrics/instruments/meter.rb

@@ -1,8 +1,9 @@
+require_relative 'instrument'
 require 'ruby-metrics/time_units'
 
 module Metrics
   module Instruments
-    class Meter
+    class Meter < Instrument
       include Metrics::TimeConversion
 
       # From http://www.teamquest.com/pdfs/whitepaper/ldavg2.pdf
@@ -21,7 +22,7 @@ module Metrics
         @count  = 0
         @initialized = false
         @start_time = Time.now.to_f
-        @units = "#{options[:units]}"
+        @units = options[:units]
 
         @timer_thread = Thread.new do
           begin

data/lib/ruby-metrics/instruments/timer.rb

@@ -1,8 +1,9 @@
-require File.join(File.dirname(__FILE__), '..', 'time_units')
+require_relative 'instrument'
+require 'ruby-metrics/time_units'
 
 module Metrics
   module Instruments
-    class Timer
+    class Timer < Instrument
       include Metrics::TimeConversion
 
       attr_reader :duration_unit, :rate_unit, :units

data/lib/ruby-metrics/reporter.rb

@@ -5,7 +5,12 @@ module Metrics
 
     include Logging
 
+    def stop
+      @running = false
+    end
+
     def initialize(options = {})
+      @running = true
 
       if options[:agent] == nil
         raise "Need an agent to report data from"
@@ -15,13 +20,13 @@ module Metrics
       agent = options[:agent] 
 
       Thread.new {
-        while(true)
+        while(@running)
           agent.reporters.each do |name, service|
             service.report(agent)
           end
           sleep delay
         end
-      }.join
+      }
     end
 
   end

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

@@ -0,0 +1,79 @@
+require 'ruby-metrics/version'
+require 'ruby-metrics'
+
+require 'gmetric'
+
+module Metrics
+  module Reporters
+    class GangliaReporter
+
+      attr_reader :host_ip
+      attr_reader :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].class.to_s
+                    when "Fixnum"
+                      "uint32"
+                    when "Float"
+                      "float"
+                    when "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|
+          nothing_to_do = false
+          data =  { :name => name, :units => instrument.units }
+          case instrument
+            when Metrics::Instruments::Counter
+              value = instrument.to_i
+              data.merge! :value => value.to_i
+              send_data data
+            when Metrics::Instruments::Gauge
+              if instrument.get.is_a? Hash
+                instrument.get.each do |key, value|
+                  data.merge! :name => "#{name}_#{key}", :value => value
+                  send_data data
+                end
+              else 
+                data.merge! :value => instrument.get
+                send_data data
+              end
+            when Metrics::Instruments::Timer
+              [:count, :fifteen_minute_rate, :five_minute_rate, :one_minute_rate, :min, :max, :mean].each do |attribute|
+                data.merge!(:name => "#{name}_#{attribute}", :value => instrument.send(attribute))
+                send_data data
+              end
+            when Metrics::Instruments::Meter
+              [:count, :fifteen_minute_rate, :five_minute_rate, :one_minute_rate, :mean_rate].each do |attribute|
+                data.merge!(:name => "#{name_attribute}", :value => instrument.send(attribute) )
+              end
+            else 
+              puts "Unhandled instrument"
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,83 @@
+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|
+          nothing_to_do = false
+          measure_time = Time.now.to_i
+
+          case instrument.class.to_s
+            when "Metrics::Instruments::Counter"
+              value = instrument.to_i
+              post_url = "#{API_URL}/counters/#{name}.json" 
+              post_data = {:measure_time => measure_time, :value => value.to_i}
+              send_data(post_url, post_data)
+            when "Metrics::Instruments::Gauge"
+              post_url = "#{API_URL}/gauges/#{name}.json"
+              if instrument.get.is_a? Hash
+                instrument.get.each do |key, value|
+                  post_data = {:measure_time => measure_time, :source => key, :value => value}
+                  send_data(post_url, post_data)
+                end
+              else 
+                post_data = {:measure_time => measure_time, :value => instrument.get}
+                send_data(post_url, post_data)
+              end
+            when "Metrics::Instruments::Timer"
+              post_url = "#{API_URL}/gauges/#{name}.json"
+              common_data = {:measure_time => measure_time}
+
+              [:count, :fifteen_minute_rate, :five_minute_rate, :one_minute_rate, :min, :max, :mean].each do |attribute|
+                post_data = {:source => attribute, :value => instrument.send(attribute)}.merge(common_data)
+                send_data(post_url, post_data)
+              end
+            else 
+              puts "Unhandled instrument"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby-metrics/version.rb

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

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/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

data/spec/reporters/opentsdb_spec.rb

@@ -0,0 +1,299 @@
+require 'spec_helper'
+require 'opentsdb/client'
+require 'ruby-metrics/reporters/opentsdb'
+require 'ruby-metrics'
+require 'timecop'
+
+module Metrics
+  module Reporters
+    describe 'OpenTSDBReporter' do
+
+      let(:mock_tsdb_client) {
+        mock_tsdb_client = double(OpenTSDB::Client)
+      }
+
+      let(:reporter) {
+        expect(OpenTSDB::Client).to receive(:new).and_return mock_tsdb_client
+        OpenTSDBReporter.new(:tags => {:foo => 'bar'})
+      }
+
+      let(:agent) {
+        Metrics::Agent.new
+      }
+
+      it 'should report a counter correctly' do
+        counter = agent.counter :my_counter
+        counter.incr
+        counter.incr
+
+        counter_data = {
+            :value => 2,
+            :timestamp => anything,
+            :tags => {
+                :units => '',
+                :foo => 'bar'
+            },
+            :metric => 'my_counter'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(counter_data)
+
+        reporter.report(agent)
+      end
+
+      it 'should report a tagged counter correctly' do
+        counter = agent.counter :logins, 'logins'
+        counter.incr
+        counter.tag(:user, 'sam')
+
+        counter_data = {
+            :value => 1,
+            :timestamp => anything,
+            :tags => {
+                :units => 'logins',
+                :foo => 'bar',
+                :user => 'sam'
+            },
+            :metric => 'logins'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(counter_data)
+
+        reporter.report(agent)
+      end
+
+      it 'should report a gauge that returns a hash' do
+        gauge = agent.gauge :my_gauge do
+          {
+              :hit_count => 42,
+              :http_requests => 320
+          }
+        end
+        gauge.tag(:mytag, 'somevalue')
+
+
+        tags = {
+            :units => '',
+            :foo => 'bar',
+            :mytag => 'somevalue'
+        }
+
+        gauge_hit_data = {
+            :value => 42,
+            :timestamp => anything,
+            :tags => tags,
+            :metric => 'my_gauge.hit_count'
+        }
+        gauge_requests_data = {
+            :value => 320,
+            :timestamp => anything,
+            :tags => tags,
+            :metric => 'my_gauge.http_requests'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(gauge_hit_data)
+        expect(mock_tsdb_client).to receive(:put).with(gauge_requests_data)
+
+        reporter.report(agent)
+      end
+
+
+      it 'should report a gauge that returns a non-hash value' do
+        agent.gauge :boring_gauge, 'units' do
+          42
+        end
+
+        gauge_data = {
+            :value => 42,
+            :timestamp => anything,
+            :tags => {
+                :units => 'units',
+                :foo => 'bar',
+            },
+            :metric => 'boring_gauge'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(gauge_data)
+
+        reporter.report(agent)
+      end
+
+      it 'should report a timer' do
+        timer = agent.timer :some_timer, 'requests'
+        timer.update(5, :seconds)
+
+        timer_counter_data = {
+            :value => 1,
+            :timestamp => anything,
+            :tags => {
+                :units => 'requests',
+                :foo => 'bar'
+            },
+            :metric => 'some_timer.count'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(timer_counter_data)
+
+        timer_fifteen = {
+            :value => 0.0,
+            :timestamp => anything,
+            :tags => {
+                :units => 'requests/sec',
+                :foo => 'bar'
+            },
+            :metric => 'some_timer.fifteen_minute_rate'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(timer_fifteen)
+
+        timer_five = {
+            :value => 0.0,
+            :timestamp => anything,
+            :tags => {
+                :units => 'requests/sec',
+                :foo => 'bar'
+            },
+            :metric => 'some_timer.five_minute_rate'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(timer_five)
+
+
+        timer_one = {
+            :value => 0.0,
+            :timestamp => anything,
+            :tags => {
+                :units => 'requests/sec',
+                :foo => 'bar'
+            },
+            :metric => 'some_timer.one_minute_rate'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(timer_one)
+
+
+        timer_min = {
+            :value => 5.0,
+            :timestamp => anything,
+            :tags => {
+                :units => 'sec/requests',
+                :foo => 'bar'
+            },
+            :metric => 'some_timer.min'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(timer_min)
+
+
+        timer_max = {
+            :value => 5.0,
+            :timestamp => anything,
+            :tags => {
+                :units => 'sec/requests',
+                :foo => 'bar'
+            },
+            :metric => 'some_timer.max'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(timer_max)
+
+        timer_mean = {
+            :value => 5.0,
+            :timestamp => anything,
+            :tags => {
+                :units => 'sec/requests',
+                :foo => 'bar'
+            },
+            :metric => 'some_timer.mean'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(timer_mean)
+
+        reporter.report(agent)
+      end
+
+      it 'should report a gauge that returns a non-hash value' do
+        agent.gauge :boring_gauge, 'units' do
+          42
+        end
+
+        gauge_data = {
+            :value => 42,
+            :timestamp => anything,
+            :tags => {
+                :units => 'units',
+                :foo => 'bar',
+            },
+            :metric => 'boring_gauge'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(gauge_data)
+
+        reporter.report(agent)
+      end
+
+      it 'should report a meter' do
+        expect(Thread).to receive(:new).and_return nil
+
+        meter = agent.meter :http_requests, 'requests'
+        meter.mark
+        meter.mark
+        meter.mark
+        meter.tick
+        meter.mark
+        meter.tag :somekey, 'value'
+
+        meter_counter_data = {
+            :value => 1,
+            :timestamp => anything,
+            :tags => {
+                :units => 'requests',
+                :foo => 'bar',
+                :somekey => 'value'
+            },
+            :metric => 'http_requests.count'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(meter_counter_data)
+
+        meter_fifteen = {
+            :value => 0.6,
+            :timestamp => anything,
+            :tags => {
+                :units => 'requests/sec',
+                :foo => 'bar',
+                :somekey => 'value'
+            },
+            :metric => 'http_requests.fifteen_minute_rate'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(meter_fifteen)
+
+        meter_five = {
+            :value => 0.6,
+            :timestamp => anything,
+            :tags => {
+                :units => 'requests/sec',
+                :foo => 'bar',
+                :somekey => 'value'
+            },
+            :metric => 'http_requests.five_minute_rate'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(meter_five)
+
+
+        meter_one = {
+            :value => 0.6,
+            :timestamp => anything,
+            :tags => {
+                :units => 'requests/sec',
+                :foo => 'bar',
+                :somekey => 'value'
+            },
+            :metric => 'http_requests.one_minute_rate'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(meter_one)
+
+        meter_mean = {
+            :value => anything,
+            :timestamp => anything,
+            :tags => {
+                :units => 'requests/sec',
+                :foo => 'bar',
+                :somekey => 'value'
+            },
+            :metric => 'http_requests.mean_rate'
+        }
+        expect(mock_tsdb_client).to receive(:put).with(meter_mean)
+
+        reporter.report(agent)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-metrics
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-08 00:00:00.000000000 Z
+date: 2014-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -132,6 +132,7 @@ files:
 - lib/ruby-metrics/instruments/counter.rb
 - lib/ruby-metrics/instruments/gauge.rb
 - lib/ruby-metrics/instruments/histogram.rb
+- lib/ruby-metrics/instruments/instrument.rb
 - lib/ruby-metrics/instruments/meter.rb
 - lib/ruby-metrics/instruments/timer.rb
 - lib/ruby-metrics/integration.rb
@@ -140,12 +141,12 @@ files:
 - lib/ruby-metrics/integration/webrick.rb
 - lib/ruby-metrics/logging.rb
 - lib/ruby-metrics/reporter.rb
+- lib/ruby-metrics/reporters/ganglia.rb
+- lib/ruby-metrics/reporters/librato.rb
 - lib/ruby-metrics/statistics/exponential_sample.rb
 - lib/ruby-metrics/statistics/uniform_sample.rb
 - lib/ruby-metrics/time_units.rb
 - lib/ruby-metrics/version.rb
-- ruby-metrics-ganglia.gemspec
-- ruby-metrics-librato.gemspec
 - ruby-metrics-opentsdb.gemspec
 - ruby-metrics.gemspec
 - spec/agent_spec.rb
@@ -156,6 +157,8 @@ files:
 - spec/instruments/timer_spec.rb
 - spec/integration/rack_endpoint_spec.rb
 - spec/integration/rack_middleware_spec.rb
+- spec/reporter_spec.rb
+- spec/reporters/opentsdb_spec.rb
 - spec/spec_helper.rb
 - spec/statistics/exponential_sample_spec.rb
 - spec/statistics/uniform_sample_spec.rb

data/ruby-metrics-ganglia.gemspec

@@ -1,21 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path('../lib', __FILE__)
-require 'ruby-metrics/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'ruby-metrics-ganglia'
-  s.version     = Metrics::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ['John Ewart']
-  s.email       = ['john@johnewart.net']
-  s.homepage    = 'https://github.com/johnewart/ruby-metrics'
-  s.summary     = %q{Ganglia reporter for ruby-metrics}
-  s.description = %q{A reporter that uses Ganglia's to stash metric data}
-  s.license     = 'MIT'
-
-  s.files         = ['lib/ruby-metrics/reporters/ganglia.rb']
-  s.require_paths = ['lib']
-
-  s.add_dependency 'gmetric', '0.1.3'
-  s.add_dependency 'ruby-metrics', Metrics::VERSION
-end

data/ruby-metrics-librato.gemspec

@@ -1,20 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path('../lib', __FILE__)
-require 'ruby-metrics/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'ruby-metrics-librato'
-  s.version     = Metrics::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ['John Ewart']
-  s.email       = ['john@johnewart.net']
-  s.homepage    = 'https://github.com/johnewart/ruby-metrics'
-  s.summary     = %q{Librato reporter for ruby-metrics}
-  s.description = %q{A reporter that uses Librato to stash metric data}
-  s.license     = 'MIT'
-
-  s.files         = ['lib/ruby-metrics/reporters/librato.rb']
-  s.require_paths = ['lib']
-
-  s.add_dependency 'ruby-metrics', Metrics::VERSION
-end