sentry-ruby 0.1.3 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b16bf44cdc5e7689122b6727e08f680c7cfb98be5bebba286fdfc8a9e9f2cb81
-  data.tar.gz: 55a4793366f3e1a1dba8db0bec236d5c7bed5b2f1cb838244faaf629f4a1edb4
+  metadata.gz: 517c3e0bc0ab170dbd508034bf74b3a9ba62a1a32f13a992ba84d65f81249e01
+  data.tar.gz: 8a86690e05e1695f15e2da33002ecd52b4596ef8dbd2e9c0a7461f94a8868906
 SHA512:
-  metadata.gz: 99da84ece5e4ee5c459fa93284edfa2154c4bb0409278bb763ff98c2ceeddb57821f173c8fe3d1cf3a1cfa48d9d168e676f8cc666117604d7b367c5f8f352f4c
-  data.tar.gz: aed7ff1ecf47362e8f8be166cc173b0b5ef62dacd17dc21d7d10e6c8240193024b934d1b510cbb72ccd39837c24b79421b568577ad3e3921adbb4b050395a976
+  metadata.gz: 3cc45e503a6ed19a5cc507ab0791087e432b612581498e84403fd806e0d9538ff02f57c2fbb64294ba9895514218bca05610f637a8708a752e6eaf42fa61bfaa
+  data.tar.gz: 9eb027f449b6bdee43316e3b78364d1680d56442b5f34ec82b49059a9f28418a51448e24e45318efb022e526b62e067e410a8e78eb3b67678f1e18ce46866004

data/CHANGELOG.md

@@ -1,5 +1,74 @@
 # Changelog
 
+## 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
+- Tracing support
+
 ## 0.1.3
 
 Fix require reference

data/Gemfile

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

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/Rakefile

@@ -1,6 +1,8 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new(:spec).tap do |task|
+  task.rspec_opts = "--order rand"
+end
 
 task :default => :spec

data/lib/sentry-ruby.rb

@@ -1,10 +1,26 @@
+require "forwardable"
+require "time"
+
 require "sentry/version"
 require "sentry/core_ext/object/deep_dup"
 require "sentry/configuration"
 require "sentry/logger"
 require "sentry/event"
+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
@@ -20,7 +36,17 @@ module Sentry
     META
   end
 
+  def self.utc_now
+    Time.now.utc
+  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)
@@ -29,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
@@ -39,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
@@ -92,6 +123,10 @@ module Sentry
       get_current_hub.capture_message(message, **options, &block)
     end
 
+    def start_transaction(**options)
+      get_current_hub.start_transaction(**options)
+    end
+
     def last_event_id
       get_current_hub.last_event_id
     end

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/benchmarks/benchmark_transport.rb

@@ -0,0 +1,14 @@
+module Sentry
+  class BenchmarkTransport < Transport
+    attr_accessor :events
+
+    def initialize(*)
+      super
+      @events = []
+    end
+
+    def send_event(event)
+      @events << encode(event.to_hash)
+    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 = Time.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,21 +78,7 @@ module Sentry
       end
 
       def current_breadcrumbs
-        Sentry.breadcrumbs
-      end
-    end
-    module OldBreadcrumbsSentryLogger
-      def self.included(base)
-        base.class_eval do
-          include Sentry::Breadcrumbs::SentryLogger
-          alias_method :add_without_sentry, :add
-          alias_method :add, :add_with_sentry
-        end
-      end
-
-      def add_with_sentry(*args)
-        add_breadcrumb(*args)
-        add_without_sentry(*args)
+        Sentry.get_current_scope.breadcrumbs
       end
     end
   end