sentry-ruby 5.26.0 → 6.0.0

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

@@ -12,11 +12,16 @@ module Sentry
       4 => :fatal
     }.freeze
 
+    ORIGIN = "auto.log.ruby.std_logger"
+
     def add(severity, message = nil, progname = nil, &block)
       result = super
 
       return unless Sentry.initialized? && Sentry.get_current_hub
 
+      # Only process logs that meet or exceed the logger's level
+      return result if severity < level
+
       # exclude sentry SDK logs -- to prevent recursive log action,
       # do not process internal logs again
       if message.nil? && progname != Sentry::Logger::PROGNAME
@@ -32,7 +37,7 @@ module Sentry
         message = message.to_s.strip
 
         if !message.nil? && message != Sentry::Logger::PROGNAME && method = SEVERITY_MAP[severity]
-          Sentry.logger.send(method, message)
+          Sentry.logger.send(method, message, origin: ORIGIN)
         end
       end
 

data/lib/sentry/test_helper.rb

@@ -2,8 +2,13 @@
 
 module Sentry
   module TestHelper
+    module_function
+
     DUMMY_DSN = "http://12345:67890@sentry.localdomain/sentry/42"
 
+    # Not really real, but it will be resolved as a non-local for testing needs
+    REAL_DSN = "https://user:pass@getsentry.io/project/42"
+
     # Alters the existing SDK configuration with test-suitable options. Mainly:
     # - Sets a dummy DSN instead of `nil` or an actual DSN.
     # - Sets the transport to DummyTransport, which allows easy access to the captured events.
@@ -22,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
@@ -46,6 +52,8 @@ module Sentry
     def teardown_sentry_test
       return unless Sentry.initialized?
 
+      clear_sentry_events
+
       # pop testing layer created by `setup_sentry_test`
       # but keep the base layer to avoid nil-pointer errors
       # TODO: find a way to notify users if they somehow popped the test layer before calling this method
@@ -55,6 +63,21 @@ module Sentry
       Sentry::Scope.global_event_processors.clear
     end
 
+    def clear_sentry_events
+      return unless Sentry.initialized?
+
+      sentry_transport.clear if sentry_transport.respond_to?(:clear)
+
+      if Sentry.configuration.enable_logs && sentry_logger.respond_to?(:clear)
+        sentry_logger.clear
+      end
+    end
+
+    # @return [Sentry::StructuredLogger, Sentry::DebugStructuredLogger]
+    def sentry_logger
+      Sentry.logger
+    end
+
     # @return [Transport]
     def sentry_transport
       Sentry.get_current_client.transport

data/lib/sentry/transaction.rb

@@ -2,13 +2,11 @@
 
 require "sentry/baggage"
 require "sentry/profiler"
+require "sentry/utils/sample_rand"
 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]"
 
@@ -39,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
@@ -57,90 +49,39 @@ module Sentry
     # @return [Profiler]
     attr_reader :profiler
 
+    # Sample rand value generated from trace_id
+    # @return [String]
+    attr_reader :sample_rand
+
     def initialize(
-      hub:,
       name: nil,
       source: :custom,
       parent_sampled: nil,
       baggage: nil,
+      sample_rand: nil,
       **options
     )
       super(transaction: self, **options)
 
       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 = {}
-
-      unless @hub.profiler_running?
-        @profiler = @configuration.profiler_class.new(@configuration)
-      end
+      @sample_rand = sample_rand
 
       init_span_recorder
-    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
+      init_profiler
 
-      baggage.freeze!
-
-      new(
-        trace_id: trace_id,
-        parent_span_id: parent_span_id,
-        parent_sampled: parent_sampled,
-        hub: hub,
-        baggage: baggage,
-        **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)
+      unless @sample_rand
+        generator = Utils::SampleRand.new(trace_id: @trace_id)
+        @sample_rand = generator.generate_from_trace_id
+      end
     end
 
     # @return [Hash]
-    def to_hash
+    def to_h
       hash = super
 
       hash.merge!(
@@ -153,6 +94,13 @@ module Sentry
       hash
     end
 
+    def parent_sample_rate
+      return unless @baggage&.items
+
+      sample_rate_str = @baggage.items["sample_rate"]
+      sample_rate_str&.to_f
+    end
+
     # @return [Transaction]
     def deep_dup
       copy = super
@@ -180,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
@@ -191,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
@@ -225,7 +175,7 @@ module Sentry
           @effective_sample_rate /= 2**factor
         end
 
-        @sampled = Random.rand < @effective_sample_rate
+        @sampled = @sample_rand < @effective_sample_rate
       end
 
       if @sampled
@@ -238,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
@@ -318,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
@@ -328,13 +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?
@@ -343,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/debug_transport.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "pathname"
+require "delegate"
+
+module Sentry
+  # DebugTransport is a transport that logs events to a file for debugging purposes.
+  #
+  # It can optionally also send events to Sentry via HTTP transport if a real DSN
+  # is provided.
+  class DebugTransport < SimpleDelegator
+    DEFAULT_LOG_FILE_PATH = File.join("log", "sentry_debug_events.log")
+
+    attr_reader :log_file, :backend
+
+    def initialize(configuration)
+      @log_file = initialize_log_file(configuration)
+      @backend = initialize_backend(configuration)
+
+      super(@backend)
+    end
+
+    def send_event(event)
+      log_envelope(envelope_from_event(event))
+      backend.send_event(event)
+    end
+
+    def log_envelope(envelope)
+      envelope_json = {
+        timestamp: Time.now.utc.iso8601,
+        envelope_headers: envelope.headers,
+        items: envelope.items.map do |item|
+          { headers: item.headers, payload: item.payload }
+        end
+      }
+
+      File.open(log_file, "a") { |file| file << JSON.dump(envelope_json) << "\n" }
+    end
+
+    def logged_envelopes
+      return [] unless File.exist?(log_file)
+
+      File.readlines(log_file).map do |line|
+        JSON.parse(line)
+      end
+    end
+
+    def clear
+      File.write(log_file, "")
+      log_debug("DebugTransport: Cleared events from #{log_file}")
+    end
+
+    private
+
+    def initialize_backend(configuration)
+      backend = configuration.dsn.local? ? DummyTransport : HTTPTransport
+      backend.new(configuration)
+    end
+
+    def initialize_log_file(configuration)
+      log_file = Pathname(configuration.sdk_debug_transport_log_file || DEFAULT_LOG_FILE_PATH)
+
+      FileUtils.mkdir_p(log_file.dirname) unless log_file.dirname.exist?
+
+      log_file
+    end
+  end
+end

data/lib/sentry/transport/dummy_transport.rb

@@ -12,6 +12,7 @@ module Sentry
 
     def send_event(event)
       @events << event
+      super
     end
 
     def send_envelope(envelope)

data/lib/sentry/transport/http_transport.rb

@@ -45,11 +45,7 @@ module Sentry
       auth_header = generate_auth_header
       headers["X-Sentry-Auth"] = auth_header if auth_header
 
-      response = conn.start do |http|
-        request = ::Net::HTTP::Post.new(endpoint, headers)
-        request.body = data
-        http.request(request)
-      end
+      response = do_request(endpoint, headers, data)
 
       if response.code.match?(/\A2\d{2}/)
         handle_rate_limited_response(response) if has_rate_limited_header?(response)
@@ -111,6 +107,14 @@ module Sentry
       connection
     end
 
+    def do_request(endpoint, headers, body)
+      conn.start do |http|
+        request = ::Net::HTTP::Post.new(endpoint, headers)
+        request.body = body
+        http.request(request)
+      end
+    end
+
     private
 
     def has_rate_limited_header?(headers)

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)
@@ -223,3 +220,4 @@ end
 require "sentry/transport/dummy_transport"
 require "sentry/transport/http_transport"
 require "sentry/transport/spotlight_transport"
+require "sentry/transport/debug_transport"

data/lib/sentry/utils/logging_helper.rb

@@ -3,27 +3,29 @@
 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
 
-      sdk_logger.error(LOGGER_PROGNAME) do
+      sdk_logger&.error(LOGGER_PROGNAME) do
         message
       end
     end
 
     # @!visibility private
     def log_debug(message)
-      sdk_logger.debug(LOGGER_PROGNAME) { message }
+      sdk_logger&.debug(LOGGER_PROGNAME) { message }
     end
 
     # @!visibility private
     def log_warn(message)
-      sdk_logger.warn(LOGGER_PROGNAME) { message }
+      sdk_logger&.warn(LOGGER_PROGNAME) { message }
+    end
+
+    # @!visibility private
+    def sdk_logger
+      @sdk_logger ||= Sentry.sdk_logger
     end
   end
 end