pingdom-ruby 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZTM1MGFiMDA5ZThmZjI4ZTVlOTVkYjcwOTc3ODJjMTZmOWY1ZDE2Mw==
+  data.tar.gz: !binary |-
+    ZWE2ZTkxOTQ0MDUzYWE0MWY0MmMxYWMyNjUzYzJiYmJiNTBjZjY1Mg==
+SHA512:
+  metadata.gz: !binary |-
+    ZjEzYWNlZjkyMGQ1MjI0ZWNjZmQwY2YxOWJiN2IxZGI5YmU2MGRmZGU2NzM1
+    NTY3NzRhNjgwOTU0NzdhMjM2YmNmNjJjOGIxZmE5NWY1ZDRkYWU4ZTlmOGEy
+    ZmI5ZmJhNDIxZjE5ZmQwN2M2OGRkOWZjODk1MmNjNTUyNmY3ZjE=
+  data.tar.gz: !binary |-
+    YmQ1NjBkMzVmZGM4ZGU4NjUzZGE1NzhlNjMzMDkwZWFlMTMwMGY1M2UyMzBk
+    YzVmMjY2NWRlMmVhZWZhZTZiNjZjNTZiMDEzY2M0ZjA4ZWY2MzhiNjU4MTc1
+    MTdlMmIxNWE5NzgyMzc5NTIzNmY2ZjcwYTZkZjE1MjIxN2M1Njc=

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+gem "faraday", '~> 0.8.8'
+
+gem "excon"
+gem "yajl-ruby", "~> 0.8.1", :require => "yajl"
+
+gem "activesupport", "~> 3.0.4"
+gem "i18n", "~> 0.5.0" # ActiveSupport dependency
+
+group :development do
+  gem "bundler"
+  gem "rake", '~> 10.1.0'
+  gem "rspec", '~> 2.14.1'
+end

data/Gemfile.lock

@@ -0,0 +1,33 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.0.20)
+    diff-lcs (1.2.4)
+    excon (0.26.0)
+    faraday (0.8.8)
+      multipart-post (~> 1.2.0)
+    i18n (0.5.0)
+    multipart-post (1.2.0)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+    yajl-ruby (0.8.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 3.0.4)
+  bundler
+  excon
+  faraday (~> 0.8.8)
+  i18n (~> 0.5.0)
+  rake (~> 10.1.0)
+  rspec (~> 2.14.1)
+  yajl-ruby (~> 0.8.1)

data/Rakefile

@@ -0,0 +1,21 @@
+require "rubygems"
+require "bundler"
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :console do
+  exec %(ruby -rirb -rubygems -r bundler/setup -r lib/pingdom-ruby -e '$credentials = YAML.load_file("credentials.yml").with_indifferent_access; $client = Pingdom::Client.new($credentials); IRB.start')
+end
+
+task :default => :spec

data/Readme.md

@@ -0,0 +1,56 @@
+# Pingdom RESTful API Client
+
+Pingdom RESTful API wrapper for Ruby.
+
+NOTE: This is a 3rd party gem and not an official product from Pingdom.
+
+## Usage
+
+    client = Pingdom::Client.new :username => u, :password => p, :key => k
+    check = client.checks.first #=> #<Pingdom::Check>
+    check.last_response_time    #=> 200 (ms)
+    check.status                #=> "up"
+
+    result = check.results.first(:probes => [1,2,3], :status => [:up, :down])
+                                #=> #<Pingdom::Result>
+    result.status               #=> :up
+    result.up?                  #=> true
+    result.response_time        #=> 20000 (microsecs)
+
+    avg = check.summary.average(:from   => 1.month.ago,
+                                :probes => [1,2,3])
+                                #=> #<Pingdom::Summary::Average>
+    avg.response_time           #=> 200 (ms)
+    probe_avg = avg.averages.first
+    probe_avg.response_time     #=> 120 (ms)
+    probe_avg.probe.name        #=> "Atlanta, GA"
+
+## Contributors
+
+* Updated for Ruby 1.9.x/2.0.0 by Jason Straughan ([jdstraughan](http://github.com/jdstraughan))
+* Emily Price ([duien](http://github.com/duien))
+* Based on [pingom-client](https://github.com/mtodd/pingdom-client) by [Matt Todd](https://github.com/mtodd)
+
+## License
+
+The MIT License
+
+Copyright (c) 2013 Jason Straughan.
+
+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/lib/pingdom-ruby.rb

@@ -0,0 +1,25 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'faraday'
+require 'tinder/faraday_response'
+
+require 'active_support/core_ext/numeric/time'
+require 'active_support/core_ext/time/acts_like'
+require 'active_support/core_ext/time/calculations'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/hash/slice'
+require 'active_support/inflector'
+
+require 'pingdom'
+require 'pingdom/client'
+require 'pingdom/base'
+require 'pingdom/check'
+require 'pingdom/result'
+require 'pingdom/probe'
+require 'pingdom/contact'
+require 'pingdom/summary'
+require 'pingdom/summary/average'
+require 'pingdom/summary/outage'
+require 'pingdom/summary/performance'

data/lib/pingdom.rb

@@ -0,0 +1,8 @@
+module Pingdom
+  
+  VERSION = '0.0.6.alpha'
+  
+  class Error < RuntimeError
+  end
+  
+end

data/lib/pingdom/base.rb

@@ -0,0 +1,54 @@
+module Pingdom
+  class Base
+    
+    def initialize(client, response, attributes = {})
+      @client     = client
+      @response   = response
+      @attributes = attributes
+    end
+    
+    def self.attributes(hash)
+      hash.each do |(attribute, aliases)|
+        class_eval <<-"end;" unless instance_methods.include?(attribute.to_s)
+          def #{attribute}
+            @attributes[:#{attribute}]
+          end
+        end;
+        
+        Array.wrap(aliases).each do |aliased|
+          alias_method aliased, attribute
+        end
+      end
+    end
+    
+    def method_missing(name, *args, &block)
+      @attributes[name] or super
+    end
+    
+    def respond_to?(name)
+      super(name) || @attributes.key?(name)
+    end
+    
+    def id
+      @attributes[:id]
+    end
+    
+    def inspect
+      "#<%s %s>" % [self.class.to_s, @attributes.inject([]){ |a, (k,v)| a << "%s: %s" % [k,v.inspect]; a }.join(' ')]
+    end
+    
+    def self.check_error!(response)
+      if response.body.key?(:error)
+        raise Error, "%s (%s %s)" % [ response.body[:error][:errormessage],
+                                      response.body[:error][:statuscode],
+                                      response.body[:error][:statusdesc] ]
+      end
+    end
+    
+    def self.parse(client, response)
+      check_error!(response)
+      response.body
+    end
+    
+  end
+end

data/lib/pingdom/check.rb

@@ -0,0 +1,34 @@
+module Pingdom
+  
+  # {"name"=>"Autocomplete", "id"=>259103, "type"=>"http", "lastresponsetime"=>203173, "status"=>"up", "lasttesttime"=>1298102416}
+  class Check < Base
+    def self.parse(client, response)
+      checks = super
+      Array.wrap(checks[:checks] || checks[:check]).map do |check|
+        new(client, response, check)
+      end
+    end
+    
+    attributes  :lastresponsetime => :last_response_time,
+                :lasttesttime     => :last_test_time,
+                :lasterrortime    => :last_error_time
+    
+    def results(options = {})
+      @client.results(id, options)
+    end
+    
+    def summary
+      @client.summary(id)
+    end
+    
+    def lasttesttime
+      Time.at(super)
+    end
+    
+    def lasterrortime
+      Time.at(super)
+    end
+    
+  end
+  
+end

data/lib/pingdom/client.rb

@@ -0,0 +1,89 @@
+require File.join(File.dirname(__FILE__), '..', 'pingdom-ruby') unless defined? Pingdom
+
+module Pingdom
+  class Client
+    
+    attr_accessor :limit
+    
+    def initialize(options = {})
+      @options = options.with_indifferent_access.reverse_merge(:http_driver => :excon)
+      
+      raise ArgumentError, "an application key must be provided (as :key)" unless @options.key?(:key)
+      
+      @connection = Faraday::Connection.new(:url => "https://api/pingdom.com/api/2.0/") do |builder|
+        builder.url_prefix = "https://api.pingdom.com/api/2.0"
+        
+        builder.adapter :logger, @options[:logger]
+        
+        builder.adapter @options[:http_driver]
+        
+        # builder.use Gzip # TODO: write GZip response handler, add Accept-Encoding: gzip header
+        builder.response :yajl
+        builder.use Tinder::FaradayResponse::WithIndifferentAccess
+        
+        builder.basic_auth @options[:username], @options[:password]
+      end
+    end
+    
+    # probes => [1,2,3] #=> probes => "1,2,3"
+    def prepare_params(options)
+      options.each do |(key, value)|
+        options[key] = Array.wrap(value).map(&:to_s).join(',')
+        options[key] = value.to_i if value.acts_like?(:time)
+      end
+      
+      options
+    end
+    
+    def get(uri, params = {}, &block)
+      response = @connection.get(@connection.build_url(uri, prepare_params(params)), "App-Key" => @options[:key], &block)
+      update_limits!(response.headers['req-limit-short'], response.headers['req-limit-long'])
+      response
+    end
+    
+    def update_limits!(short, long)
+      @limit ||= {}
+      @limit[:short]  = parse_limit(short)
+      @limit[:long]   = parse_limit(long)
+      @limit
+    end
+    
+    # "Remaining: 394 Time until reset: 3589"
+    def parse_limit(limit)
+      if limit.to_s =~ /Remaining: (\d+) Time until reset: (\d+)/
+        { :remaining => $1.to_i,
+          :resets_at => $2.to_i.seconds.from_now }
+      end
+    end
+    
+    def test!(options = {})
+      Result.parse(self, get("single", options)).first
+    end
+    
+    def checks(options = {})
+      Check.parse(self, get("checks", options))
+    end
+    def check(id)
+      Check.parse(self, get("checks/#{id}")).first
+    end
+    
+    # Check ID
+    def results(id, options = {})
+      options.reverse_merge!(:includeanalysis => true)
+      Result.parse(self, get("results/#{id}", options))
+    end
+    
+    def probes(options = {})
+      Probe.parse(self, get("probes", options))
+    end
+    
+    def contacts(options = {})
+      Contact.parse(self, get("contacts", options))
+    end
+    
+    def summary(id)
+      Summary.proxy(self, id)
+    end
+    
+  end
+end

data/lib/pingdom/contact.rb

@@ -0,0 +1,16 @@
+module Pingdom
+  
+  # {"name"=>"Larry Bernstein", "directtwitter"=>false, "id"=>142762, "cellphone"=>"1-510-501-7401",
+  # "paused"=>false, "defaultsmsprovider"=>"clickatell", "email"=>"lbernstein@demandbase.com"}
+  class Contact < Base
+    def self.parse(client, response)
+      super[:contacts].map do |contact|
+        new(client, response, contact)
+      end
+    end
+    
+    attributes :cellphone => :phone
+    
+  end
+  
+end

data/lib/pingdom/probe.rb

@@ -0,0 +1,20 @@
+module Pingdom
+  
+  # {"city"=>"Manchester", "name"=>"Manchester, UK", "country"=>"United Kingdom",
+  # "countryiso"=>"GB", "id"=>46, "ip"=>"212.84.74.156", "hostname"=>"s424.pingdom.com", "active"=>true}
+  class Probe < Base
+    def self.parse(client, response)
+      super[:probes].map do |probe|
+        new(client, response, probe)
+      end
+    end
+    
+    attributes :countryiso => [:country_iso, :country_code]
+    
+    def test!(options)
+      @client.test!(options.merge(:probeid => id))
+    end
+    
+  end
+  
+end

data/lib/pingdom/result.rb

@@ -0,0 +1,20 @@
+module Pingdom
+  
+  # {"statusdesclong"=>"OK", "probeid"=>28, "responsetime"=>221, "statusdesc"=>"OK", "status"=>"up", "probedesc"=>"Amsterdam 2, Netherlands"}
+  class Result < Base
+    def self.parse(client, response)
+      results = super
+      Array.wrap(results[:results] || results[:result]).map do |result|
+        new(client, response, result)
+      end
+    end
+    
+    attributes  :responsetime => :response_time,
+                :probeid      => :probe_id
+    
+    def probe
+      @client.probes.detect{ |probe| probe.id == probe_id }
+    end
+  end
+  
+end

data/lib/pingdom/summary.rb

@@ -0,0 +1,44 @@
+module Pingdom
+  
+  class Summary < Base
+    
+    class Proxy < Struct.new(:client, :check_id)
+      def average(options = {})
+        options.reverse_merge!(:byprobe => true, :includeuptime => true)
+        Average.parse(client, client.get("summary.average/#{check_id}", options))
+      end
+      alias_method :averages, :average
+      
+      def outage(options = {})
+        options.reverse_merge!(:byprobe => true, :includeuptime => true)
+        Outage.parse(client, client.get("summary.outage/#{check_id}", options))
+      end
+      alias_method :outages, :outage
+      
+      def performance(options = {})
+        options.reverse_merge!(:resolution => :day, :includeuptime => true)
+        Performance.parse(client, client.get("summary.performance/#{check_id}", options))
+      end
+    end
+    
+    def self.proxy(client, check)
+      Proxy.new(client, check)
+    end
+    
+    def from
+      Time.at(@attributes[:from])
+    end
+    
+    def to
+      Time.at(@attributes[:to])
+    end
+    
+    attributes :responsetime => :response_time
+    
+    # {"status"=>{"totalup"=>5035757, "totalunknown"=>1293069551, "totaldown"=>5078}}
+    class Status < Base
+    end
+    
+  end
+  
+end

data/lib/pingdom/summary/average.rb

@@ -0,0 +1,47 @@
+module Pingdom
+  class Summary
+    
+    # summary.average includeuptime probes=34,35 byprobe
+    # { "responsetime"=>{
+    #     "from"=>0, "to"=>1298110456, "probes"=>"34, 35", "avgresponse"=>[
+    #       {"probeid"=>35, "avgresponse"=>94},
+    #       {"probeid"=>34, "avgresponse"=>125} ]},
+    #   "status"=>{"totalup"=>5035757, "totalunknown"=>1293069551, "totaldown"=>5078}}
+    class Average < Base
+      def self.parse(client, response)
+        body  = super[:summary]
+        sum   = body[:responsetime]
+        attrs = sum.slice(:from, :to)
+        attrs[:probes] = (attrs[:probes] || "").gsub(/\w+/, '').split(',').map{|e| e.to_i }
+        
+        sum[:status] = Status.new(client, response, body[:status]) if body.key?(:status)
+        
+        case sum[:avgresponse]
+        when Array
+          sum[:responsetime]   = 0
+          sum[:averages]  =
+          sum.delete(:avgresponse).map do |avg|
+            sum[:responsetime] += avg[:avgresponse]
+            new(client, response, avg)
+          end
+          sum[:responsetime] = sum[:responsetime] / sum[:averages].size if sum[:averages].size > 0
+          
+        when Integer
+          sum[:responsetime] = sum.delete(:avgresponse)
+          
+        end
+        
+        sum = Summary.new(client, response, sum)
+      end
+      
+      attributes  :probeid      => :probe_id,
+                  :responsetime => :response_time
+      
+      def probe
+        @client.probes.detect{ |probe| probe.id == probe_id }
+      end
+      
+    end
+    
+  end
+end

data/lib/pingdom/summary/outage.rb

@@ -0,0 +1,35 @@
+module Pingdom
+  class Summary
+    
+    # summary.outage
+    # {"states"=>[{"timeto"=>1297587576, "timefrom"=>1297475316, "status"=>"up"},
+    #             {"timeto"=>1297587906, "timefrom"=>1297587576, "status"=>"down"},
+    #             {"timeto"=>1298110749, "timefrom"=>1297587906, "status"=>"up"}]}
+    class Outage < Base
+      def self.parse(client, response)
+        super[:summary][:states].
+        select{ |s| s[:status] == "down" }.
+        map do |outage|
+          new(client, response, outage)
+        end
+      end
+      
+      def downtime
+        (@attributes[:timeto] - @attributes[:timefrom]).seconds
+      end
+      
+      def timefrom
+        Time.at(@attributes[:timefrom])
+      end
+      
+      def timeto
+        Time.at(@attributes[:timeto])
+      end
+      
+      attributes  :timefrom => [:time_from, :from],
+                  :timeto   => [:time_to, :to,]
+      
+    end
+    
+  end
+end

data/lib/pingdom/summary/performance.rb

@@ -0,0 +1,65 @@
+module Pingdom
+  class Summary
+    
+    # summary.performance includeuptime resolution=day
+    # {"days"=>[{"unmonitored"=>0, "downtime"=>0, "starttime"=>1297238400, "uptime"=>86400, "avgresponse"=>234},
+    #           {"unmonitored"=>0, "downtime"=>0, "starttime"=>1297324800, "uptime"=>86400, "avgresponse"=>215},
+    #           {"unmonitored"=>0, "downtime"=>2648, "starttime"=>1297411200, "uptime"=>83752, "avgresponse"=>211},
+    #           {"unmonitored"=>0, "downtime"=>0, "starttime"=>1297497600, "uptime"=>86400, "avgresponse"=>207},
+    #           {"unmonitored"=>0, "downtime"=>330, "starttime"=>1297584000, "uptime"=>86070, "avgresponse"=>228},
+    #           {"unmonitored"=>0, "downtime"=>0, "starttime"=>1297670400, "uptime"=>86400, "avgresponse"=>236},
+    #           {"unmonitored"=>0, "downtime"=>0, "starttime"=>1297756800, "uptime"=>86400, "avgresponse"=>230},
+    #           {"unmonitored"=>0, "downtime"=>0, "starttime"=>1297843200, "uptime"=>86400, "avgresponse"=>256},
+    #           {"unmonitored"=>0, "downtime"=>0, "starttime"=>1297929600, "uptime"=>86400, "avgresponse"=>216},
+    #           {"unmonitored"=>0, "downtime"=>0, "starttime"=>1298016000, "uptime"=>86400, "avgresponse"=>251},
+    #           {"unmonitored"=>0, "downtime"=>0, "starttime"=>1298102400, "uptime"=>8646, "avgresponse"=>223}]}
+    class Performance < Base
+      INTERVALS = {
+        "hour"  => 1.hour,
+        "day"   => 1.day,
+        "week"  => 1.week
+      }
+      
+      def self.parse(client, response)
+        body      = super[:summary]
+        interval  = body.keys.detect{ |k| INTERVALS.keys.include?(k.chomp('s').to_s) }.chomp('s').to_sym
+        intervals = body[interval.to_s.pluralize]
+        
+        intervals.map do |perf|
+          perf[:interval] = interval
+          new(client, response, perf)
+        end
+      end
+      
+      def starttime
+        Time.at(@attributes[:starttime])
+      end
+      alias_method :start_at, :starttime
+      
+      def endtime
+        starttime + INTERVALS[interval.to_s].to_i
+      end
+      alias_method :end_at, :endtime
+      
+      def uptime
+        @attributes[:uptime].seconds
+      end
+      def downtime
+        @attributes[:downtime].seconds
+      end
+      def unmonitored
+        @attributes[:unmonitored].seconds
+      end
+      def monitored
+        uptime + downtime
+      end
+      def period
+        monitored + unmonitored
+      end
+      
+      attributes :avgresponse => :response_time
+      
+    end
+    
+  end
+end

data/lib/tinder/faraday_response.rb

@@ -0,0 +1,56 @@
+# Taken from:
+# https://github.com/collectiveidea/tinder/raw/master/lib/tinder/middleware.rb
+# See:
+# https://github.com/collectiveidea/tinder/blob/master/MIT-LICENSE
+# 
+# Copyright (c) 2006-2010 Brandon Keepers, Collective Idea
+# 
+# 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 PURPOa AND
+# NONINFRINGEMENT. IN NO EVENT SaALL 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.
+# 
+module Tinder
+  module FaradayResponse
+    class WithIndifferentAccess < ::Faraday::Response::Middleware
+      begin
+        require 'active_support/core_ext/hash/indifferent_access'
+      rescue LoadError, NameError => error
+        self.load_error = error
+      end
+      
+      def self.register_on_complete(env)
+        env[:response].on_complete do |response|
+          json = response[:body]
+          if json.is_a?(Hash)
+            response[:body] = ::HashWithIndifferentAccess.new(json)
+          elsif json.is_a?(Array) and json.first.is_a?(Hash)
+            response[:body] = json.map{|item| ::HashWithIndifferentAccess.new(item) }
+          end
+        end
+      end
+    end
+    
+    class RaiseOnAuthenticationFailure < ::Faraday::Response::Middleware
+      def self.register_on_complete(env)
+        env[:response].on_complete do |response|
+          raise AuthenticationFailed if response[:status] == 401
+        end
+      end
+    end
+  end
+end

data/pingdom-ruby.gemspec

@@ -0,0 +1,39 @@
+Gem::Specification.new do |s|
+  s.name = %q{pingdom-ruby}
+  s.version = "1.0.0"
+  
+  s.authors = ["Jason Straughan"]
+  s.date = %q{2013-10-05}
+  s.description = %q{Pingdom Ruby Client}
+  s.email = %q{jasons@grok-interactive.com}
+  s.files = [
+    "pingdom-ruby.gemspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "lib/pingdom/base.rb",
+    "lib/pingdom/check.rb",
+    "lib/pingdom/client.rb",
+    "lib/pingdom/contact.rb",
+    "lib/pingdom/probe.rb",
+    "lib/pingdom/result.rb",
+    "lib/pingdom/summary/average.rb",
+    "lib/pingdom/summary/outage.rb",
+    "lib/pingdom/summary/performance.rb",
+    "lib/pingdom/summary.rb",
+    "lib/pingdom-ruby.rb",
+    "lib/pingdom.rb",
+    "lib/tinder/faraday_response.rb",
+    "Rakefile",
+    "Readme.md",
+    "spec/pingdom-ruby_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Pingdom Ruby Client}
+  s.test_files = [
+    "spec/spec_helper.rb",
+    "spec/pingdom-ruby_spec.rb"
+  ]
+end

data/spec/pingdom-ruby_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Pingdom::Client do
+  let(:client){ Pingdom::Client.new(CREDENTIALS.merge(:logger => LOGGER)) }
+  
+  describe "#test!" do
+    it "should test a single endpoint" do
+      response = client.test!(:host => "pingdom.com", :type => "http")
+      
+      response.status.should == "up"
+      response.responsetime.should be_a(Numeric)
+    end
+  end
+  
+  describe "#checks" do
+    it "should get a list of checks" do
+      checks = client.checks
+      
+      first = checks.first
+      first.should be_a(Pingdom::Check)
+      first.last_response_time.should be_a(Numeric)
+    end
+  end
+  
+  describe "#limit" do
+    { :short  => "short term",
+      :long   => "long term" }.each do |(key, label)|
+      describe label do
+        let(:limit){ client.test!(:host => "pingdom.com", :type => "http"); client.limit[key] }
+        
+        it "should indicate how many requests can be made" do
+          limit[:remaining].should be_a(Numeric)
+        end
+        
+        it "should indicate when the current limit will be reset" do
+          limit[:resets_at].acts_like?(:time).should be_true
+        end
+      end
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'rubygems'
+require 'bundler/setup'
+require 'pingdom-ruby'
+
+require 'logger'
+require 'rspec'
+
+LOGGER      = Logger.new(File.join(File.dirname(__FILE__), 'test.log'))
+CREDENTIALS = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'credentials.yml')).with_indifferent_access

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: pingdom-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jason Straughan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-05 00:00:00.000000000 Z
+dependencies: []
+description: Pingdom Ruby Client
+email: jasons@grok-interactive.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- pingdom-ruby.gemspec
+- Gemfile
+- Gemfile.lock
+- lib/pingdom/base.rb
+- lib/pingdom/check.rb
+- lib/pingdom/client.rb
+- lib/pingdom/contact.rb
+- lib/pingdom/probe.rb
+- lib/pingdom/result.rb
+- lib/pingdom/summary/average.rb
+- lib/pingdom/summary/outage.rb
+- lib/pingdom/summary/performance.rb
+- lib/pingdom/summary.rb
+- lib/pingdom-ruby.rb
+- lib/pingdom.rb
+- lib/tinder/faraday_response.rb
+- Rakefile
+- Readme.md
+- spec/pingdom-ruby_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.1.5
+signing_key: 
+specification_version: 4
+summary: Pingdom Ruby Client
+test_files:
+- spec/spec_helper.rb
+- spec/pingdom-ruby_spec.rb
+has_rdoc: