sentry-ruby 5.18.2 → 5.28.1

data/lib/sentry/envelope/item.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Sentry
+  # @api private
+  class Envelope::Item
+    STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD = 500
+    MAX_SERIALIZED_PAYLOAD_SIZE = 1024 * 1000
+
+    SIZE_LIMITS = Hash.new(MAX_SERIALIZED_PAYLOAD_SIZE).update(
+      "profile" => 1024 * 1000 * 50
+    )
+
+    attr_reader :size_limit, :headers, :payload, :type, :data_category
+
+    # rate limits and client reports use the data_category rather than envelope item type
+    def self.data_category(type)
+      case type
+      when "session", "attachment", "transaction", "profile", "span", "log" then type
+      when "sessions" then "session"
+      when "check_in" then "monitor"
+      when "statsd", "metric_meta" then "metric_bucket"
+      when "event" then "error"
+      when "client_report" then "internal"
+      else "default"
+      end
+    end
+
+    def initialize(headers, payload)
+      @headers = headers
+      @payload = payload
+      @type = headers[:type] || "event"
+      @data_category = self.class.data_category(type)
+      @size_limit = SIZE_LIMITS[type]
+    end
+
+    def to_s
+      [JSON.generate(@headers), @payload.is_a?(String) ? @payload : JSON.generate(@payload)].join("\n")
+    end
+
+    def serialize
+      result = to_s
+
+      if result.bytesize > size_limit
+        remove_breadcrumbs!
+        result = to_s
+      end
+
+      if result.bytesize > size_limit
+        reduce_stacktrace!
+        result = to_s
+      end
+
+      [result, result.bytesize > size_limit]
+    end
+
+    def size_breakdown
+      payload.map do |key, value|
+        "#{key}: #{JSON.generate(value).bytesize}"
+      end.join(", ")
+    end
+
+    private
+
+    def remove_breadcrumbs!
+      if payload.key?(:breadcrumbs)
+        payload.delete(:breadcrumbs)
+      elsif payload.key?("breadcrumbs")
+        payload.delete("breadcrumbs")
+      end
+    end
+
+    def reduce_stacktrace!
+      if exceptions = payload.dig(:exception, :values) || payload.dig("exception", "values")
+        exceptions.each do |exception|
+          # in most cases there is only one exception (2 or 3 when have multiple causes), so we won't loop through this double condition much
+          traces = exception.dig(:stacktrace, :frames) || exception.dig("stacktrace", "frames")
+
+          if traces && traces.size > STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD
+            size_on_both_ends = STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD / 2
+            traces.replace(
+              traces[0..(size_on_both_ends - 1)] + traces[-size_on_both_ends..-1],
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentry/envelope.rb

@@ -3,91 +3,6 @@
 module Sentry
   # @api private
   class Envelope
-    class Item
-      STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD = 500
-      MAX_SERIALIZED_PAYLOAD_SIZE = 1024 * 1000
-
-      attr_accessor :headers, :payload
-
-      def initialize(headers, payload)
-        @headers = headers
-        @payload = payload
-      end
-
-      def type
-        @headers[:type] || 'event'
-      end
-
-      # rate limits and client reports use the data_category rather than envelope item type
-      def self.data_category(type)
-        case type
-        when 'session', 'attachment', 'transaction', 'profile', 'span' then type
-        when 'sessions' then 'session'
-        when 'check_in' then 'monitor'
-        when 'statsd', 'metric_meta' then 'metric_bucket'
-        when 'event' then 'error'
-        when 'client_report' then 'internal'
-        else 'default'
-        end
-      end
-
-      def data_category
-        self.class.data_category(type)
-      end
-
-      def to_s
-        [JSON.generate(@headers), @payload.is_a?(String) ? @payload : JSON.generate(@payload)].join("\n")
-      end
-
-      def serialize
-        result = to_s
-
-        if result.bytesize > MAX_SERIALIZED_PAYLOAD_SIZE
-          remove_breadcrumbs!
-          result = to_s
-        end
-
-        if result.bytesize > MAX_SERIALIZED_PAYLOAD_SIZE
-          reduce_stacktrace!
-          result = to_s
-        end
-
-        [result, result.bytesize > MAX_SERIALIZED_PAYLOAD_SIZE]
-      end
-
-      def size_breakdown
-        payload.map do |key, value|
-          "#{key}: #{JSON.generate(value).bytesize}"
-        end.join(", ")
-      end
-
-      private
-
-      def remove_breadcrumbs!
-        if payload.key?(:breadcrumbs)
-          payload.delete(:breadcrumbs)
-        elsif payload.key?("breadcrumbs")
-          payload.delete("breadcrumbs")
-        end
-      end
-
-      def reduce_stacktrace!
-        if exceptions = payload.dig(:exception, :values) || payload.dig("exception", "values")
-          exceptions.each do |exception|
-            # in most cases there is only one exception (2 or 3 when have multiple causes), so we won't loop through this double condition much
-            traces = exception.dig(:stacktrace, :frames) || exception.dig("stacktrace", "frames")
-
-            if traces && traces.size > STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD
-              size_on_both_ends = STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD / 2
-              traces.replace(
-                traces[0..(size_on_both_ends - 1)] + traces[-size_on_both_ends..-1],
-              )
-            end
-          end
-        end
-      end
-    end
-
     attr_accessor :headers, :items
 
     def initialize(headers = {})
@@ -108,3 +23,5 @@ module Sentry
     end
   end
 end
+
+require_relative "envelope/item"

data/lib/sentry/event.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
-require 'socket'
-require 'securerandom'
-require 'sentry/interface'
-require 'sentry/backtrace'
-require 'sentry/utils/real_ip'
-require 'sentry/utils/request_id'
-require 'sentry/utils/custom_inspection'
+require "socket"
+require "securerandom"
+require "sentry/interface"
+require "sentry/backtrace"
+require "sentry/utils/real_ip"
+require "sentry/utils/request_id"
+require "sentry/utils/custom_inspection"
+require "sentry/utils/uuid"
 
 module Sentry
   # This is an abstract class that defines the shared attributes of an event.
@@ -42,12 +43,15 @@ module Sentry
     # @return [Hash, nil]
     attr_accessor :dynamic_sampling_context
 
+    # @return [Array<Attachment>]
+    attr_accessor :attachments
+
     # @param configuration [Configuration]
     # @param integration_meta [Hash, nil]
     # @param message [String, nil]
     def initialize(configuration:, integration_meta: nil, message: nil)
       # Set some simple default values
-      @event_id      = SecureRandom.uuid.delete("-")
+      @event_id      = Utils.uuid
       @timestamp     = Sentry.utc_now.iso8601
       @platform      = :ruby
       @type          = self.class::TYPE
@@ -57,6 +61,7 @@ module Sentry
       @extra         = {}
       @contexts      = {}
       @tags          = {}
+      @attachments   = []
 
       @fingerprint = []
       @dynamic_sampling_context = nil

data/lib/sentry/excon/middleware.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Excon
+    OP_NAME = "http.client"
+
+    class Middleware < ::Excon::Middleware::Base
+      def initialize(stack)
+        super
+        @instrumenter = Instrumenter.new
+      end
+
+      def request_call(datum)
+        @instrumenter.start_transaction(datum)
+        @stack.request_call(datum)
+      end
+
+      def response_call(datum)
+        @instrumenter.finish_transaction(datum)
+        @stack.response_call(datum)
+      end
+    end
+
+    class Instrumenter
+      SPAN_ORIGIN = "auto.http.excon"
+      BREADCRUMB_CATEGORY = "http"
+
+      include Utils::HttpTracing
+
+      def start_transaction(env)
+        return unless Sentry.initialized?
+
+        current_span = Sentry.get_current_scope&.span
+        @span = current_span&.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f, origin: SPAN_ORIGIN)
+
+        request_info = extract_request_info(env)
+
+        if propagate_trace?(request_info[:url])
+          set_propagation_headers(env[:headers])
+        end
+      end
+
+      def finish_transaction(response)
+        return unless @span
+
+        response_status = response[:response][:status]
+        request_info = extract_request_info(response)
+
+        if record_sentry_breadcrumb?
+          record_sentry_breadcrumb(request_info, response_status)
+        end
+
+        set_span_info(@span, request_info, response_status)
+      ensure
+        @span&.finish
+      end
+
+      private
+
+      def extract_request_info(env)
+        url = env[:scheme] + "://" + env[:hostname] + env[:path]
+        result = { method: env[:method].to_s.upcase, url: url }
+
+        if Sentry.configuration.send_default_pii
+          result[:query] = env[:query]
+
+          # Handle excon 1.0.0+
+          result[:query] = build_nested_query(result[:query]) unless result[:query].is_a?(String)
+
+          result[:body] = env[:body]
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/sentry/excon.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+Sentry.register_patch(:excon) do
+  if defined?(::Excon)
+    require "sentry/excon/middleware"
+    if Excon.defaults[:middlewares]
+      Excon.defaults[:middlewares] << Sentry::Excon::Middleware unless Excon.defaults[:middlewares].include?(Sentry::Excon::Middleware)
+    end
+  end
+end

data/lib/sentry/faraday.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Faraday
+    OP_NAME = "http.client"
+
+    module Connection
+      # Since there's no way to preconfigure Faraday connections and add our instrumentation
+      # by default, we need to extend the connection constructor and do it there
+      #
+      # @see https://lostisland.github.io/faraday/#/customization/index?id=configuration
+      def initialize(url = nil, options = nil)
+        super
+
+        # Ensure that we attach instrumentation only if the adapter is not net/http
+        # because if is is, then the net/http instrumentation will take care of it
+        if builder.adapter.name != "Faraday::Adapter::NetHttp"
+          # Make sure that it's going to be the first middleware so that it can capture
+          # the entire request processing involving other middlewares
+          builder.insert(0, ::Faraday::Request::Instrumentation, name: OP_NAME, instrumenter: Instrumenter.new)
+        end
+      end
+    end
+
+    class Instrumenter
+      SPAN_ORIGIN = "auto.http.faraday"
+      BREADCRUMB_CATEGORY = "http"
+
+      include Utils::HttpTracing
+
+      def instrument(op_name, env, &block)
+        return block.call unless Sentry.initialized?
+
+        Sentry.with_child_span(op: op_name, start_timestamp: Sentry.utc_now.to_f, origin: SPAN_ORIGIN) do |sentry_span|
+          request_info = extract_request_info(env)
+
+          if propagate_trace?(request_info[:url])
+            set_propagation_headers(env[:request_headers])
+          end
+
+          res = block.call
+          response_status = res.status
+
+          if record_sentry_breadcrumb?
+            record_sentry_breadcrumb(request_info, response_status)
+          end
+
+          if sentry_span
+            set_span_info(sentry_span, request_info, response_status)
+          end
+
+          res
+        end
+      end
+
+      private
+
+      def extract_request_info(env)
+        url = env[:url].scheme + "://" + env[:url].host + env[:url].path
+        result = { method: env[:method].to_s.upcase, url: url }
+
+        if Sentry.configuration.send_default_pii
+          result[:query] = env[:url].query
+          result[:body] = env[:body]
+        end
+
+        result
+      end
+    end
+  end
+end
+
+Sentry.register_patch(:faraday) do
+  if defined?(::Faraday)
+    ::Faraday::Connection.prepend(Sentry::Faraday::Connection)
+  end
+end

data/lib/sentry/graphql.rb

@@ -4,6 +4,6 @@ Sentry.register_patch(:graphql) do |config|
   if defined?(::GraphQL::Schema) && defined?(::GraphQL::Tracing::SentryTrace) && ::GraphQL::Schema.respond_to?(:trace_with)
     ::GraphQL::Schema.trace_with(::GraphQL::Tracing::SentryTrace, set_transaction_name: true)
   else
-    config.logger.warn(Sentry::LOGGER_PROGNAME) { 'You tried to enable the GraphQL integration but no GraphQL gem was detected. Make sure you have the `graphql` gem (>= 2.2.6) in your Gemfile.' }
+    config.sdk_logger.warn(Sentry::LOGGER_PROGNAME) { "You tried to enable the GraphQL integration but no GraphQL gem was detected. Make sure you have the `graphql` gem (>= 2.2.6) in your Gemfile." }
   end
 end

data/lib/sentry/hub.rb

@@ -8,12 +8,42 @@ module Sentry
   class Hub
     include ArgumentCheckingHelper
 
+    MUTEX = Mutex.new
+
     attr_reader :last_event_id
 
+    attr_reader :current_profiler
+
     def initialize(client, scope)
       first_layer = Layer.new(client, scope)
       @stack = [first_layer]
       @last_event_id = nil
+      @current_profiler = {}
+    end
+
+    # This is an internal private method
+    # @api private
+    def start_profiler!(transaction)
+      MUTEX.synchronize do
+        transaction.start_profiler!
+        @current_profiler[transaction.__id__] = transaction.profiler
+      end
+    end
+
+    # This is an internal private method
+    # @api private
+    def stop_profiler!(transaction)
+      MUTEX.synchronize do
+        @current_profiler.delete(transaction.__id__)&.stop
+      end
+    end
+
+    # This is an internal private method
+    # @api private
+    def profiler_running?
+      MUTEX.synchronize do
+        !@current_profiler.empty?
+      end
     end
 
     def new_from_top
@@ -73,7 +103,13 @@ module Sentry
     end
 
     def pop_scope
-      @stack.pop
+      if @stack.size > 1
+        @stack.pop
+      else
+        # We never want to enter a situation where we have no scope and no client
+        client = current_client
+        @stack = [Layer.new(client, Scope.new)]
+      end
     end
 
     def start_transaction(transaction: nil, custom_sampling_context: {}, instrumenter: :sentry, **options)
@@ -84,13 +120,14 @@ module Sentry
 
       sampling_context = {
         transaction_context: transaction.to_hash,
-        parent_sampled: transaction.parent_sampled
+        parent_sampled: transaction.parent_sampled,
+        parent_sample_rate: transaction.parent_sample_rate
       }
 
       sampling_context.merge!(custom_sampling_context)
       transaction.set_initial_sample_decision(sampling_context: sampling_context)
 
-      transaction.start_profiler!
+      start_profiler!(transaction)
 
       transaction
     end
@@ -180,6 +217,16 @@ module Sentry
       event.check_in_id
     end
 
+    def capture_log_event(message, **options)
+      return unless current_client
+
+      event = current_client.event_from_log(message, **options)
+
+      return unless event
+
+      current_client.buffer_log_event(event, current_scope)
+    end
+
     def capture_event(event, **options, &block)
       check_argument_type!(event, Sentry::Event)
 
@@ -214,6 +261,7 @@ module Sentry
     end
 
     def add_breadcrumb(breadcrumb, hint: {})
+      return unless current_client
       return unless configuration.enabled_in_current_env?
 
       if before_breadcrumb = current_client.configuration.before_breadcrumb
@@ -248,7 +296,11 @@ module Sentry
 
       return unless session
       session.close
-      Sentry.session_flusher.add_session(session)
+
+      # NOTE: Under some circumstances, session_flusher nilified out of sync
+      #   See: https://github.com/getsentry/sentry-ruby/issues/2378
+      #   See: https://github.com/getsentry/sentry-ruby/pull/2396
+      Sentry.session_flusher&.add_session(session)
     end
 
     def with_session_tracking(&block)
@@ -306,6 +358,7 @@ module Sentry
         parent_span_id: propagation_context.parent_span_id,
         parent_sampled: propagation_context.parent_sampled,
         baggage: propagation_context.baggage,
+        sample_rand: propagation_context.sample_rand,
         **options
       )
     end

data/lib/sentry/interfaces/mechanism.rb

@@ -12,7 +12,7 @@ module Sentry
     # @return [Boolean]
     attr_accessor :handled
 
-    def initialize(type: 'generic', handled: true)
+    def initialize(type: "generic", handled: true)
       @type = type
       @handled = handled
     end

data/lib/sentry/interfaces/request.rb

@@ -59,7 +59,7 @@ module Sentry
         self.query_string = request.query_string
       end
 
-      self.url = request.scheme && request.url.split('?').first
+      self.url = request.scheme && request.url.split("?").first
       self.method = request.request_method
 
       self.headers = filter_and_format_headers(env, send_default_pii)
@@ -85,21 +85,21 @@ module Sentry
       env.each_with_object({}) do |(key, value), memo|
         begin
           key = key.to_s # rack env can contain symbols
-          next memo['X-Request-Id'] ||= Utils::RequestId.read_from(env) if Utils::RequestId::REQUEST_ID_HEADERS.include?(key)
+          next memo["X-Request-Id"] ||= Utils::RequestId.read_from(env) if Utils::RequestId::REQUEST_ID_HEADERS.include?(key)
           next if is_server_protocol?(key, value, env["SERVER_PROTOCOL"])
           next if is_skippable_header?(key)
           next if key == "HTTP_AUTHORIZATION" && !send_default_pii
 
           # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
           key = key.sub(/^HTTP_/, "")
-          key = key.split('_').map(&:capitalize).join('-')
+          key = key.split("_").map(&:capitalize).join("-")
 
           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.
           # See: https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/middleware/remote_ip.rb#L134
-          Sentry.logger.warn(LOGGER_PROGNAME) { "Error raised while formatting headers: #{e.message}" }
+          Sentry.sdk_logger.warn(LOGGER_PROGNAME) { "Error raised while formatting headers: #{e.message}" }
           next
         end
       end
@@ -108,7 +108,7 @@ module Sentry
     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))
+        !(key.start_with?("HTTP_") || CONTENT_HEADERS.include?(key))
     end
 
     # In versions < 3, Rack adds in an incorrect HTTP_VERSION key, which causes downstream
@@ -120,7 +120,7 @@ module Sentry
       rack_version = Gem::Version.new(::Rack.release)
       return false if rack_version >= Gem::Version.new("3.0")
 
-      key == 'HTTP_VERSION' && value == protocol_version
+      key == "HTTP_VERSION" && value == protocol_version
     end
 
     def filter_and_format_env(env, rack_env_whitelist)

data/lib/sentry/interfaces/single_exception.rb

@@ -7,8 +7,8 @@ module Sentry
     include CustomInspection
 
     SKIP_INSPECTION_ATTRIBUTES = [:@stacktrace]
-    PROBLEMATIC_LOCAL_VALUE_REPLACEMENT = "[ignored due to error]".freeze
-    OMISSION_MARK = "...".freeze
+    PROBLEMATIC_LOCAL_VALUE_REPLACEMENT = "[ignored due to error]"
+    OMISSION_MARK = "..."
     MAX_LOCAL_BYTES = 1024
 
     attr_reader :type, :module, :thread_id, :stacktrace, :mechanism
@@ -26,7 +26,7 @@ module Sentry
 
       @value = Utils::EncodingHelper.encode_to_utf_8(exception_message.byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES))
 
-      @module = exception.class.to_s.split('::')[0...-1].join('::')
+      @module = exception.class.to_s.split("::")[0...-1].join("::")
       @thread_id = Thread.current.object_id
       @stacktrace = stacktrace
       @mechanism = mechanism

data/lib/sentry/interfaces/stacktrace.rb

@@ -27,8 +27,9 @@ module Sentry
       attr_accessor :abs_path, :context_line, :function, :in_app, :filename,
                   :lineno, :module, :pre_context, :post_context, :vars
 
-      def initialize(project_root, line)
+      def initialize(project_root, line, strip_backtrace_load_path = true)
         @project_root = project_root
+        @strip_backtrace_load_path = strip_backtrace_load_path
 
         @abs_path = line.file
         @function = line.method if line.method
@@ -44,6 +45,7 @@ module Sentry
 
       def compute_filename
         return if abs_path.nil?
+        return abs_path unless @strip_backtrace_load_path
 
         prefix =
           if under_project_root? && in_app

data/lib/sentry/interfaces/stacktrace_builder.rb

@@ -17,22 +17,35 @@ module Sentry
     # @return [Proc, nil]
     attr_reader :backtrace_cleanup_callback
 
+    # @return [Boolean]
+    attr_reader :strip_backtrace_load_path
+
     # @param project_root [String]
     # @param app_dirs_pattern [Regexp, nil]
     # @param linecache [LineCache]
     # @param context_lines [Integer, nil]
     # @param backtrace_cleanup_callback [Proc, nil]
+    # @param strip_backtrace_load_path [Boolean]
     # @see Configuration#project_root
     # @see Configuration#app_dirs_pattern
     # @see Configuration#linecache
     # @see Configuration#context_lines
     # @see Configuration#backtrace_cleanup_callback
-    def initialize(project_root:, app_dirs_pattern:, linecache:, context_lines:, backtrace_cleanup_callback: nil)
+    # @see Configuration#strip_backtrace_load_path
+    def initialize(
+      project_root:,
+      app_dirs_pattern:,
+      linecache:,
+      context_lines:,
+      backtrace_cleanup_callback: nil,
+      strip_backtrace_load_path: true
+    )
       @project_root = project_root
       @app_dirs_pattern = app_dirs_pattern
       @linecache = linecache
       @context_lines = context_lines
       @backtrace_cleanup_callback = backtrace_cleanup_callback
+      @strip_backtrace_load_path = strip_backtrace_load_path
     end
 
     # Generates a StacktraceInterface with the given backtrace.
@@ -73,7 +86,7 @@ module Sentry
     private
 
     def convert_parsed_line_into_frame(line)
-      frame = StacktraceInterface::Frame.new(project_root, line)
+      frame = StacktraceInterface::Frame.new(project_root, line, strip_backtrace_load_path)
       frame.set_context(linecache, context_lines) if context_lines
       frame
     end

data/lib/sentry/linecache.rb

@@ -29,9 +29,9 @@ module Sentry
 
     def getlines(path)
       @cache[path] ||= begin
-        IO.readlines(path)
-                       rescue
-                         nil
+        File.open(path, "r", &:readlines)
+      rescue
+        nil
       end
     end