sentry-ruby-core 5.22.4 → 5.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85e7e5a5ad9a1f396ef7a106926f203df35a53b7b317f41a3b345dca0c98e9ef
-  data.tar.gz: 7963e284f23ac79656f94eccbed48840be1746927bcae3ae18a66c60aea923c5
+  metadata.gz: ea57af962e29f8ae1d85f7a1cdc2106f1865e8afcdce4a2fd24b653c67ac10f5
+  data.tar.gz: c086418c80e60b60d1e099701fdb6b9ae1a9136bd464213dd9ff9cc17c582b75
 SHA512:
-  metadata.gz: bcc6489dc377e0880ab1d668b01902ad03505a0eebc8331a0e5d3ce03bc86068b6ed684e84db9810ce677baefe339597b90317814f21babd423af8b8b52ab1a7
-  data.tar.gz: 1711020af1887f806b3cc01a9e1d2540b616e5f3e5d77da85cb252e85ae90af9062de51eb9e552a434595345d0978a10b6002cd2944e0baaf4414275e58fd399
+  metadata.gz: 5b9d195dc52ed15d1da607ecdc532f0bf87036a3e3670753d4694919b402d38dd9200319406714d91575186287cd40abfa857408a432867cf734f6c32b6c3749
+  data.tar.gz: 86ad04ab139eb703950d206a1a2a029f42da4fdf43896a342fa961ec8f7cd607de27270b49ec4ba7a635e2d34018387990e1a56d26287af39bf2708aee004a23

data/Gemfile

@@ -3,6 +3,8 @@
 source "https://rubygems.org"
 git_source(:github) { |name| "https://github.com/#{name}.git" }
 
+eval_gemfile "../Gemfile"
+
 gem "sentry-ruby", path: "./"
 
 rack_version = ENV["RACK_VERSION"]
@@ -27,9 +29,8 @@ gem "benchmark_driver"
 gem "benchmark-ipsa"
 gem "benchmark-memory"
 
-gem "yard", github: "lsegal/yard"
+gem "yard"
 gem "webrick"
 gem "faraday"
 gem "excon"
-
-eval_gemfile File.expand_path("../Gemfile", __dir__)
+gem "webmock"

data/lib/sentry/background_worker.rb

@@ -9,8 +9,7 @@ module Sentry
     include LoggingHelper
 
     attr_reader :max_queue, :number_of_threads
-    # @deprecated Use Sentry.logger to retrieve the current logger instead.
-    attr_reader :logger
+
     attr_accessor :shutdown_timeout
 
     DEFAULT_MAX_QUEUE = 30
@@ -19,7 +18,7 @@ module Sentry
       @shutdown_timeout = 1
       @number_of_threads = configuration.background_worker_threads
       @max_queue = configuration.background_worker_max_queue
-      @logger = configuration.logger
+      @sdk_logger = configuration.sdk_logger
       @debug = configuration.debug
       @shutdown_callback = nil
 

data/lib/sentry/backpressure_monitor.rb

@@ -6,7 +6,7 @@ module Sentry
     MAX_DOWNSAMPLE_FACTOR = 10
 
     def initialize(configuration, client, interval: DEFAULT_INTERVAL)
-      super(configuration.logger, interval)
+      super(configuration.sdk_logger, interval)
       @client = client
 
       @healthy = true

data/lib/sentry/backtrace.rb

@@ -16,7 +16,7 @@ module Sentry
       /x
 
       # org.jruby.runtime.callsite.CachingCallSite.call(CachingCallSite.java:170)
-      JAVA_INPUT_FORMAT = /^(.+)\.([^\.]+)\(([^\:]+)\:(\d+)\)$/
+      JAVA_INPUT_FORMAT = /^([\w$.]+)\.([\w$]+)\(([\w$.]+):(\d+)\)$/
 
       # The file portion of the line (such as app/models/user.rb)
       attr_reader :file

data/lib/sentry/breadcrumb.rb

@@ -2,6 +2,7 @@
 
 module Sentry
   class Breadcrumb
+    MAX_NESTING = 10
     DATA_SERIALIZATION_ERROR_MESSAGE = "[data were removed due to serialization issues]"
 
     # @return [String, nil]
@@ -47,7 +48,7 @@ module Sentry
     # @param message [String]
     # @return [void]
     def message=(message)
-      @message = (message || "").byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES)
+      @message = message && Utils::EncodingHelper.valid_utf_8?(message) ? message.byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES) : ""
     end
 
     # @param level [String]
@@ -60,16 +61,16 @@ module Sentry
 
     def serialized_data
       begin
-        ::JSON.parse(::JSON.generate(@data))
+        ::JSON.parse(::JSON.generate(@data, max_nesting: MAX_NESTING))
       rescue Exception => e
-        Sentry.logger.debug(LOGGER_PROGNAME) do
+        Sentry.sdk_logger.debug(LOGGER_PROGNAME) do
           <<~MSG
 can't serialize breadcrumb data because of error: #{e}
 data: #{@data}
           MSG
         end
 
-        DATA_SERIALIZATION_ERROR_MESSAGE
+        { error: DATA_SERIALIZATION_ERROR_MESSAGE }
       end
     end
   end

data/lib/sentry/check_in_event.rb

@@ -2,6 +2,7 @@
 
 require "securerandom"
 require "sentry/cron/monitor_config"
+require "sentry/utils/uuid"
 
 module Sentry
   class CheckInEvent < Event
@@ -43,7 +44,7 @@ module Sentry
       self.status = status
       self.duration = duration
       self.monitor_config = monitor_config
-      self.check_in_id = check_in_id || SecureRandom.uuid.delete("-")
+      self.check_in_id = check_in_id || Utils.uuid
     end
 
     # @return [Hash]

data/lib/sentry/client.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "sentry/transport"
+require "sentry/log_event"
+require "sentry/log_event_buffer"
 
 module Sentry
   class Client
@@ -14,16 +16,16 @@ module Sentry
     # @return [SpotlightTransport, nil]
     attr_reader :spotlight_transport
 
+    # @!visibility private
+    attr_reader :log_event_buffer
+
     # @!macro configuration
     attr_reader :configuration
 
-    # @deprecated Use Sentry.logger to retrieve the current logger instead.
-    attr_reader :logger
-
     # @param configuration [Configuration]
     def initialize(configuration)
       @configuration = configuration
-      @logger = configuration.logger
+      @sdk_logger = configuration.sdk_logger
 
       if transport_class = configuration.transport.transport_class
         @transport = transport_class.new(configuration)
@@ -38,6 +40,8 @@ module Sentry
       end
 
       @spotlight_transport = SpotlightTransport.new(configuration) if configuration.spotlight
+
+      @log_event_buffer = LogEventBuffer.new(configuration, self).start
     end
 
     # Applies the given scope's data to the event and sends it to Sentry.
@@ -88,6 +92,15 @@ module Sentry
       nil
     end
 
+    # Buffer a log event to be sent later with other logs in a single envelope
+    # @param event [LogEvent] the log event to be buffered
+    # @return [LogEvent]
+    def buffer_log_event(event, scope)
+      return unless event.is_a?(LogEvent)
+      @log_event_buffer.add_event(scope.apply_to_event(event))
+      event
+    end
+
     # Capture an envelope directly.
     # @param envelope [Envelope] the envelope to be captured.
     # @return [void]
@@ -100,6 +113,7 @@ module Sentry
     def flush
       transport.flush if configuration.sending_to_dsn_allowed?
       spotlight_transport.flush if spotlight_transport
+      @log_event_buffer.flush
     end
 
     # Initializes an Event object with the given exception. Returns `nil` if the exception's class is excluded from reporting.
@@ -167,6 +181,27 @@ module Sentry
       )
     end
 
+    # Initializes a LogEvent object with the given message and options
+    #
+    # @param message [String] the log message
+    # @param level [Symbol] the log level (:trace, :debug, :info, :warn, :error, :fatal)
+    # @param options [Hash] additional options
+    # @option options [Array] :parameters Array of values to replace template tokens in the message
+    #
+    # @return [LogEvent] the created log event
+    def event_from_log(message, level:, **options)
+      return unless configuration.sending_allowed?
+
+      attributes = options.reject { |k, _| k == :level || k == :severity }
+
+      LogEvent.new(
+        level: level,
+        body: message,
+        timestamp: Time.now.to_f,
+        attributes: attributes
+      )
+    end
+
     # Initializes an Event object with the given Transaction object.
     # @param transaction [Transaction] the transaction to be recorded.
     # @return [TransactionEvent]

data/lib/sentry/configuration.rb

@@ -12,6 +12,8 @@ require "sentry/cron/configuration"
 require "sentry/metrics/configuration"
 require "sentry/linecache"
 require "sentry/interfaces/stacktrace_builder"
+require "sentry/logger"
+require "sentry/log_event_buffer"
 
 module Sentry
   class Configuration
@@ -183,7 +185,19 @@ module Sentry
     # Logger used by Sentry. In Rails, this is the Rails logger, otherwise
     # Sentry provides its own Sentry::Logger.
     # @return [Logger]
-    attr_accessor :logger
+    attr_accessor :sdk_logger
+
+    # @deprecated Use {#sdk_logger=} instead.
+    def logger=(logger)
+      warn "[sentry] `config.logger=` is deprecated. Please use `config.sdk_logger=` instead."
+      self.sdk_logger = logger
+    end
+
+    # @deprecated Use {#sdk_logger} instead.
+    def logger
+      warn "[sentry] `config.logger` is deprecated. Please use `config.sdk_logger` instead."
+      self.sdk_logger
+    end
 
     # Project directory root for in_app detection. Could be Rails root, etc.
     # Set automatically for Rails.
@@ -262,8 +276,13 @@ module Sentry
     # @return [Proc]
     attr_accessor :traces_sampler
 
+    # Enable Structured Logging
+    # @return [Boolean]
+    attr_accessor :enable_logs
+
     # Easier way to use performance tracing
     # If set to true, will set traces_sample_rate to 1.0
+    # @deprecated It will be removed in the next major release.
     # @return [Boolean, nil]
     attr_reader :enable_tracing
 
@@ -306,6 +325,10 @@ module Sentry
     # @return [Array<Symbol>]
     attr_accessor :enabled_patches
 
+    # Maximum number of log events to buffer before sending
+    # @return [Integer]
+    attr_accessor :max_log_events
+
     # these are not config options
     # @!visibility private
     attr_reader :errors, :gem_specs
@@ -418,7 +441,7 @@ module Sentry
       self.excluded_exceptions = IGNORE_DEFAULT + PUMA_IGNORE_DEFAULT
       self.inspect_exception_causes_for_exclusion = true
       self.linecache = ::Sentry::LineCache.new
-      self.logger = ::Sentry::Logger.new(STDOUT)
+      self.sdk_logger = ::Sentry::Logger.new(STDOUT)
       self.project_root = Dir.pwd
       self.propagate_traces = true
 
@@ -445,6 +468,7 @@ module Sentry
       self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT
       self.traces_sampler = nil
       self.enable_tracing = nil
+      self.enable_logs = false
 
       self.profiler_class = Sentry::Profiler
 
@@ -454,6 +478,8 @@ module Sentry
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
 
       run_post_initialization_callbacks
+
+      self.max_log_events = LogEventBuffer::DEFAULT_MAX_EVENTS
     end
 
     def validate
@@ -542,6 +568,12 @@ module Sentry
     end
 
     def enable_tracing=(enable_tracing)
+      unless enable_tracing.nil?
+        log_warn <<~MSG
+          `enable_tracing` is now deprecated in favor of `traces_sample_rate = 1.0`.
+        MSG
+      end
+
       @enable_tracing = enable_tracing
       @traces_sample_rate ||= 1.0 if enable_tracing
     end

data/lib/sentry/envelope/item.rb

@@ -15,7 +15,7 @@ module Sentry
     # rate limits and client reports use the data_category rather than envelope item type
     def self.data_category(type)
       case type
-      when "session", "attachment", "transaction", "profile", "span" then type
+      when "session", "attachment", "transaction", "profile", "span", "log" then type
       when "sessions" then "session"
       when "check_in" then "monitor"
       when "statsd", "metric_meta" then "metric_bucket"

data/lib/sentry/event.rb

@@ -7,6 +7,7 @@ require "sentry/backtrace"
 require "sentry/utils/real_ip"
 require "sentry/utils/request_id"
 require "sentry/utils/custom_inspection"
+require "sentry/utils/uuid"
 
 module Sentry
   # This is an abstract class that defines the shared attributes of an event.
@@ -50,7 +51,7 @@ module Sentry
     # @param message [String, nil]
     def initialize(configuration:, integration_meta: nil, message: nil)
       # Set some simple default values
-      @event_id      = SecureRandom.uuid.delete("-")
+      @event_id      = Utils.uuid
       @timestamp     = Sentry.utc_now.iso8601
       @platform      = :ruby
       @type          = self.class::TYPE

data/lib/sentry/hub.rb

@@ -8,12 +8,42 @@ module Sentry
   class Hub
     include ArgumentCheckingHelper
 
+    MUTEX = Mutex.new
+
     attr_reader :last_event_id
 
+    attr_reader :current_profiler
+
     def initialize(client, scope)
       first_layer = Layer.new(client, scope)
       @stack = [first_layer]
       @last_event_id = nil
+      @current_profiler = {}
+    end
+
+    # This is an internal private method
+    # @api private
+    def start_profiler!(transaction)
+      MUTEX.synchronize do
+        transaction.start_profiler!
+        @current_profiler[transaction.__id__] = transaction.profiler
+      end
+    end
+
+    # This is an internal private method
+    # @api private
+    def stop_profiler!(transaction)
+      MUTEX.synchronize do
+        @current_profiler.delete(transaction.__id__)&.stop
+      end
+    end
+
+    # This is an internal private method
+    # @api private
+    def profiler_running?
+      MUTEX.synchronize do
+        !@current_profiler.empty?
+      end
     end
 
     def new_from_top
@@ -96,7 +126,7 @@ module Sentry
       sampling_context.merge!(custom_sampling_context)
       transaction.set_initial_sample_decision(sampling_context: sampling_context)
 
-      transaction.start_profiler!
+      start_profiler!(transaction)
 
       transaction
     end
@@ -186,6 +216,16 @@ module Sentry
       event.check_in_id
     end
 
+    def capture_log_event(message, **options)
+      return unless current_client
+
+      event = current_client.event_from_log(message, **options)
+
+      return unless event
+
+      current_client.buffer_log_event(event, current_scope)
+    end
+
     def capture_event(event, **options, &block)
       check_argument_type!(event, Sentry::Event)
 

data/lib/sentry/interfaces/request.rb

@@ -99,7 +99,7 @@ module Sentry
           # Rails adds objects to the Rack env that can sometimes raise exceptions
           # when `to_s` is called.
           # See: https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/middleware/remote_ip.rb#L134
-          Sentry.logger.warn(LOGGER_PROGNAME) { "Error raised while formatting headers: #{e.message}" }
+          Sentry.sdk_logger.warn(LOGGER_PROGNAME) { "Error raised while formatting headers: #{e.message}" }
           next
         end
       end

data/lib/sentry/linecache.rb

@@ -29,9 +29,9 @@ module Sentry
 
     def getlines(path)
       @cache[path] ||= begin
-        IO.readlines(path)
-                       rescue
-                         nil
+        File.open(path, "r", &:readlines)
+      rescue
+        nil
       end
     end
 

data/lib/sentry/log_event.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Sentry
+  # Event type that represents a log entry with its attributes
+  #
+  # @see https://develop.sentry.dev/sdk/telemetry/logs/#log-envelope-item-payload
+  class LogEvent < Event
+    TYPE = "log"
+
+    DEFAULT_PARAMETERS = [].freeze
+    DEFAULT_ATTRIBUTES = {}.freeze
+    DEFAULT_CONTEXT = {}.freeze
+
+    SERIALIZEABLE_ATTRIBUTES = %i[
+      level
+      body
+      timestamp
+      trace_id
+      attributes
+    ]
+
+    SENTRY_ATTRIBUTES = {
+      "sentry.trace.parent_span_id" => :parent_span_id,
+      "sentry.environment" => :environment,
+      "sentry.release" => :release,
+      "sentry.address" => :server_name,
+      "sentry.sdk.name" => :sdk_name,
+      "sentry.sdk.version" => :sdk_version,
+      "sentry.message.template" => :template
+    }
+
+    LEVELS = %i[trace debug info warn error fatal].freeze
+
+    attr_accessor :level, :body, :template, :attributes
+
+    def initialize(configuration: Sentry.configuration, **options)
+      super(configuration: configuration)
+
+      @type = TYPE
+      @level = options.fetch(:level)
+      @body = options[:body]
+      @template = @body if is_template?
+      @attributes = options[:attributes] || DEFAULT_ATTRIBUTES
+      @contexts = DEFAULT_CONTEXT
+    end
+
+    def to_hash
+      SERIALIZEABLE_ATTRIBUTES.each_with_object({}) do |name, memo|
+        memo[name] = serialize(name)
+      end
+    end
+
+    private
+
+    def serialize(name)
+      serializer = :"serialize_#{name}"
+
+      if respond_to?(serializer, true)
+        __send__(serializer)
+      else
+        public_send(name)
+      end
+    end
+
+    def serialize_level
+      level.to_s
+    end
+
+    def serialize_sdk_name
+      Sentry.sdk_meta["name"]
+    end
+
+    def serialize_sdk_version
+      Sentry.sdk_meta["version"]
+    end
+
+    def serialize_timestamp
+      Time.parse(timestamp).to_f
+    end
+
+    def serialize_trace_id
+      contexts.dig(:trace, :trace_id)
+    end
+
+    def serialize_parent_span_id
+      contexts.dig(:trace, :parent_span_id)
+    end
+
+    def serialize_body
+      if parameters.empty?
+        body
+      elsif parameters.is_a?(Hash)
+        body % parameters
+      else
+        sprintf(body, *parameters)
+      end
+    end
+
+    def serialize_attributes
+      hash = attributes.each_with_object({}) do |(key, value), memo|
+        memo[key] = attribute_hash(value)
+      end
+
+      SENTRY_ATTRIBUTES.each do |key, name|
+        if (value = serialize(name))
+          hash[key] = attribute_hash(value)
+        end
+      end
+
+      hash
+    end
+
+    def attribute_hash(value)
+      { value: value, type: value_type(value) }
+    end
+
+    def value_type(value)
+      case value
+      when Integer
+        "integer"
+      when TrueClass, FalseClass
+        "boolean"
+      when Float
+        "double"
+      else
+        "string"
+      end
+    end
+
+    def parameters
+      @parameters ||= begin
+        return DEFAULT_PARAMETERS unless template
+
+        parameters = template_tokens.empty? ?
+          attributes.fetch(:parameters, DEFAULT_PARAMETERS) : attributes.slice(*template_tokens)
+
+        if parameters.is_a?(Hash)
+          parameters.each do |key, value|
+            attributes["sentry.message.parameter.#{key}"] = value
+          end
+        else
+          parameters.each_with_index do |param, index|
+            attributes["sentry.message.parameter.#{index}"] = param
+          end
+        end
+      end
+    end
+
+    TOKEN_REGEXP = /%\{(\w+)\}/
+
+    def template_tokens
+      @template_tokens ||= body.scan(TOKEN_REGEXP).flatten.map(&:to_sym)
+    end
+
+    def is_template?
+      body.include?("%s") || TOKEN_REGEXP.match?(body)
+    end
+  end
+end

data/lib/sentry/log_event_buffer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "sentry/threaded_periodic_worker"
+
+module Sentry
+  # LogEventBuffer buffers log events and sends them to Sentry in a single envelope.
+  #
+  # This is used internally by the `Sentry::Client`.
+  #
+  # @!visibility private
+  class LogEventBuffer < ThreadedPeriodicWorker
+    FLUSH_INTERVAL = 5 # seconds
+    DEFAULT_MAX_EVENTS = 100
+
+    # @!visibility private
+    attr_reader :pending_events
+
+    def initialize(configuration, client)
+      super(configuration.sdk_logger, FLUSH_INTERVAL)
+
+      @client = client
+      @pending_events = []
+      @max_events = configuration.max_log_events || DEFAULT_MAX_EVENTS
+      @dsn = configuration.dsn
+      @sdk = Sentry.sdk_meta
+      @mutex = Mutex.new
+
+      log_debug("[Logging] Initialized buffer with max_events=#{@max_events}, flush_interval=#{FLUSH_INTERVAL}s")
+    end
+
+    def start
+      ensure_thread
+      self
+    end
+
+    def flush
+      @mutex.synchronize do
+        return if empty?
+
+        log_debug("[LogEventBuffer] flushing #{size} log events")
+
+        send_events
+      end
+
+      log_debug("[LogEventBuffer] flushed #{size} log events")
+
+      self
+    end
+    alias_method :run, :flush
+
+    def add_event(event)
+      raise ArgumentError, "expected a LogEvent, got #{event.class}" unless event.is_a?(LogEvent)
+
+      @mutex.synchronize do
+        @pending_events << event
+        send_events if size >= @max_events
+      end
+
+      self
+    end
+
+    def empty?
+      @pending_events.empty?
+    end
+
+    def size
+      @pending_events.size
+    end
+
+    private
+
+    def send_events
+      @client.send_envelope(to_envelope)
+      @pending_events.clear
+    end
+
+    def to_envelope
+      envelope = Envelope.new(
+        event_id: SecureRandom.uuid.delete("-"),
+        sent_at: Sentry.utc_now.iso8601,
+        dsn: @dsn,
+        sdk: @sdk
+      )
+
+      envelope.add_item(
+        {
+          type: "log",
+          item_count: size,
+          content_type: "application/vnd.sentry.items.log+json"
+        },
+        { items: @pending_events.map(&:to_hash) }
+      )
+
+      envelope
+    end
+  end
+end

data/lib/sentry/metrics/aggregator.rb

@@ -34,7 +34,7 @@ module Sentry
       attr_reader :client, :thread, :buckets, :flush_shift, :code_locations
 
       def initialize(configuration, client)
-        super(configuration.logger, FLUSH_INTERVAL)
+        super(configuration.sdk_logger, FLUSH_INTERVAL)
         @client = client
         @before_emit = configuration.metrics.before_emit
         @enable_code_locations = configuration.metrics.enable_code_locations