sentry-ruby-core 4.4.2 → 5.0.0

data/lib/sentry/transaction.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   class Transaction < Span
     SENTRY_TRACE_REGEXP = Regexp.new(
@@ -12,7 +14,22 @@ module Sentry
 
     include LoggingHelper
 
-    attr_reader :name, :parent_sampled, :hub, :configuration, :logger
+    # The name of the transaction.
+    # @return [String]
+    attr_reader :name
+
+    # The sampling decision of the parent transaction, which will be considered when making the current transaction's sampling decision.
+    # @return [String]
+    attr_reader :parent_sampled
+
+    # @deprecated Use Sentry.get_current_hub instead.
+    attr_reader :hub
+
+    # @deprecated Use Sentry.configuration instead.
+    attr_reader :configuration
+
+    # @deprecated Use Sentry.logger instead.
+    attr_reader :logger
 
     def initialize(name: nil, parent_sampled: nil, hub:, **options)
       super(**options)
@@ -21,11 +38,23 @@ module Sentry
       @parent_sampled = parent_sampled
       @transaction = self
       @hub = hub
-      @configuration = hub.configuration
-      @logger = configuration.logger
+      @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
+      @logger = hub.configuration.logger
       init_span_recorder
     end
 
+    # 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 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, hub: Sentry.get_current_hub, **options)
       return unless hub.configuration.tracing_enabled?
       return unless sentry_trace
@@ -44,12 +73,14 @@ module Sentry
       new(trace_id: trace_id, parent_span_id: parent_span_id, parent_sampled: parent_sampled, hub: hub, **options)
     end
 
+    # @return [Hash]
     def to_hash
       hash = super
       hash.merge!(name: @name, sampled: @sampled, parent_sampled: @parent_sampled)
       hash
     end
 
+    # @return [Transaction]
     def deep_dup
       copy = super
       copy.init_span_recorder(@span_recorder.max_length)
@@ -63,23 +94,24 @@ module Sentry
       copy
     end
 
+    # Sets initial sampling decision of the transaction.
+    # @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 configuration.tracing_enabled?
+      unless @tracing_enabled
         @sampled = false
         return
       end
 
       return unless @sampled.nil?
 
-      traces_sampler = configuration.traces_sampler
-
       sample_rate =
-        if traces_sampler.is_a?(Proc)
-          traces_sampler.call(sampling_context)
+        if @traces_sampler.is_a?(Proc)
+          @traces_sampler.call(sampling_context)
         elsif !sampling_context[:parent_sampled].nil?
           sampling_context[:parent_sampled]
         else
-          configuration.traces_sample_rate
+          @traces_sample_rate
         end
 
       transaction_description = generate_transaction_description
@@ -111,6 +143,9 @@ module Sentry
       end
     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)
       if hub
         log_warn(
@@ -129,7 +164,10 @@ module Sentry
         @name = UNLABELD_NAME
       end
 
-      return unless @sampled || @parent_sampled
+      unless @sampled || @parent_sampled
+        hub.current_client.transport.record_lost_event(:sample_rate, 'transaction')
+        return
+      end
 
       event = hub.current_client.event_from_transaction(self)
       hub.capture_event(event)

data/lib/sentry/transaction_event.rb

@@ -4,24 +4,37 @@ module Sentry
   class TransactionEvent < Event
     TYPE = "transaction"
 
-    ATTRIBUTES = %i(
+    SERIALIZEABLE_ATTRIBUTES = %i(
       event_id level timestamp start_timestamp
       release environment server_name modules
       user tags contexts extra
       transaction platform sdk type
     )
 
-    attr_accessor(*ATTRIBUTES)
+    WRITER_ATTRIBUTES = SERIALIZEABLE_ATTRIBUTES - %i(type timestamp start_timestamp level)
+
+    attr_writer(*WRITER_ATTRIBUTES)
+    attr_reader(*SERIALIZEABLE_ATTRIBUTES)
+
+    # @return [<Array[Span]>]
     attr_accessor :spans
 
-    def start_timestamp=(time)
-      @start_timestamp = time.is_a?(Time) ? time.to_f : time
+    # @param configuration [Configuration]
+    # @param integration_meta [Hash, nil]
+    # @param message [String, nil]
+    def initialize(configuration:, integration_meta: nil, message: nil)
+      super
+      @type = TYPE
     end
 
-    def type
-      TYPE
+    # Sets the event's start_timestamp.
+    # @param time [Time, Float]
+    # @return [void]
+    def start_timestamp=(time)
+      @start_timestamp = time.is_a?(Time) ? time.to_f : time
     end
 
+    # @return [Hash]
     def to_hash
       data = super
       data[:spans] = @spans.map(&:to_hash) if @spans

data/lib/sentry/transport/configuration.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Sentry
   class Transport
     class Configuration
-      attr_accessor :timeout, :open_timeout, :proxy, :ssl, :ssl_ca_file, :ssl_verification, :http_adapter, :faraday_builder,
-        :transport_class, :encoding
+      attr_accessor :timeout, :open_timeout, :proxy, :ssl, :ssl_ca_file, :ssl_verification, :encoding
+      attr_reader :transport_class
 
       def initialize
         @ssl_verification = true

data/lib/sentry/transport/dummy_transport.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   class DummyTransport < Transport
     attr_accessor :events

data/lib/sentry/transport/http_transport.rb

@@ -1,5 +1,7 @@
-require 'faraday'
-require 'zlib'
+# frozen_string_literal: true
+
+require "net/http"
+require "zlib"
 
 module Sentry
   class HTTPTransport < Transport
@@ -10,12 +12,12 @@ module Sentry
     DEFAULT_DELAY = 60
     RETRY_AFTER_HEADER = "retry-after"
     RATE_LIMIT_HEADER = "x-sentry-rate-limits"
+    USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
 
-    attr_reader :conn, :adapter
+    attr_reader :conn
 
     def initialize(*args)
       super
-      @adapter = @transport_configuration.http_adapter || Faraday.default_adapter
       @conn = set_conn
       @endpoint = @dsn.envelope_endpoint
     end
@@ -28,29 +30,37 @@ module Sentry
         encoding = GZIP_ENCODING
       end
 
-      response = conn.post @endpoint do |req|
-        req.headers['Content-Type'] = CONTENT_TYPE
-        req.headers['Content-Encoding'] = encoding
-        req.headers['X-Sentry-Auth'] = generate_auth_header
-        req.body = data
+      headers = {
+        'Content-Type' => CONTENT_TYPE,
+        'Content-Encoding' => encoding,
+        'X-Sentry-Auth' => generate_auth_header,
+        'User-Agent' => USER_AGENT
+      }
+
+      response = conn.start do |http|
+        request = ::Net::HTTP::Post.new(@endpoint, headers)
+        request.body = data
+        http.request(request)
       end
 
-      if has_rate_limited_header?(response.headers)
-        handle_rate_limited_response(response.headers)
-      end
-    rescue Faraday::Error => e
-      error_info = e.message
+      if response.code.match?(/\A2\d{2}/)
+        if has_rate_limited_header?(response)
+          handle_rate_limited_response(response)
+        end
+      else
+        error_info = "the server responded with status #{response.code}"
 
-      if e.response
-        if e.response[:status] == 429
-          handle_rate_limited_response(e.response[:headers])
+        if response.code == "429"
+          handle_rate_limited_response(response)
         else
-          error_info += "\nbody: #{e.response[:body]}"
-          error_info += " Error in headers is: #{e.response[:headers]['x-sentry-error']}" if e.response[:headers]['x-sentry-error']
+          error_info += "\nbody: #{response.body}"
+          error_info += " Error in headers is: #{response['x-sentry-error']}" if response['x-sentry-error']
         end
-      end
 
-      raise Sentry::ExternalError, error_info
+        raise Sentry::ExternalError, error_info
+      end
+    rescue SocketError => e
+      raise Sentry::ExternalError.new(e.message)
     end
 
     private
@@ -118,31 +128,40 @@ module Sentry
     end
 
     def set_conn
-      server = @dsn.server
+      server = URI(@dsn.server)
 
       log_debug("Sentry HTTP Transport connecting to #{server}")
 
-      Faraday.new(server, :ssl => ssl_configuration, :proxy => @transport_configuration.proxy) do |builder|
-        @transport_configuration.faraday_builder&.call(builder)
-        builder.response :raise_error
-        builder.options.merge! faraday_opts
-        builder.headers[:user_agent] = "sentry-ruby/#{Sentry::VERSION}"
-        builder.adapter(*adapter)
-      end
-    end
+      use_ssl = server.scheme == "https"
+      port = use_ssl ? 443 : 80
 
-    # TODO: deprecate and replace where possible w/Faraday Builder
-    def faraday_opts
-      [:timeout, :open_timeout].each_with_object({}) do |opt, memo|
-        memo[opt] = @transport_configuration.public_send(opt) if @transport_configuration.public_send(opt)
+      connection =
+        if proxy = @transport_configuration.proxy
+          ::Net::HTTP.new(server.hostname, port, proxy[:uri].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
+        else
+          ::Net::HTTP.new(server.hostname, port, nil)
+        end
+
+      connection.use_ssl = use_ssl
+      connection.read_timeout = @transport_configuration.timeout
+      connection.write_timeout = @transport_configuration.timeout if connection.respond_to?(:write_timeout)
+      connection.open_timeout = @transport_configuration.open_timeout
+
+      ssl_configuration.each do |key, value|
+        connection.send("#{key}=", value)
       end
+
+      connection
     end
 
     def ssl_configuration
-      (@transport_configuration.ssl || {}).merge(
-        :verify => @transport_configuration.ssl_verification,
-        :ca_file => @transport_configuration.ssl_ca_file
-      )
+      configuration = {
+        verify: @transport_configuration.ssl_verification,
+        ca_file: @transport_configuration.ssl_ca_file
+      }.merge(@transport_configuration.ssl || {})
+
+      configuration[:verify_mode] = configuration.delete(:verify) ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+      configuration
     end
   end
 end

data/lib/sentry/transport.rb

@@ -1,22 +1,44 @@
+# 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_accessor :configuration
-    attr_reader :logger, :rate_limits
+    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)
-      @configuration = 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 = {})
@@ -27,14 +49,9 @@ module Sentry
       event_hash = event.to_hash
       item_type = get_item_type(event_hash)
 
-      unless configuration.sending_allowed?
-        log_debug("Envelope [#{item_type}] not sent: #{configuration.error_messages}")
-
-        return
-      end
-
       if is_rate_limited?(item_type)
         log_info("Envelope [#{item_type}] not sent: rate limiting")
+        record_lost_event(:ratelimit_backoff, item_type)
 
         return
       end
@@ -91,20 +108,38 @@ module Sentry
 
     def encode(event)
       # Convert to hash
-      event_hash = event.to_hash
+      event_payload = event.to_hash
+      event_id = event_payload[:event_id] || event_payload["event_id"]
+      item_type = get_item_type(event_payload)
+
+      envelope = Envelope.new(
+        {
+          event_id: event_id,
+          dsn: @dsn.to_s,
+          sdk: Sentry.sdk_meta,
+          sent_at: Sentry.utc_now.iso8601
+        }
+      )
+
+      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
 
-      event_id = event_hash[:event_id] || event_hash["event_id"]
-      item_type = get_item_type(event_hash)
+      log_info("Sending envelope [#{item_type}] #{event_id} to Sentry")
 
-      envelope = <<~ENVELOPE
-        {"event_id":"#{event_id}","dsn":"#{configuration.dsn.to_s}","sdk":#{Sentry.sdk_meta.to_json},"sent_at":"#{Sentry.utc_now.iso8601}"}
-        {"type":"#{item_type}","content_type":"application/json"}
-        #{JSON.generate(event_hash)}
-      ENVELOPE
+      envelope.to_s
+    end
 
-      log_info("Sending envelope [#{item_type}] #{event_id} to Sentry")
+    def record_lost_event(reason, item_type)
+      return unless @send_client_reports
+      return unless CLIENT_REPORT_REASONS.include?(reason)
 
-      envelope
+      item_type ||= 'event'
+      @discarded_events[[reason, item_type]] += 1
     end
 
     private
@@ -112,6 +147,32 @@ module Sentry
     def get_item_type(event_hash)
       event_hash[:type] || event_hash["type"] || "event"
     end
+
+    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
   end
 end
 

data/lib/sentry/utils/argument_checking_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module ArgumentCheckingHelper
     private

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

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

data/lib/sentry/utils/logging_helper.rb

@@ -1,24 +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
+      @logger.error(LOGGER_PROGNAME) do
         message
       end
     end
 
     def log_info(message)
-      logger.info(LOGGER_PROGNAME) { message }
+      @logger.info(LOGGER_PROGNAME) { message }
     end
 
     def log_debug(message)
-      logger.debug(LOGGER_PROGNAME) { message }
+      @logger.debug(LOGGER_PROGNAME) { message }
     end
 
     def log_warn(message)
-      logger.warn(LOGGER_PROGNAME) { message }
+      @logger.warn(LOGGER_PROGNAME) { message }
     end
   end
 end

data/lib/sentry/utils/real_ip.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ipaddr'
 
 # Based on ActionDispatch::RemoteIp. All security-related precautions from that
@@ -29,7 +31,13 @@ module Sentry
         @client_ip = client_ip
         @real_ip = real_ip
         @forwarded_for = forwarded_for
-        @trusted_proxies = (LOCAL_ADDRESSES + Array(trusted_proxies)).map { |proxy| IPAddr.new(proxy.to_s) }.uniq
+        @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

data/lib/sentry/utils/request_id.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module Utils
     module RequestId

data/lib/sentry/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
-  VERSION = "4.4.2"
+  VERSION = "5.0.0"
 end