sentry-ruby-core 5.1.1 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfc28e6f57d57de669447d555889196617f72ce09624b343cd284375021f60f5
-  data.tar.gz: 5a6af91521df30a18ac1d021b2e59cd9e871653f1325cf6d65346e6c1dc91d7e
+  metadata.gz: 03d233c6e1bd55ddc4044c7a23b6bc74047eec17a8c16d5f33f768065641259c
+  data.tar.gz: bec07f880bff192b6ef71aaefdf9dc9ff2ff072a539f94ed5c4fd0398ad1146a
 SHA512:
-  metadata.gz: fbe80e4c07f972d3babbf8c26c31cd97da84e91d77e86628a6931f35d7e66c83fb48461838d1a3e402361ee78dd9a3b6dfe849833f08a4573328d0eb4b5e66e1
-  data.tar.gz: 0f081f57f89207ece5279bd77fa89d311c3d516231421ccf60f4b9c232065a606d80eacc53ab460f12e087aa7b2fadfc4cdd4636863cb58261cc4e58a605ad2c
+  metadata.gz: c3d90a9b888db8a396e260dccf5df3a38d4f153c9bc2b31b92fc206009553fec2d3d0fe47bb1a871b001372fcba8013fee4e16b60405588db4ce3984f56d675e
+  data.tar.gz: 2ae1db7dee78487fec06b1cb1c6fb2dfa77852ae20b0c28b6c2f0e0b964f728fdea40a8261495439ef6e193182a0f7dc3196dc1bd75368abcf2d78852310361a

data/Gemfile

@@ -1,4 +1,5 @@
 source "https://rubygems.org"
+git_source(:github) { |name| "https://github.com/#{name}.git" }
 
 gem "sentry-ruby-core", path: "./"
 gem "sentry-ruby", path: "./"

data/README.md

@@ -29,7 +29,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`.
 

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)
@@ -174,8 +176,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

@@ -207,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
@@ -261,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

@@ -34,10 +34,6 @@ module Sentry
       @items << Item.new(headers, payload)
     end
 
-    def to_s
-      [JSON.generate(@headers), *@items.map(&:to_s)].join("\n")
-    end
-
     def item_types
       @items.map(&:type)
     end

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,6 +26,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]
 
@@ -34,12 +38,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]
@@ -48,6 +46,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          = {}
@@ -70,8 +69,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
@@ -145,9 +142,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
 
@@ -156,24 +150,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

@@ -2,6 +2,7 @@
 
 require "sentry/scope"
 require "sentry/client"
+require "sentry/session"
 
 module Sentry
   class Hub
@@ -104,6 +105,8 @@ module Sentry
 
       return unless event
 
+      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)
@@ -143,12 +146,11 @@ module Sentry
 
       event = current_client.capture_event(event, scope, hint)
 
-
       if event && configuration.debug
         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
 
@@ -175,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/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

@@ -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

@@ -3,8 +3,8 @@
 module Sentry
   # @api private
   class Redis
-    OP_NAME ||= "db.redis.command"
-    LOGGER_NAME ||= :redis_logger
+    OP_NAME = "db.redis.command"
+    LOGGER_NAME = :redis_logger
 
     def initialize(commands, host, port, db)
       @commands, @host, @port, @db = commands, host, port, db
@@ -60,9 +60,11 @@ module Sentry
 
     def parsed_commands
       commands.map do |statement|
-        command, key, *_values = statement
+        command, key, *arguments = statement
 
-        { command: command.to_s.upcase, key: key }
+        { 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
 

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
 
@@ -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,80 @@
+# 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
+      log_debug("Killing session flusher")
+      @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_event.rb

@@ -1,31 +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
-    end
+    # @return [Float, nil]
+    attr_reader :start_timestamp
 
     # Sets the event's start_timestamp.
     # @param time [Time, Float]
@@ -38,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/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/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

@@ -57,8 +57,48 @@ module Sentry
 
       return if envelope.items.empty?
 
-      log_info("[Transport] Sending envelope with items [#{envelope.item_types.join(', ')}] #{envelope.event_id} to Sentry")
-      send_data(envelope.to_s)
+      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
+
+    def serialize_envelope(envelope)
+      serialized_items = []
+      serialized_results = []
+
+      envelope.items.each do |item|
+        result = item.to_s
+
+        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}}")
+
+          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)
@@ -67,6 +107,8 @@ module Sentry
         case item_type
         when "transaction"
           @rate_limits["transaction"]
+        when "sessions"
+          @rate_limits["session"]
         else
           @rate_limits["error"]
         end
@@ -106,7 +148,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(
         {
@@ -125,7 +167,6 @@ 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
 
-
       envelope
     end
 
@@ -133,16 +174,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.1.1"
+  VERSION = "5.3.0"
 end

data/lib/sentry-ruby.rb

@@ -12,11 +12,13 @@ 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"
 require "sentry/hub"
 require "sentry/background_worker"
+require "sentry/session_flusher"
 
 [
   "sentry/rake",
@@ -61,6 +63,10 @@ module Sentry
     #   @return [BackgroundWorker]
     attr_accessor :background_worker
 
+    # @!attribute [r] session_flusher
+    #   @return [SessionFlusher]
+    attr_reader :session_flusher
+
     ##### Patch Registration #####
 
     # @!visibility private
@@ -94,6 +100,14 @@ module Sentry
     # @param name [String] name of the integration
     # @param version [String] version of the integration
     def register_integration(name, version)
+      if initialized?
+        logger.warn(LOGGER_PROGNAME) do
+          <<~MSG
+            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
+
       meta = { name: "sentry.ruby.#{name}", version: version }.freeze
       integrations[name.to_s] = meta
     end
@@ -189,11 +203,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
@@ -310,6 +331,26 @@ module Sentry
       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]
@@ -344,6 +385,40 @@ 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)
+      current_span = get_current_scope.get_span
+
+      if current_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]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby-core
 version: !ruby/object:Gem::Version
-  version: 5.1.1
+  version: 5.3.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-02-24 00:00:00.000000000 Z
+date: 2022-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -56,6 +56,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
@@ -76,6 +77,8 @@ files:
 - 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