sentry-ruby 5.10.0 → 5.14.0

data/lib/sentry/net/http.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "net/http"
+require "resolv"
 
 module Sentry
   # @api private
@@ -30,18 +31,21 @@ module Sentry
         return super if from_sentry_sdk?
 
         Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f) do |sentry_span|
-          set_sentry_trace_header(req, sentry_span)
+          request_info = extract_request_info(req)
+
+          if propagate_trace?(request_info[:url], Sentry.configuration)
+            set_propagation_headers(req)
+          end
 
           super.tap do |res|
-            record_sentry_breadcrumb(req, res)
+            record_sentry_breadcrumb(request_info, res)
 
             if sentry_span
-              request_info = extract_request_info(req)
               sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
-              sentry_span.set_data('url', request_info[:url])
-              sentry_span.set_data('http.method', request_info[:method])
-              sentry_span.set_data('http.query', request_info[:query]) if request_info[:query]
-              sentry_span.set_data('status', res.code.to_i)
+              sentry_span.set_data(Span::DataConventions::URL, request_info[:url])
+              sentry_span.set_data(Span::DataConventions::HTTP_METHOD, request_info[:method])
+              sentry_span.set_data(Span::DataConventions::HTTP_QUERY, request_info[:query]) if request_info[:query]
+              sentry_span.set_data(Span::DataConventions::HTTP_STATUS_CODE, res.code.to_i)
             end
           end
         end
@@ -49,23 +53,13 @@ module Sentry
 
       private
 
-      def set_sentry_trace_header(req, sentry_span)
-        return unless 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?
+      def set_propagation_headers(req)
+        Sentry.get_trace_propagation_headers&.each { |k, v| req[k] = v }
       end
 
-      def record_sentry_breadcrumb(req, res)
+      def record_sentry_breadcrumb(request_info, res)
         return unless Sentry.initialized? && Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
 
-        request_info = extract_request_info(req)
-
         crumb = Sentry::Breadcrumb.new(
           level: :info,
           category: BREADCRUMB_CATEGORY,
@@ -84,7 +78,10 @@ module Sentry
       end
 
       def extract_request_info(req)
-        uri = req.uri || URI.parse("#{use_ssl? ? 'https' : 'http'}://#{address}#{req.path}")
+        # IPv6 url could look like '::1/path', and that won't parse without
+        # wrapping it in square brackets.
+        hostname = address =~ Resolv::IPv6::Regex ? "[#{address}]" : address
+        uri = req.uri || URI.parse("#{use_ssl? ? 'https' : 'http'}://#{hostname}#{req.path}")
         url = "#{uri.scheme}://#{uri.host}#{uri.path}" rescue uri.to_s
 
         result = { method: req.method, url: url }
@@ -96,8 +93,14 @@ module Sentry
 
         result
       end
+
+      def propagate_trace?(url, configuration)
+        url &&
+          configuration.propagate_traces &&
+          configuration.trace_propagation_targets.any? { |target| url.match?(target) }
+      end
     end
   end
 end
 
-Sentry.register_patch(Sentry::Net::HTTP, Net::HTTP)
+Sentry.register_patch(:http, Sentry::Net::HTTP, Net::HTTP)

data/lib/sentry/profiler.rb

@@ -9,6 +9,7 @@ module Sentry
     # 101 Hz in microseconds
     DEFAULT_INTERVAL = 1e6 / 101
     MICRO_TO_NANO_SECONDS = 1e3
+    MIN_SAMPLES_REQUIRED = 2
 
     attr_reader :sampled, :started, :event_id
 
@@ -73,14 +74,19 @@ module Sentry
     end
 
     def to_hash
-      return {} unless @sampled
+      unless @sampled
+        record_lost_event(:sample_rate)
+        return {}
+      end
+
       return {} unless @started
 
       results = StackProf.results
-      return {} unless results
-      return {} if results.empty?
-      return {} if results[:samples] == 0
-      return {} unless results[:raw]
+
+      if !results || results.empty? || results[:samples] == 0 || !results[:raw]
+        record_lost_event(:insufficient_data)
+        return {}
+      end
 
       frame_map = {}
 
@@ -103,7 +109,7 @@ module Sentry
         }
 
         frame_hash[:module] = mod if mod
-        frame_hash[:lineno] = frame_data[:line] if frame_data[:line]
+        frame_hash[:lineno] = frame_data[:line] if frame_data[:line] && frame_data[:line] >= 0
 
         frame_hash
       end
@@ -157,8 +163,9 @@ module Sentry
 
       log('Some samples thrown away') if samples.size != results[:samples]
 
-      if samples.size <= 2
+      if samples.size <= MIN_SAMPLES_REQUIRED
         log('Not enough samples, discarding profiler')
+        record_lost_event(:insufficient_data)
         return {}
       end
 
@@ -218,5 +225,9 @@ module Sentry
 
       [function, mod]
     end
+
+    def record_lost_event(reason)
+      Sentry.get_current_client&.transport&.record_lost_event(reason, 'profile')
+    end
   end
 end

data/lib/sentry/propagation_context.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "sentry/baggage"
+
+module Sentry
+  class PropagationContext
+    SENTRY_TRACE_REGEXP = Regexp.new(
+      "^[ \t]*" +  # whitespace
+      "([0-9a-f]{32})?" +  # trace_id
+      "-?([0-9a-f]{16})?" +  # span_id
+      "-?([01])?" +  # sampled
+      "[ \t]*$"  # whitespace
+    )
+
+    # An uuid that can be used to identify a trace.
+    # @return [String]
+    attr_reader :trace_id
+    # An uuid that can be used to identify the span.
+    # @return [String]
+    attr_reader :span_id
+    # Span parent's span_id.
+    # @return [String, nil]
+    attr_reader :parent_span_id
+    # The sampling decision of the parent transaction.
+    # @return [Boolean, nil]
+    attr_reader :parent_sampled
+    # Is there an incoming trace or not?
+    # @return [Boolean]
+    attr_reader :incoming_trace
+    # 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
+
+    def initialize(scope, env = nil)
+      @scope = scope
+      @parent_span_id = nil
+      @parent_sampled = nil
+      @baggage = nil
+      @incoming_trace = false
+
+      if env
+        sentry_trace_header = env["HTTP_SENTRY_TRACE"] || env[SENTRY_TRACE_HEADER_NAME]
+        baggage_header = env["HTTP_BAGGAGE"] || env[BAGGAGE_HEADER_NAME]
+
+        if sentry_trace_header
+          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 = if baggage_header && !baggage_header.empty?
+                        Baggage.from_incoming_header(baggage_header)
+                      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!
+            @incoming_trace = true
+          end
+        end
+      end
+
+      @trace_id ||= SecureRandom.uuid.delete("-")
+      @span_id = SecureRandom.uuid.delete("-").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]
+    end
+
+    # Returns the trace context that can be used to embed in an Event.
+    # @return [Hash]
+    def get_trace_context
+      {
+        trace_id: trace_id,
+        span_id: span_id,
+        parent_span_id: parent_span_id
+      }
+    end
+
+    # Returns the sentry-trace header from the propagation context.
+    # @return [String]
+    def get_traceparent
+      "#{trace_id}-#{span_id}"
+    end
+
+    # Returns the Baggage from the propagation context or populates as head SDK if empty.
+    # @return [Baggage, nil]
+    def get_baggage
+      populate_head_baggage if @baggage.nil? || @baggage.mutable
+      @baggage
+    end
+
+    # Returns the Dynamic Sampling Context from the baggage.
+    # @return [String, nil]
+    def get_dynamic_sampling_context
+      get_baggage&.dynamic_sampling_context
+    end
+
+    private
+
+    def populate_head_baggage
+      return unless Sentry.initialized?
+
+      configuration = Sentry.configuration
+
+      items = {
+        "trace_id" => trace_id,
+        "environment" => configuration.environment,
+        "release" => configuration.release,
+        "public_key" => configuration.dsn&.public_key,
+        "user_segment" => @scope.user && @scope.user["segment"]
+      }
+
+      items.compact!
+      @baggage = Baggage.new(items, mutable: false)
+    end
+  end
+end

data/lib/sentry/puma.rb

@@ -1,10 +1,19 @@
 # frozen_string_literal: true
 
+return unless defined?(Puma::Server)
+
 module Sentry
   module Puma
     module Server
+      PUMA_4_AND_PRIOR = Gem::Version.new(::Puma::Const::PUMA_VERSION) < Gem::Version.new("5.0.0")
+
       def lowlevel_error(e, env, status=500)
-        result = super
+        result =
+          if PUMA_4_AND_PRIOR
+            super(e, env)
+          else
+            super
+          end
 
         begin
           Sentry.capture_exception(e) do |scope|
@@ -20,6 +29,4 @@ module Sentry
   end
 end
 
-if defined?(Puma::Server)
-  Sentry.register_patch(Sentry::Puma::Server, Puma::Server)
-end
+Sentry.register_patch(:puma, Sentry::Puma::Server, Puma::Server)

data/lib/sentry/rack/capture_exceptions.rb

@@ -62,11 +62,8 @@ module Sentry
       end
 
       def start_transaction(env, scope)
-        sentry_trace = env["HTTP_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
+        transaction = Sentry.continue_trace(env, **options)
         Sentry.start_transaction(transaction: transaction, custom_sampling_context: { env: env }, **options)
       end
 

data/lib/sentry/redis.rb

@@ -19,7 +19,10 @@ module Sentry
 
           if span
             span.set_description(commands_description)
-            span.set_data(:server, server_description)
+            span.set_data(Span::DataConventions::DB_SYSTEM, "redis")
+            span.set_data(Span::DataConventions::DB_NAME, db)
+            span.set_data(Span::DataConventions::SERVER_ADDRESS, host)
+            span.set_data(Span::DataConventions::SERVER_PORT, port)
           end
         end
       end
@@ -96,8 +99,10 @@ end
 
 if defined?(::Redis::Client)
   if Gem::Version.new(::Redis::VERSION) < Gem::Version.new("5.0")
-    Sentry.register_patch(Sentry::Redis::OldClientPatch, ::Redis::Client)
+    Sentry.register_patch(:redis, Sentry::Redis::OldClientPatch, ::Redis::Client)
   elsif defined?(RedisClient)
-    RedisClient.register(Sentry::Redis::GlobalRedisInstrumentation)
+    Sentry.register_patch(:redis) do
+      RedisClient.register(Sentry::Redis::GlobalRedisInstrumentation)
+    end
   end
 end

data/lib/sentry/release_detector.rb

@@ -28,7 +28,7 @@ module Sentry
       end
 
       def detect_release_from_git
-        Sentry.sys_command("git rev-parse --short HEAD") if File.directory?(".git")
+        Sentry.sys_command("git rev-parse HEAD") if File.directory?(".git")
       end
 
       def detect_release_from_env

data/lib/sentry/scope.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "sentry/breadcrumb_buffer"
+require "sentry/propagation_context"
 require "etc"
 
 module Sentry
@@ -20,7 +21,8 @@ module Sentry
       :event_processors,
       :rack_env,
       :span,
-      :session
+      :session,
+      :propagation_context
     ]
 
     attr_reader(*ATTRIBUTES)
@@ -50,7 +52,10 @@ module Sentry
       event.transaction_info = { source: transaction_source } if transaction_source
 
       if span
-        event.contexts[:trace] = span.get_trace_context
+        event.contexts[:trace] ||= span.get_trace_context
+      else
+        event.contexts[:trace] ||= propagation_context.get_trace_context
+        event.dynamic_sampling_context ||= propagation_context.get_dynamic_sampling_context
       end
 
       event.fingerprint = fingerprint
@@ -95,6 +100,7 @@ module Sentry
       copy.fingerprint = fingerprint.deep_dup
       copy.span = span.deep_dup
       copy.session = session.deep_dup
+      copy.propagation_context = propagation_context.deep_dup
       copy
     end
 
@@ -111,6 +117,7 @@ module Sentry
       self.transaction_sources = scope.transaction_sources
       self.fingerprint = scope.fingerprint
       self.span = scope.span
+      self.propagation_context = scope.propagation_context
     end
 
     # Updates the scope's data from the given options.
@@ -272,6 +279,13 @@ module Sentry
       @event_processors << block
     end
 
+    # Generate a new propagation context either from the incoming env headers or from scratch.
+    # @param env [Hash, nil]
+    # @return [void]
+    def generate_propagation_context(env = nil)
+      @propagation_context = PropagationContext.new(self, env)
+    end
+
     protected
 
     # for duplicating scopes internally
@@ -292,6 +306,7 @@ module Sentry
       @rack_env = {}
       @span = nil
       @session = nil
+      generate_propagation_context
       set_new_breadcrumb_buffer
     end
 

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",
@@ -75,7 +112,7 @@ module Sentry
       timestamp: nil
     )
       @trace_id = trace_id || SecureRandom.uuid.delete("-")
-      @span_id = 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
@@ -208,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,24 +14,28 @@ 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:
       # - 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)
-      Sentry.get_current_scope.clear
     end
 
     # Clears all stored events and envelopes.
@@ -40,9 +44,12 @@ module Sentry
     def teardown_sentry_test
       return unless Sentry.initialized?
 
-      sentry_transport.events = []
-      sentry_transport.envelopes = []
-      Sentry.get_current_scope.clear
+      # 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]
@@ -75,4 +82,3 @@ module Sentry
     end
   end
 end
-

data/lib/sentry/transaction.rb

@@ -2,16 +2,13 @@
 
 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]"
 
@@ -92,6 +89,8 @@ module Sentry
       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`.
@@ -132,18 +131,10 @@ module Sentry
       )
     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.
+    # @deprecated Use Sentry::PropagationContext.extract_sentry_trace instead.
     # @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]
+      PropagationContext.extract_sentry_trace(sentry_trace)
     end
 
     # @return [Hash]
@@ -323,6 +314,7 @@ module Sentry
       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

data/lib/sentry/transaction_event.rb

@@ -8,9 +8,6 @@ module Sentry
     # @return [<Array[Span]>]
     attr_accessor :spans
 
-    # @return [Hash, nil]
-    attr_accessor :dynamic_sampling_context
-
     # @return [Hash]
     attr_accessor :measurements