sentry-ruby-core 5.1.1 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfc28e6f57d57de669447d555889196617f72ce09624b343cd284375021f60f5
-  data.tar.gz: 5a6af91521df30a18ac1d021b2e59cd9e871653f1325cf6d65346e6c1dc91d7e
+  metadata.gz: c6a629d8aa998cef5638cd40e3dc9e0ad24770d0c31540b327c669e9fb84aedd
+  data.tar.gz: e373b601b401fddca9307a32ea1dda36bc4994209c68b19748e89f128a598e80
 SHA512:
-  metadata.gz: fbe80e4c07f972d3babbf8c26c31cd97da84e91d77e86628a6931f35d7e66c83fb48461838d1a3e402361ee78dd9a3b6dfe849833f08a4573328d0eb4b5e66e1
-  data.tar.gz: 0f081f57f89207ece5279bd77fa89d311c3d516231421ccf60f4b9c232065a606d80eacc53ab460f12e087aa7b2fadfc4cdd4636863cb58261cc4e58a605ad2c
+  metadata.gz: 2cfd2f1fe582578b74bc23610931d95bf7a86c35c696c658d55fb4f40ddfdd129c36bae415bc73efef20ecfb435f33ba72e3b46a96f536c0c61692d8c8cb34e2
+  data.tar.gz: f10f71edc8bef7a57426de73e0cf2a1aea855c89ec2900a065986d33f064216f7da74c0cf9f7dd41c08dcb18224a61c6c43bad67548a327ca593b73b526e3d8a

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

@@ -57,8 +57,43 @@ 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
+          item.payload.delete(:breadcrumbs)
+          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 +102,8 @@ module Sentry
         case item_type
         when "transaction"
           @rate_limits["transaction"]
+        when "sessions"
+          @rate_limits["session"]
         else
           @rate_limits["error"]
         end
@@ -125,7 +162,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
 

data/lib/sentry/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sentry
-  VERSION = "5.1.1"
+  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",
@@ -61,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
@@ -189,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
@@ -310,6 +322,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]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby-core
 version: !ruby/object:Gem::Version
-  version: 5.1.1
+  version: 5.2.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-02-24 00:00:00.000000000 Z
+date: 2022-03-08 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