sentry-ruby-core 5.0.2 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f6a137330d349e7d0cfa5535bdf80f940266df9e01b4f134df6a49c475724fa
-  data.tar.gz: 27d2fd1c95d69dc1cf6b01a2ca6c9c6e58fcaf2cba2a76706b6a26fe323f4599
+  metadata.gz: c6a629d8aa998cef5638cd40e3dc9e0ad24770d0c31540b327c669e9fb84aedd
+  data.tar.gz: e373b601b401fddca9307a32ea1dda36bc4994209c68b19748e89f128a598e80
 SHA512:
-  metadata.gz: c6f8a78bd9bdb89ca6f710a036e1e4917891968e1de929da024dbebc12a5d86642a51e367b329b6a1c9f6c670af47d5bad0a8fd15804c3511f33edd5333ae789
-  data.tar.gz: '0559dd91dcdb831e132d5e74d0680cdedbb3e07c83b1f3129e635eb868bc8fb5a84e27813276058d436709543ec45f602f3f89ababec9295b1b0208292ee77c7'
+  metadata.gz: 2cfd2f1fe582578b74bc23610931d95bf7a86c35c696c658d55fb4f40ddfdd129c36bae415bc73efef20ecfb435f33ba72e3b46a96f536c0c61692d8c8cb34e2
+  data.tar.gz: f10f71edc8bef7a57426de73e0cf2a1aea855c89ec2900a065986d33f064216f7da74c0cf9f7dd41c08dcb18224a61c6c43bad67548a327ca593b73b526e3d8a

data/Gemfile

@@ -9,6 +9,7 @@ gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
 gem "rspec-retry"
 gem "webmock"
+gem "fakeredis"
 gem "timecop"
 gem 'simplecov'
 gem "simplecov-cobertura", "~> 1.4"

data/lib/sentry/configuration.rb

@@ -75,6 +75,7 @@ module Sentry
     # An array of breadcrumbs loggers to be used. Available options are:
     # - :sentry_logger
     # - :http_logger
+    # - :redis_logger
     #
     # And if you also use sentry-rails:
     # - :active_support_logger
@@ -206,6 +207,10 @@ module Sentry
     # @return [Boolean]
     attr_accessor :send_client_reports
 
+    # Track sessions in request/response cycles automatically
+    # @return [Boolean]
+    attr_accessor :auto_session_tracking
+
     # these are not config options
     # @!visibility private
     attr_reader :errors, :gem_specs
@@ -260,6 +265,7 @@ module Sentry
       self.send_default_pii = false
       self.skip_rake_integration = false
       self.send_client_reports = true
+      self.auto_session_tracking = true
       self.trusted_proxies = []
       self.dsn = ENV['SENTRY_DSN']
       self.server_name = server_name_from_env

data/lib/sentry/envelope.rb

@@ -3,24 +3,43 @@
 module Sentry
   # @api private
   class Envelope
-    def initialize(headers)
+    class Item
+      attr_accessor :headers, :payload
+
+      def initialize(headers, payload)
+        @headers = headers
+        @payload = payload
+      end
+
+      def type
+        @headers[:type] || 'event'
+      end
+
+      def to_s
+        <<~ITEM
+          #{JSON.generate(@headers)}
+          #{JSON.generate(@payload)}
+        ITEM
+      end
+    end
+
+    attr_accessor :headers, :items
+
+    def initialize(headers = {})
       @headers = headers
       @items = []
     end
 
     def add_item(headers, payload)
-      @items << [headers, payload]
+      @items << Item.new(headers, payload)
     end
 
-    def to_s
-      payload = @items.map do |item_headers, item_payload|
-        <<~ENVELOPE
-          #{JSON.generate(item_headers)}
-          #{JSON.generate(item_payload)}
-        ENVELOPE
-      end.join("\n")
+    def item_types
+      @items.map(&:type)
+    end
 
-      "#{JSON.generate(@headers)}\n#{payload}"
+    def event_id
+      @headers[:event_id]
     end
   end
 end

data/lib/sentry/event.rb

@@ -23,6 +23,7 @@ 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]
 

data/lib/sentry/hub.rb

@@ -2,6 +2,7 @@
 
 require "sentry/scope"
 require "sentry/client"
+require "sentry/session"
 
 module Sentry
   class Hub
@@ -94,6 +95,8 @@ module Sentry
     def capture_exception(exception, **options, &block)
       check_argument_type!(exception, ::Exception)
 
+      return if Sentry.exception_captured?(exception)
+
       return unless current_client
 
       options[:hint] ||= {}
@@ -102,7 +105,12 @@ module Sentry
 
       return unless event
 
-      capture_event(event, **options, &block)
+      current_scope.session&.update_from_exception(event.exception)
+
+      capture_event(event, **options, &block).tap do
+        # mark the exception as captured so we can use this information to avoid duplicated capturing
+        exception.instance_variable_set(Sentry::CAPTURED_SIGNATURE, true)
+      end
     end
 
     def capture_message(message, **options, &block)
@@ -138,7 +146,6 @@ module Sentry
 
       event = current_client.capture_event(event, scope, hint)
 
-
       if event && configuration.debug
         configuration.log_debug(event.to_json_compatible)
       end
@@ -170,6 +177,30 @@ module Sentry
       configuration.background_worker_threads = original_background_worker_threads
     end
 
+    def start_session
+      return unless current_scope
+      current_scope.set_session(Session.new)
+    end
+
+    def end_session
+      return unless current_scope
+      session = current_scope.session
+      current_scope.set_session(nil)
+
+      return unless session
+      session.close
+      Sentry.session_flusher.add_session(session)
+    end
+
+    def with_session_tracking(&block)
+      return yield unless configuration.auto_session_tracking
+
+      start_session
+      yield
+    ensure
+      end_session
+    end
+
     private
 
     def current_layer

data/lib/sentry/interfaces/exception.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "set"
 
 module Sentry
   class ExceptionInterface < Interface

data/lib/sentry/interfaces/request.rb

@@ -62,7 +62,7 @@ module Sentry
       self.url = request.scheme && request.url.split('?').first
       self.method = request.request_method
 
-      self.headers = filter_and_format_headers(env)
+      self.headers = filter_and_format_headers(env, send_default_pii)
       self.env     = filter_and_format_env(env, rack_env_whitelist)
     end
 
@@ -81,13 +81,14 @@ module Sentry
       e.message
     end
 
-    def filter_and_format_headers(env)
+    def filter_and_format_headers(env, send_default_pii)
       env.each_with_object({}) do |(key, value), memo|
         begin
           key = key.to_s # rack env can contain symbols
           next memo['X-Request-Id'] ||= Utils::RequestId.read_from(env) if Utils::RequestId::REQUEST_ID_HEADERS.include?(key)
           next if is_server_protocol?(key, value, env["SERVER_PROTOCOL"])
           next if is_skippable_header?(key)
+          next if key == "HTTP_AUTHORIZATION" && !send_default_pii
 
           # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
           key = key.sub(/^HTTP_/, "")

data/lib/sentry/net/http.rb

@@ -6,7 +6,8 @@ module Sentry
   # @api private
   module Net
     module HTTP
-      OP_NAME = "net.http"
+      OP_NAME = "http.client"
+      BREADCRUMB_CATEGORY = "net.http"
 
       # To explain how the entire thing works, we need to know how the original Net::HTTP#request works
       # Here's part of its definition. As you can see, it usually calls itself inside a #start block
@@ -53,7 +54,7 @@ module Sentry
 
         crumb = Sentry::Breadcrumb.new(
           level: :info,
-          category: OP_NAME,
+          category: BREADCRUMB_CATEGORY,
           type: :info,
           data: {
             status: res.code.to_i,

data/lib/sentry/rack/capture_exceptions.rb

@@ -14,30 +14,32 @@ module Sentry
         Sentry.clone_hub_to_current_thread
 
         Sentry.with_scope do |scope|
-          scope.clear_breadcrumbs
-          scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
-          scope.set_rack_env(env)
-
-          transaction = start_transaction(env, scope)
-          scope.set_span(transaction) if transaction
-
-          begin
-            response = @app.call(env)
-          rescue Sentry::Error
-            finish_transaction(transaction, 500)
-            raise # Don't capture Sentry errors
-          rescue Exception => e
-            capture_exception(e)
-            finish_transaction(transaction, 500)
-            raise
+          Sentry.with_session_tracking do
+            scope.clear_breadcrumbs
+            scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
+            scope.set_rack_env(env)
+
+            transaction = start_transaction(env, scope)
+            scope.set_span(transaction) if transaction
+
+            begin
+              response = @app.call(env)
+            rescue Sentry::Error
+              finish_transaction(transaction, 500)
+              raise # Don't capture Sentry errors
+            rescue Exception => e
+              capture_exception(e)
+              finish_transaction(transaction, 500)
+              raise
+            end
+
+            exception = collect_exception(env)
+            capture_exception(exception) if exception
+
+            finish_transaction(transaction, response[0])
+
+            response
           end
-
-          exception = collect_exception(env)
-          capture_exception(exception) if exception
-
-          finish_transaction(transaction, response[0])
-
-          response
         end
       end
 
@@ -59,7 +61,7 @@ module Sentry
         sentry_trace = env["HTTP_SENTRY_TRACE"]
         options = { name: scope.transaction_name, op: transaction_op }
         transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, **options) if sentry_trace
-        Sentry.start_transaction(transaction: transaction, **options)
+        Sentry.start_transaction(transaction: transaction, custom_sampling_context: { env: env }, **options)
       end
 
 

data/lib/sentry/redis.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Sentry
+  # @api private
+  class Redis
+    OP_NAME = "db.redis.command"
+    LOGGER_NAME = :redis_logger
+
+    def initialize(commands, host, port, db)
+      @commands, @host, @port, @db = commands, host, port, db
+    end
+
+    def instrument
+      return yield unless Sentry.initialized?
+
+      record_span do
+        yield.tap do
+          record_breadcrumb
+        end
+      end
+    end
+
+    private
+
+    attr_reader :commands, :host, :port, :db
+
+    def record_span
+      return yield unless (transaction = Sentry.get_current_scope.get_transaction) && transaction.sampled
+
+      sentry_span = transaction.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
+
+      yield.tap do
+        sentry_span.set_description(commands_description)
+        sentry_span.set_data(:server, server_description)
+        sentry_span.set_timestamp(Sentry.utc_now.to_f)
+      end
+    end
+
+    def record_breadcrumb
+      return unless Sentry.configuration.breadcrumbs_logger.include?(LOGGER_NAME)
+
+      Sentry.add_breadcrumb(
+        Sentry::Breadcrumb.new(
+          level: :info,
+          category: OP_NAME,
+          type: :info,
+          data: {
+            commands: parsed_commands,
+            server: server_description
+          }
+        )
+      )
+    end
+
+    def commands_description
+      parsed_commands.map do |statement|
+        statement.values.join(" ").strip
+      end.join(", ")
+    end
+
+    def parsed_commands
+      commands.map do |statement|
+        command, key, *arguments = statement
+
+        { command: command.to_s.upcase, key: key }.tap do |command_set|
+          command_set[:arguments] = arguments.join(" ") if Sentry.configuration.send_default_pii
+        end
+      end
+    end
+
+    def server_description
+      "#{host}:#{port}/#{db}"
+    end
+
+    module Client
+      def logging(commands, &block)
+        Sentry::Redis.new(commands, host, port, db).instrument do
+          super
+        end
+      end
+    end
+  end
+end
+
+if defined?(::Redis::Client)
+  Sentry.register_patch do
+    patch = Sentry::Redis::Client
+    Redis::Client.prepend(patch) unless Redis::Client.ancestors.include?(patch)
+  end
+end

data/lib/sentry/scope.rb

@@ -7,7 +7,7 @@ module Sentry
   class Scope
     include ArgumentCheckingHelper
 
-    ATTRIBUTES = [:transaction_names, :contexts, :extra, :tags, :user, :level, :breadcrumbs, :fingerprint, :event_processors, :rack_env, :span]
+    ATTRIBUTES = [:transaction_names, :contexts, :extra, :tags, :user, :level, :breadcrumbs, :fingerprint, :event_processors, :rack_env, :span, :session]
 
     attr_reader(*ATTRIBUTES)
 
@@ -76,6 +76,7 @@ module Sentry
       copy.transaction_names = transaction_names.deep_dup
       copy.fingerprint = fingerprint.deep_dup
       copy.span = span.deep_dup
+      copy.session = session.deep_dup
       copy
     end
 
@@ -173,7 +174,7 @@ module Sentry
     def set_contexts(contexts_hash)
       check_argument_type!(contexts_hash, Hash)
       @contexts.merge!(contexts_hash) do |key, old, new|
-        new.merge(old)
+        old.merge(new)
       end
     end
 
@@ -198,6 +199,13 @@ module Sentry
       @transaction_names << transaction_name
     end
 
+    # Sets the currently active session on the scope.
+    # @param session [Session, nil]
+    # @return [void]
+    def set_session(session)
+      @session = session
+    end
+
     # Returns current transaction name.
     # The "transaction" here does not refer to `Transaction` objects.
     # @return [String, nil]
@@ -251,6 +259,7 @@ module Sentry
       @event_processors = []
       @rack_env = {}
       @span = nil
+      @session = nil
       set_new_breadcrumb_buffer
     end
 

data/lib/sentry/session.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sentry
+  class Session
+    attr_reader :started, :status
+
+    # TODO-neel add :crashed after adding handled mechanism
+    STATUSES = %i(ok errored exited)
+    AGGREGATE_STATUSES = %i(errored exited)
+
+    def initialize
+      @started = Sentry.utc_now
+      @status = :ok
+    end
+
+    # TODO-neel add :crashed after adding handled mechanism
+    def update_from_exception(_exception = nil)
+      @status = :errored
+    end
+
+    def close
+      @status = :exited if @status == :ok
+    end
+
+    # truncate seconds from the timestamp since we only care about
+    # minute level granularity for aggregation
+    def aggregation_key
+      Time.utc(started.year, started.month, started.day, started.hour, started.min)
+    end
+
+    def deep_dup
+      dup
+    end
+  end
+end

data/lib/sentry/session_flusher.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Sentry
+  class SessionFlusher
+    include LoggingHelper
+
+    FLUSH_INTERVAL = 60
+
+    def initialize(configuration, client)
+      @thread = nil
+      @client = client
+      @pending_aggregates = {}
+      @release = configuration.release
+      @environment = configuration.environment
+      @logger = configuration.logger
+
+      log_debug("[Sessions] Sessions won't be captured without a valid release") unless @release
+    end
+
+    def flush
+      return if @pending_aggregates.empty?
+      envelope = pending_envelope
+
+      Sentry.background_worker.perform do
+        @client.transport.send_envelope(envelope)
+      end
+
+      @pending_aggregates = {}
+    end
+
+    def add_session(session)
+      return unless @release
+
+      ensure_thread
+
+      return unless Session::AGGREGATE_STATUSES.include?(session.status)
+      @pending_aggregates[session.aggregation_key] ||= init_aggregates(session.aggregation_key)
+      @pending_aggregates[session.aggregation_key][session.status] += 1
+    end
+
+    def kill
+      @thread&.kill
+    end
+
+    private
+
+    def init_aggregates(aggregation_key)
+      aggregates = { started: aggregation_key.iso8601 }
+      Session::AGGREGATE_STATUSES.each { |k| aggregates[k] = 0 }
+      aggregates
+    end
+
+    def pending_envelope
+      envelope = Envelope.new
+
+      header = { type: 'sessions' }
+      payload = { attrs: attrs, aggregates: @pending_aggregates.values }
+
+      envelope.add_item(header, payload)
+      envelope
+    end
+
+    def attrs
+      { release: @release, environment: @environment }
+    end
+
+    def ensure_thread
+      return if @thread&.alive?
+
+      @thread = Thread.new do
+        loop do
+          sleep(FLUSH_INTERVAL)
+          flush
+        end
+      end
+    end
+
+  end
+end

data/lib/sentry/transaction.rb

@@ -164,13 +164,12 @@ module Sentry
         @name = UNLABELD_NAME
       end
 
-      unless @sampled || @parent_sampled
+      if @sampled
+        event = hub.current_client.event_from_transaction(self)
+        hub.capture_event(event)
+      else
         hub.current_client.transport.record_lost_event(:sample_rate, 'transaction')
-        return
       end
-
-      event = hub.current_client.event_from_transaction(self)
-      hub.capture_event(event)
     end
 
     protected

data/lib/sentry/transport/dummy_transport.rb

@@ -2,15 +2,20 @@
 
 module Sentry
   class DummyTransport < Transport
-    attr_accessor :events
+    attr_accessor :events, :envelopes
 
     def initialize(*)
       super
       @events = []
+      @envelopes = []
     end
 
     def send_event(event)
       @events << event
     end
+
+    def send_envelope(envelope)
+      @envelopes << envelope
+    end
   end
 end

data/lib/sentry/transport.rb

@@ -46,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)
 
-      if is_rate_limited?(item_type)
-        log_info("Envelope [#{item_type}] not sent: rate limiting")
-        record_lost_event(:ratelimit_backoff, item_type)
+      event
+    end
+
+    def send_envelope(envelope)
+      reject_rate_limited_items(envelope)
 
-        return
+      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
 
-      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)
@@ -71,6 +102,8 @@ module Sentry
         case item_type
         when "transaction"
           @rate_limits["transaction"]
+        when "sessions"
+          @rate_limits["session"]
         else
           @rate_limits["error"]
         end
@@ -106,7 +139,7 @@ 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"]
@@ -129,9 +162,7 @@ module Sentry
       client_report_headers, client_report_payload = fetch_pending_client_report
       envelope.add_item(client_report_headers, client_report_payload) if client_report_headers
 
-      log_info("Sending envelope [#{item_type}] #{event_id} to Sentry")
-
-      envelope.to_s
+      envelope
     end
 
     def record_lost_event(reason, item_type)
@@ -173,6 +204,19 @@ module Sentry
 
       [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/version.rb

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

data/lib/sentry-ruby.rb

@@ -17,6 +17,7 @@ require "sentry/span"
 require "sentry/transaction"
 require "sentry/hub"
 require "sentry/background_worker"
+require "sentry/session_flusher"
 
 [
   "sentry/rake",
@@ -31,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
@@ -59,6 +62,10 @@ module Sentry
     #   @return [BackgroundWorker]
     attr_accessor :background_worker
 
+    # @!attribute [r] session_flusher
+    #   @return [SessionFlusher]
+    attr_reader :session_flusher
+
     ##### Patch Registration #####
 
     # @!visibility private
@@ -111,9 +118,17 @@ module Sentry
 
     # @!method configuration
     #   @!macro configuration
+    def configuration
+      return unless initialized?
+      get_current_client.configuration
+    end
+
     # @!method send_event
     #   @!macro send_event
-    def_delegators :get_current_client, :configuration, :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.
@@ -135,13 +150,31 @@ module Sentry
 
     # @!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_delegators :get_current_scope, :set_tags, :set_extras, :set_user, :set_context
+    def set_context(*args)
+      return unless initialized?
+      get_current_scope.set_context(*args)
+    end
 
     ##### Main APIs #####
 
@@ -161,11 +194,18 @@ 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
@@ -201,7 +241,8 @@ module Sentry
     #
     # @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.
@@ -221,14 +262,16 @@ module Sentry
     # 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.
@@ -250,7 +293,8 @@ module Sentry
     # @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.
@@ -274,7 +318,28 @@ module Sentry
     # @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.
@@ -282,7 +347,8 @@ module Sentry
     # @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.
@@ -290,30 +356,41 @@ module Sentry
     # @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 #####
 
@@ -344,3 +421,4 @@ end
 
 # patches
 require "sentry/net/http"
+require "sentry/redis"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby-core
 version: !ruby/object:Gem::Version
-  version: 5.0.2
+  version: 5.2.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-31 00:00:00.000000000 Z
+date: 2022-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -73,8 +73,11 @@ files:
 - lib/sentry/rack.rb
 - lib/sentry/rack/capture_exceptions.rb
 - lib/sentry/rake.rb
+- lib/sentry/redis.rb
 - lib/sentry/release_detector.rb
 - lib/sentry/scope.rb
+- lib/sentry/session.rb
+- lib/sentry/session_flusher.rb
 - lib/sentry/span.rb
 - lib/sentry/transaction.rb
 - lib/sentry/transaction_event.rb