sentry-ruby 5.28.1 → 6.5.0

data/lib/sentry/hub.rb

@@ -116,10 +116,10 @@ module Sentry
       return unless configuration.tracing_enabled?
       return unless instrumenter == configuration.instrumenter
 
-      transaction ||= Transaction.new(**options.merge(hub: self))
+      transaction ||= Transaction.new(**options)
 
       sampling_context = {
-        transaction_context: transaction.to_hash,
+        transaction_context: transaction.to_h,
         parent_sampled: transaction.parent_sampled,
         parent_sample_rate: transaction.parent_sample_rate
       }
@@ -218,7 +218,7 @@ module Sentry
     end
 
     def capture_log_event(message, **options)
-      return unless current_client
+      return unless current_client && current_client.configuration.enable_logs
 
       event = current_client.event_from_log(message, **options)
 
@@ -227,6 +227,29 @@ module Sentry
       current_client.buffer_log_event(event, current_scope)
     end
 
+    # Captures a metric and sends it to Sentry
+    #
+    # @param name [String] the metric name
+    # @param type [Symbol] the metric type (:counter, :gauge, :distribution)
+    # @param value [Numeric] the metric value
+    # @param unit [String, nil] (optional) the metric unit
+    # @param attributes [Hash, nil] (optional) additional attributes for the metric
+    # @return [void]
+    def capture_metric(name:, type:, value:, unit: nil, attributes: nil)
+      return unless current_client&.configuration.enable_metrics
+
+      metric = MetricEvent.new(
+        name: name,
+        value: value,
+        type: type,
+        unit: unit,
+        attributes: attributes,
+      )
+
+      current_client.buffer_metric_event(metric, current_scope)
+    end
+
+
     def capture_event(event, **options, &block)
       check_argument_type!(event, Sentry::Event)
 
@@ -353,7 +376,6 @@ module Sentry
       return nil unless propagation_context.incoming_trace
 
       Transaction.new(
-        hub: self,
         trace_id: propagation_context.trace_id,
         parent_span_id: propagation_context.parent_span_id,
         parent_sampled: propagation_context.parent_sampled,

data/lib/sentry/interface.rb

@@ -3,7 +3,7 @@
 module Sentry
   class Interface
     # @return [Hash]
-    def to_hash
+    def to_h
       Hash[instance_variables.map { |name| [name[1..-1].to_sym, instance_variable_get(name)] }]
     end
   end

data/lib/sentry/interfaces/exception.rb

@@ -13,9 +13,9 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
+    def to_h
       data = super
-      data[:values] = data[:values].map(&:to_hash) if data[:values]
+      data[:values] = data[:values].map(&:to_h) if data[:values]
       data
     end
 

data/lib/sentry/interfaces/request.rb

@@ -69,6 +69,8 @@ module Sentry
     private
 
     def read_data_from(request)
+      return "Skipped non-rewindable request body" unless request.body.respond_to?(:rewind)
+
       if request.form_data?
         request.POST
       elsif request.body # JSON requests, etc

data/lib/sentry/interfaces/single_exception.rb

@@ -32,10 +32,10 @@ module Sentry
       @mechanism = mechanism
     end
 
-    def to_hash
+    def to_h
       data = super
-      data[:stacktrace] = data[:stacktrace].to_hash if data[:stacktrace]
-      data[:mechanism] = data[:mechanism].to_hash
+      data[:stacktrace] = data[:stacktrace].to_h if data[:stacktrace]
+      data[:mechanism] = data[:mechanism].to_h
       data
     end
 
@@ -60,7 +60,7 @@ module Sentry
             end
         end
 
-        stacktrace.frames.last.vars = locals
+        stacktrace.frames.last&.vars = locals
       end
 
       new(exception: exception, stacktrace: stacktrace, mechanism: mechanism)

data/lib/sentry/interfaces/stacktrace.rb

@@ -11,8 +11,8 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
-      { frames: @frames.map(&:to_hash) }
+    def to_h
+      { frames: @frames.map(&:to_h) }
     end
 
     # @return [String]
@@ -66,7 +66,7 @@ module Sentry
             linecache.get_file_context(abs_path, lineno, context_lines)
       end
 
-      def to_hash(*args)
+      def to_h(*args)
         data = super(*args)
         data.delete(:vars) unless vars && !vars.empty?
         data.delete(:pre_context) unless pre_context && !pre_context.empty?

data/lib/sentry/interfaces/stacktrace_builder.rb

@@ -75,14 +75,6 @@ module Sentry
       StacktraceInterface.new(frames: frames)
     end
 
-    # Get the code location hash for a single line for where metrics where added.
-    # @return [Hash]
-    def metrics_code_location(unparsed_line)
-      parsed_line = Backtrace::Line.parse(unparsed_line)
-      frame = convert_parsed_line_into_frame(parsed_line)
-      frame.to_hash.reject { |k, _| %i[project_root in_app].include?(k) }
-    end
-
     private
 
     def convert_parsed_line_into_frame(line)

data/lib/sentry/interfaces/threads.rb

@@ -13,7 +13,7 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
+    def to_h
       {
         values: [
           {
@@ -21,7 +21,7 @@ module Sentry
             name: @name,
             crashed: @crashed,
             current: @current,
-            stacktrace: @stacktrace&.to_hash
+            stacktrace: @stacktrace&.to_h
           }
         ]
       }

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.to_f,
+        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