sentry-ruby-core 4.3.2 → 4.5.0.pre.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85c558cf77534e3d3fea7d30e417171302f485042b8a09b3a1114c714f1b17ec
-  data.tar.gz: d8077c3cfee56f1427d03770dc8d28e9920bbba4d97e14e983d3b7a5a949be95
+  metadata.gz: 39b0d720876099298375f0ea0130ced0effa7fe7cb3c153d5075cff400788d7a
+  data.tar.gz: 3e89ef0214a1b632274605984514aa4703d6aea3bcc6c625d8f32eaa2f552203
 SHA512:
-  metadata.gz: 9cc8fa4030f678d6b2cd34d1c5752e4da6065527ed598e6f43a14ab6adcb44fbe4f104b99de9dd65d45995f726fc074bf3944891348ce4491a385ce22acfa493
-  data.tar.gz: 8fc20069fbddcb6dba3206ea8d7578c9da54f5a0812c0388e9e1afc983befcaaaa3d32390af78b6f3bee6294e997455dbcc807d7543380bc20740b314534dd7b
+  metadata.gz: 263a733c7d5c2ca356a1de8f5b75b7ec1266e1ea6abe57b20db0a4789a2bd7bb1444dababc06a1291089c009dbcae05b8ded8a11bcd21f721ece3df454e1fb8b
+  data.tar.gz: b256b35de1a11df8e0b3468d47365fec0646da828f05e3161cd4b0374a5b7fda4586d911146895d04bb6574306688b587012c6b85d3b09baf096771efb3d1e49

data/.craft.yml

@@ -13,9 +13,6 @@ targets:
     # we always need to make sure sentry-ruby-core is present when pushing to any target
     - name: gem
       onlyIfPresent: /^sentry-ruby-core-\d.*\.gem$/
-    - name: github
-      onlyIfPresent: /^sentry-ruby-core-\d.*\.gem$/
-      tagPrefix: sentry-ruby-v
     - name: registry
       onlyIfPresent: /^sentry-ruby-core-\d.*\.gem$/
       type: sdk
@@ -26,3 +23,6 @@ targets:
       type: sdk
       config:
           canonical: 'gem:sentry-ruby-core'
+    - name: github
+      onlyIfPresent: /^sentry-ruby-core-\d.*\.gem$/
+      tagPrefix: sentry-ruby-v

data/CHANGELOG.md

@@ -1,5 +1,97 @@
 # Changelog
 
+## Unreleased
+
+### Features
+
+- Implement sentry-trace propagation [#1446](https://github.com/getsentry/sentry-ruby/pull/1446)
+
+The SDK will insert the `sentry-trace` to outgoing requests made with `Net::HTTP`. Its value would look like `d827317d25d5420aa3aa97a0257db998-57757614642bdff5-1`. 
+
+If the receiver service also uses Sentry and the SDK supports performance monitoring, its tracing event will be connected with the sender application's.
+
+Example:
+
+<img width="1283" alt="connect sentry trace" src="https://user-images.githubusercontent.com/5079556/118963250-d7b40980-b998-11eb-9de4-598d1b220137.png">
+
+This feature is activated by default. But users can use the new `config.propagate_traces` config option to disable it.
+
+### Bug Fixes
+
+- Allow toggling background sending on the fly [#1447](https://github.com/getsentry/sentry-ruby/pull/1447) 
+
+## 4.4.2
+
+- Fix NoMethodError when SDK's dsn is nil [#1433](https://github.com/getsentry/sentry-ruby/pull/1433)
+- fix: Update protocol version to 7 [#1434](https://github.com/getsentry/sentry-ruby/pull/1434)
+  - Fixes [#867](https://github.com/getsentry/sentry-ruby/issues/867)
+
+## 4.4.1
+
+- Apply patches when initializing the SDK [#1432](https://github.com/getsentry/sentry-ruby/pull/1432)
+
+## 4.4.0
+
+### Features
+
+#### Support category-based rate limiting [#1336](https://github.com/getsentry/sentry-ruby/pull/1336) 
+
+Sentry rate limits different types of events. And when rate limiting is enabled, it sends back a `429` response to the SDK. Currently, the SDK would then raise an error like this:
+
+```
+Unable to record event with remote Sentry server (Sentry::Error - the server responded with status 429
+body: {"detail":"event rejected due to rate limit"}):
+```
+
+This change improves the SDK's handling on such responses by:
+
+- Not treating them as errors, so you don't see the noise anymore.
+- Halting event sending for a while according to the duration provided in the response. And warns you with a message like:
+
+```
+Envelope [event] not sent: Excluded by random sample
+```
+
+#### Record request span from Net::HTTP library [#1381](https://github.com/getsentry/sentry-ruby/pull/1381)
+
+Now any outgoing requests will be recorded as a tracing span. Example:
+
+<img width="60%" alt="net:http span example" src="https://user-images.githubusercontent.com/5079556/115838944-c1279a80-a44c-11eb-8c67-dfd92bf68bbd.png">
+
+
+#### Record breadcrumb for Net::HTTP requests [#1394](https://github.com/getsentry/sentry-ruby/pull/1394)
+
+With the new `http_logger` breadcrumbs logger:
+
+```ruby
+config.breadcrumbs_logger = [:http_logger]
+```
+
+The SDK now records a new `net.http` breadcrumb whenever the user makes a request with the `Net::HTTP` library.
+
+<img width="60%" alt="net http breadcrumb" src="https://user-images.githubusercontent.com/5079556/114298326-5f7c3d80-9ae8-11eb-9108-222384a7f1a2.png">
+
+#### Support config.debug configuration option [#1400](https://github.com/getsentry/sentry-ruby/pull/1400)
+
+It'll determine whether the SDK should run in the debugging mode. Default is `false`. When set to true, SDK errors will be logged with backtrace.
+
+#### Add the third tracing state [#1402](https://github.com/getsentry/sentry-ruby/pull/1402)
+  - `rate == 0` - Tracing enabled. Rejects all locally created transactions but  respects sentry-trace.
+  - `1 > rate > 0` - Tracing enabled. Samples locally created transactions  with the rate and respects sentry-trace.
+  - `rate < 0` or `rate > 1` - Tracing disabled.
+
+### Refactorings
+
+- Let Transaction constructor take an optional hub argument [#1384](https://github.com/getsentry/sentry-ruby/pull/1384)
+- Introduce LoggingHelper [#1385](https://github.com/getsentry/sentry-ruby/pull/1385)
+- Raise exception if a Transaction is initialized without a hub [#1391](https://github.com/getsentry/sentry-ruby/pull/1391)
+- Make hub a required argument for Transaction constructor [#1401](https://github.com/getsentry/sentry-ruby/pull/1401) 
+
+### Bug Fixes
+
+- Check `Scope#set_context`'s value argument [#1415](https://github.com/getsentry/sentry-ruby/pull/1415)
+- Disable tracing if events are not allowed to be sent [#1421](https://github.com/getsentry/sentry-ruby/pull/1421)
+
 ## 4.3.2
 
 - Correct type attribute's usages [#1354](https://github.com/getsentry/sentry-ruby/pull/1354)

data/Gemfile

@@ -9,7 +9,10 @@ gem "i18n", "<= 1.8.7"
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
 gem "rspec-retry"
+gem "webmock"
+gem "timecop"
 gem "codecov", "0.2.12"
+gem "tapping_device"
 
 gem "pry"
 gem "rack" unless ENV["WITHOUT_RACK"] == "1"

data/lib/sentry-ruby.rb

@@ -6,6 +6,7 @@ require "sentry/version"
 require "sentry/exceptions"
 require "sentry/core_ext/object/deep_dup"
 require "sentry/utils/argument_checking_helper"
+require "sentry/utils/logging_helper"
 require "sentry/configuration"
 require "sentry/logger"
 require "sentry/event"
@@ -31,6 +32,8 @@ module Sentry
 
   LOGGER_PROGNAME = "sentry".freeze
 
+  SENTRY_TRACE_HEADER_NAME = "sentry-trace".freeze
+
   THREAD_LOCAL = :sentry_hub
 
   def self.sdk_meta
@@ -62,9 +65,26 @@ module Sentry
 
     attr_accessor :background_worker
 
+    @@registered_patches = []
+
+    def register_patch(&block)
+      registered_patches << block
+    end
+
+    def apply_patches(config)
+      registered_patches.each do |patch|
+        patch.call(config)
+      end
+    end
+
+    def registered_patches
+      @@registered_patches
+    end
+
     def init(&block)
       config = Configuration.new
       yield(config) if block_given?
+      apply_patches(config)
       client = Client.new(config)
       scope = Scope.new(max_breadcrumbs: config.max_breadcrumbs)
       hub = Hub.new(client, scope)
@@ -188,3 +208,6 @@ module Sentry
     end
   end
 end
+
+# patches
+require "sentry/net/http"

data/lib/sentry/background_worker.rb

@@ -4,21 +4,24 @@ require "concurrent/configuration"
 
 module Sentry
   class BackgroundWorker
-    attr_reader :max_queue, :number_of_threads
+    include LoggingHelper
+
+    attr_reader :max_queue, :number_of_threads, :logger
 
     def initialize(configuration)
       @max_queue = 30
       @number_of_threads = configuration.background_worker_threads
+      @logger = configuration.logger
 
       @executor =
         if configuration.async
-          configuration.logger.debug(LOGGER_PROGNAME) { "config.async is set, BackgroundWorker is disabled" }
+          log_debug("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" }
+          log_debug("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" }
+          log_debug("initialized a background worker with #{@number_of_threads} threads")
 
           Concurrent::ThreadPoolExecutor.new(
             min_threads: 0,

data/lib/sentry/client.rb

@@ -2,6 +2,8 @@ require "sentry/transport"
 
 module Sentry
   class Client
+    include LoggingHelper
+
     attr_reader :transport, :configuration, :logger
 
     def initialize(configuration)
@@ -28,7 +30,7 @@ module Sentry
 
       if async_block = configuration.async
         dispatch_async_event(async_block, event, hint)
-      elsif hint.fetch(:background, true)
+      elsif configuration.background_worker_threads != 0 && hint.fetch(:background, true)
         dispatch_background_event(event, hint)
       else
         send_event(event, hint)
@@ -36,7 +38,7 @@ module Sentry
 
       event
     rescue => e
-      logger.error(LOGGER_PROGNAME) { "Event capturing failed: #{e.message}" }
+      log_error("Event capturing failed", e, debug: configuration.debug)
       nil
     end
 
@@ -76,7 +78,7 @@ module Sentry
         event = configuration.before_send.call(event, hint)
 
         if event.nil?
-          logger.info(LOGGER_PROGNAME) { "Discarded event because before_send returned nil" }
+          log_info("Discarded event because before_send returned nil")
           return
         end
       end
@@ -86,11 +88,21 @@ module Sentry
       event
     rescue => e
       loggable_event_type = (event_type || "event").capitalize
-      logger.error(LOGGER_PROGNAME) { "#{loggable_event_type} sending failed: #{e.message}" }
-      logger.error(LOGGER_PROGNAME) { "Unreported #{loggable_event_type}: #{Event.get_log_message(event.to_hash)}" }
+      log_error("#{loggable_event_type} sending failed", e, debug: configuration.debug)
+
+      event_info = Event.get_log_message(event.to_hash)
+      log_info("Unreported #{loggable_event_type}: #{event_info}")
       raise
     end
 
+    def generate_sentry_trace(span)
+      return unless configuration.propagate_traces
+
+      trace = span.to_sentry_trace
+      log_debug("[Tracing] Adding #{SENTRY_TRACE_HEADER_NAME} header to outgoing request: #{trace}")
+      trace
+    end
+
     private
 
     def dispatch_background_event(event, hint)
@@ -112,9 +124,8 @@ module Sentry
       end
     rescue => e
       loggable_event_type = event_hash["type"] || "event"
-      logger.error(LOGGER_PROGNAME) { "Async #{loggable_event_type} sending failed: #{e.message}" }
+      log_error("Async #{loggable_event_type} sending failed", e, debug: configuration.debug)
       send_event(event, hint)
     end
-
   end
 end

data/lib/sentry/configuration.rb

@@ -8,6 +8,7 @@ require "sentry/interfaces/stacktrace_builder"
 
 module Sentry
   class Configuration
+    include LoggingHelper
     # Directories to be recognized as part of your app. e.g. if you
     # have an `engines` dir at the root of your project, you may want
     # to set this to something like /(app|config|engines|lib)/
@@ -71,6 +72,10 @@ module Sentry
     # RACK_ENV by default.
     attr_reader :environment
 
+    # Whether the SDK should run in the debugging mode. Default is false.
+    # If set to true, SDK errors will be logged with backtrace
+    attr_accessor :debug
+
     # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
     attr_reader :dsn
 
@@ -101,6 +106,9 @@ module Sentry
     # Set automatically for Rails.
     attr_reader :project_root
 
+    # Insert sentry-trace to outgoing requests' headers
+    attr_accessor :propagate_traces
+
     # Array of rack env parameters to be included in the event sent to sentry.
     attr_accessor :rack_env_whitelist
 
@@ -167,13 +175,12 @@ module Sentry
     LOG_PREFIX = "** [Sentry] ".freeze
     MODULE_SEPARATOR = "::".freeze
 
-    AVAILABLE_BREADCRUMBS_LOGGERS = [:sentry_logger, :active_support_logger].freeze
-
     # Post initialization callbacks are called at the end of initialization process
     # allowing extending the configuration of sentry-ruby by multiple extensions
     @@post_initialization_callbacks = []
 
     def initialize
+      self.debug = false
       self.background_worker_threads = Concurrent.processor_count
       self.max_breadcrumbs = BreadcrumbBuffer::DEFAULT_SIZE
       self.breadcrumbs_logger = []
@@ -186,6 +193,7 @@ module Sentry
       self.linecache = ::Sentry::LineCache.new
       self.logger = ::Sentry::Logger.new(STDOUT)
       self.project_root = Dir.pwd
+      self.propagate_traces = true
 
       self.release = detect_release
       self.sample_rate = 1.0
@@ -226,10 +234,6 @@ module Sentry
         if logger.is_a?(Array)
           logger
         else
-          unless AVAILABLE_BREADCRUMBS_LOGGERS.include?(logger)
-            raise Sentry::Error, "Unsupported breadcrumbs logger. Supported loggers: #{AVAILABLE_BREADCRUMBS_LOGGERS}"
-          end
-
           Array(logger)
         end
 
@@ -278,10 +282,10 @@ module Sentry
     def exception_class_allowed?(exc)
       if exc.is_a?(Sentry::Error)
         # Try to prevent error reporting loops
-        logger.debug(LOGGER_PROGNAME) { "Refusing to capture Sentry error: #{exc.inspect}" }
+        log_debug("Refusing to capture Sentry error: #{exc.inspect}")
         false
       elsif excluded_exception?(exc)
-        logger.debug(LOGGER_PROGNAME) { "User excluded error: #{exc.inspect}" }
+        log_debug("User excluded error: #{exc.inspect}")
         false
       else
         true
@@ -293,7 +297,7 @@ module Sentry
     end
 
     def tracing_enabled?
-      !!((@traces_sample_rate && @traces_sample_rate > 0.0) || @traces_sampler)
+      !!((@traces_sample_rate && @traces_sample_rate >= 0.0 && @traces_sample_rate <= 1.0) || @traces_sampler) && sending_allowed?
     end
 
     def stacktrace_builder
@@ -314,7 +318,7 @@ module Sentry
         detect_release_from_capistrano ||
         detect_release_from_heroku
     rescue => e
-      logger.error(LOGGER_PROGNAME) { "Error detecting release: #{e.message}" }
+      log_error("Error detecting release", e, debug: debug)
     end
 
     def excluded_exception?(incoming_exception)
@@ -349,7 +353,7 @@ module Sentry
     def detect_release_from_heroku
       return unless running_on_heroku?
       return if ENV['CI']
-      logger.warn(LOGGER_PROGNAME) { HEROKU_DYNO_METADATA_MESSAGE } && return unless ENV['HEROKU_SLUG_COMMIT']
+      log_warn(HEROKU_DYNO_METADATA_MESSAGE) && return unless ENV['HEROKU_SLUG_COMMIT']
 
       ENV['HEROKU_SLUG_COMMIT']
     end

data/lib/sentry/hub.rb

@@ -21,6 +21,10 @@ module Sentry
       current_layer&.client
     end
 
+    def configuration
+      current_client.configuration
+    end
+
     def current_scope
       current_layer&.scope
     end
@@ -69,10 +73,10 @@ module Sentry
       @stack.pop
     end
 
-    def start_transaction(transaction: nil, configuration: Sentry.configuration, custom_sampling_context: {}, **options)
+    def start_transaction(transaction: nil, custom_sampling_context: {}, **options)
       return unless configuration.tracing_enabled?
 
-      transaction ||= Transaction.new(**options)
+      transaction ||= Transaction.new(**options.merge(hub: self))
 
       sampling_context = {
         transaction_context: transaction.to_hash,
@@ -81,7 +85,7 @@ module Sentry
 
       sampling_context.merge!(custom_sampling_context)
 
-      transaction.set_initial_sample_decision(configuration: current_client.configuration, sampling_context: sampling_context)
+      transaction.set_initial_sample_decision(sampling_context: sampling_context)
       transaction
     end
 

data/lib/sentry/net/http.rb

@@ -0,0 +1,126 @@
+require "net/http"
+
+module Sentry
+  module Net
+    module HTTP
+      OP_NAME = "net.http"
+
+      # To explain how the entire thing works, we need to know how the original Net::HTTP#request works
+      # Here's part of its definition. As you can see, it usually calls itself inside a #start block
+      #
+      # ```
+      # def request(req, body = nil, &block)
+      #   unless started?
+      #     start {
+      #       req['connection'] ||= 'close'
+      #       return request(req, body, &block) # <- request will be called for the second time from the first call
+      #     }
+      #   end
+      #   # .....
+      # end
+      # ```
+      #
+      # So when the entire flow looks like this:
+      #
+      # 1. #request is called.
+      #   - But because the request hasn't started yet, it calls #start (which then calls #do_start)
+      #   - At this moment @sentry_span is still nil, so #set_sentry_trace_header returns early
+      # 2. #do_start then creates a new Span and assigns it to @sentry_span
+      # 3. #request is called for the second time.
+      #   - This time @sentry_span should present. So #set_sentry_trace_header will set the sentry-trace header on the request object
+      # 4. Once the request finished, it
+      #   - Records a breadcrumb if http_logger is set
+      #   - Finishes the Span inside @sentry_span and clears the instance variable
+      #
+      def request(req, body = nil, &block)
+        set_sentry_trace_header(req)
+
+        super.tap do |res|
+          record_sentry_breadcrumb(req, res)
+          record_sentry_span(req, res)
+        end
+      end
+
+      def do_start
+        super.tap do
+          start_sentry_span
+        end
+      end
+
+      def do_finish
+        super.tap do
+          finish_sentry_span
+        end
+      end
+
+      private
+
+      def set_sentry_trace_header(req)
+        return unless @sentry_span
+
+        trace = Sentry.get_current_client.generate_sentry_trace(@sentry_span)
+        req[SENTRY_TRACE_HEADER_NAME] = trace if trace
+      end
+
+      def record_sentry_breadcrumb(req, res)
+        if Sentry.initialized? && Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
+          return if from_sentry_sdk?
+
+          request_info = extract_request_info(req)
+          crumb = Sentry::Breadcrumb.new(
+            level: :info,
+            category: OP_NAME,
+            type: :info,
+            data: {
+              method: request_info[:method],
+              url: request_info[:url],
+              status: res.code.to_i
+            }
+          )
+          Sentry.add_breadcrumb(crumb)
+        end
+      end
+
+      def record_sentry_span(req, res)
+        if Sentry.initialized? && @sentry_span
+          request_info = extract_request_info(req)
+          @sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
+          @sentry_span.set_data(:status, res.code.to_i)
+        end
+      end
+
+      def start_sentry_span
+        if Sentry.initialized? && transaction = Sentry.get_current_scope.get_transaction
+          return if from_sentry_sdk?
+          return if transaction.sampled == false
+
+          child_span = transaction.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
+          @sentry_span = child_span
+        end
+      end
+
+      def finish_sentry_span
+        if Sentry.initialized? && @sentry_span
+          @sentry_span.set_timestamp(Sentry.utc_now.to_f)
+          @sentry_span = nil
+        end
+      end
+
+      def from_sentry_sdk?
+        dsn = Sentry.configuration.dsn
+        dsn && dsn.host == self.address
+      end
+
+      def extract_request_info(req)
+        uri = req.uri
+        url = "#{uri.scheme}://#{uri.host}#{uri.path}" rescue uri.to_s
+        { method: req.method, url: url }
+      end
+    end
+  end
+end
+
+Sentry.register_patch do
+  patch = Sentry::Net::HTTP
+  Net::HTTP.send(:prepend, patch) unless Net::HTTP.ancestors.include?(patch)
+end

data/lib/sentry/scope.rb

@@ -130,6 +130,7 @@ module Sentry
     end
 
     def set_context(key, value)
+      check_argument_type!(value, Hash)
       @contexts.merge!(key => value)
     end
 

data/lib/sentry/span.rb

@@ -21,7 +21,16 @@ module Sentry
     attr_reader :trace_id, :span_id, :parent_span_id, :sampled, :start_timestamp, :timestamp, :description, :op, :status, :tags, :data
     attr_accessor :span_recorder, :transaction
 
-    def initialize(description: nil, op: nil, status: nil, trace_id: nil, parent_span_id: nil, sampled: nil, start_timestamp: nil, timestamp: nil)
+    def initialize(
+      description: nil,
+      op: nil,
+      status: nil,
+      trace_id: nil,
+      parent_span_id: nil,
+      sampled: nil,
+      start_timestamp: nil,
+      timestamp: nil
+    )
       @trace_id = trace_id || SecureRandom.uuid.delete("-")
       @span_id = SecureRandom.hex(8)
       @parent_span_id = parent_span_id

data/lib/sentry/transaction.rb

@@ -10,19 +10,24 @@ module Sentry
     UNLABELD_NAME = "<unlabeled transaction>".freeze
     MESSAGE_PREFIX = "[Tracing]"
 
-    attr_reader :name, :parent_sampled
+    include LoggingHelper
 
-    def initialize(name: nil, parent_sampled: nil, **options)
+    attr_reader :name, :parent_sampled, :hub, :configuration, :logger
+
+    def initialize(name: nil, parent_sampled: nil, hub:, **options)
       super(**options)
 
       @name = name
       @parent_sampled = parent_sampled
       @transaction = self
+      @hub = hub
+      @configuration = hub.configuration
+      @logger = configuration.logger
       init_span_recorder
     end
 
-    def self.from_sentry_trace(sentry_trace, configuration: Sentry.configuration, **options)
-      return unless configuration.tracing_enabled?
+    def self.from_sentry_trace(sentry_trace, hub: Sentry.get_current_hub, **options)
+      return unless hub.configuration.tracing_enabled?
       return unless sentry_trace
 
       match = SENTRY_TRACE_REGEXP.match(sentry_trace)
@@ -36,7 +41,7 @@ module Sentry
           sampled_flag != "0"
         end
 
-      new(trace_id: trace_id, parent_span_id: parent_span_id, parent_sampled: parent_sampled, **options)
+      new(trace_id: trace_id, parent_span_id: parent_span_id, parent_sampled: parent_sampled, hub: hub, **options)
     end
 
     def to_hash
@@ -58,7 +63,7 @@ module Sentry
       copy
     end
 
-    def set_initial_sample_decision(sampling_context:, configuration: Sentry.configuration)
+    def set_initial_sample_decision(sampling_context:)
       unless configuration.tracing_enabled?
         @sampled = false
         return
@@ -78,17 +83,16 @@ module Sentry
         end
 
       transaction_description = generate_transaction_description
-      logger = configuration.logger
 
       unless [true, false].include?(sample_rate) || (sample_rate.is_a?(Numeric) && sample_rate >= 0.0 && sample_rate <= 1.0)
         @sampled = false
-        logger.warn("#{MESSAGE_PREFIX} Discarding #{transaction_description} because of invalid sample_rate: #{sample_rate}")
+        log_warn("#{MESSAGE_PREFIX} Discarding #{transaction_description} because of invalid sample_rate: #{sample_rate}")
         return
       end
 
       if sample_rate == 0.0 || sample_rate == false
         @sampled = false
-        logger.debug("#{MESSAGE_PREFIX} Discarding #{transaction_description} because traces_sampler returned 0 or false")
+        log_debug("#{MESSAGE_PREFIX} Discarding #{transaction_description} because traces_sampler returned 0 or false")
         return
       end
 
@@ -99,15 +103,26 @@ module Sentry
       end
 
       if @sampled
-        logger.debug("#{MESSAGE_PREFIX} Starting #{transaction_description}")
+        log_debug("#{MESSAGE_PREFIX} Starting #{transaction_description}")
       else
-        logger.debug(
+        log_debug(
           "#{MESSAGE_PREFIX} Discarding #{transaction_description} because it's not included in the random sample (sampling rate = #{sample_rate})"
         )
       end
     end
 
     def finish(hub: nil)
+      if hub
+        log_warn(
+          <<~MSG
+            Specifying a different hub in `Transaction#finish` will be deprecated in version 5.0.
+            Please use `Hub#start_transaction` with the designated hub.
+          MSG
+        )
+      end
+
+      hub ||= @hub
+
       super() # Span#finish doesn't take arguments
 
       if @name.nil?
@@ -116,7 +131,6 @@ module Sentry
 
       return unless @sampled || @parent_sampled
 
-      hub ||= Sentry.get_current_hub
       event = hub.current_client.event_from_transaction(self)
       hub.capture_event(event)
     end

data/lib/sentry/transport.rb

@@ -3,15 +3,20 @@ require "base64"
 
 module Sentry
   class Transport
-    PROTOCOL_VERSION = '5'
+    PROTOCOL_VERSION = '7'
     USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
 
+    include LoggingHelper
+
     attr_accessor :configuration
+    attr_reader :logger, :rate_limits
 
     def initialize(configuration)
       @configuration = configuration
+      @logger = configuration.logger
       @transport_configuration = configuration.transport
       @dsn = configuration.dsn
+      @rate_limits = {}
     end
 
     def send_data(data, options = {})
@@ -19,8 +24,18 @@ module Sentry
     end
 
     def send_event(event)
+      event_hash = event.to_hash
+      item_type = get_item_type(event_hash)
+
       unless configuration.sending_allowed?
-        configuration.logger.debug(LOGGER_PROGNAME) { "Event not sent: #{configuration.error_messages}" }
+        log_debug("Envelope [#{item_type}] not sent: #{configuration.error_messages}")
+
+        return
+      end
+
+      if is_rate_limited?(item_type)
+        log_info("Envelope [#{item_type}] not sent: rate limiting")
+
         return
       end
 
@@ -33,6 +48,35 @@ module Sentry
       event
     end
 
+    def is_rate_limited?(item_type)
+      # check category-specific limit
+      category_delay =
+        case item_type
+        when "transaction"
+          @rate_limits["transaction"]
+        else
+          @rate_limits["error"]
+        end
+
+      # check universal limit if not category limit
+      universal_delay = @rate_limits[nil]
+
+      delay =
+        if category_delay && universal_delay
+          if category_delay > universal_delay
+            category_delay
+          else
+            universal_delay
+          end
+        elsif category_delay
+          category_delay
+        else
+          universal_delay
+        end
+
+      !!delay && delay > Time.now
+    end
+
     def generate_auth_header
       now = Sentry.utc_now.to_i
       fields = {
@@ -50,7 +94,7 @@ module Sentry
       event_hash = event.to_hash
 
       event_id = event_hash[:event_id] || event_hash["event_id"]
-      item_type = event_hash[:type] || event_hash["type"] || "event"
+      item_type = get_item_type(event_hash)
 
       envelope = <<~ENVELOPE
         {"event_id":"#{event_id}","dsn":"#{configuration.dsn.to_s}","sdk":#{Sentry.sdk_meta.to_json},"sent_at":"#{Sentry.utc_now.iso8601}"}
@@ -58,10 +102,16 @@ module Sentry
         #{JSON.generate(event_hash)}
       ENVELOPE
 
-      configuration.logger.info(LOGGER_PROGNAME) { "Sending envelope [#{item_type}] #{event_id} to Sentry" }
+      log_info("Sending envelope [#{item_type}] #{event_id} to Sentry")
 
       envelope
     end
+
+    private
+
+    def get_item_type(event_hash)
+      event_hash[:type] || event_hash["type"] || "event"
+    end
   end
 end
 

data/lib/sentry/transport/http_transport.rb

@@ -7,6 +7,10 @@ module Sentry
     GZIP_THRESHOLD = 1024 * 30
     CONTENT_TYPE = 'application/x-sentry-envelope'
 
+    DEFAULT_DELAY = 60
+    RETRY_AFTER_HEADER = "retry-after"
+    RATE_LIMIT_HEADER = "x-sentry-rate-limits"
+
     attr_reader :conn, :adapter
 
     def initialize(*args)
@@ -24,18 +28,26 @@ module Sentry
         encoding = GZIP_ENCODING
       end
 
-      conn.post @endpoint do |req|
+      response = conn.post @endpoint do |req|
         req.headers['Content-Type'] = CONTENT_TYPE
         req.headers['Content-Encoding'] = encoding
         req.headers['X-Sentry-Auth'] = generate_auth_header
         req.body = data
       end
+
+      if has_rate_limited_header?(response.headers)
+        handle_rate_limited_response(response.headers)
+      end
     rescue Faraday::Error => e
       error_info = e.message
 
       if e.response
-        error_info += "\nbody: #{e.response[:body]}"
-        error_info += " Error in headers is: #{e.response[:headers]['x-sentry-error']}" if e.response[:headers]['x-sentry-error']
+        if e.response[:status] == 429
+          handle_rate_limited_response(e.response[:headers])
+        else
+          error_info += "\nbody: #{e.response[:body]}"
+          error_info += " Error in headers is: #{e.response[:headers]['x-sentry-error']}" if e.response[:headers]['x-sentry-error']
+        end
       end
 
       raise Sentry::ExternalError, error_info
@@ -43,6 +55,64 @@ module Sentry
 
     private
 
+    def has_rate_limited_header?(headers)
+      headers[RETRY_AFTER_HEADER] || headers[RATE_LIMIT_HEADER]
+    end
+
+    def handle_rate_limited_response(headers)
+      rate_limits =
+        if rate_limits = headers[RATE_LIMIT_HEADER]
+          parse_rate_limit_header(rate_limits)
+        elsif retry_after = headers[RETRY_AFTER_HEADER]
+          # although Sentry doesn't send a date string back
+          # based on HTTP specification, this could be a date string (instead of an integer)
+          retry_after = retry_after.to_i
+          retry_after = DEFAULT_DELAY if retry_after == 0
+
+          { nil => Time.now + retry_after }
+        else
+          { nil => Time.now + DEFAULT_DELAY }
+        end
+
+      rate_limits.each do |category, limit|
+        if current_limit = @rate_limits[category]
+          if current_limit < limit
+            @rate_limits[category] = limit
+          end
+        else
+          @rate_limits[category] = limit
+        end
+      end
+    end
+
+    def parse_rate_limit_header(rate_limit_header)
+      time = Time.now
+
+      result = {}
+
+      limits = rate_limit_header.split(",")
+      limits.each do |limit|
+        next if limit.nil? || limit.empty?
+
+        begin
+          retry_after, categories = limit.strip.split(":").first(2)
+          retry_after = time + retry_after.to_i
+          categories = categories.split(";")
+
+          if categories.empty?
+            result[nil] = retry_after
+          else
+            categories.each do |category|
+              result[category] = retry_after
+            end
+          end
+        rescue StandardError
+        end
+      end
+
+      result
+    end
+
     def should_compress?(data)
       @transport_configuration.encoding == GZIP_ENCODING && data.bytesize >= GZIP_THRESHOLD
     end
@@ -50,7 +120,7 @@ module Sentry
     def set_conn
       server = @dsn.server
 
-      configuration.logger.debug(LOGGER_PROGNAME) { "Sentry HTTP Transport connecting to #{server}" }
+      log_debug("Sentry HTTP Transport connecting to #{server}")
 
       Faraday.new(server, :ssl => ssl_configuration, :proxy => @transport_configuration.proxy) do |builder|
         @transport_configuration.faraday_builder&.call(builder)

data/lib/sentry/utils/logging_helper.rb

@@ -0,0 +1,24 @@
+module Sentry
+  module LoggingHelper
+    def log_error(message, exception, debug: false)
+      message = "#{message}: #{exception.message}"
+      message += "\n#{exception.backtrace.join("\n")}" if debug
+
+      logger.error(LOGGER_PROGNAME) do
+        message
+      end
+    end
+
+    def log_info(message)
+      logger.info(LOGGER_PROGNAME) { message }
+    end
+
+    def log_debug(message)
+      logger.debug(LOGGER_PROGNAME) { message }
+    end
+
+    def log_warn(message)
+      logger.warn(LOGGER_PROGNAME) { message }
+    end
+  end
+end

data/lib/sentry/version.rb

@@ -1,3 +1,3 @@
 module Sentry
-  VERSION = "4.3.2"
+  VERSION = "4.5.0-beta.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby-core
 version: !ruby/object:Gem::Version
-  version: 4.3.2
+  version: 4.5.0.pre.beta.1
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-06 00:00:00.000000000 Z
+date: 2021-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -83,6 +83,7 @@ files:
 - lib/sentry/interfaces/threads.rb
 - lib/sentry/linecache.rb
 - lib/sentry/logger.rb
+- lib/sentry/net/http.rb
 - lib/sentry/rack.rb
 - lib/sentry/rack/capture_exceptions.rb
 - lib/sentry/rack/deprecations.rb
@@ -97,6 +98,7 @@ files:
 - lib/sentry/transport/http_transport.rb
 - lib/sentry/utils/argument_checking_helper.rb
 - lib/sentry/utils/exception_cause_chain.rb
+- lib/sentry/utils/logging_helper.rb
 - lib/sentry/utils/real_ip.rb
 - lib/sentry/utils/request_id.rb
 - lib/sentry/version.rb
@@ -120,11 +122,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3.1
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A gem that provides a client interface for the Sentry error logger