sentry-ruby-core 4.8.0 → 5.2.0

data/lib/sentry/transport.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "json"
 require "base64"
+require "sentry/envelope"
 
 module Sentry
   class Transport
@@ -20,7 +23,10 @@ module Sentry
 
     include LoggingHelper
 
-    attr_reader :logger, :rate_limits, :discarded_events, :last_client_report_sent
+    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
@@ -40,23 +46,54 @@ module Sentry
     end
 
     def send_event(event)
-      event_hash = event.to_hash
-      item_type = get_item_type(event_hash)
+      envelope = envelope_from_event(event)
+      send_envelope(envelope)
+
+      event
+    end
+
+    def send_envelope(envelope)
+      reject_rate_limited_items(envelope)
 
-      if is_rate_limited?(item_type)
-        log_info("Envelope [#{item_type}] not sent: rate limiting")
-        record_lost_event(:ratelimit_backoff, item_type)
+      return if envelope.items.empty?
 
-        return
+      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
 
-      encoded_data = encode(event)
+    def serialize_envelope(envelope)
+      serialized_items = []
+      serialized_results = []
 
-      return nil unless encoded_data
+      envelope.items.each do |item|
+        result = item.to_s
 
-      send_data(encoded_data)
+        if result.bytesize > Event::MAX_SERIALIZED_PAYLOAD_SIZE
+          item.payload.delete(:breadcrumbs)
+          result = item.to_s
+        end
 
-      event
+        if result.bytesize > Event::MAX_SERIALIZED_PAYLOAD_SIZE
+          size_breakdown = item.payload.map do |key, value|
+            "#{key}: #{JSON.generate(value).bytesize}"
+          end.join(", ")
+
+          log_debug("Envelope item [#{item.type}] is still oversized without breadcrumbs: {#{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)
@@ -65,6 +102,8 @@ module Sentry
         case item_type
         when "transaction"
           @rate_limits["transaction"]
+        when "sessions"
+          @rate_limits["session"]
         else
           @rate_limits["error"]
         end
@@ -100,32 +139,28 @@ module Sentry
       'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
     end
 
-    def encode(event)
+    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 = get_item_type(event_payload)
 
-      envelope_header = {
-        event_id: event_id,
-        dsn: @dsn.to_s,
-        sdk: Sentry.sdk_meta,
-        sent_at: Sentry.utc_now.iso8601
-      }
+      envelope = Envelope.new(
+        {
+          event_id: event_id,
+          dsn: @dsn.to_s,
+          sdk: Sentry.sdk_meta,
+          sent_at: Sentry.utc_now.iso8601
+        }
+      )
 
-      event_header = { type: item_type, content_type: 'application/json' }
+      envelope.add_item(
+        { type: item_type, content_type: 'application/json' },
+        event_payload
+      )
 
-      envelope = <<~ENVELOPE
-        #{JSON.generate(envelope_header)}
-        #{JSON.generate(event_header)}
-        #{JSON.generate(event_payload)}
-      ENVELOPE
-
-      client_report = fetch_pending_client_report
-      envelope << client_report if client_report
-
-      log_info("Sending envelope [#{item_type}] #{event_id} to Sentry")
+      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
@@ -159,21 +194,28 @@ module Sentry
       end
 
       item_header = { type: 'client_report' }
-
       item_payload = {
         timestamp: Sentry.utc_now.iso8601,
         discarded_events: discarded_events_hash
       }
 
-      client_report_item = <<~CLIENT_REPORT_ITEM
-        #{JSON.generate(item_header)}
-        #{JSON.generate(item_payload)}
-      CLIENT_REPORT_ITEM
-
       @discarded_events = Hash.new(0)
       @last_client_report_sent = Time.now
 
-      client_report_item
+      [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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module CustomInspection
     def inspect

data/lib/sentry/utils/exception_cause_chain.rb

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

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

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.8.0"
+  VERSION = "5.2.0"
 end

data/lib/sentry-ruby.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "English"
 require "forwardable"
 require "time"
@@ -15,7 +17,7 @@ require "sentry/span"
 require "sentry/transaction"
 require "sentry/hub"
 require "sentry/background_worker"
-
+require "sentry/session_flusher"
 
 [
   "sentry/rake",
@@ -30,6 +32,8 @@ end
 module Sentry
   META = { "name" => "sentry.ruby", "version" => Sentry::VERSION }.freeze
 
+  CAPTURED_SIGNATURE = :@__sentry_captured
+
   LOGGER_PROGNAME = "sentry".freeze
 
   SENTRY_TRACE_HEADER_NAME = "sentry-trace".freeze
@@ -37,6 +41,7 @@ module Sentry
   THREAD_LOCAL = :sentry_hub
 
   class << self
+    # @!visibility private
     def exception_locals_tp
       @exception_locals_tp ||= TracePoint.new(:raise) do |tp|
         exception = tp.raised_exception
@@ -53,46 +58,130 @@ module Sentry
       end
     end
 
+    # @!attribute [rw] background_worker
+    #   @return [BackgroundWorker]
     attr_accessor :background_worker
 
+    # @!attribute [r] session_flusher
+    #   @return [SessionFlusher]
+    attr_reader :session_flusher
+
     ##### Patch Registration #####
-    #
+
+    # @!visibility private
     def register_patch(&block)
       registered_patches << block
     end
 
+    # @!visibility private
     def apply_patches(config)
       registered_patches.each do |patch|
         patch.call(config)
       end
     end
 
+    # @!visibility private
     def registered_patches
       @registered_patches ||= []
     end
 
     ##### Integrations #####
-    #
+
     # Returns a hash that contains all the integrations that have been registered to the main SDK.
+    #
+    # @return [Hash{String=>Hash}]
     def integrations
       @integrations ||= {}
     end
 
     # Registers the SDK integration with its name and version.
+    #
+    # @param name [String] name of the integration
+    # @param version [String] version of the integration
     def register_integration(name, version)
       meta = { name: "sentry.ruby.#{name}", version: version }.freeze
       integrations[name.to_s] = meta
     end
 
     ##### Method Delegation #####
-    #
+
     extend Forwardable
 
-    def_delegators :get_current_client, :configuration, :send_event
-    def_delegators :get_current_scope, :set_tags, :set_extras, :set_user, :set_context
+    # @!macro [new] configuration
+    #   The Configuration object that's used for configuring the client and its transport.
+    #   @return [Configuration]
+    # @!macro [new] send_event
+    #   Sends the event to Sentry.
+    #   @param event [Event] the event to be sent.
+    #   @param hint [Hash] the hint data that'll be passed to `before_send` callback.
+    #   @return [Event]
+
+    # @!method configuration
+    #   @!macro configuration
+    def configuration
+      return unless initialized?
+      get_current_client.configuration
+    end
+
+    # @!method send_event
+    #   @!macro send_event
+    def send_event(*args)
+      return unless initialized?
+      get_current_client.send_event(*args)
+    end
+
+    # @!macro [new] set_extras
+    #   Updates the scope's extras attribute by merging with the old value.
+    #   @param extras [Hash]
+    #   @return [Hash]
+    # @!macro [new] set_user
+    #   Sets the scope's user attribute.
+    #   @param user [Hash]
+    #   @return [Hash]
+    # @!macro [new] set_context
+    #   Adds a new key-value pair to current contexts.
+    #   @param key [String, Symbol]
+    #   @param value [Object]
+    #   @return [Hash]
+    # @!macro [new] set_tags
+    #   Updates the scope's tags attribute by merging with the old value.
+    #   @param tags [Hash]
+    #   @return [Hash]
+
+    # @!method set_tags
+    #   @!macro set_tags
+    def set_tags(*args)
+      return unless initialized?
+      get_current_scope.set_tags(*args)
+    end
+
+    # @!method set_extras
+    #   @!macro set_extras
+    def set_extras(*args)
+      return unless initialized?
+      get_current_scope.set_extras(*args)
+    end
+
+    # @!method set_user
+    #   @!macro set_user
+    def set_user(*args)
+      return unless initialized?
+      get_current_scope.set_user(*args)
+    end
+
+    # @!method set_context
+    #   @!macro set_context
+    def set_context(*args)
+      return unless initialized?
+      get_current_scope.set_context(*args)
+    end
 
     ##### Main APIs #####
+
+    # Initializes the SDK with given configuration.
     #
+    # @yieldparam config [Configuration]
+    # @return [void]
     def init(&block)
       config = Configuration.new
       yield(config) if block_given?
@@ -105,36 +194,62 @@ module Sentry
       @main_hub = hub
       @background_worker = Sentry::BackgroundWorker.new(config)
 
+      @session_flusher = if config.auto_session_tracking
+                           Sentry::SessionFlusher.new(config, client)
+                         else
+                           nil
+                         end
+
       if config.capture_exception_frame_locals
         exception_locals_tp.enable
       end
+
+      at_exit do
+        @session_flusher&.kill
+        @background_worker.shutdown
+      end
+    end
+
+    # Returns true if the SDK is initialized.
+    #
+    # @return [Boolean]
+    def initialized?
+      !!get_main_hub
     end
 
     # Returns an uri for security policy reporting that's generated from the given DSN
     # (To learn more about security policy reporting: https://docs.sentry.io/product/security-policy-reporting/)
     #
     # It returns nil if
+    # - The SDK is not initialized yet.
+    # - The DSN is not provided or is invalid.
     #
-    # 1. The SDK is not initialized yet.
-    # 2. The DSN is not provided or is invalid.
+    # @return [String, nil]
     def csp_report_uri
       return unless initialized?
       configuration.csp_report_uri
     end
 
     # Returns the main thread's active hub.
+    #
+    # @return [Hub]
     def get_main_hub
       @main_hub
     end
 
     # Takes an instance of Sentry::Breadcrumb and stores it to the current active scope.
+    #
+    # @return [Breadcrumb, nil]
     def add_breadcrumb(breadcrumb, **options)
-      get_current_hub&.add_breadcrumb(breadcrumb, **options)
+      return unless initialized?
+      get_current_hub.add_breadcrumb(breadcrumb, **options)
     end
 
     # Returns the current active hub.
     # If the current thread doesn't have an active hub, it will clone the main thread's active hub,
     # stores it in the current thread, and then returns it.
+    #
+    # @return [Hub]
     def get_current_hub
       # we need to assign a hub to the current thread if it doesn't have one yet
       #
@@ -145,85 +260,141 @@ module Sentry
     end
 
     # Returns the current active client.
+    # @return [Client, nil]
     def get_current_client
-      get_current_hub&.current_client
+      return unless initialized?
+      get_current_hub.current_client
     end
 
     # Returns the current active scope.
+    #
+    # @return [Scope, nil]
     def get_current_scope
-      get_current_hub&.current_scope
+      return unless initialized?
+      get_current_hub.current_scope
     end
 
     # Clones the main thread's active hub and stores it to the current thread.
+    #
+    # @return [void]
     def clone_hub_to_current_thread
       Thread.current.thread_variable_set(THREAD_LOCAL, get_main_hub.clone)
     end
 
     # Takes a block and yields the current active scope.
     #
-    # ```ruby
-    # Sentry.configure_scope do |scope|
-    #   scope.set_tags(foo: "bar")
-    # end
+    # @example
+    #   Sentry.configure_scope do |scope|
+    #     scope.set_tags(foo: "bar")
+    #   end
     #
-    # Sentry.capture_message("test message") # this event will have tags { foo: "bar" }
-    # ```
+    #   Sentry.capture_message("test message") # this event will have tags { foo: "bar" }
     #
+    # @yieldparam scope [Scope]
+    # @return [void]
     def configure_scope(&block)
-      get_current_hub&.configure_scope(&block)
+      return unless initialized?
+      get_current_hub.configure_scope(&block)
     end
 
     # Takes a block and yields a temporary scope.
     # The temporary scope will inherit all the attributes from the current active scope and replace it to be the active
-    # scope inside the block. For example:
+    # scope inside the block.
     #
-    # ```ruby
-    # Sentry.configure_scope do |scope|
-    #   scope.set_tags(foo: "bar")
-    # end
+    # @example
+    #   Sentry.configure_scope do |scope|
+    #     scope.set_tags(foo: "bar")
+    #   end
     #
-    # Sentry.capture_message("test message") # this event will have tags { foo: "bar" }
+    #   Sentry.capture_message("test message") # this event will have tags { foo: "bar" }
     #
-    # Sentry.with_scope do |temp_scope|
-    #   temp_scope.set_tags(foo: "baz")
-    #   Sentry.capture_message("test message 2") # this event will have tags { foo: "baz" }
-    # end
+    #   Sentry.with_scope do |temp_scope|
+    #     temp_scope.set_tags(foo: "baz")
+    #     Sentry.capture_message("test message 2") # this event will have tags { foo: "baz" }
+    #   end
     #
-    # Sentry.capture_message("test message 3") # this event will have tags { foo: "bar" }
-    # ```
+    #   Sentry.capture_message("test message 3") # this event will have tags { foo: "bar" }
     #
+    # @yieldparam scope [Scope]
+    # @return [void]
     def with_scope(&block)
-      get_current_hub&.with_scope(&block)
+      return unless initialized?
+      get_current_hub.with_scope(&block)
+    end
+
+    # Wrap a given block with session tracking.
+    # Aggregate sessions in minutely buckets will be recorded
+    # around this block and flushed every minute.
+    #
+    # @example
+    #   Sentry.with_session_tracking do
+    #     a = 1 + 1 # new session recorded with :exited status
+    #   end
+    #
+    #   Sentry.with_session_tracking do
+    #     1 / 0
+    #   rescue => e
+    #     Sentry.capture_exception(e) # new session recorded with :errored status
+    #   end
+    # @return [void]
+    def with_session_tracking(&block)
+      return yield unless initialized?
+      get_current_hub.with_session_tracking(&block)
     end
 
     # Takes an exception and reports it to Sentry via the currently active hub.
+    #
+    # @yieldparam scope [Scope]
+    # @return [Event, nil]
     def capture_exception(exception, **options, &block)
-      get_current_hub&.capture_exception(exception, **options, &block)
+      return unless initialized?
+      get_current_hub.capture_exception(exception, **options, &block)
     end
 
     # Takes a message string and reports it to Sentry via the currently active hub.
+    #
+    # @yieldparam scope [Scope]
+    # @return [Event, nil]
     def capture_message(message, **options, &block)
-      get_current_hub&.capture_message(message, **options, &block)
+      return unless initialized?
+      get_current_hub.capture_message(message, **options, &block)
     end
 
     # Takes an instance of Sentry::Event and dispatches it to the currently active hub.
+    #
+    # @return [Event, nil]
     def capture_event(event)
-      get_current_hub&.capture_event(event)
+      return unless initialized?
+      get_current_hub.capture_event(event)
     end
 
     # Takes or initializes a new Sentry::Transaction and makes a sampling decision for it.
+    #
+    # @return [Transaction, nil]
     def start_transaction(**options)
-      get_current_hub&.start_transaction(**options)
+      return unless initialized?
+      get_current_hub.start_transaction(**options)
     end
 
     # Returns the id of the lastly reported Sentry::Event.
+    #
+    # @return [String, nil]
     def last_event_id
-      get_current_hub&.last_event_id
+      return unless initialized?
+      get_current_hub.last_event_id
     end
 
+    # Checks if the exception object has been captured by the SDK.
+    #
+    # @return [Boolean]
+    def exception_captured?(exc)
+      return false unless initialized?
+      !!exc.instance_variable_get(CAPTURED_SIGNATURE)
+    end
 
     ##### Helpers #####
-    #
+
+    # @!visibility private
     def sys_command(command)
       result = `#{command} 2>&1` rescue nil
       return if result.nil? || result.empty? || ($CHILD_STATUS && $CHILD_STATUS.exitstatus != 0)
@@ -231,18 +402,17 @@ module Sentry
       result.strip
     end
 
-    def initialized?
-      !!@main_hub
-    end
-
+    # @!visibility private
     def logger
       configuration.logger
     end
 
+    # @!visibility private
     def sdk_meta
       META
     end
 
+    # @!visibility private
     def utc_now
       Time.now.utc
     end
@@ -251,3 +421,4 @@ end
 
 # patches
 require "sentry/net/http"
+require "sentry/redis"

data/sentry-ruby-core.gemspec

@@ -22,6 +22,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "faraday"
   spec.add_dependency "concurrent-ruby"
 end

data/sentry-ruby.gemspec

@@ -18,6 +18,5 @@ Gem::Specification.new do |spec|
   spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
 
   spec.add_dependency "sentry-ruby-core", Sentry::VERSION
-  spec.add_dependency "faraday", ">= 1.0"
   spec.add_dependency "concurrent-ruby", '~> 1.0', '>= 1.0.2'
 end