librato-metrics 0.1.0

data/.gitignore

@@ -0,0 +1,19 @@
+.rvmrc
+.bundle
+.DS_Store
+Gemfile.lock
+*.gem
+
+# docs
+rdoc
+doc
+.yardoc
+
+# textmate
+*.tmproj
+
+# vim
+*.swp
+
+# rcov generated
+coverage

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,11 @@
+Librato Software Confidential and Proprietary
+
+Copyright (C) 2011, Librato Inc.  ALL RIGHTS RESERVED.
+
+Except as specifically permitted herein, no portion of the
+information, including but not limited to object code and source
+code, may be reproduced, modified, distributed, republished or
+otherwise utilized in any form or by any means for any purpose
+without the prior written permission of Librato Inc.
+
+Visit http://librato.com for more information.

data/README.md

@@ -0,0 +1,114 @@
+Librato Metrics
+=======
+
+A convenient Ruby wrapper for the Librato Metrics API.
+
+## Installation
+
+In your shell:
+
+    gem install librato-metrics
+
+Then, in your application or script:
+
+    require 'librato/metrics'
+
+## Quick Start
+
+If you are looking for the quickest possible route to getting a data into Metrics, you only need two lines:
+
+    Librato::Metrics.authenticate 'email', 'api_key'
+    Librato::Metrics.submit :my_metric => 42, :my_other_metric => 1002
+
+Unspecified metrics will send a *gauge*, but if you need to send a different metric type or include additional properties, simply use a hash:
+
+    Librato::Metrics.submit :my_metric => {:type => :counter, :value => 1002, :source => 'myapp'}
+
+While this is all you need to get started, if you are sending a number of metrics regularly a queue may be easier/more performant so read on...
+
+## Authentication
+
+Make sure you have [an account for Metrics](https://metrics.librato.com/) and then authenticate with your email and API key (on your account page):
+
+    Librato::Metrics.authenticate 'email', 'api_key'
+
+## Sending Metrics
+
+If you are sending very many metrics or sending them very often, it will be much higher performance to bundle them up together to reduce your request volume. Use `Queue` for this.
+
+Queue up a simple gauge metric named `temperature`:
+
+    queue = Librato::Metrics::Queue.new
+    queue.add :temperature => 32.2
+
+If you are tracking measurements over several seconds/minutes, the queue will handle storing measurement time for you (otherwise all metrics will be recorded as measured when they are submitted).
+
+You can queue multiple metrics at once. Here's a gauge (`load`) and a counter (`visits`):
+
+    queue.add :load => 2.2, :visits => {:type => :counter, :value => 400}
+
+Queue up a metric with a specified source:
+
+    queue.add :cpu => {:source => 'app1', :value => 92.6}
+
+A complete [list of metric attributes](http://dev.librato.com/v1/metrics) is available in the [API documentation](http://dev.librato.com/v1).
+
+Save all queued metrics:
+
+    queue.submit
+
+## Benchmarking
+
+If you have operations in your application you want to record execution time for, you can use the `#time` method:
+
+    queue.time :my_measurement do
+      # do work...
+    end
+
+If you need extra attributes for the measurement, simply add them on:
+
+    queue.time :my_measurement, :source => 'app1' do
+      # do work...
+    end
+
+## Querying Metrics
+
+Get name and properties for all metrics you have in the system:
+
+    metrics = Librato::Metrics.list
+
+Get only metrics whose name includes `time`:
+
+    metrics = Librato::Metrics.list :name => 'time'
+
+## Querying Metric Data
+
+Get attributes for metric `temperature`:
+
+    data = Librato::Metrics.fetch :temperature
+
+Get the 20 most recent data points for `temperature`:
+
+    data = Librato::Metrics.fetch :temperature, :count => 20
+
+Get the 20 most recent data points for `temperature` from a specific source:
+
+    data = Librato::Metrics.fetch :temperature, :count => 20, :source => 'app1'
+
+Get the 20 most recent 15 minute data point rollups for `temperature`:
+
+    data = Librato::Metrics.fetch :temperature, :count => 20, :resolution => 900
+
+There are many more options supported for querying, take a look at the [REST API docs](http://dev.librato.com/v1/get/gauges/:name) for more details.
+
+## Contribution
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project and submit a pull request from a feature or bugfix branch.
+* Please include specs. This is important so we don't break your changes unintentionally in a future version.
+* Please don't modify the Rakefile, version, or history. If you do change these files, please isolate a separate commit so we can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2011-2012 [Librato Inc.](http://librato.com) See LICENSE for details.

data/Rakefile

@@ -0,0 +1,24 @@
+require 'bundler'
+
+# Packaging
+Bundler::GemHelper.install_tasks
+
+# Testing
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--color'
+end
+
+task :default => :spec
+task :test => :spec
+
+# Docs
+require 'yard'
+YARD::Rake::YardocTask.new
+
+# IRB
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/librato/metrics.rb"
+end
+

data/lib/librato/metrics.rb

@@ -0,0 +1,89 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'base64'
+require 'excon'
+require 'json'
+
+require 'metrics/errors'
+require 'metrics/persistence'
+require 'metrics/queue'
+require 'metrics/simple'
+require 'metrics/version'
+
+module Librato
+
+  # Metrics provides a simple wrapper for the Metrics web API. Some
+  # of the methods Metrics provides will be documented below. Others
+  # are delegated to {Librato::Metrics::Simple} and will be
+  # documented there.
+  module Metrics
+    extend SingleForwardable
+
+    TYPES = [:counter, :gauge]
+
+    # Expose class methods of Simple via Metrics itself.
+    #
+    # TODO: Explain exposed interface with examples.
+    def_delegators Librato::Metrics::Simple, :api_endpoint, :api_endpoint=,
+                  :authenticate, :connection, :persistence, :persistence=,
+                  :persister, :submit
+
+    # Query metric data
+    #
+    # @example Get attributes for a metric
+    #   attrs = Librato::Metrics.fetch :temperature
+    #
+    # @example Get 20 most recent data points for metric
+    #   data = Librato::Metrics.fetch :temperature, :count => 20
+    #
+    # @example Get 20 most recent data points for a specific source
+    #   data = Librato::Metrics.fetch :temperature, :count => 20,
+    #                                  :source => 'app1'
+    #
+    # @example Get the 20 most recent 15 minute data point rollups
+    #   data = Librato::Metrics.fetch :temperature, :count => 20,
+    #                                 :resolution => 900
+    #
+    # A full list of query parameters can be found in the API
+    # documentation: {http://dev.librato.com/v1/get/gauges/:name}
+    #
+    # @param [Symbol|String] metric Metric name
+    # @param [Hash] options Query options
+    def self.fetch(metric, options={})
+      resolution = options.delete(:resolution) || 1
+      count = options.delete(:count)
+      query = {}
+      if count
+        query.merge!({:count => count, :resolution => resolution})
+      end
+      query.merge!(options)
+      # TODO: look up type when not specified.
+      type = options.delete(:type) || 'gauge'
+      response = connection.get(:path => "v1/#{type}s/#{metric}.json",
+                                :query => query, :expects => 200)
+      parsed = JSON.parse(response.body)
+      # TODO: pagination support
+      query.empty? ? parsed : parsed["measurements"]
+    end
+
+    # List currently existing metrics
+    #
+    # @example List all metrics
+    #   Librato::Metrics.list
+    #
+    # @example List metrics with 'foo' in the name
+    #   Librato::Metrics.list :name => 'foo'
+    #
+    # @param [Hash] options
+    def self.list(options={})
+      query = {}
+      query[:name] = options[:name] if options[:name]
+      response = connection.get(:path => 'v1/metrics.json',
+                                :query => query, :expects => 200)
+      # TODO: pagination support
+      JSON.parse(response.body)["metrics"]
+    end
+
+  end
+end

data/lib/librato/metrics/errors.rb

@@ -0,0 +1,11 @@
+
+module Librato
+  module Metrics
+
+    class MetricsError < StandardError; end
+
+    class CredentialsMissing < MetricsError; end
+    class NoMetricsQueued < MetricsError; end
+
+  end
+end

data/lib/librato/metrics/persistence.rb

@@ -0,0 +1,3 @@
+
+require 'metrics/persistence/direct'
+require 'metrics/persistence/test'

data/lib/librato/metrics/persistence/direct.rb

@@ -0,0 +1,22 @@
+
+# Manages direct persistence with the Librato Metrics web API
+
+module Librato
+  module Metrics
+    module Persistence
+      class Direct
+
+        # Persist the queued metrics directly to the
+        # Metrics web API.
+        #
+        def persist(queued)
+          payload = queued.to_json
+          Simple.connection.post(:path => '/v1/metrics.json',
+              :headers => {'Content-Type' => 'application/json'},
+              :body => payload, :expects => 200)
+        end
+
+      end
+    end
+  end
+end

data/lib/librato/metrics/persistence/test.rb

@@ -0,0 +1,27 @@
+# Use for testing the interface with persistence methods
+
+module Librato
+  module Metrics
+    module Persistence
+      class Test
+
+        # persist the given metrics
+        def persist(metrics)
+          @persisted = metrics
+          return !@return_value.nil? ? @return_value : true
+        end
+
+        # return what was persisted
+        def persisted
+          @persisted
+        end
+
+        # force a return value from persistence
+        def return_value(value)
+          @return_value = value
+        end
+
+      end
+    end
+  end
+end

data/lib/librato/metrics/queue.rb

@@ -0,0 +1,110 @@
+module Librato
+  module Metrics
+    class Queue
+
+      def initialize
+        @queued ||= {}
+      end
+
+      # Add a metric entry to the metric set:
+      #
+      # @param Hash metrics metrics to add
+      # @return Hash queued_metrics the currently queued metrics
+      def add(args)
+        args.each do |key, value|
+          if value.respond_to?(:each)
+            type = (value.delete(:type) || 'gauge')
+            type = ("#{type}s").to_sym
+            value[:name] = key.to_s
+            @queued[type] ||= []
+            @queued[type] << value
+          else
+            @queued[:gauges] ||= []
+            @queued[:gauges] << {:name => key.to_s, :value => value}
+          end
+        end
+        queued
+      end
+
+      # Currently queued counters
+      #
+      # @return Array
+      def counters
+        @queued[:counters] || []
+      end
+
+      # Remove all queued metrics
+      #
+      def flush
+        @queued = {}
+      end
+      alias :flush_queued :flush
+
+      # The object this MetricSet will use to persist
+      #
+      def persister
+        @persister ||= create_persister
+      end
+
+      # Currently queued gauges
+      #
+      # @return Array
+      def gauges
+        @queued[:gauges] || []
+      end
+
+      # All currently queued metrics
+      #
+      # @return Hash
+      def queued
+        @queued
+      end
+
+      # Persist currently queued metrics
+      #
+      # @return Boolean
+      def submit
+        raise NoMetricsQueued if self.queued.empty?
+        if persister.persist(self.queued)
+          flush and return true
+        end
+        false
+      end
+
+      # Capture execution time for a block and queue
+      # it as the value for a metric. Times are recorded
+      # in milliseconds.
+      #
+      # Options are the same as for {#add}.
+      #
+      # @example Queue API request response time
+      #   queue.time :api_request_time do
+      #     # API request..
+      #   end
+      #
+      # @example Queue API request response time w/ source
+      #   queue.time :api_request_time, :source => 'app1' do
+      #     # API request..
+      #   end
+      #
+      # @param [Symbol|String] name Metric name
+      # @param [Hash] options Metric options
+      def time(name, options={})
+        start = Time.now
+        yield
+        duration = (Time.now - start) * 1000.0 # milliseconds
+        metric = {name => options.merge({:value => duration})}
+        add metric
+      end
+      alias :benchmark :time
+
+    private
+
+      def create_persister
+        type = Simple.persistence.capitalize
+        Librato::Metrics::Persistence.const_get(type).new
+      end
+
+    end
+  end
+end

data/lib/librato/metrics/simple.rb

@@ -0,0 +1,100 @@
+module Librato
+  module Metrics
+
+    # Class-level methods for quick one-off submission of metrics.
+    #
+    # @example Send a quick metric
+    #   Librato::Metrics::Simple.authenticate 'fred@foo.com', 'myapikey'
+    #   Librato::Metrics::Simple.save :total_vists => {:type => counter, :value => 2311}
+    #
+    # For more than quick one-off use, take a look at {Queue}. For
+    # convenience, most of Simple's methods can be accessed directly from
+    # the {Metrics} module.
+    #
+    class Simple
+
+      class << self
+        # class instance vars
+        attr_accessor :email, :api_key
+
+        # API endpoint to use for queries and direct
+        # persistence.
+        #
+        # @return [String] api_endpoint
+        def api_endpoint
+          @api_endpoint ||= 'https://metrics-api.librato.com/v1/'
+        end
+
+        # Set API endpoint for use with queries and direct
+        # persistence. Generally you should not need to set this
+        # as it will default to the current Librato Metrics
+        # endpoint.
+        #
+        def api_endpoint=(endpoint)
+          @api_endpoint = endpoint
+        end
+
+        # Authenticate for direct persistence
+        #
+        # @param [String] email
+        # @param [String] api_key
+        def authenticate(email, api_key)
+          flush_authentication
+          self.email, self.api_key = email, api_key
+        end
+
+        def connection
+          @connection ||= Excon.new(self.api_endpoint, :headers => {'Authorization' => auth_header})
+        end
+
+        # Purge current credentials and connection
+        #
+        def flush_authentication
+          self.email = nil
+          self.api_key = nil
+          @connection = nil
+        end
+
+        # Persistence type to use when saving metrics.
+        # Default is :direct.
+        #
+        def persistence
+          @persistence ||= :direct
+        end
+
+        # Set persistence type to use when saving metrics.
+        #
+        # @param [Symbol] persistence_type
+        def persistence=(persist_method)
+          @persistence = persist_method
+        end
+
+        def persister
+          @queue ? @queue.persister : nil
+        end
+
+        # Submit all queued metrics
+        #
+        def submit(args)
+          @queue ||= Queue.new
+          @queue.add args
+          @queue.submit
+        end
+
+      private
+
+        def auth_header
+          raise CredentialsMissing unless (self.email and self.api_key)
+          encoded = Base64.encode64("#{email}:#{api_key}").gsub("\n", ' ')
+          "Basic #{encoded}"
+        end
+
+        def flush_persistence
+          @persistence = nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/librato/metrics/version.rb

@@ -0,0 +1,5 @@
+module Librato
+  module Metrics
+    VERSION = "0.1.0"
+  end
+end

data/librato-metrics.gemspec

@@ -0,0 +1,36 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'librato/metrics/version'
+
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.5'
+
+  s.name              = 'librato-metrics'
+  s.version           = Librato::Metrics::VERSION
+
+  s.summary     = "Ruby wrapper for Librato's Metrics API"
+  s.description = "An easy to use ruby wrapper for Librato's Metrics API"
+
+  s.authors  = ["Matt Sanders"]
+  s.email    = 'matt@librato.com'
+  s.homepage = 'http://metrics.librato.com'
+
+  s.require_paths = %w[lib]
+
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[LICENSE]
+
+  ## runtime dependencies
+  s.add_dependency 'excon', '~>0.7.12'
+
+  ## development dependencies
+  s.add_development_dependency 'rspec', '~>2.6.0'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'rdiscount' # for yard
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rspec'
+require 'rspec/mocks/standalone'
+
+require 'librato/metrics'
+
+RSpec.configure do |config|
+
+end

data/spec/unit/metrics/queue_spec.rb

@@ -0,0 +1,146 @@
+require "spec_helper.rb"
+
+module Librato
+  module Metrics
+
+    describe Queue do
+
+      describe "#add" do
+
+        context "with single hash argument" do
+          it "should record a key-value gauge" do
+            subject.add :foo => 3000
+            subject.queued.should eql({:gauges => [{:name => 'foo', :value => 3000}]})
+          end
+        end
+
+        context "with specified metric type" do
+          it "should record counters" do
+            subject.add :total_visits => {:type => :counter, :value => 4000}
+            expected = {:counters => [{:name => 'total_visits', :value => 4000}]}
+            subject.queued.should eql expected
+          end
+
+          it "should record gauges" do
+            subject.add :temperature => {:type => :gauge, :value => 34}
+            expected = {:gauges => [{:name => 'temperature', :value => 34}]}
+            subject.queued.should eql expected
+          end
+        end
+
+        context "with extra attributes" do
+          it "should record" do
+            measure_time = Time.now
+            subject.add :disk_use => {:value => 35.4, :period => 2,
+              :description => 'current disk utilization', :measure_time => measure_time,
+              :source => 'db2'}
+            expected = {:gauges => [{:value => 35.4, :name => 'disk_use', :period => 2,
+              :description => 'current disk utilization', :measure_time => measure_time,
+              :source => 'db2'}]}
+            subject.queued.should eql expected
+          end
+        end
+
+        context "with multiple metrics" do
+          it "should record" do
+            subject.add :foo => 123, :bar => 345, :baz => 567
+            expected = {:gauges=>[{:name=>"foo", :value=>123}, {:name=>"bar", :value=>345}, {:name=>"baz", :value=>567}]}
+            subject.queued.should eql expected
+          end
+        end
+
+      end
+
+      describe "#counters" do
+
+        it "should return currently queued counters" do
+          subject.add :transactions => {:type => :counter, :value => 12345},
+                        :register_cents => {:type => :gauge, :value => 211101}
+          subject.counters.should eql [{:name => 'transactions', :value => 12345}]
+        end
+
+        it "should return [] when no queued counters" do
+          subject.counters.should eql []
+        end
+
+      end
+
+      describe "#gauges" do
+
+        it "should return currently queued gauges" do
+          subject.add :transactions => {:type => :counter, :value => 12345},
+                        :register_cents => {:type => :gauge, :value => 211101}
+          subject.gauges.should eql [{:name => 'register_cents', :value => 211101}]
+        end
+
+        it "should return [] when no queued gauges" do
+          subject.gauges.should eql []
+        end
+
+      end
+
+      describe "#submit" do
+
+        before(:all) do
+          Librato::Metrics.authenticate 'me@librato.com', 'foo'
+          Librato::Metrics.persistence = :test
+        end
+        after(:all) { Librato::Metrics::Simple.flush_authentication }
+
+        context "when successful" do
+          it "should flush queued metrics and return true" do
+            subject.add :steps => 2042, :distance => 1234
+            subject.submit.should be_true
+            subject.queued.should be_empty
+          end
+        end
+
+        context "when failed" do
+          it "should preserve queue and return false" do
+            subject.add :steps => 2042, :distance => 1234
+            subject.persister.return_value(false)
+            subject.submit.should be_false
+            subject.queued.should_not be_empty
+          end
+        end
+
+      end
+
+      describe "#time" do
+
+        context "with metric name only" do
+
+          it "should queue metric with timed value" do
+            subject.time :sleeping do
+              sleep 0.1
+            end
+            queued = subject.queued[:gauges][0]
+            queued[:name].should == 'sleeping'
+            queued[:value].should be > 100
+            queued[:value].should be_within(30).of(100)
+          end
+
+        end
+
+        context "with metric and options" do
+
+          it "should queue metric with value and options" do
+            subject.time :sleep_two, :source => 'app1', :period => 2 do
+              sleep 0.05
+            end
+            queued = subject.queued[:gauges][0]
+            queued[:name].should == 'sleep_two'
+            queued[:period].should == 2
+            queued[:source].should == 'app1'
+            queued[:value].should be > 50
+            queued[:value].should be_within(30).of(50)
+          end
+
+        end
+
+      end
+
+    end # MetricSet
+
+  end
+end

data/spec/unit/metrics/simple_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module Librato
+  module Metrics
+
+    describe Simple do
+
+      describe "#api_endpoint" do
+        it "should default to metrics" do
+          Simple.api_endpoint.should == 'https://metrics-api.librato.com/v1/'
+        end
+      end
+
+      describe "#api_endpoint=" do
+        it "should set api_endpoint" do
+          @prior = Simple.api_endpoint
+          Simple.api_endpoint = 'http://test.com/'
+          Simple.api_endpoint.should == 'http://test.com/'
+          Simple.api_endpoint = @prior
+        end
+
+        # TODO:
+        # it "should ensure trailing slash"
+        # it "should ensure real URI"
+      end
+
+      describe "#authenticate" do
+        context "when given two arguments" do
+          it "should store them as email and api_key" do
+            Simple.authenticate 'test@librato.com', 'api_key'
+            Simple.email.should == 'test@librato.com'
+            Simple.api_key.should == 'api_key'
+          end
+        end
+      end
+
+      describe "#connection" do
+        it "should raise exception without authentication" do
+          Simple.flush_authentication
+          lambda{ Simple.connection }.should raise_error(Librato::Metrics::CredentialsMissing)
+        end
+      end
+
+      describe "#persistence" do
+        it "should default to direct" do
+          Simple.send(:flush_persistence)
+          Simple.persistence.should == :direct
+        end
+
+        it "should allow configuration of persistence method" do
+          current = Simple.persistence
+          Simple.persistence = :fake
+          Simple.persistence.should == :fake
+          Simple.persistence = current
+        end
+      end
+
+      describe "#submit" do
+        before(:all) do
+          Simple.persistence = :test
+          Simple.authenticate 'me@librato.com', 'foo'
+        end
+        after(:all) { Simple.flush_authentication }
+
+        it "should persist metrics immediately" do
+          Simple.persistence = :test
+          Simple.submit(:foo => 123).should eql true
+          Simple.persister.persisted.should eql({:gauges => [{:name => 'foo', :value => 123}]})
+        end
+
+        it "should tolerate muliple metrics" do
+          lambda{ Simple.submit :foo => 123, :bar => 456 }.should_not raise_error
+          expected = {:gauges => [{:name => 'foo', :value => 123}, {:name => 'bar', :value => 456}]}
+          Simple.persister.persisted.should eql expected
+        end
+      end
+
+    end
+
+  end
+end

data/spec/unit/metrics_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module Librato
+
+  describe Metrics do
+
+   describe "#authorize" do
+
+     context "when given two arguments" do
+       it "should store them on simple" do
+         Metrics.authenticate 'tester@librato.com', 'api_key'
+         Metrics::Simple.email.should == 'tester@librato.com'
+         Metrics::Simple.api_key.should == 'api_key'
+       end
+     end
+
+   end
+
+   describe "#list" do
+
+     context "without arguments" do
+
+       it "should list all metrics"
+
+     end
+
+     context "with a name argument" do
+
+       it "should list metrics that match"
+
+     end
+
+   end
+
+   describe "#persistence" do
+
+     it "should allow configuration of persistence method" do
+       Metrics.persistence = :test
+       Metrics.persistence.should == :test
+     end
+
+   end
+
+   describe "#submit" do
+     before(:all) do
+       Librato::Metrics.persistence = :test
+       Librato::Metrics.authenticate 'me@librato.com', 'foo'
+     end
+     after(:all) { Librato::Metrics::Simple.flush_authentication }
+
+     it "should persist metrics immediately" do
+       Metrics.persistence = :test
+       Metrics.submit(:foo => 123).should eql true
+       Metrics.persister.persisted.should eql({:gauges => [{:name => 'foo', :value => 123}]})
+     end
+
+     it "should tolerate multiple metrics" do
+       lambda{ Librato::Metrics.submit :foo => 123, :bar => 456 }.should_not raise_error
+       expected = {:gauges => [{:name => 'foo', :value => 123}, {:name => 'bar', :value => 456}]}
+       Librato::Metrics.persister.persisted.should eql expected
+     end
+
+   end
+
+  end
+
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: librato-metrics
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Matt Sanders
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-08 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: &70180001393620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.12
+  type: :runtime
+  prerelease: false
+  version_requirements: *70180001393620
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70180001393140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *70180001393140
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70180001392760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70180001392760
+- !ruby/object:Gem::Dependency
+  name: rdiscount
+  requirement: &70180001392300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70180001392300
+description: An easy to use ruby wrapper for Librato's Metrics API
+email: matt@librato.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/librato/metrics.rb
+- lib/librato/metrics/errors.rb
+- lib/librato/metrics/persistence.rb
+- lib/librato/metrics/persistence/direct.rb
+- lib/librato/metrics/persistence/test.rb
+- lib/librato/metrics/queue.rb
+- lib/librato/metrics/simple.rb
+- lib/librato/metrics/version.rb
+- librato-metrics.gemspec
+- spec/spec_helper.rb
+- spec/unit/metrics/queue_spec.rb
+- spec/unit/metrics/simple_spec.rb
+- spec/unit/metrics_spec.rb
+homepage: http://metrics.librato.com
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+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.10
+signing_key: 
+specification_version: 2
+summary: Ruby wrapper for Librato's Metrics API
+test_files:
+- spec/spec_helper.rb
+- spec/unit/metrics/queue_spec.rb
+- spec/unit/metrics/simple_spec.rb
+- spec/unit/metrics_spec.rb
+has_rdoc: