sentry-raven 1.1.0 → 3.1.2

data/Gemfile

@@ -0,0 +1,37 @@
+source "https://rubygems.org/"
+
+gemspec
+
+rails_version = ENV["RAILS_VERSION"]
+rails_version = "5.2" if rails_version.nil?
+
+if rails_version.to_f != 0
+  gem "rails", "~> #{rails_version}"
+  gem "rspec-rails", "~> 4.0"
+end
+
+gem "delayed_job"
+gem "sidekiq"
+
+gem "rack"
+gem "rack-timeout"
+
+# TODO: Remove this if https://github.com/jruby/jruby/issues/6547 is addressed
+gem "i18n", "<= 1.8.7"
+
+gem "pry"
+gem "benchmark-ips"
+gem "benchmark_driver"
+gem "benchmark-ipsa"
+gem "benchmark-memory"
+gem "ruby-prof", platform: :mri
+gem "rake", "> 12"
+gem "rubocop", "~> 0.81.0"
+gem "rspec", "~> 3.9.0"
+gem "capybara", "~> 3.15.0" # rspec system tests
+gem "puma" # rspec system tests
+
+gem "timecop"
+gem "test-unit"
+gem "simplecov"
+gem "codecov", "<= 0.2.12"

data/Makefile

@@ -0,0 +1,3 @@
+build:
+	bundle install
+	gem build sentry-raven.gemspec

data/README.md

@@ -1,13 +1,44 @@
-# Raven-Ruby
+<p align="center">
+  <a href="https://sentry.io" target="_blank" align="center">
+    <img src="https://sentry-brand.storage.googleapis.com/sentry-logo-black.png" width="280">
+  </a>
+  <br>
+</p>
+
+# Raven-Ruby, the Ruby Client for Sentry
+
+### 🚧 Migrating To The New SDK 🚧
+
+We've released our new Ruby SDK, [sentry-ruby](https://github.com/getsentry/sentry-ruby/tree/master/sentry-ruby). Here are the benefits of migrating to it:
+
+- **Unified Interfaces With Other SDKs:** The design of `sentry-raven` is outdated compared with our modern Sentry SDKs. If you also use other Sentry SDKs, such as Sentry's JavaScript SDK for your frontend application, you'll notice that their interfaces are quite different from the one provided for `sentry-raven`. The new `sentry-ruby` SDK provides a more consistent user experience across all different platforms.
+
+- **Performance Monitoring:** The Sentry Ruby SDK includes [performance monitoring](https://docs.sentry.io/product/performance/), which you can enable if you haven't already as ([discussed here](https://docs.sentry.io/platforms/ruby/performance/)).
+
+- **Future Support:** `sentry-raven` has entered maintenance mode, which means it won't receive any new feature supports or aggressive bug fixes.
+
+- **Better Extensibility:** Unlike `sentry-raven`, `sentry-ruby` is built with extensibility in mind and will allow the community to build extensions for different integrations/features.
+
+If you're interested in the migration, please also read our [migration guide](https://docs.sentry.io/platforms/ruby/migration/) for more information.
+
+---
+
 
 [![Gem Version](https://img.shields.io/gem/v/sentry-raven.svg)](https://rubygems.org/gems/sentry-raven)
-[![Build Status](https://img.shields.io/travis/getsentry/raven-ruby/master.svg)](https://travis-ci.org/getsentry/raven-ruby)
+![Build Status](https://github.com/getsentry/raven-ruby/workflows/Test/badge.svg)
+[![Coverage Status](https://img.shields.io/codecov/c/github/getsentry/sentry-ruby/master?logo=codecov)](https://codecov.io/gh/getsentry/sentry-ruby/branch/master)
+[![Gem](https://img.shields.io/gem/dt/sentry-raven.svg)](https://rubygems.org/gems/sentry-raven/)
+[![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=sentry-raven&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=sentry-raven&package-manager=bundler&version-scheme=semver)
+
+
+[Documentation](https://docs.sentry.io/clients/ruby/) | [Bug Tracker](https://github.com/getsentry/raven-ruby/issues) | [Forum](https://forum.sentry.io/) | IRC: irc.freenode.net, #sentry
+
+The official Ruby-language client and integration layer for the [Sentry](https://github.com/getsentry/sentry) error reporting API.
 
-A client and integration layer for the [Sentry](https://github.com/getsentry/sentry) error reporting API.
 
 ## Requirements
 
-We test on Ruby 1.9, 2.2 and 2.3 at the latest patchlevel/teeny version. Our Rails integration works with Rails 4.2+. JRuby support is experimental - check TravisCI to see if the build is passing or failing.
+We test on Ruby 2.3, 2.4, 2.5, 2.6 and 2.7 at the latest patchlevel/teeny version. We also support JRuby 9.0. Our Rails integration works with Rails 4.2+, including Rails 5 and Rails 6.
 
 ## Getting Started
 
@@ -17,30 +48,30 @@ We test on Ruby 1.9, 2.2 and 2.3 at the latest patchlevel/teeny version. Our Rai
 gem "sentry-raven"
 ```
 
-### Raven only runs when SENTRY_DSN is set
+### Raven only runs when Sentry DSN is set
 
 Raven will capture and send exceptions to the Sentry server whenever its DSN is set. This makes environment-based configuration easy - if you don't want to send errors in a certain environment, just don't set the DSN in that environment!
 
 ```bash
 # Set your SENTRY_DSN environment variable.
-export SENTRY_DSN=http://public:secret@example.com/project-id
+export SENTRY_DSN=http://public@example.com/project-id
 ```
 ```ruby
-# Or you can configure the client in the code (not recommended - keep your DSN secret!)
+# Or you can configure the client in the code.
 Raven.configure do |config|
-  config.dsn = 'http://public:secret@example.com/project-id'
+  config.dsn = 'http://public@example.com/project-id'
 end
 ```
 
-### Raven doesn't report some kinds of data by default.
+### Raven doesn't report some kinds of data by default
 
-Raven ignores some exceptions by default - most of these are related to 404s or controller actions not being found. [For a complete list, see the `IGNORE_DEFAULT` constant](https://github.com/getsentry/raven-ruby/blob/master/lib/raven/configuration.rb).
+**Raven ignores some exceptions by default** - most of these are related to 404s or controller actions not being found. [For a complete list, see the `IGNORE_DEFAULT` constant](https://github.com/getsentry/raven-ruby/blob/master/lib/raven/configuration.rb).
 
-Raven doesn't report POST data or cookies by default. In addition, it will attempt to remove any obviously sensitive data, such as credit card or Social Security numbers. For more information about how Sentry processes your data, [check out the documentation on the `processors` config setting.](https://docs.getsentry.com/hosted/clients/ruby/config/)
+Raven doesn't report POST data or cookies by default. In addition, it will attempt to remove any obviously sensitive data, such as credit card or Social Security numbers. For more information about how Sentry processes your data, [check out the documentation on the `processors` config setting.](https://docs.sentry.io/platforms/ruby/configuration/options/)
 
-### Call
+### Usage
 
-If you use Rails, you're already done - no more configuration required! Check [Integrations](https://docs.getsentry.com/hosted/clients/ruby/integrations/) for more details on other gems Sentry integrates with automatically.
+**If you use Rails, you're already done - no more configuration required!** Check [Integrations](https://docs.sentry.io/platforms/ruby/configuration/integrations/) for more details on other gems Sentry integrates with automatically.
 
 Otherwise, Raven supports two methods of capturing exceptions:
 
@@ -57,10 +88,77 @@ rescue ZeroDivisionError => exception
 end
 ```
 
+### More configuration
+
+You're all set - but there's a few more settings you may want to know about too!
+
+#### async
+
+When an error or message occurs, the notification is immediately sent to Sentry. Raven can be configured to send asynchronously:
+
+```ruby
+config.async = lambda { |event|
+  Thread.new { Raven.send_event(event) }
+}
+```
+
+Using a thread to send events will be adequate for truly parallel Ruby platforms such as JRuby, though the benefit on MRI/CRuby will be limited. If the async callback raises an exception, Raven will attempt to send synchronously.
+
+Note that the naive example implementation has a major drawback - it can create an infinite number of threads. We recommend creating a background job, using your background job processor, that will send Sentry notifications in the background.
+
+```ruby
+config.async = lambda { |event| SentryJob.perform_later(event) }
+
+class SentryJob < ActiveJob::Base
+  queue_as :default
+
+  def perform(event)
+    Raven.send_event(event)
+  end
+end
+```
+
+#### transport_failure_callback
+
+If Raven fails to send an event to Sentry for any reason (either the Sentry server has returned a 4XX or 5XX response), this Proc or lambda will be called.
+
+```ruby
+config.transport_failure_callback = lambda { |event, error|
+  AdminMailer.email_admins("Oh god, it's on fire because #{error.message}!", event).deliver_later
+}
+```
+
+#### Context
+
+Much of the usefulness of Sentry comes from additional context data with the events. Raven makes this very convenient by providing methods to set thread local context data that is then submitted automatically with all events:
+
+```ruby
+Raven.user_context email: 'foo@example.com'
+
+Raven.tags_context interesting: 'yes'
+
+Raven.extra_context additional_info: 'foo'
+```
+
+You can also use `tags_context` and `extra_context` to provide scoped information:
+
+```ruby
+Raven.tags_context(interesting: 'yes') do
+  # the `interesting: 'yes'` tag will only present in the requests sent inside the block
+  Raven.capture_exception(exception)
+end
+
+Raven.extra_context(additional_info: 'foo') do
+  # same as above, the `additional_info` will only present in this request
+  Raven.capture_exception(exception)
+end
+```
+
+For more information, see [Context](https://docs.sentry.io/platforms/ruby/enriching-events/context/).
+
 ## More Information
 
-* [Documentation](https://docs.getsentry.com/hosted/clients/ruby/)
-* [Bug Tracker](https://github.com/getsentry/raven-ruby/issues>)
-* [Code](https://github.com/getsentry/raven-ruby>)
-* [Mailing List](https://groups.google.com/group/getsentry>)
-* [IRC](irc://irc.freenode.net/sentry>)  (irc.freenode.net, #sentry)
+* [Documentation](https://docs.sentry.io/clients/ruby/)
+* [Bug Tracker](https://github.com/getsentry/raven-ruby/issues)
+* [Forum](https://forum.sentry.io/)
+- [Discord](https://discord.gg/ez5KZN7)

data/Rakefile

@@ -0,0 +1,30 @@
+require 'rake'
+require 'raven'
+require 'rubygems/package_task'
+require 'bundler/gem_tasks'
+
+gemspec = Gem::Specification.load(Dir['*.gemspec'].first)
+
+Gem::PackageTask.new(gemspec).define
+
+begin
+  require 'rubygems'
+  require 'rspec/core/rake_task'
+
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new(:rubocop) do |task|
+    task.patterns = ['lib/**/*.rb','spec/**/*.rb',]
+    task.options << '--display-cop-names'
+  end
+
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = 'spec/**/*_spec.rb'
+  end
+
+rescue LoadError
+  task :spec do
+    abort "Rspec is not available. bundle install to run unit tests"
+  end
+end
+
+task :default => [:rubocop, :spec]

data/exe/raven

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require "raven"
+require "raven/cli"
+require "optparse"
+
+parser = OptionParser.new do |opt|
+  opt.banner = "Usage: raven COMMAND [OPTIONS]"
+  opt.separator  ""
+  opt.separator  "Commands"
+  opt.separator  "     test: send a test event"
+  opt.separator  ""
+  opt.separator  "Options"
+
+  opt.on("-h", "--help", "help") do
+    puts parser
+  end
+end
+
+parser.parse!
+
+case ARGV[0]
+when "test"
+  dsn = ARGV[1] if ARGV.length > 1
+  if !dsn
+    puts "Usage: raven test <dsn>"
+  else
+    Raven::CLI.test(dsn)
+  end
+else
+  puts parser
+end

data/lib/raven/backtrace.rb

@@ -1,16 +1,22 @@
+# frozen_string_literal: true
+
 ## Inspired by Rails' and Airbrake's backtrace parsers.
 
 module Raven
-
   # Front end to parsing the backtrace for each notice
   class Backtrace
     # Handles backtrace parsing line by line
     class Line
-      # regexp (optionnally allowing leading X: for windows support)
-      RUBY_INPUT_FORMAT = %r{^((?:[a-zA-Z]:)?[^:]+|<.*>):(\d+)(?::in `([^']+)')?$}
+      RB_EXTENSION = ".rb"
+      # regexp (optional leading X: on windows, or JRuby9000 class-prefix)
+      RUBY_INPUT_FORMAT = /
+        ^ \s* (?: [a-zA-Z]: | uri:classloader: )? ([^:]+ | <.*>):
+        (\d+)
+        (?: :in \s `([^']+)')?$
+      /x.freeze
 
       # org.jruby.runtime.callsite.CachingCallSite.call(CachingCallSite.java:170)
-      JAVA_INPUT_FORMAT = %r{^(.+)\.([^\.]+)\(([^\:]+)\:(\d+)\)$}
+      JAVA_INPUT_FORMAT = /^(.+)\.([^\.]+)\(([^\:]+)\:(\d+)\)$/.freeze
 
       # The file portion of the line (such as app/models/user.rb)
       attr_reader :file
@@ -31,6 +37,7 @@ module Raven
         ruby_match = unparsed_line.match(RUBY_INPUT_FORMAT)
         if ruby_match
           _, file, number, method = ruby_match.to_a
+          file.sub!(/\.class$/, RB_EXTENSION)
           module_name = nil
         else
           java_match = unparsed_line.match(JAVA_INPUT_FORMAT)
@@ -47,7 +54,7 @@ module Raven
       end
 
       def in_app
-        if self.file =~ self.class.in_app_pattern
+        if file =~ self.class.in_app_pattern
           true
         else
           false
@@ -69,7 +76,7 @@ module Raven
 
       def self.in_app_pattern
         @in_app_pattern ||= begin
-          project_root = Raven.configuration.project_root && Raven.configuration.project_root.to_s
+          project_root = Raven.configuration.project_root&.to_s
           Regexp.new("^(#{project_root}/)?#{Raven.configuration.app_dirs_pattern || APP_DIRS_PATTERN}")
         end
       end
@@ -79,7 +86,7 @@ module Raven
       attr_writer :file, :number, :method, :module_name
     end
 
-    APP_DIRS_PATTERN = /(bin|exe|app|config|lib|test)/
+    APP_DIRS_PATTERN = /(bin|exe|app|config|lib|test)/.freeze
 
     # holder for an Array of Backtrace::Line instances
     attr_reader :lines
@@ -87,6 +94,8 @@ module Raven
     def self.parse(backtrace, opts = {})
       ruby_lines = backtrace.is_a?(Array) ? backtrace : backtrace.split(/\n\s*/)
 
+      ruby_lines = opts[:configuration].backtrace_cleanup_callback.call(ruby_lines) if opts[:configuration]&.backtrace_cleanup_callback
+
       filters = opts[:filters] || []
       filtered_lines = ruby_lines.to_a.map do |line|
         filters.reduce(line) do |nested_line, proc|
@@ -106,7 +115,7 @@ module Raven
     end
 
     def inspect
-      "<Backtrace: " + lines.map(&inspect).join(", ") + ">"
+      "<Backtrace: " + lines.map(&:inspect).join(", ") + ">"
     end
 
     def to_s

data/lib/raven/base.rb

@@ -1,203 +1,63 @@
 require 'raven/version'
+require "raven/helpers/deprecation_helper"
+require 'raven/core_ext/object/deep_dup'
 require 'raven/backtrace'
+require 'raven/breadcrumbs'
 require 'raven/processor'
 require 'raven/processor/sanitizedata'
 require 'raven/processor/removecircularreferences'
 require 'raven/processor/utf8conversion'
 require 'raven/processor/cookies'
 require 'raven/processor/post_data'
+require 'raven/processor/http_headers'
 require 'raven/configuration'
 require 'raven/context'
 require 'raven/client'
 require 'raven/event'
+require 'raven/linecache'
 require 'raven/logger'
 require 'raven/interfaces/message'
 require 'raven/interfaces/exception'
 require 'raven/interfaces/single_exception'
 require 'raven/interfaces/stack_trace'
 require 'raven/interfaces/http'
+require 'raven/transports'
+require 'raven/transports/http'
 require 'raven/utils/deep_merge'
+require 'raven/utils/real_ip'
+require 'raven/utils/request_id'
+require 'raven/utils/exception_cause_chain'
+require 'raven/instance'
 
-module Raven
-  AVAILABLE_INTEGRATIONS = %w[delayed_job railties sidekiq rack rake].freeze
-
-  class << self
-    # The client object is responsible for delivering formatted data to the Sentry server.
-    # Must respond to #send. See Raven::Client.
-    attr_writer :client
-
-    # A Raven configuration object. Must act like a hash and return sensible
-    # values for all Raven configuration options. See Raven::Configuration.
-    attr_writer :configuration
-
-    def context
-      Context.current
-    end
-
-    def logger
-      @logger ||= Logger.new
-    end
-
-    # The configuration object.
-    # @see Raven.configure
-    def configuration
-      @configuration ||= Configuration.new
-    end
-
-    # The client object is responsible for delivering formatted data to the Sentry server.
-    def client
-      @client ||= Client.new(configuration)
-    end
-
-    # Tell the log that the client is good to go
-    def report_status
-      return if client.configuration.silence_ready
-      if client.configuration.send_in_current_environment?
-        logger.info "Raven #{VERSION} ready to catch errors"
-      else
-        logger.info "Raven #{VERSION} configured not to send errors."
-      end
-    end
-    alias_method :report_ready, :report_status
-
-    # Call this method to modify defaults in your initializers.
-    #
-    # @example
-    #   Raven.configure do |config|
-    #     config.server = 'http://...'
-    #   end
-    def configure
-      yield(configuration) if block_given?
-
-      self.client = Client.new(configuration)
-      report_status
-      self.client
-    end
-
-    # Send an event to the configured Sentry server
-    #
-    # @example
-    #   evt = Raven::Event.new(:message => "An error")
-    #   Raven.send_event(evt)
-    def send_event(event)
-      client.send_event(event)
-    end
-
-    # Capture and process any exceptions from the given block, or globally if
-    # no block is given
-    #
-    # @example
-    #   Raven.capture do
-    #     MyApp.run
-    #   end
-    def capture(options = {})
-      if block_given?
-        begin
-          yield
-        rescue Error
-          raise # Don't capture Raven errors
-        rescue Exception => e
-          capture_exception(e, options)
-          raise
-        end
-      else
-        install_at_exit_hook(options)
-      end
-    end
-
-    def capture_type(obj, options = {})
-      return false unless should_capture?(obj)
-      message_or_exc = obj.is_a?(String) ? "message" : "exception"
-      if (evt = Event.send("from_" + message_or_exc, obj, options))
-        yield evt if block_given?
-        if configuration.async?
-          configuration.async.call(evt)
-        else
-          send_event(evt)
-        end
-        Thread.current[:sentry_last_event_id] = evt.id
-        evt
-      end
-    end
-    alias_method :capture_message, :capture_type
-    alias_method :capture_exception, :capture_type
+require 'forwardable'
+require 'English'
 
-    def last_event_id
-      Thread.current[:sentry_last_event_id]
-    end
-
-    def should_capture?(message_or_exc)
-      if configuration.should_capture
-        configuration.should_capture.call(*[message_or_exc])
-      else
-        true
-      end
-    end
+module Raven
+  AVAILABLE_INTEGRATIONS = %w(delayed_job railties sidekiq rack rack-timeout rake).freeze
 
-    # Provides extra context to the exception prior to it being handled by
-    # Raven. An exception can have multiple annotations, which are merged
-    # together.
-    #
-    # The options (annotation) is treated the same as the ``options``
-    # parameter to ``capture_exception`` or ``Event.from_exception``, and
-    # can contain the same ``:user``, ``:tags``, etc. options as these
-    # methods.
-    #
-    # These will be merged with the ``options`` parameter to
-    # ``Event.from_exception`` at the top of execution.
-    #
-    # @example
-    #   begin
-    #     raise "Hello"
-    #   rescue => exc
-    #     Raven.annotate_exception(exc, :user => { 'id' => 1,
-    #                              'email' => 'foo@example.com' })
-    #   end
-    def annotate_exception(exc, options = {})
-      notes = (exc.instance_variable_defined?(:@__raven_context) && exc.instance_variable_get(:@__raven_context)) || {}
-      notes.merge!(options)
-      exc.instance_variable_set(:@__raven_context, notes)
-      exc
-    end
+  class Error < StandardError
+  end
 
-    # Bind user context. Merges with existing context (if any).
-    #
-    # It is recommending that you send at least the ``id`` and ``email``
-    # values. All other values are arbitrary.
-    #
-    # @example
-    #   Raven.user_context('id' => 1, 'email' => 'foo@example.com')
-    def user_context(options = nil)
-      self.context.user = options || {}
-    end
+  class << self
+    extend Forwardable
 
-    # Bind tags context. Merges with existing context (if any).
-    #
-    # Tags are key / value pairs which generally represent things like application version,
-    # environment, role, and server names.
-    #
-    # @example
-    #   Raven.tags_context('my_custom_tag' => 'tag_value')
-    def tags_context(options = nil)
-      self.context.tags.merge!(options || {})
+    def instance
+      @instance ||= Raven::Instance.new
     end
 
-    # Bind extra context. Merges with existing context (if any).
-    #
-    # Extra context shows up as Additional Data within Sentry, and is completely arbitrary.
-    #
-    # @example
-    #   Raven.extra_context('my_custom_data' => 'value')
-    def extra_context(options = nil)
-      self.context.extra.merge!(options || {})
-    end
+    def_delegators :instance, :client=, :configuration=, :context, :logger, :configuration,
+                   :client, :report_status, :configure, :send_event, :capture, :capture_type,
+                   :last_event_id, :annotate_exception, :user_context,
+                   :tags_context, :extra_context, :rack_context, :breadcrumbs
 
-    def rack_context(env)
-      if env.empty?
-        env = nil
-      end
-      self.context.rack_env = env
-    end
+    def_delegator :instance, :report_status, :report_ready
+    def_delegator :instance, :capture_type, :capture_message
+    def_delegator :instance, :capture_type, :capture_exception
+    # For cross-language compatibility
+    def_delegator :instance, :capture_type, :captureException
+    def_delegator :instance, :capture_type, :captureMessage
+    def_delegator :instance, :annotate_exception, :annotateException
+    def_delegator :instance, :annotate_exception, :annotate
 
     # Injects various integrations. Default behavior: inject all available integrations
     def inject
@@ -214,7 +74,7 @@ module Raven
       integrations_to_load = Raven::AVAILABLE_INTEGRATIONS & only_integrations
       not_found_integrations = only_integrations - integrations_to_load
       if not_found_integrations.any?
-        self.logger.warn "Integrations do not exist: #{not_found_integrations.join ', '}"
+        logger.warn "Integrations do not exist: #{not_found_integrations.join ', '}"
       end
       integrations_to_load &= Gem.loaded_specs.keys
       # TODO(dcramer): integrations should have some additional checks baked-in
@@ -228,34 +88,25 @@ module Raven
 
     def load_integration(integration)
       require "raven/integrations/#{integration}"
-    rescue Exception => error
-      self.logger.warn "Unable to load raven/integrations/#{integration}: #{error}"
+    rescue Exception => e
+      logger.warn "Unable to load raven/integrations/#{integration}: #{e}"
     end
 
-    def rails_safely_prepend(module_name, opts = {})
-      return if opts[:to].nil?
+    def safely_prepend(module_name, opts = {})
+      return if opts[:to].nil? || opts[:from].nil?
+
       if opts[:to].respond_to?(:prepend, true)
-        opts[:to].send(:prepend, Raven::Rails::Overrides.const_get(module_name))
+        opts[:to].send(:prepend, opts[:from].const_get(module_name))
       else
-        opts[:to].send(:include, Raven::Rails::Overrides.const_get("Old" + module_name))
+        opts[:to].send(:include, opts[:from].const_get("Old" + module_name))
       end
     end
 
-    # For cross-language compat
-    alias :captureException :capture_exception
-    alias :captureMessage :capture_message
-    alias :annotateException :annotate_exception
-    alias :annotate :annotate_exception
+    def sys_command(command)
+      result = `#{command} 2>&1` rescue nil
+      return if result.nil? || result.empty? || ($CHILD_STATUS && $CHILD_STATUS.exitstatus != 0)
 
-    private
-
-    def install_at_exit_hook(options)
-      at_exit do
-        if $!
-          logger.debug "Caught a post-mortem exception: #{$!.inspect}"
-          capture_exception($!, options)
-        end
-      end
+      result.strip
     end
   end
 end

data/lib/raven/breadcrumbs/active_support_logger.rb

@@ -0,0 +1,25 @@
+module Raven
+  module Breadcrumbs
+    module ActiveSupportLogger
+      class << self
+        def add(name, started, _finished, _unique_id, data)
+          Raven.breadcrumbs.record do |crumb|
+            crumb.data = data
+            crumb.category = name
+            crumb.timestamp = started.to_i
+          end
+        end
+
+        def inject
+          @subscriber = ::ActiveSupport::Notifications.subscribe(/.*/) do |name, started, finished, unique_id, data|
+            add(name, started, finished, unique_id, data)
+          end
+        end
+
+        def detach
+          ::ActiveSupport::Notifications.unsubscribe(@subscriber)
+        end
+      end
+    end
+  end
+end

data/lib/raven/breadcrumbs/logger.rb

@@ -0,0 +1,3 @@
+DeprecationHelper.deprecate_old_breadcrumbs_configuration(:sentry_logger)
+
+require "raven/breadcrumbs/sentry_logger"