global_error_handler 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 07f69e5667ebe1d85b0a8c19d1235a4e2f616376
+  data.tar.gz: 6b567dc07286f74344be7f8095f5ff2143653428
+SHA512:
+  metadata.gz: 0b6e21e73feb9f79d781bda7e1568f189d9e925e6b4e5add59358dc27f3dd756026b75c945b8daabe872a24756d28db307c67083f51be810077089c9c3d61a79
+  data.tar.gz: ac37c37754e81d3619c43c3dc8b75be62a041597a81f157643559266a3f53a6506511e836f4d636cef9d06da9187609b9400393f01479f61580581ae8340328d

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TODO: Write your name
+
+MIT License
+
+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/README.md

@@ -0,0 +1,41 @@
+# GlobalErrorHandler
+
+GlobalErrorHandler catches application exceptions on the middleware level and store them into the redis database.
+It adds Exceptions tab to Redis Web server in case to view, filter, delete or truncate them.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'global_error_handler'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install global_error_handler
+
+## Configuration
+
+Add redis database configuration into `global_exceptions_handler` section of _redis.yml_. See [redis_example.yml](https://github.com/kolobock/global_error_handler/blob/master/config/redis_example.yml) for more details.
+
+## Usage
+
+Target your browser to `/resque/exceptions/` path of your Rails Application server to view all Exceptions.
+*Truncate all* deletes all Exceptions by filter if filter is selected or _ALL_ Exceptions otherwise.
+
+If `rescue_from` is used in your application, add following line at top of the method specified to `with:` parameter of resque_from helper.
+
+```ruby
+GlobalErrorHandler::Handler.new(request.env, exception).process_exception!
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/global_error_handler/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/config/redis_example.yml

@@ -0,0 +1,38 @@
+development:
+  main: &dev_main
+    db: "1"
+    host: localhost
+    port: 6379
+    password:
+
+  global_exception_handler: &dev_global_exception_handler
+    db: "3"
+    host: localhost
+    port: 6379
+    password:
+
+test:
+  main:
+    <<: *dev_main
+
+  global_exception_handler:
+    <<: *dev_global_exception_handler
+
+production:
+  main: &main
+    db: '0'
+    host: localhost
+    port: 6379
+    password:
+
+  global_exception_handler: &global_exception_handler
+    db: '2'
+    host: localhost
+    port: 6379
+    password:
+
+staging:
+  main:
+    <<: *main
+  global_exception_handler:
+    <<: *global_exception_handler

data/global_error_handler.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'global_error_handler/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "global_error_handler"
+  spec.version       = GlobalErrorHandler::VERSION
+  spec.authors       = ["Andrii Rudenko"]
+  spec.email         = ["kolobock@gmail.com"]
+  spec.summary       = %q{Records application' exceptions into the separated redis database.}
+  spec.description   = %q{On the middleware level catch an exception from Rails app and store in the separated Redis database.}
+  spec.homepage      = "https://github.com/kolobock/global_error_handler/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", '~> 1.6'
+  spec.add_development_dependency "rake", '~> 10.3', '>= 10.3.2'
+
+  spec.add_dependency 'resque', '~> 1.25', '>= 1.25.1'
+  spec.add_dependency 'haml', '~> 4.0', '>= 4.0.5'
+end

data/lib/global_error_handler.rb

@@ -0,0 +1,22 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
+
+module GlobalErrorHandler
+end
+
+require 'resque'
+require 'resque/server'
+require 'haml'
+
+
+require 'global_error_handler/redis'
+require 'global_error_handler/parser'
+require 'global_error_handler/handler'
+require 'global_error_handler/app_exception'
+require 'global_error_handler/global_error_handler'
+
+require 'global_error_handler/middleware'
+require 'global_error_handler/rails' if defined? Rails::Railtie
+
+require "global_error_handler/version"
+
+Resque::Server.register GlobalErrorHandler::Server

data/lib/global_error_handler/app_exception.rb

@@ -0,0 +1,68 @@
+class GlobalErrorHandler::AppException
+  class << self
+    def all(page, field = nil, filter = nil)
+      page ||= 0
+      if field && filter
+        keys = GlobalErrorHandler::Redis.filter_exception_keys page, "error_#{field}", filter
+      else
+        keys = GlobalErrorHandler::Redis.exception_keys page
+      end
+      GlobalErrorHandler::Redis.find_all keys
+    end
+
+    def count(field = nil, filter = nil)
+      if field && filter
+        GlobalErrorHandler::Redis.filtered_exceptions_count("error_#{field}", filter)
+      else
+        GlobalErrorHandler::Redis.exceptions_count
+      end
+    end
+
+    def find(id)
+      return if id.blank?
+      GlobalErrorHandler::Redis.find exception_key(id)
+    end
+
+    def delete(id)
+      return if id.blank?
+      GlobalErrorHandler::Redis.delete exception_key(id)
+    end
+
+    def delete_all(ids)
+      return if ids.blank?
+      keys = ids.map{ |id| exception_key id }
+      GlobalErrorHandler::Redis.delete_all keys
+    end
+
+    def truncate(filter = nil, opts = {})
+      if filter
+        field = opts.delete(:field)
+        ids = filtered_ids_by field, filter
+        delete_all ids
+      else
+        GlobalErrorHandler::Redis.truncate!
+      end
+    end
+
+    def filters_for(field)
+      keys = GlobalErrorHandler::Redis.filter_keys_for "error_#{field}"
+      return [] if keys.blank?
+      keys.map do |key|
+        key =~ /^#{GlobalErrorHandler::Redis::FILTER_KEY_PREFIX}:error_#{field}:(.*)/
+        $1
+      end
+    end
+
+    def filtered_ids_by(field, str)
+      GlobalErrorHandler::Redis.filter_exception_keys 0, "error_#{field}", str, len
+      return [] if keys.blank?
+      keys.map{ |key| key.split(':').last rescue nil }.compact
+    end
+
+    private
+
+    def exception_key(id)
+      GlobalErrorHandler::Redis.exception_key(id)
+    end
+  end
+end

data/lib/global_error_handler/global_error_handler.rb

@@ -0,0 +1,185 @@
+module GlobalErrorHandler
+  module Server
+    GEH_VIEW_PATH   = File.join(File.dirname(__FILE__), 'server', 'views')
+    GEH_PUBLIC_PATH = File.join(File.dirname(__FILE__), 'server', 'public')
+
+    def self.registered(app)
+      app.get '/exceptions' do
+        key = params.keys.first
+        if %w(js css).include? key
+          geh_public_view params[key], key
+        else
+          prepare_and_show_index_action
+        end
+      end
+
+      app.get '/exceptions/filter/:filter_by/:filter' do
+        prepare_and_show_index_action
+      end
+
+      app.get '/exceptions/:id' do
+        @app_exception = GlobalErrorHandler::AppException.find(params[:id])
+        show_view :show
+      end
+
+      app.delete '/exceptions/filter/:filter_by/:filter/truncate' do
+        truncate_and_redirect_to_exceptions
+      end
+
+      app.delete '/exceptions/truncate' do
+        truncate_and_redirect_to_exceptions
+      end
+
+      app.delete '/exceptions/delete' do
+        GlobalErrorHandler::AppException.delete_all(params[:app_exception_delete_ids])
+        redirect_to_exceptions
+      end
+
+      app.delete '/exceptions/:id' do
+        GlobalErrorHandler::AppException.delete(params[:id])
+        redirect_to_exceptions
+      end
+
+      app.tabs << 'Exceptions'
+
+      app.helpers do
+        include ActionView::Helpers::TextHelper #link_to
+        include ActionView::Helpers::UrlHelper #simple_format
+        include ActionView::Helpers::FormHelper #select_tag check_box_tag
+        include ActionView::Helpers::FormOptionsHelper #options_for_select
+        include ActionView::Helpers::OutputSafetyHelper #delete via ajax
+
+        def prepare_and_show_index_action
+          @app_exceptions = GlobalErrorHandler::AppException.all(params[:start], params[:filter_by], get_filter)
+          @all_classes = GlobalErrorHandler::AppException.filters_for('class')
+          @all_messages = GlobalErrorHandler::AppException.filters_for('message')
+          show_view :index
+        end
+
+        def truncate_and_redirect_to_exceptions
+          GlobalErrorHandler::AppException.truncate(get_filter, field: params[:filter_by])
+          redirect exceptions_path
+        end
+
+        def redirect_to_exceptions
+          redirect exceptions_path(params[:start], params[:filter_by], params[:filter])
+        end
+
+        def show_view(filename = :index)
+          erb haml( File.read(File.join(GEH_VIEW_PATH, "#{filename}.html.haml")) )
+        end
+
+        def geh_public_view(filename, dir='')
+          file = File.join(GEH_PUBLIC_PATH, dir, filename)
+          begin
+            cache_control :public, :max_age => 1800
+            send_file file
+          rescue Errno::ENOENT
+            404
+          end
+        end
+
+        def exceptions_path(start = nil, filter_by = nil, filter = nil)
+          path = "/resque/exceptions"
+          path += "/filter/#{filter_by}/#{URI.escape(filter)}" if filter_by && filter
+          path += "?start=#{start}" if start
+          path
+        end
+
+        def exception_path(id, start=nil, filter_by = nil, filter = nil)
+          path = "/resque/exceptions/#{id}"
+          path_params = []
+          path_params.push "start=#{start}" if start
+          path_params.push "filter_by=#{filter_by}&filter=#{URI.escape(filter)}" if filter_by && filter
+          path += '?' + path_params.join('&') if path_params.size > 0
+          path
+        end
+
+        def apps_size
+          @apps_size ||= GlobalErrorHandler::AppException.count(params[:filter_by], get_filter).to_i
+        end
+
+        def apps_start_at
+          return 0 if apps_size < 1
+          params[:start].to_i + 1
+        end
+
+        def apps_per_page
+          10
+        end
+
+        def apps_end_at
+          if apps_start_at + apps_per_page > apps_size
+            apps_size
+          else
+            apps_start_at + apps_per_page - 1
+          end
+        end
+
+        def each_app_exception(&block)
+          return unless block_given?
+          @app_exceptions.try(:each) do |app_exception|
+            yield app_exception
+          end
+        end
+
+        def pagination(options = {})
+          start    = options[:start] || 0
+          per_page = apps_per_page
+          total    = options[:total] || 0
+          return if total < per_page
+
+          markup = ""
+          if start - per_page >= 0
+            markup << link_to(raw("&laquo; less"), exceptions_path(start - per_page), :class => 'btn less')
+          elsif start > 0 && start < per_page
+            markup << link_to(raw("&laquo; less"), exceptions_path(0), :class => 'btn less')
+          end
+
+          markup << pages_markup(start, per_page, total)
+
+          if start + per_page < total
+            markup << link_to(raw("more &raquo;"), exceptions_path(start + per_page), :class => 'btn more')
+          end
+          markup
+        end
+
+        def pages_markup(start, per_page, total)
+          pages_count = ((total - 1)/ per_page).ceil
+          return '' if pages_count < 1
+
+          left_ind = start / per_page
+          markups = [left_ind.to_s]
+          while (left_ind -= 1) >= 0 && (start/per_page - left_ind <= max_side_links || pages_count < max_links)
+            markups.unshift link_to(left_ind, exceptions_path(left_ind * per_page, params[:filter_by], params[:filter]), :class => 'btn pages')
+          end
+          right_ind = start / per_page
+          if right_ind > max_side_links && pages_count >= max_links
+            markups.unshift '...' if right_ind - max_side_links > 1
+            markups.unshift link_to(0, exceptions_path(0, params[:filter_by], params[:filter]), :class => 'btn pages')
+          end
+          while (right_ind +=1) * per_page < total && (right_ind - start / per_page <= max_side_links || pages_count < max_links)
+            markups.push link_to(right_ind, exceptions_path(per_page * right_ind, params[:filter_by], params[:filter]), :class => 'btn pages')
+          end
+          if pages_count >= max_links && pages_count >= right_ind
+            markups.push '...' if pages_count - right_ind >= 1
+            markups.push link_to(pages_count, exceptions_path(pages_count * per_page, params[:filter_by], params[:filter]), :class => 'btn pages')
+          end
+          markups.join(' ')
+        end
+
+        def max_side_links
+          4
+        end
+
+        def max_links
+          max_side_links * 2 + 1
+        end
+
+        def get_filter
+          URI.unescape(params[:filter]) if params[:filter]
+        end
+      end
+    end
+  end
+end

data/lib/global_error_handler/handler.rb

@@ -0,0 +1,25 @@
+class GlobalErrorHandler::Handler
+  def initialize(env, exception)
+    @env = env
+    @exception = exception
+    @controller = @env['action_controller.instance']
+    @parsed_error = nil
+  end
+
+  def process_exception!
+    return if @env['global_error_handler.proceed_time']
+    @env['global_error_handler.proceed_time'] = Time.now.utc
+    parse_exception
+    store_exception
+  end
+
+  private
+
+  def parse_exception
+    @parsed_error = GlobalErrorHandler::Parser.new(@env, @exception, @controller).parse
+  end
+
+  def store_exception
+    GlobalErrorHandler::Redis.store(@parsed_error.info_hash)
+  end
+end

data/lib/global_error_handler/middleware.rb

@@ -0,0 +1,15 @@
+class GlobalErrorHandler::Middleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    exception = nil
+    status, headers, response = @app.call(env)
+  rescue Exception => exception
+    GlobalErrorHandler::Handler.new(env, exception).process_exception!
+  ensure
+    raise exception if exception
+    [status, headers, response]
+  end
+end

data/lib/global_error_handler/parser.rb

@@ -0,0 +1,41 @@
+class GlobalErrorHandler::Parser
+  attr_reader :info_hash
+
+  def initialize(env, exception, controller)
+    @env = env
+    @exception = exception
+    @controller = controller
+    @request = ActionDispatch::Request.new(@env)
+    @info_hash = {}
+  end
+
+  def parse
+    @info_hash[:error_class]    = @exception.class.to_s.strip
+    @info_hash[:error_message]  = @exception.message.to_s.strip
+    @info_hash[:error_trace]    = @exception.backtrace.join("\n")
+    @info_hash[:request_method] = @request.method
+    @info_hash[:request_params] = @request.params
+    @info_hash[:target_url]     = @request.url
+    @info_hash[:referer_url]    = @request.referer
+    @info_hash[:user_agent]     = @request.user_agent
+    @info_hash[:user_info]      = user_info
+    @info_hash[:timestamp]      = Time.now.utc
+    self
+  end
+
+  private
+
+  def user_info
+    {
+      Orig_IP_Address: get_remote_ip,
+      IP_Address: @request.ip,
+      Remote_Address: @request.remote_addr
+    }
+  end
+
+  def get_remote_ip
+    @request.remote_ip
+  rescue => e
+    e.message
+  end
+end

data/lib/global_error_handler/rails.rb

@@ -0,0 +1,13 @@
+class GlobalErrorHandler::Railtie < Rails::Railtie
+  initializer 'global_error_handler.configure_rails_initialization' do
+    insert_middleware
+  end
+
+  def insert_middleware
+    if defined? ActionDispatch::DebugExceptions
+      Rails.application.middleware.insert_after ActionDispatch::DebugExceptions, GlobalErrorHandler::Middleware
+    else
+      Rails.application.middleware.use GlobalErrorHandler::Middleware
+    end
+  end
+end

data/lib/global_error_handler/redis.rb

@@ -0,0 +1,99 @@
+class GlobalErrorHandler::Redis
+  CURRENT_ID_KEY       = 'global_error_handler:current_id'
+  EXCEPTIONS_REDIS_KEY = 'global_error_handler:exceptions'
+  EXCEPTION_KEY_PREFIX = 'global_error_handler:exception'
+  FILTER_KEY_PREFIX    = 'global_error_handler:filter'
+
+  class << self
+    def store(info_hash)
+      redis_key = exception_key(next_id!)
+      redis.hmset redis_key, info_hash.merge(id: current_id).to_a.flatten
+      redis.rpush EXCEPTIONS_REDIS_KEY, redis_key
+      %w(error_class error_message).each do |field|
+        redis.rpush filter_key(field, info_hash[field.to_sym]), redis_key
+      end
+    end
+
+    def redis
+      @redis ||= begin
+                   unless $redis_global_exception_handler.is_a? Redis
+                     redis_config = YAML.load_file(File.join(Rails.root, 'config', 'redis.yml'))[Rails.env]
+                     $redis_global_exception_handler = Redis.new(redis_config['global_exception_handler'])
+                   end
+                   $redis_global_exception_handler
+                 end
+    end
+
+    def current_id
+      redis.get(CURRENT_ID_KEY)
+    end
+
+    # def sort(field, direction = 'ASC', page = 0, per_page = 1000)
+    #   redis.sort(EXCEPTIONS_REDIS_KEY, by: "#{EXCEPTION_KEY_PREFIX}_*->#{field}_*", order: "#{direction}", limit: [page, per_page])
+    # end
+
+    def exceptions_count
+      redis.llen EXCEPTIONS_REDIS_KEY
+    end
+
+    def filtered_exceptions_count(field, filter)
+      redis.llen filter_key(field, filter)
+    end
+
+    def exception_keys(page = 0, per_page = 10)
+      redis.lrange EXCEPTIONS_REDIS_KEY, page.to_i, per_page.to_i + page.to_i - 1
+    end
+
+    def filter_exception_keys(page = 0, field = nil, filter = nil, per_page = 10)
+      redis.lrange filter_key(field, filter), page.to_i, per_page.to_i + page.to_i - 1
+    end
+
+    def filter_keys_for(field)
+      redis.keys filter_key(field, '*')
+    end
+
+    def find(key)
+      Hashie::Mash.new redis.hgetall(key)
+    end
+
+    def find_all(keys)
+      keys.map { |key| find(key) }
+    end
+
+    def delete(key)
+      redis.lrem EXCEPTIONS_REDIS_KEY, 1, key
+      clear_filters key
+      redis.del key
+    end
+
+    def delete_all(keys)
+      keys.each { |key| delete(key) rescue next }
+    end
+
+    def truncate!
+      redis.flushdb
+    end
+
+    def exception_key(id = current_id)
+      "#{EXCEPTION_KEY_PREFIX}:#{id}"
+    end
+
+    def filter_key(field, filter)
+      "#{FILTER_KEY_PREFIX}:#{field}:#{filter}"
+    end
+
+    protected
+
+    def next_id!
+      redis.incr(CURRENT_ID_KEY)
+    end
+
+    def clear_filters(key)
+      %w(error_class error_message).each do |field|
+        filter_keys_for(field).each do |filter_key|
+          redis.lrem filter_key, 1, key
+        end
+      end
+    end
+  end
+end

data/lib/global_error_handler/server/public/css/global_error_handler.css

@@ -0,0 +1,8 @@
+.commands li { display: inline-block; }
+.commands li.filter {
+  float: right;
+}
+
+.commands li.filter select {
+  max-width: 300px;
+}

data/lib/global_error_handler/server/public/js/global_error_handler.js

@@ -0,0 +1,46 @@
+$(document).ready(function() {
+  $('.js-link').unbind('click');
+  $('.js-link').bind('click', function(event) {
+    event.preventDefault();
+    event.stopPropagation();
+    var h = document.createElement('input');
+    h.type = 'hidden';
+    h.name = '_method';
+    h.value = this.getAttribute('data-method');
+    var f = document.createElement('form');
+    f.appendChild(h);
+    f.style.display = 'none';
+
+    if(this.getAttribute('data-get-ids')){
+      checkboxes = $('.select-exception:checked').clone();
+      if(checkboxes.length == 0) {
+        alert('Select at least one exception to delete please.');
+        return false;
+      }
+      $(f).append(checkboxes);
+    }
+
+    this.parentNode.appendChild(f);
+    f.method = 'POST';
+    f.action = this.getAttribute('href');
+    if(confirm(this.getAttribute('data-confirm'))) {
+      f.submit();
+    } else {
+      f.parentNode.removeChild(f);
+    }
+    return false;
+  });
+
+  $('.select-all-exceptions').click(function() {
+    $('.select-exception').attr('checked', $(this).attr('checked'));
+  });
+
+  $('.filter-by').change(function() {
+    selected = $(this).val();
+    field = $(this).attr('data-field');
+    if(selected == '')
+      window.location = '/resque/exceptions'
+    else
+      window.location = '/resque/exceptions/filter/' + field + '/' + encodeURIComponent(encodeURIComponent(selected));
+  });
+})

data/lib/global_error_handler/server/views/index.html.haml

@@ -0,0 +1,45 @@
+- filter_suffix = "filter by Error #{params[:filter_by].capitalize}: #{get_filter}" if params[:filter_by]
+%h1 App Exceptions
+%p.sub #{filter_suffix}
+#app_exceptions
+  .commands
+    %ul
+      %li= link_to 'Delete selected', exception_path('delete', params[:start], params[:filter_by], params[:filter]),
+        method: :delete, class: 'js-link',
+        data: {confirm: 'Are you sure to delete selected Exceptions?', get_ids: true}
+      %li= link_to 'Truncate all', exceptions_path(nil, params[:filter_by], params[:filter]) + '/truncate',
+        method: :delete, class: 'js-link',
+        data: {confirm: 'Are you sure to truncate ALL the Exceptions?'}
+      %li.filter= select_tag 'filter_by_message', options_for_select(@all_messages, params[:filter_by].to_s.eql?('message') ? get_filter : nil), prompt: 'Error Message Filter',
+        class: 'filter-by', data: {field: 'message'}
+      %li.filter= select_tag 'filter_by_class', options_for_select(@all_classes, params[:filter_by].to_s.eql?('class') ? get_filter : nil), prompt: 'Error Class Filter',
+        class: 'filter-by', data: {field: 'class'}
+
+  %p.sub
+    Showing #{apps_start_at} to #{apps_end_at} of
+    %b #{apps_size}
+    exceptions
+
+  %table
+    %thead
+      %tr
+        %th= check_box_tag nil, nil, false, class: 'select-all-exceptions'
+        %th Timestamp
+        %th Error Class
+        %th Error Message
+        %th Error Trace
+        %th
+    %tbody
+      - each_app_exception do |app_exception|
+        %tr
+          %td= check_box_tag 'app_exception_delete_ids[]', app_exception.id, false, class: 'select-exception', id: "select-exception-#{app_exception.id}"
+          %td= link_to app_exception.timestamp, exception_path(app_exception.id)
+          %td= link_to app_exception.error_class, exception_path(app_exception.id)
+          %td= simple_format app_exception.error_message
+          %td= simple_format app_exception.error_trace.try(:split, "\n").try(:[], 0..4).try(:join, "\n")
+          %td= link_to 'Delete', exception_path(app_exception.id, params[:start], params[:filter_by], params[:filter]), method: :delete,
+            data: {confirm: 'Are you sure to remove an Exception?'}, class: 'js-link'
+  %p.pagination= pagination(start: apps_start_at - 1, total: apps_size)
+%script{type: 'text/javascript', src: '/resque/exceptions?js=global_error_handler.js'}
+%link{type: 'text/css', href: '/resque/style.css', rel: 'stylesheet'}
+%link{type: 'text/css', href: '/resque/exceptions?css=global_error_handler.css', rel: 'stylesheet'}

data/lib/global_error_handler/server/views/show.html.haml

@@ -0,0 +1,28 @@
+%h1 #{@app_exception.error_class} at #{@app_exception.timestamp} details
+
+%table
+  %tr
+    %th Message:
+    %td= simple_format @app_exception.error_message
+  %tr
+    %th Trace:
+    %td= simple_format @app_exception.error_trace
+  %tr
+    %th Request method:
+    %td= @app_exception.request_method
+  %tr
+    %th Request parameters:
+    %td= simple_format @app_exception.request_params
+  %tr
+    %th Target URL:
+    %td= simple_format @app_exception.target_url
+  %tr
+    %th Referer:
+    %td= simple_format @app_exception.referer_url
+  %tr
+    %th User Agent:
+    %td= simple_format @app_exception.user_agent
+  %tr
+    %th User Info:
+    %td= simple_format @app_exception.user_info
+

data/lib/global_error_handler/version.rb

@@ -0,0 +1,3 @@
+module GlobalErrorHandler
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: global_error_handler
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Andrii Rudenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.25'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.25.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.25'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.25.1
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.5
+description: On the middleware level catch an exception from Rails app and store in
+  the separated Redis database.
+email:
+- kolobock@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/redis_example.yml
+- global_error_handler.gemspec
+- lib/global_error_handler.rb
+- lib/global_error_handler/app_exception.rb
+- lib/global_error_handler/global_error_handler.rb
+- lib/global_error_handler/handler.rb
+- lib/global_error_handler/middleware.rb
+- lib/global_error_handler/parser.rb
+- lib/global_error_handler/rails.rb
+- lib/global_error_handler/redis.rb
+- lib/global_error_handler/server/public/css/global_error_handler.css
+- lib/global_error_handler/server/public/js/global_error_handler.js
+- lib/global_error_handler/server/views/index.html.haml
+- lib/global_error_handler/server/views/show.html.haml
+- lib/global_error_handler/version.rb
+homepage: https://github.com/kolobock/global_error_handler/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Records application' exceptions into the separated redis database.
+test_files: []