pingdom-client 0.0.0.alpha

data/Gemfile

@@ -0,0 +1,15 @@
+source :rubygems
+
+gem "faraday", "~> 0.5.6"
+
+gem "excon", "~> 0.5.6"
+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", "~> 1.0.0"
+  gem "rake", "~> 0.8.7"
+  gem "rspec", "2.1.0"
+end

data/Gemfile.lock

@@ -0,0 +1,37 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.4)
+    addressable (2.2.4)
+    diff-lcs (1.1.2)
+    excon (0.5.6)
+    faraday (0.5.6)
+      addressable (~> 2.2.4)
+      multipart-post (~> 1.1.0)
+      rack (>= 1.1.0, < 2)
+    i18n (0.5.0)
+    multipart-post (1.1.0)
+    rack (1.2.1)
+    rake (0.8.7)
+    rspec (2.1.0)
+      rspec-core (~> 2.1.0)
+      rspec-expectations (~> 2.1.0)
+      rspec-mocks (~> 2.1.0)
+    rspec-core (2.1.0)
+    rspec-expectations (2.1.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.1.0)
+    yajl-ruby (0.8.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 3.0.4)
+  bundler (~> 1.0.0)
+  excon (~> 0.5.6)
+  faraday (~> 0.5.6)
+  i18n (~> 0.5.0)
+  rake (~> 0.8.7)
+  rspec (= 2.1.0)
+  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-client -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,47 @@
+# Pingdom RESTful API Client
+
+Pingdom now offers a RESTful API, which gives us no reason not to make a decent,
+non-SOAP API client for their services.
+
+## Usage
+
+    client = Pingdom::Client.new :username => u, :password => p
+    check = client.checks.first #=> #<Pingdom::Check>
+    check.lastresponsetime      #=> 200 (ms)
+    check.status                #=> :up
+    check.up?                   #=> true
+
+    result = check.results.first(:probes => [1,2,3], :status => [:up, :down])
+                                #=> #<Pingdom::Result>
+    result.status               #=> :up
+    result.up?                  #=> true
+    result.responsetime         #=> 200 (ms)
+    
+    avg = check.average(:from   => 1.month.ago,
+                        :probes => [1,2,3])
+                                #=> #<Pingdom::Summary::Average>
+    avg.responsetime.avgresponse
+
+## License
+
+The MIT License
+
+Copyright (c) 2011 Matt Todd.
+
+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-client.rb

@@ -0,0 +1,435 @@
+require 'faraday'
+
+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'
+
+LOGGER = lambda do |app|
+  lambda do |env|
+    puts "Request: %s %s" % [env[:method], env[:url].to_s]
+    app.call(env)
+  end
+end
+
+module Pingdom
+  class Client
+    
+    attr_accessor :limit
+    
+    def initialize(credentials = {})
+      @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.builder.run LOGGER
+        
+        builder.adapter :excon
+        
+        # builder.use Gzip # TODO: write GZip response handler, add Accept-Encoding: gzip header
+        builder.response :yajl
+        builder.use Tinder::FaradayResponse::WithIndifferentAccess
+        
+        builder.basic_auth credentials[:username], credentials[: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)), &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}"))
+    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
+  
+  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
+  
+  # {"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
+  
+  # {"name"=>"Autocomplete", "id"=>259103, "type"=>"http", "lastresponsetime"=>203173, "status"=>"up", "lasttesttime"=>1298102416}
+  class Check < Base
+    def self.parse(client, response)
+      super[:checks].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
+  
+  # {"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
+  
+  # {"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
+  
+  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
+    
+    # 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
+      
+      def probe
+        @client.probes.detect{ |probe| probe.id == probe_id }
+      end
+      
+    end
+    
+    # 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
+    
+    # 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
+        interval  = body.keys.detect{ |k| INTERVALS.keys.include?(k.to_s) }.to_sym
+        intervals = body[interval]
+        
+        intervals.map do |perf|
+          perf[:interval] = interval
+          new(client, response, perf)
+        end
+      end
+      
+      def starttime
+        Time.at(@attributes[:starttime])
+      end
+      
+      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
+      
+    end
+    
+    # {"status"=>{"totalup"=>5035757, "totalunknown"=>1293069551, "totaldown"=>5078}}
+    class Status < Base
+    end
+    
+  end
+  
+  class Error < RuntimeError
+  end
+end
+
+# Taken from:
+# https://github.com/collectiveidea/tinder/raw/master/lib/tinder/middleware.rb
+# See:
+# https://github.com/collectiveidea/tinder/blob/master/MIT-LICENSE
+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-client.gemspec

@@ -0,0 +1,66 @@
+Gem::Specification.new do |s|
+  s.name = %q{pingdom-client}
+  s.version = "0.0.0.alpha"
+  
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Matt Todd"]
+  s.date = %q{2011-02-24}
+  s.description = %q{Pingdom Ruby Client}
+  s.email = %q{chiology@gmail.com}
+  s.files = [
+    "pingdom-client.gemspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "lib/pingdom-client.rb",
+    "Rakefile",
+    "Readme.md",
+    "spec/pingdom-client_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/mtodd/pingdom-client}
+  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-client_spec.rb"
+  ]
+  
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+    
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency("faraday",       ["~> 0.5.6"])
+      s.add_runtime_dependency("excon",         ["~> 0.5.6"])
+      s.add_runtime_dependency("yajl-ruby",     ["~> 0.8.1"])
+      s.add_runtime_dependency("activesupport", ["~> 3.0.4"])
+      s.add_runtime_dependency("i18n",          ["~> 0.5.0"])
+      
+      s.add_development_dependency("bundler", ["~> 1.0.0"])
+      s.add_development_dependency("rake",    ["~> 0.8.7"])
+      s.add_development_dependency("rspec",   ["= 2.1.0"])
+    else
+      s.add_dependency("faraday",       ["~> 0.5.6"])
+      s.add_dependency("excon",         ["~> 0.5.6"])
+      s.add_dependency("yajl-ruby",     ["~> 0.8.1"])
+      s.add_dependency("activesupport", ["~> 3.0.4"])
+      s.add_dependency("i18n",          ["~> 0.5.0"])
+      
+      s.add_dependency("bundler", ["~> 1.0.0"])
+      s.add_dependency("rake",    ["~> 0.8.7"])
+      s.add_dependency("rspec",   ["= 2.1.0"])
+    end
+  else
+    s.add_dependency("faraday",       ["~> 0.5.6"])
+    s.add_dependency("excon",         ["~> 0.5.6"])
+    s.add_dependency("yajl-ruby",     ["~> 0.8.1"])
+    s.add_dependency("activesupport", ["~> 3.0.4"])
+    s.add_dependency("i18n",          ["~> 0.5.0"])
+    
+    s.add_dependency("bundler", ["~> 1.0.0"])
+    s.add_dependency("rake", ["~> 0.8.7"])
+    s.add_dependency("rspec", ["= 2.1.0"])
+  end
+end

data/spec/pingdom-client_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Pingdom::Client do
+  let(:client){ Pingdom::Client.new(CREDENTIALS) }
+  
+  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,8 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'rubygems'
+require 'bundler/setup'
+require 'pingdom-client'
+
+require 'rspec'
+
+CREDENTIALS = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'credentials.yml')).inject({}){ |h,(k,v)| h[k.to_sym] = v; h }

metadata

@@ -0,0 +1,203 @@
+--- !ruby/object:Gem::Specification 
+name: pingdom-client
+version: !ruby/object:Gem::Version 
+  hash: -1851332162
+  prerelease: true
+  segments: 
+  - 0
+  - 0
+  - 0
+  - alpha
+  version: 0.0.0.alpha
+platform: ruby
+authors: 
+- Matt Todd
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-24 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: faraday
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 5
+        - 6
+        version: 0.5.6
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: excon
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 5
+        - 6
+        version: 0.5.6
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 61
+        segments: 
+        - 0
+        - 8
+        - 1
+        version: 0.8.1
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 3
+        - 0
+        - 4
+        version: 3.0.4
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 0
+        - 5
+        - 0
+        version: 0.5.0
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  version_requirements: *id008
+description: Pingdom Ruby Client
+email: chiology@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- pingdom-client.gemspec
+- Gemfile
+- Gemfile.lock
+- lib/pingdom-client.rb
+- Rakefile
+- Readme.md
+- spec/pingdom-client_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/mtodd/pingdom-client
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Pingdom Ruby Client
+test_files: 
+- spec/spec_helper.rb
+- spec/pingdom-client_spec.rb