sentry-ruby 5.14.0 → 5.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95fd53222ce5360d32645f0bc7577792bdef0a02b9e4b8de27555eabd2ef1844
-  data.tar.gz: e5eb696315a22747051e5bbdeac314c5ae103cabd59d3fb266b16b0b22345611
+  metadata.gz: 565289974a80625ef7ecac6926cfb7292569dfafd84f12584a8214619bdd5ed5
+  data.tar.gz: 005b3e5c27b7188058c412d36981779eb759f7be1032429eea17a2e4a7ffcb9f
 SHA512:
-  metadata.gz: f18df0d05208c0a03352501b4b746f6ccc74799b234198b67b35e709539fde52aa36c56a6297510e8e9e1dc8a62658ac5d81e0023c5935de455effc16ee824fe
-  data.tar.gz: 47f5db68454ab971d92df8c7fbd95846830edfe09b6b2ea40fef1f5ab39a9db922a5564abe45b29fb55df729bdf53bb1632c566c93b8b7f0d1c96e00c441d0dc
+  metadata.gz: d0e68db7961263d6aa070feaa131fae4c2039884e565cd248795298a99f08d66e7c921df1a6f6175e68ac0ed554185b4b94769f8b0fcba12d76e6aa042fc3359
+  data.tar.gz: 5e10f1406d7a7809aed02cef80e1d4355e61af54ed42ffd9a1b3a54a730229abfef4f0a690980c646757b93fffa6219d6500c5700b08a6eef61b6eb682d63620

data/Gemfile

@@ -12,28 +12,9 @@ gem "redis", "~> #{redis_rb_version}"
 
 gem "puma"
 
-gem "rake", "~> 12.0"
-gem "rspec", "~> 3.0"
-gem "rspec-retry"
 gem "timecop"
-gem "simplecov"
-gem "simplecov-cobertura", "~> 1.4"
-gem "rexml"
 gem "stackprof" unless RUBY_PLATFORM == "java"
 
-ruby_version = Gem::Version.new(RUBY_VERSION)
-
-if ruby_version >= Gem::Version.new("2.6.0")
-  gem "debug", github: "ruby/debug", platform: :ruby
-  gem "irb"
-
-  if ruby_version >= Gem::Version.new("3.0.0")
-    gem "ruby-lsp-rspec"
-  end
-end
-
-gem "pry"
-
 gem "benchmark-ips"
 gem "benchmark_driver"
 gem "benchmark-ipsa"
@@ -41,3 +22,5 @@ gem "benchmark-memory"
 
 gem "yard", github: "lsegal/yard"
 gem "webrick"
+
+eval_gemfile File.expand_path("../Gemfile", __dir__)

data/lib/sentry/background_worker.rb

@@ -13,10 +13,12 @@ module Sentry
     attr_reader :logger
     attr_accessor :shutdown_timeout
 
+    DEFAULT_MAX_QUEUE = 30
+
     def initialize(configuration)
-      @max_queue = 30
       @shutdown_timeout = 1
       @number_of_threads = configuration.background_worker_threads
+      @max_queue = configuration.background_worker_max_queue
       @logger = configuration.logger
       @debug = configuration.debug
       @shutdown_callback = nil
@@ -63,6 +65,11 @@ module Sentry
       @shutdown_callback&.call
     end
 
+    def full?
+      @executor.is_a?(Concurrent::ThreadPoolExecutor) &&
+        @executor.remaining_capacity == 0
+    end
+
     private
 
     def _perform(&block)

data/lib/sentry/backpressure_monitor.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Sentry
+  class BackpressureMonitor
+    include LoggingHelper
+
+    DEFAULT_INTERVAL = 10
+    MAX_DOWNSAMPLE_FACTOR = 10
+
+    def initialize(configuration, client, interval: DEFAULT_INTERVAL)
+      @interval = interval
+      @client = client
+      @logger = configuration.logger
+
+      @thread = nil
+      @exited = false
+
+      @healthy = true
+      @downsample_factor = 0
+    end
+
+    def healthy?
+      ensure_thread
+      @healthy
+    end
+
+    def downsample_factor
+      ensure_thread
+      @downsample_factor
+    end
+
+    def run
+      check_health
+      set_downsample_factor
+    end
+
+    def check_health
+      @healthy = !(@client.transport.any_rate_limited? || Sentry.background_worker&.full?)
+    end
+
+    def set_downsample_factor
+      if @healthy
+        log_debug("[BackpressureMonitor] health check positive, reverting to normal sampling") if @downsample_factor.positive?
+        @downsample_factor = 0
+      else
+        @downsample_factor += 1 if @downsample_factor < MAX_DOWNSAMPLE_FACTOR
+        log_debug("[BackpressureMonitor] health check negative, downsampling with a factor of #{@downsample_factor}")
+      end
+    end
+
+    def kill
+      log_debug("[BackpressureMonitor] killing monitor")
+
+      @exited = true
+      @thread&.kill
+    end
+
+    private
+
+    def ensure_thread
+      return if @exited
+      return if @thread&.alive?
+
+      @thread = Thread.new do
+        loop do
+          sleep(@interval)
+          run
+        end
+      end
+    rescue ThreadError
+      log_debug("[BackpressureMonitor] Thread creation failed")
+      @exited = true
+    end
+  end
+end

data/lib/sentry/client.rb

@@ -10,6 +10,10 @@ module Sentry
     # @return [Transport]
     attr_reader :transport
 
+    # The Transport object that'll send events for the client.
+    # @return [SpotlightTransport, nil]
+    attr_reader :spotlight_transport
+
     # @!macro configuration
     attr_reader :configuration
 
@@ -32,6 +36,8 @@ module Sentry
             DummyTransport.new(configuration)
           end
       end
+
+      @spotlight_transport = SpotlightTransport.new(configuration) if configuration.spotlight
     end
 
     # Applies the given scope's data to the event and sends it to Sentry.
@@ -42,7 +48,7 @@ module Sentry
     def capture_event(event, scope, hint = {})
       return unless configuration.sending_allowed?
 
-      unless event.is_a?(TransactionEvent) || configuration.sample_allowed?
+      if event.is_a?(ErrorEvent) && !configuration.sample_allowed?
         transport.record_lost_event(:sample_rate, 'event')
         return
       end
@@ -51,7 +57,7 @@ module Sentry
       event = scope.apply_to_event(event, hint)
 
       if event.nil?
-        log_info("Discarded event because one of the event processors returned nil")
+        log_debug("Discarded event because one of the event processors returned nil")
         transport.record_lost_event(:event_processor, event_type)
         return
       end
@@ -150,7 +156,7 @@ module Sentry
         event = configuration.before_send.call(event, hint)
 
         if event.nil?
-          log_info("Discarded event because before_send returned nil")
+          log_debug("Discarded event because before_send returned nil")
           transport.record_lost_event(:before_send, 'event')
           return
         end
@@ -160,21 +166,18 @@ module Sentry
         event = configuration.before_send_transaction.call(event, hint)
 
         if event.nil?
-          log_info("Discarded event because before_send_transaction returned nil")
+          log_debug("Discarded event because before_send_transaction returned nil")
           transport.record_lost_event(:before_send, 'transaction')
           return
         end
       end
 
       transport.send_event(event)
+      spotlight_transport&.send_event(event)
 
       event
     rescue => e
-      loggable_event_type = event_type.capitalize
-      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}")
+      log_error("Event sending failed", e, debug: configuration.debug)
       transport.record_lost_event(:network_error, event_type)
       raise
     end

data/lib/sentry/configuration.rb

@@ -7,6 +7,7 @@ require 'sentry/utils/custom_inspection'
 require "sentry/dsn"
 require "sentry/release_detector"
 require "sentry/transport/configuration"
+require "sentry/cron/configuration"
 require "sentry/linecache"
 require "sentry/interfaces/stacktrace_builder"
 
@@ -40,6 +41,13 @@ module Sentry
     # @return [Integer]
     attr_accessor :background_worker_threads
 
+    # The maximum queue size for the background worker.
+    # Jobs will be rejected above this limit.
+    #
+    # Default is {BackgroundWorker::DEFAULT_MAX_QUEUE}.
+    # @return [Integer]
+    attr_accessor :background_worker_max_queue
+
     # a proc/lambda that takes an array of stack traces
     # it'll be used to silence (reduce) backtrace of the exception
     #
@@ -142,6 +150,14 @@ module Sentry
     # @return [Boolean]
     attr_accessor :include_local_variables
 
+    # Whether to capture events and traces into Spotlight. Default is false.
+    # If you set this to true, Sentry will send events and traces to the local
+    # Sidecar proxy at http://localhost:8969/stream.
+    # If you want to use a different Sidecar proxy address, set this to String
+    # with the proxy URL.
+    # @return [Boolean, String]
+    attr_accessor :spotlight
+
     # @deprecated Use {#include_local_variables} instead.
     alias_method :capture_exception_frame_locals, :include_local_variables
 
@@ -211,10 +227,14 @@ module Sentry
     # @return [String]
     attr_accessor :server_name
 
-    # Return a Transport::Configuration object for transport-related configurations.
-    # @return [Transport]
+    # Transport related configuration.
+    # @return [Transport::Configuration]
     attr_reader :transport
 
+    # Cron related configuration.
+    # @return [Cron::Configuration]
+    attr_reader :cron
+
     # Take a float between 0.0 and 1.0 as the sample rate for tracing events (transactions).
     # @return [Float, nil]
     attr_reader :traces_sample_rate
@@ -243,6 +263,12 @@ module Sentry
     # @return [Boolean]
     attr_accessor :auto_session_tracking
 
+    # Whether to downsample transactions automatically because of backpressure.
+    # Starts a new monitor thread to check health of the SDK every 10 seconds.
+    # Default is false
+    # @return [Boolean]
+    attr_accessor :enable_backpressure_handling
+
     # Allowlist of outgoing request targets to which sentry-trace and baggage headers are attached.
     # Default is all (/.*/)
     # @return [Array<String, Regexp>]
@@ -321,6 +347,7 @@ module Sentry
       self.app_dirs_pattern = nil
       self.debug = false
       self.background_worker_threads = Concurrent.processor_count
+      self.background_worker_max_queue = BackgroundWorker::DEFAULT_MAX_QUEUE
       self.backtrace_cleanup_callback = nil
       self.max_breadcrumbs = BreadcrumbBuffer::DEFAULT_SIZE
       self.breadcrumbs_logger = []
@@ -342,8 +369,10 @@ module Sentry
       self.skip_rake_integration = false
       self.send_client_reports = true
       self.auto_session_tracking = true
+      self.enable_backpressure_handling = false
       self.trusted_proxies = []
       self.dsn = ENV['SENTRY_DSN']
+      self.spotlight = false
       self.server_name = server_name_from_env
       self.instrumenter = :sentry
       self.trace_propagation_targets = [PROPAGATION_TARGETS_MATCH_ALL]
@@ -356,6 +385,7 @@ module Sentry
       self.enable_tracing = nil
 
       @transport = Transport::Configuration.new
+      @cron = Cron::Configuration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
 
       run_post_initialization_callbacks
@@ -444,14 +474,14 @@ module Sentry
 
     def profiles_sample_rate=(profiles_sample_rate)
       raise ArgumentError, "profiles_sample_rate must be a Numeric or nil" unless is_numeric_or_nil?(profiles_sample_rate)
-      log_info("Please make sure to include the 'stackprof' gem in your Gemfile to use Profiling with Sentry.") unless defined?(StackProf)
+      log_warn("Please make sure to include the 'stackprof' gem in your Gemfile to use Profiling with Sentry.") unless defined?(StackProf)
       @profiles_sample_rate = profiles_sample_rate
     end
 
     def sending_allowed?
       @errors = []
 
-      valid? && capture_in_environment?
+      spotlight || (valid? && capture_in_environment?)
     end
 
     def sample_allowed?

data/lib/sentry/cron/configuration.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Cron
+    class Configuration
+      # Defaults set here will apply to all {Cron::MonitorConfig} objects unless overwritten.
+
+      # How long (in minutes) after the expected checkin time will we wait
+      # until we consider the checkin to have been missed.
+      # @return [Integer, nil]
+      attr_accessor :default_checkin_margin
+
+      # How long (in minutes) is the checkin allowed to run for in in_progress
+      # before it is considered failed.
+      # @return [Integer, nil]
+      attr_accessor :default_max_runtime
+
+      # tz database style timezone string
+      # @return [String, nil]
+      attr_accessor :default_timezone
+    end
+  end
+end

data/lib/sentry/cron/monitor_check_ins.rb

@@ -4,7 +4,7 @@ module Sentry
       MAX_SLUG_LENGTH = 50
 
       module Patch
-        def perform(*args)
+        def perform(*args, **opts)
           slug = self.class.sentry_monitor_slug
           monitor_config = self.class.sentry_monitor_config
 
@@ -13,38 +13,49 @@ module Sentry
                                                 monitor_config: monitor_config)
 
           start = Sentry.utc_now.to_i
-          ret = super
-          duration = Sentry.utc_now.to_i - start
 
-          Sentry.capture_check_in(slug,
-                                  :ok,
-                                  check_in_id: check_in_id,
-                                  duration: duration,
-                                  monitor_config: monitor_config)
+          begin
+            # need to do this on ruby <= 2.6 sadly
+            ret = method(:perform).super_method.arity == 0 ? super() : super
+            duration = Sentry.utc_now.to_i - start
 
-          ret
-        rescue Exception
-          duration = Sentry.utc_now.to_i - start
+            Sentry.capture_check_in(slug,
+                                    :ok,
+                                    check_in_id: check_in_id,
+                                    duration: duration,
+                                    monitor_config: monitor_config)
 
-          Sentry.capture_check_in(slug,
-                                  :error,
-                                  check_in_id: check_in_id,
-                                  duration: duration,
-                                  monitor_config: monitor_config)
+            ret
+          rescue Exception
+            duration = Sentry.utc_now.to_i - start
 
-          raise
+            Sentry.capture_check_in(slug,
+                                    :error,
+                                    check_in_id: check_in_id,
+                                    duration: duration,
+                                    monitor_config: monitor_config)
+
+            raise
+          end
         end
       end
 
       module ClassMethods
         def sentry_monitor_check_ins(slug: nil, monitor_config: nil)
+          if monitor_config && Sentry.configuration
+            cron_config = Sentry.configuration.cron
+            monitor_config.checkin_margin ||= cron_config.default_checkin_margin
+            monitor_config.max_runtime ||= cron_config.default_max_runtime
+            monitor_config.timezone ||= cron_config.default_timezone
+          end
+
           @sentry_monitor_slug = slug
           @sentry_monitor_config = monitor_config
 
           prepend Patch
         end
 
-        def sentry_monitor_slug
+        def sentry_monitor_slug(name: self.name)
           @sentry_monitor_slug ||= begin
             slug = name.gsub('::', '-').downcase
             slug[-MAX_SLUG_LENGTH..-1] || slug
@@ -56,8 +67,6 @@ module Sentry
         end
       end
 
-      extend ClassMethods
-
       def self.included(base)
         base.extend(ClassMethods)
       end

data/lib/sentry/event.rb

@@ -76,34 +76,6 @@ module Sentry
       @message = (message || "").byteslice(0..MAX_MESSAGE_SIZE_IN_BYTES)
     end
 
-    class << self
-      # @!visibility private
-      def get_log_message(event_hash)
-        message = event_hash[:message] || event_hash['message']
-
-        return message unless message.nil? || message.empty?
-
-        message = get_message_from_exception(event_hash)
-
-        return message unless message.nil? || message.empty?
-
-        message = event_hash[:transaction] || event_hash["transaction"]
-
-        return message unless message.nil? || message.empty?
-
-        '<no message value>'
-      end
-
-      # @!visibility private
-      def get_message_from_exception(event_hash)
-        if exception = event_hash.dig(:exception, :values, 0)
-          "#{exception[:type]}: #{exception[:value]}"
-        elsif exception = event_hash.dig("exception", "values", 0)
-          "#{exception["type"]}: #{exception["value"]}"
-        end
-      end
-    end
-
     # @deprecated This method will be removed in v5.0.0. Please just use Sentry.configuration
     # @return [Configuration]
     def configuration

data/lib/sentry/hub.rb

@@ -156,7 +156,7 @@ module Sentry
       capture_event(event, **options, &block)
     end
 
-    def capture_check_in(slug, status, **options, &block)
+    def capture_check_in(slug, status, **options)
       check_argument_type!(slug, ::String)
       check_argument_includes!(status, Sentry::CheckInEvent::VALID_STATUSES)
 
@@ -176,7 +176,7 @@ module Sentry
 
       return unless event
 
-      capture_event(event, **options, &block)
+      capture_event(event, **options)
       event.check_in_id
     end
 

data/lib/sentry/rake.rb

@@ -17,15 +17,6 @@ module Sentry
         super
       end
     end
-
-    module Task
-      # @api private
-      def execute(args=nil)
-        return super unless Sentry.initialized? && Sentry.get_current_hub
-
-        super
-      end
-    end
   end
 end
 
@@ -34,8 +25,4 @@ module Rake
   class Application
     prepend(Sentry::Rake::Application)
   end
-
-  class Task
-    prepend(Sentry::Rake::Task)
-  end
 end

data/lib/sentry/scope.rb

@@ -44,12 +44,18 @@ module Sentry
     # @param hint [Hash] the hint data that'll be passed to event processors.
     # @return [Event]
     def apply_to_event(event, hint = nil)
-      event.tags = tags.merge(event.tags)
-      event.user = user.merge(event.user)
-      event.extra = extra.merge(event.extra)
-      event.contexts = contexts.merge(event.contexts)
-      event.transaction = transaction_name if transaction_name
-      event.transaction_info = { source: transaction_source } if transaction_source
+      unless event.is_a?(CheckInEvent)
+        event.tags = tags.merge(event.tags)
+        event.user = user.merge(event.user)
+        event.extra = extra.merge(event.extra)
+        event.contexts = contexts.merge(event.contexts)
+        event.transaction = transaction_name if transaction_name
+        event.transaction_info = { source: transaction_source } if transaction_source
+        event.fingerprint = fingerprint
+        event.level = level
+        event.breadcrumbs = breadcrumbs
+        event.rack_env = rack_env if rack_env
+      end
 
       if span
         event.contexts[:trace] ||= span.get_trace_context
@@ -58,11 +64,6 @@ module Sentry
         event.dynamic_sampling_context ||= propagation_context.get_dynamic_sampling_context
       end
 
-      event.fingerprint = fingerprint
-      event.level = level
-      event.breadcrumbs = breadcrumbs
-      event.rack_env = rack_env if rack_env
-
       all_event_processors = self.class.global_event_processors + @event_processors
 
       unless all_event_processors.empty?

data/lib/sentry/transaction.rb

@@ -218,7 +218,12 @@ module Sentry
       if sample_rate == true
         @sampled = true
       else
-        @sampled = Random.rand < sample_rate
+        if Sentry.backpressure_monitor
+          factor = Sentry.backpressure_monitor.downsample_factor
+          @effective_sample_rate /= 2**factor
+        end
+
+        @sampled = Random.rand < @effective_sample_rate
       end
 
       if @sampled
@@ -257,7 +262,9 @@ module Sentry
         event = hub.current_client.event_from_transaction(self)
         hub.capture_event(event)
       else
-        hub.current_client.transport.record_lost_event(:sample_rate, 'transaction')
+        is_backpressure = Sentry.backpressure_monitor&.downsample_factor&.positive?
+        reason = is_backpressure ? :backpressure : :sample_rate
+        hub.current_client.transport.record_lost_event(reason, 'transaction')
       end
     end
 

data/lib/sentry/transport/http_transport.rb

@@ -14,11 +14,19 @@ module Sentry
     RATE_LIMIT_HEADER = "x-sentry-rate-limits"
     USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
 
+    # The list of errors ::Net::HTTP is known to raise
+    # See https://github.com/ruby/ruby/blob/b0c639f249165d759596f9579fa985cb30533de6/lib/bundler/fetcher.rb#L281-L286
+    HTTP_ERRORS = [
+      Timeout::Error, EOFError, SocketError, Errno::ENETDOWN, Errno::ENETUNREACH,
+      Errno::EINVAL, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EAGAIN,
+      Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
+      Zlib::BufError, Errno::EHOSTUNREACH, Errno::ECONNREFUSED
+    ].freeze
+
+
     def initialize(*args)
       super
-      @endpoint = @dsn.envelope_endpoint
-
-      log_debug("Sentry HTTP Transport will connect to #{@dsn.server}")
+      log_debug("Sentry HTTP Transport will connect to #{@dsn.server}") if @dsn
     end
 
     def send_data(data)
@@ -32,34 +40,76 @@ module Sentry
       headers = {
         'Content-Type' => CONTENT_TYPE,
         'Content-Encoding' => encoding,
-        'X-Sentry-Auth' => generate_auth_header,
         'User-Agent' => USER_AGENT
       }
 
+      auth_header = generate_auth_header
+      headers['X-Sentry-Auth'] = auth_header if auth_header
+
       response = conn.start do |http|
-        request = ::Net::HTTP::Post.new(@endpoint, headers)
+        request = ::Net::HTTP::Post.new(endpoint, headers)
         request.body = data
         http.request(request)
       end
 
       if response.code.match?(/\A2\d{2}/)
-        if has_rate_limited_header?(response)
-          handle_rate_limited_response(response)
-        end
+        handle_rate_limited_response(response) if has_rate_limited_header?(response)
+      elsif response.code == "429"
+        log_debug("the server responded with status 429")
+        handle_rate_limited_response(response)
       else
         error_info = "the server responded with status #{response.code}"
+        error_info += "\nbody: #{response.body}"
+        error_info += " Error in headers is: #{response['x-sentry-error']}" if response['x-sentry-error']
+
+        raise Sentry::ExternalError, error_info
+      end
+    rescue SocketError, *HTTP_ERRORS => e
+      on_error if respond_to?(:on_error)
+      raise Sentry::ExternalError.new(e&.message)
+    end
+
+    def endpoint
+      @dsn.envelope_endpoint
+    end
+
+    def generate_auth_header
+      return nil unless @dsn
+
+      now = Sentry.utc_now.to_i
+      fields = {
+        'sentry_version' => PROTOCOL_VERSION,
+        'sentry_client' => USER_AGENT,
+        'sentry_timestamp' => now,
+        'sentry_key' => @dsn.public_key
+      }
+      fields['sentry_secret'] = @dsn.secret_key if @dsn.secret_key
+      'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
+    end
 
-        if response.code == "429"
-          handle_rate_limited_response(response)
+    def conn
+      server = URI(@dsn.server)
+
+      # connection respects proxy setting from @transport_configuration, or environment variables (HTTP_PROXY, HTTPS_PROXY, NO_PROXY)
+      # Net::HTTP will automatically read the env vars.
+      # See https://ruby-doc.org/3.2.2/stdlibs/net/Net/HTTP.html#class-Net::HTTP-label-Proxies
+      connection =
+        if proxy = normalize_proxy(@transport_configuration.proxy)
+          ::Net::HTTP.new(server.hostname, server.port, proxy[:uri].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
         else
-          error_info += "\nbody: #{response.body}"
-          error_info += " Error in headers is: #{response['x-sentry-error']}" if response['x-sentry-error']
+          ::Net::HTTP.new(server.hostname, server.port)
         end
 
-        raise Sentry::ExternalError, error_info
+      connection.use_ssl = server.scheme == "https"
+      connection.read_timeout = @transport_configuration.timeout
+      connection.write_timeout = @transport_configuration.timeout if connection.respond_to?(:write_timeout)
+      connection.open_timeout = @transport_configuration.open_timeout
+
+      ssl_configuration.each do |key, value|
+        connection.send("#{key}=", value)
       end
-    rescue SocketError => e
-      raise Sentry::ExternalError.new(e.message)
+
+      connection
     end
 
     private
@@ -126,31 +176,6 @@ module Sentry
       @transport_configuration.encoding == GZIP_ENCODING && data.bytesize >= GZIP_THRESHOLD
     end
 
-    def conn
-      server = URI(@dsn.server)
-      
-      # connection respects proxy setting from @transport_configuration, or environment variables (HTTP_PROXY, HTTPS_PROXY, NO_PROXY)
-      # Net::HTTP will automatically read the env vars.
-      # See https://ruby-doc.org/3.2.2/stdlibs/net/Net/HTTP.html#class-Net::HTTP-label-Proxies
-      connection =
-        if proxy = normalize_proxy(@transport_configuration.proxy)
-          ::Net::HTTP.new(server.hostname, server.port, proxy[:uri].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
-        else
-          ::Net::HTTP.new(server.hostname, server.port)
-        end
-
-      connection.use_ssl = server.scheme == "https"
-      connection.read_timeout = @transport_configuration.timeout
-      connection.write_timeout = @transport_configuration.timeout if connection.respond_to?(:write_timeout)
-      connection.open_timeout = @transport_configuration.open_timeout
-
-      ssl_configuration.each do |key, value|
-        connection.send("#{key}=", value)
-      end
-
-      connection
-    end
-
     # @param proxy [String, URI, Hash] Proxy config value passed into `config.transport`.
     #   Accepts either a URI formatted string, URI, or a hash with the `uri`, `user`, and `password` keys.
     # @return [Hash] Normalized proxy config that will be passed into `Net::HTTP`

data/lib/sentry/transport/spotlight_transport.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "zlib"
+
+module Sentry
+  # Designed to just report events to Spotlight in development.
+  class SpotlightTransport < HTTPTransport
+    DEFAULT_SIDECAR_URL = "http://localhost:8969/stream"
+    MAX_FAILED_REQUESTS = 3
+
+    def initialize(configuration)
+      super
+      @sidecar_url = configuration.spotlight.is_a?(String) ? configuration.spotlight : DEFAULT_SIDECAR_URL
+      @failed = 0
+      @logged = false
+
+      log_debug("[Spotlight] initialized for url #{@sidecar_url}")
+    end
+
+    def endpoint
+      "/stream"
+    end
+
+    def send_data(data)
+      if @failed >= MAX_FAILED_REQUESTS
+        unless @logged
+          log_debug("[Spotlight] disabling because of too many request failures")
+          @logged = true
+        end
+
+        return
+      end
+
+      super
+    end
+
+    def on_error
+      @failed += 1
+    end
+
+    # Similar to HTTPTransport connection, but does not support Proxy and SSL
+    def conn
+      sidecar = URI(@sidecar_url)
+      connection = ::Net::HTTP.new(sidecar.hostname, sidecar.port, nil)
+      connection.use_ssl = false
+      connection
+    end
+  end
+end

data/lib/sentry/transport.rb

@@ -19,7 +19,8 @@ module Sentry
       :sample_rate,
       :before_send,
       :event_processor,
-      :insufficient_data
+      :insufficient_data,
+      :backpressure
     ]
 
     include LoggingHelper
@@ -74,7 +75,7 @@ module Sentry
         result, oversized = item.serialize
 
         if oversized
-          log_info("Envelope item [#{item.type}] is still oversized after size reduction: {#{item.size_breakdown}}")
+          log_debug("Envelope item [#{item.type}] is still oversized after size reduction: {#{item.size_breakdown}}")
 
           next
         end
@@ -119,16 +120,8 @@ module Sentry
       !!delay && delay > Time.now
     end
 
-    def generate_auth_header
-      now = Sentry.utc_now.to_i
-      fields = {
-        'sentry_version' => PROTOCOL_VERSION,
-        'sentry_client' => USER_AGENT,
-        'sentry_timestamp' => now,
-        'sentry_key' => @dsn.public_key
-      }
-      fields['sentry_secret'] = @dsn.secret_key if @dsn.secret_key
-      'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
+    def any_rate_limited?
+      @rate_limits.values.any? { |t| t && t > Time.now }
     end
 
     def envelope_from_event(event)
@@ -175,11 +168,20 @@ module Sentry
       @discarded_events[[reason, item_type]] += 1
     end
 
+    def flush
+      client_report_headers, client_report_payload = fetch_pending_client_report(force: true)
+      return unless client_report_headers
+
+      envelope = Envelope.new
+      envelope.add_item(client_report_headers, client_report_payload)
+      send_envelope(envelope)
+    end
+
     private
 
-    def fetch_pending_client_report
+    def fetch_pending_client_report(force: false)
       return nil unless @send_client_reports
-      return nil if @last_client_report_sent > Time.now - CLIENT_REPORT_INTERVAL
+      return nil if !force && @last_client_report_sent > Time.now - CLIENT_REPORT_INTERVAL
       return nil if @discarded_events.empty?
 
       discarded_events_hash = @discarded_events.map do |key, val|
@@ -206,7 +208,7 @@ module Sentry
     def reject_rate_limited_items(envelope)
       envelope.items.reject! do |item|
         if is_rate_limited?(item.type)
-          log_info("[Transport] Envelope item [#{item.type}] not sent: rate limiting")
+          log_debug("[Transport] Envelope item [#{item.type}] not sent: rate limiting")
           record_lost_event(:ratelimit_backoff, item.type)
 
           true
@@ -220,3 +222,4 @@ end
 
 require "sentry/transport/dummy_transport"
 require "sentry/transport/http_transport"
+require "sentry/transport/spotlight_transport"

data/lib/sentry/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sentry
-  VERSION = "5.14.0"
+  VERSION = "5.16.1"
 end

data/lib/sentry-ruby.rb

@@ -21,6 +21,7 @@ require "sentry/transaction"
 require "sentry/hub"
 require "sentry/background_worker"
 require "sentry/session_flusher"
+require "sentry/backpressure_monitor"
 require "sentry/cron/monitor_check_ins"
 
 [
@@ -65,13 +66,17 @@ module Sentry
     end
 
     # @!attribute [rw] background_worker
-    #   @return [BackgroundWorker, nil]
+    #   @return [BackgroundWorker]
     attr_accessor :background_worker
 
     # @!attribute [r] session_flusher
     #   @return [SessionFlusher, nil]
     attr_reader :session_flusher
 
+    # @!attribute [r] backpressure_monitor
+    #   @return [BackpressureMonitor, nil]
+    attr_reader :backpressure_monitor
+
     ##### Patch Registration #####
 
     # @!visibility private
@@ -217,17 +222,9 @@ module Sentry
       Thread.current.thread_variable_set(THREAD_LOCAL, hub)
       @main_hub = hub
       @background_worker = Sentry::BackgroundWorker.new(config)
-
-      @session_flusher = if config.auto_session_tracking
-                           Sentry::SessionFlusher.new(config, client)
-                         else
-                           nil
-                         end
-
-      if config.include_local_variables
-        exception_locals_tp.enable
-      end
-
+      @session_flusher = config.auto_session_tracking ? Sentry::SessionFlusher.new(config, client) : nil
+      @backpressure_monitor = config.enable_backpressure_handling ? Sentry::BackpressureMonitor.new(config, client) : nil
+      exception_locals_tp.enable if config.include_local_variables
       at_exit { close }
     end
 
@@ -236,20 +233,27 @@ module Sentry
     #
     # @return [void]
     def close
-      if @background_worker
-        @background_worker.shutdown
-        @background_worker = nil
-      end
-
       if @session_flusher
+        @session_flusher.flush
         @session_flusher.kill
         @session_flusher = nil
       end
 
-      if configuration&.include_local_variables
-        exception_locals_tp.disable
+      if @backpressure_monitor
+        @backpressure_monitor.kill
+        @backpressure_monitor = nil
       end
 
+      if client = get_current_client
+        client.transport.flush
+
+        if client.configuration.include_local_variables
+          exception_locals_tp.disable
+        end
+      end
+
+      @background_worker.shutdown
+
       @main_hub = nil
       Thread.current.thread_variable_set(THREAD_LOCAL, nil)
     end
@@ -442,12 +446,10 @@ module Sentry
     # @option options [Integer] duration seconds elapsed since this monitor started
     # @option options [Cron::MonitorConfig] monitor_config configuration for this monitor
     #
-    # @yieldparam scope [Scope]
-    #
     # @return [String, nil] The {CheckInEvent#check_in_id} to use for later updates on the same slug
-    def capture_check_in(slug, status, **options, &block)
+    def capture_check_in(slug, status, **options)
       return unless initialized?
-      get_current_hub.capture_check_in(slug, status, **options, &block)
+      get_current_hub.capture_check_in(slug, status, **options)
     end
 
     # Takes or initializes a new Sentry::Transaction and makes a sampling decision for it.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby
 version: !ruby/object:Gem::Version
-  version: 5.14.0
+  version: 5.16.1
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-11-27 00:00:00.000000000 Z
+date: 2024-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -51,6 +51,7 @@ files:
 - bin/setup
 - lib/sentry-ruby.rb
 - lib/sentry/background_worker.rb
+- lib/sentry/backpressure_monitor.rb
 - lib/sentry/backtrace.rb
 - lib/sentry/baggage.rb
 - lib/sentry/breadcrumb.rb
@@ -61,6 +62,7 @@ files:
 - lib/sentry/configuration.rb
 - lib/sentry/core_ext/object/deep_dup.rb
 - lib/sentry/core_ext/object/duplicable.rb
+- lib/sentry/cron/configuration.rb
 - lib/sentry/cron/monitor_check_ins.rb
 - lib/sentry/cron/monitor_config.rb
 - lib/sentry/cron/monitor_schedule.rb
@@ -100,6 +102,7 @@ files:
 - lib/sentry/transport/configuration.rb
 - lib/sentry/transport/dummy_transport.rb
 - lib/sentry/transport/http_transport.rb
+- lib/sentry/transport/spotlight_transport.rb
 - lib/sentry/utils/argument_checking_helper.rb
 - lib/sentry/utils/custom_inspection.rb
 - lib/sentry/utils/encoding_helper.rb