exception-track 0.6.2 → 1.3.0

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

@@ -1,27 +1,33 @@
 # frozen_string_literal: true
 
 module ExceptionNotifier
-  class ExceptionTrackNotifier < ExceptionNotifier::BaseNotifier
-    def initialize(_options); end
+  class DbNotifier < ExceptionNotifier::BaseNotifier
+    def initialize(opts = {})
+      super(opts)
+    end
 
-    def call(exception, _options = {})
+    def call(exception, opts = {})
       return unless ExceptionTrack.config.enabled_env?(Rails.env)
 
       # send the notification
       title = exception.message || "None"
-
       messages = []
-      messages << headers_for_env(_options[:env])
-      messages << ""
-      messages << "--------------------------------------------------"
-      messages << ""
-      messages << exception.inspect
-      unless exception.backtrace.blank?
-        messages << "\n"
-        messages << exception.backtrace
-      end
 
-      ExceptionTrack::Log.create(title: title[0, 200], body: messages.join("\n"))
+      ActiveSupport::Notifications.instrument("track.exception_track", title: title) do
+        messages << headers_for_env(opts[:env])
+        messages << ""
+        messages << "--------------------------------------------------"
+        messages << ""
+        messages << exception.inspect
+        unless exception.backtrace.blank?
+          messages << "\n"
+          messages << exception.backtrace
+        end
+
+        Rails.logger.silence do
+          ExceptionTrack::Log.create(title: title[0, 200], body: messages.join("\n"))
+        end
+      end
     rescue => e
       errs = []
       errs << "-- [ExceptionTrack] create error ---------------------------"
@@ -41,16 +47,14 @@ module ExceptionNotifier
       parameters = filter_parameters(env)
 
       headers = []
-      headers << "Method:      #{env['REQUEST_METHOD']}"
-      headers << "URL:         #{env['REQUEST_URI']}"
-      if env['REQUEST_METHOD'].downcase != "get"
-        headers << "Parameters:\n#{pretty_hash(parameters.except(:controller, :action), 13)}"
-      end
-      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 << "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 << "Server:      #{Socket.gethostname}"
       headers << "Process:     #{$PROCESS_ID}"
 
@@ -60,10 +64,10 @@ module ExceptionNotifier
     def filter_parameters(env)
       parameters = env["action_dispatch.request.parameters"] || {}
       parameter_filter = ActiveSupport::ParameterFilter.new(env["action_dispatch.parameter_filter"] || [])
-      return parameter_filter.filter(parameters)
+      parameter_filter.filter(parameters)
     rescue => e
       Rails.logger.error "filter_parameters error: #{e.inspect}"
-      return parameters
+      parameters
     end
 
     def pretty_hash(params, indent = 0)

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,71 +1,127 @@
 --- !ruby/object:Gem::Specification
 name: exception-track
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 1.3.0
 platform: ruby
 authors:
 - Jason Lee
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-21 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: '4.0'
-  type: :runtime
+        version: '1'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        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: mysql2
+  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: '0'
+        version: 5.0.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        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:
@@ -76,6 +132,7 @@ extra_rdoc_files: []
 files:
 - MIT-LICENSE
 - README.md
+- app/assets/config/exception_track_manifest.js
 - app/assets/stylesheets/exception-track/application.css
 - app/controllers/exception_track/logs_controller.rb
 - app/models/exception_track/log.rb
@@ -88,14 +145,26 @@ files:
 - lib/exception-track.rb
 - lib/exception-track/configuration.rb
 - 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:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -110,8 +179,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Tracking exceptions for Rails application store them in database.
 test_files: []