sentry-ruby 5.16.1 → 5.21.0

data/lib/sentry/configuration.rb

@@ -3,11 +3,13 @@
 require "concurrent/utility/processor_counter"
 
 require "sentry/utils/exception_cause_chain"
-require 'sentry/utils/custom_inspection'
+require "sentry/utils/custom_inspection"
+require "sentry/utils/env_helper"
 require "sentry/dsn"
 require "sentry/release_detector"
 require "sentry/transport/configuration"
 require "sentry/cron/configuration"
+require "sentry/metrics/configuration"
 require "sentry/linecache"
 require "sentry/interfaces/stacktrace_builder"
 
@@ -21,6 +23,8 @@ module Sentry
     # have an `engines` dir at the root of your project, you may want
     # to set this to something like /(app|config|engines|lib)/
     #
+    # The default is value is /(bin|exe|app|config|lib|test|spec)/
+    #
     # @return [Regexp, nil]
     attr_accessor :app_dirs_pattern
 
@@ -186,6 +190,11 @@ module Sentry
     # @return [String]
     attr_accessor :project_root
 
+    # Whether to strip the load path while constructing the backtrace frame filename.
+    # Defaults to true.
+    # @return [Boolean]
+    attr_accessor :strip_backtrace_load_path
+
     # Insert sentry-trace to outgoing requests' headers
     # @return [Boolean]
     attr_accessor :propagate_traces
@@ -235,6 +244,10 @@ module Sentry
     # @return [Cron::Configuration]
     attr_reader :cron
 
+    # Metrics related configuration.
+    # @return [Metrics::Configuration]
+    attr_reader :metrics
+
     # Take a float between 0.0 and 1.0 as the sample rate for tracing events (transactions).
     # @return [Float, nil]
     attr_reader :traces_sample_rate
@@ -278,6 +291,10 @@ module Sentry
     # @return [Symbol]
     attr_reader :instrumenter
 
+    # The profiler class
+    # @return [Class]
+    attr_reader :profiler_class
+
     # Take a float between 0.0 and 1.0 as the sample rate for capturing profiles.
     # Note that this rate is relative to traces_sample_rate / traces_sampler,
     # i.e. the profile is sampled by this rate after the transaction is sampled.
@@ -297,38 +314,40 @@ module Sentry
     # But they are mostly considered as noise and should be ignored by default
     # Please see https://github.com/getsentry/sentry-ruby/pull/2026 for more information
     PUMA_IGNORE_DEFAULT = [
-      'Puma::MiniSSL::SSLError',
-      'Puma::HttpParserError',
-      'Puma::HttpParserError501'
+      "Puma::MiniSSL::SSLError",
+      "Puma::HttpParserError",
+      "Puma::HttpParserError501"
     ].freeze
 
     # Most of these errors generate 4XX responses. In general, Sentry clients
     # only automatically report 5xx responses.
     IGNORE_DEFAULT = [
-      'Mongoid::Errors::DocumentNotFound',
-      'Rack::QueryParser::InvalidParameterError',
-      'Rack::QueryParser::ParameterTypeError',
-      'Sinatra::NotFound'
+      "Mongoid::Errors::DocumentNotFound",
+      "Rack::QueryParser::InvalidParameterError",
+      "Rack::QueryParser::ParameterTypeError",
+      "Sinatra::NotFound"
     ].freeze
 
-    RACK_ENV_WHITELIST_DEFAULT = %w(
+    RACK_ENV_WHITELIST_DEFAULT = %w[
       REMOTE_ADDR
       SERVER_NAME
       SERVER_PORT
-    ).freeze
+    ].freeze
 
     HEROKU_DYNO_METADATA_MESSAGE = "You are running on Heroku but haven't enabled Dyno Metadata. For Sentry's "\
-    "release detection to work correctly, please run `heroku labs:enable runtime-dyno-metadata`".freeze
+    "release detection to work correctly, please run `heroku labs:enable runtime-dyno-metadata`"
 
-    LOG_PREFIX = "** [Sentry] ".freeze
-    MODULE_SEPARATOR = "::".freeze
+    LOG_PREFIX = "** [Sentry] "
+    MODULE_SEPARATOR = "::"
     SKIP_INSPECTION_ATTRIBUTES = [:@linecache, :@stacktrace_builder]
 
     INSTRUMENTERS = [:sentry, :otel]
 
-    PROPAGATION_TARGETS_MATCH_ALL = /.*/.freeze
+    PROPAGATION_TARGETS_MATCH_ALL = /.*/
 
-    DEFAULT_PATCHES = %i(redis puma http).freeze
+    DEFAULT_PATCHES = %i[redis puma http].freeze
+
+    APP_DIRS_PATTERN = /(bin|exe|app|config|lib|test|spec)/
 
     class << self
       # Post initialization callbacks are called at the end of initialization process
@@ -337,18 +356,19 @@ module Sentry
         @post_initialization_callbacks ||= []
       end
 
-    # allow extensions to add their hooks to the Configuration class
+      # allow extensions to add their hooks to the Configuration class
       def add_post_initialization_callback(&block)
         post_initialization_callbacks << block
       end
     end
 
     def initialize
-      self.app_dirs_pattern = nil
-      self.debug = false
-      self.background_worker_threads = Concurrent.processor_count
+      self.app_dirs_pattern = APP_DIRS_PATTERN
+      self.debug = Sentry::Utils::EnvHelper.env_to_bool(ENV["SENTRY_DEBUG"])
+      self.background_worker_threads = (processor_count / 2.0).ceil
       self.background_worker_max_queue = BackgroundWorker::DEFAULT_MAX_QUEUE
       self.backtrace_cleanup_callback = nil
+      self.strip_backtrace_load_path = true
       self.max_breadcrumbs = BreadcrumbBuffer::DEFAULT_SIZE
       self.breadcrumbs_logger = []
       self.context_lines = 3
@@ -371,8 +391,11 @@ module Sentry
       self.auto_session_tracking = true
       self.enable_backpressure_handling = false
       self.trusted_proxies = []
-      self.dsn = ENV['SENTRY_DSN']
-      self.spotlight = false
+      self.dsn = ENV["SENTRY_DSN"]
+
+      spotlight_env = ENV["SENTRY_SPOTLIGHT"]
+      spotlight_bool = Sentry::Utils::EnvHelper.env_to_bool(spotlight_env, strict: true)
+      self.spotlight = spotlight_bool.nil? ? (spotlight_env || false) : spotlight_bool
       self.server_name = server_name_from_env
       self.instrumenter = :sentry
       self.trace_propagation_targets = [PROPAGATION_TARGETS_MATCH_ALL]
@@ -384,8 +407,11 @@ module Sentry
       self.traces_sampler = nil
       self.enable_tracing = nil
 
+      self.profiler_class = Sentry::Profiler
+
       @transport = Transport::Configuration.new
       @cron = Cron::Configuration.new
+      @metrics = Metrics::Configuration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
 
       run_post_initialization_callbacks
@@ -478,10 +504,26 @@ module Sentry
       @profiles_sample_rate = profiles_sample_rate
     end
 
+    def profiler_class=(profiler_class)
+      if profiler_class == Sentry::Vernier::Profiler
+        begin
+          require "vernier"
+        rescue LoadError
+          raise ArgumentError, "Please add the 'vernier' gem to your Gemfile to use the Vernier profiler with Sentry."
+        end
+      end
+
+      @profiler_class = profiler_class
+    end
+
     def sending_allowed?
+      spotlight || sending_to_dsn_allowed?
+    end
+
+    def sending_to_dsn_allowed?
       @errors = []
 
-      spotlight || (valid? && capture_in_environment?)
+      valid? && capture_in_environment?
     end
 
     def sample_allowed?
@@ -490,6 +532,10 @@ module Sentry
       Random.rand < sample_rate
     end
 
+    def session_tracking?
+      auto_session_tracking && enabled_in_current_env?
+    end
+
     def exception_class_allowed?(exc)
       if exc.is_a?(Sentry::Error)
         # Try to prevent error reporting loops
@@ -541,7 +587,8 @@ module Sentry
         app_dirs_pattern: @app_dirs_pattern,
         linecache: @linecache,
         context_lines: @context_lines,
-        backtrace_cleanup_callback: @backtrace_cleanup_callback
+        backtrace_cleanup_callback: @backtrace_cleanup_callback,
+        strip_backtrace_load_path: @strip_backtrace_load_path
       )
     end
 
@@ -566,12 +613,6 @@ module Sentry
 
     private
 
-    def check_callable!(name, value)
-      unless value == nil || value.respond_to?(:call)
-        raise ArgumentError, "#{name} must be callable (or nil to disable)"
-      end
-    end
-
     def init_dsn(dsn_string)
       return if dsn_string.nil? || dsn_string.empty?
 
@@ -624,12 +665,12 @@ module Sentry
     end
 
     def environment_from_env
-      ENV['SENTRY_CURRENT_ENV'] || ENV['SENTRY_ENVIRONMENT'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      ENV["SENTRY_CURRENT_ENV"] || ENV["SENTRY_ENVIRONMENT"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
     end
 
     def server_name_from_env
       if running_on_heroku?
-        ENV['DYNO']
+        ENV["DYNO"]
       else
         # Try to resolve the hostname to an FQDN, but fall back to whatever
         # the load name is.
@@ -646,5 +687,10 @@ module Sentry
         instance_eval(&hook)
       end
     end
+
+    def processor_count
+      available_processor_count = Concurrent.available_processor_count if Concurrent.respond_to?(:available_processor_count)
+      available_processor_count || Concurrent.processor_count
+    end
   end
 end

data/lib/sentry/core_ext/object/deep_dup.rb

@@ -2,7 +2,7 @@
 
 return if Object.method_defined?(:deep_dup)
 
-require 'sentry/core_ext/object/duplicable'
+require "sentry/core_ext/object/duplicable"
 
 #########################################
 #  This file was copied from Rails 5.2  #

data/lib/sentry/cron/monitor_check_ins.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module Cron
     module MonitorCheckIns
@@ -57,7 +59,7 @@ module Sentry
 
         def sentry_monitor_slug(name: self.name)
           @sentry_monitor_slug ||= begin
-            slug = name.gsub('::', '-').downcase
+            slug = name.gsub("::", "-").downcase
             slug[-MAX_SLUG_LENGTH..-1] || slug
           end
         end

data/lib/sentry/cron/monitor_config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'sentry/cron/monitor_schedule'
+require "sentry/cron/monitor_schedule"
 
 module Sentry
   module Cron

data/lib/sentry/cron/monitor_schedule.rb

@@ -26,7 +26,7 @@ module Sentry
         # @return [Symbol]
         attr_accessor :unit
 
-        VALID_UNITS = %i(year month week day hour minute)
+        VALID_UNITS = %i[year month week day hour minute]
 
         def initialize(value, unit)
           @value = value

data/lib/sentry/dsn.rb

@@ -4,8 +4,8 @@ require "uri"
 
 module Sentry
   class DSN
-    PORT_MAP = { 'http' => 80, 'https' => 443 }.freeze
-    REQUIRED_ATTRIBUTES = %w(host path public_key project_id).freeze
+    PORT_MAP = { "http" => 80, "https" => 443 }.freeze
+    REQUIRED_ATTRIBUTES = %w[host path public_key project_id].freeze
 
     attr_reader :scheme, :secret_key, :port, *REQUIRED_ATTRIBUTES
 
@@ -13,7 +13,7 @@ module Sentry
       @raw_value = dsn_string
 
       uri = URI.parse(dsn_string)
-      uri_path = uri.path.split('/')
+      uri_path = uri.path.split("/")
 
       if uri.user
         # DSN-style string
@@ -25,7 +25,7 @@ module Sentry
       @scheme = uri.scheme
       @host = uri.host
       @port = uri.port if uri.port
-      @path = uri_path.join('/')
+      @path = uri_path.join("/")
     end
 
     def valid?

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" 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,74 +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
-
-      def to_s
-        [JSON.generate(@headers), 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 = {})
@@ -91,3 +23,5 @@ module Sentry
     end
   end
 end
+
+require_relative "envelope/item"

data/lib/sentry/error_event.rb

@@ -27,12 +27,12 @@ module Sentry
     end
 
     # @!visibility private
-    def add_exception_interface(exception)
+    def add_exception_interface(exception, mechanism:)
       if exception.respond_to?(:sentry_context)
         @extra.merge!(exception.sentry_context)
       end
 
-      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: @stacktrace_builder)
+      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: @stacktrace_builder, mechanism: mechanism)
     end
   end
 end

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
@@ -104,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
@@ -145,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