sentry-ruby 5.13.0 → 5.21.0

data/lib/sentry/event.rb

@@ -1,12 +1,12 @@
 # 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"
 
 module Sentry
   # This is an abstract class that defines the shared attributes of an event.
@@ -14,16 +14,16 @@ module Sentry
   class Event
     TYPE = "event"
     # These are readable attributes.
-    SERIALIZEABLE_ATTRIBUTES = %i(
+    SERIALIZEABLE_ATTRIBUTES = %i[
       event_id level timestamp
       release environment server_name modules
       message user tags contexts extra
       fingerprint breadcrumbs transaction transaction_info
       platform sdk type
-    )
+    ]
 
     # These are writable attributes.
-    WRITER_ATTRIBUTES = SERIALIZEABLE_ATTRIBUTES - %i(type timestamp level)
+    WRITER_ATTRIBUTES = SERIALIZEABLE_ATTRIBUTES - %i[type timestamp level]
 
     MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
 
@@ -42,6 +42,9 @@ 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]
@@ -57,6 +60,7 @@ module Sentry
       @extra         = {}
       @contexts      = {}
       @tags          = {}
+      @attachments   = []
 
       @fingerprint = []
       @dynamic_sampling_context = nil
@@ -76,34 +80,6 @@ module Sentry
       @message = (message || "").byteslice(0..MAX_MESSAGE_SIZE_IN_BYTES)
     end
 
-    class << self
-      # @!visibility private
-      def get_log_message(event_hash)
-        message = event_hash[:message] || event_hash['message']
-
-        return message unless message.nil? || message.empty?
-
-        message = get_message_from_exception(event_hash)
-
-        return message unless message.nil? || message.empty?
-
-        message = event_hash[:transaction] || event_hash["transaction"]
-
-        return message unless message.nil? || message.empty?
-
-        '<no message value>'
-      end
-
-      # @!visibility private
-      def get_message_from_exception(event_hash)
-        if exception = event_hash.dig(:exception, :values, 0)
-          "#{exception[:type]}: #{exception[:value]}"
-        elsif exception = event_hash.dig("exception", "values", 0)
-          "#{exception["type"]}: #{exception["value"]}"
-        end
-      end
-    end
-
     # @deprecated This method will be removed in v5.0.0. Please just use Sentry.configuration
     # @return [Configuration]
     def configuration
@@ -132,9 +108,7 @@ module Sentry
       unless request || env.empty?
         add_request_interface(env)
 
-        if @send_default_pii
-          user[:ip_address] = calculate_real_ip_from_rack(env)
-        end
+        user[:ip_address] ||= calculate_real_ip_from_rack(env) if @send_default_pii
 
         if request_id = Utils::RequestId.read_from(env)
           tags[:request_id] = request_id
@@ -173,11 +147,11 @@ module Sentry
     # REMOTE_ADDR to determine the Event IP, and must use other headers instead.
     def calculate_real_ip_from_rack(env)
       Utils::RealIp.new(
-        :remote_addr => env["REMOTE_ADDR"],
-        :client_ip => env["HTTP_CLIENT_IP"],
-        :real_ip => env["HTTP_X_REAL_IP"],
-        :forwarded_for => env["HTTP_X_FORWARDED_FOR"],
-        :trusted_proxies => @trusted_proxies
+        remote_addr: env["REMOTE_ADDR"],
+        client_ip: env["HTTP_CLIENT_IP"],
+        real_ip: env["HTTP_X_REAL_IP"],
+        forwarded_for: env["HTTP_X_FORWARDED_FOR"],
+        trusted_proxies: @trusted_proxies
       ).calculate_ip
     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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+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." }
+  end
+end

data/lib/sentry/hub.rb

@@ -73,7 +73,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)
@@ -156,7 +162,7 @@ module Sentry
       capture_event(event, **options, &block)
     end
 
-    def capture_check_in(slug, status, **options, &block)
+    def capture_check_in(slug, status, **options)
       check_argument_type!(slug, ::String)
       check_argument_includes!(status, Sentry::CheckInEvent::VALID_STATUSES)
 
@@ -176,7 +182,7 @@ module Sentry
 
       return unless event
 
-      capture_event(event, **options, &block)
+      capture_event(event, **options)
       event.check_in_id
     end
 
@@ -193,7 +199,14 @@ module Sentry
       elsif custom_scope = options[:scope]
         scope.update_from_scope(custom_scope)
       elsif !options.empty?
-        scope.update_from_options(**options)
+        unsupported_option_keys = scope.update_from_options(**options)
+
+        unless unsupported_option_keys.empty?
+          configuration.log_debug <<~MSG
+            Options #{unsupported_option_keys} are not supported and will not be applied to the event.
+            You may want to set them under the `extra` option.
+          MSG
+        end
       end
 
       event = current_client.capture_event(event, scope, hint)
@@ -207,6 +220,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
@@ -245,7 +259,7 @@ module Sentry
     end
 
     def with_session_tracking(&block)
-      return yield unless configuration.auto_session_tracking
+      return yield unless configuration.session_tracking?
 
       start_session
       yield
@@ -279,6 +293,12 @@ module Sentry
       headers
     end
 
+    def get_trace_propagation_meta
+      get_trace_propagation_headers.map do |k, v|
+        "<meta name=\"#{k}\" content=\"#{v}\">"
+      end.join("\n")
+    end
+
     def continue_trace(env, **options)
       configure_scope { |s| s.generate_propagation_context(env) }
 

data/lib/sentry/integrable.rb

@@ -14,6 +14,10 @@ module Sentry
     def capture_exception(exception, **options, &block)
       options[:hint] ||= {}
       options[:hint][:integration] = integration_name
+
+      # within an integration, we usually intercept uncaught exceptions so we set handled to false.
+      options[:hint][:mechanism] ||= Sentry::Mechanism.new(type: integration_name, handled: false)
+
       Sentry.capture_exception(exception, **options, &block)
     end
 

data/lib/sentry/interface.rb

@@ -14,3 +14,4 @@ require "sentry/interfaces/request"
 require "sentry/interfaces/single_exception"
 require "sentry/interfaces/stacktrace"
 require "sentry/interfaces/threads"
+require "sentry/interfaces/mechanism"

data/lib/sentry/interfaces/exception.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "set"
 
 module Sentry
@@ -23,17 +24,18 @@ module Sentry
     # @param stacktrace_builder [StacktraceBuilder]
     # @see SingleExceptionInterface#build_with_stacktrace
     # @see SingleExceptionInterface#initialize
+    # @param mechanism [Mechanism]
     # @return [ExceptionInterface]
-    def self.build(exception:, stacktrace_builder:)
+    def self.build(exception:, stacktrace_builder:, mechanism:)
       exceptions = Sentry::Utils::ExceptionCauseChain.exception_to_array(exception).reverse
       processed_backtrace_ids = Set.new
 
       exceptions = exceptions.map do |e|
         if e.backtrace && !processed_backtrace_ids.include?(e.backtrace.object_id)
           processed_backtrace_ids << e.backtrace.object_id
-          SingleExceptionInterface.build_with_stacktrace(exception: e, stacktrace_builder: stacktrace_builder)
+          SingleExceptionInterface.build_with_stacktrace(exception: e, stacktrace_builder: stacktrace_builder, mechanism: mechanism)
         else
-          SingleExceptionInterface.new(exception: exception)
+          SingleExceptionInterface.new(exception: exception, mechanism: mechanism)
         end
       end
 

data/lib/sentry/interfaces/mechanism.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sentry
+  class Mechanism < Interface
+    # Generic identifier, mostly the source integration for this exception.
+    # @return [String]
+    attr_accessor :type
+
+    # A manually captured exception has handled set to true,
+    # false if coming from an integration where we intercept an uncaught exception.
+    # Defaults to true here and will be set to false explicitly in integrations.
+    # @return [Boolean]
+    attr_accessor :handled
+
+    def initialize(type: "generic", handled: true)
+      @type = type
+      @handled = handled
+    end
+  end
+end

data/lib/sentry/interfaces/request.rb

@@ -2,8 +2,8 @@
 
 module Sentry
   class RequestInterface < Interface
-    REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
-    CONTENT_HEADERS = %w(CONTENT_TYPE CONTENT_LENGTH).freeze
+    REQUEST_ID_HEADERS = %w[action_dispatch.request_id HTTP_X_REQUEST_ID].freeze
+    CONTENT_HEADERS = %w[CONTENT_TYPE CONTENT_LENGTH].freeze
     IP_HEADERS = [
       "REMOTE_ADDR",
       "HTTP_CLIENT_IP",
@@ -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,14 +85,14 @@ 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
@@ -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,14 +7,14 @@ 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
+    attr_reader :type, :module, :thread_id, :stacktrace, :mechanism
     attr_accessor :value
 
-    def initialize(exception:, stacktrace: nil)
+    def initialize(exception:, mechanism:, stacktrace: nil)
       @type = exception.class.to_s
       exception_message =
         if exception.respond_to?(:detailed_message)
@@ -22,23 +22,26 @@ module Sentry
         else
           exception.message || ""
         end
+      exception_message = exception_message.inspect unless exception_message.is_a?(String)
 
       @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
     end
 
     def to_hash
       data = super
       data[:stacktrace] = data[:stacktrace].to_hash if data[:stacktrace]
+      data[:mechanism] = data[:mechanism].to_hash
       data
     end
 
     # patch this method if you want to change an exception's stacktrace frames
     # also see `StacktraceBuilder.build`.
-    def self.build_with_stacktrace(exception:, stacktrace_builder:)
+    def self.build_with_stacktrace(exception:, stacktrace_builder:, mechanism:)
       stacktrace = stacktrace_builder.build(backtrace: exception.backtrace)
 
       if locals = exception.instance_variable_get(:@sentry_locals)
@@ -60,7 +63,7 @@ module Sentry
         stacktrace.frames.last.vars = locals
       end
 
-      new(exception: exception, stacktrace: stacktrace)
+      new(exception: exception, stacktrace: stacktrace, mechanism: mechanism)
     end
   end
 end

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.
@@ -62,10 +75,18 @@ module Sentry
       StacktraceInterface.new(frames: frames)
     end
 
+    # Get the code location hash for a single line for where metrics where added.
+    # @return [Hash]
+    def metrics_code_location(unparsed_line)
+      parsed_line = Backtrace::Line.parse(unparsed_line)
+      frame = convert_parsed_line_into_frame(parsed_line)
+      frame.to_hash.reject { |k, _| %i[project_root in_app].include?(k) }
+    end
+
     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/logger.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'logger'
+require "logger"
 
 module Sentry
   class Logger < ::Logger