sentry-ruby 6.2.0 → 6.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 768b3e936767873916ec042d50b4beec38446376593c8bd177ce8a94c0aa7140
-  data.tar.gz: c55f461f61ee4794134b0ebbeff58dc6c354de67ed9cd6cc5925335e20f31685
+  metadata.gz: ea228d904661a633e6bdfd3eb0ea4dc6ac129a0fed8f4a0e378e9a6e84de30e0
+  data.tar.gz: 71c6db91301a24a1b05afa798a249de12b31a5d68c45d16f138f73c0999b3183
 SHA512:
-  metadata.gz: '02192b9d9c6bf6a1c6698c1c793a5048373b31bcbee7d3f4d890fbb3d5969d3548d261eef133c35d14452fd8b366feddc58557779e25a5c0a43d23fe005cc900'
-  data.tar.gz: 8ff1c960e8e4f5f028d1243d0815eead580f259863b2740e3a6159e18238986cd9517203d7bd4c9a61b4389955068ff7ccb77f689e08baa09ac30c6d86d15681
+  metadata.gz: 07adab1cfe625b662c7cc89867225f40f07a36b0b73b70c916969ad5bac6ec1516bda791b767398e0b48246e5f23e31601d954cec9f724a79d33980e45d6e4d5
+  data.tar.gz: 5072c6873787d7e070050df7aeeb3e9040ca3add4c04f1c4e21c63d12fb241ee6615eced7f71fac5edeee4381d60272069bdc38ce967033ead0e2e76894b2573

data/Gemfile

@@ -7,8 +7,11 @@ eval_gemfile "../Gemfile.dev"
 
 gem "sentry-ruby", path: "./"
 
+ruby_version = Gem::Version.new(RUBY_VERSION)
+
 rack_version = ENV["RACK_VERSION"]
 rack_version = "3.0.0" if rack_version.nil?
+
 gem "rack", "~> #{Gem::Version.new(rack_version)}" unless rack_version == "0"
 
 redis_rb_version = ENV.fetch("REDIS_RB_VERSION", "5.0")
@@ -32,3 +35,24 @@ gem "webrick"
 gem "faraday"
 gem "excon"
 gem "webmock"
+
+group :sequel do
+  gem "sequel"
+
+  sqlite_version = if ruby_version >= Gem::Version.new("3.2")
+    "2.1.0"
+  elsif ruby_version >= Gem::Version.new("3.0")
+    "1.4.0"
+  else
+    "1.3.0"
+  end
+
+  platform :ruby do
+    gem "sqlite3", "~> #{sqlite_version}"
+  end
+
+  platform :jruby do
+    gem "activerecord-jdbcmysql-adapter"
+    gem "jdbc-sqlite3"
+  end
+end

data/README.md

@@ -105,7 +105,7 @@ To learn more about sampling transactions, please visit the [official documentat
 
 * [![Ruby docs](https://img.shields.io/badge/documentation-sentry.io-green.svg?label=ruby%20docs)](https://docs.sentry.io/platforms/ruby/)
 * [![Forum](https://img.shields.io/badge/forum-sentry-green.svg)](https://forum.sentry.io/c/sdks)
-* [![Discord Chat](https://img.shields.io/discord/621778831602221064?logo=discord&logoColor=ffffff&color=7389D8)](https://discord.gg/PXa5Apfe7K)
+* [![Discord Chat](https://img.shields.io/discord/621778831602221064?logo=discord&logoColor=ffffff&color=7389D8)](https://discord.gg/sentry)
 * [![Stack Overflow](https://img.shields.io/badge/stack%20overflow-sentry-green.svg)](https://stackoverflow.com/questions/tagged/sentry)
 * [![X Follow](https://img.shields.io/twitter/follow/sentry?label=sentry&style=social)](https://x.com/intent/follow?screen_name=sentry)
 

data/lib/sentry/client.rb

@@ -3,6 +3,8 @@
 require "sentry/transport"
 require "sentry/log_event"
 require "sentry/log_event_buffer"
+require "sentry/metric_event"
+require "sentry/metric_event_buffer"
 require "sentry/utils/uuid"
 require "sentry/utils/encoding_helper"
 
@@ -21,6 +23,9 @@ module Sentry
     # @!visibility private
     attr_reader :log_event_buffer
 
+    # @!visibility private
+    attr_reader :metric_event_buffer
+
     # @!macro configuration
     attr_reader :configuration
 
@@ -44,7 +49,11 @@ module Sentry
       @spotlight_transport = SpotlightTransport.new(configuration) if configuration.spotlight
 
       if configuration.enable_logs
-        @log_event_buffer = LogEventBuffer.new(configuration, self).start
+        @log_event_buffer = LogEventBuffer.new(configuration, self)
+      end
+
+      if configuration.enable_metrics
+        @metric_event_buffer = MetricEventBuffer.new(configuration, self)
       end
     end
 
@@ -98,7 +107,17 @@ module Sentry
     # @return [LogEvent]
     def buffer_log_event(event, scope)
       return unless event.is_a?(LogEvent)
-      @log_event_buffer.add_event(scope.apply_to_event(event))
+      @log_event_buffer.add_item(scope.apply_to_telemetry(event))
+      event
+    end
+
+    # Buffer a metric event to be sent later with other metrics in a single envelope
+    # @param event [MetricEvent] the metric event to be buffered
+    # @return [MetricEvent]
+    def buffer_metric_event(event, scope)
+      return unless event.is_a?(MetricEvent)
+      event = scope.apply_to_telemetry(event)
+      @metric_event_buffer.add_item(event)
       event
     end
 
@@ -115,6 +134,7 @@ module Sentry
       transport.flush if configuration.sending_to_dsn_allowed?
       spotlight_transport.flush if spotlight_transport
       @log_event_buffer&.flush
+      @metric_event_buffer&.flush
     end
 
     # Initializes an Event object with the given exception. Returns `nil` if the exception's class is excluded from reporting.
@@ -275,53 +295,6 @@ module Sentry
       raise
     end
 
-    # Send an envelope with batched logs
-    # @param log_events [Array<LogEvent>] the log events to be sent
-    # @api private
-    # @return [void]
-    def send_logs(log_events)
-      envelope = Envelope.new(
-        event_id: Sentry::Utils.uuid,
-        sent_at: Sentry.utc_now.iso8601,
-        dsn: configuration.dsn,
-        sdk: Sentry.sdk_meta
-      )
-
-      discarded_count = 0
-      envelope_items = []
-
-      if configuration.before_send_log
-        log_events.each do |log_event|
-          processed_log_event = configuration.before_send_log.call(log_event)
-
-          if processed_log_event
-            envelope_items << processed_log_event.to_h
-          else
-            discarded_count += 1
-          end
-        end
-
-        envelope_items
-      else
-        envelope_items = log_events.map(&:to_h)
-      end
-
-      envelope.add_item(
-        {
-          type: "log",
-          item_count: envelope_items.size,
-          content_type: "application/vnd.sentry.items.log+json"
-        },
-        { items: envelope_items }
-      )
-
-      send_envelope(envelope)
-
-      unless discarded_count.zero?
-        transport.record_lost_event(:before_send, "log_item", num: discarded_count)
-      end
-    end
-
     # Send an envelope directly to Sentry.
     # @param envelope [Envelope] the envelope to be sent.
     # @return [void]

data/lib/sentry/configuration.rb

@@ -14,6 +14,7 @@ require "sentry/interfaces/stacktrace_builder"
 require "sentry/logger"
 require "sentry/structured_logger"
 require "sentry/log_event_buffer"
+require "sentry/metric_event_buffer"
 
 module Sentry
   class Configuration
@@ -337,6 +338,32 @@ module Sentry
     # @return [Integer]
     attr_accessor :max_log_events
 
+    # Enable metrics collection, defaults to true
+    # @return [Boolean]
+    attr_accessor :enable_metrics
+
+    # Maximum number of metric events to buffer before sending
+    # @return [Integer]
+    attr_accessor :max_metric_events
+
+    # Optional Proc, called before sending a metric
+    # @example
+    #   config.before_send_metric = lambda do |metric|
+    #     # return nil to drop the metric
+    #     metric
+    #   end
+    # @return [Proc, nil]
+    attr_reader :before_send_metric
+
+    # Optional Proc, called to filter log messages before sending to Sentry
+    # @example
+    #   config.std_lib_logger_filter = lambda do |logger, message, level|
+    #     # Only send error and fatal logs to Sentry
+    #     [:error, :fatal].include?(level)
+    #   end
+    # @return [Proc, nil]
+    attr_reader :std_lib_logger_filter
+
     # these are not config options
     # @!visibility private
     attr_reader :errors, :gem_specs
@@ -499,9 +526,12 @@ module Sentry
       self.before_send_transaction = nil
       self.before_send_check_in = nil
       self.before_send_log = nil
+      self.before_send_metric = nil
+      self.std_lib_logger_filter = nil
       self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT
       self.traces_sampler = nil
       self.enable_logs = false
+      self.enable_metrics = true
 
       self.profiler_class = Sentry::Profiler
       self.profiles_sample_interval = DEFAULT_PROFILES_SAMPLE_INTERVAL
@@ -512,6 +542,7 @@ module Sentry
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
 
       self.max_log_events = LogEventBuffer::DEFAULT_MAX_EVENTS
+      self.max_metric_events = MetricEventBuffer::DEFAULT_MAX_METRICS
 
       run_callbacks(:after, :initialize)
 
@@ -581,12 +612,24 @@ module Sentry
       @before_send_check_in = value
     end
 
+    def before_send_metric=(value)
+      check_callable!("before_send_metric", value)
+
+      @before_send_metric = value
+    end
+
     def before_breadcrumb=(value)
       check_callable!("before_breadcrumb", value)
 
       @before_breadcrumb = value
     end
 
+    def std_lib_logger_filter=(value)
+      check_callable!("std_lib_logger_filter", value)
+
+      @std_lib_logger_filter = value
+    end
+
     def environment=(environment)
       @environment = environment.to_s
     end

data/lib/sentry/envelope/item.rb

@@ -15,7 +15,8 @@ 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", "log" then type
+      when "session", "attachment", "transaction", "profile", "span", "trace_metric" then type
+      when "log" then "log_item"
       when "sessions" then "session"
       when "check_in" then "monitor"
       when "event" then "error"

data/lib/sentry/hub.rb

@@ -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)
 

data/lib/sentry/interfaces/single_exception.rb

@@ -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/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_h
-      SERIALIZEABLE_ATTRIBUTES.each_with_object({}) do |name, memo|
-        memo[name] = serialize(name)
-      end
+      {
+        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,75 +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
-
-    def clear!
-      @pending_events.clear
-    end
-
-    private
-
-    def send_events
-      @client.send_logs(@pending_events)
-    rescue => e
-      log_debug("[LogEventBuffer] Failed to send logs: #{e.message}")
-    ensure
-      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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "sentry/metric_event"
+
+module Sentry
+  module Metrics
+    class << self
+      # 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
+
+      # 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
+
+      # 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
+end

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,10 +60,6 @@ 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
 
@@ -89,6 +85,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 = span ? span.get_trace_context : propagation_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]

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

data/lib/sentry/std_lib_logger.rb

@@ -37,6 +37,10 @@ module Sentry
         message = message.to_s.strip
 
         if !message.nil? && message != Sentry::Logger::PROGNAME && method = SEVERITY_MAP[severity]
+          if (filter = Sentry.configuration.std_lib_logger_filter) && !filter.call(self, message, method)
+            return result
+          end
+
           Sentry.logger.send(method, message, origin: ORIGIN)
         end
       end

data/lib/sentry/telemetry_event_buffer.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "sentry/threaded_periodic_worker"
+require "sentry/envelope"
+
+module Sentry
+  # TelemetryEventBuffer is a base class for buffering telemetry events (logs, metrics, etc.)
+  # and sending them to Sentry in a single envelope.
+  #
+  # This is used internally by the `Sentry::Client`.
+  #
+  # @!visibility private
+  class TelemetryEventBuffer < ThreadedPeriodicWorker
+    FLUSH_INTERVAL = 5 # seconds
+
+    # @!visibility private
+    attr_reader :pending_items, :envelope_type, :data_category, :thread
+
+    def initialize(configuration, client, event_class:, max_items:, max_items_before_drop:, envelope_type:, envelope_content_type:, before_send:)
+      super(configuration.sdk_logger, FLUSH_INTERVAL)
+
+      @client = client
+      @dsn = configuration.dsn
+      @debug = configuration.debug
+      @event_class = event_class
+      @max_items = max_items
+      @max_items_before_drop = max_items_before_drop
+      @envelope_type = envelope_type
+      @data_category = Sentry::Envelope::Item.data_category(@envelope_type)
+      @envelope_content_type = envelope_content_type
+      @before_send = before_send
+
+      @pending_items = []
+      @mutex = Mutex.new
+
+      log_debug("[#{self.class}] Initialized buffer with max_items=#{@max_items}, flush_interval=#{FLUSH_INTERVAL}s")
+    end
+
+    def flush
+      @mutex.synchronize do
+        return if empty?
+
+        log_debug("[#{self.class}] flushing #{size} #{@event_class}")
+
+        send_items
+      end
+
+      self
+    end
+    alias_method :run, :flush
+
+    def add_item(item)
+      @mutex.synchronize do
+        return unless ensure_thread
+
+        if size >= @max_items_before_drop
+          log_debug("[#{self.class}] exceeded max capacity, dropping event")
+          @client.transport.record_lost_event(:queue_overflow, @data_category)
+        else
+          @pending_items << item
+        end
+
+        send_items if size >= @max_items
+      end
+
+      self
+    end
+
+    def empty?
+      @pending_items.empty?
+    end
+
+    def size
+      @pending_items.size
+    end
+
+    def clear!
+      @pending_items.clear
+    end
+
+    private
+
+    def send_items
+      envelope = Envelope.new(
+        event_id: Sentry::Utils.uuid,
+        sent_at: Sentry.utc_now.iso8601,
+        dsn: @dsn,
+        sdk: Sentry.sdk_meta
+      )
+
+      discarded_count = 0
+      envelope_items = []
+
+      if @before_send
+        @pending_items.each do |item|
+          processed_item = @before_send.call(item)
+
+          if processed_item
+            envelope_items << processed_item.to_h
+          else
+            discarded_count += 1
+          end
+        end
+      else
+        envelope_items = @pending_items.map(&:to_h)
+      end
+
+      unless discarded_count.zero?
+        @client.transport.record_lost_event(:before_send, @data_category, num: discarded_count)
+      end
+
+      return if envelope_items.empty?
+
+      envelope.add_item(
+        {
+          type: @envelope_type,
+          item_count: envelope_items.size,
+          content_type: @envelope_content_type
+        },
+        { items: envelope_items }
+      )
+
+      @client.send_envelope(envelope)
+    rescue => e
+      log_error("[#{self.class}] Failed to send #{@event_class}", e, debug: @debug)
+    ensure
+      clear!
+    end
+  end
+end

data/lib/sentry/test_helper.rb

@@ -102,6 +102,13 @@ module Sentry
         .flat_map { |item| item.payload[:items] }
     end
 
+    def sentry_metrics
+      sentry_envelopes
+        .flat_map(&:items)
+        .select { |item| item.headers[:type] == "trace_metric" }
+        .flat_map { |item| item.payload[:items] }
+    end
+
     # Returns the last captured event object.
     # @return [Event, nil]
     def last_sentry_event

data/lib/sentry/utils/logging_helper.rb

@@ -6,26 +6,40 @@ module Sentry
     # @!visibility private
     def log_error(message, exception, debug: false)
       message = "#{message}: #{exception.message}"
-      message += "\n#{exception.backtrace.join("\n")}" if debug
+      message += "\n#{exception.backtrace.join("\n")}" if debug && exception.backtrace
 
-      sdk_logger&.error(LOGGER_PROGNAME) do
-        message
-      end
+      sdk_logger&.error(LOGGER_PROGNAME) { message }
+    rescue StandardError => e
+      log_to_stderr(e, message)
     end
 
     # @!visibility private
     def log_debug(message)
       sdk_logger&.debug(LOGGER_PROGNAME) { message }
+    rescue StandardError => e
+      log_to_stderr(e, message)
     end
 
     # @!visibility private
     def log_warn(message)
       sdk_logger&.warn(LOGGER_PROGNAME) { message }
+    rescue StandardError => e
+      log_to_stderr(e, message)
     end
 
     # @!visibility private
     def sdk_logger
       @sdk_logger ||= Sentry.sdk_logger
     end
+
+    # @!visibility private
+    def log_to_stderr(error, message)
+      error_msg = "Sentry SDK logging failed (#{error.class}: #{error.message}): #{message}".scrub(%q(<?>))
+      error_msg += "\n#{error.backtrace.map { |line| line.scrub(%q(<?>)) }.join("\n")}" if error.backtrace
+
+      $stderr.puts(error_msg)
+    rescue StandardError
+      # swallow everything – logging must never crash the app
+    end
   end
 end

data/lib/sentry/utils/telemetry_attributes.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Sentry
+  module Utils
+    module TelemetryAttributes
+      private
+
+      def attribute_hash(value)
+        case value
+        when String
+          { value: value, type: "string" }
+        when TrueClass, FalseClass
+          { value: value, type: "boolean" }
+        when Integer
+          { value: value, type: "integer" }
+        when Float
+          { value: value, type: "double" }
+        else
+          begin
+            { value: JSON.generate(value), type: "string" }
+          rescue
+            { value: value, type: "string" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentry/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sentry
-  VERSION = "6.2.0"
+  VERSION = "6.3.0"
 end

data/lib/sentry-ruby.rb

@@ -27,6 +27,7 @@ require "sentry/session_flusher"
 require "sentry/backpressure_monitor"
 require "sentry/cron/monitor_check_ins"
 require "sentry/vernier/profiler"
+require "sentry/metrics"
 
 [
   "sentry/rake",
@@ -627,6 +628,24 @@ module Sentry
       @logger ||= configuration.structured_logging.logger_class.new(configuration)
     end
 
+    # Returns the metrics API for capturing custom metrics.
+    #
+    # @example Enable metrics
+    #   Sentry.init do |config|
+    #     config.dsn = "YOUR_DSN"
+    #     config.enable_metrics = true
+    #   end
+    #
+    # @example Usage
+    #   Sentry.metrics.count("button.click", 1, attributes: { button_id: "submit" })
+    #   Sentry.metrics.distribution("response.time", 120.5, unit: "millisecond")
+    #   Sentry.metrics.gauge("cpu.usage", 75.2, unit: "percent")
+    #
+    # @return [Metrics] The metrics API
+    def metrics
+      Metrics
+    end
+
     ##### Helpers #####
 
     # @!visibility private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby
 version: !ruby/object:Gem::Version
-  version: 6.2.0
+  version: 6.3.0
 platform: ruby
 authors:
 - Sentry Team
@@ -106,6 +106,9 @@ files:
 - lib/sentry/log_event.rb
 - lib/sentry/log_event_buffer.rb
 - lib/sentry/logger.rb
+- lib/sentry/metric_event.rb
+- lib/sentry/metric_event_buffer.rb
+- lib/sentry/metrics.rb
 - lib/sentry/net/http.rb
 - lib/sentry/profiler.rb
 - lib/sentry/profiler/helpers.rb
@@ -118,11 +121,13 @@ files:
 - lib/sentry/release_detector.rb
 - lib/sentry/rspec.rb
 - lib/sentry/scope.rb
+- lib/sentry/sequel.rb
 - lib/sentry/session.rb
 - lib/sentry/session_flusher.rb
 - lib/sentry/span.rb
 - lib/sentry/std_lib_logger.rb
 - lib/sentry/structured_logger.rb
+- lib/sentry/telemetry_event_buffer.rb
 - lib/sentry/test_helper.rb
 - lib/sentry/threaded_periodic_worker.rb
 - lib/sentry/transaction.rb
@@ -143,21 +148,22 @@ files:
 - lib/sentry/utils/real_ip.rb
 - lib/sentry/utils/request_id.rb
 - lib/sentry/utils/sample_rand.rb
+- lib/sentry/utils/telemetry_attributes.rb
 - lib/sentry/utils/uuid.rb
 - lib/sentry/vernier/output.rb
 - lib/sentry/vernier/profiler.rb
 - lib/sentry/version.rb
 - sentry-ruby-core.gemspec
 - sentry-ruby.gemspec
-homepage: https://github.com/getsentry/sentry-ruby/tree/6.2.0/sentry-ruby
+homepage: https://github.com/getsentry/sentry-ruby/tree/6.3.0/sentry-ruby
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/getsentry/sentry-ruby/tree/6.2.0/sentry-ruby
-  source_code_uri: https://github.com/getsentry/sentry-ruby/tree/6.2.0/sentry-ruby
-  changelog_uri: https://github.com/getsentry/sentry-ruby/blob/6.2.0/CHANGELOG.md
+  homepage_uri: https://github.com/getsentry/sentry-ruby/tree/6.3.0/sentry-ruby
+  source_code_uri: https://github.com/getsentry/sentry-ruby/tree/6.3.0/sentry-ruby
+  changelog_uri: https://github.com/getsentry/sentry-ruby/blob/6.3.0/CHANGELOG.md
   bug_tracker_uri: https://github.com/getsentry/sentry-ruby/issues
-  documentation_uri: http://www.rubydoc.info/gems/sentry-ruby/6.2.0
+  documentation_uri: http://www.rubydoc.info/gems/sentry-ruby/6.3.0
 rdoc_options: []
 require_paths:
 - lib