sentry-ruby-core 5.1.0 → 5.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8b9d0c43497ccc151613d208b6e9a51489586a41cbb7849cbcfcd3e5795765f
-  data.tar.gz: 79e7e9f621b2fe8bfc1c1dc292a16392e499925c13bdc1c31c3f8e05240f42e0
+  metadata.gz: 896f183ea604d1e6857591eff87175f8bb8a83dd1e40fc3e80982a71dd3abe0e
+  data.tar.gz: ffc931b4d436be3c5b1858260a5e2a0508d75455c23d0971bd0f1d2a02f0e178
 SHA512:
-  metadata.gz: 3def5710a658f0365dbe11292f548aafcaf6d467d04abd5e0973035c5c3243307d49347b829ae0aa93d459c2bf4036813ec2a4589471c8da21d438318144c0aa
-  data.tar.gz: 99eab89037a4e468c7bb257d33aaf85ec8830102aa233a9af4c5091c92d67726f4ffab47b3eeedba07f079b4b3600145458e9283274532b534824acd21236617
+  metadata.gz: 467c2493df9a8ba98148b1d467d313bfc23defd9b34a9355242b01ed7ac4f092932b19607ad79e16883f83ba9b1fa53b736872f920f4fb0590761fcdbfc12a25
+  data.tar.gz: 074c4ac8eff86f456646ceef087433abf38a81ad1e8a3d0cec465caddf5a4e96459ed9c641854f7dba37ac9e851fde8f7e09798f35420f4d12586b89039282d4

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

@@ -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,9 +105,11 @@ 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, true)
+        exception.instance_variable_set(Sentry::CAPTURED_SIGNATURE, true)
       end
     end
 
@@ -141,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
@@ -173,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/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
 
@@ -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_event.rb

@@ -25,6 +25,7 @@ module Sentry
     def initialize(configuration:, integration_meta: nil, message: nil)
       super
       @type = TYPE
+      self.level = nil
     end
 
     # Sets the event's start_timestamp.

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,59 @@ 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
+          if item.payload.key?(:breadcrumbs)
+            item.payload.delete(:breadcrumbs)
+          elsif item.payload.key?("breadcrumbs")
+            item.payload.delete("breadcrumbs")
+          end
 
-      event
+          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)
@@ -71,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 +144,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 +167,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 +209,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.1.0"
+  VERSION = "5.2.1"
 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
@@ -92,6 +99,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 expected 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
@@ -187,11 +202,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
@@ -308,6 +330,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]
@@ -350,6 +392,13 @@ module Sentry
       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 #####
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby-core
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.2.1
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-02-10 00:00:00.000000000 Z
+date: 2022-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -76,6 +76,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