exceptify 1.0.0

data/lib/exceptify/resque.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "resque/failure/base"
+require "exceptify"
+
+module Exceptify
+  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
+      }
+
+      Exceptify.notify_exception(exception, data: {resque: data})
+    end
+  end
+end

data/lib/exceptify/sidekiq.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+require "exceptify"
+
+::Sidekiq.configure_server do |config|
+  config.error_handlers << proc do |ex, context, config|
+    # Before Sidekiq 7.1.5 the config was not passed to the proc
+    if config
+      Exceptify.notify_exception(ex, data: {sidekiq: {context: context, config: config}})
+    else
+      Exceptify.notify_exception(ex, data: {sidekiq: context})
+    end
+  end
+end

data/lib/exceptify/slack_notifier.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Exceptify
+  class SlackNotifier < BaseNotifier
+    include Exceptify::BacktraceCleaner
+
+    attr_accessor :notifier
+
+    def initialize(options)
+      options = options.dup
+      fail_silently = options.delete(:fail_silently) { false }
+      injected_notifier = options.delete(:notifier)
+      super()
+      self.base_options = options
+
+      @ignore_data_if = options[:ignore_data_if]
+      @backtrace_lines = options.fetch(:backtrace_lines, 10)
+      @additional_fields = options[:additional_fields]
+      @message_opts = options.fetch(:additional_parameters, {}).dup
+      @color = @message_opts.delete(:color) { "danger" }
+
+      @notifier = injected_notifier || build_notifier(options)
+    rescue => e
+      raise unless fail_silently
+
+      log_configuration_error(e)
+      @notifier = nil
+    end
+
+    def call(exception, options = {})
+      notification = Notification.new(exception, options, backtrace_cleaner: self)
+      clean_message = exception.message.tr("`", "'")
+      attchs = attchs(notification, clean_message)
+
+      return unless valid?
+
+      args = [exception, options, clean_message, @message_opts.merge(attachments: attchs)]
+      send_notice(*args) do |_msg, message_opts|
+        message_opts[:channel] = options[:channel] if options.key?(:channel)
+
+        @notifier.ping "", message_opts
+      end
+    end
+
+    protected
+
+    def valid?
+      !@notifier.nil?
+    end
+
+    def deep_reject(hash, block)
+      hash.each do |k, v|
+        deep_reject(v, block) if v.is_a?(Hash)
+
+        hash.delete(k) if block.call(k, v)
+      end
+    end
+
+    private
+
+    def build_notifier(options)
+      webhook_url = options[:webhook_url]
+      raise ArgumentError, "You must provide 'webhook_url' option" if blank?(webhook_url)
+      unless defined?(::Slack::Notifier)
+        raise ArgumentError, "Slack notifier requires the 'slack-notifier' gem"
+      end
+
+      Slack::Notifier.new(webhook_url, options)
+    end
+
+    def blank?(value)
+      value.nil? || (value.respond_to?(:empty?) && value.empty?)
+    end
+
+    def log_configuration_error(error)
+      Exceptify.logger&.warn(
+        "Slack notifier disabled: #{error.class}: #{error.message}"
+      )
+    end
+
+    def attchs(notification, clean_message)
+      text, data = information_from_notification(notification)
+      backtrace = notification.backtrace
+      fields = fields(notification, clean_message, backtrace, data)
+
+      [color: @color, text: text, fields: fields, mrkdwn_in: %w[text fields]]
+    end
+
+    def information_from_notification(notification)
+      errors_count = notification.options[:accumulated_errors_count].to_i
+      exception_class = notification.exception.class
+
+      measure_word = if errors_count > 1
+        errors_count
+      else
+        /^[aeiou]/i.match?(exception_class.to_s) ? "An" : "A"
+      end
+
+      exception_name = "*#{measure_word}* `#{exception_class}`"
+      env = notification.env
+      data = notification.data
+
+      notification.options[:headers] ||= {}
+      notification.options[:headers]["Content-Type"] = "application/json"
+
+      if env.nil?
+        text = "#{exception_name} *occured in background*\n"
+      else
+        kontroller = env["action_controller.instance"]
+        request = "#{env["REQUEST_METHOD"]} <#{env["REQUEST_URI"]}>"
+        text = "#{exception_name} *occurred while* `#{request}`"
+        text += " *was processed by* `#{kontroller.controller_name}##{kontroller.action_name}`" if kontroller
+        text += "\n"
+      end
+
+      [text, data]
+    end
+
+    def fields(notification, clean_message, backtrace, data)
+      fields = [
+        {title: "Exception", value: clean_message},
+        {title: "Hostname", value: notification.hostname}
+      ]
+
+      unless backtrace.empty?
+        formatted_backtrace = "```#{backtrace.first(@backtrace_lines).join("\n")}```"
+        fields << {title: "Backtrace", value: formatted_backtrace}
+      end
+
+      unless data.empty?
+        deep_reject(data, @ignore_data_if) if @ignore_data_if.is_a?(Proc)
+        data_string = data.map { |k, v| "#{k}: #{v}" }.join("\n")
+        fields << {title: "Data", value: "```#{data_string}```"}
+      end
+
+      fields.concat(@additional_fields) if @additional_fields
+
+      fields
+    end
+  end
+end

data/lib/exceptify/sns_notifier.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Exceptify
+  class SnsNotifier < BaseNotifier
+    def initialize(options)
+      options = options.dup
+      super
+
+      @notifier = options.delete(:client) || build_client(options)
+      @options = default_options.merge(options)
+    end
+
+    def call(exception, custom_opts = {})
+      custom_options = options.merge(custom_opts)
+      notification = Notification.new(exception, custom_options)
+
+      subject = build_subject(notification, custom_options)
+      message = build_message(notification, custom_options)
+
+      notifier.publish(
+        topic_arn: custom_options[:topic_arn],
+        message: message,
+        subject: subject
+      )
+    end
+
+    private
+
+    attr_reader :notifier, :options
+
+    def build_client(options)
+      raise ArgumentError, "You must provide 'region' option" unless options[:region]
+      raise ArgumentError, "You must provide 'access_key_id' option" unless options[:access_key_id]
+      raise ArgumentError, "You must provide 'secret_access_key' option" unless options[:secret_access_key]
+      raise ArgumentError, "SNS notifier requires the 'aws-sdk-sns' gem" unless defined?(::Aws::SNS::Client)
+
+      Aws::SNS::Client.new(
+        region: options[:region],
+        access_key_id: options[:access_key_id],
+        secret_access_key: options[:secret_access_key]
+      )
+    end
+
+    def build_subject(notification, options)
+      subject =
+        "#{options[:sns_prefix]} - #{accumulated_exception_name(notification, options)} occurred"
+      (subject.length > 120) ? subject[0...120] + "..." : subject
+    end
+
+    def build_message(notification, options)
+      exception = notification.exception
+      exception_name = accumulated_exception_name(notification, options)
+
+      if notification.env.nil?
+        text = "#{exception_name} occured in background\n"
+        data = notification.data
+      else
+        env = notification.env
+
+        kontroller = env["action_controller.instance"]
+        data = notification.data
+        request = "#{env["REQUEST_METHOD"]} <#{env["REQUEST_URI"]}>"
+
+        text = "#{exception_name} occurred while #{request}"
+        text += " was processed by #{kontroller.controller_name}##{kontroller.action_name}\n" if kontroller
+      end
+
+      text += "Exception: #{exception.message}\n"
+      text += "Hostname: #{notification.hostname}\n"
+      text += "Data: #{data}\n"
+
+      return text if notification.backtrace.empty?
+
+      formatted_backtrace = notification.backtrace.first(options[:backtrace_lines]).join("\n").to_s
+      text + "Backtrace:\n#{formatted_backtrace}\n"
+    end
+
+    def accumulated_exception_name(notification, options)
+      errors_count = options[:accumulated_errors_count].to_i
+      exception = notification.exception
+
+      measure_word = if errors_count > 1
+        errors_count
+      else
+        /^[aeiou]/i.match?(exception.class.to_s) ? "An" : "A"
+      end
+
+      "#{measure_word} #{exception.class}"
+    end
+
+    def default_options
+      {
+        sns_prefix: "[ERROR]",
+        backtrace_lines: 10
+      }
+    end
+  end
+end

data/lib/exceptify/solid_queue.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "active_job"
+require "active_support/notifications"
+require "exceptify"
+
+module Exceptify
+  module SolidQueue
+    ADAPTER_NAME = "solid_queue"
+    EVENT_NAME = "perform.active_job"
+    JOB_ATTRIBUTES = %i[
+      job_id
+      provider_job_id
+      queue_name
+      priority
+      arguments
+      executions
+      exception_executions
+      locale
+      timezone
+      enqueued_at
+      scheduled_at
+    ].freeze
+
+    class << self
+      def install
+        return if installed?
+
+        @subscription = ActiveSupport::Notifications.subscribe(EVENT_NAME) do |*args|
+          notify(ActiveSupport::Notifications::Event.new(*args))
+        end
+      end
+
+      def installed?
+        !!@subscription
+      end
+
+      def notify(event)
+        exception = event.payload[:exception_object]
+        job = event.payload[:job]
+
+        return unless exception && solid_queue_job?(job)
+
+        Exceptify.notify_exception(exception, data: {solid_queue: job_data(job)})
+      end
+
+      private
+
+      def solid_queue_job?(job)
+        queue_adapter_name(job) == ADAPTER_NAME
+      end
+
+      def queue_adapter_name(job)
+        job.class.queue_adapter_name if job && job.class.respond_to?(:queue_adapter_name)
+      end
+
+      def job_data(job)
+        {adapter: queue_adapter_name(job), job_class: job.class.name}.tap do |data|
+          JOB_ATTRIBUTES.each do |attribute|
+            data[attribute] = job.public_send(attribute) if job.respond_to?(attribute)
+          end
+        end.compact
+      end
+    end
+  end
+end
+
+Exceptify::SolidQueue.install

data/lib/exceptify/teams_notifier.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "action_dispatch"
+require "active_support/core_ext/time"
+require "json"
+
+module Exceptify
+  class TeamsNotifier < BaseNotifier
+    include Exceptify::BacktraceCleaner
+
+    class MissingController
+      def method_missing(*args, &block)
+      end
+
+      def respond_to_missing?(*args)
+      end
+    end
+
+    attr_accessor :httparty
+
+    def initialize(options = {})
+      options = options.dup
+      @httparty = options.delete(:http_client) || HTTParty
+      super()
+      self.base_options = options
+      @default_options = options
+    end
+
+    def call(exception, options = {})
+      @options = options.merge(@default_options)
+      @exception = exception
+      @backtrace = exception.backtrace ? clean_backtrace(exception) : nil
+
+      @env = @options.delete(:env)
+
+      @application_name = @options.delete(:app_name) || rails_app_name
+      @gitlab_url = @options.delete(:git_url)
+      @jira_url = @options.delete(:jira_url)
+
+      @webhook_url = @options.delete(:webhook_url)
+      raise ArgumentError, "You must provide 'webhook_url' parameter." unless @webhook_url
+
+      if @env.nil?
+        @controller = @request_items = nil
+      else
+        @controller = @env["action_controller.instance"] || MissingController.new
+        @additional_exception_data = @env["exceptify.exception_data"]
+        request = ActionDispatch::Request.new(@env)
+
+        @request_items = {url: request.original_url,
+                          http_method: request.method,
+                          ip_address: request.remote_ip,
+                          parameters: request.filtered_parameters,
+                          timestamp: Time.current}
+
+      end
+
+      payload = message_text
+
+      @options[:body] = payload.to_json
+      @options[:headers] ||= {}
+      @options[:headers]["Content-Type"] = "application/json"
+      @options[:debug_output] = $stdout
+
+      @httparty.post(@webhook_url, @options)
+    end
+
+    private
+
+    def message_text
+      text = {
+        "@type" => "MessageCard",
+        "@context" => "http://schema.org/extensions",
+        "summary" => "#{@application_name} Exception Alert",
+        "title" => "⚠️ Exception Occurred in #{env_name} ⚠️",
+        "sections" => [
+          {
+            "activityTitle" => activity_title,
+            "activitySubtitle" => @exception.message.to_s
+          }
+        ],
+        "potentialAction" => []
+      }
+
+      text["sections"].push details
+      text["potentialAction"].push gitlab_view_link unless @gitlab_url.nil?
+      text["potentialAction"].push gitlab_issue_link unless @gitlab_url.nil?
+      text["potentialAction"].push jira_issue_link unless @jira_url.nil?
+
+      text
+    end
+
+    def details
+      details = {
+        "title" => "Details",
+        "facts" => []
+      }
+
+      details["facts"].push message_request unless @request_items.nil?
+      details["facts"].push message_backtrace unless @backtrace.nil?
+      details["facts"].push additional_exception_data unless @additional_exception_data.nil?
+      details
+    end
+
+    def activity_title
+      errors_count = @options[:accumulated_errors_count].to_i
+
+      "#{(errors_count > 1) ? errors_count : "A"} *#{@exception.class}* occurred" +
+        (@controller ? " in *#{controller_and_method}*." : ".")
+    end
+
+    def message_request
+      {
+        "name" => "Request",
+        "value" => "#{hash_presentation(@request_items)}\n  "
+      }
+    end
+
+    def message_backtrace(size = 3)
+      text = []
+      size = (@backtrace.size < size) ? @backtrace.size : size
+      text << "```"
+      size.times { |i| text << "* " + @backtrace[i] }
+      text << "```"
+
+      {
+        "name" => "Backtrace",
+        "value" => text.join("  \n").to_s
+      }
+    end
+
+    def additional_exception_data
+      {
+        "name" => "Data",
+        "value" => "`#{@additional_exception_data}`\n  "
+      }
+    end
+
+    def gitlab_view_link
+      {
+        "@type" => "ViewAction",
+        "name" => "\u{1F98A} View in GitLab",
+        "target" => [
+          "#{@gitlab_url}/#{@application_name}"
+        ]
+      }
+    end
+
+    def gitlab_issue_link
+      link = [@gitlab_url, @application_name, "issues", "new"].join("/")
+      params = {
+        "issue[title]" => ["[BUG] Error 500 :",
+          controller_and_method,
+          "(#{@exception.class})",
+          @exception.message].compact.join(" ")
+      }.to_query
+
+      {
+        "@type" => "ViewAction",
+        "name" => "\u{1F98A} Create Issue in GitLab",
+        "target" => [
+          "#{link}/?#{params}"
+        ]
+      }
+    end
+
+    def jira_issue_link
+      {
+        "@type" => "ViewAction",
+        "name" => "🐞 Create Issue in Jira",
+        "target" => [
+          "#{@jira_url}/secure/CreateIssue!default.jspa"
+        ]
+      }
+    end
+
+    def controller_and_method
+      if @controller
+        "#{@controller.controller_name}##{@controller.action_name}"
+      else
+        ""
+      end
+    end
+
+    def hash_presentation(hash)
+      text = []
+
+      hash.each do |key, value|
+        text << "* **#{key}** : `#{value}`"
+      end
+
+      text.join("  \n")
+    end
+
+    def rails_app_name
+      return unless defined?(Rails) && Rails.respond_to?(:application)
+
+      if ::Gem::Version.new(Rails.version) >= ::Gem::Version.new("6.0")
+        Rails.application.class.module_parent_name.underscore
+      else
+        Rails.application.class.parent_name.underscore
+      end
+    end
+
+    def env_name
+      Rails.env if defined?(Rails) && Rails.respond_to?(:env)
+    end
+  end
+end

data/lib/exceptify/version.rb

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

data/lib/exceptify/views/exceptify/_backtrace.html.erb

@@ -0,0 +1,3 @@
+<pre style="font-size: 12px; padding: 10px; border: 1px solid #e1e1e8; background-color:#f5f5f5">
+  <%= @backtrace.join("\n") %>
+</pre>

data/lib/exceptify/views/exceptify/_backtrace.text.erb

@@ -0,0 +1 @@
+<%= raw @backtrace.join("\n") %>

data/lib/exceptify/views/exceptify/_data.html.erb

@@ -0,0 +1,6 @@
+<ul style="list-style: none">
+  <li>
+    <strong>data:</strong>
+    <span><%= PP.pp(@data, +"") %></span>
+  </li>
+</ul>

data/lib/exceptify/views/exceptify/_data.text.erb

@@ -0,0 +1 @@
+* data: <%= raw PP.pp(@data, +"") %>

data/lib/exceptify/views/exceptify/_environment.html.erb

@@ -0,0 +1,10 @@
+<% filtered_env = @request.filtered_env -%>
+
+<ul style="list-style: none">
+  <% filtered_env.keys.map(&:to_s).sort.each do |key| -%>
+    <li>
+      <strong><%= key %>:</strong>
+      <span><%= inspect_object(filtered_env[key]) %></span>
+    </li>
+  <% end -%>
+</ul>

data/lib/exceptify/views/exceptify/_environment.text.erb

@@ -0,0 +1,5 @@
+<% filtered_env = @request.filtered_env -%>
+<% max = filtered_env.keys.map(&:to_s).max { |a, b| a.length <=> b.length } -%>
+<% filtered_env.keys.map(&:to_s).sort.each do |key| -%>
+  * <%= raw safe_encode("%-*s: %s" % [max.length, key, inspect_object(filtered_env[key])]).strip %>
+<% end -%>

data/lib/exceptify/views/exceptify/_request.html.erb

@@ -0,0 +1,36 @@
+<ul style="list-style: none">
+  <li>
+    <strong>URL:</strong>
+    <span><%= @request.url %></span>
+  </li>
+  <li>
+    <strong>HTTP Method:</strong>
+    <span><%= @request.request_method %></span>
+  </li>
+  <li>
+    <strong>IP Address:</strong>
+    <span><%= @request.remote_ip %></span>
+  </li>
+  <li>
+    <strong>Parameters:</strong>
+    <span><%= @request.filtered_parameters.inspect %></span>
+  </li>
+  <li>
+    <strong>Timestamp:</strong>
+    <span><%= @timestamp %></span>
+  </li>
+  <li>
+    <strong>Server:</strong>
+    <span><%= Socket.gethostname %></span>
+  </li>
+  <% if defined?(Rails) && Rails.respond_to?(:root) %>
+    <li>
+      <strong>Rails root:</strong>
+      <span><%= Rails.root %></span>
+    </li>
+  <% end %>
+  <li>
+    <strong>Process:</strong>
+    <span><%= $$ %></span>
+  </li>
+</ul>

data/lib/exceptify/views/exceptify/_request.text.erb

@@ -0,0 +1,10 @@
+* URL        : <%= raw safe_encode @request.url %>
+* HTTP Method: <%= raw @request.request_method %>
+* IP address : <%= raw @request.remote_ip %>
+* Parameters : <%= raw safe_encode @request.filtered_parameters.inspect %>
+* Timestamp  : <%= raw @timestamp %>
+* Server : <%= raw Socket.gethostname %>
+<% if defined?(Rails) && Rails.respond_to?(:root) %>
+  * Rails root : <%= raw Rails.root %>
+<% end %>
+* Process: <%= raw $$ %>

data/lib/exceptify/views/exceptify/_session.html.erb

@@ -0,0 +1,10 @@
+<ul style="list-style: none">
+  <li>
+    <strong>session_id: </strong>
+    <span><%= @request.ssl? ? "[FILTERED]" : (@request.session['session_id'] || (@request.env["rack.session.options"] and @request.env["rack.session.options"][:id]).inspect) %></span>
+  </li>
+  <li>
+    <strong>data: </strong>
+    <span><%= PP.pp(@request.session.to_hash, +"") %></span>
+  </li>
+</ul>

data/lib/exceptify/views/exceptify/_session.text.erb

@@ -0,0 +1,2 @@
+* session id: <%= @request.ssl? ? "[FILTERED]" : (raw (@request.session['session_id'] || (@request.env["rack.session.options"] and @request.env["rack.session.options"][:id])).inspect.html_safe) %>
+* data: <%= raw PP.pp(@request.session.to_hash, +"") %>

data/lib/exceptify/views/exceptify/_title.html.erb

@@ -0,0 +1,3 @@
+<h2>
+  <%= title.to_s.humanize %>
+</h2>

data/lib/exceptify/views/exceptify/_title.text.erb

@@ -0,0 +1,3 @@
+-------------------------------
+<%= raw title.to_s.humanize %>:
+-------------------------------