sentry-ruby 4.0.0 → 4.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 517bd830d9052aef4d3c9011f95e1d95f7740fae3bfdd746ece393766f637d84
-  data.tar.gz: 0b25ac7ffe3abf0c8b0a153681952bd36315fe406341add2e7e724632ca74d35
+  metadata.gz: 823d9f50e4335e2c08fa6a6afedac78e2c6243ea94a104db560870f0021c51c7
+  data.tar.gz: 385143cfb2e2218afb9fca2bebe07a26bca02565cd525b32a1abdde38bcd53e0
 SHA512:
-  metadata.gz: a717d3e5286400706e44f8bf1a17d6901e5fc7149efbff7f2f70758b1ac5c4f0f134f0d875a5543fa95777013aa1b0b0168f7c41fa149316bd9ced3a2f4ed48e
-  data.tar.gz: ad58cf9e97b482ff9b3107a677d1bc03d3429bba26052f908ce43b25635985f65525b3345afccd1488d5c94eabb0c6565b1ce16d003859da2e359f6ccbdd1eb9
+  metadata.gz: 143855b2a274c65d17b72a60adbe8ff72b2d71ad316796d7899803d3bf28f4645cba7afa1518aabae592b0093ba51f5f3c41d755ce9674cd65b3da3363a5bb72
+  data.tar.gz: a4b8fc9795553867da3b5d6c0eebd6f2d4198805c21f19a936149653ddac882b4db5cba46678f016982f3529314a95d5a23e9770173f53dbeb33ff7ba6a4b6c7

data/CHANGELOG.md

@@ -1,5 +1,83 @@
 # Changelog
 
+## 4.1.3
+
+- rm reference to old constant (from Rails v2.2) [#1184](https://github.com/getsentry/sentry-ruby/pull/1184)
+- Use copied env in events [#1186](https://github.com/getsentry/sentry-ruby/pull/1186)
+  - Fixes [#1183](https://github.com/getsentry/sentry-ruby/issues/1183)
+- Refactor RequestInterface [#1187](https://github.com/getsentry/sentry-ruby/pull/1187)
+- Supply event hint to async callback when possible [#1189](https://github.com/getsentry/sentry-ruby/pull/1189)
+  - Fixes [#1188](https://github.com/getsentry/sentry-ruby/issues/1188)
+- Refactor stacktrace parsing and increase test coverage [#1190](https://github.com/getsentry/sentry-ruby/pull/1190)
+- Sentry.send_event should also take a hint [#1192](https://github.com/getsentry/sentry-ruby/pull/1192)
+
+## 4.1.2
+
+- before_send callback shouldn't be applied to transaction events [#1167](https://github.com/getsentry/sentry-ruby/pull/1167)
+- Transaction improvements [#1170](https://github.com/getsentry/sentry-ruby/pull/1170)
+- Support Ruby 3 [#1172](https://github.com/getsentry/sentry-ruby/pull/1172)
+- Add Integrable module [#1177](https://github.com/getsentry/sentry-ruby/pull/1177)
+
+## 4.1.1
+
+- Fix NoMethodError when sending is not allowed [#1161](https://github.com/getsentry/sentry-ruby/pull/1161)
+- Add notification for users who still use deprecated middlewares [#1160](https://github.com/getsentry/sentry-ruby/pull/1160)
+- Improve top-level api safety [#1162](https://github.com/getsentry/sentry-ruby/pull/1162)
+
+## 4.1.0
+
+- Separate rack integration [#1138](https://github.com/getsentry/sentry-ruby/pull/1138)
+  - Fixes [#1136](https://github.com/getsentry/sentry-ruby/pull/1136)
+- Fix event sampling [#1144](https://github.com/getsentry/sentry-ruby/pull/1144)
+- Merge & rename 2 Rack middlewares [#1147](https://github.com/getsentry/sentry-ruby/pull/1147)
+  - Fixes [#1153](https://github.com/getsentry/sentry-ruby/pull/1153)
+  - Removed `Sentry::Rack::Tracing` middleware and renamed `Sentry::Rack::CaptureException` to `Sentry::Rack::CaptureExceptions`.
+- Deep-copy spans [#1148](https://github.com/getsentry/sentry-ruby/pull/1148)
+- Move span recorder related code from Span to Transaction [#1149](https://github.com/getsentry/sentry-ruby/pull/1149)
+- Check SDK initialization before running integrations [#1151](https://github.com/getsentry/sentry-ruby/pull/1151)
+  - Fixes [#1145](https://github.com/getsentry/sentry-ruby/pull/1145)
+- Refactor transport [#1154](https://github.com/getsentry/sentry-ruby/pull/1154)
+- Implement non-blocking event sending [#1155](https://github.com/getsentry/sentry-ruby/pull/1155)
+  - Added `background_worker_threads` configuration option.
+
+### Noticeable Changes
+
+#### Middleware Changes
+
+`Sentry::Rack::Tracing` is now removed. And `Sentry::Rack::CaptureException` has been renamed to `Sentry::Rack::CaptureExceptions`.
+
+#### Events Are Sent Asynchronously
+
+`sentry-ruby` now 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.
+3. The worker will have a number of threads. And the one of the idle threads will pick the job and call `Client#send_event`.
+    - If all the threads are busy, new jobs will be put into a queue, which has a limit of 30.
+    - If the queue size is exceeded, new events will be dropped.
+
+However, if you still prefer to use your own async approach, that's totally fine. If you have `config.async` set, the worker won't initialize a thread pool and won't be used either.
+
+This functionality also introduces a new `background_worker_threads` config option. It allows you to decide how many threads should the worker hold. By default, the value will be the number of the processors your machine has. For example, if your machine has 4 processors, the value would be 4.
+
+Of course, you can always override the value to fit your use cases, like
+
+```ruby
+config.background_worker_threads = 5 # the worker will have 5 threads for sending events
+```
+
+You can also disable this new non-blocking behaviour by giving a `0` value:
+
+```ruby
+config.background_worker_threads = 0 # all events will be sent synchronously
+```
+
+## 4.0.1
+
+- Add rake integration: [1137](https://github.com/getsentry/sentry-ruby/pull/1137)
+- Make Event's interfaces accessible: [1135](https://github.com/getsentry/sentry-ruby/pull/1135)
+- ActiveSupportLogger should only record events that has a started time: [1132](https://github.com/getsentry/sentry-ruby/pull/1132)
+
 ## 4.0.0
 
 - Only documents update for the official release and no API/feature changes.

data/Gemfile

@@ -5,10 +5,10 @@ gemspec
 
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
-gem "codecov"
+gem "codecov", "0.2.12"
 
 gem "pry"
-gem "rack"
+gem "rack" unless ENV["WITHOUT_RACK"] == "1"
 
 gem "benchmark-ips"
 gem "benchmark_driver"

data/README.md

@@ -28,6 +28,10 @@ The official Ruby-language client and integration layer for the [Sentry](https:/
 
 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.
 
+## Migrate From sentry-raven
+
+If you're using `sentry-raven`, we recommend you to migrate to this new SDK. You can find the benefits of migrating and how to do it in our [migration guide](https://docs.sentry.io/platforms/ruby/migration/).
+
 ## Getting Started
 
 ### Install
@@ -90,7 +94,7 @@ Sentry.init do |config|
 end
 ```
 
-To lean more about performance monitoring, please visit the [official documentation](https://docs.sentry.io/platforms/ruby/performance).
+To learn more about performance monitoring, please visit the [official documentation](https://docs.sentry.io/platforms/ruby/performance).
 
 ### Usage
 
@@ -111,8 +115,7 @@ Sentry.init do |config|
   end
 end
 
-use Sentry::Rack::Tracing # this needs to be placed first
-use Sentry::Rack::CaptureException
+use Sentry::Rack::CaptureExceptions
 ```
 
 Otherwise, Sentry you can always use the capture helpers manually
@@ -136,13 +139,13 @@ We also provide integrations with popular frameworks/libraries with the related
 
 You're all set - but there's a few more settings you may want to know about too!
 
-#### async
+#### Blocking v.s. Non-blocking
 
-When an error or message occurs, the notification is immediately sent to Sentry. Sentry can be configured to send asynchronously:
+**Before version 4.1.0**, `sentry-ruby` sends every event immediately. But it can be configured to send asynchronously:
 
 ```ruby
-config.async = lambda { |event|
-  Thread.new { Sentry.send_event(event) }
+config.async = lambda { |event, hint|
+  Thread.new { Sentry.send_event(event, hint) }
 }
 ```
 
@@ -151,17 +154,52 @@ Using a thread to send events will be adequate for truly parallel Ruby platforms
 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) }
+config.async = lambda { |event, hint| SentryJob.perform_later(event, hint) }
 
 class SentryJob < ActiveJob::Base
   queue_as :default
 
-  def perform(event)
-    Sentry.send_event(event)
+  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: 
+
+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.
+3. The worker will have a number of threads. And the one of the idle threads will pick the job and call `Client#send_event`.
+  - If all the threads are busy, new jobs will be put into a queue, which has a limit of 30.
+  - If the queue size is exceeded, new events will be dropped.
+
+However, if you still prefer to use your own async approach, that's totally fine. If you have `config.async` set, the worker won't initialize a thread pool and won't be used either.
+
+##### About `Sentry::BackgroundWorker`
+
+- The worker is built on top of the [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby) gem's [ThreadPoolExecutor](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ThreadPoolExecutor.html), which is also used by Rails ActiveJob's async adapter. This should minimize the risk of messing up client applications with our own thread pool implementaion.
+
+This functionality also introduces a new `background_worker_threads` config option. It allows you to decide how many threads should the worker hold. By default, the value will be the number of the processors your machine has. For example, if your machine has 4 processors, the value would be 4.
+
+Of course, you can always override the value to fit your use cases, like
+
+```ruby
+config.background_worker_threads = 5 # the worker will have 5 threads for sending events
+```
+
+You can also disable this new non-blocking behaviour by giving a `0` value:
+
+```ruby
+config.background_worker_threads = 0 # all events will be sent synchronously
+```
+
+If you want to send a particular event immediately, you can use event hints to do it:
+
+```ruby
+Sentry.capture_message("send me now!", hint: { background: false })
+```
+
 #### 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:
@@ -187,7 +225,6 @@ Or use top-level setters
 Sentry.set_user(id: 1, email: "test@example.com")
 Sentry.set_tags(tag_1: "foo", tag_2: "bar")
 Sentry.set_extras(order_number: 1234, tickets_count: 4)
-
 ```
 
 Or build up a temporary scope for local information:
@@ -218,3 +255,4 @@ Sentry.capture_exception(exception, tags: {foo: "bar"})
 * [Bug Tracker](https://github.com/getsentry/sentry-ruby/issues)
 * [Forum](https://forum.sentry.io/)
 - [Discord](https://discord.gg/ez5KZN7)
+

data/lib/sentry-ruby.rb

@@ -1,4 +1,5 @@
 require "forwardable"
+require "time"
 
 require "sentry/version"
 require "sentry/core_ext/object/deep_dup"
@@ -9,7 +10,17 @@ require "sentry/transaction_event"
 require "sentry/span"
 require "sentry/transaction"
 require "sentry/hub"
-require "sentry/rack"
+require "sentry/background_worker"
+
+def safely_require(lib)
+  begin
+    require lib
+  rescue LoadError
+  end
+end
+
+safely_require "sentry/rake"
+safely_require "sentry/rack"
 
 module Sentry
   class Error < StandardError
@@ -29,11 +40,25 @@ module Sentry
     Time.now.utc
   end
 
+  class << self
+    def integrations
+      @integrations ||= {}
+    end
+
+    def register_integration(name, version)
+      meta = { name: "sentry.ruby.#{name}", version: version }.freeze
+      integrations[name.to_s] = meta
+    end
+  end
+
   class << self
     extend Forwardable
 
+    def_delegators :get_current_client, :configuration, :send_event
     def_delegators :get_current_scope, :set_tags, :set_extras, :set_user
 
+    attr_accessor :background_worker
+
     def init(&block)
       config = Configuration.new
       yield(config)
@@ -42,6 +67,11 @@ module Sentry
       hub = Hub.new(client, scope)
       Thread.current[THREAD_LOCAL] = hub
       @main_hub = hub
+      @background_worker = Sentry::BackgroundWorker.new(config)
+    end
+
+    def initialized?
+      !!@main_hub
     end
 
     def get_main_hub
@@ -56,12 +86,8 @@ module Sentry
       get_current_scope.breadcrumbs.record(breadcrumb, &block)
     end
 
-    def configuration
-      get_current_client.configuration
-    end
-
     def get_current_client
-      get_current_hub.current_client
+      get_current_hub&.current_client
     end
 
     def get_current_hub
@@ -78,39 +104,35 @@ module Sentry
     end
 
     def get_current_scope
-      get_current_hub.current_scope
+      get_current_hub&.current_scope
     end
 
     def with_scope(&block)
-      get_current_hub.with_scope(&block)
+      get_current_hub&.with_scope(&block)
     end
 
     def configure_scope(&block)
-      get_current_hub.configure_scope(&block)
-    end
-
-    def send_event(event)
-      get_current_client.send_event(event)
+      get_current_hub&.configure_scope(&block)
     end
 
     def capture_event(event)
-      get_current_hub.capture_event(event)
+      get_current_hub&.capture_event(event)
     end
 
     def capture_exception(exception, **options, &block)
-      get_current_hub.capture_exception(exception, **options, &block)
+      get_current_hub&.capture_exception(exception, **options, &block)
     end
 
     def capture_message(message, **options, &block)
-      get_current_hub.capture_message(message, **options, &block)
+      get_current_hub&.capture_message(message, **options, &block)
     end
 
     def start_transaction(**options)
-      get_current_hub.start_transaction(**options)
+      get_current_hub&.start_transaction(**options)
     end
 
     def last_event_id
-      get_current_hub.last_event_id
+      get_current_hub&.last_event_id
     end
 
     def sys_command(command)

data/lib/sentry/background_worker.rb

@@ -0,0 +1,37 @@
+require "concurrent/executor/thread_pool_executor"
+require "concurrent/executor/immediate_executor"
+
+module Sentry
+  class BackgroundWorker
+    attr_reader :max_queue, :number_of_threads
+
+    def initialize(configuration)
+      @max_queue = 30
+      @number_of_threads = configuration.background_worker_threads
+
+      @executor =
+        if configuration.async
+          configuration.logger.debug(LOGGER_PROGNAME) { "config.async is set, BackgroundWorker is disabled" }
+          Concurrent::ImmediateExecutor.new
+        elsif @number_of_threads == 0
+          configuration.logger.debug(LOGGER_PROGNAME) { "config.background_worker_threads is set to 0, all events will be sent synchronously" }
+          Concurrent::ImmediateExecutor.new
+        else
+          configuration.logger.debug(LOGGER_PROGNAME) { "initialized a background worker with #{@number_of_threads} threads" }
+
+          Concurrent::ThreadPoolExecutor.new(
+            min_threads: 0,
+            max_threads: @number_of_threads,
+            max_queue: @max_queue,
+            fallback_policy: :discard
+          )
+        end
+    end
+
+    def perform(&block)
+      @executor.post do
+        block.call
+      end
+    end
+  end
+end

data/lib/sentry/backtrace.rb

@@ -82,16 +82,14 @@ module Sentry
 
     # holder for an Array of Backtrace::Line instances
     attr_reader :lines
-    attr_reader :configuration
 
-    def self.parse(backtrace, configuration:)
+    def self.parse(backtrace, project_root, app_dirs_pattern, &backtrace_cleanup_callback)
       ruby_lines = backtrace.is_a?(Array) ? backtrace : backtrace.split(/\n\s*/)
 
-      ruby_lines = configuration.backtrace_cleanup_callback.call(ruby_lines) if configuration&.backtrace_cleanup_callback
+      ruby_lines = backtrace_cleanup_callback.call(ruby_lines) if backtrace_cleanup_callback
 
       in_app_pattern ||= begin
-        project_root = configuration.project_root&.to_s
-        Regexp.new("^(#{project_root}/)?#{configuration.app_dirs_pattern || APP_DIRS_PATTERN}")
+        Regexp.new("^(#{project_root}/)?#{app_dirs_pattern || APP_DIRS_PATTERN}")
       end
 
       lines = ruby_lines.to_a.map do |unparsed_line|

data/lib/sentry/client.rb

@@ -20,35 +20,51 @@ module Sentry
       end
     end
 
-    def capture_event(event, scope, hint = nil)
+    def capture_event(event, scope, hint = {})
+      return unless configuration.sending_allowed?
+
       scope.apply_to_event(event, hint)
 
-      if configuration.async?
+      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
-          configuration.async.call(event.to_json_compatible)
+          event_hash = event.to_json_compatible
+
+          if async_block.arity == 2
+            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
       else
-        send_event(event, hint)
+        if hint.fetch(:background, true)
+          Sentry.background_worker.perform do
+            send_event(event, hint)
+          end
+        else
+          send_event(event, hint)
+        end
       end
 
       event
     end
 
-    def event_from_exception(exception)
+    def event_from_exception(exception, hint = {})
+      integration_meta = Sentry.integrations[hint[:integration]]
       return unless @configuration.exception_class_allowed?(exception)
 
-      Event.new(configuration: configuration).tap do |event|
+      Event.new(configuration: configuration, integration_meta: integration_meta).tap do |event|
         event.add_exception_interface(exception)
       end
     end
 
-    def event_from_message(message)
-      Event.new(configuration: configuration, message: message)
+    def event_from_message(message, hint = {})
+      integration_meta = Sentry.integrations[hint[:integration]]
+      Event.new(configuration: configuration, integration_meta: integration_meta, message: message)
     end
 
     def event_from_transaction(transaction)
@@ -64,9 +80,9 @@ module Sentry
     end
 
     def send_event(event, hint = nil)
-      return false unless configuration.sending_allowed?
+      event_type = event.is_a?(Event) ? event.type : event["type"]
+      event = configuration.before_send.call(event, hint) if configuration.before_send && event_type == "event"
 
-      event = configuration.before_send.call(event, hint) if configuration.before_send
       if event.nil?
         configuration.logger.info(LOGGER_PROGNAME) { "Discarded event because before_send returned nil" }
         return