sentry-ruby 5.3.0 → 5.8.0

data/lib/sentry/transport.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require "json"
+require "base64"
+require "sentry/envelope"
+
+module Sentry
+  class Transport
+    PROTOCOL_VERSION = '7'
+    USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
+    CLIENT_REPORT_INTERVAL = 30
+
+    # https://develop.sentry.dev/sdk/client-reports/#envelope-item-payload
+    CLIENT_REPORT_REASONS = [
+      :ratelimit_backoff,
+      :queue_overflow,
+      :cache_overflow, # NA
+      :network_error,
+      :sample_rate,
+      :before_send,
+      :event_processor
+    ]
+
+    include LoggingHelper
+
+    attr_reader :rate_limits, :discarded_events, :last_client_report_sent
+
+    # @deprecated Use Sentry.logger to retrieve the current logger instead.
+    attr_reader :logger
+
+    def initialize(configuration)
+      @logger = configuration.logger
+      @transport_configuration = configuration.transport
+      @dsn = configuration.dsn
+      @rate_limits = {}
+      @send_client_reports = configuration.send_client_reports
+
+      if @send_client_reports
+        @discarded_events = Hash.new(0)
+        @last_client_report_sent = Time.now
+      end
+    end
+
+    def send_data(data, options = {})
+      raise NotImplementedError
+    end
+
+    def send_event(event)
+      envelope = envelope_from_event(event)
+      send_envelope(envelope)
+
+      event
+    end
+
+    def send_envelope(envelope)
+      reject_rate_limited_items(envelope)
+
+      return if envelope.items.empty?
+
+      data, serialized_items = serialize_envelope(envelope)
+
+      if data
+        log_info("[Transport] Sending envelope with items [#{serialized_items.map(&:type).join(', ')}] #{envelope.event_id} to Sentry")
+        send_data(data)
+      end
+    end
+
+    def serialize_envelope(envelope)
+      serialized_items = []
+      serialized_results = []
+
+      envelope.items.each do |item|
+        result, oversized = item.serialize
+
+        if oversized
+          log_info("Envelope item [#{item.type}] is still oversized after size reduction: {#{item.size_breakdown}}")
+
+          next
+        end
+
+        serialized_results << result
+        serialized_items << item
+      end
+
+      data = [JSON.generate(envelope.headers), *serialized_results].join("\n") unless serialized_results.empty?
+
+      [data, serialized_items]
+    end
+
+    def is_rate_limited?(item_type)
+      # check category-specific limit
+      category_delay =
+        case item_type
+        when "transaction"
+          @rate_limits["transaction"]
+        when "sessions"
+          @rate_limits["session"]
+        else
+          @rate_limits["error"]
+        end
+
+      # check universal limit if not category limit
+      universal_delay = @rate_limits[nil]
+
+      delay =
+        if category_delay && universal_delay
+          if category_delay > universal_delay
+            category_delay
+          else
+            universal_delay
+          end
+        elsif category_delay
+          category_delay
+        else
+          universal_delay
+        end
+
+      !!delay && delay > Time.now
+    end
+
+    def generate_auth_header
+      now = Sentry.utc_now.to_i
+      fields = {
+        'sentry_version' => PROTOCOL_VERSION,
+        'sentry_client' => USER_AGENT,
+        'sentry_timestamp' => now,
+        'sentry_key' => @dsn.public_key
+      }
+      fields['sentry_secret'] = @dsn.secret_key if @dsn.secret_key
+      'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
+    end
+
+    def envelope_from_event(event)
+      # Convert to hash
+      event_payload = event.to_hash
+      event_id = event_payload[:event_id] || event_payload["event_id"]
+      item_type = event_payload[:type] || event_payload["type"]
+
+      envelope_headers = {
+        event_id: event_id,
+        dsn: @dsn.to_s,
+        sdk: Sentry.sdk_meta,
+        sent_at: Sentry.utc_now.iso8601
+      }
+
+      if event.is_a?(TransactionEvent) && event.dynamic_sampling_context
+        envelope_headers[:trace] = event.dynamic_sampling_context
+      end
+
+      envelope = Envelope.new(envelope_headers)
+
+      envelope.add_item(
+        { type: item_type, content_type: 'application/json' },
+        event_payload
+      )
+
+      client_report_headers, client_report_payload = fetch_pending_client_report
+      envelope.add_item(client_report_headers, client_report_payload) if client_report_headers
+
+      envelope
+    end
+
+    def record_lost_event(reason, item_type)
+      return unless @send_client_reports
+      return unless CLIENT_REPORT_REASONS.include?(reason)
+
+      @discarded_events[[reason, item_type]] += 1
+    end
+
+    private
+
+    def fetch_pending_client_report
+      return nil unless @send_client_reports
+      return nil if @last_client_report_sent > Time.now - CLIENT_REPORT_INTERVAL
+      return nil if @discarded_events.empty?
+
+      discarded_events_hash = @discarded_events.map do |key, val|
+        reason, type = key
+
+        # 'event' has to be mapped to 'error'
+        category = type == 'transaction' ? 'transaction' : 'error'
+
+        { reason: reason, category: category, quantity: val }
+      end
+
+      item_header = { type: 'client_report' }
+      item_payload = {
+        timestamp: Sentry.utc_now.iso8601,
+        discarded_events: discarded_events_hash
+      }
+
+      @discarded_events = Hash.new(0)
+      @last_client_report_sent = Time.now
+
+      [item_header, item_payload]
+    end
+
+    def reject_rate_limited_items(envelope)
+      envelope.items.reject! do |item|
+        if is_rate_limited?(item.type)
+          log_info("[Transport] Envelope item [#{item.type}] not sent: rate limiting")
+          record_lost_event(:ratelimit_backoff, item.type)
+
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end
+
+require "sentry/transport/dummy_transport"
+require "sentry/transport/http_transport"

data/lib/sentry/utils/argument_checking_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Sentry
+  module ArgumentCheckingHelper
+    private
+
+    def check_argument_type!(argument, expected_type)
+      unless argument.is_a?(expected_type)
+        raise ArgumentError, "expect the argument to be a #{expected_type}, got #{argument.class} (#{argument.inspect})"
+      end
+    end
+  end
+end

data/lib/sentry/utils/custom_inspection.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Sentry
+  module CustomInspection
+    def inspect
+      attr_strings = (instance_variables - self.class::SKIP_INSPECTION_ATTRIBUTES).each_with_object([]) do |attr, result|
+        value = instance_variable_get(attr)
+        result << "#{attr}=#{value.inspect}" if value
+      end
+
+      "#<#{self.class.name} #{attr_strings.join(", ")}>"
+    end
+  end
+end

data/lib/sentry/utils/encoding_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Utils
+    module EncodingHelper
+      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)
+        end
+
+        value = value.scrub unless value.valid_encoding?
+        value
+      end
+
+      def self.valid_utf_8?(value)
+        return true unless value.respond_to?(:force_encoding)
+
+        value.dup.force_encoding(Encoding::UTF_8).valid_encoding?
+      end
+    end
+  end
+end

data/lib/sentry/utils/exception_cause_chain.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Utils
+    module ExceptionCauseChain
+      def self.exception_to_array(exception)
+        exceptions = [exception]
+
+        while exception.cause
+          exception = exception.cause
+          break if exceptions.any? { |e| e.object_id == exception.object_id }
+
+          exceptions << exception
+        end
+
+        exceptions
+      end
+    end
+  end
+end

data/lib/sentry/utils/logging_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sentry
+  module LoggingHelper
+    def log_error(message, exception, debug: false)
+      message = "#{message}: #{exception.message}"
+      message += "\n#{exception.backtrace.join("\n")}" if debug
+
+      @logger.error(LOGGER_PROGNAME) do
+        message
+      end
+    end
+
+    def log_info(message)
+      @logger.info(LOGGER_PROGNAME) { message }
+    end
+
+    def log_debug(message)
+      @logger.debug(LOGGER_PROGNAME) { message }
+    end
+
+    def log_warn(message)
+      @logger.warn(LOGGER_PROGNAME) { message }
+    end
+  end
+end

data/lib/sentry/utils/real_ip.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+# Based on ActionDispatch::RemoteIp. All security-related precautions from that
+# middleware have been removed, because the Event IP just needs to be accurate,
+# and spoofing an IP here only makes data inaccurate, not insecure. Don't re-use
+# this module if you have to *trust* the IP address.
+module Sentry
+  module Utils
+    class RealIp
+      LOCAL_ADDRESSES = [
+        "127.0.0.1",      # localhost IPv4
+        "::1",            # localhost IPv6
+        "fc00::/7",       # private IPv6 range fc00::/7
+        "10.0.0.0/8",     # private IPv4 range 10.x.x.x
+        "172.16.0.0/12",  # private IPv4 range 172.16.0.0 .. 172.31.255.255
+        "192.168.0.0/16", # private IPv4 range 192.168.x.x
+      ]
+
+      attr_reader :ip
+
+      def initialize(
+        remote_addr: nil,
+        client_ip: nil,
+        real_ip: nil,
+        forwarded_for: nil,
+        trusted_proxies: []
+      )
+        @remote_addr = remote_addr
+        @client_ip = client_ip
+        @real_ip = real_ip
+        @forwarded_for = forwarded_for
+        @trusted_proxies = (LOCAL_ADDRESSES + Array(trusted_proxies)).map do |proxy|
+          if proxy.is_a?(IPAddr)
+            proxy
+          else
+            IPAddr.new(proxy.to_s)
+          end
+        end.uniq
+      end
+
+      def calculate_ip
+        # CGI environment variable set by Rack
+        remote_addr = ips_from(@remote_addr).last
+
+        # Could be a CSV list and/or repeated headers that were concatenated.
+        client_ips    = ips_from(@client_ip)
+        real_ips      = ips_from(@real_ip)
+
+        # The first address in this list is the original client, followed by
+        # the IPs of successive proxies. We want to search starting from the end
+        # until we find the first proxy that we do not trust.
+        forwarded_ips = ips_from(@forwarded_for).reverse
+
+        ips = [client_ips, real_ips, forwarded_ips, remote_addr].flatten.compact
+
+        # If every single IP option is in the trusted list, just return REMOTE_ADDR
+        @ip = filter_trusted_proxy_addresses(ips).first || remote_addr
+      end
+
+      protected
+
+      def ips_from(header)
+        # Split the comma-separated list into an array of strings
+        ips = header ? header.strip.split(/[,\s]+/) : []
+        ips.select do |ip|
+          begin
+            # Only return IPs that are valid according to the IPAddr#new method
+            range = IPAddr.new(ip).to_range
+            # we want to make sure nobody is sneaking a netmask in
+            range.begin == range.end
+          rescue ArgumentError
+            nil
+          end
+        end
+      end
+
+      def filter_trusted_proxy_addresses(ips)
+        ips.reject { |ip| @trusted_proxies.any? { |proxy| proxy === ip } }
+      end
+    end
+  end
+end

data/lib/sentry/utils/request_id.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Utils
+    module RequestId
+      REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
+
+      # Request ID based on ActionDispatch::RequestId
+      def self.read_from(env)
+        REQUEST_ID_HEADERS.each do |key|
+          request_id = env[key]
+          return request_id if request_id
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/sentry/version.rb

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