sentry-ruby 0.2.0 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8f89cd1b0354cede1b5aab23b0b8652fed01bcebc3af7f0cb45a13d0f1d99ba
-  data.tar.gz: 38fa765f4acb958b8170a31017028a45cce342667bd8dee7dbff07c4e097ffc5
+  metadata.gz: 4cf12a695558927106256af0d85575b36bf2675b1ba87cf13baec2e40354055f
+  data.tar.gz: 418475b2abe315f62b642d38ced99b6c16b78ffa1fef7ef645203bf46dff72e9
 SHA512:
-  metadata.gz: be0a56af7629bf528be987f62bcb0a4fd12430d75b7541acc6d946314306ab4968c214eb7a533695dcd8aa3b3f434225f8dffceecee4bc39a8b5bd45e168e3d1
-  data.tar.gz: 383d6e88932c6ff3f6e79ca3c35c05d7a23151dd85db057e45dc8577f88673e8195659df3a0c01d71b1e67a61e7f1008eb36ab294047fdeea5cedf2a7d02f92c
+  metadata.gz: f4b5c90aad8d0249c29e901beb3569d4e0a89c53d35f8da459e97eb4134b989728c89ebc913b59f0db1b85c1903beedfcfb5968d5833d3fc2d5a6d209308212c
+  data.tar.gz: 86acbab302abb4d2cd66c9cc447486dcbebef127bbfbc03df69f2085057965166c3afc6a3f969d046b157255d1e88d54f85e7fac5581daa112e798eda04db2c7

data/CHANGELOG.md

@@ -1,5 +1,75 @@
 # Changelog
 
+## 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 [#1161](https://github.com/getsentry/sentry-ruby/pull/1161)
+
+## 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.
+
+## 0.3.0
+
+- Major API changes: [1123](https://github.com/getsentry/sentry-ruby/pull/1123)
+- Support event hint: [1122](https://github.com/getsentry/sentry-ruby/pull/1122)
+- Add request-id tag to events: [1120](https://github.com/getsentry/sentry-ruby/pull/1120) (by @tvec)
+
 ## 0.2.0
 
 - Multiple fixes and refactorings

data/Gemfile

@@ -8,7 +8,7 @@ gem "rspec", "~> 3.0"
 gem "codecov"
 
 gem "pry"
-gem "rack"
+gem "rack" unless ENV["WITHOUT_RACK"] == "1"
 
 gem "benchmark-ips"
 gem "benchmark_driver"

data/README.md

@@ -7,6 +7,8 @@
 
 # sentry-ruby, the Ruby Client for Sentry
 
+**The old `sentry-raven` client has entered maintenance mode and was moved to [here](https://github.com/getsentry/sentry-ruby/tree/master/sentry-raven).**
+
 ---
 
 
@@ -17,7 +19,7 @@
 [![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=sentry-ruby&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=sentry-ruby&package-manager=bundler&version-scheme=semver)
 
 
-[Documentation](https://docs.sentry.io/clients/ruby/) | [Bug Tracker](https://github.com/getsentry/sentry-ruby/issues) | [Forum](https://forum.sentry.io/) | IRC: irc.freenode.net, #sentry
+[Documentation](https://docs.sentry.io/platforms/ruby/) | [Bug Tracker](https://github.com/getsentry/sentry-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.
 
@@ -26,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
@@ -70,17 +76,46 @@ Sentry.init do |config|
 end
 ```
 
+### Performance Monitoring
+
+You can activate performance monitoring by enabling traces sampling:
+
+```ruby
+Sentry.init do |config|
+  # set a uniform sample rate between 0.0 and 1.0
+  config.traces_sample_rate = 0.2
+
+  # or control sampling dynamically
+  config.traces_sampler = lambda do |sampling_context|
+    # sampling_context[:transaction_context] contains the information about the transaction
+    # sampling_context[:parent_sampled] contains the transaction's parent's sample decision
+    true # return value can be a boolean or a float between 0.0 and 1.0
+  end
+end
+```
+
+To lean more about performance monitoring, please visit the [official documentation](https://docs.sentry.io/platforms/ruby/performance).
+
 ### Usage
 
 `sentry-ruby` has a default integration with `Rack`, so you only need to use the middleware in your application like:
 
-```
-require 'rack'
+```ruby
 require 'sentry-ruby'
 
-use Sentry::Rack::CaptureException
+Sentry.init do |config|
+  config.dsn = 'https://examplePublicKey@o0.ingest.sentry.io/0'
+
+  # To activate performance monitoring, set one of these options.
+  # We recommend adjusting the value in production:
+  config.traces_sample_rate = 0.5
+  # or
+  config.traces_sampler = lambda do |context|
+    true
+  end
+end
 
-run theapp
+use Sentry::Rack::CaptureExceptions
 ```
 
 Otherwise, Sentry you can always use the capture helpers manually
@@ -104,9 +139,9 @@ 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|
@@ -130,6 +165,41 @@ class SentryJob < ActiveJob::Base
 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:
@@ -148,6 +218,15 @@ end
 Sentry.capture_exception(exception) # the event will carry all those information now
 ```
 
+Or use top-level setters
+
+
+```ruby
+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:
 
 ```ruby
@@ -172,7 +251,8 @@ Sentry.capture_exception(exception, tags: {foo: "bar"})
 
 ## More Information
 
-* [Documentation](https://docs.sentry.io/clients/ruby/)
+* [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

@@ -1,3 +1,6 @@
+require "forwardable"
+require "time"
+
 require "sentry/version"
 require "sentry/core_ext/object/deep_dup"
 require "sentry/configuration"
@@ -7,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
@@ -28,6 +41,12 @@ module Sentry
   end
 
   class << self
+    extend Forwardable
+
+    def_delegators :get_current_scope, :set_tags, :set_extras, :set_user
+
+    attr_accessor :background_worker
+
     def init(&block)
       config = Configuration.new
       yield(config)
@@ -36,6 +55,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
@@ -46,8 +70,8 @@ module Sentry
       configuration.logger
     end
 
-    def breadcrumbs
-      get_current_scope.breadcrumbs
+    def add_breadcrumb(breadcrumb, &block)
+      get_current_scope.breadcrumbs.record(breadcrumb, &block)
     end
 
     def configuration
@@ -55,7 +79,7 @@ module Sentry
     end
 
     def get_current_client
-      get_current_hub.current_client
+      get_current_hub&.current_client
     end
 
     def get_current_hub
@@ -72,15 +96,15 @@ 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)
+      get_current_hub&.configure_scope(&block)
     end
 
     def send_event(event)
@@ -88,23 +112,23 @@ module Sentry
     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/breadcrumb.rb

@@ -2,13 +2,13 @@ module Sentry
   class Breadcrumb
     attr_accessor :category, :data, :message, :level, :timestamp, :type
 
-    def initialize
-      @category = nil
-      @data = {}
-      @level = nil
-      @message = nil
-      @timestamp = Sentry.utc_now.to_i
-      @type = nil
+    def initialize(category: nil, data: nil, message: nil, timestamp: nil, level: nil, type: nil)
+      @category = category
+      @data = data || {}
+      @level = level
+      @message = message
+      @timestamp = timestamp || Sentry.utc_now.to_i
+      @type = type
     end
 
     def to_hash

data/lib/sentry/breadcrumb/sentry_logger.rb

@@ -58,17 +58,15 @@ module Sentry
         last_crumb = current_breadcrumbs.peek
         # try to avoid dupes from logger broadcasts
         if last_crumb.nil? || last_crumb.message != message
-          current_breadcrumbs.record do |crumb|
-            crumb.level = Sentry::Breadcrumb::SentryLogger::LEVELS.fetch(severity, nil)
-            crumb.category = category
-            crumb.message = message
-            crumb.type =
-              if severity >= 3
-                "error"
-              else
-                crumb.level
-              end
-          end
+          level = Sentry::Breadcrumb::SentryLogger::LEVELS.fetch(severity, nil)
+          crumb = Sentry::Breadcrumb.new(
+            level: level,
+            category: category,
+            message: message,
+            type: severity >= 3 ? "error" : level
+          )
+
+          Sentry.add_breadcrumb(crumb)
         end
       end
 
@@ -80,7 +78,7 @@ module Sentry
       end
 
       def current_breadcrumbs
-        Sentry.breadcrumbs
+        Sentry.get_current_scope.breadcrumbs
       end
     end
   end