sentry-ruby 5.26.0 → 6.1.1

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

@@ -3,6 +3,9 @@
 module Sentry
   module Utils
     module EncodingHelper
+      EMPTY_STRING = ""
+      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 +20,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,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

data/lib/sentry/utils/sample_rand.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Utils
+    class SampleRand
+      PRECISION = 1_000_000.0
+      FORMAT_PRECISION = 6
+
+      attr_reader :trace_id
+
+      def self.valid?(value)
+        return false unless value
+        value >= 0.0 && value < 1.0
+      end
+
+      def self.format(value)
+        return unless value
+
+        truncated = (value * PRECISION).floor / PRECISION
+        "%.#{FORMAT_PRECISION}f" % truncated
+      end
+
+      def initialize(trace_id: nil)
+        @trace_id = trace_id
+      end
+
+      def generate_from_trace_id
+        (random_from_trace_id * PRECISION).floor / PRECISION
+      end
+
+      def generate_from_sampling_decision(sampled, sample_rate)
+        if invalid_sample_rate?(sample_rate)
+          fallback_generation
+        else
+          generate_based_on_sampling(sampled, sample_rate)
+        end
+      end
+
+      def generate_from_value(sample_rand_value)
+        parsed_value = parse_value(sample_rand_value)
+
+        if self.class.valid?(parsed_value)
+          parsed_value
+        else
+          fallback_generation
+        end
+      end
+
+      private
+
+      def random_from_trace_id
+        if @trace_id
+          Random.new(@trace_id[0, 16].to_i(16))
+        else
+          Random.new
+        end.rand(1.0)
+      end
+
+      def invalid_sample_rate?(sample_rate)
+        sample_rate.nil? || sample_rate <= 0.0 || sample_rate > 1.0
+      end
+
+      def fallback_generation
+        if @trace_id
+          (random_from_trace_id * PRECISION).floor / PRECISION
+        else
+          format_random(Random.rand(1.0))
+        end
+      end
+
+      def generate_based_on_sampling(sampled, sample_rate)
+        random = random_from_trace_id
+
+        result = if sampled
+          random * sample_rate
+        elsif sample_rate == 1.0
+          random
+        else
+          sample_rate + random * (1.0 - sample_rate)
+        end
+
+        format_random(result)
+      end
+
+      def format_random(value)
+        truncated = (value * PRECISION).floor / PRECISION
+        ("%.#{FORMAT_PRECISION}f" % truncated).to_f
+      end
+
+      def parse_value(sample_rand_value)
+        Float(sample_rand_value)
+      rescue ArgumentError
+        nil
+      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.26.0"
+  VERSION = "6.1.1"
 end