airbrake_stats 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.3@airbrake_stats --create

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in airbrake_stats.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Nathan Witmer
+
+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 @@
+require "bundler/gem_tasks"

data/airbrake_stats.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "airbrake_stats/version"
+
+Gem::Specification.new do |s|
+  s.name        = "airbrake_stats"
+  s.version     = AirbrakeStats::VERSION
+  s.authors     = ["Tyler Montgomery"]
+  s.email       = ["tyler.a.montgomery@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Analyze Airbrake Errors}
+  s.description = %q{Pass in an Airbrake id to visualize and diagnose errors better.}
+
+  s.rubyforge_project = "airbrake_stats"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+   s.add_runtime_dependency "map"
+   s.add_runtime_dependency "nokogiri"
+   s.add_runtime_dependency "http"
+end

data/bin/airbrake_stats

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'airbrake_stats'
+
+ab_stats = AirbrakeStats::Parser.new(ARGV[0])
+
+
+# TODO load up info ahead of time like
+# ab_stats.fetch_data
+
+# print out the stats for the errors
+AirbrakeStats::Format.print(ab_stats.stats(:url), :url)
+AirbrakeStats::Format.print(ab_stats.stats(:path), :path)
+AirbrakeStats::Format.print(ab_stats.stats(:agent), :agent)
+AirbrakeStats::Format.print(ab_stats.stats(:format), :format)
+AirbrakeStats::Format.print(ab_stats.stats(:controller), :controller)
+AirbrakeStats::Format.print(ab_stats.stats(:error_message), :error_message)

data/lib/airbrake_stats.rb

@@ -0,0 +1,14 @@
+require 'map'
+require 'nokogiri'
+require 'http'
+require 'yaml'
+
+module AirbrakeStats
+  require "airbrake_stats/version"
+  require "airbrake_stats/cache"
+  require "airbrake_stats/format"
+  require "airbrake_stats/parser"
+  require "airbrake_stats/queue"
+end
+
+

data/lib/airbrake_stats/cache.rb

@@ -0,0 +1,32 @@
+class AirbrakeStats::Cache
+  attr_reader :error_id
+  def initialize(error_id)
+    @error_id = error_id
+  end
+
+  def store(errors)
+    File.open(filename, "w"){|f| f.write errors.to_yaml}
+  end
+
+  def load_errors
+    if File.exists?(filename) && !expired?
+      YAML.load_file(filename).map{|s| Map.new(s)}
+    end
+  end
+
+  def filename
+    "/tmp/airbrake_stats_#{error_id}.yml"
+  end
+
+  def expired?
+    expires_in <= 0
+  end
+
+  def expires_in
+    expires - (Time.now.to_i - File.mtime(filename).to_i)
+  end
+
+  def expires
+    900
+  end
+end

data/lib/airbrake_stats/format.rb

@@ -0,0 +1,20 @@
+class AirbrakeStats::Format
+  class << AirbrakeStats::Format
+    attr_reader :stats
+    def print(stats, method)
+      @stats = stats
+      method_width = width(method)
+      total_width = width('total')
+      puts
+      puts "#{method.to_s.center(method_width)} | total"
+      puts "#{''.ljust(method_width + 8, '-')}"
+      stats.each do |stat|
+        puts "#{stat[method].to_s.ljust(method_width)} | #{stat.total.to_s.rjust(total_width)}"
+      end
+    end
+
+    def width(method)
+      stats.inject(0){|r,s| r = s[method].to_s.length if s[method].to_s.length > r; r} 
+    end
+  end
+end

data/lib/airbrake_stats/parser.rb

@@ -0,0 +1,156 @@
+# TODO cleanup this class, Parser is kind of a bad name.
+# I'm thinking the http stuff could go in its own class
+# and the xml parsing can still happen here.
+#
+# TODO Also these methods need more documentation. I think 
+# some refactoring will naturally fallout of writing
+# docs.
+class AirbrakeStats::Parser
+  attr_accessor :error_id
+  attr_reader :max_pages
+  attr_reader :cache
+  class Error < StandardError; end;
+
+  def initialize(error_id)
+    @error_id = error_id
+    @max_pages = Integer((ENV['MAX_PAGES'] || 10))
+    @cache = AirbrakeStats::Cache.new(error_id)
+  end
+
+  def similar_errors
+
+    return @similar_errors if @similar_errors
+    if @similar_errors = cache.load_errors
+      puts "Loaded cached errors from #{cache.filename} (will expire in #{cache.expires_in/60} minutes)"
+      return @similar_errors
+    end
+    @similar_errors = notices_xml.map do |notice|
+      agent = notice.search('http-user-agent').first
+      if agent
+        # TODO better user agent parsing, but this is good enough to see if
+        # errors are caused by bots or "humans"
+        agent = "#{agent[2]} #{agent[3]}" 
+      end
+      id = parse_xml(notice, 'id')
+      url = parse_xml(notice, 'url')
+      format = parse_xml(notice, 'format')
+      path = parse_xml(notice, 'request-path')
+      controller = parse_xml(notice, 'controller')
+      error_message = parse_xml(notice, 'error-message')
+      action = parse_xml(notice, 'action')
+      controller = "#{controller}##{action}"
+      #next unless url && agent && path && format
+      Map.new(id: id, path: path, format: format, error_message: error_message, url: url, agent: agent, controller: controller )
+    end.compact
+    cache.store(@similar_errors)
+    if @similar_errors.empty?
+      puts "no notices had any data"
+      puts notices_xml.map{|n| n.search('error-message').first.text}.uniq
+    else
+      cache.store(@similar_errors)
+    end
+    @similar_errors
+  end
+
+  # Just grab and parse /errors/#{error_id}.xml
+  def error
+    @error ||= parse('')
+  end
+
+  def parse_xml(notice, element)
+    node = notice.search(element).first
+    node.text if node 
+  end
+
+  # Count up the occurance of either:
+  # - path
+  # - format
+  # - url
+  # - agent
+  # Will return an Array of Maps sorted from lowest to highest occurance
+  def stats(method)
+    stats = Hash.new(0)
+    similar_errors.each{|n| stats[n[method]] += 1}
+    stats = stats.map do |p| 
+      h = {total: p.last} 
+      h[method] = p.first
+      Map.new(h)
+    end.sort_by(&:total)
+  end
+
+  # Integer representing the ammount of  pages of errors. Based on Aibrake's docs
+  # that state they return 30 errors per request, so we divide the total number of 
+  # errors by 30 to get our number of pages
+  def page_count
+    @page_count = notices_count/30 + 1
+    @page_count = max_pages if @page_count > max_pages
+    @page_count
+  end
+
+  def max_errors
+    page_count * 30
+  end
+
+  # An Integer representing the number of other similar errors
+  def notices_count
+    @notices_count ||= error.search('notices-count').first.text.to_i
+  end
+
+  private
+
+  def similar_error_ids
+    return @similar_error_ids if @similar_error_ids
+    @similar_error_ids = []
+    puts "Getting #{page_count} pages of errors."
+    page_count.times do |page|
+      page += 1
+      errors = parse('/notices', page)
+      @similar_error_ids << errors.search('id').map(&:text)
+    end
+    @similar_error_ids.flatten!
+    if @similar_error_ids.length == max_errors
+      puts "Found #{notices_count} similar errors but only using the #{max_errors} most recent."
+    else
+      puts "Found #{notices_count} similar errors."
+    end
+    @similar_error_ids
+  end
+
+  def notices_xml
+    similar_error_ids
+    notices_xml = AirbrakeStats::Queue.new
+    puts "Downloading errors..."
+    threads = []
+    # TODO sometimes this craps out. Ususally when we ask for pages > 20
+    similar_error_ids.each_slice(4) do |slice|
+      threads << Thread.new(slice) do |ids|
+        ids.each_with_index do |id, index|
+          # print "#{index}/#{notices_count}\r"; $stdout.flush
+          notices_xml << parse("/notices/#{id}")
+        end
+      end
+    end
+    threads.map(&:join)
+    puts notices_xml.size
+    notices_xml.to_a
+  end
+
+  def url
+    @url ||= "https://#{ENV['AIRBRAKE_HOST']}.airbrake.io/errors/#{error_id}"
+  end
+
+  def parse(path, page = nil)
+    params = "?auth_token=#{ENV['AIRBRAKE_TOKEN']}"
+    params << "&page=#{page}" if page
+    # puts "#{url}#{path}.xml#{params}"
+    response = Http.get("#{url}#{path}.xml#{params}", response: :object)
+    parsed_response = Nokogiri::XML(response.body)
+    if response.status == 200
+      return parsed_response
+    else
+      error = parsed_response.search('error').first
+      raise AirbrakeStats::Error.new("#{response.status}: #{error}")
+    end
+  end
+
+end

data/lib/airbrake_stats/queue.rb

@@ -0,0 +1,7 @@
+class AirbrakeStats::Queue < Queue
+  def to_a
+    array = []
+    self.size.times{array << self.pop}
+    array
+  end
+end

data/lib/airbrake_stats/version.rb

@@ -0,0 +1,3 @@
+module AirbrakeStats
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: airbrake_stats
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tyler Montgomery
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: map
+  requirement: &70336011963120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70336011963120
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &70336011962520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70336011962520
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: &70336011961880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70336011961880
+description: Pass in an Airbrake id to visualize and diagnose errors better.
+email:
+- tyler.a.montgomery@gmail.com
+executables:
+- airbrake_stats
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE
+- Rakefile
+- airbrake_stats.gemspec
+- bin/airbrake_stats
+- lib/airbrake_stats.rb
+- lib/airbrake_stats/cache.rb
+- lib/airbrake_stats/format.rb
+- lib/airbrake_stats/parser.rb
+- lib/airbrake_stats/queue.rb
+- lib/airbrake_stats/version.rb
+homepage: ''
+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: airbrake_stats
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Analyze Airbrake Errors
+test_files: []