ActiveSupport::ErrorReporter (original) (raw)

Active Support Error Reporter ↑

ActiveSupport::ErrorReporter is a common interface for error reporting services.

To rescue and report any unhandled error, you can use the handle method:

Rails.error.handle do do_something! end

If an error is raised, it will be reported and swallowed.

Alternatively, if you want to report the error but not swallow it, you can use record:

Rails.error.record do do_something! end

Both methods can be restricted to handle only a specific error class:

maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }

Namespace

Methods

A

D

H

N

R

S

U

Constants

DEFAULT_RESCUE = [StandardError].freeze
DEFAULT_SOURCE = "application"
SEVERITIES = %i(error warning info)
UnexpectedError = Class.new(Exception)

Attributes

[RW] debug_mode
[RW] logger

Class Public methods

Source: show | on GitHub

def initialize(*subscribers, logger: nil) @subscribers = subscribers.flatten @logger = logger @debug_mode = false @context_middlewares = ErrorContextMiddlewareStack.new end

Instance Public methods

Add a middleware to modify the error context before it is sent to subscribers.

Middleware is added to a stack of callables run on an error’s execution context before passing to subscribers. Allows creation of entries in error context that are shared by all subscribers.

A context middleware receives the same parameters as report. It must return a hash - the middleware stack returns the hash after it has run through all middlewares. A middleware can mutate or replace the hash.

Rails.error.add_middleware(-> (error, context) { context.merge({ foo: :bar }) })

Source: show | on GitHub

def add_middleware(middleware) @context_middlewares.use(middleware) end

Prevent a subscriber from being notified of errors for the duration of the block. You may pass in the subscriber itself, or its class.

This can be helpful for error reporting service integrations, when they wish to handle any errors higher in the stack.

Source: show | on GitHub

def disable(subscriber) disabled_subscribers = (ActiveSupport::IsolatedExecutionState[self] ||= []) disabled_subscribers << subscriber begin yield ensure disabled_subscribers.delete(subscriber) end end

handle(*error_classes, severity: :warning, context: {}, fallback: nil, source: DEFAULT_SOURCE)Link

Evaluates the given block, reporting and swallowing any unhandled error. If no error is raised, returns the return value of the block. Otherwise, returns the result of fallback.call, or nil if fallback is not specified.

Rails.error.handle do 1 + '1' end

Can be restricted to handle only specific error classes:

maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }

Options ↑

end

Source: show | on GitHub

def handle(*error_classes, severity: :warning, context: {}, fallback: nil, source: DEFAULT_SOURCE) error_classes = DEFAULT_RESCUE if error_classes.empty? yield rescue *error_classes => error report(error, handled: true, severity: severity, context: context, source: source) fallback.call if fallback end

record(*error_classes, severity: :error, context: {}, source: DEFAULT_SOURCE)Link

Evaluates the given block, reporting and re-raising any unhandled error. If no error is raised, returns the return value of the block.

Rails.error.record do 1 + '1' end

Can be restricted to handle only specific error classes:

tags = Rails.error.record(Redis::BaseError) { redis.get("tags") }

Options ↑

end

Source: show | on GitHub

def record(*error_classes, severity: :error, context: {}, source: DEFAULT_SOURCE) error_classes = DEFAULT_RESCUE if error_classes.empty? yield rescue *error_classes => error report(error, handled: false, severity: severity, context: context, source: source) raise end

report(error, handled: true, severity: handled ? :warning : :error, context: {}, source: DEFAULT_SOURCE)Link

Report an error directly to subscribers. You can use this method when the block-based handle and record methods are not suitable.

Rails.error.report(error)

The error argument must be an instance of Exception.

Rails.error.report(Exception.new("Something went wrong"))

Otherwise you can use unexpected to report an error which does accept a string argument.

Source: show | on GitHub

def report(error, handled: true, severity: handled ? :warning : :error, context: {}, source: DEFAULT_SOURCE) return if error.instance_variable_defined?(:@__rails_error_reported) raise ArgumentError, "Reported error must be an Exception, got: #{error.inspect}" unless error.is_a?(Exception)

ensure_backtrace(error)

unless SEVERITIES.include?(severity) raise ArgumentError, "severity must be one of #{SEVERITIES.map(&:inspect).join(", ")}, got: #{severity.inspect}" end

full_context = @context_middlewares.execute( error, context: ActiveSupport::ExecutionContext.to_h.merge(context || {}), handled:, severity:, source: )

disabled_subscribers = ActiveSupport::IsolatedExecutionState[self] @subscribers.each do |subscriber| unless disabled_subscribers&.any? { |s| s === subscriber } subscriber.report(error, handled: handled, severity: severity, context: full_context, source: source) end rescue => subscriber_error if logger logger.fatal( "Error subscriber raised an error: #{subscriber_error.message} (#{subscriber_error.class})\n" + subscriber_error.backtrace.join("\n") ) else raise end end

while error unless error.frozen? error.instance_variable_set(:@__rails_error_reported, true) end error = error.cause end

nil end

Update the execution context that is accessible to error subscribers. Any context passed to handle, record, or report will be merged with the context set here.

Rails.error.set_context(section: "checkout", user_id: @user.id)

Source: show | on GitHub

def set_context(...) ActiveSupport::ExecutionContext.set(...) end

Register a new error subscriber. The subscriber must respond to

report(Exception, handled: Boolean, severity: (:error OR :warning OR :info), context: Hash, source: String)

The report method should never raise an error.

Source: show | on GitHub

def subscribe(subscriber) unless subscriber.respond_to?(:report) raise ArgumentError, "Error subscribers must respond to #report" end @subscribers << subscriber end

unexpected(error, severity: :warning, context: {}, source: DEFAULT_SOURCE)Link

Either report the given error when in production, or raise it when in development or test.

When called in production, after the error is reported, this method will return nil and execution will continue.

When called in development, the original error is wrapped in a different error class to ensure it’s not being rescued higher in the stack and will be surfaced to the developer.

This method is intended for reporting violated assertions about preconditions, or similar cases that can and should be gracefully handled in production, but that aren’t supposed to happen.

The error can be either an exception instance or a String.

example:

def edit if published? Rails.error.unexpected("[BUG] Attempting to edit a published article, that shouldn't be possible") return false end # ... end

Source: show | on GitHub

def unexpected(error, severity: :warning, context: {}, source: DEFAULT_SOURCE) error = RuntimeError.new(error) if error.is_a?(String)

if @debug_mode ensure_backtrace(error) raise UnexpectedError, "#{error.class.name}: #{error.message}", error.backtrace, cause: error else report(error, handled: true, severity: severity, context: context, source: source) end end

Unregister an error subscriber. Accepts either a subscriber or a class.

subscriber = MyErrorSubscriber.new Rails.error.subscribe(subscriber)

Rails.error.unsubscribe(subscriber)

Rails.error.unsubscribe(MyErrorSubscriber)

Source: show | on GitHub

def unsubscribe(subscriber) @subscribers.delete_if { |s| subscriber === s } end