error_stalker 0.0.12

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,30 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in error_stalker.gemspec
+gemspec
+
+group :server do
+  gem 'sinatra', '~>1.1.2'
+  gem 'vegas', '~>0.1.8'
+  gem 'thin', '~>1.2.7'
+end
+
+group :mongoid_store do
+  gem 'mongoid', '2.0.0.beta.20'
+end
+
+group :test do
+  gem 'rack-test', '~>0.5.7'
+  gem 'mocha', '~>0.9.10'
+end
+
+group :lighthouse_reporter do
+  gem 'lighthouse-api', '2.0'
+  gem 'addressable', '~>2.2.2'
+end
+
+group :email_sender do
+  gem 'mail', '~>2.2.15'
+end
+
+gem 'json', '1.4.6', :platforms => :ruby_18

data/Gemfile.lock

@@ -0,0 +1,76 @@
+PATH
+  remote: .
+  specs:
+    error_stalker (0.0.12)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activeresource (3.0.3)
+      activemodel (= 3.0.3)
+      activesupport (= 3.0.3)
+    activesupport (3.0.3)
+    addressable (2.2.2)
+    bson (1.2.0)
+    builder (2.1.2)
+    daemons (1.1.0)
+    eventmachine (0.12.10)
+    i18n (0.5.0)
+    json (1.4.6)
+    lighthouse-api (2.0)
+      activeresource (>= 3.0.0)
+      activesupport (>= 3.0.0)
+    mail (2.2.15)
+      activesupport (>= 2.3.6)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.16)
+    mocha (0.9.10)
+      rake
+    mongo (1.2.0)
+      bson (>= 1.2.0)
+    mongoid (2.0.0.beta.20)
+      activemodel (~> 3.0)
+      mongo (~> 1.1)
+      tzinfo (~> 0.3.22)
+      will_paginate (~> 3.0.pre)
+    polyglot (0.3.1)
+    rack (1.2.1)
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    rake (0.8.7)
+    sinatra (1.1.2)
+      rack (~> 1.1)
+      tilt (~> 1.2)
+    thin (1.2.7)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    tilt (1.2.1)
+    treetop (1.4.9)
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.24)
+    vegas (0.1.8)
+      rack (>= 1.0.0)
+    will_paginate (3.0.pre2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  addressable (~> 2.2.2)
+  error_stalker!
+  json (= 1.4.6)
+  lighthouse-api (= 2.0)
+  mail (~> 2.2.15)
+  mocha (~> 0.9.10)
+  mongoid (= 2.0.0.beta.20)
+  rack-test (~> 0.5.7)
+  sinatra (~> 1.1.2)
+  thin (~> 1.2.7)
+  vegas (~> 0.1.8)

data/README.rdoc

@@ -0,0 +1,3 @@
+= Exception Logger
+
+As the name says, this library allows you to log exceptions to an arbitrary backend.

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler'
+require 'rake/testtask'
+require 'rake/rdoctask'
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+task :build => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  rd.rdoc_dir = 'doc'
+end

data/bin/create_indexes

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../lib/error_stalker/server', File.dirname(__FILE__))
+
+ENV['RACK_ENV'] ||= 'development'
+
+if ARGV.length != 1
+  puts "Usage: create_indexes </path/to/error_stalker/config.yml>"
+  exit(1)
+end
+
+ErrorStalker::Server.configuration = YAML.load(File.read(ARGV[0]))[ENV['RACK_ENV']]
+store = ErrorStalker::Server.store
+store.create_indexes if store.respond_to?(:create_indexes)

data/bin/error_stalker_server

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../lib/error_stalker/server', File.dirname(__FILE__))
+require 'vegas'
+ENV['RACK_ENV'] ||= 'development'
+
+Vegas::Runner.new(ErrorStalker::Server, 'error_stalker_server', {
+   :foreground => true,
+   :before_run => lambda {|v|
+     config_file = ENV['ERROR_STALKER_CONFIG'] || v.args.first
+     if config_file
+       params = YAML.load(File.read(config_file))[ENV['RACK_ENV']]
+       ErrorStalker::Server.configuration = params
+     end
+   }
+ })

data/error_stalker.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "error_stalker/version"
+
+Gem::Specification.new do |s|
+  s.name        = "error_stalker"
+  s.version     = ErrorStalker::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Justin Weiss"]
+  s.email       = ["jweiss@avvo.com"]
+  s.homepage    = ""
+  s.summary     = %q{Logs exceptions to a pluggable backend and/or a pluggable store}
+  s.description = %q{Logs exceptions to a pluggable backend. Also provides a server for centralized exception logging using a pluggable data store.}
+
+  s.rubyforge_project = "error_stalker"
+
+  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"]
+end

data/lib/error_stalker.rb

@@ -0,0 +1,4 @@
+module ErrorStalker # :nodoc:
+end
+
+require 'error_stalker/client'

data/lib/error_stalker/backend.rb

@@ -0,0 +1,14 @@
+# ErrorStalker backends are objects representing a place that
+# ErrorStalker::Client sends exceptions to. A backend simply needs to
+# inherit from ErrorStalker::Backend::Base and override the +report+
+# method, after which they can be set using the
+# ErrorStalker::Client.backend attribute. 
+#
+# The default backend is an ErrorStalker::Backend::LogFile instance,
+# which logs exception data to a file.
+module ErrorStalker::Backend
+  autoload :Base, 'error_stalker/backend/base'
+  autoload :InMemory, 'error_stalker/backend/in_memory'
+  autoload :LogFile, 'error_stalker/backend/log_file'
+  autoload :Server, 'error_stalker/backend/server'
+end

data/lib/error_stalker/backend/base.rb

@@ -0,0 +1,14 @@
+module ErrorStalker::Backend
+
+  # The base class for exception logger backends. All backends should
+  # inherit from this class and implement the +report+ method.
+  class Base
+    
+    # Store an exception report into this backend. Subclasses should
+    # override this method. +exception_report+ is an
+    # ErrorStalker::ExceptionReport instance.
+    def report(exception_report)
+      raise NotImplementedError, "This method must be overridden in subclasses"
+    end
+  end
+end

data/lib/error_stalker/backend/in_memory.rb

@@ -0,0 +1,25 @@
+# Provides an in-memory backend that stores all exception reports in
+# an array. This is mostly useful for tests, and probably shouldn't be
+# used in real code.
+class ErrorStalker::Backend::InMemory < ErrorStalker::Backend::Base
+
+  # A list of exceptions stored in this backend.
+  attr_reader :exceptions
+
+  # Create a new instance of this backend, with an empty exception
+  # list.
+  def initialize
+    clear
+  end
+
+  # Stores exception_report in the exceptions list.
+  def report(exception_report)
+    @exceptions << exception_report
+  end
+
+  # Clears the exception list. Pretty useful in a test +setup+ method!
+  def clear
+    @exceptions = []
+  end
+
+end

data/lib/error_stalker/backend/log_file.rb

@@ -0,0 +1,33 @@
+require 'yaml'
+
+# A backend that logs all exception reports to a file. This is
+# probably what you want to be running in development mode, and is
+# also the default backend.
+class ErrorStalker::Backend::LogFile < ErrorStalker::Backend::Base
+
+  # The name of the file containing the exception reports
+  attr_reader :filename
+
+  # Creates a new LogFile backend that will log exceptions to +filename+
+  def initialize(filename)
+    @filename = filename
+  end
+
+  # Writes the information contained in +exception_report+ to the log
+  # file specified when this backend was initialized.
+  def report(exception_report)
+    File.open(filename, 'a') do |file|
+      file.puts "Machine: #{exception_report.machine}"
+      file.puts "Application: #{exception_report.application}"
+      file.puts "Timestamp: #{exception_report.timestamp}"
+      file.puts "Type: #{exception_report.type}"
+      file.puts "Exception: #{exception_report.exception}"
+      file.puts "Data: #{YAML.dump(exception_report.data)}"
+      if exception_report.backtrace
+        file.puts "Stack trace:"
+        file.puts exception_report.backtrace.join("\n")
+      end
+      file.puts
+    end
+  end
+end

data/lib/error_stalker/backend/server.rb

@@ -0,0 +1,41 @@
+require 'json'
+require 'net/http'
+
+# Stores reported exceptions to a central ErrorStalker server (a Rack
+# server pointing to an ErrorStalker::Server instance). The most
+# complicated ErrorStalker backend, it is also the most powerful. This
+# is probably what you want to be using in production.
+class ErrorStalker::Backend::Server < ErrorStalker::Backend::Base
+
+  # The hostname of the ErrorStalker server
+  attr_accessor :host
+
+  # The ErrorStalker server's port
+  attr_accessor :port
+
+  # http or https
+  attr_accessor :protocol
+
+  # The path of the ErrorStalker server, if applicable
+  attr_accessor :path 
+  
+  # Creates a new Server backend instance that will report exceptions
+  # to a centralized ErrorStalker server.
+  def initialize(params = {})
+    @protocol = params[:protocol] || 'http://'
+    @host = params[:host] || 'localhost'
+    @port = params[:port] || '5678'
+    @path = params[:path] || ''
+  end
+
+  # Reports +exception_report+ to a central ErrorStalker server.
+  def report(exception_report)
+    req = Net::HTTP::Post.new("#{path}/report.json")
+    req["content-type"] = "application/json"
+    req.body = exception_report.to_json
+    http = Net::HTTP.new(host, port)
+    http.read_timeout = 10
+    res = http.start { |http| http.request(req) }
+    res
+  end
+end

data/lib/error_stalker/client.rb

@@ -0,0 +1,62 @@
+require 'error_stalker/exception_report'
+require 'error_stalker/backend'
+require 'tempfile'
+
+# The error_stalker client enables you to log exception data to a
+# backend. The class method ErrorStalker::Client.report is usually the
+# method you want to use out of this class, although for those who
+# like block syntax, this class also provides a +report_exceptions+
+# method that reports all exceptions raised inside a block.
+class ErrorStalker::Client
+
+  # Sets the backend the client will use to report exceptions to
+  # +new_backend+, an ErrorStalker::Backend instance. By default,
+  # exceptions are logged using ErrorStalker::Backend::LogFileBackend.
+  def self.backend=(new_backend)
+    @backend = new_backend
+  end
+
+  # Report an exception to the exception logging backend.
+  #
+  # * application_name: A tag representing the name of the app that
+  #   this exception occurred in. This is used for advanced filtering
+  #   on the server, if the server backend is used.
+  #
+  # * exception: The exception object that was thrown. This can also
+  #   be a string, but you won't get information like the backtrace if
+  #   you don't pass an actual exception subclass.
+  #
+  # * extra_data: A hash of additional data to log with the
+  #   exception. Depending on which backend the server uses, this may
+  #   or may not be indexable.
+  def self.report(application_name, exception, extra_data = {})
+    begin
+      @backend.report(ErrorStalker::ExceptionReport.new(:application => application_name, :exception => exception, :data => extra_data))
+    rescue Exception => e # keep going if this fails
+    end
+  end
+
+  # Calls +report+ on all exceptions raised in the provided block of
+  # code. +options+ can be:
+  #
+  # [:reraise] if true, reraise exceptions caught in this
+  #            block. Defaults to true.
+  def self.report_exceptions(application_name, options = {})
+    options = {:reraise => true}.merge(options)
+    begin
+      yield
+    rescue => e
+      report(application_name, e)
+      if options[:reraise]
+        raise e
+      end
+    end
+  end
+end
+
+logfile = File.join(Dir.tmpdir, "exceptions.log")
+
+# let's put this in a better place if we're using rails
+logfile = Rails.root + 'log/exceptions.log' if defined?(Rails)
+
+ErrorStalker::Client.backend = ErrorStalker::Backend::LogFile.new(logfile)

data/lib/error_stalker/exception_group.rb

@@ -0,0 +1,29 @@
+# Container for information about a group of exceptions. This is used
+# so that we don't get overwhelmed by duplicate exceptions. Some
+# Exceptional::Stores may subclass and override this class, but the attributes
+# called out here should always be valid.
+class ErrorStalker::ExceptionGroup
+  # The number of times this exception has been reported
+  attr_accessor :count
+
+  # The unique identifier of this group. All similar exceptions should
+  # generate the same digest.
+  attr_accessor :digest
+
+  # The list of machines that have seen this exception
+  attr_accessor :machines
+
+  # The first time this exception occurred
+  attr_accessor :first_timestamp
+  
+  # The most recent time this exception occurred
+  attr_accessor :most_recent_timestamp
+
+  # The most recent ExceptionReport instance belonging to this group
+  attr_accessor :most_recent_report
+  
+  def type
+    most_recent_report.type unless most_recent_report.nil?
+  end
+  
+end

data/lib/error_stalker/exception_report.rb

@@ -0,0 +1,116 @@
+require 'json'
+require 'digest/md5'
+
+# An ExceptionReport contains all of the information we have on an
+# exception, which can then be transformed into whatever format is
+# needed for further investigation. Some data stores may override this
+# class, but they should be able to be treated as instances of this
+# class regardless.
+class ErrorStalker::ExceptionReport
+  
+  # The name of the application that caused this exception. 
+  attr_reader :application
+
+  # The name of the machine that raised this exception.
+  attr_reader :machine
+
+  # The time that this exception occurred
+  attr_reader :timestamp
+
+  # The class name of +exception+
+  attr_reader :type
+
+  # The exception object (or string message) this report represents
+  attr_reader :exception
+
+  # A hash of extra data logged along with this exception.
+  attr_reader :data
+
+  # The backtrace corresponding to this exception. Should be an array
+  # of strings, each referring to a single stack frame.
+  attr_reader :backtrace
+
+  # A unique identifier for this exception
+  attr_accessor :id
+
+  # Build a new ExceptionReport. <tt>params[:application]</tt> is a
+  # string identifying the application or component the exception was
+  # sent from, <tt>params[:exception]</tt> is the exception object you
+  # want to report (or a string error message), and
+  # <tt>params[:data]</tt> is any extra arbitrary data you want to log
+  # along with this report.
+  def initialize(params = {})
+    params = symbolize_keys(params)
+    @id = params[:id]
+    @application = params[:application]
+    @machine = params[:machine] || machine_name
+    @timestamp = params[:timestamp] || Time.now
+    @type = params[:type] || params[:exception].class.name
+    
+    if params[:exception].is_a?(Exception)
+      @exception = params[:exception].to_s
+    else
+      @exception = params[:exception]
+    end
+    
+    @data = params[:data]
+    
+    if params[:backtrace]
+      @backtrace = params[:backtrace]
+    else
+      @backtrace = params[:exception].backtrace if params[:exception].is_a?(Exception)
+    end
+
+    @digest = params[:digest] if params[:digest]
+  end
+
+  # The number of characters in this exception's stacktrace that
+  # should be used to uniquify this exception. Exceptions raised from
+  # the same place should have the same stacktrace, up to
+  # +STACK_DIGEST_LENGTH+ characters.
+  STACK_DIGEST_LENGTH = 4096
+
+  # Generate a 'mostly-unique' hash code for this exception, that
+  # should be the same for similar exceptions and different for
+  # different exceptions. This is used to group similar exceptions
+  # together.
+  def digest
+    @digest ||= Digest::MD5.hexdigest((backtrace ? backtrace.to_s[0,STACK_DIGEST_LENGTH] : exception.to_s) + type.to_s)
+  end
+
+  # Serialize this object to json, so we can send it over the wire.
+  def to_json
+    {
+      :application => application,
+      :machine => machine,
+      :timestamp => timestamp,
+      :type => type,
+      :exception => exception,
+      :data => data,
+      :backtrace => backtrace
+    }.to_json
+  end
+
+  private
+
+  # Shamelessly stolen from rails. Converts the keys in +hash+ from
+  # strings to symbols.
+  def symbolize_keys(hash)
+    hash.inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+
+  # Determine the name of this machine. Should work on Windows, Linux,
+  # and Mac OS X, but only tested on Debian, Ubuntu, and Mac OS X.
+  def machine_name
+    machine_name = 'unknown'
+    if RUBY_PLATFORM =~ /win32/
+      machine_name = ENV['COMPUTERNAME']
+    elsif RUBY_PLATFORM =~ /linux/ || RUBY_PLATFORM =~ /darwin/
+      machine_name = `/bin/hostname`.chomp
+    end
+    machine_name
+  end
+end