sentry-ruby 5.28.1 → 6.3.1

data/lib/sentry/log_event.rb

@@ -1,134 +1,52 @@
 # frozen_string_literal: true
 
+require "sentry/utils/telemetry_attributes"
+
 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
+    include Sentry::Utils::TelemetryAttributes
+
     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,
-      "sentry.origin" => :origin
-    }
 
     PARAMETER_PREFIX = "sentry.message.parameter"
 
-    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, :origin
-
-    attr_reader :configuration, *(SERIALIZEABLE_ATTRIBUTES - %i[level body attributes])
-
-    SERIALIZERS = %i[
-      attributes
-      body
-      level
-      parent_span_id
-      sdk_name
-      sdk_version
-      template
-      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
+    attr_accessor :level, :body, :template, :attributes, :origin, :trace_id, :span_id
+    attr_reader :timestamp
 
     TOKEN_REGEXP = /%\{(\w+)\}/
 
-    def initialize(configuration: Sentry.configuration, **options)
-      @configuration = configuration
+    def initialize(**options)
       @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] || {}
+      @attributes = options[:attributes] || {}
       @origin = options[:origin]
-      @contexts = {}
+      @trace_id = nil
+      @span_id = nil
     end
 
-    def to_hash
-      SERIALIZEABLE_ATTRIBUTES.each_with_object({}) do |name, memo|
-        memo[name] = serialize(name)
-      end
+    def to_h
+      {
+        level: level.to_s,
+        timestamp: timestamp.to_f,
+        trace_id: @trace_id,
+        span_id: @span_id,
+        body: serialize_body,
+        attributes: serialize_attributes
+      }.compact
     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
@@ -139,50 +57,14 @@ module Sentry
       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_template
-      template if has_parameters?
-    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) }
+      populate_sentry_attributes!
+      @attributes.transform_values! { |v| attribute_hash(v) }
     end
 
-    def value_type(value)
-      VALUE_TYPES[value.class]
+    def populate_sentry_attributes!
+      @attributes["sentry.origin"] ||= @origin if @origin
+      @attributes["sentry.message.template"] ||= template if has_parameters?
     end
 
     def parameters

data/lib/sentry/log_event_buffer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "sentry/threaded_periodic_worker"
+require "sentry/telemetry_event_buffer"
 
 module Sentry
   # LogEventBuffer buffers log events and sends them to Sentry in a single envelope.
@@ -8,68 +8,21 @@ module Sentry
   # This is used internally by the `Sentry::Client`.
   #
   # @!visibility private
-  class LogEventBuffer < ThreadedPeriodicWorker
-    FLUSH_INTERVAL = 5 # seconds
+  class LogEventBuffer < TelemetryEventBuffer
     DEFAULT_MAX_EVENTS = 100
-
-    # @!visibility private
-    attr_reader :pending_events
+    MAX_EVENTS_BEFORE_DROP = 1000
 
     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
+      super(
+        configuration,
+        client,
+        event_class: LogEvent,
+        max_items: configuration.max_log_events || DEFAULT_MAX_EVENTS,
+        max_items_before_drop: MAX_EVENTS_BEFORE_DROP,
+        envelope_type: "log",
+        envelope_content_type: "application/vnd.sentry.items.log+json",
+        before_send: configuration.before_send_log
+      )
     end
   end
 end

data/lib/sentry/metric_event.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "sentry/utils/telemetry_attributes"
+
+module Sentry
+  class MetricEvent
+    include Sentry::Utils::TelemetryAttributes
+
+    attr_reader :name, :type, :value, :unit, :timestamp, :trace_id, :span_id, :attributes
+    attr_writer :trace_id, :span_id, :attributes
+
+    def initialize(
+      name:,
+      type:,
+      value:,
+      unit: nil,
+      attributes: nil
+    )
+      @name = name
+      @type = type
+      @value = value
+      @unit = unit
+      @attributes = attributes || {}
+
+      @timestamp = Sentry.utc_now
+      @trace_id = nil
+      @span_id = nil
+    end
+
+    def to_h
+      {
+        name: @name,
+        type: @type,
+        value: @value,
+        unit: @unit,
+        timestamp: @timestamp,
+        trace_id: @trace_id,
+        span_id: @span_id,
+        attributes: serialize_attributes
+      }.compact
+    end
+
+    private
+
+    def serialize_attributes
+      @attributes.transform_values! { |v| attribute_hash(v) }
+    end
+  end
+end

data/lib/sentry/metric_event_buffer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "sentry/telemetry_event_buffer"
+
+module Sentry
+  # MetricEventBuffer buffers metric events and sends them to Sentry in a single envelope.
+  #
+  # This is used internally by the `Sentry::Client`.
+  #
+  # @!visibility private
+  class MetricEventBuffer < TelemetryEventBuffer
+    DEFAULT_MAX_METRICS = 1000
+    MAX_METRICS_BEFORE_DROP = 10_000
+
+    def initialize(configuration, client)
+      super(
+        configuration,
+        client,
+        event_class: MetricEvent,
+        max_items: configuration.max_metric_events || DEFAULT_MAX_METRICS,
+        max_items_before_drop: MAX_METRICS_BEFORE_DROP,
+        envelope_type: "trace_metric",
+        envelope_content_type: "application/vnd.sentry.items.trace-metric+json",
+        before_send: configuration.before_send_metric
+      )
+    end
+  end
+end

data/lib/sentry/metrics.rb

@@ -1,67 +1,60 @@
 # frozen_string_literal: true
 
-require "sentry/metrics/metric"
-require "sentry/metrics/counter_metric"
-require "sentry/metrics/distribution_metric"
-require "sentry/metrics/gauge_metric"
-require "sentry/metrics/set_metric"
-require "sentry/metrics/timing"
-require "sentry/metrics/aggregator"
+require "sentry/metric_event"
 
 module Sentry
   module Metrics
-    DURATION_UNITS = %w[nanosecond microsecond millisecond second minute hour day week]
-    INFORMATION_UNITS = %w[bit byte kilobyte kibibyte megabyte mebibyte gigabyte gibibyte terabyte tebibyte petabyte pebibyte exabyte exbibyte]
-    FRACTIONAL_UNITS = %w[ratio percent]
-
-    OP_NAME = "metric.timing"
-    SPAN_ORIGIN = "auto.metric.timing"
-
     class << self
-      def increment(key, value = 1.0, unit: "none", tags: {}, timestamp: nil)
-        log_deprecation
-        Sentry.metrics_aggregator&.add(:c, key, value, unit: unit, tags: tags, timestamp: timestamp)
-      end
-
-      def distribution(key, value, unit: "none", tags: {}, timestamp: nil)
-        log_deprecation
-        Sentry.metrics_aggregator&.add(:d, key, value, unit: unit, tags: tags, timestamp: timestamp)
+      # Increments a counter metric
+      # @param name [String] the metric name
+      # @param value [Numeric] the value to increment by (default: 1)
+      # @param attributes [Hash, nil] additional attributes for the metric (optional)
+      # @return [void]
+      def count(name, value: 1, attributes: nil)
+        return unless Sentry.initialized?
+
+        Sentry.get_current_hub.capture_metric(
+          name: name,
+          type: :counter,
+          value: value,
+          attributes: attributes
+        )
       end
 
-      def set(key, value, unit: "none", tags: {}, timestamp: nil)
-        log_deprecation
-        Sentry.metrics_aggregator&.add(:s, key, value, unit: unit, tags: tags, timestamp: timestamp)
-      end
-
-      def gauge(key, value, unit: "none", tags: {}, timestamp: nil)
-        log_deprecation
-        Sentry.metrics_aggregator&.add(:g, key, value, unit: unit, tags: tags, timestamp: timestamp)
-      end
-
-      def timing(key, unit: "second", tags: {}, timestamp: nil, &block)
-        log_deprecation
-
-        return unless block_given?
-        return yield unless DURATION_UNITS.include?(unit)
-
-        result, value = Sentry.with_child_span(op: OP_NAME, description: key, origin: SPAN_ORIGIN) do |span|
-          tags.each { |k, v| span.set_tag(k, v.is_a?(Array) ? v.join(", ") : v.to_s) } if span
-
-          start = Timing.send(unit.to_sym)
-          result = yield
-          value = Timing.send(unit.to_sym) - start
-
-          [result, value]
-        end
-
-        Sentry.metrics_aggregator&.add(:d, key, value, unit: unit, tags: tags, timestamp: timestamp)
-        result
+      # Records a gauge metric
+      # @param name [String] the metric name
+      # @param value [Numeric] the gauge value
+      # @param unit [String, nil] the metric unit (optional)
+      # @param attributes [Hash, nil] additional attributes for the metric (optional)
+      # @return [void]
+      def gauge(name, value, unit: nil, attributes: nil)
+        return unless Sentry.initialized?
+
+        Sentry.get_current_hub.capture_metric(
+          name: name,
+          type: :gauge,
+          value: value,
+          unit: unit,
+          attributes: attributes
+        )
       end
 
-      def log_deprecation
-        Sentry.sdk_logger.warn(LOGGER_PROGNAME) do
-          "`Sentry::Metrics` is now deprecated and will be removed in the next major."
-        end
+      # Records a distribution metric
+      # @param name [String] the metric name
+      # @param value [Numeric] the distribution value
+      # @param unit [String, nil] the metric unit (optional)
+      # @param attributes [Hash, nil] additional attributes for the metric (optional)
+      # @return [void]
+      def distribution(name, value, unit: nil, attributes: nil)
+        return unless Sentry.initialized?
+
+        Sentry.get_current_hub.capture_metric(
+          name: name,
+          type: :distribution,
+          value: value,
+          unit: unit,
+          attributes: attributes
+        )
       end
     end
   end

data/lib/sentry/profiler.rb

@@ -10,8 +10,6 @@ module Sentry
 
     VERSION = "1"
     PLATFORM = "ruby"
-    # 101 Hz in microseconds
-    DEFAULT_INTERVAL = 1e6 / 101
     MICRO_TO_NANO_SECONDS = 1e3
     MIN_SAMPLES_REQUIRED = 2
 
@@ -24,6 +22,7 @@ module Sentry
 
       @profiling_enabled = defined?(StackProf) && configuration.profiling_enabled?
       @profiles_sample_rate = configuration.profiles_sample_rate
+      @profiles_sample_interval = configuration.profiles_sample_interval
       @project_root = configuration.project_root
       @app_dirs_pattern = configuration.app_dirs_pattern
       @in_app_pattern = Regexp.new("^(#{@project_root}/)?#{@app_dirs_pattern}")
@@ -32,7 +31,7 @@ module Sentry
     def start
       return unless @sampled
 
-      @started = StackProf.start(interval: DEFAULT_INTERVAL,
+      @started = StackProf.start(interval: @profiles_sample_interval,
                                  mode: :wall,
                                  raw: true,
                                  aggregate: false)
@@ -81,9 +80,9 @@ module Sentry
       log("Discarding profile due to sampling decision") unless @sampled
     end
 
-    def to_hash
+    def to_h
       unless @sampled
-        record_lost_event(:sample_rate)
+        record_lost_event(:sample_rate) if @profiling_enabled
         return {}
       end
 

data/lib/sentry/rack/capture_exceptions.rb

@@ -33,7 +33,7 @@ module Sentry
               raise # Don't capture Sentry errors
             rescue Exception => e
               capture_exception(e, env)
-              finish_transaction(transaction, 500)
+              finish_transaction(transaction, status_code_for_exception(e))
               raise
             end
 
@@ -86,6 +86,10 @@ module Sentry
       def mechanism
         Sentry::Mechanism.new(type: MECHANISM_TYPE, handled: false)
       end
+
+      def status_code_for_exception(exception)
+        500
+      end
     end
   end
 end

data/lib/sentry/rspec.rb

@@ -70,7 +70,7 @@ RSpec::Matchers.define :include_sentry_event do |event_message = "", **opts|
   end
 
   def dump_events(sentry_events)
-    sentry_events.map(&Kernel.method(:Hash)).map do |hash|
+    sentry_events.map(&:to_h).map do |hash|
       hash.select { |k, _| [:message, :contexts, :tags, :exception].include?(k) }
     end.map do |hash|
       JSON.pretty_generate(hash)

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) || event.is_a?(LogEvent)
+      unless event.is_a?(CheckInEvent)
         event.tags = tags.merge(event.tags)
         event.user = user.merge(event.user)
         event.extra = extra.merge(event.extra)
@@ -60,23 +60,10 @@ 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
-
-        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
-
-        if event.respond_to?(:dynamic_sampling_context)
-          event.dynamic_sampling_context ||= propagation_context.get_dynamic_sampling_context
-        end
-      end
+      trace_context = get_trace_context
+      dynamic_sampling_context = trace_context.delete(:dynamic_sampling_context)
+      event.contexts[:trace] ||= trace_context
+      event.dynamic_sampling_context ||= dynamic_sampling_context
 
       all_event_processors = self.class.global_event_processors + @event_processors
 
@@ -89,6 +76,37 @@ module Sentry
       event
     end
 
+    # A leaner version of apply_to_event that applies to
+    # lightweight payloads like Logs and Metrics.
+    #
+    # Adds trace_id, span_id, user from the scope and default attributes from configuration.
+    #
+    # @param telemetry [MetricEvent, LogEvent] the telemetry event to apply scope context to
+    # @return [MetricEvent, LogEvent] the telemetry event with scope context applied
+    def apply_to_telemetry(telemetry)
+      # TODO-neel when new scope set_attribute api is added: add them here
+      trace_context = get_trace_context
+      telemetry.trace_id = trace_context[:trace_id]
+      telemetry.span_id = trace_context[:span_id]
+
+      configuration = Sentry.configuration
+      return telemetry unless configuration
+
+      telemetry.attributes["sentry.sdk.name"] ||= Sentry.sdk_meta["name"]
+      telemetry.attributes["sentry.sdk.version"] ||= Sentry.sdk_meta["version"]
+      telemetry.attributes["sentry.environment"] ||= configuration.environment if configuration.environment
+      telemetry.attributes["sentry.release"] ||= configuration.release if configuration.release
+      telemetry.attributes["server.address"] ||= configuration.server_name if configuration.server_name
+
+      if configuration.send_default_pii && !user.empty?
+        telemetry.attributes["user.id"] ||= user[:id] if user[:id]
+        telemetry.attributes["user.name"] ||= user[:username] if user[:username]
+        telemetry.attributes["user.email"] ||= user[:email] if user[:email]
+      end
+
+      telemetry
+    end
+
     # Adds the breadcrumb to the scope's breadcrumbs buffer.
     # @param breadcrumb [Breadcrumb]
     # @return [void]
@@ -278,6 +296,20 @@ module Sentry
       span
     end
 
+    # Returns the trace context for this scope.
+    # Prioritizes external propagation context (from OTel) over local propagation context.
+    # @return [Hash]
+    def get_trace_context
+      if span
+        span.get_trace_context.merge(dynamic_sampling_context: span.get_dynamic_sampling_context)
+      elsif (external_context = Sentry.get_external_propagation_context)
+        trace_id, span_id = external_context
+        { trace_id: trace_id, span_id: span_id }
+      else
+        propagation_context.get_trace_context.merge(dynamic_sampling_context: propagation_context.get_dynamic_sampling_context)
+      end
+    end
+
     # Sets the scope's fingerprint attribute.
     # @param fingerprint [Array]
     # @return [Array]

data/lib/sentry/sequel.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Sequel
+    OP_NAME = "db.sql.sequel"
+    SPAN_ORIGIN = "auto.db.sequel"
+
+    # Sequel Database extension module that instruments queries
+    module DatabaseExtension
+      def log_connection_yield(sql, conn, args = nil)
+        return super unless Sentry.initialized?
+
+        Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f, origin: SPAN_ORIGIN) do |span|
+          result = super
+
+          if span
+            span.set_description(sql)
+            span.set_data(Span::DataConventions::DB_SYSTEM, database_type.to_s)
+            span.set_data(Span::DataConventions::DB_NAME, opts[:database]) if opts[:database]
+            span.set_data(Span::DataConventions::SERVER_ADDRESS, opts[:host]) if opts[:host]
+            span.set_data(Span::DataConventions::SERVER_PORT, opts[:port]) if opts[:port]
+          end
+
+          result
+        end
+      end
+    end
+  end
+
+  ::Sequel::Database.register_extension(:sentry, Sentry::Sequel::DatabaseExtension)
+end
+
+Sentry.register_patch(:sequel) do
+  ::Sequel::Database.extension(:sentry) if defined?(::Sequel::Database)
+end