pagerduty_tools 0.3.0

data/lib/pagerduty_tools.rb

@@ -0,0 +1,4 @@
+require "pagerduty_tools/campfire"
+require "pagerduty_tools/pagerduty"
+require "pagerduty_tools/report"
+require "pagerduty_tools/version"

data/lib/pagerduty_tools/campfire.rb

@@ -0,0 +1,86 @@
+# Copyright 2011 Marc Hedlund <marc@precipice.org>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# campfire.rb -- Totally stupid Campfire API client
+#
+# This is the simplest possible Campfire client, intended just
+# to set the topic in a Campfire room, and nothing else.
+#
+# Adapted from https://gist.github.com/7cefe083682cdd3e4e10
+#
+# To make this work, add a configuration file at ~/.pagerduty-campfire.yaml
+# containing the following:
+#
+#     site:  https://example.campfirenow.com
+#     room:  99999
+#     token: abababababababababababababababababababab
+#
+# (with the values changed to match your configuration).
+
+require 'net/http'
+require 'nokogiri'
+require 'uri'
+require 'yaml'
+
+CONFIG_FILE = "~/.pagerduty-campfire.yaml"
+CA_FILE     = "#{File.dirname(__FILE__)}/cacert.pem"
+
+module Campfire
+  class Bot
+    def initialize
+      # TODO: make sure that the file is there and that all the keys are, too.
+      config = YAML.load_file(File.expand_path(CONFIG_FILE))
+      @uri   = URI.parse config["site"]
+      @room  = config["room"]
+      @token = config["token"]
+      @pass  = 'x'
+
+      @http             = Net::HTTP.new(@uri.host, @uri.port)
+      @http.use_ssl     = true
+      @http.ca_file     = File.expand_path(CA_FILE)
+      @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    end
+
+    def topic(topic)
+      request = Net::HTTP::Put.new "/room/#{@room}.xml"
+      message = Nokogiri::XML::Builder.new do |xml|
+        xml.room {
+          xml.topic topic
+        }
+      end
+      return do_request(request, message.to_xml)
+    end
+
+    def paste(body)
+      request = Net::HTTP::Post.new("/room/#{@room}/speak.xml")
+      message = Nokogiri::XML::Builder.new do |xml|
+        xml.message {
+          xml.type_ "PasteMessage"
+          xml.body body
+        }
+      end
+      return do_request(request, message.to_xml)
+    end
+
+    private
+
+    def do_request(request, message)
+      @http.start do |connection|
+        request['Content-Type'] = 'application/xml'
+        request.basic_auth @token, @pass
+        return connection.request(request, message)
+      end
+    end
+  end
+end

data/lib/pagerduty_tools/pagerduty.rb

@@ -0,0 +1,248 @@
+# Copyright 2011 Marc Hedlund <marc@precipice.org>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# pagerduty.rb -- tools for working with data from the PagerDuty site.
+#
+# PagerDuty does provide an API, but it is fairly limited. This code is
+# intended to make it look like the API was more extensive and could
+# provide some better reporting options.
+
+require 'nokogiri'
+require 'mechanize'
+require 'highline/import'
+
+require "#{File.dirname(__FILE__)}/report"
+
+COOKIE_FILE     = "~/.pagerduty-cookies"
+EMAIL_PROMPT    = "PagerDuty account email address: "
+PASSWORD_PROMPT = "PagerDuty password: "
+ACCOUNT_PROMPT  = "Select your PagerDuty domain: "
+
+module PagerDuty
+  class Agent
+    attr_accessor :domain
+
+    def initialize
+      # Works around a bug in highline, producing "input stream exhausted" errors. See:
+      # http://groups.google.com/group/comp.lang.ruby/browse_thread/thread/939d9f86a18e6f9e/ec1c3f1921cd66ea
+      HighLine.track_eof = false
+
+      @cookie_file = File.expand_path(COOKIE_FILE)
+      @agent       = Mechanize.new
+
+      load_cookies
+      find_domain
+    end
+
+    def fetch(path)
+      uri  = URI.parse "https://#{@domain}#{path}"
+      page = @agent.get uri
+
+      # If we asked for a page and didn't get it, we probably have to log in.
+      # TODO: check for non-login pages, like server error pages.
+      while page.uri.path != uri.path
+        page = login page
+      end
+
+      if @cookie_file
+        @agent.cookie_jar.save_as(@cookie_file)
+        File.chmod(0600, @cookie_file)
+      end
+
+      return page
+    end
+
+    private
+
+    def load_cookies
+      if File.exist?(@cookie_file)
+        @agent.cookie_jar.load(@cookie_file)
+
+        # Try to find the user's PagerDuty domain from their auth_token cookie.
+        token = @agent.cookie_jar.to_a.select { |cookie| cookie.name == "auth_token" }.first
+
+        if token
+          @domain = token.domain
+        end
+      end
+    end
+
+    def find_domain
+      return if @domain
+
+      @email = ask(EMAIL_PROMPT)
+
+      accounts_search_page = @agent.get URI.parse "http://app.pagerduty.com/accounts/search"
+      accounts_search_form = accounts_search_page.form_with(:action => "/accounts/search_results")
+      accounts_search_form.email = @email
+
+      search_results_page = accounts_search_form.submit
+      search_results = Nokogiri::HTML(search_results_page.body)
+      account_list = search_results.css("ul.accounts_list")
+      domains = account_list.css("a").map { |account| URI.parse(account["href"]).host }
+
+      if domains.count == 0
+        puts "No PagerDuty accounts found for that address."
+      elsif domains.count == 1
+        @domain = domains.first
+      else
+        say(ACCOUNT_PROMPT)
+        @domain = choose(*domains)
+      end
+    end
+
+    def login(page)
+      login_form = page.form_with(:action => "/session")
+      @email   ||= ask(EMAIL_PROMPT)
+
+      login_form.email    = @email
+      login_form.password = ask(PASSWORD_PROMPT) {|q| q.echo = "*" }
+
+      return login_form.submit
+    end
+  end
+
+  class Escalation
+    def initialize(levels=nil, policy = nil)
+      @levels = levels
+      @policy = policy
+    end
+
+    def parse(dashboard_body)
+      # Scrape out the on-call list from the Dashboard HTML.
+      policies = Nokogiri::HTML(dashboard_body).css("div.whois_oncall")
+
+      oncall = if @policy
+                 policies.detect do |policy|
+                   policy.css('h4 a').text == @policy
+                 end
+               else
+                 policies.first
+               end
+
+      @results = []
+
+      oncall.css("div").each do |div|
+        level_text = div.css("span > strong").text
+        level_text =~ /Level (\d+)\:/
+        level = $1
+
+        # PagerDuty sometimes adds a comment saying what the rotation is called
+        # for this level. If it's there, use it, or fall back to a generic label.
+        label_text = div.xpath("span/comment()").text
+        label = label_text[/\(<[^>]+>(.+) on-call<\/a>\)/, 1] || "Level #{level}"
+
+        person = div.css("span > a")
+
+        start_time, end_time = div.css("span.time").text.split(" - ").map {|text| text.strip }
+
+        if @levels == nil or @levels.length == 0 or @levels.include?(level)
+          @results << {
+                        'level' => level,
+                        'label' => label,
+                        'person' => person.text,
+                        'person_path' => person.first['href'],
+                        'start_time' => start_time,
+                        'end_time' => end_time
+                      }
+        end
+      end
+
+      return @results
+    end
+
+    def label_for_level(level)
+      @results.find {|result| result['level'] == level }['label']
+    end
+
+    def label_for_person(person)
+      @results.find {|result| result['person'] == person }['label']
+    end
+
+    def level_for_person(person)
+      @results.find {|result| result['person'] == person }['level']
+    end
+  end
+
+  class Alert < Report::Item
+    attr_accessor :type, :user
+
+    def initialize(time, type, user)
+      # This charming little chunk works around an apparent bug in Chronic:
+      # if the parsed month is the same as the current month, :context =>
+      # :past will fail to set the month correctly.  (Looks like
+      # 'if @now.month > target_month' on line 28 of
+      # chronic-0.3.0/lib/chronic/repeaters/repeater_month_name.rb
+      # should be 'if @now.month >= target_month'.) Anyway, there, I
+      # fixed it.
+      if time.start_with?(Time.now.strftime("%b"))
+        super(Chronic.parse(time))
+      else
+        super(Chronic.parse(time, :context => :past))
+      end
+      @type = type
+      @user = user
+    end
+
+    def phone_or_sms?
+      type == "Phone" or type == "SMS"
+    end
+
+    def email?
+      type == "Email"
+    end
+  end
+
+  class Incident < Report::Item
+    attr_accessor :status, :resolver, :service, :trigger, :event
+
+    def initialize(incident)
+      super(Time.xmlschema(incident['created_on']))
+      @status  = incident['status']
+      @service = incident['service']['name']
+      @trigger = incident['trigger_details']
+      @event   = incident['trigger_details']['event']
+
+      if status == 'resolved'
+        if incident['resolved_by'].nil? # nil resolvers are automatic, e.g. Nagios
+          @resolver = "[Automatic]"
+        else
+          @resolver = incident['resolved_by']['name']
+        end
+      end
+    end
+
+    def resolved?
+      status == 'resolved'
+    end
+
+    def trigger_name
+      if trigger['type'] == 'nagios_trigger'
+        return "#{service}: #{event['host']} - #{event['service']}"
+      else
+        return "#{service}: #{event['description']}"
+      end
+    end
+  end
+
+  class Person
+    attr_accessor :email
+    
+    def parse page_body
+      user = Nokogiri::HTML(page_body).css("div#user_profile").first
+      div = user.css("div").first
+      @email = div.css("td > a").text
+    end
+  end
+end

data/lib/pagerduty_tools/report.rb

@@ -0,0 +1,127 @@
+# Copyright 2011 Marc Hedlund <marc@precipice.org>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# report.rb - basic tool for building up reports.
+
+require 'chronic'
+
+module Report
+  class Item
+    attr_accessor :time
+
+    def initialize(time)
+      @time = time
+    end
+
+    def between?(start_time, end_time)
+      time >= start_time and time < end_time
+    end
+
+    def off_hours?
+      # Outside normal work hours - 6p to 8a (localtime)
+      time.hour >= 18 or graveyard?
+    end
+
+    def graveyard?
+      # Worst of the worst - midnight to 8am (localtime)
+      time.hour < 8
+    end
+  end
+
+  class Summary
+    attr_accessor :current_start, :current_end, :previous_start, :previous_end
+
+    def initialize(current_start, current_end, previous_start, previous_end)
+      @current_start  = current_start
+      @current_end    = current_end
+      @previous_start = previous_start
+      @previous_end   = previous_end
+      @items          = []
+    end
+
+    def <<(item)
+      @items << item
+    end
+
+    def current_items
+      select_between?(current_start, current_end)
+    end
+
+    def previous_items
+      select_between?(previous_start, previous_end)
+    end
+
+    def current_count(&selector)
+      count_from(current_items, &selector)
+    end
+
+    def previous_count(&selector)
+      count_from(previous_items, &selector)
+    end
+
+    def current_summary(&selector)
+      summarize(current_items, &selector)
+    end
+
+    def previous_summary(&selector)
+      summarize(previous_items, &selector)
+    end
+
+    def pct_change(&selector)
+      old_value = previous_count(&selector)
+      new_value = current_count(&selector)
+      Report.pct_change old_value, new_value
+    end
+
+    private
+
+    def summarize(collection)
+      summary = Hash.new(0)
+
+      collection.each do |item|
+        yield item, summary
+      end
+
+      return summary.sort {|a, b| b[1] <=> a[1] }
+    end
+
+    def count_from(collection)
+      if block_given?
+        return collection.count {|item| yield item }
+      else
+        return collection.count
+      end
+    end
+
+    def select_between?(a, b)
+      @items.select {|item| item.between?(a, b) }
+    end
+  end
+
+  def self.pct_change(old_value, new_value)
+    if old_value == 0
+      return "no occurrences last week"
+    else
+      change = (((new_value.to_f - old_value.to_f) / old_value.to_f) * 100).to_i
+
+      if change == 0
+        return "no change vs. last week"
+      elsif change < 0
+        return "#{change}% vs. last week"
+      else
+        return "+#{change}% vs. last week"
+      end
+    end
+  end
+end