sentry-ruby 5.4.2 → 5.16.1

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,28 +176,9 @@ module Sentry
       @transport_configuration.encoding == GZIP_ENCODING && data.bytesize >= GZIP_THRESHOLD
     end
 
-    def conn
-      server = URI(@dsn.server)
-
-      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, nil)
-        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`
     def normalize_proxy(proxy)
       return proxy unless proxy
 

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

@@ -18,7 +18,9 @@ module Sentry
       :network_error,
       :sample_rate,
       :before_send,
-      :event_processor
+      :event_processor,
+      :insufficient_data,
+      :backpressure
     ]
 
     include LoggingHelper
@@ -73,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
@@ -118,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)
@@ -136,20 +130,31 @@ module Sentry
       event_id = event_payload[:event_id] || event_payload["event_id"]
       item_type = event_payload[:type] || event_payload["type"]
 
-      envelope = Envelope.new(
-        {
-          event_id: event_id,
-          dsn: @dsn.to_s,
-          sdk: Sentry.sdk_meta,
-          sent_at: Sentry.utc_now.iso8601
-        }
-      )
+      envelope_headers = {
+        event_id: event_id,
+        dsn: @dsn.to_s,
+        sdk: Sentry.sdk_meta,
+        sent_at: Sentry.utc_now.iso8601
+      }
+
+      if event.is_a?(Event) && event.dynamic_sampling_context
+        envelope_headers[:trace] = event.dynamic_sampling_context
+      end
+
+      envelope = Envelope.new(envelope_headers)
 
       envelope.add_item(
         { type: item_type, content_type: 'application/json' },
         event_payload
       )
 
+      if event.is_a?(TransactionEvent) && event.profile
+        envelope.add_item(
+          { type: 'profile', content_type: 'application/json' },
+          event.profile
+        )
+      end
+
       client_report_headers, client_report_payload = fetch_pending_client_report
       envelope.add_item(client_report_headers, client_report_payload) if client_report_headers
 
@@ -163,18 +168,27 @@ 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|
         reason, type = key
 
         # 'event' has to be mapped to 'error'
-        category = type == 'transaction' ? 'transaction' : 'error'
+        category = type == 'event' ? 'error' : type
 
         { reason: reason, category: category, quantity: val }
       end
@@ -194,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
@@ -208,3 +222,4 @@ end
 
 require "sentry/transport/dummy_transport"
 require "sentry/transport/http_transport"
+require "sentry/transport/spotlight_transport"

data/lib/sentry/utils/argument_checking_helper.rb

@@ -4,9 +4,15 @@ module Sentry
   module ArgumentCheckingHelper
     private
 
-    def check_argument_type!(argument, expected_type)
-      unless argument.is_a?(expected_type)
-        raise ArgumentError, "expect the argument to be a #{expected_type}, got #{argument.class} (#{argument.inspect})"
+    def check_argument_type!(argument, *expected_types)
+      unless expected_types.any? { |t| argument.is_a?(t) }
+        raise ArgumentError, "expect the argument to be a #{expected_types.join(' or ')}, got #{argument.class} (#{argument.inspect})"
+      end
+    end
+
+    def check_argument_includes!(argument, values)
+      unless values.include?(argument)
+        raise ArgumentError, "expect the argument to be one of #{values.map(&:inspect).join(' or ')}, got #{argument.inspect}"
       end
     end
   end

data/lib/sentry/utils/encoding_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Utils
+    module EncodingHelper
+      def self.encode_to_utf_8(value)
+        if value.encoding != Encoding::UTF_8 && value.respond_to?(:force_encoding)
+          value = value.dup.force_encoding(Encoding::UTF_8)
+        end
+
+        value = value.scrub unless value.valid_encoding?
+        value
+      end
+
+      def self.valid_utf_8?(value)
+        return true unless value.respond_to?(:force_encoding)
+
+        value.dup.force_encoding(Encoding::UTF_8).valid_encoding?
+      end
+    end
+  end
+end

data/lib/sentry/version.rb

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

data/lib/sentry-ruby.rb

@@ -8,17 +8,21 @@ require "sentry/version"
 require "sentry/exceptions"
 require "sentry/core_ext/object/deep_dup"
 require "sentry/utils/argument_checking_helper"
+require "sentry/utils/encoding_helper"
 require "sentry/utils/logging_helper"
 require "sentry/configuration"
 require "sentry/logger"
 require "sentry/event"
 require "sentry/error_event"
 require "sentry/transaction_event"
+require "sentry/check_in_event"
 require "sentry/span"
 require "sentry/transaction"
 require "sentry/hub"
 require "sentry/background_worker"
 require "sentry/session_flusher"
+require "sentry/backpressure_monitor"
+require "sentry/cron/monitor_check_ins"
 
 [
   "sentry/rake",
@@ -39,6 +43,8 @@ module Sentry
 
   SENTRY_TRACE_HEADER_NAME = "sentry-trace".freeze
 
+  BAGGAGE_HEADER_NAME = "baggage".freeze
+
   THREAD_LOCAL = :sentry_hub
 
   class << self
@@ -60,30 +66,44 @@ 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
-    def register_patch(&block)
-      registered_patches << block
+    def register_patch(key, patch = nil, target = nil, &block)
+      if patch && block
+        raise ArgumentError.new("Please provide either a patch and its target OR a block, but not both")
+      end
+
+      if block
+        registered_patches[key] = block
+      else
+        registered_patches[key] = proc do
+          target.send(:prepend, patch) unless target.ancestors.include?(patch)
+        end
+      end
     end
 
     # @!visibility private
     def apply_patches(config)
-      registered_patches.each do |patch|
-        patch.call(config)
+      registered_patches.each do |key, patch|
+        patch.call(config) if config.enabled_patches.include?(key)
       end
     end
 
     # @!visibility private
     def registered_patches
-      @registered_patches ||= []
+      @registered_patches ||= {}
     end
 
     ##### Integrations #####
@@ -202,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.capture_exception_frame_locals
-        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
 
@@ -221,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&.capture_exception_frame_locals
-        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
@@ -348,7 +367,7 @@ module Sentry
     # @yieldparam scope [Scope]
     # @return [void]
     def with_scope(&block)
-      return unless initialized?
+      return yield unless initialized?
       get_current_hub.with_scope(&block)
     end
 
@@ -417,6 +436,22 @@ module Sentry
       get_current_hub.capture_event(event)
     end
 
+    # Captures a check-in and sends it to Sentry via the currently active hub.
+    #
+    # @param slug [String] identifier of this monitor
+    # @param status [Symbol] status of this check-in, one of {CheckInEvent::VALID_STATUSES}
+    #
+    # @param [Hash] options extra check-in options
+    # @option options [String] check_in_id for updating the status of an existing monitor
+    # @option options [Integer] duration seconds elapsed since this monitor started
+    # @option options [Cron::MonitorConfig] monitor_config configuration for this monitor
+    #
+    # @return [String, nil] The {CheckInEvent#check_in_id} to use for later updates on the same slug
+    def capture_check_in(slug, status, **options)
+      return unless initialized?
+      get_current_hub.capture_check_in(slug, status, **options)
+    end
+
     # Takes or initializes a new Sentry::Transaction and makes a sampling decision for it.
     #
     # @return [Transaction, nil]
@@ -439,22 +474,8 @@ module Sentry
     #   end
     #
     def with_child_span(**attributes, &block)
-      if Sentry.initialized? && current_span = get_current_scope.get_span
-        result = nil
-
-        begin
-          current_span.with_child_span(**attributes) do |child_span|
-            get_current_scope.set_span(child_span)
-            result = yield(child_span)
-          end
-        ensure
-          get_current_scope.set_span(current_span)
-        end
-
-        result
-      else
-        yield(nil)
-      end
+      return yield(nil) unless Sentry.initialized?
+      get_current_hub.with_child_span(**attributes, &block)
     end
 
     # Returns the id of the lastly reported Sentry::Event.
@@ -473,6 +494,59 @@ module Sentry
       !!exc.instance_variable_get(CAPTURED_SIGNATURE)
     end
 
+    # Add a global event processor [Proc].
+    # These run before scope event processors.
+    #
+    # @yieldparam event [Event]
+    # @yieldparam hint [Hash, nil]
+    # @return [void]
+    #
+    # @example
+    #   Sentry.add_global_event_processor do |event, hint|
+    #     event.tags = { foo: 42 }
+    #     event
+    #   end
+    #
+    def add_global_event_processor(&block)
+      Scope.add_global_event_processor(&block)
+    end
+
+    # Returns the traceparent (sentry-trace) header for distributed tracing.
+    # Can be either from the currently active span or the propagation context.
+    #
+    # @return [String, nil]
+    def get_traceparent
+      return nil unless initialized?
+      get_current_hub.get_traceparent
+    end
+
+    # Returns the baggage header for distributed tracing.
+    # Can be either from the currently active span or the propagation context.
+    #
+    # @return [String, nil]
+    def get_baggage
+      return nil unless initialized?
+      get_current_hub.get_baggage
+    end
+
+    # Returns the a Hash containing sentry-trace and baggage.
+    # Can be either from the currently active span or the propagation context.
+    #
+    # @return [Hash, nil]
+    def get_trace_propagation_headers
+      return nil unless initialized?
+      get_current_hub.get_trace_propagation_headers
+    end
+
+    # Continue an incoming trace from a rack env like hash.
+    #
+    # @param env [Hash]
+    # @return [Transaction, nil]
+    def continue_trace(env, **options)
+      return nil unless initialized?
+      get_current_hub.continue_trace(env, **options)
+    end
+
     ##### Helpers #####
 
     # @!visibility private
@@ -503,3 +577,4 @@ end
 # patches
 require "sentry/net/http"
 require "sentry/redis"
+require "sentry/puma"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby
 version: !ruby/object:Gem::Version
-  version: 5.4.2
+  version: 5.16.1
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-17 00:00:00.000000000 Z
+date: 2024-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -42,7 +42,6 @@ files:
 - ".rspec"
 - ".yardopts"
 - CHANGELOG.md
-- CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - Makefile
@@ -52,14 +51,21 @@ 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
 - lib/sentry/breadcrumb/sentry_logger.rb
 - lib/sentry/breadcrumb_buffer.rb
+- lib/sentry/check_in_event.rb
 - lib/sentry/client.rb
 - 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
 - lib/sentry/dsn.rb
 - lib/sentry/envelope.rb
 - lib/sentry/error_event.rb
@@ -77,6 +83,9 @@ files:
 - lib/sentry/linecache.rb
 - lib/sentry/logger.rb
 - lib/sentry/net/http.rb
+- lib/sentry/profiler.rb
+- lib/sentry/propagation_context.rb
+- lib/sentry/puma.rb
 - lib/sentry/rack.rb
 - lib/sentry/rack/capture_exceptions.rb
 - lib/sentry/rake.rb
@@ -93,8 +102,10 @@ 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
 - lib/sentry/utils/exception_cause_chain.rb
 - lib/sentry/utils/logging_helper.rb
 - lib/sentry/utils/real_ip.rb