class ActiveSupport::ErrorReporter

end
User.find_by(params)
user = Rails.error.handle(fallback: -> { User.anonymous }) do
be returned when the block raises and is handled:
rescuing an error, a fallback can be provided. The fallback must be a callable whose result will
Both handle and record pass through the return value from the block. In the case of handle
severity, and unhandled ones to :error.
severity can be one of :error, :warning, or :info. Handled errors default to the :warning
Additionally a severity can be passed along to communicate how important the error report is.
end
# …
Rails.error.handle(context: { section: “admin” }) do
You can also pass some extra context information that may be used by the error subscribers:
maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get(“tags”) }
Both methods can be restricted to only handle a specific exception 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.

def handle(error_class = StandardError, severity: :warning, context: {}, fallback: nil)


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

Report any unhandled exception, and swallow it. 
def handle(error_class = StandardError, severity: :warning, context: {}, fallback: nil)
  yield
rescue error_class => error
  report(error, handled: true, severity: severity, context: context)
  fallback.call if fallback
end

def initialize(*subscribers, logger: nil) 

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

def record(error_class = StandardError, severity: :error, context: {}) 

def record(error_class = StandardError, severity: :error, context: {})
  yield
rescue error_class => error
  report(error, handled: false, severity: severity, context: context)
  raise
end

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

Rails.error.report(error, handled: true)

When the block based +handle+ and +record+ methods are not suitable, you can directly use +report+ 
def report(error, handled:, severity: handled ? :warning : :error, context: {})
  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)
  @subscribers.each do |subscriber|
    subscriber.report(error, handled: handled, severity: severity, context: full_context)
  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
  nil
end

def set_context(...)

See +ActiveSupport::ExecutionContext.set+

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

Update the execution context that is accessible to error subscribers 
def set_context(...)
  ActiveSupport::ExecutionContext.set(...)
end

def subscribe(subscriber)

The +report+ method +should+ never raise an error.

report(Exception, handled: Boolean, context: Hash)

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