celerbrake 0.1.0

data/lib/celerbrake/rake.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# This is not bulletproof, but if this file is executed before a task
+# definition, we can grab tasks descriptions and locations.
+# See: https://goo.gl/ksn6PE
+Rake::TaskManager.record_task_metadata = true
+
+module Celerbrake
+  module Rake
+    # Redefine +Rake::Task#execute+, so it can report errors to Celerbrake.
+    module Task
+      # A wrapper around the original +#execute+, that catches all errors and
+      # notifies Celerbrake.
+      #
+      # rubocop:disable Lint/RescueException
+      def execute(args = nil)
+        super(args)
+      rescue Exception => ex
+        notify_celerbrake(ex, args)
+        raise ex
+      end
+      # rubocop:enable Lint/RescueException
+
+      private
+
+      def notify_celerbrake(exception, args)
+        notice = Celerbrake.build_notice(exception)
+        notice[:context][:component] = 'rake'
+        notice[:context][:action] = name
+        notice[:params].merge!(
+          rake_task: task_info,
+          execute_args: args,
+          argv: ARGV.join(' '),
+        )
+
+        Celerbrake.notify_sync(notice)
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
+      def task_info
+        info = {}
+
+        info[:name] = name
+        info[:timestamp] = timestamp.to_s
+        info[:investigation] = investigation
+
+        info[:full_comment] = full_comment if full_comment
+        info[:arg_names] = arg_names if arg_names.any?
+        info[:arg_description] = arg_description if arg_description
+        info[:locations] = locations if locations.any?
+        info[:sources] = sources if sources.any?
+
+        if prerequisite_tasks.any?
+          info[:prerequisite_tasks] = prerequisite_tasks.map do |p|
+            p.__send__(:task_info)
+          end
+        end
+
+        info
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize
+    end
+  end
+end
+
+Rake::Task.prepend(Celerbrake::Rake::Task)

data/lib/celerbrake/resque.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Resque
+  module Failure
+    # Provides Resque integration with Celerbrake.
+    #
+    # @since v5.0.0
+    # @see https://github.com/resque/resque/wiki/Failure-Backends
+    class Celerbrake < Base
+      def save
+        ::Celerbrake.notify_sync(exception, payload) do |notice|
+          notice[:context][:component] = 'resque'
+          notice[:context][:action] = action(payload)
+        end
+      end
+
+      private
+
+      # @return [String] job's name. When ActiveJob is present, retrieve
+      #   job_class. When used directly, use worker's name
+      def action(payload)
+        active_job_args = payload['args'].first if payload['args']
+        if active_job_args.is_a?(Hash) && active_job_args['job_class']
+          active_job_args['job_class']
+        else
+          payload['class'].to_s
+        end
+      end
+    end
+  end
+end
+
+module Celerbrake
+  module Resque
+    # Measures elapsed time of a job and notifies Celerbrake of the execution
+    # status.
+    #
+    # @since v9.6.0
+    module Job
+      def perform
+        timing = Celerbrake::Benchmark.measure do
+          super
+        end
+      rescue StandardError => exception
+        Celerbrake.notify_queue_sync(
+          queue: payload['class'],
+          error_count: 1,
+          timing: 0.01,
+        )
+        raise exception
+      else
+        Celerbrake.notify_queue_sync(
+          queue: payload['class'],
+          error_count: 0,
+          timing: timing,
+        )
+      end
+    end
+  end
+end
+
+Resque::Job.prepend(Celerbrake::Resque::Job)

data/lib/celerbrake/shoryuken.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Shoryuken
+    # Provides integration with Shoryuken.
+    class ErrorHandler
+      # rubocop:disable Lint/RescueException
+      def call(worker, queue, _sqs_msg, body, &block)
+        timing = Celerbrake::Benchmark.measure(&block)
+      rescue Exception => exception
+        notify_celerbrake(exception, worker, queue, body)
+        Celerbrake.notify_queue(
+          queue: worker.class.to_s,
+          error_count: 1,
+          timing: 0.01,
+        )
+        raise exception
+      else
+        Celerbrake.notify_queue(
+          queue: worker.class.to_s,
+          error_count: 0,
+          timing: timing,
+        )
+      end
+      # rubocop:enable Lint/RescueException
+
+      private
+
+      def notify_celerbrake(exception, worker, queue, body)
+        Celerbrake.notify(exception, notice_context(queue, body)) do |notice|
+          notice[:context][:component] = 'shoryuken'
+          notice[:context][:action] = worker.class.to_s
+        end
+      end
+
+      def notice_context(queue, body)
+        {
+          queue: queue,
+          body: body.is_a?(Array) ? { batch: body } : { body: body },
+        }
+      end
+    end
+  end
+end
+
+if defined?(::Shoryuken)
+  Shoryuken.configure_server do |config|
+    config.server_middleware do |chain|
+      chain.add Celerbrake::Shoryuken::ErrorHandler
+    end
+  end
+end

data/lib/celerbrake/sidekiq/retryable_jobs_filter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Sidekiq
+    # Filter that can ignore notices from jobs that failed but will be retried
+    # by Sidekiq
+    # @since v7.3.0
+    class RetryableJobsFilter
+      if Gem::Version.new(::Sidekiq::VERSION) < Gem::Version.new('5.0.0')
+        require 'sidekiq/middleware/server/retry_jobs'
+        DEFAULT_MAX_RETRY_ATTEMPTS = \
+          ::Sidekiq::Middleware::Server::RetryJobs::DEFAULT_MAX_RETRY_ATTEMPTS
+      else
+        require 'sidekiq/job_retry'
+        DEFAULT_MAX_RETRY_ATTEMPTS = ::Sidekiq::JobRetry::DEFAULT_MAX_RETRY_ATTEMPTS
+      end
+
+      def initialize(max_retries: nil)
+        @max_retries = max_retries
+      end
+
+      def call(notice)
+        job = notice[:params][:job]
+
+        notice.ignore! if retryable?(job)
+      end
+
+      private
+
+      def retryable?(job)
+        return false unless job && job['retry']
+
+        max_attempts = max_attempts_for(job)
+        retry_count = (job['retry_count'] || -1) + 1
+        retry_count < max_attempts
+      end
+
+      def max_attempts_for(job)
+        if @max_retries
+          @max_retries
+        elsif job['retry'].is_a?(Integer)
+          job['retry']
+        else
+          max_retries
+        end
+      end
+
+      def max_retries
+        @max_retries ||= ::Sidekiq.options[:max_retries] || DEFAULT_MAX_RETRY_ATTEMPTS
+      end
+    end
+  end
+end

data/lib/celerbrake/sidekiq.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'celerbrake/sidekiq/retryable_jobs_filter'
+
+module Celerbrake
+  module Sidekiq
+    # Provides integration with Sidekiq v2+.
+    class ErrorHandler
+      def call(_worker, context, _queue, &block)
+        timing = Celerbrake::Benchmark.measure(&block)
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        notify_celerbrake(exception, context)
+        Celerbrake.notify_queue(
+          queue: context['class'],
+          error_count: 1,
+          timing: 0.01,
+        )
+        raise exception
+      else
+        Celerbrake.notify_queue(
+          queue: context['class'],
+          error_count: 0,
+          timing: timing,
+        )
+      end
+
+      private
+
+      def notify_celerbrake(exception, context)
+        Celerbrake.notify(exception, job: context) do |notice|
+          notice[:context][:component] = 'sidekiq'
+          notice[:context][:action] = action(context)
+        end
+      end
+
+      # @return [String] job's name. When ActiveJob is present, retrieve
+      #   job_class. When used directly, use worker's name
+      def action(context)
+        klass = context['class'] || (context[:job] && context[:job]['class'])
+        return klass unless context[:job] && context[:job]['args'].first.is_a?(Hash)
+        return klass unless (job_class = context[:job]['args'].first['job_class'])
+
+        job_class
+      end
+    end
+  end
+end
+
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add(Celerbrake::Sidekiq::ErrorHandler)
+  end
+end

data/lib/celerbrake/sneakers.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Sneakers
+    # Provides integration with Sneakers.
+    #
+    # @see https://github.com/jondot/sneakers
+    # @since v7.2.0
+    class ErrorReporter
+      # @return [Array<Symbol>] ignored keys values of which raise
+      #   SystemStackError when `as_json` is called on them
+      # @see https://github.com/celerbrake/celerbrake/issues/850
+      IGNORED_KEYS = %i[delivery_tag consumer channel].freeze
+
+      # rubocop:disable Style/OptionalArguments
+      def call(exception, worker = nil, context)
+        # Later versions add a middle argument.
+        Celerbrake.notify(exception, filter_context(context)) do |notice|
+          notice[:context][:component] = 'sneakers'
+          notice[:context][:action] = worker.class.to_s
+        end
+      end
+      # rubocop:enable Style/OptionalArguments
+
+      private
+
+      def filter_context(context)
+        return context unless context[:delivery_info]
+
+        h = context.dup
+        h[:delivery_info] = context[:delivery_info].reject do |k, _v|
+          IGNORED_KEYS.include?(k)
+        end
+        h
+      end
+    end
+  end
+end
+
+Sneakers.error_reporters << Celerbrake::Sneakers::ErrorReporter.new
+
+module Celerbrake
+  module Sneakers
+    # @todo Migrate to Sneakers v2.12.0 middleware API when it's released
+    # @see https://github.com/jondot/sneakers/pull/364
+    module Worker
+      # Sneakers v2.7.0+ renamed `do_work` to `process_work`.
+      define_method(
+        ::Sneakers::Worker.method_defined?(:process_work) ? :process_work : :do_work,
+      ) do |delivery_info, metadata, msg, handler|
+        timing = Celerbrake::Benchmark.measure do
+          super(delivery_info, metadata, msg, handler)
+        end
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        Celerbrake.notify_queue(
+          queue: self.class.to_s,
+          error_count: 1,
+          timing: 0.01,
+        )
+        raise exception
+      else
+        Celerbrake.notify_queue(
+          queue: self.class.to_s,
+          error_count: 0,
+          timing: timing,
+        )
+      end
+    end
+  end
+end
+
+Sneakers::Worker.prepend(Celerbrake::Sneakers::Worker)

data/lib/celerbrake/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# We use Semantic Versioning v2.0.0
+# More information: http://semver.org/
+module Celerbrake
+  CELERBRAKE_VERSION = '0.1.0'
+end

data/lib/celerbrake.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+require 'English'
+
+# Core library that sends notices.
+# See: https://github.com/celerbrake/celerbrake-ruby
+require 'celerbrake-ruby'
+
+require 'celerbrake/version'
+
+# Automatically load needed files for the environment the library is running in.
+if defined?(Rack)
+  require 'celerbrake/rack'
+
+  require 'celerbrake/rails' if defined?(Rails)
+end
+
+require 'celerbrake/rake' if defined?(Rake::Task)
+require 'celerbrake/resque' if defined?(Resque)
+require 'celerbrake/sidekiq' if defined?(Sidekiq)
+require 'celerbrake/shoryuken' if defined?(Shoryuken)
+require 'celerbrake/delayed_job' if defined?(Delayed)
+require 'celerbrake/sneakers' if defined?(Sneakers)
+
+require 'celerbrake/logger'
+
+# Notify of unhandled exceptions, if there were any, but ignore SystemExit.
+at_exit do
+  Celerbrake.notify_sync($ERROR_INFO) if $ERROR_INFO
+  Celerbrake.close
+end

data/lib/generators/celerbrake_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Creates the Celerbrake initializer file for Rails apps.
+#
+# @example Invokation from terminal
+#   rails generate celerbrake [NAME]
+#
+class CelerbrakeGenerator < Rails::Generators::Base
+  # Adds current directory to source paths, so we can find the template file.
+  source_root File.expand_path(__dir__)
+
+  # Makes the NAME option optional, which allows to subclass from Base, so we
+  # can pass arguments to the ERB template.
+  #
+  # @see https://asciicasts.com/episodes/218-making-generators-in-rails-3.html
+  argument :name, type: :string, default: 'application'
+
+  desc 'Configures the Celerbrake notifier'
+  def generate_layout
+    template 'celerbrake_initializer.rb.erb', 'config/initializers/celerbrake.rb'
+  end
+end

data/lib/generators/celerbrake_initializer.rb.erb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# Celerbrake is an online tool that provides robust exception tracking in your
+# Rails applications. In doing so, it allows you to easily review errors, tie an
+# error to an individual piece of code, and trace the cause back to recent
+# changes. Celerbrake enables for easy categorization, searching, and
+# prioritization of exceptions so that when errors occur, your team can quickly
+# determine the root cause.
+#
+# Configuration details:
+# https://github.com/celerbrake/celerbrake-ruby#configuration
+if (project_id = ENV['CELERBRAKE_PROJECT_ID']) &&
+   project_key = (ENV['CELERBRAKE_PROJECT_KEY'] || ENV['CELERBRAKE_API_KEY'])
+  Celerbrake.configure do |c|
+    # You must set both project_id & project_key. To find your project_id and
+    # project_key navigate to your project's General Settings and copy the
+    # values from the right sidebar.
+    # https://github.com/celerbrake/celerbrake-ruby#project_id--project_key
+    c.project_id = project_id
+    c.project_key = project_key
+
+    # Configures the root directory of your project. Expects a String or a
+    # Pathname, which represents the path to your project. Providing this option
+    # helps us to filter out repetitive data from backtrace frames and link to
+    # GitHub files from our dashboard.
+    # https://github.com/celerbrake/celerbrake-ruby#root_directory
+    c.root_directory = Rails.root
+
+    # By default, Celerbrake Ruby outputs to STDOUT. In Rails apps it makes sense
+    # to use the Rails' logger.
+    # https://github.com/celerbrake/celerbrake-ruby#logger
+    c.logger = Celerbrake::Rails.logger
+
+    # Configures the environment the application is running in. Helps the
+    # Celerbrake dashboard to distinguish between exceptions occurring in
+    # different environments.
+    # NOTE: This option must be set in order to make the 'ignore_environments'
+    # option work.
+    # https://github.com/celerbrake/celerbrake-ruby#environment
+    c.environment = Rails.env
+
+    # Setting this option allows Celerbrake to filter exceptions occurring in
+    # unwanted environments such as :test.  NOTE: This option *does not* work if
+    # you don't set the 'environment' option.
+    # https://github.com/celerbrake/celerbrake-ruby#ignore_environments
+    c.ignore_environments = %w[test]
+
+    # A list of parameters that should be filtered out of what is sent to
+    # Celerbrake. By default, all "password" attributes will have their contents
+    # replaced.
+    # https://github.com/celerbrake/celerbrake-ruby#blocklist_keys
+    c.blocklist_keys = [/password/i, /authorization/i]
+
+    # Alternatively, you can integrate with Rails' filter_parameters.
+    # Read more: https://goo.gl/gqQ1xS
+    # c.blocklist_keys = Rails.application.config.filter_parameters
+  end
+
+  # A filter that collects request body information. Enable it if you are sure you
+  # don't send sensitive information to Celerbrake in your body (such as passwords).
+  # https://github.com/celerbrake/celerbrake#requestbodyfilter
+  # Celerbrake.add_filter(Celerbrake::Rack::RequestBodyFilter.new)
+
+  # Attaches thread & fiber local variables along with general thread information.
+  # Celerbrake.add_filter(Celerbrake::Filters::ThreadFilter.new)
+
+  # Attaches loaded dependencies to the notice object
+  # (under context/versions/dependencies).
+  # Celerbrake.add_filter(Celerbrake::Filters::DependencyFilter.new)
+
+  # If you want to convert your log messages to Celerbrake errors, we offer an
+  # integration with the Logger class from stdlib.
+  # https://github.com/celerbrake/celerbrake#logger
+  # Rails.logger = Celerbrake::CelerbrakeLogger.new(Rails.logger)
+else
+  Rails.logger.warn(
+    "#{__FILE__}: Celerbrake project id or project key is not set. " \
+    "Skipping Celerbrake configuration"
+  )
+end