sentry-ruby 5.13.0 → 5.21.0

data/lib/sentry/session_flusher.rb

@@ -1,58 +1,38 @@
 # frozen_string_literal: true
 
 module Sentry
-  class SessionFlusher
-    include LoggingHelper
-
+  class SessionFlusher < ThreadedPeriodicWorker
     FLUSH_INTERVAL = 60
 
     def initialize(configuration, client)
-      @thread = nil
-      @exited = false
+      super(configuration.logger, FLUSH_INTERVAL)
       @client = client
       @pending_aggregates = {}
       @release = configuration.release
       @environment = configuration.environment
-      @logger = configuration.logger
 
       log_debug("[Sessions] Sessions won't be captured without a valid release") unless @release
     end
 
     def flush
       return if @pending_aggregates.empty?
-      envelope = pending_envelope
-
-      Sentry.background_worker.perform do
-        @client.transport.send_envelope(envelope)
-      end
 
+      @client.capture_envelope(pending_envelope)
       @pending_aggregates = {}
     end
 
+    alias_method :run, :flush
+
     def add_session(session)
-      return if @exited
       return unless @release
 
-      begin
-        ensure_thread
-      rescue ThreadError
-        log_debug("Session flusher thread creation failed")
-        @exited = true
-        return
-      end
+      return unless ensure_thread
 
       return unless Session::AGGREGATE_STATUSES.include?(session.status)
       @pending_aggregates[session.aggregation_key] ||= init_aggregates(session.aggregation_key)
       @pending_aggregates[session.aggregation_key][session.status] += 1
     end
 
-    def kill
-      log_debug("Killing session flusher")
-
-      @exited = true
-      @thread&.kill
-    end
-
     private
 
     def init_aggregates(aggregation_key)
@@ -64,7 +44,7 @@ module Sentry
     def pending_envelope
       envelope = Envelope.new
 
-      header = { type: 'sessions' }
+      header = { type: "sessions" }
       payload = { attrs: attrs, aggregates: @pending_aggregates.values }
 
       envelope.add_item(header, payload)
@@ -74,17 +54,5 @@ module Sentry
     def attrs
       { release: @release, environment: @environment }
     end
-
-    def ensure_thread
-      return if @thread&.alive?
-
-      @thread = Thread.new do
-        loop do
-          sleep(FLUSH_INTERVAL)
-          flush
-        end
-      end
-    end
-
   end
 end

data/lib/sentry/span.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require "securerandom"
+require "sentry/metrics/local_aggregator"
 
 module Sentry
   class Span
-
     # We will try to be consistent with OpenTelemetry on this front going forward.
     # https://develop.sentry.dev/sdk/performance/span-data-conventions/
     module DataConventions
@@ -39,6 +39,11 @@ module Sentry
       # Recommended: If different than server.port.
       # Example: 16456
       SERVER_SOCKET_PORT = "server.socket.port"
+
+      FILEPATH = "code.filepath"
+      LINENO = "code.lineno"
+      FUNCTION = "code.function"
+      NAMESPACE = "code.namespace"
     end
 
     STATUS_MAP = {
@@ -55,6 +60,8 @@ module Sentry
       504 => "deadline_exceeded"
     }
 
+    DEFAULT_SPAN_ORIGIN = "manual"
+
     # An uuid that can be used to identify a trace.
     # @return [String]
     attr_reader :trace_id
@@ -88,6 +95,9 @@ module Sentry
     # Span data
     # @return [Hash]
     attr_reader :data
+    # Span origin that tracks what kind of instrumentation created a span
+    # @return [String]
+    attr_reader :origin
 
     # The SpanRecorder the current span belongs to.
     # SpanRecorder holds all spans under the same Transaction object (including the Transaction itself).
@@ -109,7 +119,8 @@ module Sentry
       parent_span_id: nil,
       sampled: nil,
       start_timestamp: nil,
-      timestamp: nil
+      timestamp: nil,
+      origin: nil
     )
       @trace_id = trace_id || SecureRandom.uuid.delete("-")
       @span_id = span_id || SecureRandom.uuid.delete("-").slice(0, 16)
@@ -123,6 +134,7 @@ module Sentry
       @status = status
       @data = {}
       @tags = {}
+      @origin = origin || DEFAULT_SPAN_ORIGIN
     end
 
     # Finishes the span by adding a timestamp.
@@ -148,9 +160,15 @@ module Sentry
       transaction.get_baggage&.serialize
     end
 
+    # Returns the Dynamic Sampling Context from the transaction baggage.
+    # @return [Hash, nil]
+    def get_dynamic_sampling_context
+      transaction.get_baggage&.dynamic_sampling_context
+    end
+
     # @return [Hash]
     def to_hash
-      {
+      hash = {
         trace_id: @trace_id,
         span_id: @span_id,
         parent_span_id: @parent_span_id,
@@ -160,8 +178,14 @@ module Sentry
         op: @op,
         status: @status,
         tags: @tags,
-        data: @data
+        data: @data,
+        origin: @origin
       }
+
+      summary = metrics_summary
+      hash[:_metrics_summary] = summary if summary
+
+      hash
     end
 
     # Returns the span's context that can be used to embed in an Event.
@@ -173,7 +197,9 @@ module Sentry
         parent_span_id: @parent_span_id,
         description: @description,
         op: @op,
-        status: @status
+        status: @status,
+        origin: @origin,
+        data: @data
       }
     end
 
@@ -269,5 +295,20 @@ module Sentry
     def set_tag(key, value)
       @tags[key] = value
     end
+
+    # Sets the origin of the span.
+    # @param origin [String]
+    def set_origin(origin)
+      @origin = origin
+    end
+
+    # Collects gauge metrics on the span for metric summaries.
+    def metrics_local_aggregator
+      @metrics_local_aggregator ||= Sentry::Metrics::LocalAggregator.new
+    end
+
+    def metrics_summary
+      @metrics_local_aggregator&.to_hash
+    end
   end
 end

data/lib/sentry/test_helper.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Sentry
   module TestHelper
-    DUMMY_DSN = 'http://12345:67890@sentry.localdomain/sentry/42'
+    DUMMY_DSN = "http://12345:67890@sentry.localdomain/sentry/42"
 
     # Alters the existing SDK configuration with test-suitable options. Mainly:
     # - Sets a dummy DSN instead of `nil` or an actual DSN.
@@ -20,7 +22,7 @@ module Sentry
       # set transport to DummyTransport, so we can easily intercept the captured events
       dummy_config.transport.transport_class = Sentry::DummyTransport
       # make sure SDK allows sending under the current environment
-      dummy_config.enabled_environments << dummy_config.environment unless dummy_config.enabled_environments.include?(dummy_config.environment)
+      dummy_config.enabled_environments += [dummy_config.environment] unless dummy_config.enabled_environments.include?(dummy_config.environment)
       # disble async event sending
       dummy_config.background_worker_threads = 0
 
@@ -50,6 +52,7 @@ module Sentry
       if Sentry.get_current_hub.instance_variable_get(:@stack).size > 1
         Sentry.get_current_hub.pop_scope
       end
+      Sentry::Scope.global_event_processors.clear
     end
 
     # @return [Transport]

data/lib/sentry/threaded_periodic_worker.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Sentry
+  class ThreadedPeriodicWorker
+    include LoggingHelper
+
+    def initialize(logger, internal)
+      @thread = nil
+      @exited = false
+      @interval = internal
+      @logger = logger
+    end
+
+    def ensure_thread
+      return false if @exited
+      return true if @thread&.alive?
+
+      @thread = Thread.new do
+        loop do
+          sleep(@interval)
+          run
+        end
+      end
+
+      true
+    rescue ThreadError
+      log_debug("[#{self.class.name}] thread creation failed")
+      @exited = true
+      false
+    end
+
+    def kill
+      log_debug("[#{self.class.name}] thread killed")
+
+      @exited = true
+      @thread&.kill
+    end
+  end
+end

data/lib/sentry/transaction.rb

@@ -9,11 +9,11 @@ module Sentry
     # @deprecated Use Sentry::PropagationContext::SENTRY_TRACE_REGEXP instead.
     SENTRY_TRACE_REGEXP = PropagationContext::SENTRY_TRACE_REGEXP
 
-    UNLABELD_NAME = "<unlabeled transaction>".freeze
+    UNLABELD_NAME = "<unlabeled transaction>"
     MESSAGE_PREFIX = "[Tracing]"
 
     # https://develop.sentry.dev/sdk/event-payloads/transaction/#transaction-annotations
-    SOURCES = %i(custom url route view component task)
+    SOURCES = %i[custom url route view component task]
 
     include LoggingHelper
 
@@ -85,7 +85,7 @@ module Sentry
       @effective_sample_rate = nil
       @contexts = {}
       @measurements = {}
-      @profiler = Profiler.new(@configuration)
+      @profiler = @configuration.profiler_class.new(@configuration)
       init_span_recorder
     end
 
@@ -110,14 +110,15 @@ module Sentry
 
       trace_id, parent_span_id, parent_sampled = sentry_trace_data
 
-      baggage = if baggage && !baggage.empty?
-                  Baggage.from_incoming_header(baggage)
-                else
-                  # If there's an incoming sentry-trace but no incoming baggage header,
-                  # for instance in traces coming from older SDKs,
-                  # baggage will be empty and frozen and won't be populated as head SDK.
-                  Baggage.new({})
-                end
+      baggage =
+        if baggage && !baggage.empty?
+          Baggage.from_incoming_header(baggage)
+        else
+          # If there's an incoming sentry-trace but no incoming baggage header,
+          # for instance in traces coming from older SDKs,
+          # baggage will be empty and frozen and won't be populated as head SDK.
+          Baggage.new({})
+        end
 
       baggage.freeze!
 
@@ -218,7 +219,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 +263,10 @@ 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")
+        hub.current_client.transport.record_lost_event(reason, "span")
       end
     end
 
@@ -294,6 +303,11 @@ module Sentry
       profiler.start
     end
 
+    # These are high cardinality and thus bad
+    def source_low_quality?
+      source == :url
+    end
+
     protected
 
     def init_span_recorder(limit = 1000)
@@ -329,11 +343,6 @@ module Sentry
       @baggage = Baggage.new(items, mutable: false)
     end
 
-    # These are high cardinality and thus bad
-    def source_low_quality?
-      source == :url
-    end
-
     class SpanRecorder
       attr_reader :max_length, :spans
 

data/lib/sentry/transaction_event.rb

@@ -17,6 +17,9 @@ module Sentry
     # @return [Hash, nil]
     attr_accessor :profile
 
+    # @return [Hash, nil]
+    attr_accessor :metrics_summary
+
     def initialize(transaction:, **options)
       super(**options)
 
@@ -29,6 +32,7 @@ module Sentry
       self.tags = transaction.tags
       self.dynamic_sampling_context = transaction.get_baggage.dynamic_sampling_context
       self.measurements = transaction.measurements
+      self.metrics_summary = transaction.metrics_summary
 
       finished_spans = transaction.span_recorder.spans.select { |span| span.timestamp && span != transaction }
       self.spans = finished_spans.map(&:to_hash)
@@ -49,6 +53,7 @@ module Sentry
       data[:spans] = @spans.map(&:to_hash) if @spans
       data[:start_timestamp] = @start_timestamp
       data[:measurements] = @measurements
+      data[:_metrics_summary] = @metrics_summary if @metrics_summary
       data
     end
 
@@ -69,8 +74,7 @@ module Sentry
           id: event_id,
           name: transaction.name,
           trace_id: transaction.trace_id,
-          # TODO-neel-profiler stubbed for now, see thread_id note in profiler.rb
-          active_thead_id: '0'
+          active_thread_id: transaction.profiler.active_thread_id.to_s
         }
       )
 

data/lib/sentry/transport/configuration.rb

@@ -3,7 +3,79 @@
 module Sentry
   class Transport
     class Configuration
-      attr_accessor :timeout, :open_timeout, :proxy, :ssl, :ssl_ca_file, :ssl_verification, :encoding
+      # The timeout in seconds to open a connection to Sentry, in seconds.
+      # Default value is 2.
+      #
+      # @return [Integer]
+      attr_accessor :timeout
+
+      # The timeout in seconds to read data from Sentry, in seconds.
+      # Default value is 1.
+      #
+      # @return [Integer]
+      attr_accessor :open_timeout
+
+      # The proxy configuration to use to connect to Sentry.
+      # Accepts either a URI formatted string, URI, or a hash with the `uri`,
+      # `user`, and `password` keys.
+      #
+      # @example
+      #   # setup proxy using a string:
+      #   config.transport.proxy = "https://user:password@proxyhost:8080"
+      #
+      #   # setup proxy using a URI:
+      #   config.transport.proxy = URI("https://user:password@proxyhost:8080")
+      #
+      #   # setup proxy using a hash:
+      #   config.transport.proxy = {
+      #     uri: URI("https://proxyhost:8080"),
+      #     user: "user",
+      #     password: "password"
+      #   }
+      #
+      # If you're using the default transport (`Sentry::HTTPTransport`),
+      # proxy settings will also automatically be read from tne environment
+      # variables (`HTTP_PROXY`, `HTTPS_PROXY`, `NO_PROXY`).
+      #
+      # @return [String, URI, Hash, nil]
+      attr_accessor :proxy
+
+      # The SSL configuration to use to connect to Sentry.
+      # You can either pass a `Hash` containing `ca_file` and `verification` keys,
+      # or you can set those options directly on the `Sentry::HTTPTransport::Configuration` object:
+      #
+      # @example
+      #   config.transport.ssl =  {
+      #     ca_file: "/path/to/ca_file",
+      #     verification: true
+      #   end
+      #
+      # @return [Hash, nil]
+      attr_accessor :ssl
+
+      # The path to the CA file to use to verify the SSL connection.
+      # Default value is `nil`.
+      #
+      # @return [String, nil]
+      attr_accessor :ssl_ca_file
+
+      # Whether to verify that the peer certificate is valid in SSL connections.
+      # Default value is `true`.
+      #
+      # @return [Boolean]
+      attr_accessor :ssl_verification
+
+      # The encoding to use to compress the request body.
+      # Default value is `Sentry::HTTPTransport::GZIP_ENCODING`.
+      #
+      # @return [String]
+      attr_accessor :encoding
+
+      # The class to use as a transport to connect to Sentry.
+      # If this option not set, it will return `nil`, and Sentry will use
+      # `Sentry::HTTPTransport` by default.
+      #
+      # @return [Class, nil]
       attr_reader :transport_class
 
       def initialize

data/lib/sentry/transport/http_transport.rb

@@ -7,18 +7,26 @@ module Sentry
   class HTTPTransport < Transport
     GZIP_ENCODING = "gzip"
     GZIP_THRESHOLD = 1024 * 30
-    CONTENT_TYPE = 'application/x-sentry-envelope'
+    CONTENT_TYPE = "application/x-sentry-envelope"
 
     DEFAULT_DELAY = 60
     RETRY_AFTER_HEADER = "retry-after"
     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)
@@ -30,36 +38,78 @@ module Sentry
       end
 
       headers = {
-        'Content-Type' => CONTENT_TYPE,
-        'Content-Encoding' => encoding,
-        'X-Sentry-Auth' => generate_auth_header,
-        'User-Agent' => USER_AGENT
+        "Content-Type" => CONTENT_TYPE,
+        "Content-Encoding" => encoding,
+        "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