sentry-ruby 5.26.0 → 6.5.0

data/lib/sentry/metric_event.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "sentry/utils/telemetry_attributes"
+
+module Sentry
+  class MetricEvent
+    include Sentry::Utils::TelemetryAttributes
+
+    attr_reader :name, :type, :value, :unit, :timestamp, :trace_id, :span_id, :attributes
+    attr_writer :trace_id, :span_id, :attributes
+
+    def initialize(
+      name:,
+      type:,
+      value:,
+      unit: nil,
+      attributes: nil
+    )
+      @name = name
+      @type = type
+      @value = value
+      @unit = unit
+      @attributes = attributes || {}
+
+      @timestamp = Sentry.utc_now
+      @trace_id = nil
+      @span_id = nil
+    end
+
+    def to_h
+      {
+        name: @name,
+        type: @type,
+        value: @value,
+        unit: @unit,
+        timestamp: @timestamp.to_f,
+        trace_id: @trace_id,
+        span_id: @span_id,
+        attributes: serialize_attributes
+      }.compact
+    end
+
+    private
+
+    def serialize_attributes
+      @attributes.transform_values { |v| attribute_hash(v) }
+    end
+  end
+end

data/lib/sentry/metric_event_buffer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "sentry/telemetry_event_buffer"
+
+module Sentry
+  # MetricEventBuffer buffers metric events and sends them to Sentry in a single envelope.
+  #
+  # This is used internally by the `Sentry::Client`.
+  #
+  # @!visibility private
+  class MetricEventBuffer < TelemetryEventBuffer
+    DEFAULT_MAX_METRICS = 1000
+    MAX_METRICS_BEFORE_DROP = 10_000
+
+    def initialize(configuration, client)
+      super(
+        configuration,
+        client,
+        event_class: MetricEvent,
+        max_items: configuration.max_metric_events || DEFAULT_MAX_METRICS,
+        max_items_before_drop: MAX_METRICS_BEFORE_DROP,
+        envelope_type: "trace_metric",
+        envelope_content_type: "application/vnd.sentry.items.trace-metric+json",
+        before_send: configuration.before_send_metric
+      )
+    end
+  end
+end

data/lib/sentry/metrics.rb

@@ -1,55 +1,60 @@
 # frozen_string_literal: true
 
-require "sentry/metrics/metric"
-require "sentry/metrics/counter_metric"
-require "sentry/metrics/distribution_metric"
-require "sentry/metrics/gauge_metric"
-require "sentry/metrics/set_metric"
-require "sentry/metrics/timing"
-require "sentry/metrics/aggregator"
+require "sentry/metric_event"
 
 module Sentry
   module Metrics
-    DURATION_UNITS = %w[nanosecond microsecond millisecond second minute hour day week]
-    INFORMATION_UNITS = %w[bit byte kilobyte kibibyte megabyte mebibyte gigabyte gibibyte terabyte tebibyte petabyte pebibyte exabyte exbibyte]
-    FRACTIONAL_UNITS = %w[ratio percent]
-
-    OP_NAME = "metric.timing"
-    SPAN_ORIGIN = "auto.metric.timing"
-
     class << self
-      def increment(key, value = 1.0, unit: "none", tags: {}, timestamp: nil)
-        Sentry.metrics_aggregator&.add(:c, key, value, unit: unit, tags: tags, timestamp: timestamp)
-      end
-
-      def distribution(key, value, unit: "none", tags: {}, timestamp: nil)
-        Sentry.metrics_aggregator&.add(:d, key, value, unit: unit, tags: tags, timestamp: timestamp)
-      end
-
-      def set(key, value, unit: "none", tags: {}, timestamp: nil)
-        Sentry.metrics_aggregator&.add(:s, key, value, unit: unit, tags: tags, timestamp: timestamp)
+      # Increments a counter metric
+      # @param name [String] the metric name
+      # @param value [Numeric] the value to increment by (default: 1)
+      # @param attributes [Hash, nil] additional attributes for the metric (optional)
+      # @return [void]
+      def count(name, value: 1, attributes: nil)
+        return unless Sentry.initialized?
+
+        Sentry.get_current_hub.capture_metric(
+          name: name,
+          type: :counter,
+          value: value,
+          attributes: attributes
+        )
       end
 
-      def gauge(key, value, unit: "none", tags: {}, timestamp: nil)
-        Sentry.metrics_aggregator&.add(:g, key, value, unit: unit, tags: tags, timestamp: timestamp)
+      # Records a gauge metric
+      # @param name [String] the metric name
+      # @param value [Numeric] the gauge value
+      # @param unit [String, nil] the metric unit (optional)
+      # @param attributes [Hash, nil] additional attributes for the metric (optional)
+      # @return [void]
+      def gauge(name, value, unit: nil, attributes: nil)
+        return unless Sentry.initialized?
+
+        Sentry.get_current_hub.capture_metric(
+          name: name,
+          type: :gauge,
+          value: value,
+          unit: unit,
+          attributes: attributes
+        )
       end
 
-      def timing(key, unit: "second", tags: {}, timestamp: nil, &block)
-        return unless block_given?
-        return yield unless DURATION_UNITS.include?(unit)
-
-        result, value = Sentry.with_child_span(op: OP_NAME, description: key, origin: SPAN_ORIGIN) do |span|
-          tags.each { |k, v| span.set_tag(k, v.is_a?(Array) ? v.join(", ") : v.to_s) } if span
-
-          start = Timing.send(unit.to_sym)
-          result = yield
-          value = Timing.send(unit.to_sym) - start
-
-          [result, value]
-        end
-
-        Sentry.metrics_aggregator&.add(:d, key, value, unit: unit, tags: tags, timestamp: timestamp)
-        result
+      # Records a distribution metric
+      # @param name [String] the metric name
+      # @param value [Numeric] the distribution value
+      # @param unit [String, nil] the metric unit (optional)
+      # @param attributes [Hash, nil] additional attributes for the metric (optional)
+      # @return [void]
+      def distribution(name, value, unit: nil, attributes: nil)
+        return unless Sentry.initialized?
+
+        Sentry.get_current_hub.capture_metric(
+          name: name,
+          type: :distribution,
+          value: value,
+          unit: unit,
+          attributes: attributes
+        )
       end
     end
   end

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

@@ -3,15 +3,14 @@
 require "securerandom"
 require "sentry/baggage"
 require "sentry/utils/uuid"
+require "sentry/utils/sample_rand"
 
 module Sentry
   class PropagationContext
     SENTRY_TRACE_REGEXP = Regexp.new(
-      "^[ \t]*" +  # whitespace
-      "([0-9a-f]{32})?" +  # trace_id
+      "\\A([0-9a-f]{32})?" + # trace_id
       "-?([0-9a-f]{16})?" +  # span_id
-      "-?([01])?" +  # sampled
-      "[ \t]*$"  # whitespace
+      "-?([01])?\\z"         # sampled
     )
 
     # An uuid that can be used to identify a trace.
@@ -33,6 +32,91 @@ module Sentry
     # Please use the #get_baggage method for interfacing outside this class.
     # @return [Baggage, nil]
     attr_reader :baggage
+    # The propagated random value used for sampling decisions.
+    # @return [Float, nil]
+    attr_reader :sample_rand
+
+    # Extract the trace_id, parent_span_id and parent_sampled values from a sentry-trace header.
+    #
+    # @param sentry_trace [String] the sentry-trace header value from the previous transaction.
+    # @return [Array, nil]
+    def self.extract_sentry_trace(sentry_trace)
+      value = sentry_trace.to_s.strip
+      return if value.empty?
+
+      match = SENTRY_TRACE_REGEXP.match(value)
+      return if match.nil?
+
+      trace_id, parent_span_id, sampled_flag = match[1..3]
+      parent_sampled = sampled_flag.nil? ? nil : sampled_flag != "0"
+
+      [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
+
+      sample_rand_str = baggage.items["sample_rand"]
+      return unless sample_rand_str
+
+      generator = Utils::SampleRand.new(trace_id: trace_id)
+      generator.generate_from_value(sample_rand_str)
+    end
+
+    def self.generate_sample_rand(baggage, trace_id, parent_sampled)
+      generator = Utils::SampleRand.new(trace_id: trace_id)
+
+      if baggage&.items && !parent_sampled.nil?
+        sample_rate_str = baggage.items["sample_rate"]
+        sample_rate = sample_rate_str&.to_f
+
+        if sample_rate && !parent_sampled.nil?
+          generator.generate_from_sampling_decision(parent_sampled, sample_rate)
+        else
+          generator.generate_from_trace_id
+        end
+      else
+        generator.generate_from_trace_id
+      end
+    end
 
     def initialize(scope, env = nil)
       @scope = scope
@@ -40,6 +124,7 @@ module Sentry
       @parent_sampled = nil
       @baggage = nil
       @incoming_trace = false
+      @sample_rand = nil
 
       if env
         sentry_trace_header = env["HTTP_SENTRY_TRACE"] || env[SENTRY_TRACE_HEADER_NAME]
@@ -49,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
@@ -61,28 +144,20 @@ module Sentry
                 Baggage.new({})
               end
 
-            @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
 
       @trace_id ||= Utils.uuid
       @span_id = Utils.uuid.slice(0, 16)
-    end
-
-    # Extract the trace_id, parent_span_id and parent_sampled values from a sentry-trace header.
-    #
-    # @param sentry_trace [String] the sentry-trace header value from the previous transaction.
-    # @return [Array, nil]
-    def self.extract_sentry_trace(sentry_trace)
-      match = SENTRY_TRACE_REGEXP.match(sentry_trace)
-      return nil if match.nil?
-
-      trace_id, parent_span_id, sampled_flag = match[1..3]
-      parent_sampled = sampled_flag.nil? ? nil : sampled_flag != "0"
-
-      [trace_id, parent_span_id, parent_sampled]
+      @sample_rand ||= self.class.generate_sample_rand(@baggage, @trace_id, @parent_sampled)
     end
 
     # Returns the trace context that can be used to embed in an Event.
@@ -123,9 +198,11 @@ module Sentry
 
       items = {
         "trace_id" => trace_id,
+        "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