Deprecate config.metrics and Sentry::Metrics

Author: sl0thentr0py

CHANGELOG.md

@@ -6,6 +6,28 @@
 - Revert "[rails] support string errors in error reporter (#2464)" ([#2533](https://github.com/getsentry/sentry-ruby/pull/2533))
 - Removed unnecessary warning about missing `stackprof` when Vernier is configured as the profiler ([#2537](https://github.com/getsentry/sentry-ruby/pull/2537))
 
+### Miscellaneous
+
+- Deprecate all Metrics related APIs [#2539](https://github.com/getsentry/sentry-ruby/pull/2539)
+    
+    Sentry [no longer has the Metrics Beta offering](https://sentry.zendesk.com/hc/en-us/articles/26369339769883-Metrics-Beta-Ended-on-October-7th) so
+    all the following APIs linked to Metrics have been deprecated and will be removed in the next major.
+
+    ```ruby
+    Sentry.init do |config|
+      # ...
+      config.metrics.enabled = true
+      config.metrics.enable_code_locations = true
+      config.metrics.before_emit = lambda {}
+    end
+
+    Sentry::Metrics.increment('button_click')
+    Sentry::Metrics.distribution('page_load', 15.0, unit: 'millisecond')
+    Sentry::Metrics.gauge('page_load', 15.0, unit: 'millisecond')
+    Sentry::Metrics.set('user_view', 'jane')
+    Sentry::Metrics.timing('how_long') { sleep(1) }
+    ```
+
 ## 5.22.3
 
 ### Bug Fixes

sentry-ruby/lib/sentry-ruby.rb

@@ -83,7 +83,8 @@ def exception_locals_tp
     attr_reader :backpressure_monitor
 
     # @!attribute [r] metrics_aggregator
-    #   @return [Metrics::Aggregator, nil]
+    # @deprecated
+    # @return [nil]
     attr_reader :metrics_aggregator
 
     ##### Patch Registration #####
@@ -241,7 +242,7 @@ def init(&block)
       @background_worker = Sentry::BackgroundWorker.new(config)
       @session_flusher = config.session_tracking? ? Sentry::SessionFlusher.new(config, client) : nil
       @backpressure_monitor = config.enable_backpressure_handling ? Sentry::BackpressureMonitor.new(config, client) : nil
-      @metrics_aggregator = config.metrics.enabled ? Sentry::Metrics::Aggregator.new(config, client) : nil
+      @metrics_aggregator = nil
       exception_locals_tp.enable if config.include_local_variables
       at_exit { close }
     end
@@ -262,12 +263,6 @@ def close
         @backpressure_monitor = nil
       end
 
-      if @metrics_aggregator
-        @metrics_aggregator.flush(force: true)
-        @metrics_aggregator.kill
-        @metrics_aggregator = nil
-      end
-
       if client = get_current_client
         client.flush
 

sentry-ruby/lib/sentry/configuration.rb

@@ -245,6 +245,7 @@ def capture_exception_frame_locals=(value)
     attr_reader :cron
 
     # Metrics related configuration.
+    # @deprecated It will be removed in the next major release.
     # @return [Metrics::Configuration]
     attr_reader :metrics
 
@@ -450,7 +451,7 @@ def initialize
 
       @transport = Transport::Configuration.new
       @cron = Cron::Configuration.new
-      @metrics = Metrics::Configuration.new
+      @metrics = Metrics::Configuration.new(self.logger)
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
 
       run_post_initialization_callbacks

sentry-ruby/lib/sentry/cron/monitor_check_ins.rb

@@ -14,12 +14,12 @@ def perform(*args, **opts)
                                                 :in_progress,
                                                 monitor_config: monitor_config)
 
-          start = Metrics::Timing.duration_start
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
           begin
             # need to do this on ruby <= 2.6 sadly
             ret = method(:perform).super_method.arity == 0 ? super() : super
-            duration = Metrics::Timing.duration_end(start)
+            duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
 
             Sentry.capture_check_in(slug,
                                     :ok,
@@ -29,7 +29,7 @@ def perform(*args, **opts)
 
             ret
           rescue Exception
-            duration = Metrics::Timing.duration_end(start)
+            duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
 
             Sentry.capture_check_in(slug,
                                     :error,

sentry-ruby/lib/sentry/interfaces/stacktrace_builder.rb

@@ -75,14 +75,6 @@ def build(backtrace:, &frame_callback)
       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)

sentry-ruby/lib/sentry/metrics.rb

@@ -1,55 +1,14 @@
 # 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"
-
 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)
-        Sentry.metrics_aggregator&.add(:c, key, value, unit: unit, tags: tags, timestamp: timestamp)
-      end
-
-      def distribution(key, value, unit: "none", tags: {}, timestamp: nil)
-        Sentry.metrics_aggregator&.add(:d, key, value, unit: unit, tags: tags, timestamp: timestamp)
-      end
-
-      def set(key, value, unit: "none", tags: {}, timestamp: nil)
-        Sentry.metrics_aggregator&.add(:s, key, value, unit: unit, tags: tags, timestamp: timestamp)
-      end
-
-      def gauge(key, value, unit: "none", tags: {}, timestamp: nil)
-        Sentry.metrics_aggregator&.add(:g, key, value, unit: unit, tags: tags, timestamp: timestamp)
-      end
-
-      def timing(key, unit: "second", tags: {}, timestamp: nil, &block)
-        return unless block_given?
-        return yield unless DURATION_UNITS.include?(unit)
+      def method_missing(m, *args, &block)
+        return unless Sentry.initialized?
 
-        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]
+        Sentry.logger.warn(LOGGER_PROGNAME) do
+          "`Sentry::Metrics` is now deprecated and will be removed in the next major."
         end
-
-        Sentry.metrics_aggregator&.add(:d, key, value, unit: unit, tags: tags, timestamp: timestamp)
-        result
       end
     end
   end

sentry-ruby/lib/sentry/metrics/aggregator.rb

@@ -4,43 +4,16 @@
   module Metrics
     class Configuration
       include ArgumentCheckingHelper
+      include LoggingHelper
 
-      # Enable metrics usage.
-      # Starts a new {Sentry::Metrics::Aggregator} instance to aggregate metrics
-      # and a thread to aggregate flush every 5 seconds.
-      # @return [Boolean]
-      attr_accessor :enabled
-
-      # Enable code location reporting.
-      # Will be sent once per day.
-      # True by default.
-      # @return [Boolean]
-      attr_accessor :enable_code_locations
-
-      # Optional Proc, called before emitting a metric to the aggregator.
-      # Use it to filter keys (return false/nil) or update tags.
-      # Make sure to return true at the end.
-      #
-      # @example
-      #   config.metrics.before_emit = lambda do |key, tags|
-      #     return nil if key == 'foo'
-      #     tags[:bar] = 42
-      #     tags.delete(:baz)
-      #     true
-      #   end
-      #
-      # @return [Proc, nil]
-      attr_reader :before_emit
-
-      def initialize
-        @enabled = false
-        @enable_code_locations = true
+      def initialize(logger)
+        @logger = logger
       end
 
-      def before_emit=(value)
-        check_callable!("metrics.before_emit", value)
-
-        @before_emit = value
+      def method_missing(m, *args, &block)
+        log_warn <<~MSG
+          `config.metrics` is now deprecated and will be removed in the next major.
+        MSG
       end
     end
   end

sentry-ruby/lib/sentry/metrics/configuration.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "securerandom"
-require "sentry/metrics/local_aggregator"
 
 module Sentry
   class Span
@@ -187,9 +186,6 @@ def to_hash
         origin: @origin
       }
 
-      summary = metrics_summary
-      hash[:_metrics_summary] = summary if summary
-
       hash
     end
 
@@ -306,14 +302,5 @@ def set_tag(key, value)
     def set_origin(origin)
       @origin = origin
     end
-
-    # Collects gauge metrics on the span for metric summaries.
-    def metrics_local_aggregator
-      @metrics_local_aggregator ||= Sentry::Metrics::LocalAggregator.new
-    end
-
-    def metrics_summary
-      @metrics_local_aggregator&.to_hash
-    end
   end
 end

sentry-ruby/lib/sentry/metrics/counter_metric.rb

@@ -17,7 +17,8 @@ class TransactionEvent < Event
     # @return [Hash, nil]
     attr_accessor :profile
 
-    # @return [Hash, nil]
+    # @return [nil]
+    # @deprecated
     attr_accessor :metrics_summary
 
     def initialize(transaction:, **options)
@@ -32,7 +33,6 @@ def initialize(transaction:, **options)
       self.tags = transaction.tags
       self.dynamic_sampling_context = transaction.get_baggage.dynamic_sampling_context
       self.measurements = transaction.measurements
-      self.metrics_summary = transaction.metrics_summary
 
       finished_spans = transaction.span_recorder.spans.select { |span| span.timestamp && span != transaction }
       self.spans = finished_spans.map(&:to_hash)
@@ -53,7 +53,6 @@ def to_hash
       data[:spans] = @spans.map(&:to_hash) if @spans
       data[:start_timestamp] = @start_timestamp
       data[:measurements] = @measurements
-      data[:_metrics_summary] = @metrics_summary if @metrics_summary
       data
     end
 

sentry-ruby/lib/sentry/metrics/distribution_metric.rb

@@ -276,16 +276,6 @@ def sentry_context
       event = subject.event_from_transaction(transaction)
       expect(event.contexts).to include({ foo: { bar: 42 } })
     end
-
-    it 'adds metric summary on transaction if any' do
-      key = [:c, 'incr', 'none', []]
-      transaction.metrics_local_aggregator.add(key, 10)
-      hash = subject.event_from_transaction(transaction).to_hash
-
-      expect(hash[:_metrics_summary]).to eq({
-        'c:incr@none' => { count: 1, max: 10.0, min: 10.0, sum: 10.0, tags: {} }
-      })
-    end
   end
 
   describe "#event_from_exception" do

sentry-ruby/lib/sentry/metrics/gauge_metric.rb

@@ -99,17 +99,4 @@
       end
     end
   end
-
-  describe '#metrics_code_location' do
-    it 'builds metrics code location hash for line' do
-      hash = subject.metrics_code_location(backtrace.first)
-
-      expect(hash[:filename]).to match(/stacktrace_test_fixture.rb/)
-      expect(hash[:function]).to eq("bar")
-      expect(hash[:lineno]).to eq(8)
-      expect(hash[:pre_context]).to eq(["end\n", "\n", "def bar\n"])
-      expect(hash[:context_line]).to eq("  baz\n")
-      expect(hash[:post_context]).to eq(["end\n", nil, nil])
-    end
-  end
 end

sentry-ruby/lib/sentry/metrics/local_aggregator.rb

@@ -3,11 +3,18 @@
 require 'spec_helper'
 
 RSpec.describe Sentry::Metrics::Configuration do
-  describe '#before_emit=' do
-    it 'raises error when setting before_emit to anything other than callable or nil' do
-      subject.before_emit = -> { }
-      subject.before_emit = nil
-      expect { subject.before_emit = true }.to raise_error(ArgumentError, 'metrics.before_emit must be callable (or nil to disable)')
+  let(:stringio) { StringIO.new }
+  subject { described_class.new(::Logger.new(stringio)) }
+
+  %i[enabled enable_code_locations before_emit].each do |method|
+    describe "#{method}=" do
+      it 'logs deprecation warning' do
+        subject.send("#{method}=", true)
+
+        expect(stringio.string).to include(
+          "WARN -- sentry: `config.metrics` is now deprecated and will be removed in the next major."
+        )
+      end
     end
   end
 end

sentry-ruby/lib/sentry/metrics/metric.rb

@@ -3,136 +3,32 @@
 require 'spec_helper'
 
 RSpec.describe Sentry::Metrics do
+  let(:stringio) { StringIO.new }
+
   before do
     perform_basic_setup do |config|
-      config.metrics.enabled = true
+      config.logger = ::Logger.new(stringio)
     end
   end
 
   let(:aggregator) { Sentry.metrics_aggregator }
   let(:fake_time) { Time.new(2024, 1, 1, 1, 1, 3) }
 
-  describe '.increment' do
-    it 'passes default value of 1.0 with only key' do
-      expect(aggregator).to receive(:add).with(
-        :c,
-        'foo',
-        1.0,
-        unit: 'none',
-        tags: {},
-        timestamp: nil
-      )
-
-      described_class.increment('foo')
-    end
-
-    it 'passes through args to aggregator' do
-      expect(aggregator).to receive(:add).with(
-        :c,
-        'foo',
-        5.0,
-        unit: 'second',
-        tags: { fortytwo: 42 },
-        timestamp: fake_time
-      )
-
-      described_class.increment('foo', 5.0, unit: 'second', tags: { fortytwo: 42 }, timestamp: fake_time)
-    end
-  end
-
-  describe '.distribution' do
-    it 'passes through args to aggregator' do
-      expect(aggregator).to receive(:add).with(
-        :d,
-        'foo',
-        5.0,
-        unit: 'second',
-        tags: { fortytwo: 42 },
-        timestamp: fake_time
-      )
-
-      described_class.distribution('foo', 5.0, unit: 'second', tags: { fortytwo: 42 }, timestamp: fake_time)
-    end
-  end
-
-  describe '.set' do
-    it 'passes through args to aggregator' do
-      expect(aggregator).to receive(:add).with(
-        :s,
-        'foo',
-        'jane',
-        unit: 'none',
-        tags: { fortytwo: 42 },
-        timestamp: fake_time
-      )
-
-      described_class.set('foo', 'jane', tags: { fortytwo: 42 }, timestamp: fake_time)
-    end
-  end
-
-  describe '.gauge' do
-    it 'passes through args to aggregator' do
-      expect(aggregator).to receive(:add).with(
-        :g,
-        'foo',
-        5.0,
-        unit: 'second',
-        tags: { fortytwo: 42 },
-        timestamp: fake_time
-      )
-
-      described_class.gauge('foo', 5.0, unit: 'second', tags: { fortytwo: 42 }, timestamp: fake_time)
-    end
-  end
-
-  describe '.timing' do
-    it 'does nothing without a block' do
-      expect(aggregator).not_to receive(:add)
-      described_class.timing('foo')
-    end
-
-    it 'does nothing with a non-duration unit' do
-      expect(aggregator).not_to receive(:add)
-      result = described_class.timing('foo', unit: 'ratio') { 42 }
-      expect(result).to eq(42)
-    end
-
-    it 'measures time taken as distribution and passes through args to aggregator' do
-      expect(aggregator).to receive(:add).with(
-        :d,
-        'foo',
-        an_instance_of(Integer),
-        unit: 'millisecond',
-        tags: { fortytwo: 42 },
-        timestamp: fake_time
-      )
-
-      result = described_class.timing('foo', unit: 'millisecond', tags: { fortytwo: 42 }, timestamp: fake_time) { sleep(0.1); 42 }
-      expect(result).to eq(42)
-    end
-
-    context 'with running transaction' do
-      let(:transaction) { transaction = Sentry.start_transaction(name: 'metrics') }
-
-      before do
-        perform_basic_setup do |config|
-          config.enable_tracing = true
-          config.metrics.enabled = true
-        end
-
-        Sentry.get_current_scope.set_span(transaction)
-      end
-
-      it 'starts a span' do
-        expect(Sentry).to receive(:with_child_span).with(op: Sentry::Metrics::OP_NAME, description: 'foo', origin: Sentry::Metrics::SPAN_ORIGIN).and_call_original
-
-        described_class.timing('foo') { sleep(0.1) }
-      end
-
-      it 'has the correct tags on the new span' do
-        described_class.timing('foo', tags: { a: 42, b: [1, 2] }) { sleep(0.1) }
-        span = transaction.span_recorder.spans.last
-        expect(span.tags).to eq(a: '42', b: '1, 2')
+  %i[increment distribution set gauge timing distribution].each do |method|
+    describe ".#{method}" do
+      it 'logs deprecation warning' do
+        described_class.send(
+          method,
+          'foo',
+          5.0,
+          unit: 'second',
+          tags: { fortytwo: 42 },
+          timestamp: fake_time
+        )
+
+        expect(stringio.string).to include(
+          "WARN -- sentry: `Sentry::Metrics` is now deprecated and will be removed in the next major."
+        )
       end
     end
   end

sentry-ruby/lib/sentry/metrics/set_metric.rb

@@ -77,16 +77,6 @@
       expect(hash[:span_id].length).to eq(16)
       expect(hash[:origin]).to eq('manual')
     end
-
-    it 'has metric summary if present' do
-      key = [:c, 'incr', 'none', []]
-      subject.metrics_local_aggregator.add(key, 10)
-
-      hash = subject.to_hash
-      expect(hash[:_metrics_summary]).to eq({
-        'c:incr@none' => { count: 1, max: 10.0, min: 10.0, sum: 10.0, tags: {} }
-      })
-    end
   end
 
   describe "#to_sentry_trace" do

sentry-ruby/lib/sentry/metrics/timing.rb

@@ -1139,14 +1139,6 @@
         expect(described_class.backpressure_monitor).to eq(nil)
       end
 
-      it "flushes and kills metrics aggregator" do
-        perform_basic_setup { |c| c.metrics.enabled = true }
-        expect(described_class.metrics_aggregator).to receive(:flush).with(force: true)
-        expect(described_class.metrics_aggregator).to receive(:kill)
-        described_class.close
-        expect(described_class.metrics_aggregator).to eq(nil)
-      end
-
       it "flushes transport" do
         expect(described_class.get_current_client).to receive(:flush)
         described_class.close