sentry-ruby-core 4.3.2 → 4.4.0.pre.beta.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85c558cf77534e3d3fea7d30e417171302f485042b8a09b3a1114c714f1b17ec
-  data.tar.gz: d8077c3cfee56f1427d03770dc8d28e9920bbba4d97e14e983d3b7a5a949be95
+  metadata.gz: cb17ca62057f29a255a7d725bd574775d840e987cbc3c067a9294b63311d26aa
+  data.tar.gz: 9268967f80f8406bbcf3bf2b0dc150567b3adc16d1c4b38fd8ef5df5a1559737
 SHA512:
-  metadata.gz: 9cc8fa4030f678d6b2cd34d1c5752e4da6065527ed598e6f43a14ab6adcb44fbe4f104b99de9dd65d45995f726fc074bf3944891348ce4491a385ce22acfa493
-  data.tar.gz: 8fc20069fbddcb6dba3206ea8d7578c9da54f5a0812c0388e9e1afc983befcaaaa3d32390af78b6f3bee6294e997455dbcc807d7543380bc20740b314534dd7b
+  metadata.gz: 3d57f757d5d7c36c24bf296fbb673c8afe20fb3fadc89c1a1f4046856188286f9db9c7fdd2b6c3d49e921a302f179f1c4acef4ac737b802cc0640e979eab0de8
+  data.tar.gz: e5900027bce05c31a9bd10ea6fb2f660deee1494e37545a0637ea89767353add86b39fc4dde07de0c4ac9fcadb2f2d2bc8441308d4f89396e5c5de124ed7f445

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,7 @@ targets:
       type: sdk
       config:
           canonical: 'gem:sentry-ruby-core'
+    - name: github
+      onlyIfPresent: /^sentry-ruby-core-\d.*\.gem$/
+      tagPrefix: sentry-ruby-v
+      changelog: sentry-ruby/CHANGELOG.md

data/CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## 4.4.0-beta.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)
+
 ## 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,8 @@ 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/net/http"
 require "sentry/configuration"
 require "sentry/logger"
 require "sentry/event"

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)
@@ -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,8 +88,10 @@ 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
 
@@ -112,9 +116,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
 
@@ -167,13 +172,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 = []
@@ -226,10 +230,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 +278,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 +293,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)
     end
 
     def stacktrace_builder
@@ -314,7 +314,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 +349,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,87 @@
+require "net/http"
+
+module Sentry
+  module Net
+    module HTTP
+      OP_NAME = "net.http"
+
+      def request(req, body = nil, &block)
+        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 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_host = Sentry.configuration.dsn.host
+        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
+
+Net::HTTP.send(:prepend, Sentry::Net::HTTP)

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

@@ -6,12 +6,17 @@ module Sentry
     PROTOCOL_VERSION = '5'
     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.4.0-beta.0"
 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.4.0.pre.beta.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-06 00:00:00.000000000 Z
+date: 2021-04-23 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,9 +122,9 @@ 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
 signing_key: