sentry-ruby 5.4.2 → 5.16.1

data/lib/sentry/span.rb

@@ -4,6 +4,43 @@ require "securerandom"
 
 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
+      URL = "url"
+      HTTP_STATUS_CODE = "http.response.status_code"
+      HTTP_QUERY = "http.query"
+      HTTP_METHOD = "http.request.method"
+
+      # An identifier for the database management system (DBMS) product being used.
+      # Example: postgresql
+      DB_SYSTEM = "db.system"
+
+      # The name of the database being accessed.
+      # For commands that switch the database, this should be set to the target database
+      # (even if the command fails).
+      # Example: myDatabase
+      DB_NAME = "db.name"
+
+      # Name of the database host.
+      # Example: example.com
+      SERVER_ADDRESS = "server.address"
+
+      # Logical server port number
+      # Example: 80; 8080; 443
+      SERVER_PORT = "server.port"
+
+      # Physical server IP address or Unix socket address.
+      # Example: 10.5.3.2
+      SERVER_SOCKET_ADDRESS = "server.socket.address"
+
+      # Physical server port.
+      # Recommended: If different than server.port.
+      # Example: 16456
+      SERVER_SOCKET_PORT = "server.socket.port"
+    end
+
     STATUS_MAP = {
       400 => "invalid_argument",
       401 => "unauthenticated",
@@ -60,25 +97,28 @@ module Sentry
     # The Transaction object the Span belongs to.
     # Every span needs to be attached to a Transaction and their child spans will also inherit the same transaction.
     # @return [Transaction]
-    attr_accessor :transaction
+    attr_reader :transaction
 
     def initialize(
+      transaction:,
       description: nil,
       op: nil,
       status: nil,
       trace_id: nil,
+      span_id: nil,
       parent_span_id: nil,
       sampled: nil,
       start_timestamp: nil,
       timestamp: nil
     )
       @trace_id = trace_id || SecureRandom.uuid.delete("-")
-      @span_id = SecureRandom.hex(8)
+      @span_id = span_id || SecureRandom.uuid.delete("-").slice(0, 16)
       @parent_span_id = parent_span_id
       @sampled = sampled
       @start_timestamp = start_timestamp || Sentry.utc_now.to_f
       @timestamp = timestamp
       @description = description
+      @transaction = transaction
       @op = op
       @status = status
       @data = {}
@@ -87,11 +127,8 @@ module Sentry
 
     # Finishes the span by adding a timestamp.
     # @return [self]
-    def finish
-      # already finished
-      return if @timestamp
-
-      @timestamp = Sentry.utc_now.to_f
+    def finish(end_timestamp: nil)
+      @timestamp = end_timestamp || @timestamp || Sentry.utc_now.to_f
       self
     end
 
@@ -104,6 +141,13 @@ module Sentry
       "#{@trace_id}-#{@span_id}-#{sampled_flag}"
     end
 
+    # Generates a W3C Baggage header string for distributed tracing
+    # from the incoming baggage stored on the transaction.
+    # @return [String, nil]
+    def to_baggage
+      transaction.get_baggage&.serialize
+    end
+
     # @return [Hash]
     def to_hash
       {
@@ -136,9 +180,8 @@ module Sentry
     # Starts a child span with given attributes.
     # @param attributes [Hash] the attributes for the child span.
     def start_child(**attributes)
-      attributes = attributes.dup.merge(trace_id: @trace_id, parent_span_id: @span_id, sampled: @sampled)
+      attributes = attributes.dup.merge(transaction: @transaction, trace_id: @trace_id, parent_span_id: @span_id, sampled: @sampled)
       new_span = Span.new(**attributes)
-      new_span.transaction = transaction
       new_span.span_recorder = span_recorder
 
       if span_recorder
@@ -163,6 +206,10 @@ module Sentry
       yield(child_span)
 
       child_span.finish
+    rescue
+      child_span.set_http_status(500)
+      child_span.finish
+      raise
     end
 
     def deep_dup
@@ -198,7 +245,7 @@ module Sentry
     # @param status_code [String] example: "500".
     def set_http_status(status_code)
       status_code = status_code.to_i
-      set_data("status_code", status_code)
+      set_data(DataConventions::HTTP_STATUS_CODE, status_code)
 
       status =
         if status_code >= 200 && status_code < 299

data/lib/sentry/test_helper.rb

@@ -14,22 +14,27 @@ module Sentry
     # @return [void]
     def setup_sentry_test(&block)
       raise "please make sure the SDK is initialized for testing" unless Sentry.initialized?
-      copied_config = Sentry.configuration.dup
+      dummy_config = Sentry.configuration.dup
       # configure dummy DSN, so the events will not be sent to the actual service
-      copied_config.dsn = DUMMY_DSN
+      dummy_config.dsn = DUMMY_DSN
       # set transport to DummyTransport, so we can easily intercept the captured events
-      copied_config.transport.transport_class = Sentry::DummyTransport
+      dummy_config.transport.transport_class = Sentry::DummyTransport
       # make sure SDK allows sending under the current environment
-      copied_config.enabled_environments << copied_config.environment unless copied_config.enabled_environments.include?(copied_config.environment)
+      dummy_config.enabled_environments << dummy_config.environment unless dummy_config.enabled_environments.include?(dummy_config.environment)
       # disble async event sending
-      copied_config.background_worker_threads = 0
+      dummy_config.background_worker_threads = 0
 
       # user can overwrite some of the configs, with a few exceptions like:
-      # - capture_exception_frame_locals
+      # - include_local_variables
       # - auto_session_tracking
-      block&.call(copied_config)
+      block&.call(dummy_config)
 
-      test_client = Sentry::Client.new(copied_config)
+      # the base layer's client should already use the dummy config so nothing will be sent by accident
+      base_client = Sentry::Client.new(dummy_config)
+      Sentry.get_current_hub.bind_client(base_client)
+      # create a new layer so mutations made to the testing scope or configuration could be simply popped later
+      Sentry.get_current_hub.push_scope
+      test_client = Sentry::Client.new(dummy_config.dup)
       Sentry.get_current_hub.bind_client(test_client)
     end
 
@@ -39,8 +44,12 @@ module Sentry
     def teardown_sentry_test
       return unless Sentry.initialized?
 
-      sentry_transport.events = []
-      sentry_transport.envelopes = []
+      # pop testing layer created by `setup_sentry_test`
+      # but keep the base layer to avoid nil-pointer errors
+      # TODO: find a way to notify users if they somehow popped the test layer before calling this method
+      if Sentry.get_current_hub.instance_variable_get(:@stack).size > 1
+        Sentry.get_current_hub.pop_scope
+      end
     end
 
     # @return [Transport]
@@ -73,4 +82,3 @@ module Sentry
     end
   end
 end
-

data/lib/sentry/transaction.rb

@@ -1,27 +1,44 @@
 # frozen_string_literal: true
 
+require "sentry/baggage"
+require "sentry/profiler"
+require "sentry/propagation_context"
+
 module Sentry
   class Transaction < Span
-    SENTRY_TRACE_REGEXP = Regexp.new(
-      "^[ \t]*" +  # whitespace
-      "([0-9a-f]{32})?" +  # trace_id
-      "-?([0-9a-f]{16})?" +  # span_id
-      "-?([01])?" +  # sampled
-      "[ \t]*$"  # whitespace
-    )
+    # @deprecated Use Sentry::PropagationContext::SENTRY_TRACE_REGEXP instead.
+    SENTRY_TRACE_REGEXP = PropagationContext::SENTRY_TRACE_REGEXP
+
     UNLABELD_NAME = "<unlabeled transaction>".freeze
     MESSAGE_PREFIX = "[Tracing]"
 
+    # https://develop.sentry.dev/sdk/event-payloads/transaction/#transaction-annotations
+    SOURCES = %i(custom url route view component task)
+
     include LoggingHelper
 
     # The name of the transaction.
     # @return [String]
     attr_reader :name
 
+    # The source of the transaction name.
+    # @return [Symbol]
+    attr_reader :source
+
     # The sampling decision of the parent transaction, which will be considered when making the current transaction's sampling decision.
     # @return [String]
     attr_reader :parent_sampled
 
+    # The parsed incoming W3C baggage header.
+    # This is only for accessing the current baggage variable.
+    # Please use the #get_baggage method for interfacing outside this class.
+    # @return [Baggage, nil]
+    attr_reader :baggage
+
+    # The measurements added to the transaction.
+    # @return [Hash]
+    attr_reader :measurements
+
     # @deprecated Use Sentry.get_current_hub instead.
     attr_reader :hub
 
@@ -31,52 +48,106 @@ module Sentry
     # @deprecated Use Sentry.logger instead.
     attr_reader :logger
 
-    def initialize(name: nil, parent_sampled: nil, hub:, **options)
-      super(**options)
+    # The effective sample rate at which this transaction was sampled.
+    # @return [Float, nil]
+    attr_reader :effective_sample_rate
 
-      @name = name
+    # Additional contexts stored directly on the transaction object.
+    # @return [Hash]
+    attr_reader :contexts
+
+    # The Profiler instance for this transaction.
+    # @return [Profiler]
+    attr_reader :profiler
+
+    def initialize(
+      hub:,
+      name: nil,
+      source: :custom,
+      parent_sampled: nil,
+      baggage: nil,
+      **options
+    )
+      super(transaction: self, **options)
+
+      set_name(name, source: source)
       @parent_sampled = parent_sampled
-      @transaction = self
       @hub = hub
+      @baggage = baggage
       @configuration = hub.configuration # to be removed
       @tracing_enabled = hub.configuration.tracing_enabled?
       @traces_sampler = hub.configuration.traces_sampler
       @traces_sample_rate = hub.configuration.traces_sample_rate
       @logger = hub.configuration.logger
+      @release = hub.configuration.release
+      @environment = hub.configuration.environment
+      @dsn = hub.configuration.dsn
+      @effective_sample_rate = nil
+      @contexts = {}
+      @measurements = {}
+      @profiler = Profiler.new(@configuration)
       init_span_recorder
     end
 
+    # @deprecated use Sentry.continue_trace instead.
+    #
     # Initalizes a Transaction instance with a Sentry trace string from another transaction (usually from an external request).
     #
     # The original transaction will become the parent of the new Transaction instance. And they will share the same `trace_id`.
     #
     # The child transaction will also store the parent's sampling decision in its `parent_sampled` attribute.
     # @param sentry_trace [String] the trace string from the previous transaction.
+    # @param baggage [String, nil] the incoming baggage header string.
     # @param hub [Hub] the hub that'll be responsible for sending this transaction when it's finished.
     # @param options [Hash] the options you want to use to initialize a Transaction instance.
     # @return [Transaction, nil]
-    def self.from_sentry_trace(sentry_trace, hub: Sentry.get_current_hub, **options)
+    def self.from_sentry_trace(sentry_trace, baggage: nil, hub: Sentry.get_current_hub, **options)
       return unless hub.configuration.tracing_enabled?
       return unless sentry_trace
 
-      match = SENTRY_TRACE_REGEXP.match(sentry_trace)
-      return if match.nil?
-      trace_id, parent_span_id, sampled_flag = match[1..3]
-
-      parent_sampled =
-        if sampled_flag.nil?
-          nil
-        else
-          sampled_flag != "0"
-        end
+      sentry_trace_data = extract_sentry_trace(sentry_trace)
+      return unless sentry_trace_data
+
+      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.freeze!
+
+      new(
+        trace_id: trace_id,
+        parent_span_id: parent_span_id,
+        parent_sampled: parent_sampled,
+        hub: hub,
+        baggage: baggage,
+        **options
+      )
+    end
 
-      new(trace_id: trace_id, parent_span_id: parent_span_id, parent_sampled: parent_sampled, hub: hub, **options)
+    # @deprecated Use Sentry::PropagationContext.extract_sentry_trace instead.
+    # @return [Array, nil]
+    def self.extract_sentry_trace(sentry_trace)
+      PropagationContext.extract_sentry_trace(sentry_trace)
     end
 
     # @return [Hash]
     def to_hash
       hash = super
-      hash.merge!(name: @name, sampled: @sampled, parent_sampled: @parent_sampled)
+
+      hash.merge!(
+        name: @name,
+        source: @source,
+        sampled: @sampled,
+        parent_sampled: @parent_sampled
+      )
+
       hash
     end
 
@@ -94,6 +165,15 @@ module Sentry
       copy
     end
 
+    # Sets a custom measurement on the transaction.
+    # @param name [String] name of the measurement
+    # @param value [Float] value of the measurement
+    # @param unit [String] unit of the measurement
+    # @return [void]
+    def set_measurement(name, value, unit = "")
+      @measurements[name] = { value: value, unit: unit }
+    end
+
     # Sets initial sampling decision of the transaction.
     # @param sampling_context [Hash] a context Hash that'll be passed to `traces_sampler` (if provided).
     # @return [void]
@@ -103,7 +183,10 @@ module Sentry
         return
       end
 
-      return unless @sampled.nil?
+      unless @sampled.nil?
+        @effective_sample_rate = @sampled ? 1.0 : 0.0
+        return
+      end
 
       sample_rate =
         if @traces_sampler.is_a?(Proc)
@@ -116,7 +199,11 @@ module Sentry
 
       transaction_description = generate_transaction_description
 
-      unless [true, false].include?(sample_rate) || (sample_rate.is_a?(Numeric) && sample_rate >= 0.0 && sample_rate <= 1.0)
+      if [true, false].include?(sample_rate)
+        @effective_sample_rate = sample_rate ? 1.0 : 0.0
+      elsif sample_rate.is_a?(Numeric) && sample_rate >= 0.0 && sample_rate <= 1.0
+        @effective_sample_rate = sample_rate.to_f
+      else
         @sampled = false
         log_warn("#{MESSAGE_PREFIX} Discarding #{transaction_description} because of invalid sample_rate: #{sample_rate}")
         return
@@ -131,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
@@ -146,7 +238,7 @@ module Sentry
     # Finishes the transaction's recording and send it to Sentry.
     # @param hub [Hub] the hub that'll send this transaction. (Deprecated)
     # @return [TransactionEvent]
-    def finish(hub: nil)
+    def finish(hub: nil, end_timestamp: nil)
       if hub
         log_warn(
           <<~MSG
@@ -158,20 +250,57 @@ module Sentry
 
       hub ||= @hub
 
-      super() # Span#finish doesn't take arguments
+      super(end_timestamp: end_timestamp)
 
       if @name.nil?
         @name = UNLABELD_NAME
       end
 
+      @profiler.stop
+
       if @sampled
         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
 
+    # Get the existing frozen incoming baggage
+    # or populate one with sentry- items as the head SDK.
+    # @return [Baggage]
+    def get_baggage
+      populate_head_baggage if @baggage.nil? || @baggage.mutable
+      @baggage
+    end
+
+    # Set the transaction name directly.
+    # Considered internal api since it bypasses the usual scope logic.
+    # @param name [String]
+    # @param source [Symbol]
+    # @return [void]
+    def set_name(name, source: :custom)
+      @name = name
+      @source = SOURCES.include?(source) ? source.to_sym : :custom
+    end
+
+    # Set contexts directly on the transaction.
+    # @param key [String, Symbol]
+    # @param value [Object]
+    # @return [void]
+    def set_context(key, value)
+      @contexts[key] = value
+    end
+
+    # Start the profiler.
+    # @return [void]
+    def start_profiler!
+      profiler.set_initial_sample_decision(sampled)
+      profiler.start
+    end
+
     protected
 
     def init_span_recorder(limit = 1000)
@@ -188,6 +317,30 @@ module Sentry
       result
     end
 
+    def populate_head_baggage
+      items = {
+        "trace_id" => trace_id,
+        "sample_rate" => effective_sample_rate&.to_s,
+        "sampled" => sampled&.to_s,
+        "environment" => @environment,
+        "release" => @release,
+        "public_key" => @dsn&.public_key
+      }
+
+      items["transaction"] = name unless source_low_quality?
+
+      user = @hub.current_scope&.user
+      items["user_segment"] = user["segment"] if user && user["segment"]
+
+      items.compact!
+      @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

@@ -8,9 +8,34 @@ module Sentry
     # @return [<Array[Span]>]
     attr_accessor :spans
 
+    # @return [Hash]
+    attr_accessor :measurements
+
     # @return [Float, nil]
     attr_reader :start_timestamp
 
+    # @return [Hash, nil]
+    attr_accessor :profile
+
+    def initialize(transaction:, **options)
+      super(**options)
+
+      self.transaction = transaction.name
+      self.transaction_info = { source: transaction.source }
+      self.contexts.merge!(transaction.contexts)
+      self.contexts.merge!(trace: transaction.get_trace_context)
+      self.timestamp = transaction.timestamp
+      self.start_timestamp = transaction.start_timestamp
+      self.tags = transaction.tags
+      self.dynamic_sampling_context = transaction.get_baggage.dynamic_sampling_context
+      self.measurements = transaction.measurements
+
+      finished_spans = transaction.span_recorder.spans.select { |span| span.timestamp && span != transaction }
+      self.spans = finished_spans.map(&:to_hash)
+
+      populate_profile(transaction)
+    end
+
     # Sets the event's start_timestamp.
     # @param time [Time, Float]
     # @return [void]
@@ -23,7 +48,33 @@ module Sentry
       data = super
       data[:spans] = @spans.map(&:to_hash) if @spans
       data[:start_timestamp] = @start_timestamp
+      data[:measurements] = @measurements
       data
     end
+
+    private
+
+    def populate_profile(transaction)
+      profile_hash = transaction.profiler.to_hash
+      return if profile_hash.empty?
+
+      profile_hash.merge!(
+        environment: environment,
+        release: release,
+        timestamp: Time.at(start_timestamp).iso8601,
+        device: { architecture: Scope.os_context[:machine] },
+        os: { name: Scope.os_context[:name], version: Scope.os_context[:version] },
+        runtime: Scope.runtime_context,
+        transaction: {
+          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'
+        }
+      )
+
+      self.profile = profile_hash
+    end
   end
 end

data/lib/sentry/transport/configuration.rb

@@ -3,7 +3,80 @@
 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