sentry-ruby 5.16.1 → 5.21.0

data/lib/sentry/hub.rb

@@ -73,7 +73,13 @@ module Sentry
     end
 
     def pop_scope
-      @stack.pop
+      if @stack.size > 1
+        @stack.pop
+      else
+        # We never want to enter a situation where we have no scope and no client
+        client = current_client
+        @stack = [Layer.new(client, Scope.new)]
+      end
     end
 
     def start_transaction(transaction: nil, custom_sampling_context: {}, instrumenter: :sentry, **options)
@@ -193,7 +199,14 @@ module Sentry
       elsif custom_scope = options[:scope]
         scope.update_from_scope(custom_scope)
       elsif !options.empty?
-        scope.update_from_options(**options)
+        unsupported_option_keys = scope.update_from_options(**options)
+
+        unless unsupported_option_keys.empty?
+          configuration.log_debug <<~MSG
+            Options #{unsupported_option_keys} are not supported and will not be applied to the event.
+            You may want to set them under the `extra` option.
+          MSG
+        end
       end
 
       event = current_client.capture_event(event, scope, hint)
@@ -207,6 +220,7 @@ module Sentry
     end
 
     def add_breadcrumb(breadcrumb, hint: {})
+      return unless current_client
       return unless configuration.enabled_in_current_env?
 
       if before_breadcrumb = current_client.configuration.before_breadcrumb
@@ -245,7 +259,7 @@ module Sentry
     end
 
     def with_session_tracking(&block)
-      return yield unless configuration.auto_session_tracking
+      return yield unless configuration.session_tracking?
 
       start_session
       yield
@@ -279,6 +293,12 @@ module Sentry
       headers
     end
 
+    def get_trace_propagation_meta
+      get_trace_propagation_headers.map do |k, v|
+        "<meta name=\"#{k}\" content=\"#{v}\">"
+      end.join("\n")
+    end
+
     def continue_trace(env, **options)
       configure_scope { |s| s.generate_propagation_context(env) }
 

data/lib/sentry/integrable.rb

@@ -14,6 +14,10 @@ module Sentry
     def capture_exception(exception, **options, &block)
       options[:hint] ||= {}
       options[:hint][:integration] = integration_name
+
+      # within an integration, we usually intercept uncaught exceptions so we set handled to false.
+      options[:hint][:mechanism] ||= Sentry::Mechanism.new(type: integration_name, handled: false)
+
       Sentry.capture_exception(exception, **options, &block)
     end
 

data/lib/sentry/interface.rb

@@ -14,3 +14,4 @@ require "sentry/interfaces/request"
 require "sentry/interfaces/single_exception"
 require "sentry/interfaces/stacktrace"
 require "sentry/interfaces/threads"
+require "sentry/interfaces/mechanism"

data/lib/sentry/interfaces/exception.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "set"
 
 module Sentry
@@ -23,17 +24,18 @@ module Sentry
     # @param stacktrace_builder [StacktraceBuilder]
     # @see SingleExceptionInterface#build_with_stacktrace
     # @see SingleExceptionInterface#initialize
+    # @param mechanism [Mechanism]
     # @return [ExceptionInterface]
-    def self.build(exception:, stacktrace_builder:)
+    def self.build(exception:, stacktrace_builder:, mechanism:)
       exceptions = Sentry::Utils::ExceptionCauseChain.exception_to_array(exception).reverse
       processed_backtrace_ids = Set.new
 
       exceptions = exceptions.map do |e|
         if e.backtrace && !processed_backtrace_ids.include?(e.backtrace.object_id)
           processed_backtrace_ids << e.backtrace.object_id
-          SingleExceptionInterface.build_with_stacktrace(exception: e, stacktrace_builder: stacktrace_builder)
+          SingleExceptionInterface.build_with_stacktrace(exception: e, stacktrace_builder: stacktrace_builder, mechanism: mechanism)
         else
-          SingleExceptionInterface.new(exception: exception)
+          SingleExceptionInterface.new(exception: exception, mechanism: mechanism)
         end
       end
 

data/lib/sentry/interfaces/mechanism.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sentry
+  class Mechanism < Interface
+    # Generic identifier, mostly the source integration for this exception.
+    # @return [String]
+    attr_accessor :type
+
+    # A manually captured exception has handled set to true,
+    # false if coming from an integration where we intercept an uncaught exception.
+    # Defaults to true here and will be set to false explicitly in integrations.
+    # @return [Boolean]
+    attr_accessor :handled
+
+    def initialize(type: "generic", handled: true)
+      @type = type
+      @handled = handled
+    end
+  end
+end

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",
@@ -59,7 +59,7 @@ module Sentry
         self.query_string = request.query_string
       end
 
-      self.url = request.scheme && request.url.split('?').first
+      self.url = request.scheme && request.url.split("?").first
       self.method = request.request_method
 
       self.headers = filter_and_format_headers(env, send_default_pii)
@@ -85,14 +85,14 @@ module Sentry
       env.each_with_object({}) do |(key, value), memo|
         begin
           key = key.to_s # rack env can contain symbols
-          next memo['X-Request-Id'] ||= Utils::RequestId.read_from(env) if Utils::RequestId::REQUEST_ID_HEADERS.include?(key)
+          next memo["X-Request-Id"] ||= Utils::RequestId.read_from(env) if Utils::RequestId::REQUEST_ID_HEADERS.include?(key)
           next if is_server_protocol?(key, value, env["SERVER_PROTOCOL"])
           next if is_skippable_header?(key)
           next if key == "HTTP_AUTHORIZATION" && !send_default_pii
 
           # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
           key = key.sub(/^HTTP_/, "")
-          key = key.split('_').map(&:capitalize).join('-')
+          key = key.split("_").map(&:capitalize).join("-")
 
           memo[key] = Utils::EncodingHelper.encode_to_utf_8(value.to_s)
         rescue StandardError => e
@@ -108,7 +108,7 @@ module Sentry
     def is_skippable_header?(key)
       key.upcase != key || # lower-case envs aren't real http headers
         key == "HTTP_COOKIE" || # Cookies don't go here, they go somewhere else
-        !(key.start_with?('HTTP_') || CONTENT_HEADERS.include?(key))
+        !(key.start_with?("HTTP_") || CONTENT_HEADERS.include?(key))
     end
 
     # In versions < 3, Rack adds in an incorrect HTTP_VERSION key, which causes downstream
@@ -120,7 +120,7 @@ module Sentry
       rack_version = Gem::Version.new(::Rack.release)
       return false if rack_version >= Gem::Version.new("3.0")
 
-      key == 'HTTP_VERSION' && value == protocol_version
+      key == "HTTP_VERSION" && value == protocol_version
     end
 
     def filter_and_format_env(env, rack_env_whitelist)

data/lib/sentry/interfaces/single_exception.rb

@@ -7,14 +7,14 @@ module Sentry
     include CustomInspection
 
     SKIP_INSPECTION_ATTRIBUTES = [:@stacktrace]
-    PROBLEMATIC_LOCAL_VALUE_REPLACEMENT = "[ignored due to error]".freeze
-    OMISSION_MARK = "...".freeze
+    PROBLEMATIC_LOCAL_VALUE_REPLACEMENT = "[ignored due to error]"
+    OMISSION_MARK = "..."
     MAX_LOCAL_BYTES = 1024
 
-    attr_reader :type, :module, :thread_id, :stacktrace
+    attr_reader :type, :module, :thread_id, :stacktrace, :mechanism
     attr_accessor :value
 
-    def initialize(exception:, stacktrace: nil)
+    def initialize(exception:, mechanism:, stacktrace: nil)
       @type = exception.class.to_s
       exception_message =
         if exception.respond_to?(:detailed_message)
@@ -26,20 +26,22 @@ module Sentry
 
       @value = Utils::EncodingHelper.encode_to_utf_8(exception_message.byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES))
 
-      @module = exception.class.to_s.split('::')[0...-1].join('::')
+      @module = exception.class.to_s.split("::")[0...-1].join("::")
       @thread_id = Thread.current.object_id
       @stacktrace = stacktrace
+      @mechanism = mechanism
     end
 
     def to_hash
       data = super
       data[:stacktrace] = data[:stacktrace].to_hash if data[:stacktrace]
+      data[:mechanism] = data[:mechanism].to_hash
       data
     end
 
     # patch this method if you want to change an exception's stacktrace frames
     # also see `StacktraceBuilder.build`.
-    def self.build_with_stacktrace(exception:, stacktrace_builder:)
+    def self.build_with_stacktrace(exception:, stacktrace_builder:, mechanism:)
       stacktrace = stacktrace_builder.build(backtrace: exception.backtrace)
 
       if locals = exception.instance_variable_get(:@sentry_locals)
@@ -61,7 +63,7 @@ module Sentry
         stacktrace.frames.last.vars = locals
       end
 
-      new(exception: exception, stacktrace: stacktrace)
+      new(exception: exception, stacktrace: stacktrace, mechanism: mechanism)
     end
   end
 end

data/lib/sentry/interfaces/stacktrace.rb

@@ -27,8 +27,9 @@ module Sentry
       attr_accessor :abs_path, :context_line, :function, :in_app, :filename,
                   :lineno, :module, :pre_context, :post_context, :vars
 
-      def initialize(project_root, line)
+      def initialize(project_root, line, strip_backtrace_load_path = true)
         @project_root = project_root
+        @strip_backtrace_load_path = strip_backtrace_load_path
 
         @abs_path = line.file
         @function = line.method if line.method
@@ -44,6 +45,7 @@ module Sentry
 
       def compute_filename
         return if abs_path.nil?
+        return abs_path unless @strip_backtrace_load_path
 
         prefix =
           if under_project_root? && in_app

data/lib/sentry/interfaces/stacktrace_builder.rb

@@ -17,22 +17,35 @@ module Sentry
     # @return [Proc, nil]
     attr_reader :backtrace_cleanup_callback
 
+    # @return [Boolean]
+    attr_reader :strip_backtrace_load_path
+
     # @param project_root [String]
     # @param app_dirs_pattern [Regexp, nil]
     # @param linecache [LineCache]
     # @param context_lines [Integer, nil]
     # @param backtrace_cleanup_callback [Proc, nil]
+    # @param strip_backtrace_load_path [Boolean]
     # @see Configuration#project_root
     # @see Configuration#app_dirs_pattern
     # @see Configuration#linecache
     # @see Configuration#context_lines
     # @see Configuration#backtrace_cleanup_callback
-    def initialize(project_root:, app_dirs_pattern:, linecache:, context_lines:, backtrace_cleanup_callback: nil)
+    # @see Configuration#strip_backtrace_load_path
+    def initialize(
+      project_root:,
+      app_dirs_pattern:,
+      linecache:,
+      context_lines:,
+      backtrace_cleanup_callback: nil,
+      strip_backtrace_load_path: true
+    )
       @project_root = project_root
       @app_dirs_pattern = app_dirs_pattern
       @linecache = linecache
       @context_lines = context_lines
       @backtrace_cleanup_callback = backtrace_cleanup_callback
+      @strip_backtrace_load_path = strip_backtrace_load_path
     end
 
     # Generates a StacktraceInterface with the given backtrace.
@@ -62,10 +75,18 @@ 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)
-      frame = StacktraceInterface::Frame.new(project_root, line)
+      frame = StacktraceInterface::Frame.new(project_root, line, strip_backtrace_load_path)
       frame.set_context(linecache, context_lines) if context_lines
       frame
     end

data/lib/sentry/logger.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'logger'
+require "logger"
 
 module Sentry
   class Logger < ::Logger

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