sentry-ruby 5.26.0 → 6.3.0

data/lib/sentry/event.rb

@@ -81,12 +81,6 @@ module Sentry
       @message = (message || "").byteslice(0..MAX_MESSAGE_SIZE_IN_BYTES)
     end
 
-    # @deprecated This method will be removed in v5.0.0. Please just use Sentry.configuration
-    # @return [Configuration]
-    def configuration
-      Sentry.configuration
-    end
-
     # Sets the event's timestamp.
     # @param time [Time, Float]
     # @return [void]
@@ -118,16 +112,16 @@ module Sentry
     end
 
     # @return [Hash]
-    def to_hash
+    def to_h
       data = serialize_attributes
-      data[:breadcrumbs] = breadcrumbs.to_hash if breadcrumbs
-      data[:request] = request.to_hash if request
+      data[:breadcrumbs] = breadcrumbs.to_h if breadcrumbs
+      data[:request] = request.to_h if request
       data
     end
 
     # @return [Hash]
     def to_json_compatible
-      JSON.parse(JSON.generate(to_hash))
+      JSON.parse(JSON.generate(to_h))
     end
 
     private

data/lib/sentry/graphql.rb

@@ -4,6 +4,6 @@ Sentry.register_patch(:graphql) do |config|
   if defined?(::GraphQL::Schema) && defined?(::GraphQL::Tracing::SentryTrace) && ::GraphQL::Schema.respond_to?(:trace_with)
     ::GraphQL::Schema.trace_with(::GraphQL::Tracing::SentryTrace, set_transaction_name: true)
   else
-    config.logger.warn(Sentry::LOGGER_PROGNAME) { "You tried to enable the GraphQL integration but no GraphQL gem was detected. Make sure you have the `graphql` gem (>= 2.2.6) in your Gemfile." }
+    config.sdk_logger.warn(Sentry::LOGGER_PROGNAME) { "You tried to enable the GraphQL integration but no GraphQL gem was detected. Make sure you have the `graphql` gem (>= 2.2.6) in your Gemfile." }
   end
 end

data/lib/sentry/hub.rb

@@ -116,11 +116,12 @@ 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,
-        parent_sampled: transaction.parent_sampled
+        transaction_context: transaction.to_h,
+        parent_sampled: transaction.parent_sampled,
+        parent_sample_rate: transaction.parent_sample_rate
       }
 
       sampling_context.merge!(custom_sampling_context)
@@ -217,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)
 
@@ -226,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)
 
@@ -352,11 +376,11 @@ 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,
         baggage: propagation_context.baggage,
+        sample_rand: propagation_context.sample_rand,
         **options
       )
     end

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,129 +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
-    }
-
-    USER_ATTRIBUTES = {
-      "user.id" => :user_id,
-      "user.name" => :user_username,
-      "user.email" => :user_email
-    }
+
+    PARAMETER_PREFIX = "sentry.message.parameter"
 
     LEVELS = %i[trace debug info warn error fatal].freeze
 
-    attr_accessor :level, :body, :template, :attributes, :user
-
-    attr_reader :configuration, *SERIALIZEABLE_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
+    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] || {}
-      @contexts = {}
+      @attributes = options[:attributes] || {}
+      @origin = options[:origin]
+      @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
@@ -134,46 +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_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
@@ -185,11 +76,11 @@ module Sentry
 
         if parameters.is_a?(Hash)
           parameters.each do |key, value|
-            attributes["sentry.message.parameter.#{key}"] = value
+            attributes["#{PARAMETER_PREFIX}.#{key}"] = value
           end
         else
           parameters.each_with_index do |param, index|
-            attributes["sentry.message.parameter.#{index}"] = param
+            attributes["#{PARAMETER_PREFIX}.#{index}"] = param
           end
         end
       end
@@ -202,5 +93,9 @@ module Sentry
     def is_template?
       body.include?("%s") || TOKEN_REGEXP.match?(body)
     end
+
+    def has_parameters?
+      attributes.keys.any? { |key| key.start_with?(PARAMETER_PREFIX) }
+    end
   end
 end

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