sentry-ruby 5.23.0 → 5.27.0

data/lib/sentry/hub.rb

@@ -120,7 +120,8 @@ module Sentry
 
       sampling_context = {
         transaction_context: transaction.to_hash,
-        parent_sampled: transaction.parent_sampled
+        parent_sampled: transaction.parent_sampled,
+        parent_sample_rate: transaction.parent_sample_rate
       }
 
       sampling_context.merge!(custom_sampling_context)
@@ -216,6 +217,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)
 
@@ -347,6 +358,7 @@ module Sentry
         parent_span_id: propagation_context.parent_span_id,
         parent_sampled: propagation_context.parent_sampled,
         baggage: propagation_context.baggage,
+        sample_rand: propagation_context.sample_rand,
         **options
       )
     end

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/log_event.rb

@@ -0,0 +1,206 @@
+# 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
+    TYPE = "log"
+
+    DEFAULT_PARAMETERS = [].freeze
+    DEFAULT_ATTRIBUTES = {}.freeze
+
+    SERIALIZEABLE_ATTRIBUTES = %i[
+      level
+      body
+      timestamp
+      environment
+      release
+      server_name
+      trace_id
+      attributes
+      contexts
+    ]
+
+    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
+    }
+
+    USER_ATTRIBUTES = {
+      "user.id" => :user_id,
+      "user.name" => :user_username,
+      "user.email" => :user_email
+    }
+
+    LEVELS = %i[trace debug info warn error fatal].freeze
+
+    attr_accessor :level, :body, :template, :attributes, :user
+
+    attr_reader :configuration, *(SERIALIZEABLE_ATTRIBUTES - %i[level body attributes])
+
+    SERIALIZERS = %i[
+      attributes
+      body
+      level
+      parent_span_id
+      sdk_name
+      sdk_version
+      timestamp
+      trace_id
+      user_id
+      user_username
+      user_email
+    ].map { |name| [name, :"serialize_#{name}"] }.to_h
+
+    VALUE_TYPES = Hash.new("string").merge!({
+      TrueClass => "boolean",
+      FalseClass => "boolean",
+      Integer => "integer",
+      Float => "double"
+    }).freeze
+
+    TOKEN_REGEXP = /%\{(\w+)\}/
+
+    def initialize(configuration: Sentry.configuration, **options)
+      @configuration = configuration
+      @type = TYPE
+      @server_name = configuration.server_name
+      @environment = configuration.environment
+      @release = configuration.release
+      @timestamp = Sentry.utc_now
+      @level = options.fetch(:level)
+      @body = options[:body]
+      @template = @body if is_template?
+      @attributes = options[:attributes] || DEFAULT_ATTRIBUTES
+      @user = options[:user] || {}
+      @contexts = {}
+    end
+
+    def to_hash
+      SERIALIZEABLE_ATTRIBUTES.each_with_object({}) do |name, memo|
+        memo[name] = serialize(name)
+      end
+    end
+
+    private
+
+    def serialize(name)
+      serializer = SERIALIZERS[name]
+
+      if serializer
+        __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
+      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_user_id
+      user[:id]
+    end
+
+    def serialize_user_username
+      user[:username]
+    end
+
+    def serialize_user_email
+      user[:email]
+    end
+
+    def serialize_attributes
+      hash = {}
+
+      attributes.each do |key, value|
+        hash[key] = attribute_hash(value)
+      end
+
+      SENTRY_ATTRIBUTES.each do |key, name|
+        if (value = serialize(name))
+          hash[key] = attribute_hash(value)
+        end
+      end
+
+      USER_ATTRIBUTES.each do |key, name|
+        if (value = serialize(name))
+          hash[key] = value
+        end
+      end
+
+      hash
+    end
+
+    def attribute_hash(value)
+      { value: value, type: value_type(value) }
+    end
+
+    def value_type(value)
+      VALUE_TYPES[value.class]
+    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
+
+    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,75 @@
+# 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
+      @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_logs(@pending_events)
+      @pending_events.clear
+    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

data/lib/sentry/profiler.rb

@@ -2,6 +2,7 @@
 
 require "securerandom"
 require_relative "profiler/helpers"
+require "sentry/utils/uuid"
 
 module Sentry
   class Profiler
@@ -17,7 +18,7 @@ module Sentry
     attr_reader :sampled, :started, :event_id
 
     def initialize(configuration)
-      @event_id = SecureRandom.uuid.delete("-")
+      @event_id = Utils.uuid
       @started = false
       @sampled = nil
 
@@ -192,7 +193,7 @@ module Sentry
     private
 
     def log(message)
-      Sentry.logger.debug(LOGGER_PROGNAME) { "[Profiler] #{message}" }
+      Sentry.sdk_logger.debug(LOGGER_PROGNAME) { "[Profiler] #{message}" }
     end
 
     def record_lost_event(reason)

data/lib/sentry/propagation_context.rb

@@ -2,15 +2,15 @@
 
 require "securerandom"
 require "sentry/baggage"
+require "sentry/utils/uuid"
+require "sentry/utils/sample_rand"
 
 module Sentry
   class PropagationContext
     SENTRY_TRACE_REGEXP = Regexp.new(
-      "^[ \t]*" +  # whitespace
-      "([0-9a-f]{32})?" +  # trace_id
+      "\\A([0-9a-f]{32})?" + # trace_id
       "-?([0-9a-f]{16})?" +  # span_id
-      "-?([01])?" +  # sampled
-      "[ \t]*$"  # whitespace
+      "-?([01])?\\z"         # sampled
     )
 
     # An uuid that can be used to identify a trace.
@@ -32,6 +32,53 @@ module Sentry
     # Please use the #get_baggage method for interfacing outside this class.
     # @return [Baggage, nil]
     attr_reader :baggage
+    # The propagated random value used for sampling decisions.
+    # @return [Float, nil]
+    attr_reader :sample_rand
+
+    # Extract the trace_id, parent_span_id and parent_sampled values from a sentry-trace header.
+    #
+    # @param sentry_trace [String] the sentry-trace header value from the previous transaction.
+    # @return [Array, nil]
+    def self.extract_sentry_trace(sentry_trace)
+      value = sentry_trace.to_s.strip
+      return if value.empty?
+
+      match = SENTRY_TRACE_REGEXP.match(value)
+      return if match.nil?
+
+      trace_id, parent_span_id, sampled_flag = match[1..3]
+      parent_sampled = sampled_flag.nil? ? nil : sampled_flag != "0"
+
+      [trace_id, parent_span_id, parent_sampled]
+    end
+
+    def self.extract_sample_rand_from_baggage(baggage, trace_id = nil)
+      return unless baggage&.items
+
+      sample_rand_str = baggage.items["sample_rand"]
+      return unless sample_rand_str
+
+      generator = Utils::SampleRand.new(trace_id: trace_id)
+      generator.generate_from_value(sample_rand_str)
+    end
+
+    def self.generate_sample_rand(baggage, trace_id, parent_sampled)
+      generator = Utils::SampleRand.new(trace_id: trace_id)
+
+      if baggage&.items && !parent_sampled.nil?
+        sample_rate_str = baggage.items["sample_rate"]
+        sample_rate = sample_rate_str&.to_f
+
+        if sample_rate && !parent_sampled.nil?
+          generator.generate_from_sampling_decision(parent_sampled, sample_rate)
+        else
+          generator.generate_from_trace_id
+        end
+      else
+        generator.generate_from_trace_id
+      end
+    end
 
     def initialize(scope, env = nil)
       @scope = scope
@@ -39,6 +86,7 @@ module Sentry
       @parent_sampled = nil
       @baggage = nil
       @incoming_trace = false
+      @sample_rand = nil
 
       if env
         sentry_trace_header = env["HTTP_SENTRY_TRACE"] || env[SENTRY_TRACE_HEADER_NAME]
@@ -60,28 +108,17 @@ module Sentry
                 Baggage.new({})
               end
 
+            @sample_rand = self.class.extract_sample_rand_from_baggage(@baggage, @trace_id)
+
             @baggage.freeze!
             @incoming_trace = true
           end
         end
       end
 
-      @trace_id ||= SecureRandom.uuid.delete("-")
-      @span_id = SecureRandom.uuid.delete("-").slice(0, 16)
-    end
-
-    # Extract the trace_id, parent_span_id and parent_sampled values from a sentry-trace header.
-    #
-    # @param sentry_trace [String] the sentry-trace header value from the previous transaction.
-    # @return [Array, nil]
-    def self.extract_sentry_trace(sentry_trace)
-      match = SENTRY_TRACE_REGEXP.match(sentry_trace)
-      return nil if match.nil?
-
-      trace_id, parent_span_id, sampled_flag = match[1..3]
-      parent_sampled = sampled_flag.nil? ? nil : sampled_flag != "0"
-
-      [trace_id, parent_span_id, parent_sampled]
+      @trace_id ||= Utils.uuid
+      @span_id = Utils.uuid.slice(0, 16)
+      @sample_rand ||= self.class.generate_sample_rand(@baggage, @trace_id, @parent_sampled)
     end
 
     # Returns the trace context that can be used to embed in an Event.
@@ -122,10 +159,10 @@ module Sentry
 
       items = {
         "trace_id" => trace_id,
+        "sample_rand" => Utils::SampleRand.format(@sample_rand),
         "environment" => configuration.environment,
         "release" => configuration.release,
-        "public_key" => configuration.dsn&.public_key,
-        "user_segment" => @scope.user && @scope.user["segment"]
+        "public_key" => configuration.dsn&.public_key
       }
 
       items.compact!

data/lib/sentry/scope.rb

@@ -46,7 +46,7 @@ module Sentry
     # @param hint [Hash] the hint data that'll be passed to event processors.
     # @return [Event]
     def apply_to_event(event, hint = nil)
-      unless event.is_a?(CheckInEvent)
+      unless event.is_a?(CheckInEvent) || event.is_a?(LogEvent)
         event.tags = tags.merge(event.tags)
         event.user = user.merge(event.user)
         event.extra = extra.merge(event.extra)
@@ -60,12 +60,22 @@ module Sentry
         event.attachments = attachments
       end
 
+      if event.is_a?(LogEvent)
+        event.user = user.merge(event.user)
+      end
+
       if span
         event.contexts[:trace] ||= span.get_trace_context
-        event.dynamic_sampling_context ||= span.get_dynamic_sampling_context
+
+        if event.respond_to?(:dynamic_sampling_context)
+          event.dynamic_sampling_context ||= span.get_dynamic_sampling_context
+        end
       else
         event.contexts[:trace] ||= propagation_context.get_trace_context
-        event.dynamic_sampling_context ||= propagation_context.get_dynamic_sampling_context
+
+        if event.respond_to?(:dynamic_sampling_context)
+          event.dynamic_sampling_context ||= propagation_context.get_dynamic_sampling_context
+        end
       end
 
       all_event_processors = self.class.global_event_processors + @event_processors

data/lib/sentry/session_flusher.rb

@@ -5,7 +5,7 @@ module Sentry
     FLUSH_INTERVAL = 60
 
     def initialize(configuration, client)
-      super(configuration.logger, FLUSH_INTERVAL)
+      super(configuration.sdk_logger, FLUSH_INTERVAL)
       @client = client
       @pending_aggregates = {}
       @release = configuration.release

data/lib/sentry/span.rb

@@ -2,6 +2,7 @@
 
 require "securerandom"
 require "sentry/metrics/local_aggregator"
+require "sentry/utils/uuid"
 
 module Sentry
   class Span
@@ -127,8 +128,8 @@ module Sentry
       timestamp: nil,
       origin: nil
     )
-      @trace_id = trace_id || SecureRandom.uuid.delete("-")
-      @span_id = span_id || SecureRandom.uuid.delete("-").slice(0, 16)
+      @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
@@ -261,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

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