never-forget 0.1.0

data/lib/never-forget.rb

@@ -0,0 +1 @@
+require 'never_forget'

data/lib/never_forget.rb

@@ -0,0 +1,23 @@
+module NeverForget
+  autoload :ExceptionHandler, 'never_forget/exception_handler'
+  autoload :Exception, 'never_forget/exception'
+
+  class << self
+    attr_writer :enabled
+    def enabled?() @enabled end
+  end
+  self.enabled = true
+
+  def self.log(error, env = {}, &block)
+    Exception.create(error, env, &block) if enabled?
+  rescue
+    warn "NeverForget: error saving exception (#{$!.class} #{$!})"
+    warn $!.backtrace.first
+  end
+end
+
+require 'never_forget/railtie' if defined? Rails::Railtie
+
+if defined?(Sinatra) and Sinatra.respond_to? :register
+  require 'never_forget/sinatra'
+end

data/lib/never_forget/exception.rb

@@ -0,0 +1,179 @@
+require 'mingo'
+require 'active_support/memoizable'
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/hash'
+require 'rack/request'
+require 'rack/utils'
+
+module NeverForget
+  class Exception < ::Mingo
+    def self.collection_name() "NeverForget" end
+    def self.collection
+      unless defined? @collection
+        db.create_collection collection_name, capped: true, size: 1.megabyte
+      end
+      super
+    end
+
+    extend ::ActiveSupport::Memoizable
+    include ::Mingo::Timestamps
+
+    def self.create(error, env)
+      if connected?
+        record = new.init(error, env)
+        yield record if block_given?
+        record.save
+        record
+      end
+    end
+
+    def self.recent
+      find.sort('$natural', :desc).limit(20)
+    end
+
+    KEEP = %w[rack.url_scheme action_dispatch.remote_ip]
+    EXCLUDE = %w[HTTP_COOKIE QUERY_STRING SERVER_ADDR]
+    KNOWN_MODULES = %w[
+      ActiveSupport::Dependencies::Blamable
+      JSON::Ext::Generator::GeneratorMethods::Object
+      ActiveSupport::Dependencies::Loadable
+      PP::ObjectMixin
+      Kernel
+    ]
+
+    attr_reader :exception, :env
+
+    def init(ex, env_hash)
+      @exception = unwrap_exception(ex)
+      @env = env_hash
+      self['name'] = exception.class.name
+      self['modules'] = tag_modules
+      self['backtrace'] = exception.backtrace.join("\n")
+      self['message'] = exception.message
+
+      if env['REQUEST_METHOD']
+        self['env'] = sanitized_env
+        self['params'] = extract_params
+        self['session'] = extract_session
+        self['cookies'] = extract_cookies
+      else
+        self['params'] = clean_unserializable_data(env)
+      end
+      self
+    end
+
+    def request
+      @request ||= Rack::Request.new(env)
+    end
+
+    def request?
+      self['env'].present?
+    end
+
+    def request_url
+      env = self['env']
+      scheme = env['rack::url_scheme']
+      host, port = env['HTTP_HOST'], env['SERVER_PORT'].to_i
+      host += ":#{port}" if 'http' == scheme && port != 80 or 'https' == scheme && port != 443
+
+      url = scheme + '://' + File.join(host, env['SCRIPT_NAME'], env['PATH_INFO'])
+      url << '?' << Rack::Utils::build_nested_query(self['params']) if get_request? and self['params'].present?
+      url
+    end
+
+    def request_method
+      self['env']['REQUEST_METHOD']
+    end
+
+    def get_request?
+      'GET' == request_method
+    end
+
+    def xhr?
+      self['env']['HTTP_X_REQUESTED_WITH'] =~ /XMLHttpRequest/i
+    end
+
+    def remote_ip
+      self['env']['action_dispatch::remote_ip'] || self['env']['REMOTE_ADDR']
+    end
+
+    def tag_modules
+      Array(exception.singleton_class.included_modules).map(&:to_s) - KNOWN_MODULES
+    end
+    memoize :tag_modules
+
+    def unwrap_exception(exception)
+      if exception.respond_to?(:original_exception)
+        exception.original_exception
+      elsif exception.respond_to?(:continued_exception)
+        exception.continued_exception
+      else
+        exception
+      end
+    end
+
+    def extract_session
+      if session = env['rack.session']
+        session_hash = session.to_hash.stringify_keys.except('session_id', '_csrf_token')
+        clean_unserializable_data session_hash
+      end
+    end
+
+    def exclude_params
+      Array(env['action_dispatch.parameter_filter']).map(&:to_s)
+    end
+    memoize :exclude_params
+
+    def extract_params
+      if params = request.params and params.any?
+        filtered = params.each_with_object({}) { |(key, value), keep|
+          keep[key] = exclude_params.include?(key.to_s) ? '[FILTERED]' : value
+        }
+        clean_unserializable_data filtered.except('utf8')
+      end
+    end
+
+    def extract_cookies
+      if cookies = env['rack.request.cookie_hash']
+        if options = env['rack.session.options']
+          cookies = cookies.except(options[:key])
+        end
+        clean_unserializable_data cookies
+      end
+    end
+
+    def sanitized_env
+      clean_unserializable_data env.select { |key, _| keep_env? key }
+    end
+
+    def keep_env?(key)
+      ( key !~ /[a-z]/ or KEEP.include?(key) ) and not discard_env?(key)
+    end
+
+    def discard_env?(key)
+      EXCLUDE.include?(key) or
+        ( key == 'REMOTE_ADDR' and env['action_dispatch.remote_ip'] )
+    end
+
+    def sanitize_key(key)
+      key.to_s.gsub('.', '::').sub(/^\$/, 'DOLLAR::')
+    end
+
+    def clean_unserializable_data(data, stack = [])
+      return "[possible infinite recursion halted]" if stack.any?{|item| item == data.object_id }
+
+      if data.respond_to?(:to_hash)
+        data.to_hash.each_with_object({}) do |(key, value), result|
+          result[sanitize_key(key)] = clean_unserializable_data(value, stack + [data.object_id])
+        end
+      elsif data.respond_to?(:to_ary)
+        data.collect do |value|
+          clean_unserializable_data(value, stack + [data.object_id])
+        end
+      else
+        data.to_s
+      end
+    end
+  end
+end

data/lib/never_forget/exception_handler.rb

@@ -0,0 +1,95 @@
+require 'rbconfig'
+require 'erubis'
+require 'active_support/memoizable'
+
+module NeverForget
+  class ExceptionHandler
+    TEMPLATE_FILE = File.expand_path('../list_exceptions.erb', __FILE__)
+
+    def initialize(app, options = {})
+      @app = app
+      @options = {:list_path => '/_exceptions'}.update(options)
+    end
+
+    def forward(env)
+      begin
+        @app.call(env)
+      rescue StandardError, ScriptError => error
+        NeverForget.log(error, env)
+        raise error
+      end
+    end
+
+    def call(env)
+      if env['PATH_INFO'] == File.join('/', @options[:list_path])
+        body = render_exceptions_view
+        [200, {'content-type' => 'text/html'}, [body]]
+      else
+        forward(env)
+      end
+    end
+    
+    def render_exceptions_view
+      template = Erubis::Eruby.new(exceptions_template)
+      context = Erubis::Context.new(:recent => Exception.recent)
+      context.extend TemplateHelpers
+      template.evaluate(context)
+    end
+    
+    def exceptions_template
+      File.read(TEMPLATE_FILE)
+    end
+  end
+
+  module TemplateHelpers
+    include RbConfig
+    extend ActiveSupport::Memoizable
+
+    def gem_path
+      paths = []
+      paths << Bundler.bundle_path << Bundler.user_bundle_path if defined? Bundler
+      paths << Gem.path if defined? Gem
+      paths.flatten.uniq
+    end
+
+    SYSDIRS = %w[ vendor site rubylib arch sitelib sitearch vendorlib vendorarch top ]
+
+    def system_path
+      SYSDIRS.map { |name| CONFIG["#{name}dir"] }.compact
+    end
+
+    def external_path
+      ['/usr/ruby1.9.2', '/home/heroku_rack', gem_path, system_path].flatten.uniq
+    end
+    memoize :external_path
+
+    def collapse_line?(line)
+      external_path.any? {|p| line.start_with? p }
+    end
+
+    def ignore_line?(line)
+      line.include? '/Library/Application Support/Pow/'
+    end
+
+    def strip_root(line)
+      if line =~ %r{/gems/([^/]+)-(\d[\w.]*)/}
+        gem_name, gem_version = $1, $2
+        path = line.split($&, 2).last
+        "#{gem_name} (#{gem_version}) #{path}"
+      elsif path = "#{root_path}/" and line.start_with? path
+        line.sub(path, '')
+      else
+        line
+      end
+    end
+
+    def root_path
+      if defined? Bundler then Bundler.root
+      elsif defined? Rails then Rails.root
+      elsif defined? Sinatra::Application then Sinatra::Application.root
+      else Dir.pwd
+      end
+    end
+    memoize :root_path
+  end
+end

data/lib/never_forget/list_exceptions.erb

@@ -0,0 +1,111 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<meta name="viewport" content="initial-scale=1.0; maximum-scale=1.0; user-scalable=0;">
+<title>Exceptions</title>
+<style>
+  body {
+    margin: 2em;
+    font: medium/1.6 Helvetica, sans-serif;
+  }
+  a:link, a:visited { color: darkblue; }
+  a:hover { color: crimson; }
+  .url, .ua { margin: .2em 0; }
+  .ua { color: gray; font-size: 85%; }
+  ol.trace {
+    margin: .5em 0;
+    padding: 0;
+    list-style: none;
+    font-size: 85%;
+    line-height: 1.2;
+  }
+  .trace .num { font-weight: bold; }
+  .trace .sys { display: none; }
+  .trace .expand a {
+    font-size: 80%; text-transform: uppercase;
+  }
+  .trace.expanded .sys { display: list-item; }
+  .trace.expanded .expand { display: none; }
+  
+  h1 { margin: 0; padding: 0; }
+  article {
+    margin-top: 1.5em;
+    padding-top: 1em;
+    border-top: 2px solid #eee;
+  }
+  h2 {
+    margin: 0 0 .2em 0;
+    padding: 0 0 .1em 0;
+    display: inline-block;
+  }
+  time {
+    display: inline-block;
+    font: 80% "American Typewriter", monospace;
+    color: gray;
+    margin-left: 1em;
+  }
+  h2 span { font-weight: normal; }
+  h3 { margin: .5em 0 .2em 0; padding: .1em 0; font-size: 1.1em; }
+  pre { margin: .2em; }
+  
+  @media only screen and (max-device-width:480px) {
+    body { margin: 7px; font-size: small; }
+    h1 { font-size: 22px; text-align: center; margin: 0; padding: 0; }
+    h2 { font-size: 18px; }
+    article { margin-top: .2em; padding-top: .2em; padding-bottom: .5em; }
+  }
+</style>
+
+<h1>Exceptions</h1>
+
+<% if @recent.has_next? %>
+<% for ex in @recent %>
+<article>
+<header><h2><%= ex['name'] %>: <span><%== ex['message'] %></span></h2>
+<time><%== ex.created_at.strftime('%a, %b %e %T') %></time>
+</header>
+
+<% if ex.request? %>
+<% url = ex.request_url %>
+<p class="url">
+  <% if ex.xhr? %>Ajax<% end %> <%= ex.request_method %>
+  <a href="<%== url %>"><%== url.split('://').last %></a>
+</p>
+<p class="ua">
+  <span class="ip"><%= ex.remote_ip %></span> &mdash;
+  <%== ex['env']['HTTP_USER_AGENT'] %>
+</p>
+<% end %>
+
+<% if ex['params'].present? %>
+<h3>Params:</h3>
+<pre class="params"><%== YAML.dump ex['params'] %></pre>
+<% end %>
+
+<% if ex['session'].present? %>
+<h3>Session:</h3>
+<pre class="session"><%== YAML.dump ex['session'] %></pre>
+<% end %>
+
+<h3>Backtrace:</h3>
+<ol class="trace">
+  <% for line in ex['backtrace'].split("\n") %>
+    <% next if ignore_line? line %>
+    <li<%= collapse_line?(line) ? ' class="sys"' : '' %>><%= strip_root(line).sub(/:(\d+):/, ' <span class="num">\1</span> ') %></li>
+  <% end %>
+  <li class="expand"><a href="#expand">full trace</a></li>
+</ol>
+</article>
+<% end %>
+
+<script>
+  document.addEventListener('click', function(e) {
+    var el = e.target
+    if (el.nodeName == 'A' && el.getAttribute('href') == '#expand') {
+      e.preventDefault()
+      el.parentNode.parentNode.className += " expanded"
+    }
+  }, false)
+</script>
+<% else %>
+  <p><i>No exceptions captured yet.</i></p>
+<% end %>

data/lib/never_forget/railtie.rb

@@ -0,0 +1,26 @@
+module NeverForget
+  class Railtie < ::Rails::Railtie
+    config.never_forget = ActiveSupport::OrderedOptions.new
+    config.never_forget.enabled = ::Rails.env.production? || ::Rails.env.staging?
+    config.never_forget.list_path = '/_exceptions'
+
+    initializer "never_forget" do |app|
+      if NeverForget.enabled = app.config.never_forget.enabled
+        app.config.middleware.insert_after 'ActionDispatch::ShowExceptions',
+          ExceptionHandler, :list_path => app.config.never_forget.list_path
+
+        ::ActiveSupport.on_load(:action_controller) { include NeverForget::ControllerRescue }
+      end
+    end
+  end
+  
+  module ControllerRescue
+    def rescue_with_handler(exception)
+      if super
+        # the exception was handled, but we still want to save it
+        NeverForget.log(exception, request.env)
+        true
+      end
+    end
+  end
+end

data/lib/never_forget/sinatra.rb

@@ -0,0 +1,17 @@
+module NeverForget
+  module Sinatra
+    module Helpers
+      def log_error(boom = $!, env = nil)
+        env = request.env if env.nil? and respond_to? :request
+        NeverForget.log(boom, env || {})
+      end
+    end
+
+    def self.registered(app)
+      app.use NeverForget::ExceptionHandler
+      app.helpers Helpers
+    end
+
+    ::Sinatra.register self
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: never-forget
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- "Mislav Marohni\xC4\x87"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-28 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mingo
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.2"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: erubis
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: Never Forget is a layer of persistence for exceptions thrown in a Rack application at runtime.
+email: mislav.marohnic@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/never-forget.rb
+- lib/never_forget/exception.rb
+- lib/never_forget/exception_handler.rb
+- lib/never_forget/list_exceptions.erb
+- lib/never_forget/railtie.rb
+- lib/never_forget/sinatra.rb
+- lib/never_forget.rb
+homepage: https://github.com/mislav/never-forget
+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.8
+signing_key: 
+specification_version: 3
+summary: Saves exceptions to MongoDB
+test_files: []
+