sentry-ruby-core 4.2.2 → 4.4.0

data/lib/sentry/transaction_event.rb

@@ -2,6 +2,8 @@
 
 module Sentry
   class TransactionEvent < Event
+    TYPE = "transaction"
+
     ATTRIBUTES = %i(
       event_id level timestamp start_timestamp
       release environment server_name modules
@@ -17,7 +19,7 @@ module Sentry
     end
 
     def type
-      "transaction"
+      TYPE
     end
 
     def to_hash

data/lib/sentry/transport.rb

@@ -6,12 +6,17 @@ module Sentry
     PROTOCOL_VERSION = '5'
     USER_AGENT = "sentry-ruby/#{Sentry::VERSION}"
 
+    include LoggingHelper
+
     attr_accessor :configuration
+    attr_reader :logger, :rate_limits
 
     def initialize(configuration)
       @configuration = configuration
+      @logger = configuration.logger
       @transport_configuration = configuration.transport
       @dsn = configuration.dsn
+      @rate_limits = {}
     end
 
     def send_data(data, options = {})
@@ -19,21 +24,57 @@ module Sentry
     end
 
     def send_event(event)
+      event_hash = event.to_hash
+      item_type = get_item_type(event_hash)
+
       unless configuration.sending_allowed?
-        configuration.logger.debug(LOGGER_PROGNAME) { "Event not sent: #{configuration.error_messages}" }
+        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")
+
         return
       end
 
-      encoded_data = prepare_encoded_event(event)
+      encoded_data = encode(event)
 
       return nil unless encoded_data
 
       send_data(encoded_data)
 
       event
-    rescue => e
-      failed_for_exception(e, event)
-      nil
+    end
+
+    def is_rate_limited?(item_type)
+      # check category-specific limit
+      category_delay =
+        case item_type
+        when "transaction"
+          @rate_limits["transaction"]
+        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
@@ -48,38 +89,28 @@ module Sentry
       'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
     end
 
-    def encode(event_hash)
-      event_id = event_hash[:event_id] || event_hash['event_id']
-      event_type = event_hash[:type] || event_hash['type']
+    def encode(event)
+      # Convert to hash
+      event_hash = event.to_hash
+
+      event_id = event_hash[:event_id] || event_hash["event_id"]
+      item_type = get_item_type(event_hash)
 
       envelope = <<~ENVELOPE
         {"event_id":"#{event_id}","dsn":"#{configuration.dsn.to_s}","sdk":#{Sentry.sdk_meta.to_json},"sent_at":"#{Sentry.utc_now.iso8601}"}
-        {"type":"#{event_type}","content_type":"application/json"}
+        {"type":"#{item_type}","content_type":"application/json"}
         #{JSON.generate(event_hash)}
       ENVELOPE
 
+      log_info("Sending envelope [#{item_type}] #{event_id} to Sentry")
+
       envelope
     end
 
     private
 
-    def prepare_encoded_event(event)
-      # Convert to hash
-      event_hash = event.to_hash
-
-      event_id = event_hash[:event_id] || event_hash["event_id"]
-      event_type = event_hash[:type] || event_hash["type"]
-      configuration.logger.info(LOGGER_PROGNAME) { "Sending #{event_type} #{event_id} to Sentry" }
-      encode(event_hash)
-    end
-
-    def failed_for_exception(e, event)
-      configuration.logger.warn(LOGGER_PROGNAME) { "Unable to record event with remote Sentry server (#{e.class} - #{e.message}):\n#{e.backtrace[0..10].join("\n")}" }
-      log_not_sending(event)
-    end
-
-    def log_not_sending(event)
-      configuration.logger.warn(LOGGER_PROGNAME) { "Failed to submit event. Unreported Event: #{Event.get_log_message(event.to_hash)}" }
+    def get_item_type(event_hash)
+      event_hash[:type] || event_hash["type"] || "event"
     end
   end
 end

data/lib/sentry/transport/configuration.rb

@@ -1,12 +1,14 @@
 module Sentry
   class Transport
     class Configuration
-      attr_accessor :timeout, :open_timeout, :proxy, :ssl, :ssl_ca_file, :ssl_verification, :http_adapter, :faraday_builder, :transport_class
+      attr_accessor :timeout, :open_timeout, :proxy, :ssl, :ssl_ca_file, :ssl_verification, :http_adapter, :faraday_builder,
+        :transport_class, :encoding
 
       def initialize
         @ssl_verification = true
         @open_timeout = 1
         @timeout = 2
+        @encoding = HTTPTransport::GZIP_ENCODING
       end
 
       def transport_class=(klass)

data/lib/sentry/transport/http_transport.rb

@@ -1,8 +1,16 @@
 require 'faraday'
+require 'zlib'
 
 module Sentry
   class HTTPTransport < Transport
-    CONTENT_TYPE = 'application/json'
+    GZIP_ENCODING = "gzip"
+    GZIP_THRESHOLD = 1024 * 30
+    CONTENT_TYPE = 'application/x-sentry-envelope'
+
+    DEFAULT_DELAY = 60
+    RETRY_AFTER_HEADER = "retry-after"
+    RATE_LIMIT_HEADER = "x-sentry-rate-limits"
+
     attr_reader :conn, :adapter
 
     def initialize(*args)
@@ -13,28 +21,106 @@ module Sentry
     end
 
     def send_data(data)
-      conn.post @endpoint do |req|
+      encoding = ""
+
+      if should_compress?(data)
+        data = Zlib.gzip(data)
+        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
       end
+
+      if has_rate_limited_header?(response.headers)
+        handle_rate_limited_response(response.headers)
+      end
     rescue Faraday::Error => e
       error_info = e.message
 
       if e.response
-        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']
+        if e.response[:status] == 429
+          handle_rate_limited_response(e.response[:headers])
+        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']
+        end
       end
 
-      raise Sentry::Error, error_info
+      raise Sentry::ExternalError, error_info
     end
 
     private
 
+    def has_rate_limited_header?(headers)
+      headers[RETRY_AFTER_HEADER] || headers[RATE_LIMIT_HEADER]
+    end
+
+    def handle_rate_limited_response(headers)
+      rate_limits =
+        if rate_limits = headers[RATE_LIMIT_HEADER]
+          parse_rate_limit_header(rate_limits)
+        elsif retry_after = headers[RETRY_AFTER_HEADER]
+          # although Sentry doesn't send a date string back
+          # based on HTTP specification, this could be a date string (instead of an integer)
+          retry_after = retry_after.to_i
+          retry_after = DEFAULT_DELAY if retry_after == 0
+
+          { nil => Time.now + retry_after }
+        else
+          { nil => Time.now + DEFAULT_DELAY }
+        end
+
+      rate_limits.each do |category, limit|
+        if current_limit = @rate_limits[category]
+          if current_limit < limit
+            @rate_limits[category] = limit
+          end
+        else
+          @rate_limits[category] = limit
+        end
+      end
+    end
+
+    def parse_rate_limit_header(rate_limit_header)
+      time = Time.now
+
+      result = {}
+
+      limits = rate_limit_header.split(",")
+      limits.each do |limit|
+        next if limit.nil? || limit.empty?
+
+        begin
+          retry_after, categories = limit.strip.split(":").first(2)
+          retry_after = time + retry_after.to_i
+          categories = categories.split(";")
+
+          if categories.empty?
+            result[nil] = retry_after
+          else
+            categories.each do |category|
+              result[category] = retry_after
+            end
+          end
+        rescue StandardError
+        end
+      end
+
+      result
+    end
+
+    def should_compress?(data)
+      @transport_configuration.encoding == GZIP_ENCODING && data.bytesize >= GZIP_THRESHOLD
+    end
+
     def set_conn
       server = @dsn.server
 
-      configuration.logger.debug(LOGGER_PROGNAME) { "Sentry HTTP Transport connecting to #{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)

data/lib/sentry/utils/logging_helper.rb

@@ -0,0 +1,24 @@
+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/version.rb

@@ -1,3 +1,3 @@
 module Sentry
-  VERSION = "4.2.2"
+  VERSION = "4.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby-core
 version: !ruby/object:Gem::Version
-  version: 4.2.2
+  version: 4.4.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-18 00:00:00.000000000 Z
+date: 2021-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -71,6 +71,7 @@ files:
 - lib/sentry/core_ext/object/duplicable.rb
 - lib/sentry/dsn.rb
 - lib/sentry/event.rb
+- lib/sentry/exceptions.rb
 - lib/sentry/hub.rb
 - lib/sentry/integrable.rb
 - lib/sentry/interface.rb
@@ -78,9 +79,11 @@ files:
 - lib/sentry/interfaces/request.rb
 - lib/sentry/interfaces/single_exception.rb
 - lib/sentry/interfaces/stacktrace.rb
+- lib/sentry/interfaces/stacktrace_builder.rb
 - lib/sentry/interfaces/threads.rb
 - lib/sentry/linecache.rb
 - lib/sentry/logger.rb
+- lib/sentry/net/http.rb
 - lib/sentry/rack.rb
 - lib/sentry/rack/capture_exceptions.rb
 - lib/sentry/rack/deprecations.rb
@@ -95,6 +98,7 @@ files:
 - lib/sentry/transport/http_transport.rb
 - lib/sentry/utils/argument_checking_helper.rb
 - lib/sentry/utils/exception_cause_chain.rb
+- lib/sentry/utils/logging_helper.rb
 - lib/sentry/utils/real_ip.rb
 - lib/sentry/utils/request_id.rb
 - lib/sentry/version.rb
@@ -122,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: A gem that provides a client interface for the Sentry error logger