error_stalker 0.0.12

data/lib/error_stalker/plugin.rb

@@ -0,0 +1,42 @@
+# The ErrorStalker server supports third-party plugins that add
+# functionality to the server.
+#
+# Plugins should inherit from ErrorStalker::Plugin::Base. This base
+# plugin provides functions that can be overridden in its
+# children. Currently, a few hooks are provided for plugins to
+# override:
+#
+# [ErrorStalker::Plugin::Base.new] Called when the server starts. This
+#                                method can be overridden to do things
+#                                like add extra routes to the server
+#                                or initialize any data structures
+#                                that the plugin needs to keep track
+#                                of. Take a look at
+#                                ErrorStalker::Plugin::LighthouseReporter
+#                                for a good example of how this method
+#                                can be hooked to provide additional
+#                                functionality.
+#
+# [ErrorStalker::Plugin::Base#exception_links] Called when rendering
+#                                            exception details. This
+#                                            function should return an
+#                                            array of [link_text,
+#                                            link_href] pairs that
+#                                            will be used to link to
+#                                            additional routes that
+#                                            the plugin might add.
+#
+# [ErrorStalker::Plugin::Base#after_create] Called when a new exception
+#                                         is
+#                                         reported. ErrorStalker::Plugin::EmailSender
+#                                         has a good example of this
+#                                         being used.
+#
+# After creating a plugin, it can be added to the server in the server
+# configuration file or manually added using the
+# ErrorStalker::Server#plugins attribute.
+module ErrorStalker::Plugin
+  autoload :Base, 'error_stalker/plugin/base'
+  autoload :LighthouseReporter, 'error_stalker/plugin/lighthouse_reporter'
+  autoload :EmailSender, 'error_stalker/plugin/email_sender'
+end

data/lib/error_stalker/plugin/base.rb

@@ -0,0 +1,24 @@
+# The base ErrorStalker::Plugin, that all plugins should inherit
+# from. Provides default implementations of all the supported plugin
+# methods, so you can (and should) call +super+ in your plugin subclasses.
+class ErrorStalker::Plugin::Base
+
+  # Create a new instance of this plugin. +app+ is the sinatra
+  # ErrorStalker::Server instance, and +params+ is an arbitrary hash of
+  # plugin-specific parameters or options.
+  def initialize(app, params = {})
+  end
+  
+  # An array of [name, href] pairs of links that will show up on the
+  # exception detail page. These are most commonly used to link to
+  # additional routes added by the plugin.
+  def exception_links(exception_report)
+    []
+  end
+
+  # Called after a new exception is reported. At the point that this
+  # is called, +exception_report+ will have an ID and has been
+  # associated with an exception group.
+  def after_create(app, exception_report)
+  end
+end

data/lib/error_stalker/plugin/email_sender.rb

@@ -0,0 +1,60 @@
+require 'mail'
+
+# The email sender plugin will send an email to an address the first
+# time an exception in a group is reported. Future exceptions that go
+# in the same group will not trigger emails.
+class ErrorStalker::Plugin::EmailSender < ErrorStalker::Plugin::Base
+
+  # Parameters that are used in order to figure out how and where to
+  # send the report email. These parameters are passed directly to the
+  # {mail gem}[https://github.com/mikel/mail]. See that page for a
+  # reference. The subject and body are created by the plugin, but all
+  # other parameters (to, from, etc.) will have to be passed in.
+  attr_reader :mail_params
+
+  # Create a new instance of this plugin. +mail_params+ is a hash of
+  # parameters that are used to build the report email.
+  def initialize(app, mail_params = {})
+    super(app, mail_params)
+    @mail_params = mail_params
+  end
+
+  # Builds the mail object from +exception_report+ that we can later
+  # deliver. This is mostly here to make testing easier.
+  def build_email(exception_report, exception_url)
+    @report = exception_report
+    @url = exception_url
+    
+    mail = Mail.new({
+        'subject' => "Exception on #{exception_report.machine} - #{exception_report.exception.to_s[0, 64]}",
+        'body' => ERB.new(File.read(File.expand_path('views/exception_email.erb', File.dirname(__FILE__)))).result(binding)
+      }.merge(mail_params))
+
+    if mail_params['delivery_method']
+      mail.delivery_method(mail_params['delivery_method'].to_sym, (mail_params['delivery_settings'] || {}))
+    end
+    
+    mail
+  end
+
+  # Sets up the parameters we need to build a new exception report
+  # email, and sends the mail.
+  def send_email(app, exception_report)
+    request = app.request
+    host_with_port = request.host
+    host_with_port << ":#{request.port}" if request.port != 80
+    url = "#{request.scheme}://#{host_with_port}/exceptions/#{exception_report.id}.html"
+    mail = build_email(exception_report, url)
+    mail.deliver
+  end
+
+  # Hook to trigger an email when a new exception report with
+  # +report+'s digest comes in.
+  def after_create(app, report)
+    # Only send an email if it's the first exception of this type
+    # we've seen
+    send_email(app, report) if app.store.group(report.digest).count == 1
+    super(app, report)
+  end
+
+end

data/lib/error_stalker/plugin/lighthouse_reporter.rb

@@ -0,0 +1,95 @@
+require 'lighthouse'
+
+# A simple plugin for reporting exceptions as new bugs in
+# {Lighthouse}[http://lighthouseapp.com]. When this plugin is enabled,
+# a new link will show up on the exception detail page that
+# pre-populates a form for sending the exception report to Lighthouse.
+class ErrorStalker::Plugin::LighthouseReporter < ErrorStalker::Plugin::Base
+
+  # The lighthouse project id that this plugin will report bugs to.
+  attr_reader :project_id
+
+  # Creates a new instance of this plugin. There are a few parameters
+  # that must be passed in in order for this plugin to work correctly:
+  #
+  # [params['account']] The Lighthouse account name these exceptions
+  #                     will be posted as
+  # 
+  # [params['token']] The read/write token assigned by Lighthouse for
+  #                   API access
+  # 
+  # [params['project_id']] The Lighthouse project these exceptions
+  #                        will be reported to
+  def initialize(app, params = {})
+    super(app, params)
+    app.class.send(:include, Actions)
+    app.lighthouse = self
+    Lighthouse.account = params['account']
+    Lighthouse.token = params['token']
+    @project_id = params['project_id']
+  end
+
+  # A list containing the link that will show up on the exception
+  # report's detail page. This link hooks into one of the new actions
+  # defined by this plugin.
+  def exception_links(exception_report)
+    super(exception_report) + [["Report to Lighthouse", "/lighthouse/report/#{exception_report.id}.html"]]
+  end
+
+  # Create a new Lighthouse ticket object pre-populated with information
+  # about +exception+.
+  def new_ticket(request, exception)
+    ticket = Lighthouse::Ticket.new(:project_id => project_id)
+    ticket.title = "Exception: #{exception.exception}"
+    host_with_port = request.host
+    host_with_port << ":#{request.port}" if request.port != 80
+    ticket_link = "#{request.scheme}://#{host_with_port}/exceptions/#{exception.id}.html"
+    ticket.body = ticket_link
+    ticket.tags = "exception"
+    ticket
+  end
+
+  # Post a new ticket to lighthouse with the params specified in
+  # +params+.
+  def post_ticket(params)
+    ticket = Lighthouse::Ticket.new(:project_id => project_id)
+    ticket.title = params[:title]
+    ticket.body = params[:body]
+    ticket.tags = params[:tags]
+    ticket.save
+  end
+
+  # Extra actions that will be added to the ErrorStalker::Server
+  # instance when this plugin is enabled. Provides actions for
+  # creating a new Lighthouse ticket with exception details and
+  # posting the ticket to Lighthouse. This module also adds a
+  # +lighthouse+ accessor to the server instance that can be used to
+  # build and send tickets to Lighthouse.
+  module Actions
+
+    # Adds the actions described above to the ErrorStalker::Server
+    # instance.
+    def self.included(base)
+      base.class_eval do
+
+        attr_accessor :lighthouse
+
+        get '/lighthouse/report/:id.html' do
+          @exception = store.find(params["id"])
+          @ticket = lighthouse.new_ticket(request, @exception)
+          erb File.read(File.expand_path('views/report.erb', File.dirname(__FILE__)))
+        end
+
+        post '/lighthouse/report/:id.html' do
+          if lighthouse.post_ticket(params)
+            redirect "/exceptions/#{params[:id]}.html"
+          else
+            @error = "There was an error submitting the ticket: <br />#{@ticket.errors.join("<br />")}"
+            erb File.read(File.expand_path('views/report.erb', File.dirname(__FILE__)))
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/error_stalker/plugin/views/exception_email.erb

@@ -0,0 +1,18 @@
+Exception: <%= @report.application %> (<%= @report.machine %>) at <%= @report.timestamp %>
+
+<%= @url %>
+
+Exception
+=========
+
+<%= @report.exception.to_s %>
+<% if @report.backtrace %>
+Stack Trace
+===========
+
+<%= @report.backtrace.join("\n") %>
+<% end %>
+Extra Data
+==========
+
+<%= @report.data.to_yaml %>

data/lib/error_stalker/plugin/views/report.erb

@@ -0,0 +1,18 @@
+<%= h @error if @error %>
+
+<h1>Import into Lighthouse</h1>
+
+<div id="lighthouse_form" class="clearfix">
+  <form method="post" action="/lighthouse/report/<%= @exception.id %>.html">
+    <label for="title">Title</label>
+    <input id="title" type="text" name="title" value="<%= @ticket.title %>" />
+
+    <label for="tags">Tags</label>
+    <input id="tags" type="text" name="tags" value="<%= @ticket.tags %>" />
+    
+    <label for="body">Body</label>
+    <textarea id="body" name="body"><%= @ticket.body %></textarea>
+    
+    <input type="submit" name="Create" value="Create" />
+  </form>
+</div>

data/lib/error_stalker/server.rb

@@ -0,0 +1,152 @@
+require 'sinatra/base'
+
+$: << File.expand_path('..', File.dirname(__FILE__))
+require 'error_stalker'
+require 'error_stalker/store'
+require 'error_stalker/plugin'
+require 'erb'
+require 'will_paginate'
+require 'will_paginate/view_helpers/base'
+require 'error_stalker/sinatra_link_renderer'
+require 'error_stalker/version'
+
+module ErrorStalker
+  # The ErrorStalker server. Provides a UI for browsing, grouping, and
+  # searching exception reports, as well as a centralized store for
+  # keeping exception reports. As a Sinatra app, this can be run using
+  # a config.ru file or something like Vegas. A sample Vegas runner
+  # for the server is located in <tt>bin/error_stalker_server</tt>.
+  class Server < Sinatra::Base
+
+    # The number of exceptions or exception groups to show on each
+    # page.
+    PER_PAGE = 25
+
+    # The data store (ErrorStalker::Store instance) to use to store
+    # exception data
+    attr_accessor :store 
+    
+    # A list of plugins the server will use.
+    attr_accessor :plugins
+    
+    set :root, File.dirname(__FILE__)
+    set :public, Proc.new { File.join(root, "server/public") }
+    set :views, Proc.new { File.join(root, "server/views") }
+
+    helpers do
+      include Rack::Utils
+      alias_method :h, :escape_html
+
+      include WillPaginate::ViewHelpers::Base
+
+      # Generates a url from an array of strings representing the
+      # parts of the path.
+      def url(*path_parts)
+        u = '/' + path_parts.join("/")
+        u += '.html' unless u =~ /\.\w{2,4}$/
+        u
+      end
+      alias_method :u, :url
+
+      # Cuts +str+ at +limit+ characters. If +str+ is too long, will
+      # apped '...' to the end of the returned string.
+      def cutoff(str, limit = 100)
+        if str.length > limit
+          str[0, limit] + '...'
+        else
+          str
+        end
+      end
+    end
+
+    class << self
+      # A hash of configuration options, usually read from a
+      # configuration file.
+      attr_accessor :configuration 
+    end
+    self.configuration = {}
+
+    # The default ErrorStalker::Store subclass to use by default for
+    # this ErrorStalker::Server instance. This is defined as a class
+    # method as well as an instance method so that it can be set by a
+    # configuration file before rack creates the instance of this
+    # sinatra app.
+    def self.store
+      if configuration['store']
+        store_class = configuration['store']['class'].split('::').inject(Object) {|mod, string| mod.const_get(string)}
+        store_class.new(*Array(configuration['store']['parameters']))
+      else
+        ErrorStalker::Store::InMemory.new
+      end
+    end
+
+    # A hash of configuration options, usually read from a
+    # configuration file.
+    def configuration
+      self.class.configuration
+    end
+
+    # Creates a new instance of the server, based on the configuration
+    # contained in the +configuration+ attribute.
+    def initialize
+      super
+      self.plugins = []
+      if configuration['plugin']
+        configuration['plugin'].each do |config|
+          plugin_class = config['class'].split('::').inject(Object) {|mod, string| mod.const_get(string)}
+          self.plugins << plugin_class.new(self, config['parameters'])
+        end
+      end
+      self.store = self.class.store
+    end
+    
+    get '/' do
+      @records = store.recent.paginate(:page => params[:page], :per_page => PER_PAGE)
+      erb :index
+    end
+
+    get '/search' do
+      @results = store.search(params).paginate(:page => params[:page], :per_page => PER_PAGE) if params["Search"]
+      erb :search
+    end
+    
+    get '/similar/:digest.html' do
+      @group = store.reports_in_group(params[:digest]).paginate(:page => params[:page], :per_page => PER_PAGE)
+      if @group
+        erb :similar
+      else
+        404
+      end
+    end
+    
+    get '/exceptions/:id.html' do
+      @report = store.find(params[:id])
+      if @report
+        @group = store.group(@report.digest)
+        erb :show
+      else
+        404
+      end
+    end
+    
+    get '/stats.json' do
+      timestamp = Time.at(params[:timestamp].to_i) if params[:timestamp]
+      # default to 1 hour ago
+      timestamp ||= Time.now - (60*60)
+      stats = {}
+      stats[:timestamp] = timestamp.to_i
+      stats[:total_since] = store.total_since(timestamp)
+      stats[:total] = store.total
+      stats[:version] = ErrorStalker::VERSION
+      stats.to_json
+    end
+
+    post '/report.json' do
+      report = ErrorStalker::ExceptionReport.new(JSON.parse(request.body.read))
+      report.id = store.store(report)
+      plugins.each {|p| p.after_create(self, report)}
+      200
+    end
+    
+  end
+end

data/lib/error_stalker/server/public/exception_logger.css

@@ -0,0 +1,173 @@
+body {
+  font-family: Helvetica, Calibri, sans-serif;
+}
+
+h1, h2, h3, h4 {
+  font-color: #222;
+  width: 960px;
+  overflow: hidden;
+}
+
+table {
+  border-collapse: separate;
+  border-spacing: 0;
+  margin: 0;
+  padding: 0;
+  border: 0;
+  outline: 0;
+  vertical-align: baseline;
+}
+
+h1 {
+  margin-top: 12px;
+  margin-bottom: 12px;
+}
+
+h3 {
+  margin-bottom: 4px;
+}
+
+a {
+  text-decoration: none;
+  color: #007a94;
+}
+
+a:visited {
+  color: #83389b;
+}
+
+table#exceptions td, table#exceptions th {
+  padding: 10px;
+  height: 80px;
+  word-wrap: break-word;
+}
+
+table#exceptions {
+  -moz-box-shadow: 0px 2px 5px #666;
+  -webkit-box-shadow: 0px 2px 5px #666;
+  box-shadow: 0px 2px 5px #666;
+  width: 960px;
+}
+
+table#exceptions, table#exceptions tr:first-child th:first-child {
+  -webkit-border-top-left-radius: 6px;
+  -moz-border-radius-topleft: 6px;
+  border-top-left-radius: 6px;
+}
+
+table#exceptions, table#exceptions tr:first-child th:last-child {
+  -webkit-border-top-right-radius: 6px;
+  -moz-border-radius-topright: 6px;
+  border-top-right-radius: 6px;
+}
+
+table#exceptions th {
+  color: #eee;
+  background-color: #333;
+  background: url('images/background.png');
+  border-bottom: 1px solid #dadada;
+  text-shadow:0 -1px 1px rgba(0,0,0,0.5);
+}
+
+table#exceptions tr.even {
+  background-color: #ccc;
+}
+
+table#exceptions tr.odd {
+  background-color: #eee;
+}
+
+
+table#exceptions .count {
+  width: 80px;
+  text-align: center;
+}
+
+table#exceptions .last_occurred {
+  width: 240px;
+}
+
+table#exceptions td.last_occurred {
+  font-size: 0.8em;
+}
+
+table#exceptions td.last_occurred .timestamp {
+  font-size: 1.2em;
+}
+
+table#exceptions .exception, table#exceptions .exception div {
+  width: 480px;
+}
+
+table#exceptions .links {
+  text-align: center;
+  width: 160px;
+  color: #777;
+}
+
+table#exceptions .details {
+  width: 240px;
+}
+
+pre {
+  overflow: auto;
+  padding: 8px;
+  background-color: #d6d6d6;
+  margin: 0px;
+  border: 1px solid #aaa;
+}
+
+code {
+  font-size: 14px;
+  font-family: Inconsolata, Consolas, 'Lucida Console', monospace;
+}
+
+dl.group_details dt {
+  clear: left;
+  float: left;
+  font-weight: bold;
+}
+
+dl.group_details dd {
+  margin-left: 220px;
+}
+
+form {
+  margin-left: 10px;
+  width: 380px;
+}
+
+form label {
+  width: 140px;
+  margin-right: 10px;
+  display: block;
+  float: left;
+}
+
+form input, #search_form select {
+  width: 220px;
+  margin-left: 10px;
+  float: left;
+}
+
+form textarea {
+  width: 220px;
+  height: 80px;
+  margin-left: 10px;
+  float: left;
+}
+
+form input[type=submit] {
+  clear: left;
+  width: auto;
+  margin: 8px 0px 0px 0px;
+}
+
+.pagination {
+  padding: 16px 0px;
+}
+
+.pagination em {
+  font-weight: bold;
+  font-style: normal;
+}