sentry-ruby-core 5.2.1 → 5.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 896f183ea604d1e6857591eff87175f8bb8a83dd1e40fc3e80982a71dd3abe0e
-  data.tar.gz: ffc931b4d436be3c5b1858260a5e2a0508d75455c23d0971bd0f1d2a02f0e178
+  metadata.gz: '05368ec66748ebeba74ec529e6395ce1ad5eb36f1beff0f7014e041a507099fe'
+  data.tar.gz: 150e09181157a7f36a21a46aeffdc37f47db942d967dbf206167ddb6208e6b51
 SHA512:
-  metadata.gz: 467c2493df9a8ba98148b1d467d313bfc23defd9b34a9355242b01ed7ac4f092932b19607ad79e16883f83ba9b1fa53b736872f920f4fb0590761fcdbfc12a25
-  data.tar.gz: 074c4ac8eff86f456646ceef087433abf38a81ad1e8a3d0cec465caddf5a4e96459ed9c641854f7dba37ac9e851fde8f7e09798f35420f4d12586b89039282d4
+  metadata.gz: eec3eb3c33f43854ff89fdf19c5b0b53726c9f79e8e9325969d5241f51490c1096234cbc27aa090bf408207142a265ec9c4eebdf06d159771a5e22a44d405d8b
+  data.tar.gz: e2e50b8e694d3eea9606a41dfcca942ebc41a5e64f128bc455ad34ee9ad5806ae1794993306706039270439bfa26cf7f46614ccf6525d8ecc0a46db6dad3d60a

data/Gemfile

@@ -1,7 +1,6 @@
 source "https://rubygems.org"
 git_source(:github) { |name| "https://github.com/#{name}.git" }
 
-gem "sentry-ruby-core", path: "./"
 gem "sentry-ruby", path: "./"
 
 gem "rack" unless ENV["WITHOUT_RACK"] == "1"

data/README.md

@@ -1,8 +1,11 @@
 <p align="center">
-  <a href="https://sentry.io" target="_blank" align="center">
-    <img src="https://sentry-brand.storage.googleapis.com/sentry-logo-black.png" width="280">
+  <a href="https://sentry.io/?utm_source=github&utm_medium=logo" target="_blank">
+    <picture>
+      <source srcset="https://sentry-brand.storage.googleapis.com/sentry-logo-white.png" media="(prefers-color-scheme: dark)" />
+      <source srcset="https://sentry-brand.storage.googleapis.com/sentry-logo-black.png" media="(prefers-color-scheme: light), (prefers-color-scheme: no-preference)" />
+      <img src="https://sentry-brand.storage.googleapis.com/sentry-logo-black.png" alt="Sentry" width="280">
+    </picture>
   </a>
-  <br />
 </p>
 
 _Bad software is everywhere, and we're tired of it. Sentry is on a mission to help developers write better software faster, so we can get back to enjoying technology. If you want to join us [<kbd>**Check out our open positions**</kbd>](https://sentry.io/careers/)_
@@ -29,7 +32,7 @@ If you're using `sentry-raven`, we recommend you to migrate to this new SDK. You
 
 ## Requirements
 
-We test on Ruby 2.4, 2.5, 2.6, 2.7, and 3.0 at the latest patchlevel/teeny version. We also support JRuby 9.0.
+We test on Ruby 2.4, 2.5, 2.6, 2.7, 3.0, and 3.1 at the latest patchlevel/teeny version. We also support JRuby 9.0.
 
 If you use self-hosted Sentry, please also make sure its version is above `20.6.0`.
 
@@ -52,13 +55,11 @@ gem "sentry-resque"
 
 ### Configuration
 
-You can use `Sentry.init` to initialize and configure your SDK:
-
+You need to use Sentry.init to initialize and configure your SDK:
 ```ruby
 Sentry.init do |config|
   config.dsn = "MY_DSN"
 end
-
 ```
 
 To learn more about available configuration options, please visit the [official documentation](https://docs.sentry.io/platforms/ruby/configuration/options/).

data/lib/sentry/background_worker.rb

@@ -29,7 +29,7 @@ module Sentry
           log_debug("config.background_worker_threads is set to 0, all events will be sent synchronously")
           Concurrent::ImmediateExecutor.new
         else
-          log_debug("initialized a background worker with #{@number_of_threads} threads")
+          log_debug("Initializing the background worker with #{@number_of_threads} threads")
 
           executor = Concurrent::ThreadPoolExecutor.new(
             min_threads: 0,
@@ -59,6 +59,7 @@ module Sentry
     end
 
     def shutdown
+      log_debug("Shutting down background worker")
       @shutdown_callback&.call
     end
 

data/lib/sentry/client.rb

@@ -80,9 +80,10 @@ module Sentry
 
       integration_meta = Sentry.integrations[hint[:integration]]
 
-      Event.new(configuration: configuration, integration_meta: integration_meta).tap do |event|
+      ErrorEvent.new(configuration: configuration, integration_meta: integration_meta).tap do |event|
         event.add_exception_interface(exception)
         event.add_threads_interface(crashed: true)
+        event.level = :error
       end
     end
 
@@ -94,8 +95,9 @@ module Sentry
       return unless @configuration.sending_allowed?
 
       integration_meta = Sentry.integrations[hint[:integration]]
-      event = Event.new(configuration: configuration, integration_meta: integration_meta, message: message)
+      event = ErrorEvent.new(configuration: configuration, integration_meta: integration_meta, message: message)
       event.add_threads_interface(backtrace: backtrace || caller)
+      event.level = :error
       event
     end
 
@@ -133,7 +135,7 @@ module Sentry
 
       event
     rescue => e
-      loggable_event_type = (event_type || "event").capitalize
+      loggable_event_type = event_type.capitalize
       log_error("#{loggable_event_type} sending failed", e, debug: configuration.debug)
 
       event_info = Event.get_log_message(event.to_hash)
@@ -165,7 +167,14 @@ module Sentry
     def dispatch_async_event(async_block, event, hint)
       # We have to convert to a JSON-like hash, because background job
       # processors (esp ActiveJob) may not like weird types in the event hash
-      event_hash = event.to_json_compatible
+
+      event_hash =
+        begin
+          event.to_json_compatible
+        rescue => e
+          log_error("Converting #{event.type} (#{event.event_id}) to JSON compatible hash failed", e, debug: configuration.debug)
+          return
+        end
 
       if async_block.arity == 2
         hint = JSON.parse(JSON.generate(hint))
@@ -174,8 +183,7 @@ module Sentry
         async_block.call(event_hash)
       end
     rescue => e
-      loggable_event_type = event_hash["type"] || "event"
-      log_error("Async #{loggable_event_type} sending failed", e, debug: configuration.debug)
+      log_error("Async #{event_hash["type"]} sending failed", e, debug: configuration.debug)
       send_event(event, hint)
     end
   end

data/lib/sentry/configuration.rb

@@ -290,6 +290,16 @@ module Sentry
     def async=(value)
       check_callable!("async", value)
 
+      log_warn <<~MSG
+
+        sentry-ruby now sends events asynchronously by default with its background worker (supported since 4.1.0).
+        The `config.async` callback has become redundant while continuing to cause issues.
+        (The problems of `async` are detailed in https://github.com/getsentry/sentry-ruby/issues/1522)
+
+        Therefore, we encourage you to remove it and let the background worker take care of async job sending.
+      It's deprecation is planned in the next major release (6.0), which is scheduled around the 3rd quarter of 2022.
+      MSG
+
       @async = value
     end
 

data/lib/sentry/envelope.rb

@@ -4,6 +4,9 @@ module Sentry
   # @api private
   class Envelope
     class Item
+      STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD = 500
+      MAX_SERIALIZED_PAYLOAD_SIZE = 1024 * 200
+
       attr_accessor :headers, :payload
 
       def initialize(headers, payload)
@@ -21,6 +24,54 @@ module Sentry
           #{JSON.generate(@payload)}
         ITEM
       end
+
+      def serialize
+        result = to_s
+
+        if result.bytesize > MAX_SERIALIZED_PAYLOAD_SIZE
+          remove_breadcrumbs!
+          result = to_s
+        end
+
+        if result.bytesize > MAX_SERIALIZED_PAYLOAD_SIZE
+          reduce_stacktrace!
+          result = to_s
+        end
+
+        [result, result.bytesize > MAX_SERIALIZED_PAYLOAD_SIZE]
+      end
+
+      def size_breakdown
+        payload.map do |key, value|
+          "#{key}: #{JSON.generate(value).bytesize}"
+        end.join(", ")
+      end
+
+      private
+
+      def remove_breadcrumbs!
+        if payload.key?(:breadcrumbs)
+          payload.delete(:breadcrumbs)
+        elsif payload.key?("breadcrumbs")
+          payload.delete("breadcrumbs")
+        end
+      end
+
+      def reduce_stacktrace!
+        if exceptions = payload.dig(:exception, :values) || payload.dig("exception", "values")
+          exceptions.each do |exception|
+            # in most cases there is only one exception (2 or 3 when have multiple causes), so we won't loop through this double condition much
+            traces = exception.dig(:stacktrace, :frames) || exception.dig("stacktrace", "frames")
+
+            if traces && traces.size > STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD
+              size_on_both_ends = STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD / 2
+              traces.replace(
+                traces[0..(size_on_both_ends - 1)] + traces[-size_on_both_ends..-1],
+              )
+            end
+          end
+        end
+      end
     end
 
     attr_accessor :headers, :items

data/lib/sentry/error_event.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Sentry
+  # ErrorEvent represents error or normal message events.
+  class ErrorEvent < Event
+    # @return [ExceptionInterface]
+    attr_reader :exception
+
+    # @return [ThreadsInterface]
+    attr_reader :threads
+
+    # @return [Hash]
+    def to_hash
+      data = super
+      data[:threads] = threads.to_hash if threads
+      data[:exception] = exception.to_hash if exception
+      data
+    end
+
+    # @!visibility private
+    def add_threads_interface(backtrace: nil, **options)
+      @threads = ThreadsInterface.build(
+        backtrace: backtrace,
+        stacktrace_builder: @stacktrace_builder,
+        **options
+      )
+    end
+
+    # @!visibility private
+    def add_exception_interface(exception)
+      if exception.respond_to?(:sentry_context)
+        @extra.merge!(exception.sentry_context)
+      end
+
+      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: @stacktrace_builder)
+    end
+  end
+end

data/lib/sentry/event.rb

@@ -9,7 +9,10 @@ require 'sentry/utils/request_id'
 require 'sentry/utils/custom_inspection'
 
 module Sentry
+  # This is an abstract class that defines the shared attributes of an event.
+  # Please don't use it directly. The user-facing classes are its child classes.
   class Event
+    TYPE = "event"
     # These are readable attributes.
     SERIALIZEABLE_ATTRIBUTES = %i(
       event_id level timestamp
@@ -23,7 +26,6 @@ module Sentry
     WRITER_ATTRIBUTES = SERIALIZEABLE_ATTRIBUTES - %i(type timestamp level)
 
     MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
-    MAX_SERIALIZED_PAYLOAD_SIZE = 1024 * 200
 
     SKIP_INSPECTION_ATTRIBUTES = [:@modules, :@stacktrace_builder, :@send_default_pii, :@trusted_proxies, :@rack_env_whitelist]
 
@@ -35,12 +37,6 @@ module Sentry
     # @return [RequestInterface]
     attr_reader :request
 
-    # @return [ExceptionInterface]
-    attr_reader :exception
-
-    # @return [ThreadsInterface]
-    attr_reader :threads
-
     # @param configuration [Configuration]
     # @param integration_meta [Hash, nil]
     # @param message [String, nil]
@@ -49,6 +45,7 @@ module Sentry
       @event_id      = SecureRandom.uuid.delete("-")
       @timestamp     = Sentry.utc_now.iso8601
       @platform      = :ruby
+      @type          = self.class::TYPE
       @sdk           = integration_meta || Sentry.sdk_meta
 
       @user          = {}
@@ -71,8 +68,6 @@ module Sentry
       @rack_env_whitelist = configuration.rack_env_whitelist
 
       @message = (message || "").byteslice(0..MAX_MESSAGE_SIZE_IN_BYTES)
-
-      self.level = :error
     end
 
     class << self
@@ -146,9 +141,6 @@ module Sentry
       data = serialize_attributes
       data[:breadcrumbs] = breadcrumbs.to_hash if breadcrumbs
       data[:request] = request.to_hash if request
-      data[:exception] = exception.to_hash if exception
-      data[:threads] = threads.to_hash if threads
-
       data
     end
 
@@ -157,24 +149,6 @@ module Sentry
       JSON.parse(JSON.generate(to_hash))
     end
 
-    # @!visibility private
-    def add_threads_interface(backtrace: nil, **options)
-      @threads = ThreadsInterface.build(
-        backtrace: backtrace,
-        stacktrace_builder: @stacktrace_builder,
-        **options
-      )
-    end
-
-    # @!visibility private
-    def add_exception_interface(exception)
-      if exception.respond_to?(:sentry_context)
-        @extra.merge!(exception.sentry_context)
-      end
-
-      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: @stacktrace_builder)
-    end
-
     private
 
     def add_request_interface(env)

data/lib/sentry/hub.rb

@@ -150,7 +150,7 @@ module Sentry
         configuration.log_debug(event.to_json_compatible)
       end
 
-      @last_event_id = event&.event_id
+      @last_event_id = event&.event_id unless event.is_a?(Sentry::TransactionEvent)
       event
     end
 

data/lib/sentry/interfaces/exception.rb

@@ -3,6 +3,9 @@ require "set"
 
 module Sentry
   class ExceptionInterface < Interface
+    # @return [<Array[SingleExceptionInterface]>]
+    attr_reader :values
+
     # @param exceptions [Array<SingleExceptionInterface>]
     def initialize(exceptions:)
       @values = exceptions

data/lib/sentry/net/http.rb

@@ -74,11 +74,11 @@ module Sentry
       end
 
       def start_sentry_span
-        return unless Sentry.initialized? && transaction = Sentry.get_current_scope.get_transaction
+        return unless Sentry.initialized? && span = Sentry.get_current_scope.get_span
         return if from_sentry_sdk?
-        return if transaction.sampled == false
+        return if span.sampled == false
 
-        transaction.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
+        span.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
       end
 
       def finish_sentry_span(sentry_span)

data/lib/sentry/rack/capture_exceptions.rb

@@ -3,6 +3,8 @@
 module Sentry
   module Rack
     class CaptureExceptions
+      ERROR_EVENT_ID_KEY = "sentry.error_event_id"
+
       def initialize(app)
         @app = app
       end
@@ -28,13 +30,13 @@ module Sentry
               finish_transaction(transaction, 500)
               raise # Don't capture Sentry errors
             rescue Exception => e
-              capture_exception(e)
+              capture_exception(e, env)
               finish_transaction(transaction, 500)
               raise
             end
 
             exception = collect_exception(env)
-            capture_exception(exception) if exception
+            capture_exception(exception, env) if exception
 
             finish_transaction(transaction, response[0])
 
@@ -53,8 +55,10 @@ module Sentry
         "rack.request".freeze
       end
 
-      def capture_exception(exception)
-        Sentry.capture_exception(exception)
+      def capture_exception(exception, env)
+        Sentry.capture_exception(exception).tap do |event|
+          env[ERROR_EVENT_ID_KEY] = event.event_id if event
+        end
       end
 
       def start_transaction(env, scope)

data/lib/sentry/session_flusher.rb

@@ -8,6 +8,7 @@ module Sentry
 
     def initialize(configuration, client)
       @thread = nil
+      @exited = false
       @client = client
       @pending_aggregates = {}
       @release = configuration.release
@@ -29,9 +30,16 @@ module Sentry
     end
 
     def add_session(session)
+      return if @exited
       return unless @release
 
-      ensure_thread
+      begin
+        ensure_thread
+      rescue ThreadError
+        log_debug("Session flusher thread creation failed")
+        @exited = true
+        return
+      end
 
       return unless Session::AGGREGATE_STATUSES.include?(session.status)
       @pending_aggregates[session.aggregation_key] ||= init_aggregates(session.aggregation_key)
@@ -39,6 +47,9 @@ module Sentry
     end
 
     def kill
+      log_debug("Killing session flusher")
+
+      @exited = true
       @thread&.kill
     end
 

data/lib/sentry/test_helper.rb

@@ -0,0 +1,76 @@
+module Sentry
+  module TestHelper
+    DUMMY_DSN = 'http://12345:67890@sentry.localdomain/sentry/42'
+
+    # Alters the existing SDK configuration with test-suitable options. Mainly:
+    # - Sets a dummy DSN instead of `nil` or an actual DSN.
+    # - Sets the transport to DummyTransport, which allows easy access to the captured events.
+    # - Disables background worker.
+    # - Makes sure the SDK is enabled under the current environment ("test" in most cases).
+    #
+    # It should be called **before** every test case.
+    #
+    # @yieldparam config [Configuration]
+    # @return [void]
+    def setup_sentry_test(&block)
+      raise "please make sure the SDK is initialized for testing" unless Sentry.initialized?
+      copied_config = Sentry.configuration.dup
+      # configure dummy DSN, so the events will not be sent to the actual service
+      copied_config.dsn = DUMMY_DSN
+      # set transport to DummyTransport, so we can easily intercept the captured events
+      copied_config.transport.transport_class = Sentry::DummyTransport
+      # make sure SDK allows sending under the current environment
+      copied_config.enabled_environments << copied_config.environment unless copied_config.enabled_environments.include?(copied_config.environment)
+      # disble async event sending
+      copied_config.background_worker_threads = 0
+
+      # user can overwrite some of the configs, with a few exceptions like:
+      # - capture_exception_frame_locals
+      # - auto_session_tracking
+      block&.call(copied_config)
+
+      test_client = Sentry::Client.new(copied_config)
+      Sentry.get_current_hub.bind_client(test_client)
+    end
+
+    # Clears all stored events and envelopes.
+    # It should be called **after** every test case.
+    # @return [void]
+    def teardown_sentry_test
+      return unless Sentry.initialized?
+
+      sentry_transport.events = []
+      sentry_transport.envelopes = []
+    end
+
+    # @return [Transport]
+    def sentry_transport
+      Sentry.get_current_client.transport
+    end
+
+    # Returns the captured event objects.
+    # @return [Array<Event>]
+    def sentry_events
+      sentry_transport.events
+    end
+
+    # Returns the captured envelope objects.
+    # @return [Array<Envelope>]
+    def sentry_envelopes
+      sentry_transport.envelopes
+    end
+
+    # Returns the last captured event object.
+    # @return [Event, nil]
+    def last_sentry_event
+      sentry_events.last
+    end
+
+    # Extracts SDK's internal exception container (not actual exception objects) from an given event.
+    # @return [Array<Sentry::SingleExceptionInterface>]
+    def extract_sentry_exceptions(event)
+      event&.exception&.values || []
+    end
+  end
+end
+

data/lib/sentry/transaction_event.rb

@@ -1,32 +1,15 @@
 # frozen_string_literal: true
 
 module Sentry
+  # TransactionEvent represents events that carry transaction data (type: "transaction").
   class TransactionEvent < Event
     TYPE = "transaction"
 
-    SERIALIZEABLE_ATTRIBUTES = %i(
-      event_id level timestamp start_timestamp
-      release environment server_name modules
-      user tags contexts extra
-      transaction platform sdk type
-    )
-
-    WRITER_ATTRIBUTES = SERIALIZEABLE_ATTRIBUTES - %i(type timestamp start_timestamp level)
-
-    attr_writer(*WRITER_ATTRIBUTES)
-    attr_reader(*SERIALIZEABLE_ATTRIBUTES)
-
     # @return [<Array[Span]>]
     attr_accessor :spans
 
-    # @param configuration [Configuration]
-    # @param integration_meta [Hash, nil]
-    # @param message [String, nil]
-    def initialize(configuration:, integration_meta: nil, message: nil)
-      super
-      @type = TYPE
-      self.level = nil
-    end
+    # @return [Float, nil]
+    attr_reader :start_timestamp
 
     # Sets the event's start_timestamp.
     # @param time [Time, Float]
@@ -39,6 +22,7 @@ module Sentry
     def to_hash
       data = super
       data[:spans] = @spans.map(&:to_hash) if @spans
+      data[:start_timestamp] = @start_timestamp
       data
     end
   end

data/lib/sentry/transport/http_transport.rb

@@ -130,7 +130,7 @@ module Sentry
       server = URI(@dsn.server)
 
       connection =
-        if proxy = @transport_configuration.proxy
+        if proxy = normalize_proxy(@transport_configuration.proxy)
           ::Net::HTTP.new(server.hostname, server.port, proxy[:uri].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
         else
           ::Net::HTTP.new(server.hostname, server.port, nil)
@@ -148,6 +148,20 @@ module Sentry
       connection
     end
 
+    def normalize_proxy(proxy)
+      return proxy unless proxy
+
+      case proxy
+      when String
+        uri = URI(proxy)
+        { uri: uri, user: uri.user, password: uri.password }
+      when URI
+        { uri: proxy, user: proxy.user, password: proxy.password }
+      when Hash
+        proxy
+      end
+    end
+
     def ssl_configuration
       configuration = {
         verify: @transport_configuration.ssl_verification,

data/lib/sentry/transport.rb

@@ -70,24 +70,10 @@ module Sentry
       serialized_results = []
 
       envelope.items.each do |item|
-        result = item.to_s
+        result, oversized = item.serialize
 
-        if result.bytesize > Event::MAX_SERIALIZED_PAYLOAD_SIZE
-          if item.payload.key?(:breadcrumbs)
-            item.payload.delete(:breadcrumbs)
-          elsif item.payload.key?("breadcrumbs")
-            item.payload.delete("breadcrumbs")
-          end
-
-          result = item.to_s
-        end
-
-        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}}")
+        if oversized
+          log_info("Envelope item [#{item.type}] is still oversized after size reduction: {#{item.size_breakdown}}")
 
           next
         end
@@ -148,7 +134,7 @@ module Sentry
       # 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)
+      item_type = event_payload[:type] || event_payload["type"]
 
       envelope = Envelope.new(
         {
@@ -174,16 +160,11 @@ module Sentry
       return unless @send_client_reports
       return unless CLIENT_REPORT_REASONS.include?(reason)
 
-      item_type ||= 'event'
       @discarded_events[[reason, item_type]] += 1
     end
 
     private
 
-    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

data/lib/sentry/version.rb

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

data/lib/sentry-ruby.rb

@@ -12,6 +12,7 @@ require "sentry/utils/logging_helper"
 require "sentry/configuration"
 require "sentry/logger"
 require "sentry/event"
+require "sentry/error_event"
 require "sentry/transaction_event"
 require "sentry/span"
 require "sentry/transaction"
@@ -59,11 +60,11 @@ module Sentry
     end
 
     # @!attribute [rw] background_worker
-    #   @return [BackgroundWorker]
+    #   @return [BackgroundWorker, nil]
     attr_accessor :background_worker
 
     # @!attribute [r] session_flusher
-    #   @return [SessionFlusher]
+    #   @return [SessionFlusher, nil]
     attr_reader :session_flusher
 
     ##### Patch Registration #####
@@ -102,7 +103,7 @@ module Sentry
       if initialized?
         logger.warn(LOGGER_PROGNAME) do
           <<~MSG
-            Integration '#{name}' is loaded after the SDK is initialized, which can cause expected behavior.  Please make sure all integrations are loaded before SDK initialization.
+            Integration '#{name}' is loaded after the SDK is initialized, which can cause unexpected behavior.  Please make sure all integrations are loaded before SDK initialization.
           MSG
         end
       end
@@ -212,10 +213,30 @@ module Sentry
         exception_locals_tp.enable
       end
 
-      at_exit do
-        @session_flusher&.kill
+      at_exit { close }
+    end
+
+    # Flushes pending events and cleans up SDK state.
+    # SDK will stop sending events and all top-level APIs will be no-ops after this.
+    #
+    # @return [void]
+    def close
+      if @background_worker
         @background_worker.shutdown
+        @background_worker = nil
+      end
+
+      if @session_flusher
+        @session_flusher.kill
+        @session_flusher = nil
+      end
+
+      if configuration&.capture_exception_frame_locals
+        exception_locals_tp.disable
       end
+
+      @main_hub = nil
+      Thread.current.thread_variable_set(THREAD_LOCAL, nil)
     end
 
     # Returns true if the SDK is initialized.
@@ -286,6 +307,7 @@ module Sentry
     #
     # @return [void]
     def clone_hub_to_current_thread
+      return unless initialized?
       Thread.current.thread_variable_set(THREAD_LOCAL, get_main_hub.clone)
     end
 
@@ -359,6 +381,25 @@ module Sentry
       get_current_hub.capture_exception(exception, **options, &block)
     end
 
+    # Takes a block and evaluates it. If the block raised an exception, it reports the exception to Sentry and re-raises it.
+    # If the block ran without exception, it returns the evaluation result.
+    #
+    # @example
+    #   Sentry.with_exception_captured do
+    #     1/1 #=> 1 will be returned
+    #   end
+    #
+    #   Sentry.with_exception_captured do
+    #     1/0 #=> ZeroDivisionError will be reported and re-raised
+    #   end
+    #
+    def with_exception_captured(**options, &block)
+      yield
+    rescue Exception => e
+      capture_exception(e, **options)
+      raise
+    end
+
     # Takes a message string and reports it to Sentry via the currently active hub.
     #
     # @yieldparam scope [Scope]
@@ -384,6 +425,38 @@ module Sentry
       get_current_hub.start_transaction(**options)
     end
 
+    # Records the block's execution as a child of the current span.
+    # If the current scope doesn't have a span, the block would still be executed but the yield param will be nil.
+    # @param attributes [Hash] attributes for the child span.
+    # @yieldparam child_span [Span, nil]
+    # @return yield result
+    #
+    # @example
+    #   Sentry.with_child_span(op: "my operation") do |child_span|
+    #     child_span.set_data(operation_data)
+    #     child_span.set_description(operation_detail)
+    #     # result will be returned
+    #   end
+    #
+    def with_child_span(**attributes, &block)
+      if Sentry.initialized? && current_span = get_current_scope.get_span
+        result = nil
+
+        begin
+          current_span.with_child_span(**attributes) do |child_span|
+            get_current_scope.set_span(child_span)
+            result = yield(child_span)
+          end
+        ensure
+          get_current_scope.set_span(current_span)
+        end
+
+        result
+      else
+        yield(nil)
+      end
+    end
+
     # Returns the id of the lastly reported Sentry::Event.
     #
     # @return [String, nil]

data/sentry-ruby-core.gemspec

@@ -18,9 +18,6 @@ Gem::Specification.new do |spec|
   spec.metadata["source_code_uri"] = spec.homepage
   spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
 
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
+  spec.add_dependency "sentry-ruby", Sentry::VERSION
   spec.add_dependency "concurrent-ruby"
 end

data/sentry-ruby.gemspec

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

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby-core
 version: !ruby/object:Gem::Version
-  version: 5.2.1
+  version: 5.4.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2022-03-18 00:00:00.000000000 Z
+date: 2022-07-26 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: sentry-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.4.0
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -56,6 +70,7 @@ files:
 - lib/sentry/core_ext/object/duplicable.rb
 - lib/sentry/dsn.rb
 - lib/sentry/envelope.rb
+- lib/sentry/error_event.rb
 - lib/sentry/event.rb
 - lib/sentry/exceptions.rb
 - lib/sentry/hub.rb
@@ -79,6 +94,7 @@ files:
 - lib/sentry/session.rb
 - lib/sentry/session_flusher.rb
 - lib/sentry/span.rb
+- lib/sentry/test_helper.rb
 - lib/sentry/transaction.rb
 - lib/sentry/transaction_event.rb
 - lib/sentry/transport.rb