sentry-ruby 5.10.0 → 5.26.0

data/lib/sentry/session_flusher.rb

@@ -1,58 +1,38 @@
 # frozen_string_literal: true
 
 module Sentry
-  class SessionFlusher
-    include LoggingHelper
-
+  class SessionFlusher < ThreadedPeriodicWorker
     FLUSH_INTERVAL = 60
 
     def initialize(configuration, client)
-      @thread = nil
-      @exited = false
+      super(configuration.sdk_logger, FLUSH_INTERVAL)
       @client = client
       @pending_aggregates = {}
       @release = configuration.release
       @environment = configuration.environment
-      @logger = configuration.logger
+      @mutex = Mutex.new
 
       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 = {}
+      @client.capture_envelope(pending_envelope)
     end
 
+    alias_method :run, :flush
+
     def add_session(session)
-      return if @exited
       return unless @release
 
-      begin
-        ensure_thread
-      rescue ThreadError
-        log_debug("Session flusher thread creation failed")
-        @exited = true
-        return
-      end
+      return unless 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")
-
-      @exited = true
-      @thread&.kill
-    end
-
     private
 
     def init_aggregates(aggregation_key)
@@ -62,11 +42,15 @@ module Sentry
     end
 
     def pending_envelope
-      envelope = Envelope.new
-
-      header = { type: 'sessions' }
-      payload = { attrs: attrs, aggregates: @pending_aggregates.values }
+      aggregates = @mutex.synchronize do
+        aggregates = @pending_aggregates.values
+        @pending_aggregates = {}
+        aggregates
+      end
 
+      envelope = Envelope.new
+      header = { type: "sessions" }
+      payload = { attrs: attrs, aggregates: aggregates }
       envelope.add_item(header, payload)
       envelope
     end
@@ -74,17 +58,5 @@ module Sentry
     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/span.rb

@@ -1,9 +1,57 @@
 # frozen_string_literal: true
 
 require "securerandom"
+require "sentry/metrics/local_aggregator"
+require "sentry/utils/uuid"
 
 module Sentry
   class Span
+    # We will try to be consistent with OpenTelemetry on this front going forward.
+    # https://develop.sentry.dev/sdk/performance/span-data-conventions/
+    module DataConventions
+      URL = "url"
+      HTTP_STATUS_CODE = "http.response.status_code"
+      HTTP_QUERY = "http.query"
+      HTTP_METHOD = "http.request.method"
+
+      # An identifier for the database management system (DBMS) product being used.
+      # Example: postgresql
+      DB_SYSTEM = "db.system"
+
+      # The name of the database being accessed.
+      # For commands that switch the database, this should be set to the target database
+      # (even if the command fails).
+      # Example: myDatabase
+      DB_NAME = "db.name"
+
+      # Name of the database host.
+      # Example: example.com
+      SERVER_ADDRESS = "server.address"
+
+      # Logical server port number
+      # Example: 80; 8080; 443
+      SERVER_PORT = "server.port"
+
+      # Physical server IP address or Unix socket address.
+      # Example: 10.5.3.2
+      SERVER_SOCKET_ADDRESS = "server.socket.address"
+
+      # Physical server port.
+      # Recommended: If different than server.port.
+      # Example: 16456
+      SERVER_SOCKET_PORT = "server.socket.port"
+
+      FILEPATH = "code.filepath"
+      LINENO = "code.lineno"
+      FUNCTION = "code.function"
+      NAMESPACE = "code.namespace"
+
+      MESSAGING_MESSAGE_ID = "messaging.message.id"
+      MESSAGING_DESTINATION_NAME = "messaging.destination.name"
+      MESSAGING_MESSAGE_RECEIVE_LATENCY = "messaging.message.receive.latency"
+      MESSAGING_MESSAGE_RETRY_COUNT = "messaging.message.retry.count"
+    end
+
     STATUS_MAP = {
       400 => "invalid_argument",
       401 => "unauthenticated",
@@ -18,6 +66,8 @@ module Sentry
       504 => "deadline_exceeded"
     }
 
+    DEFAULT_SPAN_ORIGIN = "manual"
+
     # An uuid that can be used to identify a trace.
     # @return [String]
     attr_reader :trace_id
@@ -51,6 +101,9 @@ module Sentry
     # Span data
     # @return [Hash]
     attr_reader :data
+    # Span origin that tracks what kind of instrumentation created a span
+    # @return [String]
+    attr_reader :origin
 
     # The SpanRecorder the current span belongs to.
     # SpanRecorder holds all spans under the same Transaction object (including the Transaction itself).
@@ -72,10 +125,11 @@ module Sentry
       parent_span_id: nil,
       sampled: nil,
       start_timestamp: nil,
-      timestamp: nil
+      timestamp: nil,
+      origin: nil
     )
-      @trace_id = trace_id || SecureRandom.uuid.delete("-")
-      @span_id = span_id || SecureRandom.hex(8)
+      @trace_id = trace_id || Utils.uuid
+      @span_id = span_id || Utils.uuid.slice(0, 16)
       @parent_span_id = parent_span_id
       @sampled = sampled
       @start_timestamp = start_timestamp || Sentry.utc_now.to_f
@@ -86,6 +140,7 @@ module Sentry
       @status = status
       @data = {}
       @tags = {}
+      @origin = origin || DEFAULT_SPAN_ORIGIN
     end
 
     # Finishes the span by adding a timestamp.
@@ -111,9 +166,15 @@ module Sentry
       transaction.get_baggage&.serialize
     end
 
+    # Returns the Dynamic Sampling Context from the transaction baggage.
+    # @return [Hash, nil]
+    def get_dynamic_sampling_context
+      transaction.get_baggage&.dynamic_sampling_context
+    end
+
     # @return [Hash]
     def to_hash
-      {
+      hash = {
         trace_id: @trace_id,
         span_id: @span_id,
         parent_span_id: @parent_span_id,
@@ -123,8 +184,14 @@ module Sentry
         op: @op,
         status: @status,
         tags: @tags,
-        data: @data
+        data: @data,
+        origin: @origin
       }
+
+      summary = metrics_summary
+      hash[:_metrics_summary] = summary if summary
+
+      hash
     end
 
     # Returns the span's context that can be used to embed in an Event.
@@ -136,7 +203,9 @@ module Sentry
         parent_span_id: @parent_span_id,
         description: @description,
         op: @op,
-        status: @status
+        status: @status,
+        origin: @origin,
+        data: @data
       }
     end
 
@@ -193,7 +262,7 @@ module Sentry
 
 
     # Sets the span's status.
-    # @param satus [String] status of the span.
+    # @param status [String] status of the span.
     def set_status(status)
       @status = status
     end
@@ -208,7 +277,7 @@ module Sentry
     # @param status_code [String] example: "500".
     def set_http_status(status_code)
       status_code = status_code.to_i
-      set_data("status_code", status_code)
+      set_data(DataConventions::HTTP_STATUS_CODE, status_code)
 
       status =
         if status_code >= 200 && status_code < 299
@@ -232,5 +301,20 @@ module Sentry
     def set_tag(key, value)
       @tags[key] = value
     end
+
+    # Sets the origin of the span.
+    # @param origin [String]
+    def set_origin(origin)
+      @origin = origin
+    end
+
+    # Collects gauge metrics on the span for metric summaries.
+    def metrics_local_aggregator
+      @metrics_local_aggregator ||= Sentry::Metrics::LocalAggregator.new
+    end
+
+    def metrics_summary
+      @metrics_local_aggregator&.to_hash
+    end
   end
 end

data/lib/sentry/std_lib_logger.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Sentry
+  # Ruby Logger support Add commentMore actions
+  # intercepts any logger instance and send the log to Sentry too.
+  module StdLibLogger
+    SEVERITY_MAP = {
+      0 => :debug,
+      1 => :info,
+      2 => :warn,
+      3 => :error,
+      4 => :fatal
+    }.freeze
+
+    def add(severity, message = nil, progname = nil, &block)
+      result = super
+
+      return unless Sentry.initialized? && Sentry.get_current_hub
+
+      # exclude sentry SDK logs -- to prevent recursive log action,
+      # do not process internal logs again
+      if message.nil? && progname != Sentry::Logger::PROGNAME
+
+        # handle different nature of Ruby Logger class:
+        # inspo from Sentry::Breadcrumb::SentryLogger
+        if block_given?
+          message = yield
+        else
+          message = progname
+        end
+
+        message = message.to_s.strip
+
+        if !message.nil? && message != Sentry::Logger::PROGNAME && method = SEVERITY_MAP[severity]
+          Sentry.logger.send(method, message)
+        end
+      end
+
+      result
+    end
+  end
+end
+
+Sentry.register_patch(:logger) do |config|
+  if config.enable_logs
+    ::Logger.prepend(Sentry::StdLibLogger)
+  else
+    config.sdk_logger.warn(":logger patch enabled but `enable_logs` is turned off - skipping applying patch")
+  end
+end

data/lib/sentry/structured_logger.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Sentry
+  # The StructuredLogger class implements Sentry's SDK telemetry logs protocol.
+  # It provides methods for logging messages at different severity levels and
+  # sending them to Sentry with structured data.
+  #
+  # This class follows the Sentry Logs Protocol as defined in:
+  # https://develop.sentry.dev/sdk/telemetry/logs/
+  #
+  # @example Basic usage
+  #   Sentry.logger.info("User logged in", user_id: 123)
+  #
+  # @example With structured data
+  #   Sentry.logger.warn("API request failed",
+  #     status_code: 404,
+  #     endpoint: "/api/users",
+  #     request_id: "abc-123"
+  #   )
+  #
+  # @example With a message template
+  #   # Using positional parameters
+  #   Sentry.logger.info("User %s logged in", ["Jane Doe"])
+  #
+  #   # Using hash parameters
+  #   Sentry.logger.info("User %{name} logged in", name: "Jane Doe")
+  #
+  #   # Using hash parameters and extra attributes
+  #   Sentry.logger.info("User %{name} logged in", name: "Jane Doe", user_id: 312)
+  #
+  # @see https://develop.sentry.dev/sdk/telemetry/logs/ Sentry SDK Telemetry Logs Protocol
+  class StructuredLogger
+    # Severity number mapping for log levels according to the Sentry Logs Protocol
+    # @see https://develop.sentry.dev/sdk/telemetry/logs/#log-severity-number
+    LEVELS = {
+      trace: 1,
+      debug: 5,
+      info: 9,
+      warn: 13,
+      error: 17,
+      fatal: 21
+    }.freeze
+
+    # @return [Configuration] The Sentry configuration
+    # @!visibility private
+    attr_reader :config
+
+    # Initializes a new StructuredLogger instance
+    #
+    # @param config [Configuration] The Sentry configuration
+    def initialize(config)
+      @config = config
+    end
+
+    # Logs a message at TRACE level
+    #
+    # @param message [String] The log message
+    # @param parameters [Array] Array of values to replace template parameters in the message
+    # @param attributes [Hash] Additional attributes to include with the log
+    #
+    # @return [LogEvent, nil] The created log event or nil if logging is disabled
+    def trace(message, parameters = [], **attributes)
+      log(__method__, message, parameters: parameters, **attributes)
+    end
+
+    # Logs a message at DEBUG level
+    #
+    # @param message [String] The log message
+    # @param parameters [Array] Array of values to replace template parameters in the message
+    # @param attributes [Hash] Additional attributes to include with the log
+    #
+    # @return [LogEvent, nil] The created log event or nil if logging is disabled
+    def debug(message, parameters = [], **attributes)
+      log(__method__, message, parameters: parameters, **attributes)
+    end
+
+    # Logs a message at INFO level
+    #
+    # @param message [String] The log message
+    # @param parameters [Array] Array of values to replace template parameters in the message
+    # @param attributes [Hash] Additional attributes to include with the log
+    #
+    # @return [LogEvent, nil] The created log event or nil if logging is disabled
+    def info(message, parameters = [], **attributes)
+      log(__method__, message, parameters: parameters, **attributes)
+    end
+
+    # Logs a message at WARN level
+    #
+    # @param message [String] The log message
+    # @param parameters [Array] Array of values to replace template parameters in the message
+    # @param attributes [Hash] Additional attributes to include with the log
+    #
+    # @return [LogEvent, nil] The created log event or nil if logging is disabled
+    def warn(message, parameters = [], **attributes)
+      log(__method__, message, parameters: parameters, **attributes)
+    end
+
+    # Logs a message at ERROR level
+    #
+    # @param message [String] The log message
+    # @param parameters [Array] Array of values to replace template parameters in the message
+    # @param attributes [Hash] Additional attributes to include with the log
+    #
+    # @return [LogEvent, nil] The created log event or nil if logging is disabled
+    def error(message, parameters = [], **attributes)
+      log(__method__, message, parameters: parameters, **attributes)
+    end
+
+    # Logs a message at FATAL level
+    #
+    # @param message [String] The log message
+    # @param parameters [Array] Array of values to replace template parameters in the message
+    # @param attributes [Hash] Additional attributes to include with the log
+    #
+    # @return [LogEvent, nil] The created log event or nil if logging is disabled
+    def fatal(message, parameters = [], **attributes)
+      log(__method__, message, parameters: parameters, **attributes)
+    end
+
+    # Logs a message at the specified level
+    #
+    # @param level [Symbol] The log level (:trace, :debug, :info, :warn, :error, :fatal)
+    # @param message [String] The log message
+    # @param parameters [Array, Hash] Array or Hash of values to replace template parameters in the message
+    # @param attributes [Hash] Additional attributes to include with the log
+    #
+    # @return [LogEvent, nil] The created log event or nil if logging is disabled
+    def log(level, message, parameters:, **attributes)
+      case parameters
+      when Array then
+        Sentry.capture_log(message, level: level, severity: LEVELS[level], parameters: parameters, **attributes)
+      else
+        Sentry.capture_log(message, level: level, severity: LEVELS[level], **parameters)
+      end
+    end
+  end
+end

data/lib/sentry/test_helper.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Sentry
   module TestHelper
-    DUMMY_DSN = 'http://12345:67890@sentry.localdomain/sentry/42'
+    DUMMY_DSN = "http://12345:67890@sentry.localdomain/sentry/42"
 
     # Alters the existing SDK configuration with test-suitable options. Mainly:
     # - Sets a dummy DSN instead of `nil` or an actual DSN.
@@ -14,24 +16,28 @@ module Sentry
     # @return [void]
     def setup_sentry_test(&block)
       raise "please make sure the SDK is initialized for testing" unless Sentry.initialized?
-      copied_config = Sentry.configuration.dup
+      dummy_config = Sentry.configuration.dup
       # configure dummy DSN, so the events will not be sent to the actual service
-      copied_config.dsn = DUMMY_DSN
+      dummy_config.dsn = DUMMY_DSN
       # set transport to DummyTransport, so we can easily intercept the captured events
-      copied_config.transport.transport_class = Sentry::DummyTransport
+      dummy_config.transport.transport_class = Sentry::DummyTransport
       # make sure SDK allows sending under the current environment
-      copied_config.enabled_environments << copied_config.environment unless copied_config.enabled_environments.include?(copied_config.environment)
+      dummy_config.enabled_environments += [dummy_config.environment] unless dummy_config.enabled_environments.include?(dummy_config.environment)
       # disble async event sending
-      copied_config.background_worker_threads = 0
+      dummy_config.background_worker_threads = 0
 
       # user can overwrite some of the configs, with a few exceptions like:
       # - include_local_variables
       # - auto_session_tracking
-      block&.call(copied_config)
+      block&.call(dummy_config)
 
-      test_client = Sentry::Client.new(copied_config)
+      # the base layer's client should already use the dummy config so nothing will be sent by accident
+      base_client = Sentry::Client.new(dummy_config)
+      Sentry.get_current_hub.bind_client(base_client)
+      # create a new layer so mutations made to the testing scope or configuration could be simply popped later
+      Sentry.get_current_hub.push_scope
+      test_client = Sentry::Client.new(dummy_config.dup)
       Sentry.get_current_hub.bind_client(test_client)
-      Sentry.get_current_scope.clear
     end
 
     # Clears all stored events and envelopes.
@@ -40,9 +46,13 @@ module Sentry
     def teardown_sentry_test
       return unless Sentry.initialized?
 
-      sentry_transport.events = []
-      sentry_transport.envelopes = []
-      Sentry.get_current_scope.clear
+      # pop testing layer created by `setup_sentry_test`
+      # but keep the base layer to avoid nil-pointer errors
+      # TODO: find a way to notify users if they somehow popped the test layer before calling this method
+      if Sentry.get_current_hub.instance_variable_get(:@stack).size > 1
+        Sentry.get_current_hub.pop_scope
+      end
+      Sentry::Scope.global_event_processors.clear
     end
 
     # @return [Transport]
@@ -62,6 +72,13 @@ module Sentry
       sentry_transport.envelopes
     end
 
+    def sentry_logs
+      sentry_envelopes
+        .flat_map(&:items)
+        .select { |item| item.headers[:type] == "log" }
+        .flat_map { |item| item.payload[:items] }
+    end
+
     # Returns the last captured event object.
     # @return [Event, nil]
     def last_sentry_event
@@ -73,6 +90,18 @@ module Sentry
     def extract_sentry_exceptions(event)
       event&.exception&.values || []
     end
+
+    def reset_sentry_globals!
+      Sentry::MUTEX.synchronize do
+        # Don't check initialized? because sometimes we stub it in tests
+        if Sentry.instance_variable_defined?(:@main_hub)
+          Sentry::GLOBALS.each do |var|
+            Sentry.instance_variable_set(:"@#{var}", nil)
+          end
+
+          Thread.current.thread_variable_set(Sentry::THREAD_LOCAL, nil)
+        end
+      end
+    end
   end
 end
-

data/lib/sentry/threaded_periodic_worker.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Sentry
+  class ThreadedPeriodicWorker
+    include LoggingHelper
+
+    def initialize(sdk_logger, interval)
+      @thread = nil
+      @exited = false
+      @interval = interval
+      @sdk_logger = sdk_logger
+    end
+
+    def ensure_thread
+      return false if @exited
+      return true if @thread&.alive?
+
+      @thread = Thread.new do
+        loop do
+          sleep(@interval)
+          run
+        end
+      end
+
+      true
+    rescue ThreadError
+      log_debug("[#{self.class.name}] thread creation failed")
+      @exited = true
+      false
+    end
+
+    def kill
+      log_debug("[#{self.class.name}] thread killed")
+
+      @exited = true
+      @thread&.kill
+    end
+  end
+end