sentry-ruby 5.16.0 → 5.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a5743489d7783f058f5efc6085e044b6f90e8b13ddf0327d93b09a1a26689c5
-  data.tar.gz: '086b5740b42d73b3c87c4f2fb796e1b8692a338b8dd9cc1b5e4cc9783ab8ec5d'
+  metadata.gz: 92411c3edf0e7dfd2bf84109e80a2129fc914a9c5ce153416d42ebcf46081c1e
+  data.tar.gz: b180050dc794fad86f9a8c098ef2bb96bb3ba47cd09c854ebe24e52d986e2217
 SHA512:
-  metadata.gz: c8b03ba3fce273ee269a02bc6b6a1d3a875473bd53572ba565022dd3e9bb57f87d7083d6b04e6bc987796ed7a2dc83e6ed4885abc18e0582680975b353eaa879
-  data.tar.gz: 58be55ae2198fdf17697f22fc8fb4140bcdd4ef9a5b53a09c5a16e29bf42857242393d023536e1219483a803e8647908936a4e6fd84b86924ac0627b5ec62bf8
+  metadata.gz: b8ed1dbfb63041f9e73bb0f98fddf41b35a7da81ee747bbd0b5b60448d923e642cd4f299f8f12b190766132b5d6061352341e28b2abdc7196eeea5522617b1c5
+  data.tar.gz: 966f1db9b038e31381521217ad0bde4cc35552c0b4a35795d5871b6f5c9d97f4d04fe052e8b825897b22cbe63da84719e8b101634ec8fea3677b0d5155cd39eb

data/README.md

@@ -90,7 +90,7 @@ To learn more about sampling transactions, please visit the [official documentat
 - [Sidekiq](https://docs.sentry.io/platforms/ruby/guides/sidekiq/)
 - [DelayedJob](https://docs.sentry.io/platforms/ruby/guides/delayed_job/)
 - [Resque](https://docs.sentry.io/platforms/ruby/guides/resque/)
-- [OpenTemeletry](https://docs.sentry.io/platforms/ruby/performance/instrumentation/opentelemetry/)
+- [OpenTelemetry](https://docs.sentry.io/platforms/ruby/performance/instrumentation/opentelemetry/)
 
 ### Enriching Events
 

data/Rakefile

@@ -17,4 +17,4 @@ task :isolated_specs do
   end
 end
 
-task :default => [:spec, :isolated_specs]
+task default: [:spec, :isolated_specs]

data/lib/sentry/background_worker.rb

@@ -31,7 +31,7 @@ module Sentry
           log_debug("config.background_worker_threads is set to 0, all events will be sent synchronously")
           Concurrent::ImmediateExecutor.new
         else
-          log_debug("Initializing the background worker with #{@number_of_threads} threads")
+          log_debug("Initializing the Sentry background worker with #{@number_of_threads} threads")
 
           executor = Concurrent::ThreadPoolExecutor.new(
             min_threads: 0,

data/lib/sentry/backtrace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rubygems"
+
 module Sentry
   # @api private
   class Backtrace
@@ -10,7 +12,7 @@ module Sentry
       RUBY_INPUT_FORMAT = /
         ^ \s* (?: [a-zA-Z]: | uri:classloader: )? ([^:]+ | <.*>):
         (\d+)
-        (?: :in \s `([^']+)')?$
+        (?: :in\s('|`)([^']+)')?$
       /x.freeze
 
       # org.jruby.runtime.callsite.CachingCallSite.call(CachingCallSite.java:170)
@@ -33,10 +35,10 @@ module Sentry
       # Parses a single line of a given backtrace
       # @param [String] unparsed_line The raw line from +caller+ or some backtrace
       # @return [Line] The parsed backtrace line
-      def self.parse(unparsed_line, in_app_pattern)
+      def self.parse(unparsed_line, in_app_pattern = nil)
         ruby_match = unparsed_line.match(RUBY_INPUT_FORMAT)
         if ruby_match
-          _, file, number, method = ruby_match.to_a
+          _, file, number, _, method = ruby_match.to_a
           file.sub!(/\.class$/, RB_EXTENSION)
           module_name = nil
         else
@@ -55,6 +57,8 @@ module Sentry
       end
 
       def in_app
+        return false unless in_app_pattern
+
         if file =~ in_app_pattern
           true
         else

data/lib/sentry/check_in_event.rb

@@ -27,7 +27,7 @@ module Sentry
     # @return [Symbol]
     attr_accessor :status
 
-    VALID_STATUSES = %i(ok in_progress error)
+    VALID_STATUSES = %i[ok in_progress error]
 
     def initialize(
       slug:,

data/lib/sentry/client.rb

@@ -172,8 +172,8 @@ module Sentry
         end
       end
 
-      transport.send_event(event)
-      spotlight_transport&.send_event(event)
+      transport.send_event(event) if configuration.sending_to_dsn_allowed?
+      spotlight_transport.send_event(event) if spotlight_transport
 
       event
     rescue => e

data/lib/sentry/configuration.rb

@@ -8,6 +8,7 @@ require "sentry/dsn"
 require "sentry/release_detector"
 require "sentry/transport/configuration"
 require "sentry/cron/configuration"
+require "sentry/metrics/configuration"
 require "sentry/linecache"
 require "sentry/interfaces/stacktrace_builder"
 
@@ -235,6 +236,10 @@ module Sentry
     # @return [Cron::Configuration]
     attr_reader :cron
 
+    # Metrics related configuration.
+    # @return [Metrics::Configuration]
+    attr_reader :metrics
+
     # Take a float between 0.0 and 1.0 as the sample rate for tracing events (transactions).
     # @return [Float, nil]
     attr_reader :traces_sample_rate
@@ -311,11 +316,11 @@ module Sentry
       'Sinatra::NotFound'
     ].freeze
 
-    RACK_ENV_WHITELIST_DEFAULT = %w(
+    RACK_ENV_WHITELIST_DEFAULT = %w[
       REMOTE_ADDR
       SERVER_NAME
       SERVER_PORT
-    ).freeze
+    ].freeze
 
     HEROKU_DYNO_METADATA_MESSAGE = "You are running on Heroku but haven't enabled Dyno Metadata. For Sentry's "\
     "release detection to work correctly, please run `heroku labs:enable runtime-dyno-metadata`".freeze
@@ -328,7 +333,7 @@ module Sentry
 
     PROPAGATION_TARGETS_MATCH_ALL = /.*/.freeze
 
-    DEFAULT_PATCHES = %i(redis puma http).freeze
+    DEFAULT_PATCHES = %i[redis puma http].freeze
 
     class << self
       # Post initialization callbacks are called at the end of initialization process
@@ -337,7 +342,7 @@ module Sentry
         @post_initialization_callbacks ||= []
       end
 
-    # allow extensions to add their hooks to the Configuration class
+      # allow extensions to add their hooks to the Configuration class
       def add_post_initialization_callback(&block)
         post_initialization_callbacks << block
       end
@@ -386,6 +391,7 @@ module Sentry
 
       @transport = Transport::Configuration.new
       @cron = Cron::Configuration.new
+      @metrics = Metrics::Configuration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
 
       run_post_initialization_callbacks
@@ -479,9 +485,13 @@ module Sentry
     end
 
     def sending_allowed?
+      spotlight || sending_to_dsn_allowed?
+    end
+
+    def sending_to_dsn_allowed?
       @errors = []
 
-      spotlight || (valid? && capture_in_environment?)
+      valid? && capture_in_environment?
     end
 
     def sample_allowed?
@@ -490,6 +500,10 @@ module Sentry
       Random.rand < sample_rate
     end
 
+    def session_tracking?
+      auto_session_tracking && enabled_in_current_env?
+    end
+
     def exception_class_allowed?(exc)
       if exc.is_a?(Sentry::Error)
         # Try to prevent error reporting loops
@@ -566,12 +580,6 @@ module Sentry
 
     private
 
-    def check_callable!(name, value)
-      unless value == nil || value.respond_to?(:call)
-        raise ArgumentError, "#{name} must be callable (or nil to disable)"
-      end
-    end
-
     def init_dsn(dsn_string)
       return if dsn_string.nil? || dsn_string.empty?
 

data/lib/sentry/cron/monitor_schedule.rb

@@ -26,7 +26,7 @@ module Sentry
         # @return [Symbol]
         attr_accessor :unit
 
-        VALID_UNITS = %i(year month week day hour minute)
+        VALID_UNITS = %i[year month week day hour minute]
 
         def initialize(value, unit)
           @value = value

data/lib/sentry/dsn.rb

@@ -5,7 +5,7 @@ require "uri"
 module Sentry
   class DSN
     PORT_MAP = { 'http' => 80, 'https' => 443 }.freeze
-    REQUIRED_ATTRIBUTES = %w(host path public_key project_id).freeze
+    REQUIRED_ATTRIBUTES = %w[host path public_key project_id].freeze
 
     attr_reader :scheme, :secret_key, :port, *REQUIRED_ATTRIBUTES
 

data/lib/sentry/envelope.rb

@@ -19,7 +19,7 @@ module Sentry
       end
 
       def to_s
-        [JSON.generate(@headers), JSON.generate(@payload)].join("\n")
+        [JSON.generate(@headers), @payload.is_a?(String) ? @payload : JSON.generate(@payload)].join("\n")
       end
 
       def serialize

data/lib/sentry/event.rb

@@ -14,16 +14,16 @@ module Sentry
   class Event
     TYPE = "event"
     # These are readable attributes.
-    SERIALIZEABLE_ATTRIBUTES = %i(
+    SERIALIZEABLE_ATTRIBUTES = %i[
       event_id level timestamp
       release environment server_name modules
       message user tags contexts extra
       fingerprint breadcrumbs transaction transaction_info
       platform sdk type
-    )
+    ]
 
     # These are writable attributes.
-    WRITER_ATTRIBUTES = SERIALIZEABLE_ATTRIBUTES - %i(type timestamp level)
+    WRITER_ATTRIBUTES = SERIALIZEABLE_ATTRIBUTES - %i[type timestamp level]
 
     MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
 
@@ -145,11 +145,11 @@ module Sentry
     # REMOTE_ADDR to determine the Event IP, and must use other headers instead.
     def calculate_real_ip_from_rack(env)
       Utils::RealIp.new(
-        :remote_addr => env["REMOTE_ADDR"],
-        :client_ip => env["HTTP_CLIENT_IP"],
-        :real_ip => env["HTTP_X_REAL_IP"],
-        :forwarded_for => env["HTTP_X_FORWARDED_FOR"],
-        :trusted_proxies => @trusted_proxies
+        remote_addr: env["REMOTE_ADDR"],
+        client_ip: env["HTTP_CLIENT_IP"],
+        real_ip: env["HTTP_X_REAL_IP"],
+        forwarded_for: env["HTTP_X_FORWARDED_FOR"],
+        trusted_proxies: @trusted_proxies
       ).calculate_ip
     end
   end

data/lib/sentry/interfaces/exception.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "set"
 
 module Sentry

data/lib/sentry/interfaces/request.rb

@@ -2,8 +2,8 @@
 
 module Sentry
   class RequestInterface < Interface
-    REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
-    CONTENT_HEADERS = %w(CONTENT_TYPE CONTENT_LENGTH).freeze
+    REQUEST_ID_HEADERS = %w[action_dispatch.request_id HTTP_X_REQUEST_ID].freeze
+    CONTENT_HEADERS = %w[CONTENT_TYPE CONTENT_LENGTH].freeze
     IP_HEADERS = [
       "REMOTE_ADDR",
       "HTTP_CLIENT_IP",

data/lib/sentry/interfaces/stacktrace_builder.rb

@@ -62,6 +62,14 @@ 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/metrics/aggregator.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Metrics
+    class Aggregator
+      include LoggingHelper
+
+      FLUSH_INTERVAL = 5
+      ROLLUP_IN_SECONDS = 10
+
+      # this is how far removed from user code in the backtrace we are
+      # when we record code locations
+      DEFAULT_STACKLEVEL = 4
+
+      KEY_SANITIZATION_REGEX = /[^a-zA-Z0-9_\/.-]+/
+      VALUE_SANITIZATION_REGEX = /[^[[:word:]][[:digit:]][[:space:]]_:\/@\.{}\[\]$-]+/
+
+      METRIC_TYPES = {
+        c: CounterMetric,
+        d: DistributionMetric,
+        g: GaugeMetric,
+        s: SetMetric
+      }
+
+      # exposed only for testing
+      attr_reader :thread, :buckets, :flush_shift, :code_locations
+
+      def initialize(configuration, client)
+        @client = client
+        @logger = configuration.logger
+        @before_emit = configuration.metrics.before_emit
+        @enable_code_locations = configuration.metrics.enable_code_locations
+        @stacktrace_builder = configuration.stacktrace_builder
+
+        @default_tags = {}
+        @default_tags['release'] = configuration.release if configuration.release
+        @default_tags['environment'] = configuration.environment if configuration.environment
+
+        @thread = nil
+        @exited = false
+        @mutex = Mutex.new
+
+        # a nested hash of timestamp -> bucket keys -> Metric instance
+        @buckets = {}
+
+        # the flush interval needs to be shifted once per startup to create jittering
+        @flush_shift = Random.rand * ROLLUP_IN_SECONDS
+
+        # a nested hash of timestamp (start of day) -> meta keys -> frame
+        @code_locations = {}
+      end
+
+      def add(type,
+              key,
+              value,
+              unit: 'none',
+              tags: {},
+              timestamp: nil,
+              stacklevel: nil)
+        return unless ensure_thread
+        return unless METRIC_TYPES.keys.include?(type)
+
+        updated_tags = get_updated_tags(tags)
+        return if @before_emit && !@before_emit.call(key, updated_tags)
+
+        timestamp ||= Sentry.utc_now
+
+        # this is integer division and thus takes the floor of the division
+        # and buckets into 10 second intervals
+        bucket_timestamp = (timestamp.to_i / ROLLUP_IN_SECONDS) * ROLLUP_IN_SECONDS
+
+        serialized_tags = serialize_tags(updated_tags)
+        bucket_key = [type, key, unit, serialized_tags]
+
+        added = @mutex.synchronize do
+          record_code_location(type, key, unit, timestamp, stacklevel: stacklevel) if @enable_code_locations
+          process_bucket(bucket_timestamp, bucket_key, type, value)
+        end
+
+        # for sets, we pass on if there was a new entry to the local gauge
+        local_value = type == :s ? added : value
+        process_span_aggregator(bucket_key, local_value)
+      end
+
+      def flush(force: false)
+        flushable_buckets = get_flushable_buckets!(force)
+        code_locations = get_code_locations!
+        return if flushable_buckets.empty? && code_locations.empty?
+
+        envelope = Envelope.new
+
+        unless flushable_buckets.empty?
+          payload = serialize_buckets(flushable_buckets)
+          envelope.add_item(
+            { type: 'statsd', length: payload.bytesize },
+            payload
+          )
+        end
+
+        unless code_locations.empty?
+          code_locations.each do |timestamp, locations|
+            payload = serialize_locations(timestamp, locations)
+            envelope.add_item(
+              { type: 'metric_meta', content_type: 'application/json' },
+              payload
+            )
+          end
+        end
+
+        Sentry.background_worker.perform do
+          @client.transport.send_envelope(envelope)
+        end
+      end
+
+      def kill
+        log_debug('[Metrics::Aggregator] killing thread')
+
+        @exited = true
+        @thread&.kill
+      end
+
+      private
+
+      def ensure_thread
+        return false if @exited
+        return true if @thread&.alive?
+
+        @thread = Thread.new do
+          loop do
+            # TODO-neel-metrics use event for force flush later
+            sleep(FLUSH_INTERVAL)
+            flush
+          end
+        end
+
+        true
+      rescue ThreadError
+        log_debug('[Metrics::Aggregator] thread creation failed')
+        @exited = true
+        false
+      end
+
+      # important to sort for key consistency
+      def serialize_tags(tags)
+        tags.flat_map do |k, v|
+          if v.is_a?(Array)
+            v.map { |x| [k.to_s, x.to_s] }
+          else
+            [[k.to_s, v.to_s]]
+          end
+        end.sort
+      end
+
+      def get_flushable_buckets!(force)
+        @mutex.synchronize do
+          flushable_buckets = {}
+
+          if force
+            flushable_buckets = @buckets
+            @buckets = {}
+          else
+            cutoff = Sentry.utc_now.to_i - ROLLUP_IN_SECONDS - @flush_shift
+            flushable_buckets = @buckets.select { |k, _| k <= cutoff }
+            @buckets.reject! { |k, _| k <= cutoff }
+          end
+
+          flushable_buckets
+        end
+      end
+
+      def get_code_locations!
+        @mutex.synchronize do
+          code_locations = @code_locations
+          @code_locations = {}
+          code_locations
+        end
+      end
+
+      # serialize buckets to statsd format
+      def serialize_buckets(buckets)
+        buckets.map do |timestamp, timestamp_buckets|
+          timestamp_buckets.map do |metric_key, metric|
+            type, key, unit, tags = metric_key
+            values = metric.serialize.join(':')
+            sanitized_tags = tags.map { |k, v| "#{sanitize_key(k)}:#{sanitize_value(v)}" }.join(',')
+
+            "#{sanitize_key(key)}@#{unit}:#{values}|#{type}|\##{sanitized_tags}|T#{timestamp}"
+          end
+        end.flatten.join("\n")
+      end
+
+      def serialize_locations(timestamp, locations)
+        mapping = locations.map do |meta_key, location|
+          type, key, unit = meta_key
+          mri = "#{type}:#{sanitize_key(key)}@#{unit}"
+
+          # note this needs to be an array but it really doesn't serve a purpose right now
+          [mri, [location.merge(type: 'location')]]
+        end.to_h
+
+        { timestamp: timestamp, mapping: mapping }
+      end
+
+      def sanitize_key(key)
+        key.gsub(KEY_SANITIZATION_REGEX, '_')
+      end
+
+      def sanitize_value(value)
+        value.gsub(VALUE_SANITIZATION_REGEX, '')
+      end
+
+      def get_transaction_name
+        scope = Sentry.get_current_scope
+        return nil unless scope && scope.transaction_name
+        return nil if scope.transaction_source_low_quality?
+
+        scope.transaction_name
+      end
+
+      def get_updated_tags(tags)
+        updated_tags = @default_tags.merge(tags)
+
+        transaction_name = get_transaction_name
+        updated_tags['transaction'] = transaction_name if transaction_name
+
+        updated_tags
+      end
+
+      def process_span_aggregator(key, value)
+        scope = Sentry.get_current_scope
+        return nil unless scope && scope.span
+        return nil if scope.transaction_source_low_quality?
+
+        scope.span.metrics_local_aggregator.add(key, value)
+      end
+
+      def process_bucket(timestamp, key, type, value)
+        @buckets[timestamp] ||= {}
+
+        if (metric = @buckets[timestamp][key])
+          old_weight = metric.weight
+          metric.add(value)
+          metric.weight - old_weight
+        else
+          metric = METRIC_TYPES[type].new(value)
+          @buckets[timestamp][key] = metric
+          metric.weight
+        end
+      end
+
+      def record_code_location(type, key, unit, timestamp, stacklevel: nil)
+        meta_key =  [type, key, unit]
+        start_of_day = Time.utc(timestamp.year, timestamp.month, timestamp.day).to_i
+
+        @code_locations[start_of_day] ||= {}
+        @code_locations[start_of_day][meta_key] ||= @stacktrace_builder.metrics_code_location(caller[stacklevel || DEFAULT_STACKLEVEL])
+      end
+    end
+  end
+end

data/lib/sentry/metrics/configuration.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Metrics
+    class Configuration
+      include ArgumentCheckingHelper
+
+      # 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
+      end
+
+      def before_emit=(value)
+        check_callable!("metrics.before_emit", value)
+
+        @before_emit = value
+      end
+    end
+  end
+end

data/lib/sentry/metrics/counter_metric.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Metrics
+    class CounterMetric < Metric
+      attr_reader :value
+
+      def initialize(value)
+        @value = value.to_f
+      end
+
+      def add(value)
+        @value += value.to_f
+      end
+
+      def serialize
+        [value]
+      end
+
+      def weight
+        1
+      end
+    end
+  end
+end

data/lib/sentry/metrics/distribution_metric.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Metrics
+    class DistributionMetric < Metric
+      attr_reader :value
+
+      def initialize(value)
+        @value = [value.to_f]
+      end
+
+      def add(value)
+        @value << value.to_f
+      end
+
+      def serialize
+        value
+      end
+
+      def weight
+        value.size
+      end
+    end
+  end
+end

data/lib/sentry/metrics/gauge_metric.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Metrics
+    class GaugeMetric < Metric
+      attr_reader :last, :min, :max, :sum, :count
+
+      def initialize(value)
+        value = value.to_f
+        @last = value
+        @min = value
+        @max = value
+        @sum = value
+        @count = 1
+      end
+
+      def add(value)
+        value = value.to_f
+        @last = value
+        @min = [@min, value].min
+        @max = [@max, value].max
+        @sum += value
+        @count += 1
+      end
+
+      def serialize
+        [last, min, max, sum, count]
+      end
+
+      def weight
+        5
+      end
+    end
+  end
+end

data/lib/sentry/metrics/local_aggregator.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Metrics
+    class LocalAggregator
+      # exposed only for testing
+      attr_reader :buckets
+
+      def initialize
+        @buckets = {}
+      end
+
+      def add(key, value)
+        if @buckets[key]
+          @buckets[key].add(value)
+        else
+          @buckets[key] = GaugeMetric.new(value)
+        end
+      end
+
+      def to_hash
+        return nil if @buckets.empty?
+
+        @buckets.map do |bucket_key, metric|
+          type, key, unit, tags = bucket_key
+
+          payload_key = "#{type}:#{key}@#{unit}"
+          payload_value = {
+            tags: deserialize_tags(tags),
+            min: metric.min,
+            max: metric.max,
+            count: metric.count,
+            sum: metric.sum
+          }
+
+          [payload_key, payload_value]
+        end.to_h
+      end
+
+      private
+
+      def deserialize_tags(tags)
+        tags.inject({}) do |h, tag|
+          k, v = tag
+          old = h[k]
+          # make it an array if key repeats
+          h[k] = old ? (old.is_a?(Array) ? old << v : [old, v]) : v
+          h
+        end
+      end
+    end
+  end
+end

data/lib/sentry/metrics/metric.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Metrics
+    class Metric
+      def add(value)
+        raise NotImplementedError
+      end
+
+      def serialize
+        raise NotImplementedError
+      end
+
+      def weight
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/sentry/metrics/set_metric.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'zlib'
+
+module Sentry
+  module Metrics
+    class SetMetric < Metric
+      attr_reader :value
+
+      def initialize(value)
+        @value = Set[value]
+      end
+
+      def add(value)
+        @value << value
+      end
+
+      def serialize
+        value.map { |x| x.is_a?(String) ? Zlib.crc32(x) : x.to_i }
+      end
+
+      def weight
+        value.size
+      end
+    end
+  end
+end

data/lib/sentry/metrics/timing.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Metrics
+    module Timing
+      class << self
+        def nanosecond
+          time = Sentry.utc_now
+          time.to_i * (10 ** 9) + time.nsec
+        end
+
+        def microsecond
+          time = Sentry.utc_now
+          time.to_i * (10 ** 6) + time.usec
+        end
+
+        def millisecond
+          Sentry.utc_now.to_i * (10 ** 3)
+        end
+
+        def second
+          Sentry.utc_now.to_i
+        end
+
+        def minute
+          Sentry.utc_now.to_i / 60.0
+        end
+
+        def hour
+          Sentry.utc_now.to_i / 3600.0
+        end
+
+        def day
+          Sentry.utc_now.to_i / (3600.0 * 24.0)
+        end
+
+        def week
+          Sentry.utc_now.to_i / (3600.0 * 24.0 * 7.0)
+        end
+      end
+    end
+  end
+end

data/lib/sentry/metrics.rb

@@ -0,0 +1,55 @@
+# 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'
+
+    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)
+
+        result, value = Sentry.with_child_span(op: OP_NAME, description: key) do |span|
+          tags.each { |k, v| span.set_tag(k, v.is_a?(Array) ? v.join(', ') : v.to_s) } if span
+
+          start = Timing.send(unit.to_sym)
+          result = yield
+          value = Timing.send(unit.to_sym) - start
+
+          [result, value]
+        end
+
+        Sentry.metrics_aggregator&.add(:d, key, value, unit: unit, tags: tags, timestamp: timestamp)
+        result
+      end
+    end
+  end
+end

data/lib/sentry/propagation_context.rb

@@ -50,14 +50,15 @@ module Sentry
           if sentry_trace_data
             @trace_id, @parent_span_id, @parent_sampled = sentry_trace_data
 
-            @baggage = if baggage_header && !baggage_header.empty?
-                        Baggage.from_incoming_header(baggage_header)
-                      else
-                        # If there's an incoming sentry-trace but no incoming baggage header,
-                        # for instance in traces coming from older SDKs,
-                        # baggage will be empty and frozen and won't be populated as head SDK.
-                        Baggage.new({})
-                      end
+            @baggage =
+              if baggage_header && !baggage_header.empty?
+                Baggage.from_incoming_header(baggage_header)
+              else
+                # If there's an incoming sentry-trace but no incoming baggage header,
+                # for instance in traces coming from older SDKs,
+                # baggage will be empty and frozen and won't be populated as head SDK.
+                Baggage.new({})
+              end
 
             @baggage.freeze!
             @incoming_trace = true

data/lib/sentry/puma.rb

@@ -7,7 +7,7 @@ module Sentry
     module Server
       PUMA_4_AND_PRIOR = Gem::Version.new(::Puma::Const::PUMA_VERSION) < Gem::Version.new("5.0.0")
 
-      def lowlevel_error(e, env, status=500)
+      def lowlevel_error(e, env, status = 500)
         result =
           if PUMA_4_AND_PRIOR
             super(e, env)

data/lib/sentry/scope.rb

@@ -252,6 +252,12 @@ module Sentry
       @transaction_sources.last
     end
 
+    # These are high cardinality and thus bad.
+    # @return [Boolean]
+    def transaction_source_low_quality?
+      transaction_source == :url
+    end
+
     # Returns the associated Transaction object.
     # @return [Transaction, nil]
     def get_transaction
@@ -295,7 +301,7 @@ module Sentry
     private
 
     def set_default_value
-      @contexts = { :os => self.class.os_context, :runtime => self.class.runtime_context }
+      @contexts = { os: self.class.os_context, runtime: self.class.runtime_context }
       @extra = {}
       @tags = {}
       @user = {}
@@ -355,6 +361,5 @@ module Sentry
         global_event_processors << block
       end
     end
-
   end
 end

data/lib/sentry/session.rb

@@ -5,8 +5,8 @@ module Sentry
     attr_reader :started, :status, :aggregation_key
 
     # TODO-neel add :crashed after adding handled mechanism
-    STATUSES = %i(ok errored exited)
-    AGGREGATE_STATUSES = %i(errored exited)
+    STATUSES = %i[ok errored exited]
+    AGGREGATE_STATUSES = %i[errored exited]
 
     def initialize
       @started = Sentry.utc_now

data/lib/sentry/session_flusher.rb

@@ -85,6 +85,5 @@ module Sentry
         end
       end
     end
-
   end
 end

data/lib/sentry/span.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require "securerandom"
+require "sentry/metrics/local_aggregator"
 
 module Sentry
   class Span
-
     # We will try to be consistent with OpenTelemetry on this front going forward.
     # https://develop.sentry.dev/sdk/performance/span-data-conventions/
     module DataConventions
@@ -150,7 +150,7 @@ module Sentry
 
     # @return [Hash]
     def to_hash
-      {
+      hash = {
         trace_id: @trace_id,
         span_id: @span_id,
         parent_span_id: @parent_span_id,
@@ -162,6 +162,11 @@ module Sentry
         tags: @tags,
         data: @data
       }
+
+      summary = metrics_summary
+      hash[:_metrics_summary] = summary if summary
+
+      hash
     end
 
     # Returns the span's context that can be used to embed in an Event.
@@ -269,5 +274,14 @@ module Sentry
     def set_tag(key, value)
       @tags[key] = value
     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

data/lib/sentry/transaction.rb

@@ -13,7 +13,7 @@ module Sentry
     MESSAGE_PREFIX = "[Tracing]"
 
     # https://develop.sentry.dev/sdk/event-payloads/transaction/#transaction-annotations
-    SOURCES = %i(custom url route view component task)
+    SOURCES = %i[custom url route view component task]
 
     include LoggingHelper
 
@@ -110,14 +110,15 @@ module Sentry
 
       trace_id, parent_span_id, parent_sampled = sentry_trace_data
 
-      baggage = if baggage && !baggage.empty?
-                  Baggage.from_incoming_header(baggage)
-                else
-                  # If there's an incoming sentry-trace but no incoming baggage header,
-                  # for instance in traces coming from older SDKs,
-                  # baggage will be empty and frozen and won't be populated as head SDK.
-                  Baggage.new({})
-                end
+      baggage =
+        if baggage && !baggage.empty?
+          Baggage.from_incoming_header(baggage)
+        else
+          # If there's an incoming sentry-trace but no incoming baggage header,
+          # for instance in traces coming from older SDKs,
+          # baggage will be empty and frozen and won't be populated as head SDK.
+          Baggage.new({})
+        end
 
       baggage.freeze!
 
@@ -301,6 +302,11 @@ module Sentry
       profiler.start
     end
 
+    # These are high cardinality and thus bad
+    def source_low_quality?
+      source == :url
+    end
+
     protected
 
     def init_span_recorder(limit = 1000)
@@ -336,11 +342,6 @@ module Sentry
       @baggage = Baggage.new(items, mutable: false)
     end
 
-    # These are high cardinality and thus bad
-    def source_low_quality?
-      source == :url
-    end
-
     class SpanRecorder
       attr_reader :max_length, :spans
 

data/lib/sentry/transaction_event.rb

@@ -17,6 +17,9 @@ module Sentry
     # @return [Hash, nil]
     attr_accessor :profile
 
+    # @return [Hash, nil]
+    attr_accessor :metrics_summary
+
     def initialize(transaction:, **options)
       super(**options)
 
@@ -29,6 +32,7 @@ module Sentry
       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)
@@ -49,6 +53,7 @@ module Sentry
       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
 

data/lib/sentry/transport/configuration.rb

@@ -3,7 +3,6 @@
 module Sentry
   class Transport
     class Configuration
-
       # The timeout in seconds to open a connection to Sentry, in seconds.
       # Default value is 2.
       #

data/lib/sentry/transport.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "json"
-require "base64"
 require "sentry/envelope"
 
 module Sentry

data/lib/sentry/utils/argument_checking_helper.rb

@@ -15,5 +15,11 @@ module Sentry
         raise ArgumentError, "expect the argument to be one of #{values.map(&:inspect).join(' or ')}, got #{argument.inspect}"
       end
     end
+
+    def check_callable!(name, value)
+      unless value == nil || value.respond_to?(:call)
+        raise ArgumentError, "#{name} must be callable (or nil to disable)"
+      end
+    end
   end
 end

data/lib/sentry/utils/real_ip.rb

@@ -15,7 +15,7 @@ module Sentry
         "fc00::/7",       # private IPv6 range fc00::/7
         "10.0.0.0/8",     # private IPv4 range 10.x.x.x
         "172.16.0.0/12",  # private IPv4 range 172.16.0.0 .. 172.31.255.255
-        "192.168.0.0/16", # private IPv4 range 192.168.x.x
+        "192.168.0.0/16" # private IPv4 range 192.168.x.x
       ]
 
       attr_reader :ip

data/lib/sentry/utils/request_id.rb

@@ -3,7 +3,7 @@
 module Sentry
   module Utils
     module RequestId
-      REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
+      REQUEST_ID_HEADERS = %w[action_dispatch.request_id HTTP_X_REQUEST_ID].freeze
 
       # Request ID based on ActionDispatch::RequestId
       def self.read_from(env)

data/lib/sentry/version.rb

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

data/lib/sentry-ruby.rb

@@ -23,10 +23,11 @@ require "sentry/background_worker"
 require "sentry/session_flusher"
 require "sentry/backpressure_monitor"
 require "sentry/cron/monitor_check_ins"
+require "sentry/metrics"
 
 [
   "sentry/rake",
-  "sentry/rack",
+  "sentry/rack"
 ].each do |lib|
   begin
     require lib
@@ -77,6 +78,10 @@ module Sentry
     #   @return [BackpressureMonitor, nil]
     attr_reader :backpressure_monitor
 
+    # @!attribute [r] metrics_aggregator
+    #   @return [Metrics::Aggregator, nil]
+    attr_reader :metrics_aggregator
+
     ##### Patch Registration #####
 
     # @!visibility private
@@ -222,8 +227,9 @@ module Sentry
       Thread.current.thread_variable_set(THREAD_LOCAL, hub)
       @main_hub = hub
       @background_worker = Sentry::BackgroundWorker.new(config)
-      @session_flusher = config.auto_session_tracking ? Sentry::SessionFlusher.new(config, client) : nil
+      @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
       exception_locals_tp.enable if config.include_local_variables
       at_exit { close }
     end
@@ -244,6 +250,12 @@ module Sentry
         @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.transport.flush
 

data/sentry-ruby.gemspec

@@ -21,4 +21,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "concurrent-ruby", '~> 1.0', '>= 1.0.2'
+  spec.add_dependency "bigdecimal"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby
 version: !ruby/object:Gem::Version
-  version: 5.16.0
+  version: 5.17.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-08 00:00:00.000000000 Z
+date: 2024-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -30,6 +30,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.2
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A gem that provides a client interface for the Sentry error logger
 email: accounts@sentry.io
 executables: []
@@ -82,6 +96,16 @@ files:
 - lib/sentry/interfaces/threads.rb
 - lib/sentry/linecache.rb
 - lib/sentry/logger.rb
+- lib/sentry/metrics.rb
+- lib/sentry/metrics/aggregator.rb
+- lib/sentry/metrics/configuration.rb
+- lib/sentry/metrics/counter_metric.rb
+- lib/sentry/metrics/distribution_metric.rb
+- lib/sentry/metrics/gauge_metric.rb
+- lib/sentry/metrics/local_aggregator.rb
+- lib/sentry/metrics/metric.rb
+- lib/sentry/metrics/set_metric.rb
+- lib/sentry/metrics/timing.rb
 - lib/sentry/net/http.rb
 - lib/sentry/profiler.rb
 - lib/sentry/propagation_context.rb