exceptify 1.0.0

data/lib/exceptify/modules/error_grouping.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext/numeric/time"
+require "active_support/concern"
+
+module Exceptify
+  module ErrorGrouping
+    extend ActiveSupport::Concern
+
+    class Service
+      attr_reader :cache, :fallback_cache_store, :period, :notification_trigger, :logger
+
+      def initialize(cache:, fallback_cache_store:, period:, notification_trigger:, logger:)
+        @cache = cache
+        @fallback_cache_store = fallback_cache_store
+        @period = period
+        @notification_trigger = notification_trigger
+        @logger = logger
+      end
+
+      def error_count(error_key)
+        count =
+          begin
+            cache_store.read(error_key)
+          rescue => e
+            log_cache_error(cache_store, e, :read)
+            fallback_cache_store.read(error_key)
+          end
+
+        count&.to_i
+      end
+
+      def save_error_count(error_key, count)
+        cache_store.write(error_key, count, expires_in: period)
+      rescue => e
+        log_cache_error(cache_store, e, :write)
+        fallback_cache_store.write(error_key, count, expires_in: period)
+      end
+
+      def group_error!(exception, options)
+        message_based_key = key_for_message(exception)
+        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 = key_for_backtrace(exception)
+
+          if (count = error_count(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 cache_store
+        cache || fallback_cache_store
+      end
+
+      def key_for_message(exception)
+        "exception:#{Zlib.crc32("#{exception.class.name}\nmessage:#{exception.message}")}"
+      end
+
+      def key_for_backtrace(exception)
+        "exception:#{Zlib.crc32("#{exception.class.name}\npath:#{exception.backtrace.try(:first)}")}"
+      end
+
+      def log_cache_error(cache, exception, action)
+        logger.warn(
+          "#{cache.inspect} failed to #{action}, reason: #{exception.message}. Falling back to memory cache store."
+        )
+      end
+    end
+
+    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/exceptify/modules/formatter.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/time"
+require "action_dispatch"
+require "exceptify/notification"
+
+module Exceptify
+  class Formatter
+    include Exceptify::BacktraceCleaner
+
+    attr_reader :app_name
+
+    def initialize(exception_or_notification, opts = {})
+      @notification = if exception_or_notification.is_a?(Notification)
+        exception_or_notification
+      else
+        Notification.new(exception_or_notification, opts, backtrace_cleaner: self)
+      end
+      @exception = notification.exception
+      @errors_count = notification.options[:accumulated_errors_count].to_i
+      @app_name = notification.app_name
+    end
+
+    #
+    # :warning: Error occurred in production :warning:
+    # :warning: Error occurred :warning:
+    #
+    def title
+      env = notification.env_name
+
+      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 = notification.request_context.request
+      return unless request
+
+      [
+        "```",
+        "* url : #{request.original_url}",
+        "* http_method : #{request.method}",
+        "* ip_address : #{request.remote_ip}",
+        "* parameters : #{request.filtered_parameters}",
+        "* timestamp : #{notification.timestamp}",
+        "```"
+      ].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 = notification.backtrace
+
+      return if backtrace.empty?
+
+      text = []
+
+      text << "```"
+      backtrace.first(3).each { |line| text << "* #{line}" }
+      text << "```"
+
+      text.join("\n")
+    end
+
+    #
+    # home#index
+    #
+    def controller_and_action
+      notification.controller_and_action
+    end
+
+    private
+
+    attr_reader :exception, :errors_count, :notification
+
+    def controller
+      notification.controller
+    end
+  end
+end

data/lib/exceptify/notification.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "socket"
+require "active_support/core_ext/time"
+require "exceptify/request_context"
+
+module Exceptify
+  class Notification
+    attr_reader :exception, :options, :request_context
+
+    def initialize(exception, options = {}, clock: Time, hostname: -> { Socket.gethostname }, backtrace_cleaner: nil, **keyword_options)
+      @exception = exception
+      @options = options.merge(keyword_options)
+      @clock = clock
+      @hostname = hostname
+      @backtrace_cleaner = backtrace_cleaner
+      @request_context = @options[:request_context] || RequestContext.new(@options[:env])
+    end
+
+    def env
+      request_context.env
+    end
+
+    def data
+      request_context.exception_data.merge(options[:data] || {})
+    end
+
+    def backtrace
+      return [] unless exception.backtrace
+      return @backtrace_cleaner.clean_backtrace(exception) if @backtrace_cleaner
+
+      exception.backtrace
+    end
+
+    def timestamp
+      @clock.respond_to?(:current) ? @clock.current : @clock.now
+    end
+
+    def hostname
+      @hostname.call
+    end
+
+    def app_name
+      options[:app_name] || rails_app_name
+    end
+
+    def env_name
+      Rails.env if defined?(::Rails) && ::Rails.respond_to?(:env)
+    end
+
+    def controller
+      request_context.controller
+    end
+
+    def controller_and_action
+      request_context.controller_and_action
+    end
+
+    private
+
+    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
+  end
+end

data/lib/exceptify/notifier.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_support/deprecation"
+
+module Exceptify
+  class Notifier
+    def self.exceptify(env, exception, options = {})
+      ActiveSupport::Deprecation.warn(
+        "Please use Exceptify.notify_exception(exception, options.merge(env: env))."
+      )
+      Exceptify.registered_notifier(:email).create_email(exception, options.merge(env: env))
+    end
+
+    def self.background_exceptify(exception, options = {})
+      ActiveSupport::Deprecation.warn "Please use Exceptify.notify_exception(exception, options)."
+      Exceptify.registered_notifier(:email).create_email(exception, options)
+    end
+  end
+end

data/lib/exceptify/notifier_registry.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/inflections"
+
+module Exceptify
+  class NotifierRegistry
+    attr_reader :notifiers
+
+    def initialize(notifiers = {}, factory: nil)
+      @notifiers = notifiers.dup
+      @factory = factory || method(:build_notifier)
+    end
+
+    def register(name, notifier_or_options)
+      if notifier_or_options.respond_to?(:call)
+        notifiers[name] = notifier_or_options
+      elsif notifier_or_options.is_a?(Hash)
+        notifiers[name] = @factory.call(name, notifier_or_options)
+      else
+        raise ArgumentError, "Invalid notifier '#{name}' defined as #{notifier_or_options.inspect}"
+      end
+    end
+
+    def unregister(name)
+      notifiers.delete(name)
+    end
+
+    def fetch(name)
+      notifiers[name]
+    end
+
+    def names
+      notifiers.keys
+    end
+
+    def clear
+      notifiers.clear
+    end
+
+    def copy
+      self.class.new(notifiers, factory: @factory)
+    end
+
+    private
+
+    def build_notifier(name, options)
+      notifier_classname = "#{name}_notifier".camelize
+      notifier_class = Exceptify.const_get(notifier_classname)
+      notifier_class.new(options)
+    rescue NameError => e
+      raise UndefinedNotifierError,
+        "No notifier named '#{name}' was found. Please, revise your configuration options. Cause: #{e.message}"
+    end
+  end
+end

data/lib/exceptify/rack.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "exceptify"
+
+module Exceptify
+  class Rack
+    class CascadePassException < RuntimeError; end
+
+    attr_reader :configuration
+
+    def initialize(app, options = {})
+      @app = app
+      @dispatcher = options.delete(:dispatcher)
+      @configuration = options.delete(:configuration)
+      @ignore_cascade_pass = options.delete(:ignore_cascade_pass) { true }
+
+      return if @dispatcher
+      return if options.empty? && @configuration.nil?
+
+      @configuration ||= Exceptify.configuration.copy
+      apply_options(@configuration, options)
+      @dispatcher = Dispatcher.new(@configuration)
+    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 # standard:disable Lint/RescueException
+      env["exceptify.delivered"] = true if dispatcher.notify_exception(e, env: env)
+
+      raise e unless e.is_a?(CascadePassException)
+
+      response
+    end
+
+    private
+
+    def dispatcher
+      @dispatcher || Exceptify
+    end
+
+    def apply_options(configuration, options)
+      configuration.ignored_exceptions = options.delete(:ignore_exceptions) if options.key?(:ignore_exceptions)
+      configuration.error_grouping = options.delete(:error_grouping) if options.key?(:error_grouping)
+      configuration.error_grouping_period = options.delete(:error_grouping_period) if options.key?(:error_grouping_period)
+      configuration.notification_trigger = options.delete(:notification_trigger) if options.key?(:notification_trigger)
+
+      if options.key?(:error_grouping_cache)
+        configuration.error_grouping_cache = options.delete(:error_grouping_cache)
+      elsif defined?(Rails) && Rails.respond_to?(:cache)
+        configuration.error_grouping_cache = Rails.cache
+      end
+
+      apply_ignore_options(configuration, options)
+
+      options.each do |notifier_name, opts|
+        configuration.register_notifier(notifier_name, opts)
+      end
+    end
+
+    def apply_ignore_options(configuration, options)
+      if options.key?(:ignore_if)
+        rack_ignore = options.delete(:ignore_if)
+        configuration.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|
+          configuration.ignore_notifier_if(notifier) do |exception, opts|
+            opts.key?(:env) && proc.call(opts[:env], exception)
+          end
+        end
+      end
+
+      configuration.ignore_crawlers(options.delete(:ignore_crawlers)) if options.key?(:ignore_crawlers)
+    end
+  end
+end

data/lib/exceptify/rails/runner_tie.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "exceptify"
+
+module Exceptify
+  module Rails
+    class RunnerTie
+      class << self
+        attr_writer :installed
+
+        def installed?
+          @installed == true
+        end
+
+        def reset!
+          @installed = false
+        end
+      end
+
+      def initialize(registrar: nil, error_source: nil, notifier: Exceptify)
+        @registrar = registrar || ->(&block) { at_exit(&block) }
+        @error_source = error_source || -> { $ERROR_INFO }
+        @notifier = notifier
+      end
+
+      # Registers an at_exit callback, which checks if there was an exception. This is a pretty
+      # crude way to detect exceptions from runner commands, but Rails doesn't provide a better API.
+      #
+      # This should only be called from a runner callback in your Rails config; otherwise you may
+      # register the at_exit callback in more places than you need or want it.
+      def call
+        return false if self.class.installed?
+
+        self.class.installed = true
+
+        @registrar.call do
+          exception = @error_source.call
+          if exception && !exception.is_a?(SystemExit)
+            @notifier.notify_exception(exception, data: data_for_exceptify(exception))
+          end
+        end
+
+        true
+      end
+
+      private
+
+      def data_for_exceptify(exception = nil)
+        data = {}
+        data[:error_class] = exception.class.name if exception
+        data[:error_message] = exception.message if exception
+
+        data
+      end
+    end
+  end
+end

data/lib/exceptify/rails.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Warning: This must be required after rails but before initializers have been run. If you require
+# it from config/initializers/exceptify.rb, then the rails and rake_task callbacks
+# registered here will have no effect, because Rails will have already invoked all registered rails
+# and rake_tasks handlers.
+
+require "exceptify"
+
+module Exceptify
+  class Engine < ::Rails::Engine
+    config.exceptify = Exceptify
+    config.exceptify.logger = Rails.logger
+    config.exceptify.error_grouping_cache = Rails.cache
+
+    config.app_middleware.use Exceptify::Rack
+
+    rake_tasks do
+      # Report exceptions occurring in Rake tasks.
+      require "exceptify/rake"
+    end
+
+    runner do
+      # Report exceptions occurring in runner commands.
+      require "exceptify/rails/runner_tie"
+      Exceptify::Rails::RunnerTie.new.call
+    end
+  end
+end

data/lib/exceptify/rake.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Copied/adapted from https://github.com/airbrake/airbrake/blob/master/lib/airbrake/rake.rb
+
+require "exceptify"
+require "rake"
+
+Rake::TaskManager.record_task_metadata = true if Rake.const_defined?(:TaskManager)
+
+module Exceptify
+  module RakeTaskExtensions
+    # A wrapper around the original +#execute+, that catches all errors and
+    # passes them on to Exceptify.
+    def execute(args = nil)
+      super
+    rescue Exception => e # standard:disable Lint/RescueException
+      Exceptify.notify_exception(e, data: data_for_exceptify(e)) unless e.is_a?(SystemExit)
+      raise e
+    end
+
+    private
+
+    def data_for_exceptify(exception = nil)
+      data = {}
+      data[:error_class] = exception.class.name if exception
+      data[:error_message] = exception.message if exception
+
+      data[:rake] = {}
+      data[:rake][:rake_command_line] = reconstruct_command_line
+      data[:rake][:name] = name
+      data[:rake][:timestamp] = timestamp.to_s
+      # data[:investigation] = investigation
+
+      data[:rake][:full_comment] = full_comment if full_comment
+      data[:rake][:arg_names] = arg_names if arg_names.any?
+      data[:rake][:arg_description] = arg_description if arg_description
+      data[:rake][:locations] = locations if locations.any?
+      data[:rake][:sources] = sources if sources.any?
+
+      if prerequisite_tasks.any?
+        data[:rake][:prerequisite_tasks] = prerequisite_tasks.map do |p|
+          p.__send__(:data_for_exceptify)[:rake]
+        end
+      end
+
+      data
+    end
+
+    def reconstruct_command_line
+      "rake #{ARGV.join(" ")}"
+    end
+  end
+end
+
+module Rake
+  class Task
+    prepend Exceptify::RakeTaskExtensions
+  end
+end

data/lib/exceptify/request_context.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "action_dispatch"
+
+module Exceptify
+  class RequestContext
+    attr_reader :env
+
+    def initialize(env)
+      @env = env
+    end
+
+    def present?
+      !env.nil?
+    end
+
+    def request
+      @request ||= ActionDispatch::Request.new(env) if present?
+    end
+
+    def controller
+      env["action_controller.instance"] if present?
+    end
+
+    def controller_and_action
+      "#{controller.controller_name}##{controller.action_name}" if controller
+    end
+
+    def exception_data
+      return {} unless present?
+
+      env["exceptify.exception_data"] || {}
+    end
+  end
+end