exceptify 1.0.0

data/lib/exceptify/base_notifier.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Exceptify
+  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/exceptify/configuration.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "logger"
+require "active_support/core_ext/numeric/time"
+require "active_support/cache"
+require "exceptify/notifier_registry"
+require "exceptify/modules/error_grouping"
+
+module Exceptify
+  class Configuration
+    attr_accessor :logger,
+      :ignored_exceptions,
+      :testing_mode,
+      :error_grouping,
+      :error_grouping_period,
+      :notification_trigger,
+      :error_grouping_cache,
+      :fallback_cache_store
+
+    attr_reader :notifier_registry
+
+    DEFAULT_IGNORED_EXCEPTIONS = %w[
+      ActiveRecord::RecordNotFound Mongoid::Errors::DocumentNotFound AbstractController::ActionNotFound
+      ActionController::RoutingError ActionController::UnknownFormat ActionController::UrlGenerationError
+      ActionDispatch::Http::MimeNegotiation::InvalidType Rack::Utils::InvalidParameterError
+    ].freeze
+
+    def initialize(
+      logger: Logger.new($stdout),
+      ignored_exceptions: DEFAULT_IGNORED_EXCEPTIONS,
+      notifier_registry: NotifierRegistry.new,
+      error_grouping_cache: nil,
+      fallback_cache_store: ActiveSupport::Cache::MemoryStore.new
+    )
+      @logger = logger
+      @ignored_exceptions = ignored_exceptions.dup
+      @testing_mode = false
+      @error_grouping = false
+      @error_grouping_period = 5.minutes
+      @notification_trigger = nil
+      @error_grouping_cache = error_grouping_cache
+      @fallback_cache_store = fallback_cache_store
+      @notifier_registry = notifier_registry
+      @ignores = []
+      @by_notifier_ignores = {}
+    end
+
+    def copy
+      self.class.new(
+        logger: logger,
+        ignored_exceptions: ignored_exceptions,
+        notifier_registry: notifier_registry.copy,
+        error_grouping_cache: error_grouping_cache,
+        fallback_cache_store: fallback_cache_store
+      ).tap do |configuration|
+        configuration.testing_mode = testing_mode
+        configuration.error_grouping = error_grouping
+        configuration.error_grouping_period = error_grouping_period
+        configuration.notification_trigger = notification_trigger
+        ignores.each { |condition| configuration.ignore_if(&condition) }
+        by_notifier_ignores.each { |notifier, condition| configuration.ignore_notifier_if(notifier, &condition) }
+      end
+    end
+
+    def reset!
+      notifier_registry.clear
+      clear_ignore_conditions!
+      self.error_grouping = false
+      self.notification_trigger = nil
+      self.error_grouping_cache = nil
+      fallback_cache_store.clear if fallback_cache_store.respond_to?(:clear)
+    end
+
+    def testing_mode!
+      self.testing_mode = true
+    end
+
+    def register_notifier(name, notifier_or_options)
+      notifier_registry.register(name, notifier_or_options)
+    end
+    alias_method :add_notifier, :register_notifier
+
+    def unregister_notifier(name)
+      notifier_registry.unregister(name)
+    end
+
+    def registered_notifier(name)
+      notifier_registry.fetch(name)
+    end
+
+    def notifiers
+      notifier_registry.names
+    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
+
+    def ignored?(exception, options)
+      ignores.any? { |condition| condition.call(exception, options) }
+    rescue Exception => e # standard:disable Lint/RescueException
+      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)
+
+      by_notifier_ignores[notifier].call(exception, options)
+    rescue Exception => e # standard:disable Lint/RescueException
+      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 error_count(error_key)
+      error_grouping_service.error_count(error_key)
+    end
+
+    def save_error_count(error_key, count)
+      error_grouping_service.save_error_count(error_key, count)
+    end
+
+    def group_error!(exception, options)
+      error_grouping_service.group_error!(exception, options)
+    end
+
+    def send_notification?(exception, count)
+      error_grouping_service.send_notification?(exception, count)
+    end
+
+    protected
+
+    attr_reader :ignores, :by_notifier_ignores
+
+    private
+
+    def error_grouping_service
+      ErrorGrouping::Service.new(
+        cache: error_grouping_cache,
+        fallback_cache_store: fallback_cache_store,
+        period: error_grouping_period,
+        notification_trigger: notification_trigger,
+        logger: logger
+      )
+    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

data/lib/exceptify/datadog_notifier.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "action_dispatch"
+
+module Exceptify
+  class DatadogNotifier < BaseNotifier
+    attr_reader :client,
+      :default_options
+
+    def initialize(options)
+      super
+      @client = options[:client]
+      raise ArgumentError, "You must provide 'client' option" unless @client
+
+      @default_options = options
+    end
+
+    def call(exception, options = {})
+      client.emit_event(
+        datadog_event(exception, options)
+      )
+    end
+
+    def datadog_event(exception, options = {})
+      DatadogExceptionEvent.new(
+        exception,
+        options.reverse_merge(default_options)
+      ).event
+    end
+
+    class DatadogExceptionEvent
+      include Exceptify::BacktraceCleaner
+
+      MAX_TITLE_LENGTH = 120
+      MAX_VALUE_LENGTH = 300
+      MAX_BACKTRACE_SIZE = 3
+      ALERT_TYPE = "error"
+
+      attr_reader :exception,
+        :notification,
+        :options
+
+      def initialize(exception, options)
+        @notification = Notification.new(exception, options, backtrace_cleaner: self)
+        @exception = notification.exception
+        @options = options
+      end
+
+      def request
+        @request ||= notification.request_context.request
+      end
+
+      def controller
+        @controller ||= notification.controller
+      end
+
+      def backtrace
+        @backtrace ||= notification.backtrace
+      end
+
+      def tags
+        options[:tags] || []
+      end
+
+      def title_prefix
+        options[:title_prefix] || ""
+      end
+
+      def event
+        title = formatted_title
+        body = formatted_body
+
+        Dogapi::Event.new(
+          body,
+          msg_title: title,
+          alert_type: ALERT_TYPE,
+          tags: tags,
+          aggregation_key: [title]
+        )
+      end
+
+      def formatted_title
+        title =
+          "#{title_prefix}#{controller_subtitle} (#{exception.class}) #{exception.message.inspect}"
+
+        truncate(title, MAX_TITLE_LENGTH)
+      end
+
+      def formatted_body
+        text = []
+
+        text << "%%%"
+        text << formatted_request if request
+        text << formatted_session if request
+        text << formatted_backtrace
+        text << "%%%"
+
+        text.join("\n")
+      end
+
+      def formatted_key_value(key, value)
+        "**#{key}:** #{value}"
+      end
+
+      def formatted_request
+        text = []
+        text << "### **Request**"
+        text << formatted_key_value("URL", request.url)
+        text << formatted_key_value("HTTP Method", request.request_method)
+        text << formatted_key_value("IP Address", request.remote_ip)
+        text << formatted_key_value("Parameters", request.filtered_parameters.inspect)
+        text << formatted_key_value("Timestamp", notification.timestamp)
+        text << formatted_key_value("Server", notification.hostname)
+        text << formatted_key_value("Rails root", Rails.root) if defined?(Rails) && Rails.respond_to?(:root)
+        text << formatted_key_value("Process", Process.pid)
+        text << "___"
+        text.join("\n")
+      end
+
+      def formatted_session
+        text = []
+        text << "### **Session**"
+        text << formatted_key_value("Data", request.session.to_hash)
+        text << "___"
+        text.join("\n")
+      end
+
+      def formatted_backtrace
+        size = [backtrace.size, MAX_BACKTRACE_SIZE].min
+
+        text = []
+        text << "### **Backtrace**"
+        text << "````"
+        size.times { |i| text << backtrace[i] }
+        text << "````"
+        text << "___"
+        text.join("\n")
+      end
+
+      def truncate(string, max)
+        (string.length > max) ? "#{string[0...max]}..." : string
+      end
+
+      def inspect_object(object)
+        case object
+        when Hash, Array
+          truncate(object.inspect, MAX_VALUE_LENGTH)
+        else
+          object.to_s
+        end
+      end
+
+      private
+
+      def controller_subtitle
+        "#{controller.controller_name} #{controller.action_name}" if controller
+      end
+    end
+  end
+end

data/lib/exceptify/dispatcher.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Exceptify
+  class Dispatcher
+    attr_reader :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def notify_exception(exception, options = {}, &block)
+      options = options.dup
+
+      return false if configuration.ignored_exception?(options[:ignore_exceptions], exception)
+      return false if configuration.ignored?(exception, options)
+
+      if configuration.error_grouping
+        errors_count = configuration.group_error!(exception, options)
+        return false unless configuration.send_notification?(exception, errors_count)
+      end
+
+      notification_fired = false
+      selected_notifiers = options.delete(:notifiers) || configuration.notifiers
+      [*selected_notifiers].each do |notifier|
+        unless configuration.notifier_ignored?(exception, options, notifier: notifier)
+          fire_notification(notifier, exception, options.dup, &block)
+          notification_fired = true
+        end
+      end
+
+      notification_fired
+    end
+
+    private
+
+    def fire_notification(notifier_name, exception, options, &block)
+      notifier = configuration.registered_notifier(notifier_name)
+      notifier.call(exception, options, &block)
+    rescue Exception => e # standard:disable Lint/RescueException
+      raise e if configuration.testing_mode
+
+      configuration.logger.warn(
+        "An error occurred when sending a notification using '#{notifier_name}' notifier." \
+        "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+      )
+      false
+    end
+  end
+end

data/lib/exceptify/email_notifier.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/time"
+require "action_mailer"
+require "action_dispatch"
+require "pp"
+
+module Exceptify
+  class EmailNotifier < BaseNotifier
+    DEFAULT_OPTIONS = {
+      sender_address: %("Exceptify" <notifier@example.com>),
+      exception_recipients: [],
+      email_prefix: "[ERROR] ",
+      email_format: :text,
+      sections: %w[request session environment backtrace],
+      background_sections: %w[backtrace data],
+      verbose_subject: true,
+      normalize_subject: false,
+      include_controller_and_action_names_in_subject: true,
+      delivery_method: nil,
+      mailer_settings: nil,
+      email_headers: {},
+      mailer_parent: "ActionMailer::Base",
+      template_path: "exceptify",
+      deliver_with: nil
+    }.freeze
+
+    module Mailer
+      class MissingController
+        def method_missing(*args, &block)
+        end
+
+        def respond_to_missing?(*args)
+        end
+      end
+
+      def self.extended(base)
+        base.class_eval do
+          send(:include, Exceptify::BacktraceCleaner)
+
+          # Append application view path to the Exceptify lookup context.
+          append_view_path "#{File.dirname(__FILE__)}/views"
+
+          def exceptify(env, exception, options = {}, default_options = {})
+            load_custom_views
+
+            @env = env
+            @exception = exception
+
+            env_options = env["exceptify.options"] || {}
+            @options = default_options.merge(env_options).merge(options)
+
+            @kontroller = env["action_controller.instance"] || MissingController.new
+            @request = ActionDispatch::Request.new(env)
+            @backtrace = exception.backtrace ? clean_backtrace(exception) : []
+            @timestamp = Time.current
+            @sections = @options[:sections]
+            @data = (env["exceptify.exception_data"] || {}).merge(options[:data] || {})
+            @sections += %w[data] unless @data.empty?
+
+            compose_email
+          end
+
+          def background_exceptify(exception, options = {}, default_options = {})
+            load_custom_views
+
+            @exception = exception
+            @options = default_options.merge(options).symbolize_keys
+            @backtrace = exception.backtrace || []
+            @timestamp = Time.current
+            @sections = @options[:background_sections]
+            @data = options[:data] || {}
+            @env = @kontroller = nil
+
+            compose_email
+          end
+
+          private
+
+          def compose_subject
+            subject = @options[:email_prefix].to_s.dup
+            subject << "(#{@options[:accumulated_errors_count]} times)" if @options[:accumulated_errors_count].to_i > 1
+            subject << "#{@kontroller.controller_name}##{@kontroller.action_name}" if include_controller?
+            subject << " (#{@exception.class})"
+            subject << " #{@exception.message.inspect}" if @options[:verbose_subject]
+            subject = EmailNotifier.normalize_digits(subject) if @options[:normalize_subject]
+            (subject.length > 120) ? subject[0...120] + "..." : subject
+          end
+
+          def include_controller?
+            @kontroller && @options[:include_controller_and_action_names_in_subject]
+          end
+
+          def set_data_variables
+            @data.each do |name, value|
+              instance_variable_set(:"@#{name}", value)
+            end
+          end
+
+          helper_method :inspect_object
+
+          def truncate(string, max)
+            (string.length > max) ? "#{string[0...max]}..." : string
+          end
+
+          def inspect_object(object)
+            case object
+            when Hash, Array
+              truncate(object.inspect, 300)
+            else
+              object.to_s
+            end
+          end
+
+          helper_method :safe_encode
+
+          def safe_encode(value)
+            value.encode("utf-8", invalid: :replace, undef: :replace, replace: "_")
+          end
+
+          def html_mail?
+            @options[:email_format] == :html
+          end
+
+          def compose_email
+            set_data_variables
+            subject = compose_subject
+            name = @env.nil? ? "background_exceptify" : "exceptify"
+            exception_recipients = maybe_call(@options[:exception_recipients])
+
+            headers = {
+              delivery_method: @options[:delivery_method],
+              to: exception_recipients,
+              from: @options[:sender_address],
+              subject: subject,
+              template_name: name
+            }.merge(@options[:email_headers])
+
+            mail = mail(headers) do |format|
+              format.text
+              format.html if html_mail?
+            end
+
+            mail.delivery_method.settings.merge!(@options[:mailer_settings]) if @options[:mailer_settings]
+
+            mail
+          end
+
+          def load_custom_views
+            return unless defined?(Rails) && Rails.respond_to?(:root)
+
+            prepend_view_path Rails.root.nil? ? "app/views" : "#{Rails.root}/app/views"
+          end
+
+          def maybe_call(maybe_proc)
+            maybe_proc.respond_to?(:call) ? maybe_proc.call : maybe_proc
+          end
+        end
+      end
+    end
+
+    def initialize(options)
+      super
+
+      delivery_method = options[:delivery_method] || :smtp
+      mailer_settings_key = :"#{delivery_method}_settings"
+      options[:mailer_settings] = options.delete(mailer_settings_key)
+
+      @base_options = DEFAULT_OPTIONS.merge(options)
+    end
+
+    def call(exception, options = {})
+      message = create_email(exception, options)
+
+      message.send(base_options[:deliver_with] || default_deliver_with(message))
+    end
+
+    def create_email(exception, options = {})
+      env = options[:env]
+
+      send_notice(exception, options, nil, base_options) do |_, default_opts|
+        if env.nil?
+          mailer.background_exceptify(exception, options, default_opts)
+        else
+          mailer.exceptify(env, exception, options, default_opts)
+        end
+      end
+    end
+
+    def self.normalize_digits(string)
+      string.gsub(/[0-9]+/, "N")
+    end
+
+    private
+
+    def mailer
+      @mailer ||= Class.new(base_options[:mailer_parent].constantize).tap do |mailer|
+        mailer.extend(EmailNotifier::Mailer)
+        mailer.mailer_name = base_options[:template_path]
+      end
+    end
+
+    def default_deliver_with(message)
+      # FIXME: use `if Gem::Version.new(ActionMailer::VERSION::STRING) < Gem::Version.new('4.1')`
+      message.respond_to?(:deliver_now) ? :deliver_now : :deliver
+    end
+  end
+end

data/lib/exceptify/modules/backtrace_cleaner.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Exceptify
+  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