sentry-ruby-core 6.6.2 → 7.0.0

data/lib/sentry/hub.rb

@@ -224,7 +224,7 @@ module Sentry
     end
 
     def capture_log_event(message, **options)
-      return unless current_client && current_client.configuration.enable_logs
+      return unless current_client
 
       event = current_client.event_from_log(message, **options)
 
@@ -242,7 +242,7 @@ module Sentry
     # @param attributes [Hash, nil] (optional) additional attributes for the metric
     # @return [void]
     def capture_metric(name:, type:, value:, unit: nil, attributes: nil)
-      return unless current_client&.configuration.enable_metrics
+      return unless current_client
 
       metric = MetricEvent.new(
         name: name,

data/lib/sentry/interfaces/exception.rb

@@ -25,15 +25,21 @@ module Sentry
     # @see SingleExceptionInterface#build_with_stacktrace
     # @see SingleExceptionInterface#initialize
     # @param mechanism [Mechanism]
+    # @param data_collection [DataCollection]
     # @return [ExceptionInterface]
-    def self.build(exception:, stacktrace_builder:, mechanism:)
+    def self.build(exception:, stacktrace_builder:, mechanism:, data_collection:)
       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, mechanism: mechanism)
+          SingleExceptionInterface.build_with_stacktrace(
+            exception: e,
+            stacktrace_builder: stacktrace_builder,
+            mechanism: mechanism,
+            data_collection: data_collection
+          )
         else
           SingleExceptionInterface.new(exception: exception, mechanism: mechanism)
         end

data/lib/sentry/interfaces/request.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
+require "json"
+
 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
-    IP_HEADERS = [
-      "REMOTE_ADDR",
-      "HTTP_CLIENT_IP",
-      "HTTP_X_REAL_IP",
-      "HTTP_X_FORWARDED_FOR"
-    ].freeze
 
     # Regex to detect lowercase chars — match? is allocation-free (no MatchData/String)
     LOWERCASE_PATTERN = /[a-z]/.freeze
@@ -27,10 +23,10 @@ module Sentry
     # @return [Hash]
     attr_accessor :data
 
-    # @return [String]
+    # @return [String, Hash]
     attr_accessor :query_string
 
-    # @return [String]
+    # @return [Hash]
     attr_accessor :cookies
 
     # @return [Hash]
@@ -40,33 +36,22 @@ module Sentry
     attr_accessor :env
 
     # @param env [Hash]
-    # @param send_default_pii [Boolean]
+    # @param data_collection [DataCollection]
     # @param rack_env_whitelist [Array]
-    # @see Configuration#send_default_pii
+    # @see Configuration#data_collection
     # @see Configuration#rack_env_whitelist
-    def initialize(env:, send_default_pii:, rack_env_whitelist:)
+    def initialize(env:, data_collection:, rack_env_whitelist:)
       env = env.dup
-
-      unless send_default_pii
-        # need to completely wipe out ip addresses
-        RequestInterface::IP_HEADERS.each do |header|
-          env.delete(header)
-        end
-      end
-
       request = ::Rack::Request.new(env)
-
-      if send_default_pii
-        self.data = read_data_from(request)
-        self.cookies = request.cookies
-        self.query_string = request.query_string
-      end
-
-      self.url = request.scheme && request.url.split("?").first
-      self.method = request.request_method
-
-      self.headers = filter_and_format_headers(env, send_default_pii)
-      self.env     = filter_and_format_env(env, rack_env_whitelist)
+      query = data_collection.url_query_params.filter(request.GET) rescue nil
+
+      self.method       = request.request_method
+      self.url          = request.scheme && request.url.split("?").first
+      self.query_string = query unless query&.empty?
+      self.cookies      = data_collection.cookies.filter(request.cookies, cookie: true)
+      self.data         = read_data_from(request) if data_collection.collect_incoming_http_body?
+      self.headers      = filter_and_format_headers(env, data_collection.http_headers.request)
+      self.env          = filter_and_format_env(env, data_collection.http_headers.request, rack_env_whitelist)
     end
 
     private
@@ -75,25 +60,31 @@ module Sentry
       return "Skipped non-rewindable request body" unless request.body.respond_to?(:rewind)
 
       if request.form_data?
-        request.POST
-      elsif request.body # JSON requests, etc
-        data = request.body.read(MAX_BODY_LIMIT)
-        data = Utils::EncodingHelper.encode_to_utf_8(data.to_s)
-        request.body.rewind
-        data
+        DataCollection.filter(request.POST)
+      else
+        body = request.body.read(MAX_BODY_LIMIT)
+        body = Utils::EncodingHelper.encode_to_utf_8(body.to_s)
+
+        if request.media_type == "application/json" || request.media_type&.end_with?("+json")
+          parsed_body = JSON.parse(body)
+          parsed_body.is_a?(Hash) ? DataCollection.filter(parsed_body) : parsed_body
+        else
+          body
+        end
       end
-    rescue IOError => e
+    rescue JSON::ParserError, IOError => e
       e.message
+    ensure
+      request.body.rewind if request.body.respond_to?(:rewind)
     end
 
-    def filter_and_format_headers(env, send_default_pii)
+    def filter_and_format_headers(env, collection)
       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 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.delete_prefix("HTTP_")
@@ -107,12 +98,13 @@ module Sentry
           Sentry.sdk_logger.warn(LOGGER_PROGNAME) { "Error raised while formatting headers: #{e.message}" }
           next
         end
+      end.then do |e|
+        collection.filter(e)
       end
     end
 
     def is_skippable_header?(key)
       key.match?(LOWERCASE_PATTERN) || # 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))
     end
 
@@ -134,11 +126,15 @@ module Sentry
         Gem::Version.new(::Rack.release) >= Gem::Version.new("3.0")
     end
 
-    def filter_and_format_env(env, rack_env_whitelist)
-      return env if rack_env_whitelist.empty?
-
-      env.select do |k, _v|
-        rack_env_whitelist.include? k.to_s
+    def filter_and_format_env(env, collection, rack_env_whitelist)
+      if rack_env_whitelist.empty?
+        env
+      else
+        env.select do |k, _v|
+          rack_env_whitelist.include? k.to_s
+        end
+      end.then do |e|
+        collection.filter(e)
       end
     end
   end

data/lib/sentry/interfaces/single_exception.rb

@@ -41,7 +41,7 @@ module Sentry
 
     # 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:, mechanism:)
+    def self.build_with_stacktrace(exception:, stacktrace_builder:, mechanism:, data_collection:)
       stacktrace = stacktrace_builder.build(backtrace: exception.backtrace)
 
       if locals = exception.instance_variable_get(:@sentry_locals)
@@ -60,7 +60,7 @@ module Sentry
             end
         end
 
-        stacktrace.frames.last&.vars = locals
+        stacktrace.frames.last&.vars = data_collection.stack_frame_variables.filter(locals)
       end
 
       new(exception: exception, stacktrace: stacktrace, mechanism: mechanism)

data/lib/sentry/net/http.rb

@@ -72,10 +72,9 @@ module Sentry
 
         result = { method: req.method, url: url }
 
-        if Sentry.configuration.send_default_pii
-          result[:query] = uri.query
-          result[:body] = req.body
-        end
+        query = filter_query_params(uri.query)
+        result[:query] = query if query
+        result[:body] = req.body if Sentry.configuration.data_collection.collect_outgoing_http_body?
 
         result
       end

data/lib/sentry/redis.rb

@@ -62,7 +62,7 @@ module Sentry
         command_set = { command: command.to_s.upcase }
         command_set[:key] = key if Utils::EncodingHelper.valid_utf_8?(key)
 
-        if Sentry.configuration.send_default_pii
+        if Sentry.configuration.data_collection.database_query_data
           command_set[:arguments] = arguments
                                     .select { |a| Utils::EncodingHelper.valid_utf_8?(a) }
                                     .join(" ")

data/lib/sentry/scope.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "set"
 require "sentry/breadcrumb_buffer"
 require "sentry/propagation_context"
 require "sentry/attachment"
@@ -24,7 +25,8 @@ module Sentry
       :span,
       :session,
       :attachments,
-      :propagation_context
+      :propagation_context,
+      :attributes
     ]
 
     attr_reader(*ATTRIBUTES)
@@ -84,7 +86,15 @@ module Sentry
     # @param telemetry [MetricEvent, LogEvent] the telemetry event to apply scope context to
     # @return [MetricEvent, LogEvent] the telemetry event with scope context applied
     def apply_to_telemetry(telemetry)
-      # TODO-neel when new scope set_attribute api is added: add them here
+      # Compare as strings since String and Symbol keys serialize to the same wire key.
+      existing_keys = telemetry.attributes.keys.map(&:to_s).to_set
+
+      attributes.each do |key, value|
+        next if existing_keys.include?(key)
+
+        telemetry.attributes[key] = value
+      end
+
       trace_context = get_trace_context
       telemetry.trace_id = trace_context[:trace_id]
       telemetry.span_id = trace_context[:span_id]
@@ -136,6 +146,7 @@ module Sentry
       copy.propagation_context = propagation_context.deep_dup
       copy.attachments = attachments.dup
       copy.event_processors = event_processors.dup
+      copy.attributes = attributes.deep_dup
       copy
     end
 
@@ -154,11 +165,12 @@ module Sentry
       self.span = scope.span
       self.propagation_context = scope.propagation_context
       self.attachments = scope.attachments
+      self.attributes = scope.attributes
     end
 
     # Updates the scope's data from the given options.
     # @param contexts [Hash]
-    # @param extras [Hash]
+    # @param extra [Hash]
     # @param tags [Hash]
     # @param user [Hash]
     # @param level [String, Symbol]
@@ -256,6 +268,32 @@ module Sentry
       set_contexts(key => value)
     end
 
+    # Updates the scope's attributes by merging with the old value.
+    # @param attributes_hash [Hash]
+    # @return [Hash]
+    def set_attributes(attributes_hash)
+      check_argument_type!(attributes_hash, Hash)
+      attributes_hash.each { |key, value| @attributes[key.to_s] = value }
+      @attributes
+    end
+
+    # Sets a single attribute on the scope.
+    # @param key [String, Symbol]
+    # @param value [Object]
+    # @param unit [String, Symbol, nil] an optional measurement unit for the value
+    # @return [Hash]
+    def set_attribute(key, value, unit: nil)
+      value = { value: value, unit: unit } unless unit.nil?
+      set_attributes(key => value)
+    end
+
+    # Removes a single attribute from the scope. No-op if the attribute is not set.
+    # @param key [String, Symbol]
+    # @return [void]
+    def remove_attribute(key)
+      @attributes.delete(key.to_s)
+    end
+
     # Sets the scope's level attribute.
     # @param level [String, Symbol]
     # @return [void]
@@ -361,6 +399,7 @@ module Sentry
       @span = nil
       @session = nil
       @attachments = []
+      @attributes = {}
       generate_propagation_context
       set_new_breadcrumb_buffer
     end

data/lib/sentry/span.rb

@@ -45,6 +45,7 @@ module Sentry
       FUNCTION = "code.function"
       NAMESPACE = "code.namespace"
 
+      MESSAGING_SYSTEM = "messaging.system"
       MESSAGING_MESSAGE_ID = "messaging.message.id"
       MESSAGING_DESTINATION_NAME = "messaging.destination.name"
       MESSAGING_MESSAGE_RECEIVE_LATENCY = "messaging.message.receive.latency"

data/lib/sentry/std_lib_logger.rb

@@ -50,10 +50,6 @@ module Sentry
   end
 end
 
-Sentry.register_patch(:logger) do |config|
-  if config.enable_logs
-    ::Logger.prepend(Sentry::StdLibLogger)
-  else
-    config.sdk_logger.warn(":logger patch enabled but `enable_logs` is turned off - skipping applying patch")
-  end
+Sentry.register_patch(:logger) do
+  ::Logger.prepend(Sentry::StdLibLogger)
 end

data/lib/sentry/telemetry_event_buffer.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require "sentry/threaded_periodic_worker"
 require "sentry/envelope"
 
@@ -58,7 +59,11 @@ module Sentry
 
         if size >= @max_items_before_drop
           log_debug("[#{self.class}] exceeded max capacity, dropping event")
-          @client.transport.record_lost_event(:queue_overflow, @data_category)
+          @client.transport.record_lost_event(
+            :queue_overflow,
+            @data_category,
+            num_bytes: JSON.generate(item.to_h).bytesize
+          )
         else
           @pending_items << item
         end
@@ -92,6 +97,7 @@ module Sentry
       )
 
       discarded_count = 0
+      discarded_bytes = 0
       envelope_items = []
 
       if @before_send
@@ -102,6 +108,7 @@ module Sentry
             envelope_items << processed_item.to_h
           else
             discarded_count += 1
+            discarded_bytes += JSON.generate(item.to_h).bytesize
           end
         end
       else
@@ -109,7 +116,7 @@ module Sentry
       end
 
       unless discarded_count.zero?
-        @client.transport.record_lost_event(:before_send, @data_category, num: discarded_count)
+        @client.transport.record_lost_event(:before_send, @data_category, num: discarded_count, num_bytes: discarded_bytes)
       end
 
       return if envelope_items.empty?

data/lib/sentry/test_helper.rb

@@ -33,7 +33,7 @@ module Sentry
       dummy_config.background_worker_threads = 0
 
       # user can overwrite some of the configs, with a few exceptions like:
-      # - include_local_variables
+      # - data_collection
       # - auto_session_tracking
       block&.call(dummy_config)
 
@@ -52,10 +52,10 @@ module Sentry
       test_client = Sentry::Client.new(dummy_config.dup)
       main_hub.bind_client(test_client)
 
-      # Realign the current thread's hub with the main hub so direct
+      # Realign the current execution context's hub with the main hub so direct
       # `sentry_events` reads and any hub the Rack middleware clones from the
       # main hub all observe the same DummyTransport.
-      Thread.current.thread_variable_set(Sentry::THREAD_LOCAL, main_hub)
+      Sentry.set_current_hub_internal(main_hub)
     end
 
     # Clears all stored events and envelopes.
@@ -90,9 +90,7 @@ module Sentry
         transport.clear if transport.respond_to?(:clear)
       end
 
-      if Sentry.configuration.enable_logs && sentry_logger.respond_to?(:clear)
-        sentry_logger.clear
-      end
+      sentry_logger.clear if sentry_logger.respond_to?(:clear)
     end
 
     # @return [Sentry::StructuredLogger, Sentry::DebugStructuredLogger]
@@ -159,10 +157,13 @@ module Sentry
         # Don't check initialized? because sometimes we stub it in tests
         if Sentry.instance_variable_defined?(:@main_hub)
           Sentry::GLOBALS.each do |var|
+            worker = Sentry.instance_variable_get(:"@#{var}")
+            worker.kill if worker.respond_to?(:kill)
+
             Sentry.instance_variable_set(:"@#{var}", nil)
           end
 
-          Thread.current.thread_variable_set(Sentry::THREAD_LOCAL, nil)
+          Sentry.set_current_hub_internal(nil)
         end
       end
     end

data/lib/sentry/threaded_periodic_worker.rb

@@ -30,10 +30,15 @@ module Sentry
     end
 
     def kill
-      log_debug("[#{self.class.name}] thread killed")
-
       @exited = true
-      @thread&.kill
+
+      # Only a started worker has a thread to kill (and to log about).
+      # Guarding here keeps a never-started worker's teardown silent, so
+      # killing one during test reset can't emit a stray debug line.
+      return unless @thread
+
+      log_debug("[#{self.class.name}] thread killed")
+      @thread.kill
     end
   end
 end

data/lib/sentry/transport.rb

@@ -64,7 +64,7 @@ module Sentry
       end
     rescue Sentry::SizeExceededError
       serialized_items&.each do |item|
-        record_lost_event(:send_error, item.data_category)
+        record_lost_event(:send_error, item.data_category, num: item.item_count, num_bytes: item.lost_event_byte_size)
       end
     end
 
@@ -167,11 +167,16 @@ module Sentry
       envelope
     end
 
-    def record_lost_event(reason, data_category, num: 1)
+    def record_lost_event(reason, data_category, num: 1, num_bytes: nil)
       return unless @send_client_reports
       return unless CLIENT_REPORT_REASONS.include?(reason)
 
       @discarded_events[[reason, data_category]] += num
+
+      return unless num_bytes
+
+      byte_category = Envelope::Item.byte_data_category(data_category)
+      @discarded_events[[reason, byte_category]] += num_bytes if byte_category
     end
 
     def flush
@@ -211,7 +216,13 @@ module Sentry
       envelope.items.reject! do |item|
         if is_rate_limited?(item.data_category)
           log_debug("[Transport] Envelope item [#{item.type}] not sent: rate limiting")
-          record_lost_event(:ratelimit_backoff, item.data_category)
+
+          record_lost_event(
+            :ratelimit_backoff,
+            item.data_category,
+            num: item.item_count,
+            num_bytes: item.lost_event_byte_size
+          )
 
           true
         else

data/lib/sentry/utils/http_tracing.rb

@@ -1,11 +1,39 @@
 # frozen_string_literal: true
 
+require "uri"
+
 module Sentry
   module Utils
     module HttpTracing
+      def filter_query_params(query)
+        return nil unless query
+        return nil unless query.is_a?(String) || query.is_a?(Hash)
+
+        query_hash = if query.is_a?(String)
+          URI.decode_www_form(query).each_with_object({}) do |(key, value), params|
+            params[key] = params.key?(key) ? Array(params[key]) + [value] : value
+          end
+        else
+          query
+        end
+
+        filtered_query_hash = Sentry.configuration.data_collection.url_query_params.filter(query_hash)
+        return nil if filtered_query_hash.empty?
+
+        HttpTracing.format_query(filtered_query_hash)
+      rescue
+        nil
+      end
+
+      def self.format_query(query)
+        query.flat_map do |key, value|
+          Array(value).map { |item| "#{key}=#{item}" }
+        end.join("&")
+      end
+
       def set_span_info(sentry_span, request_info, response_status)
         sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
-        sentry_span.set_data(Span::DataConventions::URL, request_info[:url])
+        sentry_span.set_data(Span::DataConventions::URL, url_with_query(request_info))
         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, response_status)
@@ -43,37 +71,25 @@ module Sentry
           Sentry.configuration.trace_propagation_targets.any? { |target| url.match?(target) }
       end
 
-      # Kindly borrowed from Rack::Utils
-      def build_nested_query(value, prefix = nil)
-        case value
-        when Array
-          value.map { |v|
-            build_nested_query(v, "#{prefix}[]")
-          }.join("&")
-        when Hash
-          value.map { |k, v|
-            build_nested_query(v, prefix ? "#{prefix}[#{k}]" : k)
-          }.delete_if(&:empty?).join("&")
-        when nil
-          URI.encode_www_form_component(prefix)
-        else
-          raise ArgumentError, "value must be a Hash" if prefix.nil?
-          "#{URI.encode_www_form_component(prefix)}=#{URI.encode_www_form_component(value)}"
-        end
-      end
 
       private
 
+      def url_with_query(request_info)
+        return request_info[:url] unless request_info[:query]
+
+        "#{request_info[:url]}?#{request_info[:query]}"
+      end
+
       def get_level(status)
         return :info unless status && status.is_a?(Integer)
 
-if status >= 500
-  :error
-elsif status >= 400
-  :warning
-else
-  :info
-end
+        if status >= 500
+          :error
+        elsif status >= 400
+          :warning
+        else
+          :info
+        end
       end
     end
   end

data/lib/sentry/utils/telemetry_attributes.rb

@@ -7,23 +7,35 @@ module Sentry
     module TelemetryAttributes
       private
 
-      def attribute_hash(value)
-        case value
-        when String
-          { value: value, type: "string" }
-        when TrueClass, FalseClass
-          { value: value, type: "boolean" }
-        when Integer
-          { value: value, type: "integer" }
-        when Float
-          { value: value, type: "double" }
+      def attribute_hash(raw_value)
+        if raw_value.is_a?(Hash) && (raw_value.key?(:value) || raw_value.key?("value"))
+          value = raw_value.key?(:value) ? raw_value[:value] : raw_value["value"]
+          unit = raw_value.key?(:unit) ? raw_value[:unit] : raw_value["unit"]
         else
-          begin
-            { value: JSON.generate(value), type: "string" }
-          rescue
+          value = raw_value
+          unit = nil
+        end
+
+        result =
+          case value
+          when String
             { value: value, type: "string" }
+          when TrueClass, FalseClass
+            { value: value, type: "boolean" }
+          when Integer
+            { value: value, type: "integer" }
+          when Float
+            { value: value, type: "double" }
+          else
+            begin
+              { value: JSON.generate(value), type: "string" }
+            rescue
+              { value: value, type: "string" }
+            end
           end
-        end
+
+        result[:unit] = unit.to_s if unit.is_a?(String) || unit.is_a?(Symbol)
+        result
       end
     end
   end

data/lib/sentry/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sentry
-  VERSION = "6.6.2"
+  VERSION = "7.0.0"
 end