sentry-raven 3.0.0 → 3.1.0

data/CONTRIBUTING.md

@@ -0,0 +1,71 @@
+<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>
+
+# Contributing
+
+You can contribute this project in the following ways:
+
+- File a [bug report] or propose a feature
+- Open a PR for bug fixes or implementing requested features
+- Give feedback to opened issues/pull requests
+- Test the latest version - `gem 'sentry-raven', github: 'getsentry/raven-ruby'`
+- Contribute documentation in the [document repo]
+
+
+And if you have any questions, please feel free to reach out on [Discord].
+
+
+[bug report]: https://github.com/getsentry/raven-ruby/issues/new?template=bug_report.md
+[document repo]: https://github.com/getsentry/sentry-docs
+[Discord]: https://discord.gg/Ww9hbqr
+
+## How To Contribute
+
+### Running Tests
+
+#### RAILS_VERSION
+
+Because this SDK supports multiple versions of Rails, or even without Rails, you might want to run your test against different versions of Rails.
+
+You can do this by changing the `RAILS_VERSION` environment variable:
+
+
+```
+$ echo RAILS_VERSION=6.0
+$ bundle update # this is necessary if you're switching between Rails versions
+$ bundle exec rake
+```
+
+If not specified, it runs tests against `Rails 5.2`. 
+
+And if you don't want to run the Rails related test cases, you can use `RAILS_VERSION=0`
+
+```
+$ RAILS_VERSION=0 bundle exec rake # runs without Rails related test cases
+```
+
+### Testing Your Change Against Example Rails Apps
+
+We have a few example apps for different Rails versions under the `/examples` folder. You can use them to perform an end-to-end testing on your changes (just remember to change the DSN to your project's).
+
+At this moment, we recommend testing against the [Rails 6 example](https://github.com/getsentry/raven-ruby/tree/master/examples/rails-6.0) first. Please read its readme to see what kind of testing you can perform with it.
+
+
+## Making a release
+
+Install and use `craft`: https://github.com/getsentry/craft
+
+Make sure the `CHANGELOG.md` is update and latest `master` contains all changes.
+
+Run:
+
+```bash
+craft prepare x.x.x
+```
+
+Where `x.x.x` stands for the version you want to release.
+Afterwards reach out to an employee of Sentry, they will cut a release by running the `publish` process of `craft`.

data/Gemfile

@@ -2,37 +2,32 @@ source "https://rubygems.org/"
 
 gemspec
 
-if ENV["RAILS_VERSION"] && (ENV["RAILS_VERSION"].to_i == 4)
-  gem "rails", "< 5"
-  gem "rspec-rails", "> 3"
-elsif ENV["RAILS_VERSION"] && (ENV["RAILS_VERSION"].to_i == 0)
-  # no-op. No Rails.
-else
-  gem "rails", "< 6"
-  gem "rspec-rails", "> 3"
-end
+rails_version = ENV["RAILS_VERSION"]
+rails_version = "5.2" if rails_version.nil?
 
-if RUBY_VERSION < '2.0'
-  gem "mime-types", "< 3.0.0"
-  gem "nokogiri", "~> 1.6.8"
-  gem "rack", "~> 1.6.8"
-  gem "sidekiq", "< 3.2"
-  gem "rack-timeout", "0.3.0"
-else
-  gem "rack"
-  gem "sidekiq"
-  gem "rack-timeout"
+if rails_version.to_f != 0
+  gem "rails", "~> #{rails_version}"
+  gem "rspec-rails", "~> 4.0"
 end
+
+gem "sidekiq"
+
+gem "rack"
+gem "rack-timeout"
+
 gem "pry"
-gem "pry-coolline"
 gem "benchmark-ips"
-gem "benchmark-ipsa" if RUBY_VERSION > '2.0'
+gem "benchmark_driver"
+gem "benchmark-ipsa"
+gem "benchmark-memory"
 gem "ruby-prof", platform: :mri
 gem "rake", "> 12"
-gem "rubocop", "~> 0.41.1" # Last version that supported 1.9, upgrade to 0.50 after we drop 1.9
-gem "rspec", "> 3"
-gem "capybara" # rspec system tests
+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", platform: :mri if RUBY_VERSION > '2.2'
+gem "test-unit"
+gem "simplecov"
+gem "codecov"

data/README.md

@@ -8,7 +8,8 @@
 # Raven-Ruby, the Ruby Client for Sentry
 
 [![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/raven-ruby/master?logo=codecov)](https://codecov.io/gh/getsentry/raven-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)
 
@@ -19,7 +20,7 @@ The official Ruby-language client and integration layer for the [Sentry](https:/
 
 ## Requirements
 
-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).
+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
 
@@ -29,7 +30,7 @@ We test on Ruby 2.3, 2.4, 2.5, 2.6 and 2.7 at the latest patchlevel/teeny versio
 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!
 
@@ -38,7 +39,7 @@ Raven will capture and send exceptions to the Sentry server whenever its DSN is
 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@example.com/project-id'
 end
@@ -48,11 +49,11 @@ end
 
 **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/config/)
 
 ### 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/integrations/) for more details on other gems Sentry integrates with automatically.
 
 Otherwise, Raven supports two methods of capturing exceptions:
 
@@ -104,26 +105,35 @@ end
 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|
-  AdminMailer.email_admins("Oh god, it's on fire!", event).deliver_later
+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.
-
-There are three primary methods for providing request 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
-# bind the logged in user
 Raven.user_context email: 'foo@example.com'
 
-# tag the request with something interesting
-Raven.tags_context interesting: 'yes'
+Raven.tags.merge!(interesting: 'yes')
+
+Raven.extra.merge!(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
 
-# provide a bit of additional context
-Raven.extra_context happiness: 'very'
+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/clients/ruby/context/).

data/lib/raven/backtrace.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ## Inspired by Rails' and Airbrake's backtrace parsers.
 
 module Raven
@@ -5,16 +7,16 @@ module Raven
   class Backtrace
     # Handles backtrace parsing line by line
     class Line
-      RB_EXTENSION = ".rb".freeze
+      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
+      /x.freeze
 
       # org.jruby.runtime.callsite.CachingCallSite.call(CachingCallSite.java:170)
-      JAVA_INPUT_FORMAT = /^(.+)\.([^\.]+)\(([^\:]+)\:(\d+)\)$/
+      JAVA_INPUT_FORMAT = /^(.+)\.([^\.]+)\(([^\:]+)\:(\d+)\)$/.freeze
 
       # The file portion of the line (such as app/models/user.rb)
       attr_reader :file
@@ -74,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
@@ -84,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
@@ -92,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|

data/lib/raven/base.rb

@@ -1,4 +1,6 @@
 require 'raven/version'
+require "raven/helpers/deprecation_helper"
+require 'raven/core_ext/object/deep_dup'
 require 'raven/backtrace'
 require 'raven/breadcrumbs'
 require 'raven/processor'
@@ -85,12 +87,13 @@ module Raven
 
     def load_integration(integration)
       require "raven/integrations/#{integration}"
-    rescue Exception => error
-      logger.warn "Unable to load raven/integrations/#{integration}: #{error}"
+    rescue Exception => e
+      logger.warn "Unable to load raven/integrations/#{integration}: #{e}"
     end
 
     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, opts[:from].const_get(module_name))
       else
@@ -101,6 +104,7 @@ module Raven
     def sys_command(command)
       result = `#{command} 2>&1` rescue nil
       return if result.nil? || result.empty? || ($CHILD_STATUS && $CHILD_STATUS.exitstatus != 0)
+
       result.strip
     end
   end

data/lib/raven/breadcrumbs.rb

@@ -64,7 +64,7 @@ module Raven
     end
 
     def empty?
-      !members.any?
+      members.none?
     end
 
     def to_hash

data/lib/raven/breadcrumbs/{activesupport.rb → active_support_logger.rb}

@@ -1,6 +1,7 @@
 module Raven
-  module ActiveSupportBreadcrumbs
-    class << self
+  module Breadcrumbs
+    module ActiveSupportLogger
+      class << self
         def add(name, started, _finished, _unique_id, data)
           Raven.breadcrumbs.record do |crumb|
             crumb.data = data
@@ -10,10 +11,15 @@ module Raven
         end
 
         def inject
-          ActiveSupport::Notifications.subscribe(/.*/) do |name, started, finished, unique_id, data|
+          @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

@@ -1,93 +1,3 @@
-require 'logger'
+DeprecationHelper.deprecate_old_breadcrumbs_configuration(:sentry_logger)
 
-module Raven
-  module BreadcrumbLogger
-    LEVELS = {
-      ::Logger::DEBUG => 'debug',
-      ::Logger::INFO  => 'info',
-      ::Logger::WARN  => 'warn',
-      ::Logger::ERROR => 'error',
-      ::Logger::FATAL => 'fatal'
-    }.freeze
-
-    EXC_FORMAT = /^([a-zA-Z0-9]+)\:\s(.*)$/
-
-    def self.parse_exception(message)
-      lines = message.split(/\n\s*/)
-      # TODO: wat
-      return nil unless lines.length > 2
-
-      match = lines[0].match(EXC_FORMAT)
-      return nil unless match
-
-      _, type, value = match.to_a
-      [type, value]
-    end
-
-    def add(*args)
-      add_breadcrumb(*args)
-      super
-    end
-
-    def add_breadcrumb(severity, message = nil, progname = nil)
-      message = progname if message.nil? # see Ruby's Logger docs for why
-      return if ignored_logger?(progname)
-      return if message.nil? || message == ""
-
-      # some loggers will add leading/trailing space as they (incorrectly, mind you)
-      # think of logging as a shortcut to std{out,err}
-      message = message.to_s.strip
-
-      last_crumb = Raven.breadcrumbs.peek
-      # try to avoid dupes from logger broadcasts
-      if last_crumb.nil? || last_crumb.message != message
-        error = Raven::BreadcrumbLogger.parse_exception(message)
-        # TODO(dcramer): we need to filter out the "currently captured error"
-        if error
-          Raven.breadcrumbs.record do |crumb|
-            crumb.level = Raven::BreadcrumbLogger::LEVELS.fetch(severity, nil)
-            crumb.category = progname || 'error'
-            crumb.type = 'error'
-            crumb.data = {
-              :type => error[0],
-              :value => error[1]
-            }
-          end
-        else
-          Raven.breadcrumbs.record do |crumb|
-            crumb.level = Raven::BreadcrumbLogger::LEVELS.fetch(severity, nil)
-            crumb.category = progname || 'logger'
-            crumb.message = message
-          end
-        end
-      end
-    end
-
-    private
-
-    def ignored_logger?(progname)
-      progname == "sentry" ||
-        Raven.configuration.exclude_loggers.include?(progname)
-    end
-  end
-  module OldBreadcrumbLogger
-    def self.included(base)
-      base.class_eval do
-        include Raven::BreadcrumbLogger
-        alias_method :add_without_raven, :add
-        alias_method :add, :add_with_raven
-      end
-    end
-
-    def add_with_raven(*args)
-      add_breadcrumb(*args)
-      add_without_raven(*args)
-    end
-  end
-end
-
-Raven.safely_prepend(
-  "BreadcrumbLogger",
-  :from => Raven,
-  :to => ::Logger
-)
+require "raven/breadcrumbs/sentry_logger"

data/lib/raven/breadcrumbs/sentry_logger.rb

@@ -0,0 +1,73 @@
+require 'logger'
+
+module Raven
+  module Breadcrumbs
+    module SentryLogger
+      LEVELS = {
+        ::Logger::DEBUG => 'debug',
+        ::Logger::INFO => 'info',
+        ::Logger::WARN => 'warn',
+        ::Logger::ERROR => 'error',
+        ::Logger::FATAL => 'fatal'
+      }.freeze
+
+      def add(*args)
+        add_breadcrumb(*args)
+        super
+      end
+
+      def add_breadcrumb(severity, message = nil, progname = nil)
+        message = progname if message.nil? # see Ruby's Logger docs for why
+        return if ignored_logger?(progname)
+        return if message.nil? || message == ""
+
+        # some loggers will add leading/trailing space as they (incorrectly, mind you)
+        # think of logging as a shortcut to std{out,err}
+        message = message.to_s.strip
+
+        last_crumb = Raven.breadcrumbs.peek
+        # try to avoid dupes from logger broadcasts
+        if last_crumb.nil? || last_crumb.message != message
+          Raven.breadcrumbs.record do |crumb|
+            crumb.level = Raven::Breadcrumbs::SentryLogger::LEVELS.fetch(severity, nil)
+            crumb.category = progname || 'logger'
+            crumb.message = message
+            crumb.type =
+              if severity >= 3
+                "error"
+              else
+                crumb.level
+              end
+          end
+        end
+      end
+
+      private
+
+      def ignored_logger?(progname)
+        progname == "sentry" ||
+          Raven.configuration.exclude_loggers.include?(progname)
+      end
+    end
+    module OldBreadcrumbsSentryLogger
+      def self.included(base)
+        base.class_eval do
+          include Raven::Breadcrumbs::SentryLogger
+          alias_method :add_without_raven, :add
+          alias_method :add, :add_with_raven
+        end
+      end
+
+      def add_with_raven(*args)
+        add_breadcrumb(*args)
+        add_without_raven(*args)
+      end
+    end
+  end
+end
+
+Raven.safely_prepend(
+  "Breadcrumbs::SentryLogger",
+  :from => Raven,
+  :to => ::Logger
+)