sentry-ruby 7.0.0 → 7.2.0

data/lib/sentry/integrable.rb

@@ -32,5 +32,17 @@ module Sentry
       options[:hint][:integration] = integration_name
       Sentry.capture_check_in(slug, status, **options, &block)
     end
+
+    def count(name, value: 1, attributes: nil)
+      Sentry.metrics.count(name, value: value, attributes: attributes, integration: integration_name)
+    end
+
+    def gauge(name, value, unit: nil, attributes: nil)
+      Sentry.metrics.gauge(name, value, unit: unit, attributes: attributes, integration: integration_name)
+    end
+
+    def distribution(name, value, unit: nil, attributes: nil)
+      Sentry.metrics.distribution(name, value, unit: unit, attributes: attributes, integration: integration_name)
+    end
   end
 end

data/lib/sentry/log_event_buffer.rb

@@ -21,7 +21,7 @@ module Sentry
         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
+        before_send: :before_send_log
       )
     end
   end

data/lib/sentry/metric_event.rb

@@ -6,7 +6,7 @@ module Sentry
   class MetricEvent
     include Sentry::Utils::TelemetryAttributes
 
-    attr_reader :name, :type, :value, :unit, :timestamp, :trace_id, :span_id, :attributes
+    attr_reader :name, :type, :value, :unit, :timestamp, :trace_id, :span_id, :attributes, :integration_meta
     attr_writer :trace_id, :span_id, :attributes
 
     def initialize(
@@ -14,13 +14,15 @@ module Sentry
       type:,
       value:,
       unit: nil,
-      attributes: nil
+      attributes: nil,
+      integration_meta: nil
     )
       @name = name
       @type = type
       @value = value
       @unit = unit
       @attributes = attributes || {}
+      @integration_meta = integration_meta
 
       @timestamp = Sentry.utc_now
       @trace_id = nil

data/lib/sentry/metric_event_buffer.rb

@@ -21,7 +21,7 @@ module Sentry
         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
+        before_send: :before_send_metric
       )
     end
   end

data/lib/sentry/metrics.rb

@@ -9,15 +9,17 @@ module Sentry
       # @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)
+      # @param integration [String, Symbol, nil] registered integration emitting the metric (optional)
       # @return [void]
-      def count(name, value: 1, attributes: nil)
+      def count(name, value: 1, attributes: nil, integration: nil)
         return unless Sentry.initialized?
 
         Sentry.get_current_hub.capture_metric(
           name: name,
           type: :counter,
           value: value,
-          attributes: attributes
+          attributes: attributes,
+          integration: integration
         )
       end
 
@@ -26,8 +28,9 @@ module Sentry
       # @param value [Numeric] the gauge value
       # @param unit [String, nil] the metric unit (optional)
       # @param attributes [Hash, nil] additional attributes for the metric (optional)
+      # @param integration [String, Symbol, nil] registered integration emitting the metric (optional)
       # @return [void]
-      def gauge(name, value, unit: nil, attributes: nil)
+      def gauge(name, value, unit: nil, attributes: nil, integration: nil)
         return unless Sentry.initialized?
 
         Sentry.get_current_hub.capture_metric(
@@ -35,7 +38,8 @@ module Sentry
           type: :gauge,
           value: value,
           unit: unit,
-          attributes: attributes
+          attributes: attributes,
+          integration: integration
         )
       end
 
@@ -44,8 +48,9 @@ module Sentry
       # @param value [Numeric] the distribution value
       # @param unit [String, nil] the metric unit (optional)
       # @param attributes [Hash, nil] additional attributes for the metric (optional)
+      # @param integration [String, Symbol, nil] registered integration emitting the metric (optional)
       # @return [void]
-      def distribution(name, value, unit: nil, attributes: nil)
+      def distribution(name, value, unit: nil, attributes: nil, integration: nil)
         return unless Sentry.initialized?
 
         Sentry.get_current_hub.capture_metric(
@@ -53,7 +58,8 @@ module Sentry
           type: :distribution,
           value: value,
           unit: unit,
-          attributes: attributes
+          attributes: attributes,
+          integration: integration
         )
       end
     end

data/lib/sentry/rufus_scheduler.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Sentry
+  # Sends Crons check-ins for rufus-scheduler `cron`, `every` and `interval` jobs.
+  # Enable with `config.enabled_patches << :rufus_scheduler`.
+  module RufusScheduler
+    module Job
+      protected
+
+      def do_call(time, do_rescue)
+        return super unless Sentry.initialized? && (monitor = sentry_monitor)
+
+        slug, monitor_config = monitor
+        check_in_id = Sentry.capture_check_in(slug, :in_progress, monitor_config: monitor_config)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        begin
+          # Run without rufus's rescue so the error is seen, then handle it like Job#do_call.
+          ret = super(time, false)
+        rescue Exception => e
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+          Sentry.capture_check_in(slug, :error, check_in_id: check_in_id, duration: duration, monitor_config: monitor_config)
+
+          raise unless do_rescue && e.is_a?(StandardError)
+          return if e.is_a?(::Rufus::Scheduler::Job::KillSignal)
+
+          return @scheduler.on_error(self, e)
+        end
+
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        Sentry.capture_check_in(slug, :ok, check_in_id: check_in_id, duration: duration, monitor_config: monitor_config)
+
+        ret
+      end
+
+      private
+
+      def sentry_monitor
+        return @sentry_monitor if defined?(@sentry_monitor)
+
+        @sentry_monitor = Sentry::RufusScheduler.monitor_for(self)
+      rescue StandardError => e
+        Sentry.sdk_logger.error(Sentry::LOGGER_PROGNAME) { "Not monitoring rufus-scheduler job #{id}: #{e.class}: #{e.message}" }
+        @sentry_monitor = nil
+      end
+    end
+
+    class << self
+      # Returns [slug, monitor_config], or nil for jobs that aren't monitored (like `at`/`in`).
+      def monitor_for(job)
+        return unless job.is_a?(::Rufus::Scheduler::RepeatJob)
+        return if job.opts[:sentry_monitor] == false
+        return if sidekiq_scheduler_job?(job)
+
+        slug = slug_for(job)
+        unless slug
+          Sentry.sdk_logger.warn(Sentry::LOGGER_PROGNAME) do
+            "Not monitoring rufus-scheduler job #{job.id} at #{job.source_location&.join(":")}: " \
+              "pass `name:` to give it a stable monitor slug."
+          end
+          return
+        end
+
+        [slug, monitor_config_for(job)]
+      end
+
+      private
+
+      # sidekiq-scheduler jobs are monitored by the :sidekiq_scheduler patch.
+      def sidekiq_scheduler_job?(job)
+        file, _ = job.callable.source_location if job.callable.respond_to?(:source_location)
+        file&.end_with?("sidekiq-scheduler/scheduler.rb")
+      end
+
+      # Job ids are random per process and block paths change between deploys,
+      # so the slug comes from `name:`, then the handler method or class.
+      def slug_for(job)
+        handler = job.handler
+        source =
+          if job.name
+            job.name.to_s
+          elsif handler.is_a?(Method)
+            # The receiver's class, not the method owner, so inherited and mixin methods get distinct slugs.
+            namespace = handler.receiver.is_a?(Module) ? handler.receiver : handler.receiver.class
+            [namespace == Object ? nil : namespace.name, handler.name].compact.join("::")
+          elsif !handler.is_a?(Proc)
+            handler.class.name
+          end
+        return unless source
+
+        Sentry::Cron::Slug.from(source)
+      end
+
+      def monitor_config_for(job)
+        case job
+        when ::Rufus::Scheduler::CronJob
+          Sentry::Cron::FugitSchedule.from_cron(job.cron_line)
+        when ::Rufus::Scheduler::EveryJob
+          Sentry::Cron::FugitSchedule.from_seconds(job.frequency)
+        end
+        # IntervalJob waits `interval` after each run ends, so it has no fixed
+        # schedule to monitor against.
+      end
+    end
+  end
+end
+
+Sentry.register_patch(:rufus_scheduler) do |config|
+  # Load rufus-scheduler in case it's required after Sentry.init.
+  begin
+    require "rufus-scheduler"
+  rescue LoadError
+  end
+
+  if defined?(::Rufus::Scheduler::RepeatJob)
+    ::Rufus::Scheduler::Job.prepend(Sentry::RufusScheduler::Job) unless ::Rufus::Scheduler::Job.ancestors.include?(Sentry::RufusScheduler::Job)
+  else
+    config.sdk_logger.warn(Sentry::LOGGER_PROGNAME) { "You tried to enable the rufus-scheduler integration but the `rufus-scheduler` gem was not detected." }
+  end
+end

data/lib/sentry/scope.rb

@@ -9,6 +9,7 @@ require "etc"
 module Sentry
   class Scope
     include ArgumentCheckingHelper
+    include CallbackHelper
 
     ATTRIBUTES = [
       :transaction_name,
@@ -71,7 +72,8 @@ module Sentry
 
       unless all_event_processors.empty?
         all_event_processors.each do |processor_block|
-          event = processor_block.call(event, hint)
+          event = safe_dispatch_callback("event_processor", processor_block, [event, hint])
+          return unless event
         end
       end
 
@@ -102,8 +104,10 @@ module Sentry
       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"]
+      sdk_meta = telemetry.respond_to?(:integration_meta) ? telemetry.integration_meta : nil
+      sdk_meta ||= Sentry.sdk_meta
+      telemetry.attributes["sentry.sdk.name"] ||= sdk_meta[:name] || sdk_meta["name"]
+      telemetry.attributes["sentry.sdk.version"] ||= sdk_meta[:version] || 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

data/lib/sentry/session_flusher.rb

@@ -35,6 +35,13 @@ module Sentry
 
     private
 
+    def reset_if_forked
+      return unless super
+
+      @mutex = Mutex.new
+      @pending_aggregates = {}
+    end
+
     def init_aggregates(aggregation_key)
       aggregates = { started: aggregation_key.iso8601 }
       Session::AGGREGATE_STATUSES.each { |k| aggregates[k] = 0 }

data/lib/sentry/std_lib_logger.rb

@@ -4,6 +4,8 @@ module Sentry
   # Ruby Logger support Add commentMore actions
   # intercepts any logger instance and send the log to Sentry too.
   module StdLibLogger
+    include CallbackHelper
+
     SEVERITY_MAP = {
       0 => :debug,
       1 => :info,
@@ -37,8 +39,12 @@ 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
+          if filter = Sentry.configuration.std_lib_logger_filter
+            return result unless safe_dispatch_callback(
+              "std_lib_logger_filter",
+              filter,
+              [self, message, method]
+            )
           end
 
           Sentry.logger.send(method, message, origin: ORIGIN)

data/lib/sentry/telemetry_event_buffer.rb

@@ -12,7 +12,10 @@ module Sentry
   #
   # @!visibility private
   class TelemetryEventBuffer < ThreadedPeriodicWorker
+    include CallbackHelper
+
     FLUSH_INTERVAL = 5 # seconds
+    FLUSH_TIMEOUT = 2 # seconds
 
     # @!visibility private
     attr_reader :pending_items, :envelope_type, :data_category, :thread
@@ -21,6 +24,7 @@ module Sentry
       super(configuration.sdk_logger, FLUSH_INTERVAL)
 
       @client = client
+      @configuration = configuration
       @dsn = configuration.dsn
       @debug = configuration.debug
       @event_class = event_class
@@ -38,39 +42,44 @@ module Sentry
     end
 
     def flush
-      @mutex.synchronize do
-        return if empty?
-
-        log_debug("[#{self.class}] flushing #{size} #{@event_class}")
+      return unless thread&.alive? && wake
 
-        send_items
-      end
+      wait_until_idle(FLUSH_TIMEOUT)
+    end
 
-      self
+    def run
+      flush_pending_items
     end
-    alias_method :run, :flush
 
     def add_item(item)
+      # the buffer thread can never add telemetry itself to prevent recursion
+      return self if Thread.current == thread
+      return unless ensure_thread
+
       # Prevent ThreadError from re-entrant locking (e.g. transport instrumentation calling Sentry.metrics.*)
       return self if @mutex.owned?
 
-      @mutex.synchronize do
-        return unless ensure_thread
-
+      dropped = false
+      size_exceeded = @mutex.synchronize do
         if size >= @max_items_before_drop
-          log_debug("[#{self.class}] exceeded max capacity, dropping event")
-          @client.transport.record_lost_event(
-            :queue_overflow,
-            @data_category,
-            num_bytes: JSON.generate(item.to_h).bytesize
-          )
+          dropped = true
         else
           @pending_items << item
         end
 
-        send_items if size >= @max_items
+        size >= @max_items
+      end
+
+      if dropped
+        log_debug("[#{self.class}] exceeded max capacity, dropping event")
+        @client.transport.record_lost_event(
+          :queue_overflow,
+          @data_category,
+          num_bytes: JSON.generate(item.to_h).bytesize
+        )
       end
 
+      wake if size_exceeded
       self
     end
 
@@ -88,21 +97,40 @@ module Sentry
 
     private
 
-    def send_items
-      envelope = Envelope.new(
-        event_id: Sentry::Utils.uuid,
-        sent_at: Sentry.utc_now.iso8601,
-        dsn: @dsn,
-        sdk: Sentry.sdk_meta
-      )
+    def reset_if_forked
+      return unless super
+
+      # Discard items inherited from the parent to avoid duplicate delivery.
+      @mutex = Mutex.new
+      @pending_items = []
+    end
+
+    def flush_pending_items
+      pending_items = @mutex.synchronize do
+        next if @pending_items.empty?
+
+        items = @pending_items
+        @pending_items = []
+        items
+      end
+
+      return unless pending_items
+
+      log_debug("[#{self.class}] flushing #{pending_items.size} #{@event_class}")
+      send_items(pending_items)
+      self
+    end
+
+    def send_items(pending_items)
+      envelope = Envelope.new(sent_at: Sentry.utc_now.iso8601)
 
       discarded_count = 0
       discarded_bytes = 0
       envelope_items = []
 
-      if @before_send
-        @pending_items.each do |item|
-          processed_item = @before_send.call(item)
+      if callback = @configuration.send(@before_send)
+        pending_items.each do |item|
+          processed_item = safe_dispatch_callback(@before_send.to_s, callback, [item])
 
           if processed_item
             envelope_items << processed_item.to_h
@@ -112,7 +140,7 @@ module Sentry
           end
         end
       else
-        envelope_items = @pending_items.map(&:to_h)
+        envelope_items = pending_items.map(&:to_h)
       end
 
       unless discarded_count.zero?
@@ -133,8 +161,6 @@ module Sentry
       @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

@@ -127,6 +127,8 @@ module Sentry
     end
 
     def sentry_logs
+      Sentry.get_current_client&.log_event_buffer&.flush
+
       sentry_envelopes
         .flat_map(&:items)
         .select { |item| item.headers[:type] == "log" }
@@ -134,6 +136,8 @@ module Sentry
     end
 
     def sentry_metrics
+      Sentry.get_current_client&.metric_event_buffer&.flush
+
       sentry_envelopes
         .flat_map(&:items)
         .select { |item| item.headers[:type] == "trace_metric" }

data/lib/sentry/threaded_periodic_worker.rb

@@ -4,41 +4,118 @@ module Sentry
   class ThreadedPeriodicWorker
     include LoggingHelper
 
+    # @!visibility private
+    attr_reader :thread, :thread_mutex, :idle_condition
+
     def initialize(sdk_logger, interval)
+      @process_id = Process.pid
       @thread = nil
       @exited = false
       @interval = interval
       @sdk_logger = sdk_logger
+
+      @thread_mutex = Mutex.new
+      @wake_condition = ConditionVariable.new
+      @idle_condition = ConditionVariable.new
+
+      @woken = false
+      @running = false
     end
 
     def ensure_thread
-      return false if @exited
-      return true if @thread&.alive?
+      reset_if_forked
 
-      @thread = Thread.new do
-        loop do
-          sleep(@interval)
-          run
-        end
-      end
+      @thread_mutex.synchronize do
+        return false if @exited
+        return true if @thread&.alive?
 
-      true
+        @thread = Thread.new { worker_loop }
+
+        true
+      end
     rescue ThreadError
+      @thread_mutex.synchronize { @exited = true }
       log_debug("[#{self.class.name}] thread creation failed")
-      @exited = true
       false
     end
 
+    def wake
+      @thread_mutex.synchronize do
+        next false if @exited
+
+        @woken = true
+        @wake_condition.signal
+        true
+      end
+    end
+
+    def wait_until_idle(timeout = nil)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout if timeout
+
+      @thread_mutex.synchronize do
+        while !@exited && (@running || @woken)
+          remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC) if deadline
+          return false if remaining && remaining <= 0
+
+          @idle_condition.wait(@thread_mutex, remaining)
+        end
+
+        true
+      end
+    end
+
     def kill
-      @exited = true
+      thread = @thread_mutex.synchronize do
+        @exited = true
+        @woken = false
+        @idle_condition.broadcast
+        @thread
+      end
 
       # Only a started worker has a thread to kill (and to log about).
       # Guarding here keeps a never-started worker's teardown silent, so
       # killing one during test reset can't emit a stray debug line.
-      return unless @thread
+      return unless thread
 
       log_debug("[#{self.class.name}] thread killed")
-      @thread.kill
+      thread.kill
+    end
+
+    private
+
+    def reset_if_forked
+      return false if @process_id == Process.pid
+
+      @process_id = Process.pid
+      @thread = nil
+      @exited = false
+      @woken = false
+      @running = false
+      @thread_mutex = Mutex.new
+      @wake_condition = ConditionVariable.new
+      @idle_condition = ConditionVariable.new
+      true
+    end
+
+    def worker_loop
+      loop do
+        @thread_mutex.synchronize do
+          @wake_condition.wait(@thread_mutex, @interval) unless @woken
+          @woken = false
+          @running = true
+        end
+
+        begin
+          run
+        rescue Exception => e
+          log_error("[#{self.class.name}] run failed", e)
+        ensure
+          @thread_mutex.synchronize do
+            @running = false
+            @idle_condition.broadcast
+          end
+        end
+      end
     end
   end
 end

data/lib/sentry/transaction.rb

@@ -14,6 +14,7 @@ module Sentry
     SOURCES = %i[custom url route view component task]
 
     include LoggingHelper
+    include CallbackHelper
 
     # The name of the transaction.
     # @return [String]
@@ -142,7 +143,12 @@ module Sentry
 
       sample_rate =
         if configuration.traces_sampler.is_a?(Proc)
-          configuration.traces_sampler.call(sampling_context)
+          safe_dispatch_callback(
+            "traces_sampler",
+            configuration.traces_sampler,
+            [sampling_context],
+            fallback: configuration.traces_sample_rate
+          )
         elsif !sampling_context[:parent_sampled].nil?
           sampling_context[:parent_sampled]
         else

data/lib/sentry/transport/debug_transport.rb

@@ -27,6 +27,11 @@ module Sentry
       backend.send_event(event)
     end
 
+    def send_envelope(envelope)
+      log_envelope(envelope)
+      backend.send_envelope(envelope)
+    end
+
     def log_envelope(envelope)
       envelope_json = {
         timestamp: Time.now.utc.iso8601,
@@ -36,13 +41,13 @@ module Sentry
         end
       }
 
-      File.open(log_file, "a") { |file| file << JSON.dump(envelope_json) << "\n" }
+      File.open(log_file, "a") { |file| file.write("#{JSON.dump(envelope_json)}\n") }
     end
 
     def logged_envelopes
       return [] unless File.exist?(log_file)
 
-      File.readlines(log_file).map do |line|
+      File.readlines(log_file).select { |line| fully_written?(line) }.map do |line|
         JSON.parse(line)
       end
     end
@@ -54,6 +59,10 @@ module Sentry
 
     private
 
+    def fully_written?(line)
+      line.end_with?("\n")
+    end
+
     def initialize_backend(configuration)
       backend = configuration.dsn.local? ? DummyTransport : HTTPTransport
       backend.new(configuration)