sentry-ruby 6.7.0 → 7.1.0

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/log_event_buffer.rb

@@ -21,7 +21,7 @@ module Sentry
         max_items_before_drop: MAX_EVENTS_BEFORE_DROP,
         envelope_type: "log",
         envelope_content_type: "application/vnd.sentry.items.log+json",
-        before_send: configuration.before_send_log
+        before_send: :before_send_log
       )
     end
   end

data/lib/sentry/metric_event.rb

@@ -6,7 +6,7 @@ module Sentry
   class MetricEvent
     include Sentry::Utils::TelemetryAttributes
 
-    attr_reader :name, :type, :value, :unit, :timestamp, :trace_id, :span_id, :attributes
+    attr_reader :name, :type, :value, :unit, :timestamp, :trace_id, :span_id, :attributes, :integration_meta
     attr_writer :trace_id, :span_id, :attributes
 
     def initialize(
@@ -14,13 +14,15 @@ module Sentry
       type:,
       value:,
       unit: nil,
-      attributes: nil
+      attributes: nil,
+      integration_meta: nil
     )
       @name = name
       @type = type
       @value = value
       @unit = unit
       @attributes = attributes || {}
+      @integration_meta = integration_meta
 
       @timestamp = Sentry.utc_now
       @trace_id = nil

data/lib/sentry/metric_event_buffer.rb

@@ -21,7 +21,7 @@ module Sentry
         max_items_before_drop: MAX_METRICS_BEFORE_DROP,
         envelope_type: "trace_metric",
         envelope_content_type: "application/vnd.sentry.items.trace-metric+json",
-        before_send: configuration.before_send_metric
+        before_send: :before_send_metric
       )
     end
   end

data/lib/sentry/metrics.rb

@@ -9,15 +9,17 @@ module Sentry
       # @param name [String] the metric name
       # @param value [Numeric] the value to increment by (default: 1)
       # @param attributes [Hash, nil] additional attributes for the metric (optional)
+      # @param integration [String, Symbol, nil] registered integration emitting the metric (optional)
       # @return [void]
-      def count(name, value: 1, attributes: nil)
+      def count(name, value: 1, attributes: nil, integration: nil)
         return unless Sentry.initialized?
 
         Sentry.get_current_hub.capture_metric(
           name: name,
           type: :counter,
           value: value,
-          attributes: attributes
+          attributes: attributes,
+          integration: integration
         )
       end
 
@@ -26,8 +28,9 @@ module Sentry
       # @param value [Numeric] the gauge value
       # @param unit [String, nil] the metric unit (optional)
       # @param attributes [Hash, nil] additional attributes for the metric (optional)
+      # @param integration [String, Symbol, nil] registered integration emitting the metric (optional)
       # @return [void]
-      def gauge(name, value, unit: nil, attributes: nil)
+      def gauge(name, value, unit: nil, attributes: nil, integration: nil)
         return unless Sentry.initialized?
 
         Sentry.get_current_hub.capture_metric(
@@ -35,7 +38,8 @@ module Sentry
           type: :gauge,
           value: value,
           unit: unit,
-          attributes: attributes
+          attributes: attributes,
+          integration: integration
         )
       end
 
@@ -44,8 +48,9 @@ module Sentry
       # @param value [Numeric] the distribution value
       # @param unit [String, nil] the metric unit (optional)
       # @param attributes [Hash, nil] additional attributes for the metric (optional)
+      # @param integration [String, Symbol, nil] registered integration emitting the metric (optional)
       # @return [void]
-      def distribution(name, value, unit: nil, attributes: nil)
+      def distribution(name, value, unit: nil, attributes: nil, integration: nil)
         return unless Sentry.initialized?
 
         Sentry.get_current_hub.capture_metric(
@@ -53,7 +58,8 @@ module Sentry
           type: :distribution,
           value: value,
           unit: unit,
-          attributes: attributes
+          attributes: attributes,
+          integration: integration
         )
       end
     end

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

@@ -9,6 +9,7 @@ require "etc"
 module Sentry
   class Scope
     include ArgumentCheckingHelper
+    include CallbackHelper
 
     ATTRIBUTES = [
       :transaction_name,
@@ -71,7 +72,8 @@ module Sentry
 
       unless all_event_processors.empty?
         all_event_processors.each do |processor_block|
-          event = processor_block.call(event, hint)
+          event = safe_dispatch_callback("event_processor", processor_block, [event, hint])
+          return unless event
         end
       end
 
@@ -102,8 +104,10 @@ module Sentry
       configuration = Sentry.configuration
       return telemetry unless configuration
 
-      telemetry.attributes["sentry.sdk.name"] ||= Sentry.sdk_meta["name"]
-      telemetry.attributes["sentry.sdk.version"] ||= Sentry.sdk_meta["version"]
+      sdk_meta = telemetry.respond_to?(:integration_meta) ? telemetry.integration_meta : nil
+      sdk_meta ||= Sentry.sdk_meta
+      telemetry.attributes["sentry.sdk.name"] ||= sdk_meta[:name] || sdk_meta["name"]
+      telemetry.attributes["sentry.sdk.version"] ||= sdk_meta[:version] || sdk_meta["version"]
       telemetry.attributes["sentry.environment"] ||= configuration.environment if configuration.environment
       telemetry.attributes["sentry.release"] ||= configuration.release if configuration.release
       telemetry.attributes["server.address"] ||= configuration.server_name if configuration.server_name

data/lib/sentry/session_flusher.rb

@@ -35,6 +35,13 @@ module Sentry
 
     private
 
+    def reset_if_forked
+      return unless super
+
+      @mutex = Mutex.new
+      @pending_aggregates = {}
+    end
+
     def init_aggregates(aggregation_key)
       aggregates = { started: aggregation_key.iso8601 }
       Session::AGGREGATE_STATUSES.each { |k| aggregates[k] = 0 }

data/lib/sentry/std_lib_logger.rb

@@ -4,6 +4,8 @@ module Sentry
   # Ruby Logger support Add commentMore actions
   # intercepts any logger instance and send the log to Sentry too.
   module StdLibLogger
+    include CallbackHelper
+
     SEVERITY_MAP = {
       0 => :debug,
       1 => :info,
@@ -37,8 +39,12 @@ module Sentry
         message = message.to_s.strip
 
         if !message.nil? && message != Sentry::Logger::PROGNAME && method = SEVERITY_MAP[severity]
-          if (filter = Sentry.configuration.std_lib_logger_filter) && !filter.call(self, message, method)
-            return result
+          if filter = Sentry.configuration.std_lib_logger_filter
+            return result unless safe_dispatch_callback(
+              "std_lib_logger_filter",
+              filter,
+              [self, message, method]
+            )
           end
 
           Sentry.logger.send(method, message, origin: ORIGIN)
@@ -50,10 +56,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

@@ -12,7 +12,10 @@ module Sentry
   #
   # @!visibility private
   class TelemetryEventBuffer < ThreadedPeriodicWorker
+    include CallbackHelper
+
     FLUSH_INTERVAL = 5 # seconds
+    FLUSH_TIMEOUT = 2 # seconds
 
     # @!visibility private
     attr_reader :pending_items, :envelope_type, :data_category, :thread
@@ -21,6 +24,7 @@ module Sentry
       super(configuration.sdk_logger, FLUSH_INTERVAL)
 
       @client = client
+      @configuration = configuration
       @dsn = configuration.dsn
       @debug = configuration.debug
       @event_class = event_class
@@ -38,39 +42,44 @@ module Sentry
     end
 
     def flush
-      @mutex.synchronize do
-        return if empty?
-
-        log_debug("[#{self.class}] flushing #{size} #{@event_class}")
+      return unless thread&.alive? && wake
 
-        send_items
-      end
+      wait_until_idle(FLUSH_TIMEOUT)
+    end
 
-      self
+    def run
+      flush_pending_items
     end
-    alias_method :run, :flush
 
     def add_item(item)
+      # the buffer thread can never add telemetry itself to prevent recursion
+      return self if Thread.current == thread
+      return unless ensure_thread
+
       # Prevent ThreadError from re-entrant locking (e.g. transport instrumentation calling Sentry.metrics.*)
       return self if @mutex.owned?
 
-      @mutex.synchronize do
-        return unless ensure_thread
-
+      dropped = false
+      size_exceeded = @mutex.synchronize do
         if size >= @max_items_before_drop
-          log_debug("[#{self.class}] exceeded max capacity, dropping event")
-          @client.transport.record_lost_event(
-            :queue_overflow,
-            @data_category,
-            num_bytes: JSON.generate(item.to_h).bytesize
-          )
+          dropped = true
         else
           @pending_items << item
         end
 
-        send_items if size >= @max_items
+        size >= @max_items
+      end
+
+      if dropped
+        log_debug("[#{self.class}] exceeded max capacity, dropping event")
+        @client.transport.record_lost_event(
+          :queue_overflow,
+          @data_category,
+          num_bytes: JSON.generate(item.to_h).bytesize
+        )
       end
 
+      wake if size_exceeded
       self
     end
 
@@ -88,21 +97,40 @@ module Sentry
 
     private
 
-    def send_items
-      envelope = Envelope.new(
-        event_id: Sentry::Utils.uuid,
-        sent_at: Sentry.utc_now.iso8601,
-        dsn: @dsn,
-        sdk: Sentry.sdk_meta
-      )
+    def reset_if_forked
+      return unless super
+
+      # Discard items inherited from the parent to avoid duplicate delivery.
+      @mutex = Mutex.new
+      @pending_items = []
+    end
+
+    def flush_pending_items
+      pending_items = @mutex.synchronize do
+        next if @pending_items.empty?
+
+        items = @pending_items
+        @pending_items = []
+        items
+      end
+
+      return unless pending_items
+
+      log_debug("[#{self.class}] flushing #{pending_items.size} #{@event_class}")
+      send_items(pending_items)
+      self
+    end
+
+    def send_items(pending_items)
+      envelope = Envelope.new(sent_at: Sentry.utc_now.iso8601)
 
       discarded_count = 0
       discarded_bytes = 0
       envelope_items = []
 
-      if @before_send
-        @pending_items.each do |item|
-          processed_item = @before_send.call(item)
+      if callback = @configuration.send(@before_send)
+        pending_items.each do |item|
+          processed_item = safe_dispatch_callback(@before_send.to_s, callback, [item])
 
           if processed_item
             envelope_items << processed_item.to_h
@@ -112,7 +140,7 @@ module Sentry
           end
         end
       else
-        envelope_items = @pending_items.map(&:to_h)
+        envelope_items = pending_items.map(&:to_h)
       end
 
       unless discarded_count.zero?
@@ -133,8 +161,6 @@ module Sentry
       @client.send_envelope(envelope)
     rescue => e
       log_error("[#{self.class}] Failed to send #{@event_class}", e, debug: @debug)
-    ensure
-      clear!
     end
   end
 end

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)
 
@@ -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]
@@ -129,6 +127,8 @@ module Sentry
     end
 
     def sentry_logs
+      Sentry.get_current_client&.log_event_buffer&.flush
+
       sentry_envelopes
         .flat_map(&:items)
         .select { |item| item.headers[:type] == "log" }
@@ -136,6 +136,8 @@ module Sentry
     end
 
     def sentry_metrics
+      Sentry.get_current_client&.metric_event_buffer&.flush
+
       sentry_envelopes
         .flat_map(&:items)
         .select { |item| item.headers[:type] == "trace_metric" }