perf: optimize LineCache to reduce allocations

Refactor LineCache internals to reduce memory allocations when reading
source context for stacktrace frames:

- Use Hash#fetch instead of ||= to avoid double hash lookup in getlines
- Remove valid_path?/getline indirection — inline bounds checking via
  line_at helper
- Build pre/post context arrays directly with Array.new instead of
  creating a single large array and slicing it
- Add set_frame_context method that sets frame attributes directly,
  avoiding the intermediate [pre, context_line, post] array allocation
- Cache context results per (filename, lineno) since the same frames
  repeat across exceptions — avoids recreating identical arrays

The public get_file_context API is preserved for custom LineCache
implementations.

Author: HazAT

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