exception-track 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 032c9ba1ad0589f704bedbff866d3bab2aae870abc44251b2e8b5f504732fe77
-  data.tar.gz: 72946a5e0284dac9fd318671aa46f2322c10522010a6d2c076024801d7749be9
+  metadata.gz: 71a2bc45d225661a466bdd4fe3ae8227253cf0e4e48430a3f3db33605c04aed7
+  data.tar.gz: fbf989949bd59b5ac8ea1b44c159cae09ded01832c21c42193729a95b20f3015
 SHA512:
-  metadata.gz: 4e2fe6f4660aec15140e9fa70f1876a51d78e1c61fdc98cfadfaaee08a5426fc3ddba66e6b3b858cc119293add6503a95bd3934de779bdcb22cb23ad0bfbfe61
-  data.tar.gz: 3807967a319b57e6e7a1fe1dc0647e3bbb4496729b47ddd392d9a36973f4d76c7470dfb646c085a841d9921b5295e8e6e6de170534a55d51bcd739295cdebbb6
+  metadata.gz: a7b776ccbda802c32ca77f60ec4257e198d2e9e96c611ccc03c14fb00efc1fb5f127a60e9df627b985ddef347d1e1ceb2f04c8919894ab73da3ac796fe8cc0c5
+  data.tar.gz: 14a4f70638b02742170ff3138d553624a8c379b2c0480624f178354fd0324dbcb58d5d75627e78f24026338fbeb750478431034ac76eb3b7cb3f8cd42df4dc9e

data/lib/exception-track/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ExceptionTrack
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/lib/exception-track.rb

@@ -7,7 +7,6 @@ require "exception-track/engine"
 
 require "exception_notification"
 require "exception_notification/rails"
-require "exception_notifier/exception_track_notifier"
 
 require "kaminari"
 
@@ -28,5 +27,5 @@ module ExceptionTrack
 end
 
 ExceptionNotification.configure do |config|
-  config.add_notifier :exception_track, {}
+  config.add_notifier :db, {}
 end

data/lib/exception_notification/rack.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ExceptionNotification
+  class Rack
+    class CascadePassException < RuntimeError; end
+
+    def initialize(app, options = {})
+      @app = app
+
+      ExceptionNotifier.tap do |en|
+        en.ignored_exceptions = options.delete(:ignore_exceptions) if options.key?(:ignore_exceptions)
+        en.error_grouping = options.delete(:error_grouping) if options.key?(:error_grouping)
+        en.error_grouping_period = options.delete(:error_grouping_period) if options.key?(:error_grouping_period)
+        en.notification_trigger = options.delete(:notification_trigger) if options.key?(:notification_trigger)
+
+        if options.key?(:error_grouping_cache)
+          en.error_grouping_cache = options.delete(:error_grouping_cache)
+        elsif defined?(Rails) && Rails.respond_to?(:cache)
+          en.error_grouping_cache = Rails.cache
+        end
+      end
+
+      if options.key?(:ignore_if)
+        rack_ignore = options.delete(:ignore_if)
+        ExceptionNotifier.ignore_if do |exception, opts|
+          opts.key?(:env) && rack_ignore.call(opts[:env], exception)
+        end
+      end
+
+      if options.key?(:ignore_notifier_if)
+        rack_ignore_by_notifier = options.delete(:ignore_notifier_if)
+        rack_ignore_by_notifier.each do |notifier, proc|
+          ExceptionNotifier.ignore_notifier_if(notifier) do |exception, opts|
+            opts.key?(:env) && proc.call(opts[:env], exception)
+          end
+        end
+      end
+
+      ExceptionNotifier.ignore_crawlers(options.delete(:ignore_crawlers)) if options.key?(:ignore_crawlers)
+
+      @ignore_cascade_pass = options.delete(:ignore_cascade_pass) { true }
+
+      options.each do |notifier_name, opts|
+        ExceptionNotifier.register_exception_notifier(notifier_name, opts)
+      end
+    end
+
+    def call(env)
+      _, headers, = response = @app.call(env)
+
+      if !@ignore_cascade_pass && headers["X-Cascade"] == "pass"
+        msg = "This exception means that the preceding Rack middleware set the 'X-Cascade' header to 'pass' -- in " \
+              "Rails, this often means that the route was not found (404 error)."
+        raise CascadePassException, msg
+      end
+
+      response
+    rescue Exception => e
+      env["exception_notifier.delivered"] = true if ExceptionNotifier.notify_exception(e, env: env)
+
+      raise e unless e.is_a?(CascadePassException)
+
+      response
+    end
+  end
+end

data/lib/exception_notification/rails.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ExceptionNotification
+  class Engine < ::Rails::Engine
+    config.exception_notification = ExceptionNotifier
+    config.exception_notification.logger = Rails.logger
+    config.exception_notification.error_grouping_cache = Rails.cache
+
+    config.app_middleware.use ExceptionNotification::Rack
+  end
+end

data/lib/exception_notification/resque.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "resque/failure/base"
+
+module ExceptionNotification
+  class Resque < Resque::Failure::Base
+    def self.count
+      ::Resque::Stat[:failed]
+    end
+
+    def save
+      data = {
+        error_class: exception.class.name,
+        error_message: exception.message,
+        failed_at: Time.now.to_s,
+        payload: payload,
+        queue: queue,
+        worker: worker.to_s
+      }
+
+      ExceptionNotifier.notify_exception(exception, data: {resque: data})
+    end
+  end
+end

data/lib/exception_notification/sidekiq.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+# Note: this class is only needed for Sidekiq version < 3.
+module ExceptionNotification
+  class Sidekiq
+    def call(_worker, msg, _queue)
+      yield
+    rescue Exception => e
+      ExceptionNotifier.notify_exception(e, data: {sidekiq: msg})
+      raise e
+    end
+  end
+end
+
+if ::Sidekiq::VERSION < "3"
+  ::Sidekiq.configure_server do |config|
+    config.server_middleware do |chain|
+      chain.add ::ExceptionNotification::Sidekiq
+    end
+  end
+else
+  ::Sidekiq.configure_server do |config|
+    config.error_handlers << proc do |ex, context|
+      ExceptionNotifier.notify_exception(ex, data: {sidekiq: context})
+    end
+  end
+end

data/lib/exception_notification/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ExceptionNotification
+  VERSION = "4.5.0"
+end

data/lib/exception_notification.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "exception_notifier/notifier"
+require "exception_notification/rack"
+require "exception_notification/version"
+
+module ExceptionNotification
+  # Alternative way to setup ExceptionNotification.
+  # Run 'rails generate exception_notification:install' to create
+  # a fresh initializer with all configuration values.
+  def self.configure
+    yield ExceptionNotifier
+  end
+end

data/lib/exception_notifier/base_notifier.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ExceptionNotifier
+  class BaseNotifier
+    attr_accessor :base_options
+
+    def initialize(options = {})
+      @base_options = options
+    end
+
+    def send_notice(exception, options, message, message_opts = nil)
+      _pre_callback(exception, options, message, message_opts)
+      result = yield(message, message_opts)
+      _post_callback(exception, options, message, message_opts)
+      result
+    end
+
+    def _pre_callback(exception, options, message, message_opts)
+      return unless @base_options[:pre_callback].respond_to?(:call)
+
+      @base_options[:pre_callback].call(options, self, exception.backtrace, message, message_opts)
+    end
+
+    def _post_callback(exception, options, message, message_opts)
+      return unless @base_options[:post_callback].respond_to?(:call)
+
+      @base_options[:post_callback].call(options, self, exception.backtrace, message, message_opts)
+    end
+  end
+end

data/lib/exception_notifier/{exception_track_notifier.rb → db_notifier.rb}

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module ExceptionNotifier
-  class ExceptionTrackNotifier < ExceptionNotifier::BaseNotifier
-    def initialize(_opts); end
+  class DbNotifier < ExceptionNotifier::BaseNotifier
+    def initialize(opts = {})
+      super(opts)
+    end
 
     def call(exception, opts = {})
       return unless ExceptionTrack.config.enabled_env?(Rails.env)
@@ -26,7 +28,7 @@ module ExceptionNotifier
           ExceptionTrack::Log.create(title: title[0, 200], body: messages.join("\n"))
         end
       end
-    rescue StandardError => e
+    rescue => e
       errs = []
       errs << "-- [ExceptionTrack] create error ---------------------------"
       errs << e.message.indent(2)
@@ -45,14 +47,14 @@ module ExceptionNotifier
       parameters = filter_parameters(env)
 
       headers = []
-      headers << "Method:      #{env['REQUEST_METHOD']}"
-      headers << "URL:         #{env['REQUEST_URI']}"
+      headers << "Method:      #{env["REQUEST_METHOD"]}"
+      headers << "URL:         #{env["REQUEST_URI"]}"
       headers << "Parameters:\n#{pretty_hash(parameters.except(:controller, :action), 13)}" if env["REQUEST_METHOD"].downcase != "get"
-      headers << "Controller:  #{parameters['controller']}##{parameters['action']}"
-      headers << "RequestId:   #{env['action_dispatch.request_id']}"
-      headers << "User-Agent:  #{env['HTTP_USER_AGENT']}"
-      headers << "Remote IP:   #{env['REMOTE_ADDR']}"
-      headers << "Language:    #{env['HTTP_ACCEPT_LANGUAGE']}"
+      headers << "Controller:  #{parameters["controller"]}##{parameters["action"]}"
+      headers << "RequestId:   #{env["action_dispatch.request_id"]}"
+      headers << "User-Agent:  #{env["HTTP_USER_AGENT"]}"
+      headers << "Remote IP:   #{env["REMOTE_ADDR"]}"
+      headers << "Language:    #{env["HTTP_ACCEPT_LANGUAGE"]}"
       headers << "Server:      #{Socket.gethostname}"
       headers << "Process:     #{$PROCESS_ID}"
 
@@ -63,7 +65,7 @@ module ExceptionNotifier
       parameters = env["action_dispatch.request.parameters"] || {}
       parameter_filter = ActiveSupport::ParameterFilter.new(env["action_dispatch.parameter_filter"] || [])
       parameter_filter.filter(parameters)
-    rescue StandardError => e
+    rescue => e
       Rails.logger.error "filter_parameters error: #{e.inspect}"
       parameters
     end

data/lib/exception_notifier/modules/backtrace_cleaner.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ExceptionNotifier
+  module BacktraceCleaner
+    def clean_backtrace(exception)
+      if defined?(Rails) && Rails.respond_to?(:backtrace_cleaner)
+        Rails.backtrace_cleaner.send(:filter, exception.backtrace)
+      else
+        exception.backtrace
+      end
+    end
+  end
+end

data/lib/exception_notifier/modules/error_grouping.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+if Rails.version > "7.0"
+  require "active_support/isolated_execution_state"
+end
+require "active_support/core_ext/numeric/time"
+require "active_support/concern"
+
+module ExceptionNotifier
+  module ErrorGrouping
+    extend ActiveSupport::Concern
+
+    included do
+      mattr_accessor :error_grouping
+      self.error_grouping = false
+
+      mattr_accessor :error_grouping_period
+      self.error_grouping_period = 5.minutes
+
+      mattr_accessor :notification_trigger
+
+      mattr_accessor :error_grouping_cache
+    end
+
+    module ClassMethods
+      # Fallback to the memory store while the specified cache store doesn't work
+      #
+      def fallback_cache_store
+        @fallback_cache_store ||= ActiveSupport::Cache::MemoryStore.new
+      end
+
+      def error_count(error_key)
+        count =
+          begin
+            error_grouping_cache.read(error_key)
+          rescue => e
+            log_cache_error(error_grouping_cache, e, :read)
+            fallback_cache_store.read(error_key)
+          end
+
+        count&.to_i
+      end
+
+      def save_error_count(error_key, count)
+        error_grouping_cache.write(error_key, count, expires_in: error_grouping_period)
+      rescue => e
+        log_cache_error(error_grouping_cache, e, :write)
+        fallback_cache_store.write(error_key, count, expires_in: error_grouping_period)
+      end
+
+      def group_error!(exception, options)
+        message_based_key = "exception:#{Zlib.crc32("#{exception.class.name}\nmessage:#{exception.message}")}"
+        accumulated_errors_count = 1
+
+        if (count = error_count(message_based_key))
+          accumulated_errors_count = count + 1
+          save_error_count(message_based_key, accumulated_errors_count)
+        else
+          backtrace_based_key =
+            "exception:#{Zlib.crc32("#{exception.class.name}\npath:#{exception.backtrace.try(:first)}")}"
+
+          if (count = error_grouping_cache.read(backtrace_based_key))
+            accumulated_errors_count = count + 1
+            save_error_count(backtrace_based_key, accumulated_errors_count)
+          else
+            save_error_count(backtrace_based_key, accumulated_errors_count)
+            save_error_count(message_based_key, accumulated_errors_count)
+          end
+        end
+
+        options[:accumulated_errors_count] = accumulated_errors_count
+      end
+
+      def send_notification?(exception, count)
+        if notification_trigger.respond_to?(:call)
+          notification_trigger.call(exception, count)
+        else
+          factor = Math.log2(count)
+          factor.to_i == factor
+        end
+      end
+
+      private
+
+      def log_cache_error(cache, exception, action)
+        "#{cache.inspect} failed to #{action}, reason: #{exception.message}. Falling back to memory cache store."
+      end
+    end
+  end
+end

data/lib/exception_notifier/modules/formatter.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/time"
+require "action_dispatch"
+
+module ExceptionNotifier
+  class Formatter
+    include ExceptionNotifier::BacktraceCleaner
+
+    attr_reader :app_name
+
+    def initialize(exception, opts = {})
+      @exception = exception
+
+      @env = opts[:env]
+      @errors_count = opts[:accumulated_errors_count].to_i
+      @app_name = opts[:app_name] || rails_app_name
+    end
+
+    #
+    # :warning: Error occurred in production :warning:
+    # :warning: Error occurred :warning:
+    #
+    def title
+      env = Rails.env if defined?(::Rails) && ::Rails.respond_to?(:env)
+
+      if env
+        "⚠️ Error occurred in #{env} ⚠️"
+      else
+        "⚠️ Error occurred ⚠️"
+      end
+    end
+
+    #
+    # A *NoMethodError* occurred.
+    # 3 *NoMethodError* occurred.
+    # A *NoMethodError* occurred in *home#index*.
+    #
+    def subtitle
+      errors_text = if errors_count > 1
+        errors_count
+      else
+        /^[aeiou]/i.match?(exception.class.to_s) ? "An" : "A"
+      end
+
+      in_action = " in *#{controller_and_action}*" if controller
+
+      "#{errors_text} *#{exception.class}* occurred#{in_action}."
+    end
+
+    #
+    #
+    # *Request:*
+    # ```
+    # * url : https://www.example.com/
+    # * http_method : GET
+    # * ip_address : 127.0.0.1
+    # * parameters : {"controller"=>"home", "action"=>"index"}
+    # * timestamp : 2019-01-01 00:00:00 UTC
+    # ```
+    #
+    def request_message
+      request = ActionDispatch::Request.new(env) if env
+      return unless request
+
+      [
+        "```",
+        "* url : #{request.original_url}",
+        "* http_method : #{request.method}",
+        "* ip_address : #{request.remote_ip}",
+        "* parameters : #{request.filtered_parameters}",
+        "* timestamp : #{Time.current}",
+        "```"
+      ].join("\n")
+    end
+
+    #
+    #
+    # *Backtrace:*
+    # ```
+    # * app/controllers/my_controller.rb:99:in `specific_function'
+    # * app/controllers/my_controller.rb:70:in `specific_param'
+    # * app/controllers/my_controller.rb:53:in `my_controller_params'
+    # ```
+    #
+    def backtrace_message
+      backtrace = exception.backtrace ? clean_backtrace(exception) : nil
+
+      return unless backtrace
+
+      text = []
+
+      text << "```"
+      backtrace.first(3).each { |line| text << "* #{line}" }
+      text << "```"
+
+      text.join("\n")
+    end
+
+    #
+    # home#index
+    #
+    def controller_and_action
+      "#{controller.controller_name}##{controller.action_name}" if controller
+    end
+
+    private
+
+    attr_reader :exception, :env, :errors_count
+
+    def rails_app_name
+      return unless defined?(::Rails) && ::Rails.respond_to?(:application)
+
+      if Rails::VERSION::MAJOR >= 6
+        Rails.application.class.module_parent_name.underscore
+      else
+        Rails.application.class.parent_name.underscore
+      end
+    end
+
+    def controller
+      env["action_controller.instance"] if env
+    end
+  end
+end

data/lib/exception_notifier/notifier.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "logger"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/module/attribute_accessors"
+require "exception_notifier/base_notifier"
+require "exception_notifier/modules/error_grouping"
+
+module ExceptionNotifier
+  include ErrorGrouping
+
+  autoload :BacktraceCleaner, "exception_notifier/modules/backtrace_cleaner"
+  autoload :Formatter, "exception_notifier/modules/formatter"
+
+  autoload :Notifier, "exception_notifier/notifier"
+  autoload :DbNotifier, "exception_notifier/db_notifier"
+
+  class UndefinedNotifierError < StandardError; end
+
+  # Define logger
+  mattr_accessor :logger
+  @@logger = Logger.new($stdout)
+
+  # Define a set of exceptions to be ignored, ie, dont send notifications when any of them are raised.
+  mattr_accessor :ignored_exceptions
+  @@ignored_exceptions = %w[
+    AbstractController::ActionNotFound
+    ActionController::BadRequest
+    ActionController::InvalidAuthenticityToken
+    ActionController::InvalidCrossOriginRequest
+    ActionController::ParameterMissing
+    ActionController::RoutingError
+    ActionController::UnknownFormat
+    ActionController::UrlGenerationError
+    ActionView::MissingTemplate
+    ActionView::TemplateError
+    ActiveRecord::RecordNotFound
+    Mime::Type::InvalidMimeType
+    Mongoid::Errors::DocumentNotFound
+  ]
+
+  mattr_accessor :testing_mode
+  @@testing_mode = false
+
+  class << self
+    # Store conditions that decide when exceptions must be ignored or not.
+    @@ignores = []
+
+    # Store by-notifier conditions that decide when exceptions must be ignored or not.
+    @@by_notifier_ignores = {}
+
+    # Store notifiers that send notifications when exceptions are raised.
+    @@notifiers = {}
+
+    def testing_mode!
+      self.testing_mode = true
+    end
+
+    def notify_exception(exception, options = {}, &block)
+      return false if ignored_exception?(options[:ignore_exceptions], exception)
+      return false if ignored?(exception, options)
+
+      if error_grouping
+        errors_count = group_error!(exception, options)
+        return false unless send_notification?(exception, errors_count)
+      end
+
+      notification_fired = false
+      selected_notifiers = options.delete(:notifiers) || notifiers
+      [*selected_notifiers].each do |notifier|
+        unless notifier_ignored?(exception, options, notifier: notifier)
+          fire_notification(notifier, exception, options.dup, &block)
+          notification_fired = true
+        end
+      end
+
+      notification_fired
+    end
+
+    def register_exception_notifier(name, notifier_or_options)
+      if notifier_or_options.respond_to?(:call)
+        @@notifiers[name] = notifier_or_options
+      elsif notifier_or_options.is_a?(Hash)
+        create_and_register_notifier(name, notifier_or_options)
+      else
+        raise ArgumentError, "Invalid notifier '#{name}' defined as #{notifier_or_options.inspect}"
+      end
+    end
+    alias_method :add_notifier, :register_exception_notifier
+
+    def unregister_exception_notifier(name)
+      @@notifiers.delete(name)
+    end
+
+    def registered_exception_notifier(name)
+      @@notifiers[name]
+    end
+
+    def notifiers
+      @@notifiers.keys
+    end
+
+    # Adds a condition to decide when an exception must be ignored or not.
+    #
+    #   ExceptionNotifier.ignore_if do |exception, options|
+    #     not Rails.env.production?
+    #   end
+    def ignore_if(&block)
+      @@ignores << block
+    end
+
+    def ignore_notifier_if(notifier, &block)
+      @@by_notifier_ignores[notifier] = block
+    end
+
+    def ignore_crawlers(crawlers)
+      ignore_if do |_exception, opts|
+        opts.key?(:env) && from_crawler(opts[:env], crawlers)
+      end
+    end
+
+    def clear_ignore_conditions!
+      @@ignores.clear
+      @@by_notifier_ignores.clear
+    end
+
+    private
+
+    def ignored?(exception, options)
+      @@ignores.any? { |condition| condition.call(exception, options) }
+    rescue Exception => e
+      raise e if @@testing_mode
+
+      logger.warn(
+        "An error occurred when evaluating an ignore condition. #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+      )
+      false
+    end
+
+    def notifier_ignored?(exception, options, notifier:)
+      return false unless @@by_notifier_ignores.key?(notifier)
+
+      condition = @@by_notifier_ignores[notifier]
+      condition.call(exception, options)
+    rescue Exception => e
+      raise e if @@testing_mode
+
+      logger.warn(<<~"MESSAGE")
+        An error occurred when evaluating a by-notifier ignore condition. #{e.class}: #{e.message}
+        #{e.backtrace.join("\n")}
+      MESSAGE
+      false
+    end
+
+    def ignored_exception?(ignore_array, exception)
+      all_ignored_exceptions = (Array(ignored_exceptions) + Array(ignore_array)).map(&:to_s)
+      exception_ancestors = exception.singleton_class.ancestors.map(&:to_s)
+      !(all_ignored_exceptions & exception_ancestors).empty?
+    end
+
+    def fire_notification(notifier_name, exception, options, &block)
+      notifier = registered_exception_notifier(notifier_name)
+      notifier.call(exception, options, &block)
+    rescue Exception => e
+      raise e if @@testing_mode
+
+      logger.warn(
+        "An error occurred when sending a notification using '#{notifier_name}' notifier." \
+        "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+      )
+      false
+    end
+
+    def create_and_register_notifier(name, options)
+      notifier_classname = "#{name}_notifier".camelize
+      notifier_class = ExceptionNotifier.const_get(notifier_classname)
+      notifier = notifier_class.new(options)
+      register_exception_notifier(name, notifier)
+    rescue NameError => e
+      raise UndefinedNotifierError,
+        "No notifier named '#{name}' was found. Please, revise your configuration options. Cause: #{e.message}"
+    end
+
+    def from_crawler(env, ignored_crawlers)
+      agent = env["HTTP_USER_AGENT"]
+      Array(ignored_crawlers).any? do |crawler|
+        agent =~ Regexp.new(crawler)
+      end
+    end
+  end
+end

metadata

@@ -1,57 +1,127 @@
 --- !ruby/object:Gem::Specification
 name: exception-track
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Jason Lee
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-16 00:00:00.000000000 Z
+date: 2021-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: exception_notification
+  name: kaminari
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '0.15'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '0.15'
 - !ruby/object:Gem::Dependency
-  name: kaminari
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.15'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.15'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
-  type: :runtime
+        version: '1'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+- !ruby/object:Gem::Dependency
+  name: mock_redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.4
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
 description: Tracking exceptions for Rails application store them in database by exception_notification
   gem.
 email:
@@ -77,7 +147,18 @@ files:
 - lib/exception-track/engine.rb
 - lib/exception-track/log_subscriber.rb
 - lib/exception-track/version.rb
-- lib/exception_notifier/exception_track_notifier.rb
+- lib/exception_notification.rb
+- lib/exception_notification/rack.rb
+- lib/exception_notification/rails.rb
+- lib/exception_notification/resque.rb
+- lib/exception_notification/sidekiq.rb
+- lib/exception_notification/version.rb
+- lib/exception_notifier/base_notifier.rb
+- lib/exception_notifier/db_notifier.rb
+- lib/exception_notifier/modules/backtrace_cleaner.rb
+- lib/exception_notifier/modules/error_grouping.rb
+- lib/exception_notifier/modules/formatter.rb
+- lib/exception_notifier/notifier.rb
 - lib/generators/exception_track/install_generator.rb
 homepage: https://github.com/rails-engine/exception-track
 licenses:
@@ -98,7 +179,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Tracking exceptions for Rails application store them in database.