sentry-ruby 5.4.2 → 5.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 310e7ac901b3da90fb400710f95be183627b1e35587f059810669469deb27763
-  data.tar.gz: 75cff84d0f7238ac444b5f6ce0a67f0150daefa38d9bac9e2b083a6f98ecff6e
+  metadata.gz: 292dc37d7e5703be7d5d2e33a84f02b492759f0c8ef656e3ae660a7196301fe4
+  data.tar.gz: 1b76f778b06e4928eb32cabe31fc208a4aa92bf8b62f447abf9dd204c97e26cb
 SHA512:
-  metadata.gz: 76251bc9b7499bc40b30c1e20c3b638a3cc5bf0a3c5df9f5210fa2b2293a3ee7e6c8c7a1d3073b1055c8788855531c36ece0517ea38e203367c0c8bf6842e130
-  data.tar.gz: cc3b7a551b8d8c798c5843b895710244857bcf110e57cc4dd1de345e7fe6e09201bf3adf3e4645d9101df201cab8ce4cda0b547b88d137ef1faab8e7a6f1693f
+  metadata.gz: ae4dbbb4e60e1dbad0e0e0e5a1fedad72e383b0709453ab4f9f6dc8cc367625e3663848885b893f28f47a3758aed7aec68fc3aa32de3974fdc9e807aa0f5d4bf
+  data.tar.gz: 2194f3cb7e4d604d8ddeaf3761406133a049a5e5870ac44e54e8d7ca90d4a41e489b39681b53c912d97c4710bd1813716863364f9de6f233e345c353b31d133f

data/Gemfile

@@ -3,12 +3,13 @@ git_source(:github) { |name| "https://github.com/#{name}.git" }
 
 gem "sentry-ruby", path: "./"
 
-gem "rack" unless ENV["WITHOUT_RACK"] == "1"
+rack_version = ENV["RACK_VERSION"]
+rack_version = "3.0.0" if rack_version.nil?
+gem "rack", "~> #{Gem::Version.new(rack_version)}" unless rack_version == "0"
 
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
 gem "rspec-retry"
-gem "webmock"
 gem "fakeredis"
 gem "timecop"
 gem 'simplecov'

data/lib/sentry/baggage.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module Sentry
+  # A {https://www.w3.org/TR/baggage W3C Baggage Header} implementation.
+  class Baggage
+    SENTRY_PREFIX = 'sentry-'
+    SENTRY_PREFIX_REGEX = /^sentry-/.freeze
+
+    DSC_KEYS = %w(
+      trace_id
+      public_key
+      sample_rate
+      release
+      environment
+      transaction
+      user_id
+      user_segment
+    ).freeze
+
+    # @return [Hash]
+    attr_reader :items
+
+    # @return [Boolean]
+    attr_reader :mutable
+
+    def initialize(items, mutable: true)
+      @items = items
+      @mutable = mutable
+    end
+
+    # Creates a Baggage object from an incoming W3C Baggage header string.
+    #
+    # Sentry items are identified with the 'sentry-' prefix and stored in a hash.
+    # The presence of a Sentry item makes the baggage object immutable.
+    #
+    # @param header [String] The incoming Baggage header string.
+    # @return [Baggage, nil]
+    def self.from_incoming_header(header)
+      items = {}
+      mutable = true
+
+      header.split(',').each do |item|
+        item = item.strip
+        key, val = item.split('=')
+
+        next unless key && val
+        next unless key =~ SENTRY_PREFIX_REGEX
+
+        baggage_key = key.split('-')[1]
+        next unless baggage_key
+
+        items[CGI.unescape(baggage_key)] = CGI.unescape(val)
+        mutable = false
+      end
+
+      new(items, mutable: mutable)
+    end
+
+    # Make the Baggage immutable.
+    # @return [void]
+    def freeze!
+      @mutable = false
+    end
+
+    # A {https://develop.sentry.dev/sdk/performance/dynamic-sampling-context/#envelope-header Dynamic Sampling Context}
+    # hash to be used in the trace envelope header.
+    # @return [Hash]
+    def dynamic_sampling_context
+      @items.select { |k, _v| DSC_KEYS.include?(k) }
+    end
+
+    # Serialize the Baggage object back to a string.
+    # @return [String]
+    def serialize
+      items = @items.map { |k, v| "#{SENTRY_PREFIX}#{CGI.escape(k)}=#{CGI.escape(v)}" }
+      items.join(',')
+    end
+  end
+end

data/lib/sentry/client.rb

@@ -105,16 +105,7 @@ module Sentry
     # @param transaction [Transaction] the transaction to be recorded.
     # @return [TransactionEvent]
     def event_from_transaction(transaction)
-      TransactionEvent.new(configuration: configuration).tap do |event|
-        event.transaction = transaction.name
-        event.contexts.merge!(trace: transaction.get_trace_context)
-        event.timestamp = transaction.timestamp
-        event.start_timestamp = transaction.start_timestamp
-        event.tags = transaction.tags
-
-        finished_spans = transaction.span_recorder.spans.select { |span| span.timestamp && span != transaction }
-        event.spans = finished_spans.map(&:to_hash)
-      end
+      TransactionEvent.new(configuration: configuration, transaction: transaction)
     end
 
     # @!macro send_event
@@ -156,6 +147,22 @@ module Sentry
       trace
     end
 
+    # Generates a W3C Baggage header for distribted tracing from the given Span.
+    # Returns `nil` if `config.propagate_traces` is `false`.
+    # @param span [Span] the span to generate trace from.
+    # @return [String, nil]
+    def generate_baggage(span)
+      return unless configuration.propagate_traces
+
+      baggage = span.to_baggage
+
+      if baggage && !baggage.empty?
+        log_debug("[Tracing] Adding #{BAGGAGE_HEADER_NAME} header to outgoing request: #{baggage}")
+      end
+
+      baggage
+    end
+
     private
 
     def dispatch_background_event(event, hint)

data/lib/sentry/event.rb

@@ -18,7 +18,7 @@ module Sentry
       event_id level timestamp
       release environment server_name modules
       message user tags contexts extra
-      fingerprint breadcrumbs transaction
+      fingerprint breadcrumbs transaction transaction_info
       platform sdk type
     )
 

data/lib/sentry/hub.rb

@@ -92,6 +92,24 @@ module Sentry
       transaction
     end
 
+    def with_child_span(**attributes, &block)
+      current_span = current_scope.get_span
+      return yield(nil) unless current_span
+
+      result = nil
+
+      begin
+        current_span.with_child_span(**attributes) do |child_span|
+          current_scope.set_span(child_span)
+          result = yield(child_span)
+        end
+      ensure
+        current_scope.set_span(current_span)
+      end
+
+      result
+    end
+
     def capture_exception(exception, **options, &block)
       check_argument_type!(exception, ::Exception)
 

data/lib/sentry/interfaces/request.rb

@@ -73,7 +73,7 @@ module Sentry
         request.POST
       elsif request.body # JSON requests, etc
         data = request.body.read(MAX_BODY_LIMIT)
-        data = encode_to_utf_8(data.to_s)
+        data = Utils::EncodingHelper.encode_to_utf_8(data.to_s)
         request.body.rewind
         data
       end
@@ -94,7 +94,7 @@ module Sentry
           key = key.sub(/^HTTP_/, "")
           key = key.split('_').map(&:capitalize).join('-')
 
-          memo[key] = encode_to_utf_8(value.to_s)
+          memo[key] = Utils::EncodingHelper.encode_to_utf_8(value.to_s)
         rescue StandardError => e
           # Rails adds objects to the Rack env that can sometimes raise exceptions
           # when `to_s` is called.
@@ -105,31 +105,21 @@ module Sentry
       end
     end
 
-    def 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
-
-      if !value.valid_encoding?
-        value = value.scrub
-      end
-
-      value
-    end
-
     def is_skippable_header?(key)
       key.upcase != key || # lower-case envs aren't real http headers
         key == "HTTP_COOKIE" || # Cookies don't go here, they go somewhere else
         !(key.start_with?('HTTP_') || CONTENT_HEADERS.include?(key))
     end
 
-    # Rack adds in an incorrect HTTP_VERSION key, which causes downstream
+    # In versions < 3, Rack adds in an incorrect HTTP_VERSION key, which causes downstream
     # to think this is a Version header. Instead, this is mapped to
     # env['SERVER_PROTOCOL']. But we don't want to ignore a valid header
     # if the request has legitimately sent a Version header themselves.
     # See: https://github.com/rack/rack/blob/028438f/lib/rack/handler/cgi.rb#L29
-    # NOTE: This will be removed in version 3.0+
     def is_server_protocol?(key, value, protocol_version)
+      rack_version = Gem::Version.new(::Rack.release)
+      return false if rack_version >= Gem::Version.new("3.0")
+
       key == 'HTTP_VERSION' && value == protocol_version
     end
 

data/lib/sentry/interfaces/single_exception.rb

@@ -15,7 +15,15 @@ module Sentry
 
     def initialize(exception:, stacktrace: nil)
       @type = exception.class.to_s
-      @value = (exception.message || "").byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES)
+      exception_message =
+        if exception.respond_to?(:detailed_message)
+          exception.detailed_message(highlight: false)
+        else
+          exception.message || ""
+        end
+
+      @value = exception_message.byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES)
+
       @module = exception.class.to_s.split('::')[0...-1].join('::')
       @thread_id = Thread.current.object_id
       @stacktrace = stacktrace

data/lib/sentry/net/http.rb

@@ -26,14 +26,21 @@ module Sentry
       #
       # So we're only instrumenting request when `Net::HTTP` is already started
       def request(req, body = nil, &block)
-        return super unless started?
+        return super unless started? && Sentry.initialized?
+        return super if from_sentry_sdk?
 
-        sentry_span = start_sentry_span
-        set_sentry_trace_header(req, sentry_span)
+        Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f) do |sentry_span|
+          set_sentry_trace_header(req, sentry_span)
 
-        super.tap do |res|
-          record_sentry_breadcrumb(req, res)
-          record_sentry_span(req, res, sentry_span)
+          super.tap do |res|
+            record_sentry_breadcrumb(req, res)
+
+            if sentry_span
+              request_info = extract_request_info(req)
+              sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
+              sentry_span.set_data(:status, res.code.to_i)
+            end
+          end
         end
       end
 
@@ -42,13 +49,17 @@ module Sentry
       def set_sentry_trace_header(req, sentry_span)
         return unless sentry_span
 
-        trace = Sentry.get_current_client.generate_sentry_trace(sentry_span)
+        client = Sentry.get_current_client
+
+        trace = client.generate_sentry_trace(sentry_span)
         req[SENTRY_TRACE_HEADER_NAME] = trace if trace
+
+        baggage = client.generate_baggage(sentry_span)
+        req[BAGGAGE_HEADER_NAME] = baggage if baggage && !baggage.empty?
       end
 
       def record_sentry_breadcrumb(req, res)
         return unless Sentry.initialized? && Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
-        return if from_sentry_sdk?
 
         request_info = extract_request_info(req)
 
@@ -64,29 +75,6 @@ module Sentry
         Sentry.add_breadcrumb(crumb)
       end
 
-      def record_sentry_span(req, res, sentry_span)
-        return unless Sentry.initialized? && sentry_span
-
-        request_info = extract_request_info(req)
-        sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
-        sentry_span.set_data(:status, res.code.to_i)
-        finish_sentry_span(sentry_span)
-      end
-
-      def start_sentry_span
-        return unless Sentry.initialized? && span = Sentry.get_current_scope.get_span
-        return if from_sentry_sdk?
-        return if span.sampled == false
-
-        span.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
-      end
-
-      def finish_sentry_span(sentry_span)
-        return unless Sentry.initialized? && sentry_span
-
-        sentry_span.set_timestamp(Sentry.utc_now.to_f)
-      end
-
       def from_sentry_sdk?
         dsn = Sentry.configuration.dsn
         dsn && dsn.host == self.address

data/lib/sentry/rack/capture_exceptions.rb

@@ -18,7 +18,7 @@ module Sentry
         Sentry.with_scope do |scope|
           Sentry.with_session_tracking do
             scope.clear_breadcrumbs
-            scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
+            scope.set_transaction_name(env["PATH_INFO"], source: :url) if env["PATH_INFO"]
             scope.set_rack_env(env)
 
             transaction = start_transaction(env, scope)
@@ -52,7 +52,7 @@ module Sentry
       end
 
       def transaction_op
-        "rack.request".freeze
+        "http.server".freeze
       end
 
       def capture_exception(exception, env)
@@ -63,8 +63,10 @@ module Sentry
 
       def start_transaction(env, scope)
         sentry_trace = env["HTTP_SENTRY_TRACE"]
-        options = { name: scope.transaction_name, op: transaction_op }
-        transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, **options) if sentry_trace
+        baggage = env["HTTP_BAGGAGE"]
+
+        options = { name: scope.transaction_name, source: scope.transaction_source, op: transaction_op }
+        transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, baggage: baggage, **options) if sentry_trace
         Sentry.start_transaction(transaction: transaction, custom_sampling_context: { env: env }, **options)
       end
 

data/lib/sentry/rake.rb

@@ -10,7 +10,7 @@ module Sentry
       def display_error_message(ex)
         Sentry.capture_exception(ex) do |scope|
           task_name = top_level_tasks.join(' ')
-          scope.set_transaction_name(task_name)
+          scope.set_transaction_name(task_name, source: :task)
           scope.set_tag("rake_task", task_name)
         end if Sentry.initialized? && !Sentry.configuration.skip_rake_integration
 

data/lib/sentry/redis.rb

@@ -3,7 +3,7 @@
 module Sentry
   # @api private
   class Redis
-    OP_NAME = "db.redis.command"
+    OP_NAME = "db.redis"
     LOGGER_NAME = :redis_logger
 
     def initialize(commands, host, port, db)
@@ -13,9 +13,14 @@ module Sentry
     def instrument
       return yield unless Sentry.initialized?
 
-      record_span do
+      Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f) do |span|
         yield.tap do
           record_breadcrumb
+
+          if span
+            span.set_description(commands_description)
+            span.set_data(:server, server_description)
+          end
         end
       end
     end
@@ -24,18 +29,6 @@ module Sentry
 
     attr_reader :commands, :host, :port, :db
 
-    def record_span
-      return yield unless (transaction = Sentry.get_current_scope.get_transaction) && transaction.sampled
-
-      sentry_span = transaction.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
-
-      yield.tap do
-        sentry_span.set_description(commands_description)
-        sentry_span.set_data(:server, server_description)
-        sentry_span.set_timestamp(Sentry.utc_now.to_f)
-      end
-    end
-
     def record_breadcrumb
       return unless Sentry.configuration.breadcrumbs_logger.include?(LOGGER_NAME)
 
@@ -61,10 +54,15 @@ module Sentry
     def parsed_commands
       commands.map do |statement|
         command, key, *arguments = statement
+        command_set = { command: command.to_s.upcase, key: key }
 
-        { command: command.to_s.upcase, key: key }.tap do |command_set|
-          command_set[:arguments] = arguments.join(" ") if Sentry.configuration.send_default_pii
+        if Sentry.configuration.send_default_pii
+          command_set[:arguments] = arguments
+                                    .select { |a| Utils::EncodingHelper.valid_utf_8?(a) }
+                                    .join(" ")
         end
+
+        command_set
       end
     end
 

data/lib/sentry/scope.rb

@@ -7,7 +7,21 @@ module Sentry
   class Scope
     include ArgumentCheckingHelper
 
-    ATTRIBUTES = [:transaction_names, :contexts, :extra, :tags, :user, :level, :breadcrumbs, :fingerprint, :event_processors, :rack_env, :span, :session]
+    ATTRIBUTES = [
+      :transaction_names,
+      :transaction_sources,
+      :contexts,
+      :extra,
+      :tags,
+      :user,
+      :level,
+      :breadcrumbs,
+      :fingerprint,
+      :event_processors,
+      :rack_env,
+      :span,
+      :session
+    ]
 
     attr_reader(*ATTRIBUTES)
 
@@ -33,6 +47,7 @@ module Sentry
       event.extra = extra.merge(event.extra)
       event.contexts = contexts.merge(event.contexts)
       event.transaction = transaction_name if transaction_name
+      event.transaction_info = { source: transaction_source } if transaction_source
 
       if span
         event.contexts[:trace] = span.get_trace_context
@@ -73,7 +88,8 @@ module Sentry
       copy.extra = extra.deep_dup
       copy.tags = tags.deep_dup
       copy.user = user.deep_dup
-      copy.transaction_names = transaction_names.deep_dup
+      copy.transaction_names = transaction_names.dup
+      copy.transaction_sources = transaction_sources.dup
       copy.fingerprint = fingerprint.deep_dup
       copy.span = span.deep_dup
       copy.session = session.deep_dup
@@ -90,6 +106,7 @@ module Sentry
       self.tags = scope.tags
       self.user = scope.user
       self.transaction_names = scope.transaction_names
+      self.transaction_sources = scope.transaction_sources
       self.fingerprint = scope.fingerprint
       self.span = scope.span
     end
@@ -195,8 +212,9 @@ module Sentry
     # The "transaction" here does not refer to `Transaction` objects.
     # @param transaction_name [String]
     # @return [void]
-    def set_transaction_name(transaction_name)
+    def set_transaction_name(transaction_name, source: :custom)
       @transaction_names << transaction_name
+      @transaction_sources << source
     end
 
     # Sets the currently active session on the scope.
@@ -213,6 +231,13 @@ module Sentry
       @transaction_names.last
     end
 
+    # Returns current transaction source.
+    # The "transaction" here does not refer to `Transaction` objects.
+    # @return [String, nil]
+    def transaction_source
+      @transaction_sources.last
+    end
+
     # Returns the associated Transaction object.
     # @return [Transaction, nil]
     def get_transaction
@@ -256,6 +281,7 @@ module Sentry
       @level = :error
       @fingerprint = []
       @transaction_names = []
+      @transaction_sources = []
       @event_processors = []
       @rack_env = {}
       @span = nil

data/lib/sentry/session.rb

@@ -2,7 +2,7 @@
 
 module Sentry
   class Session
-    attr_reader :started, :status
+    attr_reader :started, :status, :aggregation_key
 
     # TODO-neel add :crashed after adding handled mechanism
     STATUSES = %i(ok errored exited)
@@ -11,6 +11,10 @@ module Sentry
     def initialize
       @started = Sentry.utc_now
       @status = :ok
+
+      # truncate seconds from the timestamp since we only care about
+      # minute level granularity for aggregation
+      @aggregation_key = Time.utc(@started.year, @started.month, @started.day, @started.hour, @started.min)
     end
 
     # TODO-neel add :crashed after adding handled mechanism
@@ -22,12 +26,6 @@ module Sentry
       @status = :exited if @status == :ok
     end
 
-    # truncate seconds from the timestamp since we only care about
-    # minute level granularity for aggregation
-    def aggregation_key
-      Time.utc(started.year, started.month, started.day, started.hour, started.min)
-    end
-
     def deep_dup
       dup
     end

data/lib/sentry/span.rb

@@ -60,9 +60,10 @@ 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,
@@ -79,6 +80,7 @@ module Sentry
       @start_timestamp = start_timestamp || Sentry.utc_now.to_f
       @timestamp = timestamp
       @description = description
+      @transaction = transaction
       @op = op
       @status = status
       @data = {}
@@ -104,6 +106,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 +145,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

data/lib/sentry/test_helper.rb

@@ -31,6 +31,7 @@ module Sentry
 
       test_client = Sentry::Client.new(copied_config)
       Sentry.get_current_hub.bind_client(test_client)
+      Sentry.get_current_scope.clear
     end
 
     # Clears all stored events and envelopes.
@@ -41,6 +42,7 @@ module Sentry
 
       sentry_transport.events = []
       sentry_transport.envelopes = []
+      Sentry.get_current_scope.clear
     end
 
     # @return [Transport]

data/lib/sentry/transaction.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "sentry/baggage"
+
 module Sentry
   class Transaction < Span
     SENTRY_TRACE_REGEXP = Regexp.new(
@@ -12,16 +14,29 @@ module Sentry
     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
+
     # @deprecated Use Sentry.get_current_hub instead.
     attr_reader :hub
 
@@ -31,18 +46,34 @@ 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
+
+    def initialize(
+      hub:,
+      name: nil,
+      source: :custom,
+      parent_sampled: nil,
+      baggage: nil,
+      **options
+    )
+      super(transaction: self, **options)
 
       @name = name
+      @source = SOURCES.include?(source) ? source.to_sym : :custom
       @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
       init_span_recorder
     end
 
@@ -52,10 +83,11 @@ module Sentry
     #
     # 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
 
@@ -70,13 +102,38 @@ module Sentry
           sampled_flag != "0"
         end
 
-      new(trace_id: trace_id, parent_span_id: parent_span_id, parent_sampled: parent_sampled, hub: hub, **options)
+      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
 
     # @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
 
@@ -103,7 +160,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 +176,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
@@ -172,6 +236,14 @@ module Sentry
       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
+
     protected
 
     def init_span_recorder(limit = 1000)
@@ -188,6 +260,29 @@ module Sentry
       result
     end
 
+    def populate_head_baggage
+      items = {
+        "trace_id" => trace_id,
+        "sample_rate" => effective_sample_rate&.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,27 @@ module Sentry
     # @return [<Array[Span]>]
     attr_accessor :spans
 
+    # @return [Hash, nil]
+    attr_accessor :dynamic_sampling_context
+
     # @return [Float, nil]
     attr_reader :start_timestamp
 
+    def initialize(transaction:, **options)
+      super(**options)
+
+      self.transaction = transaction.name
+      self.transaction_info = { source: transaction.source }
+      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
+
+      finished_spans = transaction.span_recorder.spans.select { |span| span.timestamp && span != transaction }
+      self.spans = finished_spans.map(&:to_hash)
+    end
+
     # Sets the event's start_timestamp.
     # @param time [Time, Float]
     # @return [void]

data/lib/sentry/transport.rb

@@ -136,14 +136,18 @@ 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?(TransactionEvent) && 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' },

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.6.0"
 end

data/lib/sentry-ruby.rb

@@ -8,6 +8,7 @@ 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"
@@ -39,6 +40,8 @@ module Sentry
 
   SENTRY_TRACE_HEADER_NAME = "sentry-trace".freeze
 
+  BAGGAGE_HEADER_NAME = "baggage".freeze
+
   THREAD_LOCAL = :sentry_hub
 
   class << self
@@ -348,7 +351,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
 
@@ -439,22 +442,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.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby
 version: !ruby/object:Gem::Version
-  version: 5.4.2
+  version: 5.6.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-17 00:00:00.000000000 Z
+date: 2022-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -53,6 +53,7 @@ files:
 - lib/sentry-ruby.rb
 - lib/sentry/background_worker.rb
 - lib/sentry/backtrace.rb
+- lib/sentry/baggage.rb
 - lib/sentry/breadcrumb.rb
 - lib/sentry/breadcrumb/sentry_logger.rb
 - lib/sentry/breadcrumb_buffer.rb
@@ -95,6 +96,7 @@ files:
 - lib/sentry/transport/http_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