sentry-ruby 5.13.0 → 5.21.0

data/lib/sentry/metrics/aggregator.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Metrics
+    class Aggregator < ThreadedPeriodicWorker
+      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_\-.]+/
+      UNIT_SANITIZATION_REGEX = /[^a-zA-Z0-9_]+/
+      TAG_KEY_SANITIZATION_REGEX = /[^a-zA-Z0-9_\-.\/]+/
+
+      TAG_VALUE_SANITIZATION_MAP = {
+        "\n" => "\\n",
+        "\r" => "\\r",
+        "\t" => "\\t",
+        "\\" => "\\\\",
+        "|" => "\\u{7c}",
+        "," => "\\u{2c}"
+      }
+
+      METRIC_TYPES = {
+        c: CounterMetric,
+        d: DistributionMetric,
+        g: GaugeMetric,
+        s: SetMetric
+      }
+
+      # exposed only for testing
+      attr_reader :client, :thread, :buckets, :flush_shift, :code_locations
+
+      def initialize(configuration, client)
+        super(configuration.logger, FLUSH_INTERVAL)
+        @client = client
+        @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
+
+        @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
+
+        @client.capture_envelope(envelope)
+      end
+
+      alias_method :run, :flush
+
+      private
+
+      # 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_tag_key(k)}:#{sanitize_tag_value(v)}" }.join(",")
+
+            "#{sanitize_key(key)}@#{sanitize_unit(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)}@#{sanitize_unit(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_unit(unit)
+        unit.gsub(UNIT_SANITIZATION_REGEX, "")
+      end
+
+      def sanitize_tag_key(key)
+        key.gsub(TAG_KEY_SANITIZATION_REGEX, "")
+      end
+
+      def sanitize_tag_value(value)
+        value.chars.map { |c| TAG_VALUE_SANITIZATION_MAP[c] || c }.join
+      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,56 @@
+# 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)
+
+        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]
+        end
+
+        Sentry.metrics_aggregator&.add(:d, key, value, unit: unit, tags: tags, timestamp: timestamp)
+        result
+      end
+    end
+  end
+end

data/lib/sentry/net/http.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 
 require "net/http"
+require "resolv"
+require "sentry/utils/http_tracing"
 
 module Sentry
   # @api private
   module Net
     module HTTP
+      include Utils::HttpTracing
+
       OP_NAME = "http.client"
+      SPAN_ORIGIN = "auto.http.net_http"
       BREADCRUMB_CATEGORY = "net.http"
 
       # To explain how the entire thing works, we need to know how the original Net::HTTP#request works
@@ -19,8 +24,7 @@ module Sentry
       #       req['connection'] ||= 'close'
       #       return request(req, body, &block) # <- request will be called for the second time from the first call
       #     }
-      #   end
-      #   # .....
+      #   end # .....
       # end
       # ```
       #
@@ -29,47 +33,29 @@ module Sentry
         return super unless started? && Sentry.initialized?
         return super if from_sentry_sdk?
 
-        Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f) do |sentry_span|
+        Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f, origin: SPAN_ORIGIN) do |sentry_span|
           request_info = extract_request_info(req)
 
-          if propagate_trace?(request_info[:url], Sentry.configuration)
+          if propagate_trace?(request_info[:url])
             set_propagation_headers(req)
           end
 
-          super.tap do |res|
-            record_sentry_breadcrumb(request_info, res)
+          res = super
+          response_status = res.code.to_i
 
-            if sentry_span
-              sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
-              sentry_span.set_data(Span::DataConventions::URL, request_info[:url])
-              sentry_span.set_data(Span::DataConventions::HTTP_METHOD, request_info[:method])
-              sentry_span.set_data(Span::DataConventions::HTTP_QUERY, request_info[:query]) if request_info[:query]
-              sentry_span.set_data(Span::DataConventions::HTTP_STATUS_CODE, res.code.to_i)
-            end
+          if record_sentry_breadcrumb?
+            record_sentry_breadcrumb(request_info, response_status)
           end
-        end
-      end
 
-      private
+          if sentry_span
+            set_span_info(sentry_span, request_info, response_status)
+          end
 
-      def set_propagation_headers(req)
-        Sentry.get_trace_propagation_headers&.each { |k, v| req[k] = v }
+          res
+        end
       end
 
-      def record_sentry_breadcrumb(request_info, res)
-        return unless Sentry.initialized? && Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
-
-        crumb = Sentry::Breadcrumb.new(
-          level: :info,
-          category: BREADCRUMB_CATEGORY,
-          type: :info,
-          data: {
-            status: res.code.to_i,
-            **request_info
-          }
-        )
-        Sentry.add_breadcrumb(crumb)
-      end
+      private
 
       def from_sentry_sdk?
         dsn = Sentry.configuration.dsn
@@ -77,7 +63,10 @@ module Sentry
       end
 
       def extract_request_info(req)
-        uri = req.uri || URI.parse("#{use_ssl? ? 'https' : 'http'}://#{address}#{req.path}")
+        # IPv6 url could look like '::1/path', and that won't parse without
+        # wrapping it in square brackets.
+        hostname = address =~ Resolv::IPv6::Regex ? "[#{address}]" : address
+        uri = req.uri || URI.parse(URI::DEFAULT_PARSER.escape("#{use_ssl? ? 'https' : 'http'}://#{hostname}#{req.path}"))
         url = "#{uri.scheme}://#{uri.host}#{uri.path}" rescue uri.to_s
 
         result = { method: req.method, url: url }
@@ -89,12 +78,6 @@ module Sentry
 
         result
       end
-
-      def propagate_trace?(url, configuration)
-        url &&
-          configuration.propagate_traces &&
-          configuration.trace_propagation_targets.any? { |target| url.match?(target) }
-      end
     end
   end
 end