pingdom-to-graphite 0.0.2

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+# No Gemfile.lock for gem projects
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,11 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gemspec
+
+group :development do
+  gem "rake"
+  gem "aruba"
+  gem "cucumber"
+  gem "ronn"
+end

data/README.md

@@ -0,0 +1,96 @@
+# pingdom-to-graphite
+
+A tool for copying metrics from Pingdom to graphite. Pingdom, although allowing
+access to effectively all your metrics through the API, does have some limits in
+place to prevent abuse. This script tries to be mindful of that, although does
+provide a "backfill" option if you care to burn up your daily api limit in one
+fell swoop.
+
+## Usage
+
+The utility itself will provide detailed help for all the commands if you just
+invoke it by itself:
+
+    pingdom-to-graphite
+
+### For the Impatient
+
+Ok, so you don't like reading command line help. Here's how to get up and
+running quickly:
+
+    pingdom-to-graphite init
+
+Will place a sample config file into the default location `~/.p2g/config.json`.
+Don't worry scripters, this location can be overriden with the `-c` switch. Drop
+your pingdom credentials and graphite settings into there to enable the script
+to do any actual work.
+
+    pingdom-to-graphite init_checks
+
+This will pre-fill the pingdom->checks setting in your config file with a list
+of all your available check ids. Since you're curious:
+
+    pingdom-to-graphite list
+
+Will list them all, as well as their current status. Ok, back to business:
+
+    pingdom-to-graphite update
+
+Will pull the 100 most recent checks for each check specified in your config
+file and create a  `~/.p2g/state.json` file storing a few key timestamps about
+what data you've successfully send to graphite. Similar to the config file, this
+location can be overridden with the `-s` switch.
+
+    pingdom-to-graphite update
+
+*"Hey, that's the same command!"* you say. Indeed it is, and will run through your
+checks picking up where we left of from the last update. If you stopped to check
+graphite after that last step you might even pick up a few new checks. The idea
+is just to scedule this job via cron and let  your metrics roll in on a fixed
+schedule. How often? Well, you can't run any checks at more then  a minute
+resolution, so going any more frequently then that is wasteful. The actual
+limiting factor is that updating each metric is a separate API call, so the more
+checks you want to pipe to graphite the less frequently you'll be able to run
+the script. Want some numbers?
+
+    pingdom-to-graphite advice
+
+Will give you the rough API numbers you'd consume a day given your number of
+monitored checks in five minute increments until it finds something that works.
+However, keep in mind that you're not using this to do alerting (right, I mean,
+that's what you're paying Pingdom for) and that graphite  doesn't have any
+issues backfilling content, so picking the most aggressive value you can isn't
+necessarily the best approach! Speaking of the API, how about some more historical
+data because, you know, charts and stuff! Got that covered, but you're going to have
+to pick the specific check you'd like some more data for.
+
+    pingdom-to-graphite backfull CHECK_ID
+
+Will use up a number of your existing API calls to get historical data for that specific
+check. How many? Well, it will ask, and you can tell it. You can also specify with the 
+`-l` flag. 
+
+## License
+
+The MIT License
+
+Copyright (c) 2012 Lewis J. Goettner, III
+
+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/Rakefile

@@ -0,0 +1,3 @@
+task :console do
+  exec %(irb -Ilib)
+end

data/bin/pingdom-to-graphite

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'rubygems'
+require 'bundler/setup'
+
+require "pingdom-to-graphite/cli"
+
+PingdomToGraphite::CLI.start

data/features/copy.feature

@@ -0,0 +1,66 @@
+Feature: Copy
+  In order to populate graphite
+  As a valid user of the Pingdom API
+  I should be able to copy metrics from Pingdom
+
+  Scenario: No argument
+    When I run `pingdom-to-graphite`
+    Then the output should contain:
+    """
+    Tasks:
+    """
+
+  Scenario: Initialize config file
+    When I run `pingdom-to-graphite init -c configtest.json`
+    Then the file "configtest.json" should contain "pingdom"
+
+  
+  Scenario: Initialize the checks data
+    When I run `pingdom-to-graphite init_checks`
+    Then the exit status should be 0
+    Then the output should match /Added [\d]+ checks to/
+
+  Scenario: Get a list of your checks
+    When I run `pingdom-to-graphite list`
+    Then the exit status should be 0
+    Then the output should match /^.* \([\d]+\) - (up|down)/
+
+  Scenario: Get some advice on API limits
+    When I run `pingdom-to-graphite advice`
+    Then the exit status should be 0
+    Then the output should match /- WORKS$/
+
+  Scenario: Get the list of pingdom probes
+    When I run `pingdom-to-graphite probes`
+    Then the exit status should be 0
+    Then the output should match /^[A-Z]{2} - .*$/
+
+  Scenario: Get the results for a specific probe
+    When I run `pingdom-to-graphite results` with a valid check id
+    Then the exit status should be 0
+    Then the output should match /^[\d-]{10} [\d:]{8} (-|\+)[\d]{4}: (up|down) - [\d]+ms \(.*\)$/
+
+  @graphite
+  Scenario: Update the current checks without a state file
+    Given A mock graphite server is running
+    When I run `pingdom-to-graphite update -s teststate.json -c ../mockgraphite.json`
+    Then the exit status should be 0
+    Then graphite should have recieved results
+    Then the file "teststate.json" should contain "latest_ts"
+    Then the output should match /[\d]+ metrics sent to graphite for check [\d]+\./
+    
+  Scenario: Try to backfill a check that's never been updated
+    When I run `pingdom-to-graphite backfill 1`
+    Then the exit status should be 1
+    Then the output should contain:
+    """
+    You can't backfill a check you've never run an update on.
+    """
+
+  @graphite @copystate
+  Scenario: Backfill a specific check
+    Given A mock graphite server is running
+    When I run `pingdom-to-graphite backfill -c ../mockgraphite.json -s ../copiedstate.json -l 1` with a valid check id
+    Then the exit status should be 0
+    Then graphite should have recieved results
+    Then the output should match /[\d]+ metrics sent to graphite for check [\d]+\./

data/features/step_definitions/copy_steps.rb

@@ -0,0 +1,30 @@
+require 'json'
+
+Given /^A mock graphite server is running$/ do
+  @mock_received = Queue.new
+  @lew = "Goettner"
+  @mock_socket = TCPServer.new 20003
+  @server = Thread.new do
+    loop do
+      client = @mock_socket.accept
+      data = ""
+      recv_length = 100
+      while (tmp = client.recv(recv_length))
+        data += tmp
+        break if tmp.empty?
+      end
+      @mock_received << data
+    end
+  end
+end
+
+When /^I run `([^`]*)` with a valid check id$/ do |cmd|
+  config_file = File.expand_path('~/.p2g/config.json')
+  @config = JSON::parse(File.read(config_file));
+  step "I run `#{cmd} #{@config["pingdom"]["checks"][0]}`"
+end
+
+Then /^graphite should have recieved results$/ do 
+  last_entry = @mock_received.pop
+  last_entry.should match /^[^ ]* [\d]+ [\d]{10,}$/
+end

data/features/support/env.rb

@@ -0,0 +1,41 @@
+require "aruba/cucumber"
+require "socket"
+require "thread"
+
+Before do 
+  @aruba_timeout_seconds = 60
+end
+
+Before("@graphite") do 
+  # Create a hybrid config (real pingdom / mock graphite)
+  config_file = File.expand_path('~/.p2g/config.json')
+  @config = JSON::parse(File.read(config_file))
+  @config["pingdom"]["checks"] = [ @config["pingdom"]["checks"][0] ]
+  @config["graphite"] = {
+    "host" => "localhost",
+    "port" => "20003",
+    "prefix" => "pingdom"
+  }
+  File.open('tmp/mockgraphite.json',"w",0600) do |f|
+    f.write(JSON.generate(@config))
+  end
+end
+
+After("@graphite") do
+  File.delete('tmp/mockgraphite.json')
+  @mock_socket.close
+end
+
+
+Before("@copystate") do 
+  # Copy the real statefile (so we don't mess it up)
+  state_file = File.expand_path('~/.p2g/state.json')
+  File.open('tmp/copiedstate.json',"w",0600) do |f|
+    f.write(File.read(state_file))
+  end
+end
+  
+After("@copystate") do
+  File.delete('tmp/copiedstate.json')
+end
+

data/lib/pingdom-to-graphite.rb

@@ -0,0 +1,3 @@
+module PingdomToGraphite
+  
+end

data/lib/pingdom-to-graphite/cli.rb

@@ -0,0 +1,306 @@
+require "pingdom-to-graphite"
+require "pingdom-to-graphite/data-pull"
+require "pingdom-to-graphite/data-push"
+require "graphite-metric"
+require "thor"
+require "json"
+require "fileutils"
+require "logger"
+
+class PingdomToGraphite::CLI < Thor
+
+  class_option  :config,
+                :desc     => "The path to your config file.",
+                :type     => :string,
+                :aliases  => "-c",
+                :default  => "~/.p2g/config.json"
+
+  class_option  :state,
+                :desc     => "The path to your state file.",
+                :type     => :string,
+                :aliases  => "-s",
+                :default  => "~/.p2g/state.json"
+
+  class_option :verbose, :type => :boolean, :aliases => "-v", :desc => "Increase verbosity."
+
+  desc "init", "Create an empty config JSON file if missing."
+  def init
+    config_path = File.expand_path(options.config)
+
+    if File.exists?(config_path)
+      error("Config file already exists. (#{options.config})")
+    else
+
+      # Make sure we have a directory to put the config in
+      unless File.directory?(File.dirname(config_path))
+        FileUtils.mkdir_p(File.dirname(config_path), :mode => 0700)
+      end
+
+      # A nice little defaults file.
+      settings = {
+        "pingdom"   => {
+          "username"  => "YOUR_USERNAME",
+          "password"  => "YOUR_PASSWORD",
+          "key"       => "YOUR_API_KEY",
+          "checks"    => ["CHECK_ID_1","CHECK_ID_2"]
+        },
+        "graphite"  => {
+          "host"  => "YOUR_SERVER",
+          "port"    => "2003",
+          "prefix"  => "pingdom"
+        }  
+      }
+      File.open(File.expand_path(options.config),"w",0600) do |f|
+        f.write(JSON.pretty_generate(settings))
+      end
+
+    end
+
+  end
+
+  desc "init_checks", "Add all your checks to your config. (Will overwrite existing list.)"
+  def init_checks
+    load_config!
+    load_check_list!
+    @config["pingdom"]["checks"] = @checks.keys
+    File.open(File.expand_path(options.config),"w",0600) do |f|
+      f.write(JSON.pretty_generate(@config))
+    end
+    puts "Added #{@checks.count} checks to #{options.config}"
+  end
+
+  desc "advice", "Gives you some advice about update frequency."
+  def advice
+    load_config!
+    total_checks = @config["pingdom"]["checks"].count
+    calls_per_check = 2 + (total_checks)
+    puts "You have #{total_checks} monitored checks. Given a 48000/day API limit:"
+    every_minutes = 5
+    begin
+      daily_calls = 60*24 / every_minutes * calls_per_check
+      puts "Every #{every_minutes} Minutes: #{daily_calls}/day - #{daily_calls < 48000 ? "WORKS" : "won't work"}"
+      every_minutes += 5
+    end until (daily_calls < 48000)
+  end
+
+  desc "list", "List all your available Pingdom checks."
+  def list
+    load_check_list!
+    @checks.each do |check_id, check|
+      puts "#{check.name} (#{check.id}) - #{check.status}"
+    end
+  end
+
+  desc "probes", "List all the pingdom probes."
+  def probes
+    load_probe_list!
+    @probes.each do |probe_id, probe|
+      puts "#{probe.countryiso} - #{probe.city}"
+    end
+  end
+
+  desc "results [CHECK_ID]", "List results for a specific check. The Pingdom API limits results to 100."
+
+  method_option :start_time,
+                :desc     => "Beginning time for the checks, in any format supported by ruby's Time.parse(). Default will give you the last hour of checks.",
+                :type     => :string,
+                :aliases  => "-b"
+
+  method_option :end_time,
+                :desc     => "End time for the checks, in any format supported by ruby's Time.parse(). Default to right now.",
+                :aliases  => "-e"
+
+  def results(check_id)
+    load_config!
+    load_probe_list!
+    start_time = (options.start_time) ? DateTime.parse(options.start_time).to_i : 1.hour.ago.to_i
+    end_time = (options.end_time) ? DateTime.parse(options.end_time).to_i : DateTime.now.to_i
+    if start_time - end_time > 2764800
+      error("Date range must be less then 32 days.")
+    end
+    datapull = get_datapull
+    datapull.results(check_id, start_time, end_time).each do |result|
+      #<Pingdom::Result probeid: 33 time: 1343945109 status: "up" responsetime: 1103 statusdesc: "OK" statusdesclong: "OK">
+      puts "#{Time.at(result.time)}: #{result.status} - #{result.responsetime}ms (#{@probes[result.probeid].name})"
+    end
+    puts datapull.friendly_limit
+  end
+
+
+  desc "update", "Attempt to bring the checks defined in your config file up to date in graphite. If a check has never been polled before it will start with the last 100 checks."
+  def update
+    load_config!
+    load_state!
+    load_probe_list!
+    load_check_list!
+    datapull = get_datapull
+
+    @config["pingdom"]["checks"].each do |check_id|
+      puts "Check #{check_id}: " if options.verbose
+      # Check the state file
+      check_state = @state.has_key?(check_id.to_s) ? @state[check_id.to_s] : Hash.new
+      latest_ts = check_state.has_key?("latest_ts") ? check_state["latest_ts"] : 1.hour.ago.to_i
+      new_records = pull_and_push(check_id, latest_ts)
+      puts "#{new_records} metrics sent to graphite for check #{check_id}."
+    end
+    puts datapull.friendly_limit
+  end
+
+  desc 'backfill [CHECK_ID]', "Work backwards from the oldest check send to graphite, grabbing more historical data."
+
+  method_option :limit,
+                :desc     => "Number of API calls to use while backfilling. If you don't provide one, I'll ask!",
+                :type     => :numeric,
+                :aliases  => "-l"
+
+  def backfill(check_id)
+    load_config!
+    load_state!
+    # Check the state file
+    if @state.has_key?(check_id) && @state[check_id].has_key?("earliest_ts")
+      earliest_ts = @state[check_id.to_s]["earliest_ts"]
+    else 
+      error("You can't backfill a check you've never run an update on.")
+    end
+    load_probe_list!
+    load_check_list!
+    datapull = get_datapull
+    chunk = 10
+    unless limit = options.limit
+      limit = ask("You have #{datapull.effective_limit} API calls remaining. How many would you like to use?").to_i
+    end
+    created_ts = datapull.check(check_id).created
+    
+    # Keep within the API limits 
+    working_towards = (earliest_ts - created_ts) > 2678400 ? 31.days.ago.to_i : created_ts
+    puts "Backfilling from #{Time.at(earliest_ts)} working towards #{Time.at(working_towards)}. Check began on #{Time.at(created_ts)}"
+    # Break it into chunks
+    additions = 0
+    (limit.to_i.div(chunk)+1).times do
+      batch_count = pull_and_push(check_id, working_towards, earliest_ts, chunk)
+      puts "#{batch_count} metrics pushed in this batch." if options.verbose
+      additions += batch_count
+    end
+    puts "#{additions} metrics sent to graphite for check #{check_id}."
+  end
+
+  private
+
+  def get_datapull
+    if @datapull.nil?
+      load_config!
+      @datapull = PingdomToGraphite::DataPull.new(@config["pingdom"]["username"], @config["pingdom"]["password"], @config["pingdom"]["key"], log_level)
+    end
+    @datapull
+  end
+
+  def get_datapush
+    load_config!
+    datapush = PingdomToGraphite::DataPush.new(@config["graphite"]["host"], @config["graphite"]["port"])
+  end
+
+  def load_config!
+    if @config.nil?
+      config_file = File.expand_path(options.config)
+      unless File.exists?(config_file) 
+        error("Missing config file (#{options.config})")
+      end
+
+      @config = JSON::parse(File.read(config_file));
+    end
+
+  end
+
+  def load_state!
+    state_file = File.expand_path(options.state)
+    if File.exists?(state_file)
+      @state = JSON::parse(File.read(state_file))
+    else
+      @state = Hash.new
+    end
+  end
+
+  # Write the state to disk
+  def write_state!
+    state_file = File.expand_path(options.state)
+    File.open(state_file,"w",0600) do |f|
+      f.write(JSON.generate(@state))
+    end
+  end
+
+
+  # Store the list in the object for reference (less api calls)
+  def load_probe_list!
+    config_file = File.expand_path(options.config)
+    datapull = get_datapull
+    @probes = Hash.new
+    datapull.probes.each do |probe|
+      # {"city"=>"Manchester", "name"=>"Manchester, UK", "country"=>"United Kingdom",
+      # "countryiso"=>"GB", "id"=>46, "ip"=>"212.84.74.156", "hostname"=>"s424.pingdom.com", "active"=>true}
+      @probes[probe.id] = probe
+    end
+  end
+
+  # Store the check list in the object for reference (less api calls)
+  def load_check_list!
+    load_config!
+    datapull = get_datapull
+    @checks = Hash.new
+    datapull.checks.each do |check|
+      # {"name"=>"Autocomplete", "id"=>259103, "type"=>"http", "lastresponsetime"=>203173, 
+      #  "status"=>"up", "lasttesttime"=>1298102416}
+      @checks[check.id] = check
+    end
+  end
+
+  # Take a pingdom check, and return an Array of metrics to be passed to graphite
+  def parse_result(check_id, result)
+    results = Array.new
+    prefix = "#{@config["graphite"]["prefix"]}.#{@checks[check_id.to_i].type}."
+    prefix += @checks[check_id.to_i].name.gsub(/ /,"_").gsub(/\./,"")
+    check_status = result.status.eql?("up") ? 1 : 0
+    check_time = Time.at(result.time).to_i
+    check_city = @probes[result.probe_id].city.gsub(/ /,"_").gsub(/\./,"")
+    results << GraphiteMetric::Plaintext.new("#{prefix}.status.#{@probes[result.probe_id].countryiso}.#{check_city}", check_status, check_time)
+    results << GraphiteMetric::Plaintext.new("#{prefix}.responsetime.#{@probes[result.probe_id].countryiso}.#{check_city}", result.responsetime, check_time)
+    results.each { |metric| puts metric } if options.verbose
+    results
+  end
+
+  def pull_and_push(check_id, latest_ts = nil, earlist_ts = nil, limit = nil)
+    datapull = get_datapull
+    datapush = get_datapush
+    load_state!
+    # Check the state file
+    check_state = @state.has_key?(check_id.to_s) ? @state[check_id.to_s] : Hash.new
+    latest_stored = check_state.has_key?("latest_ts") ? check_state["latest_ts"] : nil
+    earliest_stored = check_state.has_key?("earliest_ts") ? check_state["earliest_ts"] : nil
+    # Pull the data
+    rec_count = 0
+    result_list = Array.new
+    datapull.full_results(check_id, latest_ts, earlist_ts, limit).each do |result|
+      result_list += parse_result(check_id, result)
+      latest_stored = result.time if latest_stored.nil? || result.time > latest_stored
+      earliest_stored = result.time if earliest_stored.nil? || result.time < earliest_stored
+      rec_count += 1
+    end
+    # Push to graphite
+    datapush.to_graphite(result_list) unless result_list.empty?
+    # Store the state
+    @state[check_id] = Hash.new
+    @state[check_id]["latest_ts"] = latest_stored
+    @state[check_id]["earliest_ts"] = earliest_stored
+    write_state!
+    rec_count
+  end
+
+  def error(message)
+    STDERR.puts "ERROR: #{message}"
+    exit 1
+  end
+
+  def log_level
+    options.verbose ? Logger::DEBUG : Logger::ERROR
+  end
+
+end

data/lib/pingdom-to-graphite/data-pull.rb

@@ -0,0 +1,97 @@
+require "pingdom-to-graphite"
+require "pingdom-client"
+
+require "logger"
+
+class PingdomToGraphite::DataPull
+
+  def initialize(username, password, key, log_level = Logger::ERROR)
+    @username   = username
+    @password   = password
+    @key        = key
+    @log_level  = log_level
+
+    @client = connect
+
+  end
+
+  # Return the lower of the two API limits
+  def effective_limit
+    # Catch-22: We want to maximize our API calls, but we don't have our limits until we make an API call.
+    unless @client.limit
+      @client.contacts
+    end
+    limit = @client.limit[:short][:remaining] > @client.limit[:long][:remaining] ? @client.limit[:long][:remaining] : @client.limit[:short][:remaining]
+  end
+
+  # A "Printer-friendly" version of the current limits
+  def friendly_limit
+    limit = @client.limit
+    short_time = Time.at(limit[:short][:resets_at] - Time.now).gmtime.strftime('%R:%S')
+    long_time = Time.at(limit[:long][:resets_at] - Time.now).gmtime.strftime('%R:%S')
+    "You can make #{limit[:short][:remaining]} requests in the next #{short_time} and #{limit[:long][:remaining]} requests in the next #{long_time}."
+  end
+
+  def checks
+    check_list = @client.checks
+  end
+
+  def check(id)
+    check_details = @client.check(id)
+  end
+
+  def probes
+    probe_list = @client.probes
+  end
+
+  def results(check_id, start_ts = nil, end_ts = nil, offset = nil)
+
+    check_options = {}
+
+    unless start_ts.nil?
+      check_options['from'] = start_ts
+    end
+
+    unless end_ts.nil?
+      check_options['to'] = end_ts
+    end
+
+    unless offset.nil?
+      check_options['offset'] = offset
+    end
+
+    results = @client.check(check_id).results(check_options)
+  end
+
+  # Get the full results for the range, looping over the API limits as necessary.
+  def full_results(check_id, start_ts, end_ts = nil, api_call_limit = 0)
+    offset = 0
+    full_set = Array.new
+    api_calls = 0
+    # Loop until we either grab the full data set, run out of API calls, or hit the first check
+    begin
+      api_calls += 1
+      result_set = self.results(check_id, start_ts, end_ts, offset)
+      full_set = full_set.concat(result_set)
+      offset += 100
+    end until result_set.count < 100 || effective_limit < 10 || api_calls >= api_call_limit.to_i
+    full_set
+  end
+
+
+  private
+
+  def connect
+    log = Logger.new(STDOUT)
+    log.level = @log_level
+    begin
+      client = Pingdom::Client.new :username => @username, :password => @password, :key => @key, :logger => log
+    rescue
+      error("There was a problem connecting to pingdom.")
+    end
+
+    client
+  end
+
+
+end

data/lib/pingdom-to-graphite/data-push.rb

@@ -0,0 +1,20 @@
+require "graphite-metric"
+require "socket"
+
+class PingdomToGraphite::DataPush
+
+  def initialize(graphite_host, graphite_port)
+    @graphite_host = graphite_host
+    @graphite_post = graphite_port
+  end
+
+  # Sent an array of graphite metrics to graphite
+  def to_graphite(metric_array)
+    graphite = TCPSocket.new(@graphite_host, @graphite_post)
+    metric_array.each do |metric|
+      graphite.puts metric.to_s
+    end
+    graphite.close
+  end
+
+end

data/lib/pingdom-to-graphite/version.rb

@@ -0,0 +1,3 @@
+module PingdomToGraphite
+  VERSION = "0.0.2"
+end

data/pingdom-to-graphite.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.expand_path("../lib", __FILE__)
+require "pingdom-to-graphite/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pingdom-to-graphite"
+  s.version     = PingdomToGraphite::VERSION
+  s.authors     = ["Lew Goettner"]
+  s.email       = ["lew@goettner.net"]
+  s.homepage    = "http://lewg.github.com/pingdom-to-graphite"
+  s.summary     = %q{A command line tool for pulling stats from pingdom and shipping them to graphite.}
+  s.description = %q{A tool for copying metrics from Pingdom to graphite. Pingdom, although 
+    allowing access to effectively all your metrics through the API, does have some limits 
+    in place to prevent abuse. This tool tries to be mindful of that, although does provide a 
+    "backfill" option if you care to burn up your daily api limit in one fell swoop.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "thor"
+  s.add_runtime_dependency "pingdom-client"
+  s.add_runtime_dependency "json"
+  s.add_runtime_dependency "graphite-metric"
+
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: pingdom-to-graphite
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Lew Goettner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pingdom-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: graphite-metric
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "A tool for copying metrics from Pingdom to graphite. Pingdom, although
+  \n    allowing access to effectively all your metrics through the API, does have
+  some limits \n    in place to prevent abuse. This tool tries to be mindful of that,
+  although does provide a \n    \"backfill\" option if you care to burn up your daily
+  api limit in one fell swoop."
+email:
+- lew@goettner.net
+executables:
+- pingdom-to-graphite
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/pingdom-to-graphite
+- features/copy.feature
+- features/step_definitions/copy_steps.rb
+- features/support/env.rb
+- lib/pingdom-to-graphite.rb
+- lib/pingdom-to-graphite/cli.rb
+- lib/pingdom-to-graphite/data-pull.rb
+- lib/pingdom-to-graphite/data-push.rb
+- lib/pingdom-to-graphite/version.rb
+- pingdom-to-graphite.gemspec
+homepage: http://lewg.github.com/pingdom-to-graphite
+licenses: []
+post_install_message: 
+rdoc_options: []
+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.24
+signing_key: 
+specification_version: 3
+summary: A command line tool for pulling stats from pingdom and shipping them to graphite.
+test_files: []
+has_rdoc: