sentry-ruby-core 4.1.6 → 4.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 584f6d4758f8c7756443aa2f242e0c8c8d8f34b49089863714ae52b76b18c4af
-  data.tar.gz: 4a0c8fc92d430a1b8b0726d2cee9c96d4ddc918f99702081c93b5af9b75a53a3
+  metadata.gz: 8a2e4ce39cece4f17353a14a3984cfaf57b9fc1f9288915a36f9c5ae56e719cd
+  data.tar.gz: 77ebe61492554532ce811320fbae436735c82ac3a0586176ee53b040211d6b81
 SHA512:
-  metadata.gz: d1ebaf29b9c6712e7f23ef91cad67e0ddb50fcd2849b45e1fba31e7e7e58acdacbf1f64cb6abb50c1269aa4dedf0e8dd1bd5df7cc8ea83a0be223c2124ab2652
-  data.tar.gz: 3f2e9ff72da83a8644de0e2ca6cc85b3febaa7a3bd9b84abf10e91047207debfcf83e446ee63216dbfc097947b874cd605ffa89947e162331f33f103b599ae36
+  metadata.gz: 34504541c4743476d4360e7b452e8a7a4b9a3bd66d80878a768d839d8fe00e5294c2e385d62d50527ddf957368a660c8276342abf72a82079583c0a33385e29d
+  data.tar.gz: d050d0b1bf6346553db6cc02e84b144908d877bd1883243526b0366e21eb97e924cf2f23c2c8ad10383785a90e05337615041ac6d9c87c36694d6077e3f6481d

data/CHANGELOG.md

@@ -1,5 +1,92 @@
 # Changelog
 
+## 4.3.1
+
+- Add Sentry.set_context helper [#1337](https://github.com/getsentry/sentry-ruby/pull/1337)
+- Fix handle the case where the logger messages is not of String type [#1341](https://github.com/getsentry/sentry-ruby/pull/1341)
+- Don't report Sentry::ExternalError to Sentry [#1353](https://github.com/getsentry/sentry-ruby/pull/1353)
+- Sentry.add_breadcrumb should call Hub#add_breadcrumb [#1358](https://github.com/getsentry/sentry-ruby/pull/1358)
+  - Fixes [#1357](https://github.com/getsentry/sentry-ruby/issues/1357)
+
+## 4.3.0
+
+### Features
+
+- Allow configuring BreadcrumbBuffer's size limit [#1310](https://github.com/getsentry/sentry-ruby/pull/1310)
+
+```ruby
+# the SDK will only store 10 breadcrumbs (default is 100)
+config.max_breadcrumbs = 10
+```
+
+- Compress event payload by default [#1314](https://github.com/getsentry/sentry-ruby/pull/1314)
+
+### Refatorings
+
+- Refactor interface construction [#1296](https://github.com/getsentry/sentry-ruby/pull/1296)
+- Refactor tracing implementation [#1309](https://github.com/getsentry/sentry-ruby/pull/1309)
+
+### Bug Fixes
+- Improve SDK's error handling [#1298](https://github.com/getsentry/sentry-ruby/pull/1298)
+  - Fixes [#1246](https://github.com/getsentry/sentry-ruby/issues/1246) and [#1289](https://github.com/getsentry/sentry-ruby/issues/1289)
+  - Please read [#1290](https://github.com/getsentry/sentry-ruby/issues/1290) to see the full specification
+- Treat query string as pii too [#1302](https://github.com/getsentry/sentry-ruby/pull/1302)
+  - Fixes [#1301](https://github.com/getsentry/sentry-ruby/issues/1301)
+- Ignore sentry-trace when tracing is not enabled [#1308](https://github.com/getsentry/sentry-ruby/pull/1308)
+  - Fixes [#1307](https://github.com/getsentry/sentry-ruby/issues/1307)
+- Return nil from logger methods instead of breadcrumb buffer [#1299](https://github.com/getsentry/sentry-ruby/pull/1299)
+- Exceptions with nil message shouldn't cause issues [#1327](https://github.com/getsentry/sentry-ruby/pull/1327)
+  - Fixes [#1323](https://github.com/getsentry/sentry-ruby/issues/1323)
+- Fix sampling decision with sentry-trace and add more tests [#1326](https://github.com/getsentry/sentry-ruby/pull/1326)
+
+## 4.2.2
+
+- Add thread_id to Exception interface [#1291](https://github.com/getsentry/sentry-ruby/pull/1291)
+- always convert trusted proxies to string [#1288](https://github.com/getsentry/sentry-ruby/pull/1288)
+  - fixes [#1274](https://github.com/getsentry/sentry-ruby/issues/1274)
+
+## 4.2.1
+
+### Bug Fixes
+
+- Ignore invalid values for sentry-trace header that don't match the required format [#1265](https://github.com/getsentry/sentry-ruby/pull/1265)
+- Transaction created by `.from_sentry_trace` should inherit sampling decision [#1269](https://github.com/getsentry/sentry-ruby/pull/1269)
+- Transaction's sample rate should accept any numeric value [#1278](https://github.com/getsentry/sentry-ruby/pull/1278)
+
+## 4.2.0
+
+### Features
+
+- Add configuration option for trusted proxies [#1126](https://github.com/getsentry/sentry-ruby/pull/1126)
+
+```ruby
+config.trusted_proxies = ["2.2.2.2"] # this ip address will be skipped when computing users' ip addresses
+```
+
+- Add ThreadsInterface [#1178](https://github.com/getsentry/sentry-ruby/pull/1178)
+
+<img width="1029" alt="an exception event that has the new threads interface" src="https://user-images.githubusercontent.com/5079556/103459223-98b64c00-4d48-11eb-9ebb-ee58f15e647e.png">
+
+- Support `config.before_breadcrumb` [#1253](https://github.com/getsentry/sentry-ruby/pull/1253)
+
+```ruby
+# this will be called before every breadcrumb is added to the breadcrumb buffer
+# you can use it to
+# - remove the data you don't want to send
+# - add additional info to the data
+config.before_breadcrumb = lambda do |breadcrumb, hint|
+  breadcrumb.message = "foo"
+  breadcrumb
+end
+```
+
+- Add ability to have many post initialization callbacks [#1261](https://github.com/getsentry/sentry-ruby/pull/1261)
+
+### Bug Fixes
+
+- Inspect exception cause by default & don't exclude ActiveJob::DeserializationError [#1180](https://github.com/getsentry/sentry-ruby/pull/1180)
+  - Fixes [#1071](https://github.com/getsentry/sentry-ruby/issues/1071)
+
 ## 4.1.6
 
 - Don't detect project root for Rails apps [#1243](https://github.com/getsentry/sentry-ruby/pull/1243)
@@ -140,4 +227,3 @@ Fix require reference
 ## 0.1.0
 
 First version
-

data/Gemfile

@@ -8,6 +8,7 @@ gem "i18n", "<= 1.8.7"
 
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
+gem "rspec-retry"
 gem "codecov", "0.2.12"
 
 gem "pry"

data/README.md

@@ -2,10 +2,14 @@
   <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>
+  <br />
 </p>
 
-# sentry-ruby, the Ruby Client for Sentry
+_Bad software is everywhere, and we're tired of it. Sentry is on a mission to help developers write better software faster, so we can get back to enjoying technology. If you want to join us [<kbd>**Check out our open positions**</kbd>](https://sentry.io/careers/)_
+
+Sentry SDK for Ruby
+===========
+
 
 **The old `sentry-raven` client has entered maintenance mode and was moved to [here](https://github.com/getsentry/sentry-ruby/tree/master/sentry-raven).**
 
@@ -26,7 +30,7 @@ The official Ruby-language client and integration layer for the [Sentry](https:/
 
 ## Requirements
 
-We test on Ruby 2.4, 2.5, 2.6 and 2.7 at the latest patchlevel/teeny version. We also support JRuby 9.0.
+We test on Ruby 2.4, 2.5, 2.6, 2.7, and 3.0 at the latest patchlevel/teeny version. We also support JRuby 9.0.
 
 If you use self-hosted Sentry, please also make sure its version is above `20.6.0`.
 
@@ -47,6 +51,7 @@ and depends on the integrations you want to have, you might also want to install
 ```ruby
 gem "sentry-rails"
 gem "sentry-sidekiq"
+gem "sentry-delayed_job"
 # and mores to come in the future!
 ```
 
@@ -67,7 +72,7 @@ end
 
 ### Sentry doesn't report some kinds of data by default
 
-**Sentry ignores some exceptions by default** - most of these are related to 404s parameter parsing errors. [For a complete list, see the `IGNORE_DEFAULT` constant](https://github.com/getsentry/sentry-ruby/blob/master/sentry-ruby/lib/sentry/configuration.rb#L118) and the integration gems' `IGNORE_DEFAULT`, like [`sentry-rails`'s](https://github.com/getsentry/sentry-ruby/blob/master/sentry-rails/lib/sentry/rails/configuration.rb#L12)
+**Sentry ignores some exceptions by default** - most of these are related to 404s parameter parsing errors. [For a complete list, see the `IGNORE_DEFAULT` constant](https://github.com/getsentry/sentry-ruby/blob/master/sentry-ruby/lib/sentry/configuration.rb#L151) and the integration gems' `IGNORE_DEFAULT`, like [`sentry-rails`'s](https://github.com/getsentry/sentry-ruby/blob/master/sentry-rails/lib/sentry/rails/configuration.rb#L12)
 
 Sentry doesn't send personally identifiable information (pii) by default, such as request body, user ip or cookies. If you want those information to be sent, you can use the `send_default_pii` config option:
 
@@ -136,6 +141,7 @@ We also provide integrations with popular frameworks/libraries with the related
 
 - [sentry-rails](https://github.com/getsentry/sentry-ruby/tree/master/sentry-rails)
 - [sentry-sidekiq](https://github.com/getsentry/sentry-ruby/tree/master/sentry-sidekiq)
+- [sentry-delayed_job](https://github.com/getsentry/sentry-ruby/tree/master/sentry-delayed_job)
 
 ### More configuration
 
@@ -143,32 +149,7 @@ You're all set - but there's a few more settings you may want to know about too!
 
 #### Blocking v.s. Non-blocking
 
-**Before version 4.1.0**, `sentry-ruby` sends every event immediately. But it can be configured to send asynchronously:
-
-```ruby
-config.async = lambda { |event, hint|
-  Thread.new { Sentry.send_event(event, hint) }
-}
-```
-
-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, Sentry 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, hint| SentryJob.perform_later(event, hint) }
-
-class SentryJob < ActiveJob::Base
-  queue_as :default
-
-  def perform(event, hint)
-    Sentry.send_event(event, hint)
-  end
-end
-```
-
-
-**After version 4.1.0**, `sentry-ruby` sends events asynchronously by default. The functionality works like this: 
+`sentry-ruby` sends events asynchronously by default. The functionality works like this:
 
 1. When the SDK is initialized, a `Sentry::BackgroundWorker` will be initialized too.
 2. When an event is passed to `Client#capture_event`, instead of sending it directly with `Client#send_event`, we'll let the worker do it.
@@ -202,6 +183,21 @@ If you want to send a particular event immediately, you can use event hints to d
 Sentry.capture_message("send me now!", hint: { background: false })
 ```
 
+##### `config.async`
+
+You can also use `config.async` to send events with you own worker:
+
+```ruby
+config.async = lambda { |event, hint| SentryJob.perform_later(event, hint) }
+```
+
+And if you use `sentry-rails`, you can directly use the job we defined for you:
+
+```ruby
+config.async = lambda { |event, hint| Sentry::SendEventJob.perform_later(event, hint) }
+```
+
+
 #### Contexts
 
 In sentry-ruby, every event will inherit their contextual data from the current scope. So you can enrich the event's data by configuring the current scope like:
@@ -253,8 +249,8 @@ Sentry.capture_exception(exception, tags: {foo: "bar"})
 
 ## More Information
 
-* [Documentation](https://docs.sentry.io/platforms/ruby/)
-* [Bug Tracker](https://github.com/getsentry/sentry-ruby/issues)
-* [Forum](https://forum.sentry.io/)
+- [Documentation](https://docs.sentry.io/platforms/ruby/)
+- [Bug Tracker](https://github.com/getsentry/sentry-ruby/issues)
+- [Forum](https://forum.sentry.io/)
 - [Discord](https://discord.gg/ez5KZN7)
 

data/lib/sentry-ruby.rb

@@ -3,6 +3,7 @@ require "forwardable"
 require "time"
 
 require "sentry/version"
+require "sentry/exceptions"
 require "sentry/core_ext/object/deep_dup"
 require "sentry/utils/argument_checking_helper"
 require "sentry/configuration"
@@ -26,9 +27,6 @@ require "sentry/background_worker"
 end
 
 module Sentry
-  class Error < StandardError
-  end
-
   META = { "name" => "sentry.ruby", "version" => Sentry::VERSION }.freeze
 
   LOGGER_PROGNAME = "sentry".freeze
@@ -60,7 +58,7 @@ module Sentry
     extend Forwardable
 
     def_delegators :get_current_client, :configuration, :send_event
-    def_delegators :get_current_scope, :set_tags, :set_extras, :set_user
+    def_delegators :get_current_scope, :set_tags, :set_extras, :set_user, :set_context
 
     attr_accessor :background_worker
 
@@ -68,7 +66,7 @@ module Sentry
       config = Configuration.new
       yield(config) if block_given?
       client = Client.new(config)
-      scope = Scope.new
+      scope = Scope.new(max_breadcrumbs: config.max_breadcrumbs)
       hub = Hub.new(client, scope)
       Thread.current[THREAD_LOCAL] = hub
       @main_hub = hub
@@ -82,7 +80,7 @@ module Sentry
 
     # Takes an instance of Sentry::Breadcrumb and stores it to the current active scope.
     def add_breadcrumb(breadcrumb)
-      get_current_scope.breadcrumbs.record(breadcrumb)
+      get_current_hub&.add_breadcrumb(breadcrumb)
     end
 
     # Returns the current active hub.

data/lib/sentry/background_worker.rb

@@ -1,5 +1,6 @@
 require "concurrent/executor/thread_pool_executor"
 require "concurrent/executor/immediate_executor"
+require "concurrent/configuration"
 
 module Sentry
   class BackgroundWorker

data/lib/sentry/breadcrumb/sentry_logger.rb

@@ -14,6 +14,7 @@ module Sentry
       def add(*args, &block)
         super
         add_breadcrumb(*args, &block)
+        nil
       end
 
       def add_breadcrumb(severity, message = nil, progname = nil)
@@ -49,7 +50,7 @@ module Sentry
           end
         end
 
-        return if ignored_logger?(progname) || message.empty?
+        return if ignored_logger?(progname) || message == ""
 
         # some loggers will add leading/trailing space as they (incorrectly, mind you)
         # think of logging as a shortcut to std{out,err}

data/lib/sentry/breadcrumb_buffer.rb

@@ -2,12 +2,13 @@ require "sentry/breadcrumb"
 
 module Sentry
   class BreadcrumbBuffer
+    DEFAULT_SIZE = 100
     include Enumerable
 
     attr_accessor :buffer
 
-    def initialize(size = 100)
-      @buffer = Array.new(size)
+    def initialize(size = nil)
+      @buffer = Array.new(size || DEFAULT_SIZE)
     end
 
     def record(crumb)

data/lib/sentry/client.rb

@@ -2,10 +2,11 @@ require "sentry/transport"
 
 module Sentry
   class Client
-    attr_reader :transport, :configuration
+    attr_reader :transport, :configuration, :logger
 
     def initialize(configuration)
       @configuration = configuration
+      @logger = configuration.logger
 
       if transport_class = configuration.transport.transport_class
         @transport = transport_class.new(configuration)
@@ -26,32 +27,17 @@ module Sentry
       scope.apply_to_event(event, hint)
 
       if async_block = configuration.async
-        begin
-          # We have to convert to a JSON-like hash, because background job
-          # processors (esp ActiveJob) may not like weird types in the event hash
-          event_hash = event.to_json_compatible
-
-          if async_block.arity == 2
-            hint = JSON.parse(JSON.generate(hint))
-            async_block.call(event_hash, hint)
-          else
-            async_block.call(event_hash)
-          end
-        rescue => e
-          configuration.logger.error(LOGGER_PROGNAME) { "async event sending failed: #{e.message}" }
-          send_event(event, hint)
-        end
+        dispatch_async_event(async_block, event, hint)
+      elsif hint.fetch(:background, true)
+        dispatch_background_event(event, hint)
       else
-        if hint.fetch(:background, true)
-          Sentry.background_worker.perform do
-            send_event(event, hint)
-          end
-        else
-          send_event(event, hint)
-        end
+        send_event(event, hint)
       end
 
       event
+    rescue => e
+      logger.error(LOGGER_PROGNAME) { "Event capturing failed: #{e.message}" }
+      nil
     end
 
     def event_from_exception(exception, hint = {})
@@ -60,12 +46,15 @@ module Sentry
 
       Event.new(configuration: configuration, integration_meta: integration_meta).tap do |event|
         event.add_exception_interface(exception)
+        event.add_threads_interface(crashed: true)
       end
     end
 
     def event_from_message(message, hint = {})
       integration_meta = Sentry.integrations[hint[:integration]]
-      Event.new(configuration: configuration, integration_meta: integration_meta, message: message)
+      event = Event.new(configuration: configuration, integration_meta: integration_meta, message: message)
+      event.add_threads_interface(backtrace: caller)
+      event
     end
 
     def event_from_transaction(transaction)
@@ -82,16 +71,49 @@ module Sentry
 
     def send_event(event, hint = nil)
       event_type = event.is_a?(Event) ? event.type : event["type"]
-      event = configuration.before_send.call(event, hint) if configuration.before_send && event_type == "event"
 
-      if event.nil?
-        configuration.logger.info(LOGGER_PROGNAME) { "Discarded event because before_send returned nil" }
-        return
+      if event_type == "event" && configuration.before_send
+        event = configuration.before_send.call(event, hint)
+
+        if event.nil?
+          logger.info(LOGGER_PROGNAME) { "Discarded event because before_send returned nil" }
+          return
+        end
       end
 
       transport.send_event(event)
 
       event
+    rescue => e
+      logger.error(LOGGER_PROGNAME) { "#{event_type.capitalize} sending failed: #{e.message}" }
+      logger.error(LOGGER_PROGNAME) { "Unreported #{event_type.capitalize}: #{Event.get_log_message(event.to_hash)}" }
+      raise
+    end
+
+    private
+
+    def dispatch_background_event(event, hint)
+      Sentry.background_worker.perform do
+        send_event(event, hint)
+      end
     end
+
+    def dispatch_async_event(async_block, event, hint)
+      # We have to convert to a JSON-like hash, because background job
+      # processors (esp ActiveJob) may not like weird types in the event hash
+      event_hash = event.to_json_compatible
+
+      if async_block.arity == 2
+        hint = JSON.parse(JSON.generate(hint))
+        async_block.call(event_hash, hint)
+      else
+        async_block.call(event_hash)
+      end
+    rescue => e
+      event_type = event_hash["type"]
+      logger.error(LOGGER_PROGNAME) { "Async #{event_type} sending failed: #{e.message}" }
+      send_event(event, hint)
+    end
+
   end
 end

data/lib/sentry/configuration.rb

@@ -4,6 +4,7 @@ require "sentry/utils/exception_cause_chain"
 require "sentry/dsn"
 require "sentry/transport/configuration"
 require "sentry/linecache"
+require "sentry/interfaces/stacktrace_builder"
 
 module Sentry
   class Configuration
@@ -38,10 +39,19 @@ module Sentry
     #
     attr_accessor :backtrace_cleanup_callback
 
+    # Optional Proc, called before adding the breadcrumb to the current scope
+    # E.g.: lambda { |breadcrumb, hint| breadcrumb }
+    # E.g.: lambda { |breadcrumb, hint| nil }
+    # E.g.: lambda { |breadcrumb, hint|
+    #   breadcrumb.message = 'a'
+    #   breadcrumb
+    # }
+    attr_reader :before_breadcrumb
+
     # Optional Proc, called before sending an event to the server/
-    # E.g.: lambda { |event| event }
-    # E.g.: lambda { |event| nil }
-    # E.g.: lambda { |event|
+    # E.g.: lambda { |event, hint| event }
+    # E.g.: lambda { |event, hint| nil }
+    # E.g.: lambda { |event, hint|
     #   event[:message] = 'a'
     #   event
     # }
@@ -52,6 +62,9 @@ module Sentry
     # - :active_support_logger
     attr_reader :breadcrumbs_logger
 
+    # Max number of breadcrumbs a breadcrumb buffer can hold
+    attr_accessor :max_breadcrumbs
+
     # Number of lines of code context to capture, or nil for none
     attr_accessor :context_lines
 
@@ -109,6 +122,9 @@ module Sentry
     # will not be sent to Sentry.
     attr_accessor :send_default_pii
 
+    # IP ranges for trusted proxies that will be skipped when calculating IP address.
+    attr_accessor :trusted_proxies
+
     attr_accessor :server_name
 
     # Return a Transport::Configuration object for transport-related configurations.
@@ -153,15 +169,20 @@ module Sentry
 
     AVAILABLE_BREADCRUMBS_LOGGERS = [:sentry_logger, :active_support_logger].freeze
 
+    # Post initialization callbacks are called at the end of initialization process
+    # allowing extending the configuration of sentry-ruby by multiple extensions
+    @@post_initialization_callbacks = []
+
     def initialize
       self.background_worker_threads = Concurrent.processor_count
+      self.max_breadcrumbs = BreadcrumbBuffer::DEFAULT_SIZE
       self.breadcrumbs_logger = []
       self.context_lines = 3
       self.environment = environment_from_env
       self.enabled_environments = []
       self.exclude_loggers = []
       self.excluded_exceptions = IGNORE_DEFAULT.dup
-      self.inspect_exception_causes_for_exclusion = false
+      self.inspect_exception_causes_for_exclusion = true
       self.linecache = ::Sentry::LineCache.new
       self.logger = ::Sentry::Logger.new(STDOUT)
       self.project_root = Dir.pwd
@@ -170,6 +191,7 @@ module Sentry
       self.sample_rate = 1.0
       self.send_modules = true
       self.send_default_pii = false
+      self.trusted_proxies = []
       self.dsn = ENV['SENTRY_DSN']
       self.server_name = server_name_from_env
 
@@ -178,7 +200,8 @@ module Sentry
 
       @transport = Transport::Configuration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
-      post_initialization_callback
+
+      run_post_initialization_callbacks
     end
 
     def dsn=(value)
@@ -223,6 +246,14 @@ module Sentry
       @before_send = value
     end
 
+    def before_breadcrumb=(value)
+      unless value.nil? || value.respond_to?(:call)
+        raise ArgumentError, "before_breadcrumb must be callable (or nil to disable)"
+      end
+
+      @before_breadcrumb = value
+    end
+
     def environment=(environment)
       @environment = environment.to_s
     end
@@ -265,6 +296,16 @@ module Sentry
       !!((@traces_sample_rate && @traces_sample_rate > 0.0) || @traces_sampler)
     end
 
+    def stacktrace_builder
+      @stacktrace_builder ||= StacktraceBuilder.new(
+        project_root: @project_root.to_s,
+        app_dirs_pattern: @app_dirs_pattern,
+        linecache: @linecache,
+        context_lines: @context_lines,
+        backtrace_cleanup_callback: @backtrace_cleanup_callback
+      )
+    end
+
     private
 
     def detect_release
@@ -382,7 +423,21 @@ module Sentry
       end
     end
 
-    # allow extensions to extend the Configuration class
-    def post_initialization_callback; end
+    def run_post_initialization_callbacks
+      self.class.post_initialization_callbacks.each do |hook|
+        instance_eval(&hook)
+      end
+    end
+
+    # allow extensions to add their hooks to the Configuration class
+    def self.add_post_initialization_callback(&block)
+      self.post_initialization_callbacks << block
+    end
+
+    protected
+
+    def self.post_initialization_callbacks
+      @@post_initialization_callbacks
+    end
   end
 end