sentry-ruby 5.28.1 → 6.3.1

data/lib/sentry/span.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "securerandom"
-require "sentry/metrics/local_aggregator"
 require "sentry/utils/uuid"
 
 module Sentry
@@ -173,8 +172,8 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
-      hash = {
+    def to_h
+      {
         trace_id: @trace_id,
         span_id: @span_id,
         parent_span_id: @parent_span_id,
@@ -187,11 +186,6 @@ module Sentry
         data: @data,
         origin: @origin
       }
-
-      summary = metrics_summary
-      hash[:_metrics_summary] = summary if summary
-
-      hash
     end
 
     # Returns the span's context that can be used to embed in an Event.
@@ -307,14 +301,5 @@ module Sentry
     def set_origin(origin)
       @origin = origin
     end
-
-    # Collects gauge metrics on the span for metric summaries.
-    def metrics_local_aggregator
-      @metrics_local_aggregator ||= Sentry::Metrics::LocalAggregator.new
-    end
-
-    def metrics_summary
-      @metrics_local_aggregator&.to_hash
-    end
   end
 end

data/lib/sentry/std_lib_logger.rb

@@ -37,6 +37,10 @@ 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
+          end
+
           Sentry.logger.send(method, message, origin: ORIGIN)
         end
       end

data/lib/sentry/telemetry_event_buffer.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "sentry/threaded_periodic_worker"
+require "sentry/envelope"
+
+module Sentry
+  # TelemetryEventBuffer is a base class for buffering telemetry events (logs, metrics, etc.)
+  # and sending them to Sentry in a single envelope.
+  #
+  # This is used internally by the `Sentry::Client`.
+  #
+  # @!visibility private
+  class TelemetryEventBuffer < ThreadedPeriodicWorker
+    FLUSH_INTERVAL = 5 # seconds
+
+    # @!visibility private
+    attr_reader :pending_items, :envelope_type, :data_category, :thread
+
+    def initialize(configuration, client, event_class:, max_items:, max_items_before_drop:, envelope_type:, envelope_content_type:, before_send:)
+      super(configuration.sdk_logger, FLUSH_INTERVAL)
+
+      @client = client
+      @dsn = configuration.dsn
+      @debug = configuration.debug
+      @event_class = event_class
+      @max_items = max_items
+      @max_items_before_drop = max_items_before_drop
+      @envelope_type = envelope_type
+      @data_category = Sentry::Envelope::Item.data_category(@envelope_type)
+      @envelope_content_type = envelope_content_type
+      @before_send = before_send
+
+      @pending_items = []
+      @mutex = Mutex.new
+
+      log_debug("[#{self.class}] Initialized buffer with max_items=#{@max_items}, flush_interval=#{FLUSH_INTERVAL}s")
+    end
+
+    def flush
+      @mutex.synchronize do
+        return if empty?
+
+        log_debug("[#{self.class}] flushing #{size} #{@event_class}")
+
+        send_items
+      end
+
+      self
+    end
+    alias_method :run, :flush
+
+    def add_item(item)
+      @mutex.synchronize do
+        return unless ensure_thread
+
+        if size >= @max_items_before_drop
+          log_debug("[#{self.class}] exceeded max capacity, dropping event")
+          @client.transport.record_lost_event(:queue_overflow, @data_category)
+        else
+          @pending_items << item
+        end
+
+        send_items if size >= @max_items
+      end
+
+      self
+    end
+
+    def empty?
+      @pending_items.empty?
+    end
+
+    def size
+      @pending_items.size
+    end
+
+    def clear!
+      @pending_items.clear
+    end
+
+    private
+
+    def send_items
+      envelope = Envelope.new(
+        event_id: Sentry::Utils.uuid,
+        sent_at: Sentry.utc_now.iso8601,
+        dsn: @dsn,
+        sdk: Sentry.sdk_meta
+      )
+
+      discarded_count = 0
+      envelope_items = []
+
+      if @before_send
+        @pending_items.each do |item|
+          processed_item = @before_send.call(item)
+
+          if processed_item
+            envelope_items << processed_item.to_h
+          else
+            discarded_count += 1
+          end
+        end
+      else
+        envelope_items = @pending_items.map(&:to_h)
+      end
+
+      unless discarded_count.zero?
+        @client.transport.record_lost_event(:before_send, @data_category, num: discarded_count)
+      end
+
+      return if envelope_items.empty?
+
+      envelope.add_item(
+        {
+          type: @envelope_type,
+          item_count: envelope_items.size,
+          content_type: @envelope_content_type
+        },
+        { items: envelope_items }
+      )
+
+      @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

@@ -27,6 +27,7 @@ module Sentry
       # set transport to DummyTransport, so we can easily intercept the captured events
       dummy_config.transport.transport_class = Sentry::DummyTransport
       # make sure SDK allows sending under the current environment
+      dummy_config.enabled_environments ||= []
       dummy_config.enabled_environments += [dummy_config.environment] unless dummy_config.enabled_environments.include?(dummy_config.environment)
       # disble async event sending
       dummy_config.background_worker_threads = 0
@@ -101,6 +102,13 @@ module Sentry
         .flat_map { |item| item.payload[:items] }
     end
 
+    def sentry_metrics
+      sentry_envelopes
+        .flat_map(&:items)
+        .select { |item| item.headers[:type] == "trace_metric" }
+        .flat_map { |item| item.payload[:items] }
+    end
+
     # Returns the last captured event object.
     # @return [Event, nil]
     def last_sentry_event

data/lib/sentry/transaction.rb

@@ -7,9 +7,6 @@ require "sentry/propagation_context"
 
 module Sentry
   class Transaction < Span
-    # @deprecated Use Sentry::PropagationContext::SENTRY_TRACE_REGEXP instead.
-    SENTRY_TRACE_REGEXP = PropagationContext::SENTRY_TRACE_REGEXP
-
     UNLABELD_NAME = "<unlabeled transaction>"
     MESSAGE_PREFIX = "[Tracing]"
 
@@ -40,12 +37,6 @@ module Sentry
     # @return [Hash]
     attr_reader :measurements
 
-    # @deprecated Use Sentry.get_current_hub instead.
-    attr_reader :hub
-
-    # @deprecated Use Sentry.configuration instead.
-    attr_reader :configuration
-
     # The effective sample rate at which this transaction was sampled.
     # @return [Float, nil]
     attr_reader :effective_sample_rate
@@ -63,7 +54,6 @@ module Sentry
     attr_reader :sample_rand
 
     def initialize(
-      hub:,
       name: nil,
       source: :custom,
       parent_sampled: nil,
@@ -75,26 +65,14 @@ module Sentry
 
       set_name(name, source: source)
       @parent_sampled = parent_sampled
-      @hub = hub
       @baggage = baggage
-      @configuration = hub.configuration # to be removed
-      @tracing_enabled = hub.configuration.tracing_enabled?
-      @traces_sampler = hub.configuration.traces_sampler
-      @traces_sample_rate = hub.configuration.traces_sample_rate
-      @sdk_logger = hub.configuration.sdk_logger
-      @release = hub.configuration.release
-      @environment = hub.configuration.environment
-      @dsn = hub.configuration.dsn
       @effective_sample_rate = nil
       @contexts = {}
       @measurements = {}
       @sample_rand = sample_rand
 
-      unless @hub.profiler_running?
-        @profiler = @configuration.profiler_class.new(@configuration)
-      end
-
       init_span_recorder
+      init_profiler
 
       unless @sample_rand
         generator = Utils::SampleRand.new(trace_id: @trace_id)
@@ -102,65 +80,8 @@ module Sentry
       end
     end
 
-    # @deprecated use Sentry.continue_trace instead.
-    #
-    # Initalizes a Transaction instance with a Sentry trace string from another transaction (usually from an external request).
-    #
-    # The original transaction will become the parent of the new Transaction instance. And they will share the same `trace_id`.
-    #
-    # The child transaction will also store the parent's sampling decision in its `parent_sampled` attribute.
-    # @param sentry_trace [String] the trace string from the previous transaction.
-    # @param baggage [String, nil] the incoming baggage header string.
-    # @param hub [Hub] the hub that'll be responsible for sending this transaction when it's finished.
-    # @param options [Hash] the options you want to use to initialize a Transaction instance.
-    # @return [Transaction, nil]
-    def self.from_sentry_trace(sentry_trace, baggage: nil, hub: Sentry.get_current_hub, **options)
-      return unless hub.configuration.tracing_enabled?
-      return unless sentry_trace
-
-      sentry_trace_data = extract_sentry_trace(sentry_trace)
-      return unless sentry_trace_data
-
-      trace_id, parent_span_id, parent_sampled = sentry_trace_data
-
-      baggage =
-        if baggage && !baggage.empty?
-          Baggage.from_incoming_header(baggage)
-        else
-          # If there's an incoming sentry-trace but no incoming baggage header,
-          # for instance in traces coming from older SDKs,
-          # baggage will be empty and frozen and won't be populated as head SDK.
-          Baggage.new({})
-        end
-
-      baggage.freeze!
-
-      sample_rand = extract_sample_rand_from_baggage(baggage, trace_id, parent_sampled)
-
-      new(
-        trace_id: trace_id,
-        parent_span_id: parent_span_id,
-        parent_sampled: parent_sampled,
-        hub: hub,
-        baggage: baggage,
-        sample_rand: sample_rand,
-        **options
-      )
-    end
-
-    # @deprecated Use Sentry::PropagationContext.extract_sentry_trace instead.
-    # @return [Array, nil]
-    def self.extract_sentry_trace(sentry_trace)
-      PropagationContext.extract_sentry_trace(sentry_trace)
-    end
-
-    def self.extract_sample_rand_from_baggage(baggage, trace_id, parent_sampled)
-      PropagationContext.extract_sample_rand_from_baggage(baggage, trace_id) ||
-        PropagationContext.generate_sample_rand(baggage, trace_id, parent_sampled)
-    end
-
     # @return [Hash]
-    def to_hash
+    def to_h
       hash = super
 
       hash.merge!(
@@ -207,7 +128,9 @@ module Sentry
     # @param sampling_context [Hash] a context Hash that'll be passed to `traces_sampler` (if provided).
     # @return [void]
     def set_initial_sample_decision(sampling_context:)
-      unless @tracing_enabled
+      configuration = Sentry.configuration
+
+      unless configuration && configuration.tracing_enabled?
         @sampled = false
         return
       end
@@ -218,12 +141,12 @@ module Sentry
       end
 
       sample_rate =
-        if @traces_sampler.is_a?(Proc)
-          @traces_sampler.call(sampling_context)
+        if configuration.traces_sampler.is_a?(Proc)
+          configuration.traces_sampler.call(sampling_context)
         elsif !sampling_context[:parent_sampled].nil?
           sampling_context[:parent_sampled]
         else
-          @traces_sample_rate
+          configuration.traces_sample_rate
         end
 
       transaction_description = generate_transaction_description
@@ -265,29 +188,28 @@ module Sentry
     end
 
     # Finishes the transaction's recording and send it to Sentry.
-    # @param hub [Hub] the hub that'll send this transaction. (Deprecated)
     # @return [TransactionEvent]
-    def finish(hub: nil, end_timestamp: nil)
-      if hub
-        log_warn(
-          <<~MSG
-            Specifying a different hub in `Transaction#finish` will be deprecated in version 5.0.
-            Please use `Hub#start_transaction` with the designated hub.
-          MSG
-        )
-      end
-
-      hub ||= @hub
-
+    def finish(end_timestamp: nil)
       super(end_timestamp: end_timestamp)
 
       if @name.nil?
         @name = UNLABELD_NAME
       end
 
-      @hub.stop_profiler!(self)
+      hub = Sentry.get_current_hub
+      return unless hub
 
-      if @sampled
+      hub.stop_profiler!(self)
+
+      if @sampled && ignore_status_code?
+        @sampled = false
+
+        status_code = get_http_status_code
+        log_debug("#{MESSAGE_PREFIX} Discarding #{generate_transaction_description} due to ignored HTTP status code: #{status_code}")
+
+        hub.current_client.transport.record_lost_event(:event_processor, "transaction")
+        hub.current_client.transport.record_lost_event(:event_processor, "span")
+      elsif @sampled
         event = hub.current_client.event_from_transaction(self)
         hub.capture_event(event)
       else
@@ -345,6 +267,15 @@ module Sentry
       @span_recorder.add(self)
     end
 
+    def init_profiler
+      hub = Sentry.get_current_hub
+      return unless hub
+
+      unless hub.profiler_running?
+        @profiler = hub.configuration.profiler_class.new(hub.configuration)
+      end
+    end
+
     private
 
     def generate_transaction_description
@@ -355,14 +286,16 @@ module Sentry
     end
 
     def populate_head_baggage
+      configuration = Sentry.configuration
+
       items = {
         "trace_id" => trace_id,
         "sample_rate" => effective_sample_rate&.to_s,
         "sample_rand" => Utils::SampleRand.format(@sample_rand),
         "sampled" => sampled&.to_s,
-        "environment" => @environment,
-        "release" => @release,
-        "public_key" => @dsn&.public_key
+        "environment" => configuration&.environment,
+        "release" => configuration&.release,
+        "public_key" => configuration&.dsn&.public_key
       }
 
       items["transaction"] = name unless source_low_quality?
@@ -371,6 +304,22 @@ module Sentry
       @baggage = Baggage.new(items, mutable: false)
     end
 
+    def ignore_status_code?
+      trace_ignore_status_codes = Sentry.configuration&.trace_ignore_status_codes
+      return false unless trace_ignore_status_codes
+
+      status_code = get_http_status_code
+      return false unless status_code
+
+      trace_ignore_status_codes.any? do |ignored|
+        ignored.is_a?(Range) ? ignored.include?(status_code) : status_code == ignored
+      end
+    end
+
+    def get_http_status_code
+      @data && @data[Span::DataConventions::HTTP_STATUS_CODE]
+    end
+
     class SpanRecorder
       attr_reader :max_length, :spans
 

data/lib/sentry/transaction_event.rb

@@ -17,9 +17,6 @@ module Sentry
     # @return [Hash, nil]
     attr_accessor :profile
 
-    # @return [Hash, nil]
-    attr_accessor :metrics_summary
-
     def initialize(transaction:, **options)
       super(**options)
 
@@ -32,10 +29,9 @@ module Sentry
       self.tags = transaction.tags
       self.dynamic_sampling_context = transaction.get_baggage.dynamic_sampling_context
       self.measurements = transaction.measurements
-      self.metrics_summary = transaction.metrics_summary
 
       finished_spans = transaction.span_recorder.spans.select { |span| span.timestamp && span != transaction }
-      self.spans = finished_spans.map(&:to_hash)
+      self.spans = finished_spans.map(&:to_h)
 
       populate_profile(transaction)
     end
@@ -48,12 +44,11 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
+    def to_h
       data = super
-      data[:spans] = @spans.map(&:to_hash) if @spans
+      data[:spans] = @spans.map(&:to_h) if @spans
       data[:start_timestamp] = @start_timestamp
       data[:measurements] = @measurements
-      data[:_metrics_summary] = @metrics_summary if @metrics_summary
       data
     end
 
@@ -62,7 +57,7 @@ module Sentry
     EMPTY_PROFILE = {}.freeze
 
     def populate_profile(transaction)
-      profile_hash = transaction.profiler&.to_hash || EMPTY_PROFILE
+      profile_hash = transaction.profiler&.to_h || EMPTY_PROFILE
 
       return if profile_hash.empty?
 

data/lib/sentry/transport.rb

@@ -113,7 +113,7 @@ module Sentry
 
     def envelope_from_event(event)
       # Convert to hash
-      event_payload = event.to_hash
+      event_payload = event.to_h
       event_id = event_payload[:event_id] || event_payload["event_id"]
       item_type = event_payload[:type] || event_payload["type"]
 
@@ -124,10 +124,7 @@ module Sentry
         sent_at: Sentry.utc_now.iso8601
       }
 
-      if event.is_a?(Event) && event.dynamic_sampling_context
-        envelope_headers[:trace] = event.dynamic_sampling_context
-      end
-
+      envelope_headers[:trace] = event.dynamic_sampling_context if event.dynamic_sampling_context
       envelope = Envelope.new(envelope_headers)
 
       if event.is_a?(LogEvent)

data/lib/sentry/utils/encoding_helper.rb

@@ -3,6 +3,8 @@
 module Sentry
   module Utils
     module EncodingHelper
+      MALFORMED_STRING = "<malformed-string>"
+
       def self.encode_to_utf_8(value)
         if value.encoding != Encoding::UTF_8 && value.respond_to?(:force_encoding)
           value = value.dup.force_encoding(Encoding::UTF_8)
@@ -17,6 +19,10 @@ module Sentry
 
         value.dup.force_encoding(Encoding::UTF_8).valid_encoding?
       end
+
+      def self.safe_utf_8_string(value)
+        valid_utf_8?(value) ? value : MALFORMED_STRING
+      end
     end
   end
 end

data/lib/sentry/utils/logging_helper.rb

@@ -3,27 +3,43 @@
 module Sentry
   # @private
   module LoggingHelper
-    # @!visibility private
-    attr_reader :sdk_logger
-
     # @!visibility private
     def log_error(message, exception, debug: false)
       message = "#{message}: #{exception.message}"
-      message += "\n#{exception.backtrace.join("\n")}" if debug
+      message += "\n#{exception.backtrace.join("\n")}" if debug && exception.backtrace
 
-      sdk_logger.error(LOGGER_PROGNAME) do
-        message
-      end
+      sdk_logger&.error(LOGGER_PROGNAME) { message }
+    rescue StandardError => e
+      log_to_stderr(e, message)
     end
 
     # @!visibility private
     def log_debug(message)
-      sdk_logger.debug(LOGGER_PROGNAME) { message }
+      sdk_logger&.debug(LOGGER_PROGNAME) { message }
+    rescue StandardError => e
+      log_to_stderr(e, message)
     end
 
     # @!visibility private
     def log_warn(message)
-      sdk_logger.warn(LOGGER_PROGNAME) { message }
+      sdk_logger&.warn(LOGGER_PROGNAME) { message }
+    rescue StandardError => e
+      log_to_stderr(e, message)
+    end
+
+    # @!visibility private
+    def sdk_logger
+      @sdk_logger ||= Sentry.sdk_logger
+    end
+
+    # @!visibility private
+    def log_to_stderr(error, message)
+      error_msg = "Sentry SDK logging failed (#{error.class}: #{error.message}): #{message}".scrub(%q(<?>))
+      error_msg += "\n#{error.backtrace.map { |line| line.scrub(%q(<?>)) }.join("\n")}" if error.backtrace
+
+      $stderr.puts(error_msg)
+    rescue StandardError
+      # swallow everything – logging must never crash the app
     end
   end
 end

data/lib/sentry/utils/telemetry_attributes.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Sentry
+  module Utils
+    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" }
+        else
+          begin
+            { value: JSON.generate(value), type: "string" }
+          rescue
+            { value: value, type: "string" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentry/vernier/profiler.rb

@@ -20,6 +20,7 @@ module Sentry
 
         @profiling_enabled = defined?(Vernier) && configuration.profiling_enabled?
         @profiles_sample_rate = configuration.profiles_sample_rate
+        @profiles_sample_interval = configuration.profiles_sample_interval
         @project_root = configuration.project_root
         @app_dirs_pattern = configuration.app_dirs_pattern
         @in_app_pattern = Regexp.new("^(#{@project_root}/)?#{@app_dirs_pattern}")
@@ -56,7 +57,7 @@ module Sentry
         return unless @sampled
         return if @started
 
-        @started = ::Vernier.start_profile
+        @started = ::Vernier.start_profile(interval: @profiles_sample_interval)
 
         log("Started")
 
@@ -90,9 +91,9 @@ module Sentry
         Thread.current.object_id
       end
 
-      def to_hash
+      def to_h
         unless @sampled
-          record_lost_event(:sample_rate)
+          record_lost_event(:sample_rate) if @profiling_enabled
           return EMPTY_RESULT
         end
 

data/lib/sentry/version.rb

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