sentry-ruby 5.16.1 → 5.20.1

data/lib/sentry/configuration.rb

@@ -4,10 +4,12 @@ require "concurrent/utility/processor_counter"
 
 require "sentry/utils/exception_cause_chain"
 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
@@ -297,25 +310,25 @@ 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
@@ -328,7 +341,9 @@ module Sentry
 
     PROPAGATION_TARGETS_MATCH_ALL = /.*/.freeze
 
-    DEFAULT_PATCHES = %i(redis puma http).freeze
+    DEFAULT_PATCHES = %i[redis puma http].freeze
+
+    APP_DIRS_PATTERN = /(bin|exe|app|config|lib|test|spec)/.freeze
 
     class << self
       # Post initialization callbacks are called at the end of initialization process
@@ -337,18 +352,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
@@ -372,7 +388,10 @@ module Sentry
       self.enable_backpressure_handling = false
       self.trusted_proxies = []
       self.dsn = ENV['SENTRY_DSN']
-      self.spotlight = false
+
+      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]
@@ -386,6 +405,7 @@ module Sentry
 
       @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
@@ -479,9 +499,13 @@ module Sentry
     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 +514,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 +569,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 +595,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 +647,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 +669,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

@@ -57,7 +57,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.rb

@@ -15,11 +15,28 @@ module Sentry
       end
 
       def type
-        @headers[:type] || 'event'
+        @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), JSON.generate(@payload)].join("\n")
+        [JSON.generate(@headers), @payload.is_a?(String) ? @payload : JSON.generate(@payload)].join("\n")
       end
 
       def serialize

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

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)
@@ -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)