class ActiveSupport::ErrorReporter

maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get(“tags”) }
Both methods can be restricted to handle only a specific error class:
end
do_something!
Rails.error.record do
Alternatively, if you want to report the error but not swallow it, you can use #record:
If an error is raised, it will be reported and swallowed.
end
do_something!
Rails.error.handle do
To rescue and report any unhandled error, you can use the #handle method:
ActiveSupport::ErrorReporter is a common interface for error reporting services.
= Active Support Error Reporter

def disable(subscriber)

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

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

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

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

errors. Defaults to "application".
source of the error. Subscribers can use this value to ignore certain
* +:source+ - This value is passed along to subscribers to indicate the

end
User.find_by(params)
user = Rails.error.handle(fallback: -> { User.anonymous }) do

unhandled error is raised. For example:
* +:fallback+ - A callable that provides +handle+'s return value when an

end
# ...
Rails.error.handle(context: { section: "admin" }) do

example:
* +:context+ - Extra information that is passed along to subscribers. For

Defaults to +:warning+.
important the error report is. Can be +:error+, +:warning+, or +:info+.
* +:severity+ - This value is passed along to subscribers to indicate how

==== Options

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

Can be restricted to handle only specific error classes:

end
1 + '1'
Rails.error.handle do
# Will report a TypeError to all subscribers and return nil.

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

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

def initialize(*subscribers, logger: nil)

def initialize(*subscribers, logger: nil)
  @subscribers = subscribers.flatten
  @logger = logger
end

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

errors. Defaults to "application".
source of the error. Subscribers can use this value to ignore certain
* +:source+ - This value is passed along to subscribers to indicate the

end
# ...
Rails.error.record(context: { section: "admin" }) do

example:
* +:context+ - Extra information that is passed along to subscribers. For

Defaults to +:error+.
important the error report is. Can be +:error+, +:warning+, or +:info+.
* +:severity+ - This value is passed along to subscribers to indicate how

==== Options

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

Can be restricted to handle only specific error classes:

end
1 + '1'
Rails.error.record do
# Will report a TypeError to all subscribers and re-raise it.

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

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

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

Rails.error.report(error)

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

def report(error, handled: true, severity: handled ? :warning : :error, context: {}, source: DEFAULT_SOURCE)
  return if error.instance_variable_defined?(:@__rails_error_reported)
  unless SEVERITIES.include?(severity)
    raise ArgumentError, "severity must be one of #{SEVERITIES.map(&:inspect).join(", ")}, got: #{severity.inspect}"
  end
  full_context = ActiveSupport::ExecutionContext.to_h.merge(context)
  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
  unless error.frozen?
    error.instance_variable_set(:@__rails_error_reported, true)
  end
  nil
end

def set_context(...)

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

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

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

def subscribe(subscriber)

The +report+ method should never raise an error.

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

Register a new error subscriber. The subscriber must respond to

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

def unsubscribe(subscriber)

Rails.error.unsubscribe(MyErrorSubscriber)
# or
Rails.error.unsubscribe(subscriber)

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

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

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

Modules

Classes