global_error_handler 0.3.3 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c70689ea7861a6dc4822369f19a3d2c45974b9c
-  data.tar.gz: 564b9d3fa6450d891dc1a16696b736eb3627cf4e
+  metadata.gz: 08b88ca05ee6a8591095ccc87331c1bca8afaa71
+  data.tar.gz: 5242b40af3b6c0228fb80185cf948e987aef1263
 SHA512:
-  metadata.gz: 393e188541f6a3ee090a6f7070a31650f839e53e25b67226c827aa9cb4052ebfe35c45458900e3ef707c8587d89c2587e63b830bf95aa0bbcbaa85d7eaa52031
-  data.tar.gz: 986013620cacd84d4f71d8e329fa252bd7577e9e756497e24a47554cdf26f2f2beaa77f671128c7ec250d1b5c481e3e47cb522614b0c63ffcedf50f6cfb97323
+  metadata.gz: c6faa1b848bfc346376787cf7b212e90007174d14a07e4ff861dd206d5385ffb861600afb094ec329fad20a9340011dbedacd87d99cca2f14d34cb0184d3d379
+  data.tar.gz: 20e3123c510cd74ed829b477045cbe58c68402f4c427c2e999b1a2f13bd03782ca3c5cf69ef881d3aba52f3399526638cb0615633cc83ef2f8ca5579be1bba78

data/.gitignore

@@ -20,3 +20,4 @@ tmp
 *.o
 *.a
 mkmf.log
+config/redis.yml

data/Rakefile

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

data/global_error_handler.gemspec

@@ -4,23 +4,25 @@ $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.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.authors       = ['Andrii Rudenko']
+  spec.email         = ['kolobock@gmail.com']
+  spec.summary       = "Records application' exceptions into the separated redis database."
+  spec.description   = '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.add_development_dependency "bundler", '~> 1.6'
-  spec.add_development_dependency "rake", '~> 10.3', '>= 10.3.2'
-  spec.add_development_dependency "capistrano", "< 3.0"
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.3', '>= 10.3.2'
+  spec.add_development_dependency 'capistrano', '< 3.0'
 
   spec.add_dependency 'resque', '~> 1.25', '>= 1.25.1'
   spec.add_dependency 'haml', '~> 4.0', '>= 4.0.5', '< 4.1'
+  spec.add_runtime_dependency 'actionview', '>= 4.0.5', '< 4.3'
+  spec.add_dependency 'hashie', '>= 3.3'
 end

data/lib/global_error_handler/app_exception.rb

@@ -1,72 +1,80 @@
-class GlobalErrorHandler::AppException
-  class << self
-    def all(start, field = nil, filter = nil)
-      start ||= 0
-      if field && filter
-        keys = GlobalErrorHandler::Redis.filter_exception_keys start, "error_#{field}", filter
-      else
-        keys = GlobalErrorHandler::Redis.exception_keys start
+module GlobalErrorHandler
+  class AppException #:nodoc:
+    class << self
+      def all(start, field = nil, filter = nil)
+        start ||= 0
+        if field && filter
+          keys = Redis.filter_exception_keys start, "error_#{field}", filter
+        else
+          keys = Redis.exception_keys start
+        end
+        Redis.find_all keys
       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
+      def count(field = nil, filter = nil)
+        if field && filter
+          Redis.filtered_exceptions_count("error_#{field}", filter)
+        else
+          Redis.exceptions_count
+        end
       end
-    end
 
-    def find(id)
-      return if id.blank?
-      GlobalErrorHandler::Redis.find exception_key(id)
-    end
+      def find(id)
+        return if id.blank?
+        Redis.find exception_key(id)
+      end
 
-    def delete(id)
-      return if id.blank?
-      GlobalErrorHandler::Redis.delete exception_key(id)
-    end
+      def delete(id)
+        return if id.blank?
+        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 delete_all(ids)
+        return if ids.blank?
+        keys = ids.map { |id| exception_key id }
+        Redis.delete_all keys
+      end
 
-    def truncate(filter = nil, opts = {})
-      if filter
-        field = opts.delete(:field)
-        total = opts.delete(:total) || 1000
-        size = 1000
-        (total / size.to_f).ceil.times do |iteration|
-          ids = filtered_ids_by field, filter, size, iteration
-          delete_all ids unless ids.blank?
+      def truncate(filter = nil, opts = {})
+        if filter
+          field = opts.delete(:field)
+          total = opts.delete(:total) || 1000
+          size = 1000
+          (total / size.to_f).ceil.times do |iteration|
+            ids = filtered_ids_by field, filter, size, iteration
+            delete_all ids unless ids.blank?
+          end
+        else
+          Redis.truncate!
         end
-      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
+      def filters_for(field)
+        keys = Redis.filter_keys_for "error_#{field}"
+        return [] if keys.blank?
+        keys.map do |key|
+          key =~ /^#{Redis::FILTER_KEY_PREFIX}:error_#{field}:(.*)/
+          Regexp.last_match(1)
+        end
       end
-    end
 
-    def filtered_ids_by(field, str, len=1000, start=0)
-      keys = GlobalErrorHandler::Redis.filter_exception_keys start, "error_#{field}", str, len
-      return [] if keys.blank?
-      keys.map{ |key| key.split(':').last rescue nil }.compact
-    end
+      def filtered_ids_by(field, str, len = 1000, start = 0)
+        keys = Redis.filter_exception_keys start, "error_#{field}", str, len
+        return [] if keys.blank?
+        keys.map do |key|
+          begin
+            key.split(':').last
+          rescue
+            nil
+          end
+        end.compact
+      end
 
-    private
+      private
 
-    def exception_key(id)
-      GlobalErrorHandler::Redis.exception_key(id)
-    end
+      def exception_key(id)
+        Redis.exception_key(id)
+      end
+    end # class << self
   end
 end

data/lib/global_error_handler/handler.rb

@@ -1,25 +1,27 @@
-class GlobalErrorHandler::Handler
-  def initialize(env, exception)
-    @env = env
-    @exception = exception
-    @controller = @env['action_controller.instance']
-    @parsed_error = nil
-  end
+module GlobalErrorHandler
+  class Handler #:nodoc:
+    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
+    def process_exception!
+      return if @env['global_error_handler.proceed_time']
+      @env['global_error_handler.proceed_time'] = Time.current.utc
+      parse_exception
+      store_exception
+    end
 
-  private
+    private
 
-  def parse_exception
-    @parsed_error = GlobalErrorHandler::Parser.new(@env, @exception, @controller).parse
-  end
+    def parse_exception
+      @parsed_error = Parser.new(@env, @exception, @controller).parse
+    end
 
-  def store_exception
-    GlobalErrorHandler::Redis.store(@parsed_error.info_hash)
+    def store_exception
+      Redis.store(@parsed_error.info_hash)
+    end
   end
 end

data/lib/global_error_handler/middleware.rb

@@ -1,15 +1,17 @@
-class GlobalErrorHandler::Middleware
-  def initialize(app)
-    @app = app
-  end
+module GlobalErrorHandler
+  class Middleware #:nodoc:
+    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]
+    def call(env)
+      exception = nil
+      status, headers, response = @app.call(env)
+    rescue StandardError => exception
+      GlobalErrorHandler::Handler.new(env, exception).process_exception!
+    ensure
+      fail exception if exception
+      [status, headers, response]
+    end
   end
 end

data/lib/global_error_handler/parser.rb

@@ -1,47 +1,49 @@
-class GlobalErrorHandler::Parser
-  attr_reader :info_hash
+module GlobalErrorHandler
+  class Parser #:nodoc:
+    attr_reader :info_hash
 
-  def initialize(env, exception, controller)
-    @env = env
-    @exception = exception
-    @controller = controller
-    @request = ActionDispatch::Request.new(@env)
-    @info_hash = {}
-  end
+    def initialize(env, exception, controller)
+      @env = env
+      @exception = exception
+      @controller = controller
+      @request = ActionDispatch::Request.new(@env)
+      @info_hash = Hashie::Mash.new
+    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]    = form_backtrace @exception.backtrace
-    @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
+    def parse
+      info_hash.error_class    = @exception.class.to_s.strip
+      info_hash.error_message  = @exception.message.to_s.strip
+      info_hash.error_trace    = form_backtrace @exception.backtrace
+      info_hash.request_method = @request.method
+      info_hash.request_params = @request.params.to_s
+      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.to_s
+      info_hash.timestamp      = Time.current.utc
+      self
+    end
 
-  private
+    private
 
-  def user_info
-    {
-      Orig_IP_Address: get_remote_ip,
-      IP_Address: @request.ip,
-      Remote_Address: @request.remote_addr
-    }
-  end
+    def user_info
+      {
+        Orig_IP_Address: fetch_remote_ip,
+        IP_Address: @request.ip,
+        Remote_Address: @request.remote_addr
+      }
+    end
 
-  def get_remote_ip
-    @request.remote_ip
-  rescue => e
-    e.message
-  end
+    def fetch_remote_ip
+      @request.remote_ip
+    rescue => e
+      e.message
+    end
 
-  def form_backtrace(backtrace)
-    backtrace.join("\n")
-  rescue
-    ''
+    def form_backtrace(backtrace)
+      backtrace.join("\n")
+    rescue
+      ''
+    end
   end
 end

data/lib/global_error_handler/rails.rb

@@ -1,19 +1,21 @@
-class GlobalErrorHandler::Railtie < Rails::Railtie
-  railtie_name :global_error_handler
+module GlobalErrorHandler
+  class Railtie < Rails::Railtie #:nodoc:
+    railtie_name :global_error_handler
 
-  initializer 'global_error_handler.configure_rails_initialization' do
-    insert_middleware
-  end
+    initializer 'global_error_handler.configure_rails_initialization' do
+      insert_middleware
+    end
 
-  rake_tasks do
-    load File.join(File.dirname(__FILE__), '..', 'tasks', 'global_error_handler.rake')
-  end
+    rake_tasks do
+      load File.join(File.dirname(__FILE__), '..', 'tasks', 'global_error_handler.rake')
+    end
 
-  def insert_middleware
-    if defined? ActionDispatch::DebugExceptions
-      Rails.application.middleware.insert_after ActionDispatch::DebugExceptions, GlobalErrorHandler::Middleware
-    else
-      Rails.application.middleware.use GlobalErrorHandler::Middleware
+    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
 end

data/lib/global_error_handler/redis.rb

@@ -1,154 +1,186 @@
-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'
-  FILTER_FIELDS        = %w(error_class error_message)
-  FILTER_MAX_CHARS     = 60
-  REDIS_TTL            = 4 * 7 * 24 * 60 * 60 # 4 weeks
-
-  class << self
-    def store(info_hash)
-      return if info_hash.blank?
-      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
-      FILTER_FIELDS.each do |field|
-        redis.rpush filter_key(field, build_filter_value(info_hash[field.to_sym])), redis_key
-      end
-      redis.expire redis_key, REDIS_TTL
-    end
+module GlobalErrorHandler
+  class Redis #:nodoc:
+    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'
+    FILTER_FIELDS        = %w(error_class error_message)
+    FILTER_MAX_CHARS     = 60
+    REDIS_TTL            = 4 * 7 * 24 * 60 * 60 # 4 weeks
+
+    class << self
+      def store(info_hash)
+        return if info_hash.blank?
+        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
+        FILTER_FIELDS.each do |field|
+          redis.rpush filter_key(field, build_filter_value(info_hash[field])), redis_key
+        end
+        redis.expire redis_key, REDIS_TTL
+      end
 
-    def initialize_redis_from_config #:nodoc:
-      redis_config = YAML.load_file(File.join(Rails.root, 'config', 'redis.yml'))[Rails.env]
-      Redis.new(redis_config['global_exception_handler'])
-    end
+      def initialize_redis_from_config
+        redis_config = YAML.load_file(File.join(current_root, 'config', 'redis.yml'))[current_env]
+        ::Redis.new(redis_config['global_exception_handler'])
+      end
 
-    def redis
-      @redis ||= begin
-                   $redis_global_exception_handler = initialize_redis_from_config unless $redis_global_exception_handler.is_a? Redis
-                   $redis_global_exception_handler
-                 end
-    end
+      def redis
+        @redis ||= begin
+                     $redis_global_exception_handler = initialize_redis_from_config unless $redis_global_exception_handler.is_a? ::Redis
+                     $redis_global_exception_handler
+                   end
+      end
 
-    def current_id
-      redis.get(CURRENT_ID_KEY)
-    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 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 exceptions_count
+        redis.llen EXCEPTIONS_REDIS_KEY
+      end
 
-    def filtered_exceptions_count(field, filter)
-      redis.llen filter_key(field, filter)
-    end
+      def filtered_exceptions_count(field, filter)
+        redis.llen filter_key(field, filter)
+      end
 
-    def exception_keys(start = 0, per_page = 10)
-      redis.lrange EXCEPTIONS_REDIS_KEY, start.to_i, per_page.to_i + start.to_i - 1
-    end
+      def exception_keys(start = 0, per_page = 10)
+        redis.lrange EXCEPTIONS_REDIS_KEY, start.to_i, per_page.to_i + start.to_i - 1
+      end
 
-    def filter_exception_keys(start = 0, field = nil, filter = nil, per_page = 10)
-      redis.lrange filter_key(field, filter), start.to_i, per_page.to_i + start.to_i - 1
-    end
+      def filter_exception_keys(start = 0, field = nil, filter = nil, per_page = 10)
+        redis.lrange filter_key(field, filter), start.to_i, per_page.to_i + start.to_i - 1
+      end
 
-    def filter_keys_for(field, filter = '')
-      redis.keys filter_key(field, "#{filter}*")
-    end
+      def filter_keys_for(field, filter = '')
+        redis.keys filter_key(field, "#{filter}*")
+      end
 
-    def find(key)
-      Hashie::Mash.new redis.hgetall(key)
-    end
+      def find(key)
+        Hashie::Mash.new redis.hgetall(key)
+      end
 
-    def find_all(keys)
-      keys.map { |key| find(key) }.compact
-    end
+      def find_all(keys)
+        keys.map { |key| find(key) }.compact
+      end
 
-    def delete(key)
-      delete_dependencies key
-      redis.del key
-    end
+      def delete(key)
+        delete_dependencies key
+        redis.del key
+      end
 
-    def delete_all(keys)
-      keys.each { |key| delete(key) rescue next }
-    end
+      def delete_all(keys)
+        keys.each do |key|
+          begin
+            delete(key)
+          rescue
+            next
+          end
+        end
+      end
 
-    def truncate!
-      redis.flushdb
-    end
+      def truncate!
+        redis.flushdb
+      end
 
-    def exception_key(id = current_id)
-      "#{EXCEPTION_KEY_PREFIX}:#{id}"
-    end
+      def exception_key(id = current_id)
+        "#{EXCEPTION_KEY_PREFIX}:#{id}"
+      end
 
-    def filter_key(field, filter)
-      "#{FILTER_KEY_PREFIX}:#{field}:#{filter}"
-    end
+      def filter_key(field, filter)
+        "#{FILTER_KEY_PREFIX}:#{field}:#{filter}"
+      end
 
-    def delete_dependencies(key)
-      redis.lrem EXCEPTIONS_REDIS_KEY, 1, key
-      clear_filters key
-    end
+      def delete_dependencies(key)
+        redis.lrem EXCEPTIONS_REDIS_KEY, 1, key
+        clear_filters key
+      end
 
-    def clear_filters(key)
-      FILTER_FIELDS.each do |field|
-        retry_count = 0
-        field_value = build_filter_value(redis.hget key, field)
-        begin
-          filter_keys_for(field, field_value).each do |filter_key|
-            redis.lrem filter_key, 1, key
+      def clear_filters(key)
+        FILTER_FIELDS.each do |field|
+          retry_count = 0
+          field_value = build_filter_value(redis.hget key, field)
+          begin
+            filter_keys_for(field, field_value).each do |filter_key|
+              redis.lrem filter_key, 1, key
+            end
+          rescue
+            field_value = ''
+            retry if (retry_count += 1) < 2
           end
-        rescue
-          field_value = ''
-          retry if (retry_count += 1) < 2
         end
       end
-    end
 
-    def cleanup_database_dependencies!
-      total_exceptions_count = exceptions_count
-      total_exception_keys_count = redis.keys(exception_key('*')).size
-      if total_exceptions_count > total_exception_keys_count
-        puts "==> Database dependency is broken. Need to fix it!"
-        start = 0
-        per_page = 500
-        exception_keys_to_be_cleaned_up = []
-        valid_chunks_count = 0
-        cleanup_count = exception_keys_to_be_cleaned_up.size
-        while total_exceptions_count > start
-          exception_keys(start, per_page).each do |redis_key|
-            exception_keys_to_be_cleaned_up.push redis_key unless redis.exists(redis_key)
+      def cleanup_database_dependencies!
+        total_exceptions_count = exceptions_count
+        total_exception_keys_count = redis.keys(exception_key('*')).size
+        if total_exceptions_count > total_exception_keys_count
+          puts '==> Database dependency is broken. Need to fix it!'
+          start = 0
+          per_page = 500
+          exception_keys_to_be_cleaned_up = []
+          valid_chunks_count = 0
+          cleanup_count = exception_keys_to_be_cleaned_up.size
+          while total_exceptions_count > start
+            exception_keys(start, per_page).each do |redis_key|
+              exception_keys_to_be_cleaned_up.push redis_key unless redis.exists(redis_key)
+            end
+            if cleanup_count == (cleanup_count = exception_keys_to_be_cleaned_up.size)
+              valid_chunks_count += 1
+            end
+            break if valid_chunks_count > 3 # if three ranges in a row are consistent, treat database consistency and finish looping
+            start += per_page
           end
-          if cleanup_count == (cleanup_count = exception_keys_to_be_cleaned_up.size)
-            valid_chunks_count += 1
+
+          puts "*** found #{exception_keys_to_be_cleaned_up.count} broken dependency keys."
+          exception_keys_to_be_cleaned_up.each do |redis_key|
+            begin
+              delete_dependencies(redis_key)
+            rescue
+              next
+            end
           end
-          break if valid_chunks_count > 3 #if three ranges in a row are consistent, treat database consistency and finish looping
-          start += per_page
+        else
+          puts '==> Database dependency is OK. No need to fix it!'
         end
+      end
 
-        puts "*** found #{exception_keys_to_be_cleaned_up.count} broken dependency keys."
-        exception_keys_to_be_cleaned_up.each do |redis_key|
-          delete_dependencies(redis_key) rescue next
-        end
-      else
-        puts "==> Database dependency is OK. No need to fix it!"
+      protected
+
+      def next_id!
+        redis.incr(CURRENT_ID_KEY)
       end
-    end
 
-    protected
+      private
 
-    def next_id!
-      redis.incr(CURRENT_ID_KEY)
-    end
+      def build_filter_value(txt)
+        str = begin
+                txt.split("\n").first
+              rescue
+                ''
+              end
+        str[0...FILTER_MAX_CHARS]
+      end
 
-    private
+      def current_root
+        Rails.root
+      rescue
+        begin
+          settings.root
+        rescue
+          '.'
+        end
+      end
 
-    def build_filter_value(txt)
-      str = txt.split("\n").first rescue ''
-      str[0...FILTER_MAX_CHARS]
+      def current_env
+        Rails.env
+      rescue
+        ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      end
     end
   end
 end

data/lib/global_error_handler/redis_notification_subscriber.rb

@@ -1,66 +1,70 @@
 require 'global_error_handler/redis'
 
-class GlobalErrorHandler::RedisNotificationSubscriber
-  class << self
-    def unsubscribe!
-      redis.unsubscribe(sub_channel) rescue nil
-    end
+module GlobalErrorHandler
+  class RedisNotificationSubscriber #:nodoc:
+    class << self
+      def unsubscribe!
+        redis.unsubscribe(sub_channel)
+      rescue
+        nil
+      end
 
-    def subscribe!
-      check_redis_config
-      begin
-        raise SubscriptionError, "wont subscribe to ##{sub_channel}. Someone already listening to this channel" if subscribers_count > 0
-        redis.subscribe(sub_channel) do |on|
-          puts "*** ##{Process.pid}: Listeting for the notifications on ##{sub_channel}..."
-          on.message do |channel, key|
-            puts "**** ##{channel}: #{key}"
-            GlobalErrorHandler::Redis.delete_dependencies(key) if key =~ /#{GlobalErrorHandler::Redis.exception_key("\\d+")}/
-          end
-          on.subscribe do |channel, subscriptions|
-            puts "##{Process.pid}: Subscribed to ##{channel} (#{subscriptions} subscriptions)"
-          end
+      def subscribe!
+        check_redis_config
+        begin
+          fail SubscriptionError, "wont subscribe to ##{sub_channel}. Someone already listening to this channel" if subscribers_count > 0
+          redis.subscribe(sub_channel) do |on|
+            puts "*** ##{Process.pid}: Listeting for the notifications on ##{sub_channel}..."
+            on.message do |channel, key|
+              puts "**** ##{channel}: #{key}"
+              Redis.delete_dependencies(key) if key =~ /#{Redis.exception_key("\\d+")}/
+            end
+            on.subscribe do |channel, subscriptions|
+              puts "##{Process.pid}: Subscribed to ##{channel} (#{subscriptions} subscriptions)"
+            end
 
-          on.unsubscribe do |channel, subscriptions|
-            puts "##{Process.pid}: Unsubscribed from ##{channel} (#{subscriptions} subscriptions)"
+            on.unsubscribe do |channel, subscriptions|
+              puts "##{Process.pid}: Unsubscribed from ##{channel} (#{subscriptions} subscriptions)"
+            end
           end
+        rescue ::Redis::BaseConnectionError => error
+          puts "##{Process.pid}: #{error}, retrying in 1s"
+          sleep 1
+          retry
+        rescue SubscriptionError => error
+          puts "##{Process.pid}: #{error}, retrying in 1s"
+          sleep 1
+          retry
+        rescue Interrupt => error
+          puts "##{Process.pid}: unsubscribing..."
+          unsubscribe!
+          redis.quit
+          redis.client.reconnect
         end
-      rescue Redis::BaseConnectionError => error
-        puts "##{Process.pid}: #{error}, retrying in 1s"
-        sleep 1
-        retry
-      rescue SubscriptionError => error
-        puts "##{Process.pid}: #{error}, retrying in 1s"
-        sleep 1
-        retry
-      rescue Interrupt => error
-        puts "##{Process.pid}: unsubscribing..."
-        unsubscribe!
-        redis.quit
-        redis.client.reconnect
       end
-    end
 
-    def redis
-      @redis ||= GlobalErrorHandler::Redis.initialize_redis_from_config
-    end
+      def redis
+        @redis ||= Redis.initialize_redis_from_config
+      end
 
-    def sub_channel
-      @sub_channel ||= "__keyevent@#{self.redis.client.db}__:expired"
-    end
+      def sub_channel
+        @sub_channel ||= "__keyevent@#{redis.client.db}__:expired"
+      end
 
-    def check_redis_config
-      # x     Expired events (events generated every time a key expires)
-      # g     Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...
-      # A     Alias for g$lshzxe, so that the "AKE" string means all the events.
-      # E     Keyevent events, published with __keyevent@<db>__ prefix.
-      ### AE|gE|xE|AKE|gKE|xKE
-      redis.config('set', 'notify-keyspace-events', 'xE') unless redis.config('get', 'notify-keyspace-events').last =~ /[Agx]+.?E/
-    end
+      def check_redis_config
+        # x     Expired events (events generated every time a key expires)
+        # g     Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...
+        # A     Alias for g$lshzxe, so that the "AKE" string means all the events.
+        # E     Keyevent events, published with __keyevent@<db>__ prefix.
+        ### AE|gE|xE|AKE|gKE|xKE
+        redis.config('set', 'notify-keyspace-events', 'xE') unless redis.config('get', 'notify-keyspace-events').last =~ /[Agx]+.?E/
+      end
 
-    def subscribers_count
-      redis.publish sub_channel, "check subscribers count from ##{Process.pid}"
-    end
-  end # class << self
+      def subscribers_count
+        redis.publish sub_channel, "check subscribers count from ##{Process.pid}"
+      end
+    end # class << self
 
-  class SubscriptionError < StandardError; end
+    class SubscriptionError < StandardError; end
+  end
 end

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

@@ -10,10 +10,10 @@
       %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'}
+      %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

data/lib/global_error_handler/server.rb

@@ -1,5 +1,5 @@
 module GlobalErrorHandler
-  module Server
+  module Server #:nodoc:
     GEH_VIEW_PATH   = File.join(File.dirname(__FILE__), 'server', 'views')
     GEH_PUBLIC_PATH = File.join(File.dirname(__FILE__), 'server', 'public')
 
@@ -18,7 +18,7 @@ module GlobalErrorHandler
       end
 
       app.get '/exceptions/:id' do
-        @app_exception = GlobalErrorHandler::AppException.find(params[:id])
+        @app_exception = AppException.find(params[:id])
         show_view :show
       end
 
@@ -31,33 +31,34 @@ module GlobalErrorHandler
       end
 
       app.delete '/exceptions/delete' do
-        GlobalErrorHandler::AppException.delete_all(params[:app_exception_delete_ids])
+        AppException.delete_all(params[:app_exception_delete_ids])
         redirect_to_exceptions
       end
 
       app.delete '/exceptions/:id' do
-        GlobalErrorHandler::AppException.delete(params[:id])
+        AppException.delete(params[:id])
         redirect_to_exceptions
       end
 
       app.tabs << 'Exceptions'
 
+      require 'action_view'
       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
+        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')
+          @app_exceptions = AppException.all(params[:start], params[:filter_by], fetch_filter)
+          @all_classes = AppException.filters_for('class')
+          @all_messages = AppException.filters_for('message')
           show_view :index
         end
 
         def truncate_and_redirect_to_exceptions
-          GlobalErrorHandler::AppException.truncate(get_filter, field: params[:filter_by], total: apps_size)
+          AppException.truncate(fetch_filter, field: params[:filter_by], total: apps_size)
           redirect exceptions_path
         end
 
@@ -66,10 +67,10 @@ module GlobalErrorHandler
         end
 
         def show_view(filename = :index)
-          erb haml( File.read(File.join(GEH_VIEW_PATH, "#{filename}.html.haml")) )
+          erb haml(File.read(File.join(GEH_VIEW_PATH, "#{filename}.html.haml")))
         end
 
-        def geh_public_view(filename, dir='')
+        def geh_public_view(filename, dir = '')
           file = File.join(GEH_PUBLIC_PATH, dir, filename)
           begin
             cache_control :public, max_age: 1800
@@ -80,13 +81,13 @@ module GlobalErrorHandler
         end
 
         def exceptions_path(start = nil, filter_by = nil, filter = nil)
-          path = "/resque/exceptions"
+          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)
+        def exception_path(id, start = nil, filter_by = nil, filter = nil)
           path = "/resque/exceptions/#{id}"
           path_params = []
           path_params.push "start=#{start}" if start
@@ -96,7 +97,7 @@ module GlobalErrorHandler
         end
 
         def apps_size
-          @apps_size ||= GlobalErrorHandler::AppException.count(params[:filter_by], get_filter).to_i
+          @apps_size ||= AppException.count(params[:filter_by], fetch_filter).to_i
         end
 
         def apps_start_at
@@ -116,7 +117,7 @@ module GlobalErrorHandler
           end
         end
 
-        def each_app_exception(&block)
+        def each_app_exception
           return unless block_given?
           @app_exceptions.try(:each) do |app_exception|
             yield app_exception
@@ -129,17 +130,17 @@ module GlobalErrorHandler
           total    = options[:total] || 0
           return if total < per_page
 
-          markup = ""
+          markup = ''
           if start - per_page >= 0
-            markup << link_to(raw("&laquo; less"), exceptions_path(start - per_page), class: 'btn less')
+            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')
+            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')
+            markup << link_to(raw('more &raquo;'), exceptions_path(start + per_page), class: 'btn more')
           end
           markup
         end
@@ -150,7 +151,7 @@ module GlobalErrorHandler
 
           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)
+          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
@@ -158,7 +159,7 @@ module GlobalErrorHandler
             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)
+          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
@@ -176,7 +177,7 @@ module GlobalErrorHandler
           max_side_links * 2 + 1
         end
 
-        def get_filter
+        def fetch_filter
           URI.unescape(params[:filter]) if params[:filter]
         end
       end

data/lib/global_error_handler/version.rb

@@ -1,3 +1,3 @@
-module GlobalErrorHandler
-  VERSION = "0.3.3"
+module GlobalErrorHandler #:nodoc:
+  VERSION = '1.0.2'
 end

data/lib/global_error_handler.rb

@@ -1,23 +1,24 @@
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
 
-module GlobalErrorHandler
+module GlobalErrorHandler #:nodoc:
 end
 
 require 'resque'
 require 'resque/server'
 require 'haml'
-
+require 'hashie'
 
 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/server'
 
 require 'global_error_handler/middleware'
 require 'global_error_handler/rails' if defined? Rails::Railtie
 
-require "global_error_handler/version"
+require 'global_error_handler/version'
 
 require 'global_error_handler/redis_notification_subscriber'
 

data/lib/recipes/global_error_handler.rb

@@ -1,17 +1,17 @@
 module GlobalErrorHandler
-  class Capistrano
+  class Capistrano #:nodoc:
     def self.load_into(config)
       config.load do
         namespace :global_error_handler do
           desc 'Subscribe to expiration'
           task :subscribe do
-            run %Q{cd #{current_path} && RAILS_ENV=#{rails_env} nohup rake global_error_handler:cleanup_database_dependencies >/dev/null 2>&1 & sleep 2}
-            run %Q{cd #{current_path} && RAILS_ENV=#{rails_env} nohup rake global_error_handler:subscribe_to_expired >/dev/null 2>&1 & sleep 3}
+            run %(cd #{current_path} && RAILS_ENV=#{rails_env} nohup rake global_error_handler:cleanup_database_dependencies >/dev/null 2>&1 & sleep 2)
+            run %(cd #{current_path} && RAILS_ENV=#{rails_env} nohup rake global_error_handler:subscribe_to_expired >/dev/null 2>&1 & sleep 3)
           end
 
           desc 'Unsubscribe from expiration'
           task :unsubscribe do
-            run %Q{cd #{current_path} && RAILS_ENV=#{rails_env} #{rake} global_error_handler:unsubscribe_from_expired}
+            run %(cd #{current_path} && RAILS_ENV=#{rails_env} #{rake} global_error_handler:unsubscribe_from_expired)
           end
 
           desc 'Update Subscription to expiration'

data/lib/tasks/global_error_handler.rake

@@ -1,18 +1,22 @@
 namespace :global_error_handler do
   desc 'Subscribe to expired keyevent notifications'
   task subscribe_to_expired: :environment do
-    puts '*** pid file exists!' or next if File.exists?(pid_file)
-    File.open(pid_file, 'w'){|f| f.puts Process.pid}
+    puts('*** pid file exists!') || next if File.exist?(pid_file)
+    File.open(pid_file, 'w') { |f| f.puts Process.pid }
     begin
       GlobalErrorHandler::RedisNotificationSubscriber.subscribe!
     ensure
-      File.unlink pid_file rescue nil
+      begin
+        File.unlink pid_file
+      rescue
+        nil
+      end
     end
   end
 
   desc 'Unsubscribe from expired keyevent notifications'
   task unsubscribe_from_expired: :environment do
-    puts '*** pid file does not exist!' or next unless File.exists?(pid_file)
+    puts('*** pid file does not exist!') || next unless File.exist?(pid_file)
     process_id = File.read(pid_file).to_i
     begin
       Process.kill 0, process_id
@@ -25,7 +29,11 @@ namespace :global_error_handler do
     rescue Errno::ESRCH
       puts "** No such process ##{process_id}. Exiting..."
     ensure
-      File.unlink pid_file rescue nil
+      begin
+        File.unlink pid_file
+      rescue
+        nil
+      end
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: global_error_handler
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 1.0.2
 platform: ruby
 authors:
 - Andrii Rudenko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-16 00:00:00.000000000 Z
+date: 2015-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -104,6 +104,40 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.5
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.5
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.3'
 description: On the middleware level catch an exception from Rails app and store in
   the separated Redis database.
 email: