global_error_handler 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d058f4e5d9c2556661eeba4c09ae42089bb29c2
-  data.tar.gz: 0c91959443b2c90d8ac7368d16555477116f2813
+  metadata.gz: 8eb8957dd3db4d34bc8e895b41b35c9154d16881
+  data.tar.gz: e8fb838a0a0a55c7dc6f4d4595ec0c96657caceb
 SHA512:
-  metadata.gz: 9904aac4b619724df9f9322c88d362bd9de3a9ecdb2c82945fec8f8d573fc19e3497ae798ebb61b33505067cfc9c1e26f541d8969fcc5031db97df4c671f5bf0
-  data.tar.gz: 30f4ecd49fab72f0f2a2e70a15c3eb2c37e64e0e7269e9fdf148d037d4f78e2301e462e667324a25447cc92e058a849abe756a9cd96add3cadbb36bd0d0f66e1
+  metadata.gz: 279b12664a457a4adafa4b7225c24a8510b0fd860f1fe0a5b27ed70bac8f3455ce00359cea63c5a95a10fbff5ee23633fbb5da59d6825b8034dc16c4e593b3d4
+  data.tar.gz: 3abf0f128ae798551e589f9ec331de145a3c4cd5086dfe10d4be71f43505d0fc34d62aa231d52d646ad619251ddc37b75681f961f82dd1b8ebbfbeb00d67ad00

data/README.md

@@ -55,6 +55,14 @@ If `rescue_from` is used in your application, add following line at top of the m
 GlobalErrorHandler::Handler.new(request.env, exception).process_exception!
 ```
 
+### Subscribe to expired key notifications
+Following command should run on your server in case to automatically clear filters on deleting keys from redis due to expiration.
+Default expiration time is set to 4 weeks (`GlobalErrorHandler::Redis::REDIS_TTL`)
+
+```ruby
+GlobalErrorHandler::RedisNotificationSubscriber.subscribe!
+```
+
 ## Data structure
 Redis database data structure contains following below keys:
 - 'global_error_handler:current_id' : *STRING* - stores current id of an exception. It is being incremented on adding new exception into database

data/lib/global_error_handler.rb

@@ -19,4 +19,6 @@ require 'global_error_handler/rails' if defined? Rails::Railtie
 
 require "global_error_handler/version"
 
+require 'global_error_handler/redis_notification_subscriber'
+
 Resque::Server.register GlobalErrorHandler::Server

data/lib/global_error_handler/app_exception.rb

@@ -1,11 +1,11 @@
 class GlobalErrorHandler::AppException
   class << self
-    def all(page, field = nil, filter = nil)
-      page ||= 0
+    def all(start, field = nil, filter = nil)
+      start ||= 0
       if field && filter
-        keys = GlobalErrorHandler::Redis.filter_exception_keys page, "error_#{field}", filter
+        keys = GlobalErrorHandler::Redis.filter_exception_keys start, "error_#{field}", filter
       else
-        keys = GlobalErrorHandler::Redis.exception_keys page
+        keys = GlobalErrorHandler::Redis.exception_keys start
       end
       GlobalErrorHandler::Redis.find_all keys
     end
@@ -57,8 +57,8 @@ class GlobalErrorHandler::AppException
       end
     end
 
-    def filtered_ids_by(field, str, len=1000, page=0)
-      keys = GlobalErrorHandler::Redis.filter_exception_keys page, "error_#{field}", str, len
+    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

data/lib/global_error_handler/redis.rb

@@ -3,15 +3,19 @@ class GlobalErrorHandler::Redis
   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)
       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|
+      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
 
     def redis
@@ -40,16 +44,16 @@ class GlobalErrorHandler::Redis
       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
+    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(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
+    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)
-      redis.keys filter_key(field, '*')
+    def filter_keys_for(field, filter = '')
+      redis.keys filter_key(field, "#{filter}*")
     end
 
     def find(key)
@@ -57,12 +61,11 @@ class GlobalErrorHandler::Redis
     end
 
     def find_all(keys)
-      keys.map { |key| find(key) }
+      keys.map { |key| find(key) }.compact
     end
 
     def delete(key)
-      redis.lrem EXCEPTIONS_REDIS_KEY, 1, key
-      clear_filters key
+      delete_dependencies key
       redis.del key
     end
 
@@ -82,24 +85,31 @@ class GlobalErrorHandler::Redis
       "#{FILTER_KEY_PREFIX}:#{field}:#{filter}"
     end
 
-    protected
-
-    def next_id!
-      redis.incr(CURRENT_ID_KEY)
+    def delete_dependencies(key)
+      redis.lrem EXCEPTIONS_REDIS_KEY, 1, key
+      clear_filters key
     end
 
     def clear_filters(key)
-      %w(error_class error_message).each do |field|
-        filter_keys_for(field).each do |filter_key|
+      FILTER_FIELDS.each do |field|
+        field_value = build_filter_value(redis.hget key, field)
+        filter_keys_for(field, field_value).each do |filter_key|
           redis.lrem filter_key, 1, key
         end
       end
     end
 
+    protected
+
+    def next_id!
+      redis.incr(CURRENT_ID_KEY)
+    end
+
     private
 
     def build_filter_value(txt)
-      txt.split("\n").first rescue ''
+      str = txt.split("\n").first rescue ''
+      str[0...FILTER_MAX_CHARS]
     end
   end
 end

data/lib/global_error_handler/redis_notification_subscriber.rb

@@ -0,0 +1,66 @@
+require 'global_error_handler/redis'
+
+class GlobalErrorHandler::RedisNotificationSubscriber
+  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
+
+          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
+    end
+
+    def redis
+      GlobalErrorHandler::Redis.redis
+    end
+
+    def sub_channel
+      @sub_channel ||= "__keyevent@#{self.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 subscribers_count
+      redis.publish sub_channel, "check subscribers count from ##{Process.pid}"
+    end
+  end # class << self
+
+  class SubscriptionError < StandardError; end
+end

data/lib/global_error_handler/version.rb

@@ -1,3 +1,3 @@
 module GlobalErrorHandler
-  VERSION = "0.0.6"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: global_error_handler
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Andrii Rudenko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-02 00:00:00.000000000 Z
+date: 2014-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -106,6 +106,7 @@ files:
 - lib/global_error_handler/parser.rb
 - lib/global_error_handler/rails.rb
 - lib/global_error_handler/redis.rb
+- lib/global_error_handler/redis_notification_subscriber.rb
 - lib/global_error_handler/server.rb
 - lib/global_error_handler/server/public/css/global_error_handler.css
 - lib/global_error_handler/server/public/js/global_error_handler.js
@@ -132,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.4
 signing_key: 
 specification_version: 4
 summary: Records application' exceptions into the separated redis database.