perf: avoid unnecessary allocations in hot paths

Reduce memory allocations during exception capture with zero-risk changes
that preserve identical behavior:

Backtrace::Line.parse:
- Use indexed regex captures (match[1]) instead of .to_a destructuring,
  avoiding intermediate array allocation
- Add end_with? guard before .sub! for .class extension — skips string
  allocation on non-JRuby (99.9% of cases)
- Use match? instead of =~ in #in_app to avoid MatchData allocation
- Add nil guard for file in #in_app

StacktraceInterface::Frame:
- Remove stored @project_root/@strip_backtrace_load_path ivars (passed as
  args to compute_filename instead) — fewer entries in Interface#to_h
- Use byteslice instead of [] for filename prefix stripping
- Replace chomp(File::SEPARATOR) with end_with? check to avoid allocation
- Inline under_project_root? to eliminate method call overhead

StacktraceBuilder#build:
- Replace select + reverse + map + compact chain with single reverse while
  loop, eliminating 3 intermediate array allocations

RequestInterface:
- Use delete_prefix instead of regex sub for HTTP_ prefix removal
- Replace key.upcase != key with key.match?(LOWERCASE_PATTERN) to avoid
  allocating an upcased string for every Rack env entry
- Cache Rack version check to avoid repeated Gem::Version comparisons

Author: HazAT

sentry-ruby/lib/sentry/backtrace.rb

@@ -10,13 +10,16 @@ class Backtrace
     # holder for an Array of Backtrace::Line instances
     attr_reader :lines
 
+    @in_app_pattern_cache = {}
+
     def self.parse(backtrace, project_root, app_dirs_pattern, &backtrace_cleanup_callback)
       ruby_lines = backtrace.is_a?(Array) ? backtrace : backtrace.split(/\n\s*/)
 
       ruby_lines = backtrace_cleanup_callback.call(ruby_lines) if backtrace_cleanup_callback
 
-      in_app_pattern ||= begin
-        Regexp.new("^(#{project_root}/)?#{app_dirs_pattern}")
+      cache_key = app_dirs_pattern
+      in_app_pattern = @in_app_pattern_cache.fetch(cache_key) do
+        @in_app_pattern_cache[cache_key] = Regexp.new("^(#{project_root}/)?#{app_dirs_pattern}")
       end
 
       lines = ruby_lines.to_a.map do |unparsed_line|

sentry-ruby/lib/sentry/backtrace/line.rb

@@ -6,6 +6,7 @@ class Backtrace
     # Handles backtrace parsing line by line
     class Line
       RB_EXTENSION = ".rb"
+      CLASS_EXTENSION = ".class"
       # regexp (optional leading X: on windows, or JRuby9000 class-prefix)
       RUBY_INPUT_FORMAT = /
         ^ \s* (?: [a-zA-Z]: | uri:classloader: )? ([^:]+ | <.*>):
@@ -37,12 +38,21 @@ def self.parse(unparsed_line, in_app_pattern = nil)
         ruby_match = unparsed_line.match(RUBY_INPUT_FORMAT)
 
         if ruby_match
-          _, file, number, _, module_name, method = ruby_match.to_a
-          file.sub!(/\.class$/, RB_EXTENSION)
-          module_name = module_name
+          file = ruby_match[1]
+          number = ruby_match[2]
+          module_name = ruby_match[4]
+          method = ruby_match[5]
+          if file.end_with?(CLASS_EXTENSION)
+            file.sub!(/\.class$/, RB_EXTENSION)
+          end
         else
           java_match = unparsed_line.match(JAVA_INPUT_FORMAT)
-          _, module_name, method, file, number = java_match.to_a
+          if java_match
+            module_name = java_match[1]
+            method = java_match[2]
+            file = java_match[3]
+            number = java_match[4]
+          end
         end
         new(file, number, method, module_name, in_app_pattern)
       end
@@ -74,12 +84,9 @@ def initialize(file, number, method, module_name, in_app_pattern)
 
       def in_app
         return false unless in_app_pattern
+        return false unless file
 
-        if file =~ in_app_pattern
-          true
-        else
-          false
-        end
+        file.match?(in_app_pattern)
       end
 
       # Reconstructs the line in a readable fashion

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

@@ -11,6 +11,9 @@ class RequestInterface < Interface
       "HTTP_X_FORWARDED_FOR"
     ].freeze
 
+    # Regex to detect lowercase chars — match? is allocation-free (no MatchData/String)
+    LOWERCASE_PATTERN = /[a-z]/.freeze
+
     # See Sentry server default limits at
     # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
     MAX_BODY_LIMIT = 4096 * 4
@@ -93,7 +96,7 @@ def filter_and_format_headers(env, send_default_pii)
           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.delete_prefix("HTTP_")
           key = key.split("_").map(&:capitalize).join("-")
 
           memo[key] = Utils::EncodingHelper.encode_to_utf_8(value.to_s)
@@ -107,9 +110,6 @@ def filter_and_format_headers(env, send_default_pii)
       end
     end
 
-    # Regex to detect lowercase chars — match? is allocation-free (no MatchData/String)
-    LOWERCASE_PATTERN = /[a-z]/.freeze
-
     def is_skippable_header?(key)
       key.match?(LOWERCASE_PATTERN) || # lower-case envs aren't real http headers
         key == "HTTP_COOKIE" || # Cookies don't go here, they go somewhere else
@@ -122,12 +122,18 @@ def is_skippable_header?(key)
     # if the request has legitimately sent a Version header themselves.
     # See: https://github.com/rack/rack/blob/028438f/lib/rack/handler/cgi.rb#L29
     def is_server_protocol?(key, value, protocol_version)
-      rack_version = Gem::Version.new(::Rack.release)
-      return false if rack_version >= Gem::Version.new("3.0")
+      return false if self.class.rack_3_or_above?
 
       key == "HTTP_VERSION" && value == protocol_version
     end
 
+    def self.rack_3_or_above?
+      return @rack_3_or_above if defined?(@rack_3_or_above)
+
+      @rack_3_or_above = defined?(::Rack) &&
+        Gem::Version.new(::Rack.release) >= Gem::Version.new("3.0")
+    end
+
     def filter_and_format_env(env, rack_env_whitelist)
       return env if rack_env_whitelist.empty?
 

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

@@ -28,35 +28,43 @@ class Frame < Interface
                   :lineno, :module, :pre_context, :post_context, :vars
 
       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
         @lineno = line.number
         @in_app = line.in_app
         @module = line.module_name if line.module_name
-        @filename = compute_filename
+        @filename = compute_filename(project_root, strip_backtrace_load_path)
       end
 
       def to_s
         "#{@filename}:#{@lineno}"
       end
 
-      def compute_filename
+      def compute_filename(project_root, strip_backtrace_load_path)
         return if abs_path.nil?
-        return abs_path unless @strip_backtrace_load_path
+        return abs_path unless strip_backtrace_load_path
 
+        under_root = project_root && abs_path.start_with?(project_root)
         prefix =
-          if under_project_root? && in_app
-            @project_root
-          elsif under_project_root?
-            longest_load_path || @project_root
+          if under_root && in_app
+            project_root
+          elsif under_root
+            longest_load_path || project_root
           else
             longest_load_path
           end
 
-        prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
+        if prefix
+          prefix_str = prefix.to_s
+          offset = if prefix_str.end_with?(File::SEPARATOR)
+            prefix_str.length
+          else
+            prefix_str.length + 1
+          end
+          abs_path.byteslice(offset, abs_path.bytesize - offset)
+        else
+          abs_path
+        end
       end
 
       def set_context(linecache, context_lines)
@@ -77,10 +85,6 @@ def to_h(*args)
 
       private
 
-      def under_project_root?
-        @project_root && abs_path.start_with?(@project_root)
-      end
-
       def longest_load_path
         $LOAD_PATH.select { |path| abs_path.start_with?(path.to_s) }.max_by(&:size)
       end

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

@@ -64,13 +64,21 @@ def initialize(
     # @yieldparam frame [StacktraceInterface::Frame]
     # @return [StacktraceInterface]
     def build(backtrace:, &frame_callback)
-      parsed_lines = parse_backtrace_lines(backtrace).select(&:file)
+      parsed_lines = parse_backtrace_lines(backtrace)
+
+      # Build frames in reverse order, skipping lines without files
+      # Single pass instead of select + reverse + map + compact
+      frames = []
+      i = parsed_lines.size - 1
+      while i >= 0
+        line = parsed_lines[i]
+        i -= 1
+        next unless line.file
 
-      frames = parsed_lines.reverse.map do |line|
         frame = convert_parsed_line_into_frame(line)
         frame = frame_callback.call(frame) if frame_callback
-        frame
-      end.compact
+        frames << frame if frame
+      end
 
       StacktraceInterface.new(frames: frames)
     end

sentry-ruby/lib/sentry/linecache.rb

@@ -5,43 +5,72 @@ module Sentry
   class LineCache
     def initialize
       @cache = {}
+      @context_cache = {}
     end
 
     # Any linecache you provide to Sentry must implement this method.
     # Returns an Array of Strings representing the lines in the source
     # file. The number of lines retrieved is (2 * context) + 1, the middle
     # line should be the line requested by lineno. See specs for more information.
     def get_file_context(filename, lineno, context)
-      return nil, nil, nil unless valid_path?(filename)
+      lines = getlines(filename)
+      return nil, nil, nil unless lines
 
-      lines = Array.new(2 * context + 1) do |i|
-        getline(filename, lineno - context + i)
-      end
-      [lines[0..(context - 1)], lines[context], lines[(context + 1)..-1]]
+      first_line = lineno - context
+      pre = Array.new(context) { |i| line_at(lines, first_line + i) }
+      context_line = line_at(lines, lineno)
+      post = Array.new(context) { |i| line_at(lines, lineno + 1 + i) }
+      [pre, context_line, post]
     end
 
-    private
-
-    def valid_path?(path)
-      lines = getlines(path)
-      !lines.nil?
-    end
+    # Sets context directly on a frame, avoiding intermediate array allocation.
+    # Caches results per (filename, lineno) since the same frames repeat across exceptions.
+    def set_frame_context(frame, filename, lineno, context)
+      cache_key = lineno
+      file_contexts = @context_cache[filename]
 
-    def getlines(path)
-      @cache[path] ||= begin
-        File.open(path, "r", &:readlines)
-      rescue
-        nil
+      if file_contexts
+        cached = file_contexts[cache_key]
+        if cached
+          frame.pre_context = cached[0]
+          frame.context_line = cached[1]
+          frame.post_context = cached[2]
+          return
+        end
       end
+
+      lines = getlines(filename)
+      return unless lines
+
+      first_line = lineno - context
+      pre = Array.new(context) { |i| line_at(lines, first_line + i) }
+      ctx_line = line_at(lines, lineno)
+      post = Array.new(context) { |i| line_at(lines, lineno + 1 + i) }
+
+      file_contexts = (@context_cache[filename] ||= {})
+      file_contexts[cache_key] = [pre, ctx_line, post].freeze
+
+      frame.pre_context = pre
+      frame.context_line = ctx_line
+      frame.post_context = post
     end
 
-    def getline(path, n)
-      return nil if n < 1
+    private
 
-      lines = getlines(path)
-      return nil if lines.nil?
+    def line_at(lines, n)
+      return nil if n < 1
 
       lines[n - 1]
     end
+
+    def getlines(path)
+      @cache.fetch(path) do
+        @cache[path] = begin
+          File.open(path, "r", &:readlines)
+        rescue
+          nil
+        end
+      end
+    end
   end
 end