sentry-ruby 0.3.0 → 4.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de5539f70eb6f49164765e4e13416bef15f8b697349f2d2e71f63ac57916f325
-  data.tar.gz: 89121fce3fb31be7fe783599ee204ab86354f70a870ce775c79e4a33f6141e13
+  metadata.gz: cbe0af63148c410c71208f7bac743d24e224b5265102d645831a9538262961dc
+  data.tar.gz: 9933997d430fc94d400f97b9e2319ab14ccfe1bd2ff42635eda5b13bd4e11621
 SHA512:
-  metadata.gz: ca35ae1d033f68fcebfe2c3e9e4b91fa2784a56261423a1bc5e5c7550b6304eb63963bf4273b22e924db27e1287f256e712b7e74781d866e71bae288308e13ae
-  data.tar.gz: e5853d409d5bbbb4b60ecee8c1edc3c6de91971b39938c03a19895ce790246cc234e5441d848aaba745ccc90cc4bbd3f1df4eb3108c18ea68736dab41f2ca93f
+  metadata.gz: a813b4fad61840a850b6dd82451d689272800b5d4e405ab50f80f99cfe69a371f770c1a8151491ccd2f10400822e0e4a98bc8c2ca1265b562139bd7ffc1cdd02
+  data.tar.gz: 1331331801ea39234c96e50e9fc469713efd48ee316e5620ae2c200f97a4a4d88810f942d707fb77dab7b458284ee11cad4b6153632cde4aa6014e2df5a89820

data/CHANGELOG.md

@@ -1,5 +1,76 @@
 # Changelog
 
+## 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.
+
 ## 0.3.0
 
 - Major API changes: [1123](https://github.com/getsentry/sentry-ruby/pull/1123)

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

@@ -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,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,24 @@ 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_scope, :set_tags, :set_extras, :set_user
 
+    attr_accessor :background_worker
+
     def init(&block)
       config = Configuration.new
       yield(config)
@@ -42,6 +66,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
@@ -61,7 +90,7 @@ module Sentry
     end
 
     def get_current_client
-      get_current_hub.current_client
+      get_current_hub&.current_client
     end
 
     def get_current_hub
@@ -78,15 +107,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)
@@ -94,23 +123,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/client.rb

@@ -20,7 +20,9 @@ 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?
@@ -33,22 +35,30 @@ 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
     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 +74,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

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

@@ -18,9 +18,9 @@ module Sentry
     )
 
     attr_accessor(*ATTRIBUTES)
-    attr_reader :configuration
+    attr_reader :configuration, :request, :exception, :stacktrace
 
-    def initialize(configuration:, message: nil)
+    def initialize(configuration:, integration_meta: nil, message: nil)
       # this needs to go first because some setters rely on configuration
       @configuration = configuration
 
@@ -28,7 +28,7 @@ module Sentry
       @event_id      = SecureRandom.uuid.delete("-")
       @timestamp     = Sentry.utc_now.iso8601
       @platform      = :ruby
-      @sdk           = Sentry.sdk_meta
+      @sdk           = integration_meta || Sentry.sdk_meta
 
       @user          = {}
       @extra         = {}
@@ -75,7 +75,7 @@ module Sentry
     end
 
     def rack_env=(env)
-      unless @request || env.empty?
+      unless request || env.empty?
         @request = Sentry::RequestInterface.new.tap do |int|
           int.from_rack(env)
         end
@@ -96,9 +96,9 @@ module Sentry
     def to_hash
       data = serialize_attributes
       data[:breadcrumbs] = breadcrumbs.to_hash if breadcrumbs
-      data[:stacktrace] = @stacktrace.to_hash if @stacktrace
-      data[:request] = @request.to_hash if @request
-      data[:exception] = @exception.to_hash if @exception
+      data[:stacktrace] = stacktrace.to_hash if stacktrace
+      data[:request] = request.to_hash if request
+      data[:exception] = exception.to_hash if exception
 
       data
     end

data/lib/sentry/hub.rb

@@ -76,12 +76,12 @@ module Sentry
     def capture_exception(exception, **options, &block)
       return unless current_client
 
-      event = current_client.event_from_exception(exception)
+      options[:hint] ||= {}
+      options[:hint][:exception] = exception
+      event = current_client.event_from_exception(exception, options[:hint])
 
       return unless event
 
-      options[:hint] ||= {}
-      options[:hint] = options[:hint].merge(exception: exception)
       capture_event(event, **options, &block)
     end
 
@@ -89,15 +89,15 @@ module Sentry
       return unless current_client
 
       options[:hint] ||= {}
-      options[:hint] = options[:hint].merge(message: message)
-      event = current_client.event_from_message(message)
+      options[:hint][:message] = message
+      event = current_client.event_from_message(message, options[:hint])
       capture_event(event, **options, &block)
     end
 
     def capture_event(event, **options, &block)
       return unless current_client
 
-      hint = options.delete(:hint)
+      hint = options.delete(:hint) || {}
       scope = current_scope.dup
 
       if block
@@ -110,7 +110,7 @@ module Sentry
 
       event = current_client.capture_event(event, scope, hint)
 
-      @last_event_id = event.event_id
+      @last_event_id = event&.event_id
       event
     end
 

data/lib/sentry/integrable.rb

@@ -0,0 +1,24 @@
+module Sentry
+  module Integrable
+    def register_integration(name:, version:)
+      Sentry.register_integration(name, version)
+      @integration_name = name
+    end
+
+    def integration_name
+      @integration_name
+    end
+
+    def capture_exception(exception, **options, &block)
+      options[:hint] ||= {}
+      options[:hint][:integration] = integration_name
+      Sentry.capture_exception(exception, **options, &block)
+    end
+
+    def capture_message(message, **options, &block)
+      options[:hint] ||= {}
+      options[:hint][:integration] = integration_name
+      Sentry.capture_message(message, **options, &block)
+    end
+  end
+end

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,5 @@
-require 'time'
 require 'rack'
 
-require 'sentry/rack/capture_exception'
-require 'sentry/rack/tracing'
+require 'sentry/rack/capture_exceptions'
+require 'sentry/rack/interface'
+require 'sentry/rack/deprecations'

data/lib/sentry/rack/capture_exceptions.rb

@@ -0,0 +1,62 @@
+module Sentry
+  module Rack
+    class CaptureExceptions
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        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|
+          scope.clear_breadcrumbs
+          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: transaction_op)
+          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
+            capture_exception(e)
+            finish_span(span, 500)
+            raise
+          end
+
+          exception = collect_exception(env)
+          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 transaction_op
+        "rack.request".freeze
+      end
+
+      def capture_exception(exception)
+        Sentry.capture_exception(exception)
+      end
+
+      def finish_span(span, status_code)
+        span.set_http_status(status_code)
+        span.finish
+      end
+    end
+  end
+end

data/lib/sentry/rack/deprecations.rb

@@ -0,0 +1,19 @@
+module Sentry
+  module Rack
+    class DeprecatedMiddleware
+      def initialize(_)
+        raise Sentry::Error.new <<~MSG
+
+You're seeing this message because #{self.class} has been replaced by Sentry::Rack::CaptureExceptions.
+Removing this middleware from your app and upgrading sentry-rails to 4.1.0+ should solve the issue.
+        MSG
+      end
+    end
+
+    class Tracing < DeprecatedMiddleware
+    end
+
+    class CaptureException < DeprecatedMiddleware
+    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

@@ -0,0 +1,17 @@
+require "rake"
+require "rake/task"
+
+module Rake
+  class Application
+    alias orig_display_error_messsage display_error_message
+    def display_error_message(ex)
+      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 if Sentry.initialized?
+
+      orig_display_error_messsage(ex)
+    end
+  end
+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,17 @@ 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" }
+      event_id = event_hash[:event_id] || event_hash["event_id"]
+      event_type = event_hash[:type] || event_hash["type"]
+      configuration.logger.info(LOGGER_PROGNAME) { "Sending #{event_type} #{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 = "0.3.0"
+  VERSION = "4.1.2"
 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", '~> 1.0', '>= 1.0.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 4.1.2
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-04 00:00:00.000000000 Z
+date: 2020-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -24,6 +24,26 @@ 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: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.2
 description: A gem that provides a client interface for the Sentry error logger
 email: accounts@sentry.io
 executables: []
@@ -45,6 +65,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
@@ -57,6 +78,7 @@ files:
 - lib/sentry/dsn.rb
 - lib/sentry/event.rb
 - lib/sentry/hub.rb
+- lib/sentry/integrable.rb
 - lib/sentry/interface.rb
 - lib/sentry/interfaces/exception.rb
 - lib/sentry/interfaces/request.rb
@@ -65,8 +87,10 @@ 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/deprecations.rb
+- lib/sentry/rack/interface.rb
+- lib/sentry/rake.rb
 - lib/sentry/scope.rb
 - lib/sentry/span.rb
 - lib/sentry/transaction.rb
@@ -75,7 +99,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/capture_exception.rb

@@ -1,45 +0,0 @@
-module Sentry
-  module Rack
-    class CaptureException
-      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)
-        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)
-
-          begin
-            response = @app.call(env)
-          rescue Sentry::Error
-            raise # Don't capture Sentry errors
-          rescue Exception => e
-            Sentry.capture_exception(e)
-            raise
-          end
-
-          exception = collect_exception(env)
-          Sentry.capture_exception(exception) if exception
-
-          response
-        end
-      end
-
-      def collect_exception(env)
-        env['rack.exception'] || env['sinatra.error']
-      end
-    end
-  end
-end

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