sentry-ruby 4.0.1 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 732989200a2cbf0a935c386cf84037d655332953ea2fef828099fbf68b756ab9
-  data.tar.gz: 4aecc66958496eede273d4cc4b2e3861e0ce7eb3cf769912a4a6675efeba693e
+  metadata.gz: 517c3e0bc0ab170dbd508034bf74b3a9ba62a1a32f13a992ba84d65f81249e01
+  data.tar.gz: 8a86690e05e1695f15e2da33002ecd52b4596ef8dbd2e9c0a7461f94a8868906
 SHA512:
-  metadata.gz: 798be41100ec3c8eb09039f9432df02fd0de323427fd0d8bf6d9ced8f7b39d420e972c6006bcb4490002e32f03acfad2311b8ddab826c6927bd53b2a7316c7cb
-  data.tar.gz: 78cc7ec6d5c1a7f6603f9f2e4917b26e12ad5b13c0387a00645282acf8c910518c4132c171e2c9a8311f11e82afa3eb0454d2102bf48abd4c44d6625fd4ce4cf
+  metadata.gz: 3cc45e503a6ed19a5cc507ab0791087e432b612581498e84403fd806e0d9538ff02f57c2fbb64294ba9895514218bca05610f637a8708a752e6eaf42fa61bfaa
+  data.tar.gz: 9eb027f449b6bdee43316e3b78364d1680d56442b5f34ec82b49059a9f28418a51448e24e45318efb022e526b62e067e410a8e78eb3b67678f1e18ce46866004

data/CHANGELOG.md

@@ -1,5 +1,53 @@
 # 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)

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

@@ -115,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
@@ -140,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|
@@ -166,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:
@@ -191,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:
@@ -222,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,7 @@ 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
@@ -19,6 +20,7 @@ def safely_require(lib)
 end
 
 safely_require "sentry/rake"
+safely_require "sentry/rack"
 
 module Sentry
   class Error < StandardError
@@ -43,6 +45,8 @@ module Sentry
 
     def_delegators :get_current_scope, :set_tags, :set_extras, :set_user
 
+    attr_accessor :background_worker
+
     def init(&block)
       config = Configuration.new
       yield(config)
@@ -51,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

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/client.rb

@@ -20,7 +20,9 @@ module Sentry
       end
     end
 
-    def capture_event(event, scope, hint = nil)
+    def capture_event(event, scope, hint = {})
+      return false unless configuration.sending_allowed?
+
       scope.apply_to_event(event, hint)
 
       if configuration.async?
@@ -33,7 +35,13 @@ module Sentry
           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
@@ -64,8 +72,6 @@ module Sentry
     end
 
     def send_event(event, hint = nil)
-      return false unless configuration.sending_allowed?
-
       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" }

data/lib/sentry/configuration.rb

@@ -1,3 +1,5 @@
+require "concurrent/utility/processor_counter"
+
 require "sentry/utils/exception_cause_chain"
 require "sentry/dsn"
 require "sentry/transport/configuration"
@@ -15,6 +17,15 @@ module Sentry
     attr_reader :async
     alias async? async
 
+    # to send events in a non-blocking way, sentry-ruby has its own background worker
+    # by default, the worker holds a thread pool that has [the number of processors] threads
+    # but you can configure it with this configuration option
+    # E.g.: config.background_worker_threads = 5
+    #
+    # if you want to send events synchronously, set the value to 0
+    # E.g.: config.background_worker_threads = 0
+    attr_accessor :background_worker_threads
+
     # a proc/lambda that takes an array of stack traces
     # it'll be used to silence (reduce) backtrace of the exception
     #
@@ -146,6 +157,7 @@ module Sentry
 
     def initialize
       self.async = false
+      self.background_worker_threads = Concurrent.processor_count
       self.breadcrumbs_logger = []
       self.context_lines = 3
       self.environment = environment_from_env

data/lib/sentry/hub.rb

@@ -97,7 +97,7 @@ module Sentry
     def capture_event(event, **options, &block)
       return unless current_client
 
-      hint = options.delete(:hint)
+      hint = options.delete(:hint) || {}
       scope = current_scope.dup
 
       if block

data/lib/sentry/interfaces/request.rb

@@ -1,5 +1,3 @@
-require 'rack'
-
 module Sentry
   class RequestInterface < Interface
     REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
@@ -18,25 +16,6 @@ module Sentry
       self.cookies = nil
     end
 
-    def from_rack(env_hash)
-      req = ::Rack::Request.new(env_hash)
-
-      if Sentry.configuration.send_default_pii
-        self.data = read_data_from(req)
-        self.cookies = req.cookies
-      else
-        # need to completely wipe out ip addresses
-        IP_HEADERS.each { |h| env_hash.delete(h) }
-      end
-
-      self.url = req.scheme && req.url.split('?').first
-      self.method = req.request_method
-      self.query_string = req.query_string
-
-      self.headers = format_headers_for_sentry(env_hash)
-      self.env     = format_env_for_sentry(env_hash)
-    end
-
     private
 
     # See Sentry server default limits at

data/lib/sentry/rack.rb

@@ -1,5 +1,4 @@
-require 'time'
 require 'rack'
 
-require 'sentry/rack/capture_exception'
-require 'sentry/rack/tracing'
+require 'sentry/rack/capture_exceptions'
+require 'sentry/rack/interface'

data/lib/sentry/rack/{capture_exception.rb → capture_exceptions.rb}

@@ -1,45 +1,54 @@
 module Sentry
   module Rack
-    class CaptureException
+    class CaptureExceptions
       def initialize(app)
         @app = app
       end
 
       def call(env)
-        # this call clones the main (global) hub
-        # and assigns it to the current thread's Sentry#get_current_hub
-        # it's essential for multi-thread servers (e.g. puma)
-        Sentry.clone_hub_to_current_thread unless Sentry.get_current_hub
-        # this call creates an isolated scope for every request
-        # it's essential for multi-process servers (e.g. unicorn)
+        return @app.call(env) unless Sentry.initialized?
+
+        # make sure the current thread has a clean hub
+        Sentry.clone_hub_to_current_thread
+
         Sentry.with_scope do |scope|
-          # there could be some breadcrumbs already stored in the top-level scope
-          # and for request information, we don't need those breadcrumbs
           scope.clear_breadcrumbs
-          env['sentry.client'] = Sentry.get_current_client
-
           scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
           scope.set_rack_env(env)
 
+          span = Sentry.start_transaction(name: scope.transaction_name, op: "rack.request")
+          scope.set_span(span)
+
           begin
             response = @app.call(env)
           rescue Sentry::Error
+            finish_span(span, 500)
             raise # Don't capture Sentry errors
           rescue Exception => e
             Sentry.capture_exception(e)
+            finish_span(span, 500)
             raise
           end
 
           exception = collect_exception(env)
           Sentry.capture_exception(exception) if exception
 
+          finish_span(span, response[0])
+
           response
         end
       end
 
+      private
+
       def collect_exception(env)
         env['rack.exception'] || env['sinatra.error']
       end
+
+      def finish_span(span, status_code)
+        span.set_http_status(status_code)
+        span.finish
+      end
     end
   end
 end

data/lib/sentry/rack/interface.rb

@@ -0,0 +1,22 @@
+module Sentry
+  class RequestInterface
+    def from_rack(env_hash)
+      req = ::Rack::Request.new(env_hash)
+
+      if Sentry.configuration.send_default_pii
+        self.data = read_data_from(req)
+        self.cookies = req.cookies
+      else
+        # need to completely wipe out ip addresses
+        IP_HEADERS.each { |h| env_hash.delete(h) }
+      end
+
+      self.url = req.scheme && req.url.split('?').first
+      self.method = req.request_method
+      self.query_string = req.query_string
+
+      self.headers = format_headers_for_sentry(env_hash)
+      self.env     = format_env_for_sentry(env_hash)
+    end
+  end
+end

data/lib/sentry/rake.rb

@@ -5,11 +5,11 @@ module Rake
   class Application
     alias orig_display_error_messsage display_error_message
     def display_error_message(ex)
-      Sentry.capture_exception(ex) do |scope|
+      Sentry.capture_exception(ex, hint: { background: false }) do |scope|
         task_name = top_level_tasks.join(' ')
         scope.set_transaction_name(task_name)
         scope.set_tag("rake_task", task_name)
-      end
+      end if Sentry.initialized?
 
       orig_display_error_messsage(ex)
     end

data/lib/sentry/scope.rb

@@ -29,7 +29,7 @@ module Sentry
       event.level = level
       event.transaction = transaction_names.last
       event.breadcrumbs = breadcrumbs
-      event.rack_env = rack_env
+      event.rack_env = rack_env if rack_env
 
       unless @event_processors.empty?
         @event_processors.each do |processor_block|
@@ -57,7 +57,7 @@ module Sentry
       copy.user = user.deep_dup
       copy.transaction_names = transaction_names.deep_dup
       copy.fingerprint = fingerprint.deep_dup
-      copy.span = span
+      copy.span = span.deep_dup
       copy
     end
 

data/lib/sentry/span.rb

@@ -35,11 +35,6 @@ module Sentry
       @tags = {}
     end
 
-    def set_span_recorder
-      @span_recorder = SpanRecorder.new(1000)
-      @span_recorder.add(self)
-    end
-
     def finish
       # already finished
       return if @timestamp
@@ -82,14 +77,7 @@ module Sentry
 
     def start_child(**options)
       options = options.dup.merge(trace_id: @trace_id, parent_span_id: @span_id, sampled: @sampled)
-      child_span = Span.new(options)
-      child_span.span_recorder = @span_recorder
-
-      if @span_recorder && @sampled
-        @span_recorder.add(child_span)
-      end
-
-      child_span
+      Span.new(options)
     end
 
     def with_child_span(**options, &block)
@@ -100,6 +88,10 @@ module Sentry
       child_span.finish
     end
 
+    def deep_dup
+      dup
+    end
+
     def set_op(op)
       @op = op
     end
@@ -136,20 +128,5 @@ module Sentry
     def set_tag(key, value)
       @tags[key] = value
     end
-
-    class SpanRecorder
-      attr_reader :max_length, :spans
-
-      def initialize(max_length)
-        @max_length = max_length
-        @spans = []
-      end
-
-      def add(span)
-        if @spans.count < @max_length
-          @spans << span
-        end
-      end
-    end
   end
 end

data/lib/sentry/transaction.rb

@@ -20,6 +20,11 @@ module Sentry
       set_span_recorder
     end
 
+    def set_span_recorder
+      @span_recorder = SpanRecorder.new(1000)
+      @span_recorder.add(self)
+    end
+
     def self.from_sentry_trace(sentry_trace, **options)
       return unless sentry_trace
 
@@ -37,6 +42,30 @@ module Sentry
       hash
     end
 
+    def start_child(**options)
+      child_span = super
+      child_span.span_recorder = @span_recorder
+
+      if @sampled
+        @span_recorder.add(child_span)
+      end
+
+      child_span
+    end
+
+    def deep_dup
+      copy = super
+      copy.set_span_recorder
+
+      @span_recorder.spans.each do |span|
+        # span_recorder's first span is the current span, which should not be added to the copy's spans
+        next if span == self
+        copy.span_recorder.add(span.dup)
+      end
+
+      copy
+    end
+
     def set_initial_sample_desicion(sampling_context = {})
       unless Sentry.configuration.tracing_enabled?
         @sampled = false
@@ -109,5 +138,20 @@ module Sentry
       result += " <#{@name}>" if @name
       result
     end
+
+    class SpanRecorder
+      attr_reader :max_length, :spans
+
+      def initialize(max_length)
+        @max_length = max_length
+        @spans = []
+      end
+
+      def add(span)
+        if @spans.count < @max_length
+          @spans << span
+        end
+      end
+    end
   end
 end

data/lib/sentry/transport.rb

@@ -1,20 +1,17 @@
 require "json"
 require "base64"
-require "sentry/transport/state"
 
 module Sentry
   class Transport
     PROTOCOL_VERSION = '5'
     USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
-    CONTENT_TYPE = 'application/json'
 
-    attr_accessor :configuration, :state
+    attr_accessor :configuration
 
     def initialize(configuration)
       @configuration = configuration
       @transport_configuration = configuration.transport
       @dsn = configuration.dsn
-      @state = State.new
     end
 
     def send_data(data, options = {})
@@ -22,13 +19,17 @@ module Sentry
     end
 
     def send_event(event)
-      content_type, encoded_data = prepare_encoded_event(event)
+      unless configuration.sending_allowed?
+        configuration.logger.debug(LOGGER_PROGNAME) { "Event not sent: #{configuration.error_messages}" }
+        return
+      end
+
+      encoded_data = prepare_encoded_event(event)
 
       return nil unless encoded_data
 
-      send_data(encoded_data, content_type: content_type)
+      send_data(encoded_data)
 
-      state.success
       event
     rescue => e
       failed_for_exception(e, event)
@@ -57,7 +58,7 @@ module Sentry
         #{JSON.generate(event_hash)}
       ENVELOPE
 
-      [CONTENT_TYPE, envelope]
+      envelope
     end
 
     private
@@ -66,27 +67,16 @@ module Sentry
       # Convert to hash
       event_hash = event.to_hash
 
-      unless @state.should_try?
-        failed_for_previous_failure(event_hash)
-        return
-      end
-
       event_id = event_hash[:event_id] || event_hash['event_id']
       configuration.logger.info(LOGGER_PROGNAME) { "Sending event #{event_id} to Sentry" }
       encode(event_hash)
     end
 
     def failed_for_exception(e, event)
-      @state.failure
       configuration.logger.warn(LOGGER_PROGNAME) { "Unable to record event with remote Sentry server (#{e.class} - #{e.message}):\n#{e.backtrace[0..10].join("\n")}" }
       log_not_sending(event)
     end
 
-    def failed_for_previous_failure(event)
-      configuration.logger.warn(LOGGER_PROGNAME) { "Not sending event due to previous failure(s)." }
-      log_not_sending(event)
-    end
-
     def log_not_sending(event)
       configuration.logger.warn(LOGGER_PROGNAME) { "Failed to submit event. Unreported Event: #{Event.get_log_message(event.to_hash)}" }
     end

data/lib/sentry/transport/http_transport.rb

@@ -2,6 +2,7 @@ require 'faraday'
 
 module Sentry
   class HTTPTransport < Transport
+    CONTENT_TYPE = 'application/json'
     attr_reader :conn, :adapter
 
     def initialize(*args)
@@ -11,13 +12,9 @@ module Sentry
       @endpoint = @dsn.envelope_endpoint
     end
 
-    def send_data(data, options = {})
-      unless configuration.sending_allowed?
-        logger.debug(LOGGER_PROGNAME) { "Event not sent: #{configuration.error_messages}" }
-      end
-
+    def send_data(data)
       conn.post @endpoint do |req|
-        req.headers['Content-Type'] = options[:content_type]
+        req.headers['Content-Type'] = CONTENT_TYPE
         req.headers['X-Sentry-Auth'] = generate_auth_header
         req.body = data
       end

data/lib/sentry/version.rb

@@ -1,3 +1,3 @@
 module Sentry
-  VERSION = "4.0.1"
+  VERSION = "4.1.0"
 end

data/sentry-ruby.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "faraday", ">= 1.0"
+  spec.add_dependency "concurrent-ruby"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby
 version: !ruby/object:Gem::Version
-  version: 4.0.1
+  version: 4.1.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-11 00:00:00.000000000 Z
+date: 2020-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A gem that provides a client interface for the Sentry error logger
 email: accounts@sentry.io
 executables: []
@@ -45,6 +59,7 @@ files:
 - bin/console
 - bin/setup
 - lib/sentry-ruby.rb
+- lib/sentry/background_worker.rb
 - lib/sentry/backtrace.rb
 - lib/sentry/benchmarks/benchmark_transport.rb
 - lib/sentry/breadcrumb.rb
@@ -65,8 +80,8 @@ files:
 - lib/sentry/linecache.rb
 - lib/sentry/logger.rb
 - lib/sentry/rack.rb
-- lib/sentry/rack/capture_exception.rb
-- lib/sentry/rack/tracing.rb
+- lib/sentry/rack/capture_exceptions.rb
+- lib/sentry/rack/interface.rb
 - lib/sentry/rake.rb
 - lib/sentry/scope.rb
 - lib/sentry/span.rb
@@ -76,7 +91,6 @@ files:
 - lib/sentry/transport/configuration.rb
 - lib/sentry/transport/dummy_transport.rb
 - lib/sentry/transport/http_transport.rb
-- lib/sentry/transport/state.rb
 - lib/sentry/utils/exception_cause_chain.rb
 - lib/sentry/utils/real_ip.rb
 - lib/sentry/utils/request_id.rb

data/lib/sentry/rack/tracing.rb

@@ -1,39 +0,0 @@
-module Sentry
-  module Rack
-    class Tracing
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        Sentry.clone_hub_to_current_thread unless Sentry.get_current_hub
-
-        if Sentry.configuration.traces_sample_rate.to_f == 0.0
-          return @app.call(env)
-        end
-
-        Sentry.with_scope do |scope|
-          scope.clear_breadcrumbs
-          scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
-          span = Sentry.start_transaction(name: scope.transaction_name, op: "rack.request")
-          scope.set_span(span)
-
-          begin
-            response = @app.call(env)
-          rescue
-            finish_span(span, 500)
-            raise
-          end
-
-          finish_span(span, response[0])
-          response
-        end
-      end
-
-      def finish_span(span, status_code)
-        span.set_http_status(status_code)
-        span.finish
-      end
-    end
-  end
-end

data/lib/sentry/transport/state.rb

@@ -1,40 +0,0 @@
-module Sentry
-  class Transport
-    class State
-      def initialize
-        reset
-      end
-
-      def should_try?
-        return true if @status == :online
-
-        interval = @retry_after || [@retry_number, 6].min**2
-        return true if Sentry.utc_now - @last_check >= interval
-
-        false
-      end
-
-      def failure(retry_after = nil)
-        @status = :error
-        @retry_number += 1
-        @last_check = Sentry.utc_now
-        @retry_after = retry_after
-      end
-
-      def success
-        reset
-      end
-
-      def reset
-        @status = :online
-        @retry_number = 0
-        @last_check = nil
-        @retry_after = nil
-      end
-
-      def failed?
-        @status == :error
-      end
-    end
-  end
-end