sentry-ruby 5.28.1 → 6.5.0

data/lib/sentry/profiler.rb

@@ -10,8 +10,6 @@ module Sentry
 
     VERSION = "1"
     PLATFORM = "ruby"
-    # 101 Hz in microseconds
-    DEFAULT_INTERVAL = 1e6 / 101
     MICRO_TO_NANO_SECONDS = 1e3
     MIN_SAMPLES_REQUIRED = 2
 
@@ -24,6 +22,7 @@ module Sentry
 
       @profiling_enabled = defined?(StackProf) && configuration.profiling_enabled?
       @profiles_sample_rate = configuration.profiles_sample_rate
+      @profiles_sample_interval = configuration.profiles_sample_interval
       @project_root = configuration.project_root
       @app_dirs_pattern = configuration.app_dirs_pattern
       @in_app_pattern = Regexp.new("^(#{@project_root}/)?#{@app_dirs_pattern}")
@@ -32,7 +31,7 @@ module Sentry
     def start
       return unless @sampled
 
-      @started = StackProf.start(interval: DEFAULT_INTERVAL,
+      @started = StackProf.start(interval: @profiles_sample_interval,
                                  mode: :wall,
                                  raw: true,
                                  aggregate: false)
@@ -81,9 +80,9 @@ module Sentry
       log("Discarding profile due to sampling decision") unless @sampled
     end
 
-    def to_hash
+    def to_h
       unless @sampled
-        record_lost_event(:sample_rate)
+        record_lost_event(:sample_rate) if @profiling_enabled
         return {}
       end
 

data/lib/sentry/propagation_context.rb

@@ -53,6 +53,44 @@ module Sentry
       [trace_id, parent_span_id, parent_sampled]
     end
 
+    # Determines whether we should continue an incoming trace based on org_id matching
+    # and the strict_trace_continuation configuration option.
+    #
+    # @param incoming_baggage [Baggage] the baggage from the incoming request
+    # @return [Boolean]
+    def self.should_continue_trace?(incoming_baggage)
+      return true unless Sentry.initialized?
+
+      configuration = Sentry.configuration
+      sdk_org_id = configuration.effective_org_id
+      baggage_org_id = incoming_baggage.items["org_id"]
+
+      # Mismatched org IDs always start a new trace regardless of strict mode
+      if sdk_org_id && baggage_org_id && sdk_org_id != baggage_org_id
+        Sentry.sdk_logger.debug(LOGGER_PROGNAME) do
+          "Starting a new trace because org IDs don't match (incoming baggage org_id: #{baggage_org_id}, SDK org_id: #{sdk_org_id})"
+        end
+
+        return false
+      end
+
+      return true unless configuration.strict_trace_continuation
+
+      # In strict mode, both must be present and match (unless both are missing)
+      if sdk_org_id.nil? && baggage_org_id.nil?
+        true
+      elsif sdk_org_id.nil? || baggage_org_id.nil?
+        Sentry.sdk_logger.debug(LOGGER_PROGNAME) do
+          "Starting a new trace because strict trace continuation is enabled and one org ID is missing " \
+            "(incoming baggage org_id: #{baggage_org_id.inspect}, SDK org_id: #{sdk_org_id.inspect})"
+        end
+
+        false
+      else
+        true
+      end
+    end
+
     def self.extract_sample_rand_from_baggage(baggage, trace_id = nil)
       return unless baggage&.items
 
@@ -96,9 +134,7 @@ module Sentry
           sentry_trace_data = self.class.extract_sentry_trace(sentry_trace_header)
 
           if sentry_trace_data
-            @trace_id, @parent_span_id, @parent_sampled = sentry_trace_data
-
-            @baggage =
+            incoming_baggage =
               if baggage_header && !baggage_header.empty?
                 Baggage.from_incoming_header(baggage_header)
               else
@@ -108,10 +144,13 @@ module Sentry
                 Baggage.new({})
               end
 
-            @sample_rand = self.class.extract_sample_rand_from_baggage(@baggage, @trace_id)
-
-            @baggage.freeze!
-            @incoming_trace = true
+            if self.class.should_continue_trace?(incoming_baggage)
+              @trace_id, @parent_span_id, @parent_sampled = sentry_trace_data
+              @baggage = incoming_baggage
+              @sample_rand = self.class.extract_sample_rand_from_baggage(@baggage, @trace_id)
+              @baggage.freeze!
+              @incoming_trace = true
+            end
           end
         end
       end
@@ -162,7 +201,8 @@ module Sentry
         "sample_rand" => Utils::SampleRand.format(@sample_rand),
         "environment" => configuration.environment,
         "release" => configuration.release,
-        "public_key" => configuration.dsn&.public_key
+        "public_key" => configuration.dsn&.public_key,
+        "org_id" => configuration.effective_org_id
       }
 
       items.compact!

data/lib/sentry/rack/capture_exceptions.rb

@@ -33,7 +33,7 @@ module Sentry
               raise # Don't capture Sentry errors
             rescue Exception => e
               capture_exception(e, env)
-              finish_transaction(transaction, 500)
+              finish_transaction(transaction, status_code_for_exception(e))
               raise
             end
 
@@ -72,7 +72,16 @@ module Sentry
         }
 
         transaction = Sentry.continue_trace(env, **options)
-        Sentry.start_transaction(transaction: transaction, custom_sampling_context: { env: env }, **options)
+        transaction = Sentry.start_transaction(transaction: transaction, custom_sampling_context: { env: env }, **options)
+        attach_queue_time(transaction, env)
+        transaction
+      end
+
+      def attach_queue_time(transaction, env)
+        return unless transaction
+        return unless (queue_time = extract_queue_time(env))
+
+        transaction.set_data(Span::DataConventions::HTTP_QUEUE_TIME_MS, queue_time)
       end
 
 
@@ -86,6 +95,85 @@ module Sentry
       def mechanism
         Sentry::Mechanism.new(type: MECHANISM_TYPE, handled: false)
       end
+
+      # Extracts queue time from the request environment.
+      # Calculates the time (in milliseconds) the request spent waiting in the
+      # web server queue before processing began.
+      #
+      # Subtracts puma.request_body_wait to account for time spent waiting for
+      # slow clients to send the request body, isolating actual queue time.
+      # See: https://github.com/puma/puma/blob/master/docs/architecture.md
+      #
+      # @param env [Hash] Rack env
+      # @return [Float, nil] queue time in milliseconds or nil
+      def extract_queue_time(env)
+        return unless Sentry.configuration&.capture_queue_time
+
+        header_value = env["HTTP_X_REQUEST_START"]
+        return unless header_value
+
+        request_start = parse_request_start_header(header_value)
+        return unless request_start
+
+        total_time_ms = ((Time.now.to_f - request_start) * 1000).round(2)
+
+        # reject negative (clock skew between proxy & app server)
+        return unless total_time_ms >= 0
+
+        puma_wait_ms = env["puma.request_body_wait"]
+        puma_wait_ms = puma_wait_ms.to_f if puma_wait_ms.is_a?(String)
+
+        if puma_wait_ms && puma_wait_ms > 0
+          queue_time_ms = total_time_ms - puma_wait_ms
+          queue_time_ms >= 0 ? queue_time_ms : 0.0 # more sanity check
+        else
+          total_time_ms
+        end
+      rescue StandardError
+      end
+
+      # Parses X-Request-Start header value to extract a timestamp.
+      # Supports multiple formats:
+      #   - Nginx: "t=1234567890.123" (seconds with decimal)
+      #   - Heroku, HAProxy 1.9+: "t=1234567890123456" (microseconds)
+      #   - HAProxy < 1.9: "t=1234567890" (seconds)
+      #   - Generic: "1234567890.123" (raw timestamp)
+      #
+      # @param header_value [String] The X-Request-Start header value
+      # @return [Float, nil] Timestamp in seconds since epoch or nil
+      def parse_request_start_header(header_value)
+        return unless header_value
+
+        # Take the first value if comma-separated (multiple headers collapsed by a proxy)
+        # and strip surrounding whitespace from each token
+        raw = header_value.split(",").first.to_s.strip
+
+        timestamp = if raw.start_with?("t=")
+          value = raw[2..-1].strip
+          return nil unless value.match?(/\A\d+(?:\.\d+)?\z/)
+          value.to_f
+        elsif raw.match?(/\A\d+(?:\.\d+)?\z/)
+          raw.to_f
+        else
+          return
+        end
+
+        # normalize: timestamps can be in seconds, milliseconds or microseconds
+        # any timestamp > 10 trillion = microseconds
+        if timestamp > 10_000_000_000_000
+          timestamp / 1_000_000.0
+        # timestamp > 10 billion & < 10 trillion = milliseconds
+        elsif timestamp > 10_000_000_000
+          timestamp / 1_000.0
+        else
+          timestamp # assume seconds
+        end
+      rescue StandardError
+      end
+
+      def status_code_for_exception(exception)
+        500
+      end
     end
   end
 end

data/lib/sentry/release_detector.rb

@@ -13,7 +13,7 @@ module Sentry
 
       def detect_release_from_heroku(running_on_heroku)
         return unless running_on_heroku
-        ENV["HEROKU_SLUG_COMMIT"]
+        ENV["HEROKU_BUILD_COMMIT"] || ENV["HEROKU_SLUG_COMMIT"]
       end
 
       def detect_release_from_capistrano(project_root)

data/lib/sentry/rspec.rb

@@ -70,7 +70,7 @@ RSpec::Matchers.define :include_sentry_event do |event_message = "", **opts|
   end
 
   def dump_events(sentry_events)
-    sentry_events.map(&Kernel.method(:Hash)).map do |hash|
+    sentry_events.map(&:to_h).map do |hash|
       hash.select { |k, _| [:message, :contexts, :tags, :exception].include?(k) }
     end.map do |hash|
       JSON.pretty_generate(hash)

data/lib/sentry/scope.rb

@@ -46,7 +46,7 @@ module Sentry
     # @param hint [Hash] the hint data that'll be passed to event processors.
     # @return [Event]
     def apply_to_event(event, hint = nil)
-      unless event.is_a?(CheckInEvent) || event.is_a?(LogEvent)
+      unless event.is_a?(CheckInEvent)
         event.tags = tags.merge(event.tags)
         event.user = user.merge(event.user)
         event.extra = extra.merge(event.extra)
@@ -60,23 +60,10 @@ module Sentry
         event.attachments = attachments
       end
 
-      if event.is_a?(LogEvent)
-        event.user = user.merge(event.user)
-      end
-
-      if span
-        event.contexts[:trace] ||= span.get_trace_context
-
-        if event.respond_to?(:dynamic_sampling_context)
-          event.dynamic_sampling_context ||= span.get_dynamic_sampling_context
-        end
-      else
-        event.contexts[:trace] ||= propagation_context.get_trace_context
-
-        if event.respond_to?(:dynamic_sampling_context)
-          event.dynamic_sampling_context ||= propagation_context.get_dynamic_sampling_context
-        end
-      end
+      trace_context = get_trace_context
+      dynamic_sampling_context = trace_context.delete(:dynamic_sampling_context)
+      event.contexts[:trace] ||= trace_context
+      event.dynamic_sampling_context ||= dynamic_sampling_context
 
       all_event_processors = self.class.global_event_processors + @event_processors
 
@@ -89,6 +76,37 @@ module Sentry
       event
     end
 
+    # A leaner version of apply_to_event that applies to
+    # lightweight payloads like Logs and Metrics.
+    #
+    # Adds trace_id, span_id, user from the scope and default attributes from configuration.
+    #
+    # @param telemetry [MetricEvent, LogEvent] the telemetry event to apply scope context to
+    # @return [MetricEvent, LogEvent] the telemetry event with scope context applied
+    def apply_to_telemetry(telemetry)
+      # TODO-neel when new scope set_attribute api is added: add them here
+      trace_context = get_trace_context
+      telemetry.trace_id = trace_context[:trace_id]
+      telemetry.span_id = trace_context[:span_id]
+
+      configuration = Sentry.configuration
+      return telemetry unless configuration
+
+      telemetry.attributes["sentry.sdk.name"] ||= Sentry.sdk_meta["name"]
+      telemetry.attributes["sentry.sdk.version"] ||= Sentry.sdk_meta["version"]
+      telemetry.attributes["sentry.environment"] ||= configuration.environment if configuration.environment
+      telemetry.attributes["sentry.release"] ||= configuration.release if configuration.release
+      telemetry.attributes["server.address"] ||= configuration.server_name if configuration.server_name
+
+      unless user.empty?
+        telemetry.attributes["user.id"] ||= user[:id] if user[:id]
+        telemetry.attributes["user.name"] ||= user[:username] if user[:username]
+        telemetry.attributes["user.email"] ||= user[:email] if user[:email]
+      end
+
+      telemetry
+    end
+
     # Adds the breadcrumb to the scope's breadcrumbs buffer.
     # @param breadcrumb [Breadcrumb]
     # @return [void]
@@ -117,6 +135,7 @@ module Sentry
       copy.session = session.deep_dup
       copy.propagation_context = propagation_context.deep_dup
       copy.attachments = attachments.dup
+      copy.event_processors = event_processors.dup
       copy
     end
 
@@ -278,6 +297,20 @@ module Sentry
       span
     end
 
+    # Returns the trace context for this scope.
+    # Prioritizes external propagation context (from OTel) over local propagation context.
+    # @return [Hash]
+    def get_trace_context
+      if span
+        span.get_trace_context.merge(dynamic_sampling_context: span.get_dynamic_sampling_context)
+      elsif (external_context = Sentry.get_external_propagation_context)
+        trace_id, span_id = external_context
+        { trace_id: trace_id, span_id: span_id }
+      else
+        propagation_context.get_trace_context.merge(dynamic_sampling_context: propagation_context.get_dynamic_sampling_context)
+      end
+    end
+
     # Sets the scope's fingerprint attribute.
     # @param fingerprint [Array]
     # @return [Array]

data/lib/sentry/sequel.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Sequel
+    OP_NAME = "db.sql.sequel"
+    SPAN_ORIGIN = "auto.db.sequel"
+
+    # Sequel Database extension module that instruments queries
+    module DatabaseExtension
+      def log_connection_yield(sql, conn, args = nil)
+        return super unless Sentry.initialized?
+
+        Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f, origin: SPAN_ORIGIN) do |span|
+          result = super
+
+          if span
+            span.set_description(sql)
+            span.set_data(Span::DataConventions::DB_SYSTEM, database_type.to_s)
+            span.set_data(Span::DataConventions::DB_NAME, opts[:database]) if opts[:database]
+            span.set_data(Span::DataConventions::SERVER_ADDRESS, opts[:host]) if opts[:host]
+            span.set_data(Span::DataConventions::SERVER_PORT, opts[:port]) if opts[:port]
+          end
+
+          result
+        end
+      end
+    end
+  end
+
+  ::Sequel::Database.register_extension(:sentry, Sentry::Sequel::DatabaseExtension)
+end
+
+Sentry.register_patch(:sequel) do
+  ::Sequel::Database.extension(:sentry) if defined?(::Sequel::Database)
+end

data/lib/sentry/span.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "securerandom"
-require "sentry/metrics/local_aggregator"
 require "sentry/utils/uuid"
 
 module Sentry
@@ -50,6 +49,9 @@ module Sentry
       MESSAGING_DESTINATION_NAME = "messaging.destination.name"
       MESSAGING_MESSAGE_RECEIVE_LATENCY = "messaging.message.receive.latency"
       MESSAGING_MESSAGE_RETRY_COUNT = "messaging.message.retry.count"
+
+      # Time in ms the request spent in the server queue before processing began.
+      HTTP_QUEUE_TIME_MS = "http.server.request.time_in_queue"
     end
 
     STATUS_MAP = {
@@ -173,8 +175,8 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
-      hash = {
+    def to_h
+      {
         trace_id: @trace_id,
         span_id: @span_id,
         parent_span_id: @parent_span_id,
@@ -187,11 +189,6 @@ module Sentry
         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.
@@ -307,14 +304,5 @@ module Sentry
     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/std_lib_logger.rb

@@ -37,6 +37,10 @@ module Sentry
         message = message.to_s.strip
 
         if !message.nil? && message != Sentry::Logger::PROGNAME && method = SEVERITY_MAP[severity]
+          if (filter = Sentry.configuration.std_lib_logger_filter) && !filter.call(self, message, method)
+            return result
+          end
+
           Sentry.logger.send(method, message, origin: ORIGIN)
         end
       end

data/lib/sentry/telemetry_event_buffer.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "sentry/threaded_periodic_worker"
+require "sentry/envelope"
+
+module Sentry
+  # TelemetryEventBuffer is a base class for buffering telemetry events (logs, metrics, etc.)
+  # and sending them to Sentry in a single envelope.
+  #
+  # This is used internally by the `Sentry::Client`.
+  #
+  # @!visibility private
+  class TelemetryEventBuffer < ThreadedPeriodicWorker
+    FLUSH_INTERVAL = 5 # seconds
+
+    # @!visibility private
+    attr_reader :pending_items, :envelope_type, :data_category, :thread
+
+    def initialize(configuration, client, event_class:, max_items:, max_items_before_drop:, envelope_type:, envelope_content_type:, before_send:)
+      super(configuration.sdk_logger, FLUSH_INTERVAL)
+
+      @client = client
+      @dsn = configuration.dsn
+      @debug = configuration.debug
+      @event_class = event_class
+      @max_items = max_items
+      @max_items_before_drop = max_items_before_drop
+      @envelope_type = envelope_type
+      @data_category = Sentry::Envelope::Item.data_category(@envelope_type)
+      @envelope_content_type = envelope_content_type
+      @before_send = before_send
+
+      @pending_items = []
+      @mutex = Mutex.new
+
+      log_debug("[#{self.class}] Initialized buffer with max_items=#{@max_items}, flush_interval=#{FLUSH_INTERVAL}s")
+    end
+
+    def flush
+      @mutex.synchronize do
+        return if empty?
+
+        log_debug("[#{self.class}] flushing #{size} #{@event_class}")
+
+        send_items
+      end
+
+      self
+    end
+    alias_method :run, :flush
+
+    def add_item(item)
+      @mutex.synchronize do
+        return unless ensure_thread
+
+        if size >= @max_items_before_drop
+          log_debug("[#{self.class}] exceeded max capacity, dropping event")
+          @client.transport.record_lost_event(:queue_overflow, @data_category)
+        else
+          @pending_items << item
+        end
+
+        send_items if size >= @max_items
+      end
+
+      self
+    end
+
+    def empty?
+      @pending_items.empty?
+    end
+
+    def size
+      @pending_items.size
+    end
+
+    def clear!
+      @pending_items.clear
+    end
+
+    private
+
+    def send_items
+      envelope = Envelope.new(
+        event_id: Sentry::Utils.uuid,
+        sent_at: Sentry.utc_now.iso8601,
+        dsn: @dsn,
+        sdk: Sentry.sdk_meta
+      )
+
+      discarded_count = 0
+      envelope_items = []
+
+      if @before_send
+        @pending_items.each do |item|
+          processed_item = @before_send.call(item)
+
+          if processed_item
+            envelope_items << processed_item.to_h
+          else
+            discarded_count += 1
+          end
+        end
+      else
+        envelope_items = @pending_items.map(&:to_h)
+      end
+
+      unless discarded_count.zero?
+        @client.transport.record_lost_event(:before_send, @data_category, num: discarded_count)
+      end
+
+      return if envelope_items.empty?
+
+      envelope.add_item(
+        {
+          type: @envelope_type,
+          item_count: envelope_items.size,
+          content_type: @envelope_content_type
+        },
+        { items: envelope_items }
+      )
+
+      @client.send_envelope(envelope)
+    rescue => e
+      log_error("[#{self.class}] Failed to send #{@event_class}", e, debug: @debug)
+    ensure
+      clear!
+    end
+  end
+end

data/lib/sentry/test_helper.rb

@@ -27,6 +27,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.enabled_environments += [dummy_config.environment] unless dummy_config.enabled_environments.include?(dummy_config.environment)
       # disble async event sending
       dummy_config.background_worker_threads = 0
@@ -101,6 +102,13 @@ module Sentry
         .flat_map { |item| item.payload[:items] }
     end
 
+    def sentry_metrics
+      sentry_envelopes
+        .flat_map(&:items)
+        .select { |item| item.headers[:type] == "trace_metric" }
+        .flat_map { |item| item.payload[:items] }
+    end
+
     # Returns the last captured event object.
     # @return [Event, nil]
     def last_sentry_event