activerabbit-ai 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d349dcd013eaa9c787d218d695e4e45d779b4c236fc908b84edbda42ac0471b8
-  data.tar.gz: 92c559e16a816706558028588f8869212b05e41fb10507d5fc8c40902ca95a62
+  metadata.gz: f74f9015abfef72171776a4ffc3b2773ba9c065b988d9e4f8ee23e9cdd2b282e
+  data.tar.gz: 4b28180c68924cc06116b19b21bc9b33f0d97f8ac3ed4caa68072c8efdff9fcd
 SHA512:
-  metadata.gz: f26d6cd48e6ba74b87cbdfb5adae1c89dfba13c623c0acfc7418c7061bf3559c66a48061a136a166bdb69a5e06cf1a5d6ee5067c35e20932dd4b98966ad03bcf
-  data.tar.gz: daf29ace4927b42c216a8c88df12291f783b599d32a4443e19426854f336c00fb571ae63d2f6003d05707409b150768cc0ed1c42fd12d348e7bb80689a96aabb
+  metadata.gz: 0fb79f1162dc1648c9ffe8d6cc05e813b20f3674143acbf935ecc657c7e1273a4ba35a8f873bf87e1e4e491f579b22568d0f45898de1106947ad41973b7317a9
+  data.tar.gz: f2bb325c0780e79160b6acbc4e6e10f98ca427459b58448562166d8c88cb5776e38c10fe3620d713945585ef0206f3a9465a04bdbec26c78ec47e0f78c1ba011

data/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.6.0] - 2026-01-09
+
+### Added
+- **Sentry-style Stack Traces**: Full source code context captured at error time
+  - New `SourceCodeReader` class captures 5 lines before/after each error line
+  - `structured_stack_trace` field with rich frame data (file, line, method, in_app, frame_type, source_context)
+  - `culprit_frame` identifies the first in-app frame where error occurred
+  - Frame classification: controller, model, service, job, view, helper, mailer, concern, library, gem
+- **Comprehensive Test Coverage**: 34 new tests for source code reader and exception tracker
+
+### Fixed
+- **Nil backtrace handling**: Fixed `undefined method 'include?' for nil:NilClass` when backtrace contains nil entries
+
 ## [0.5.2] - 2025-12-22
 
 ### Fixed

data/lib/active_rabbit/client/exception_tracker.rb

@@ -2,12 +2,16 @@
 
 require "digest"
 require "time"
+require_relative "source_code_reader"
 
 module ActiveRabbit
   module Client
     class ExceptionTracker
       attr_reader :configuration, :http_client
 
+      # Number of context lines to capture around error line
+      SOURCE_CONTEXT_LINES = 5
+
       def initialize(configuration, http_client)
         @configuration = configuration
         @http_client = http_client
@@ -77,8 +81,16 @@ module ActiveRabbit
       end
 
       def build_exception_data(exception:, context:, user_id:, tags:, handled: nil)
-        parsed_bt = parse_backtrace(exception.backtrace || [])
-        backtrace_lines = parsed_bt.map { |frame| frame[:line] }
+        raw_backtrace = exception.backtrace || []
+
+        # Parse backtrace with source code context (Sentry-style)
+        structured_frames = SourceCodeReader.parse_backtrace_with_source(
+          raw_backtrace,
+          context_lines: SOURCE_CONTEXT_LINES
+        )
+
+        # Keep simple backtrace lines for backward compatibility
+        backtrace_lines = raw_backtrace
 
         # Fallback: synthesize a helpful frame for routing errors with no backtrace
         if backtrace_lines.empty?
@@ -90,9 +102,24 @@ module ActiveRabbit
             path = $2
             synthetic = "#{defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : 'app'}/config/routes.rb:1:in `route_not_found' for #{path}"
           end
-          backtrace_lines = [synthetic] if synthetic
+          if synthetic
+            backtrace_lines = [synthetic]
+            structured_frames = [{
+              file: "config/routes.rb",
+              line: 1,
+              method: "route_not_found",
+              raw: synthetic,
+              in_app: true,
+              frame_type: :other,
+              index: 0,
+              source_context: nil
+            }]
+          end
         end
 
+        # Find culprit frame (first in-app frame)
+        culprit_frame = structured_frames.find { |f| f[:in_app] }
+
         # Build data in the format the API expects
         data = {
           # Required fields
@@ -100,6 +127,10 @@ module ActiveRabbit
           message: exception.message,
           backtrace: backtrace_lines,
 
+          # Structured stack frames with source context (Sentry-style)
+          structured_stack_trace: structured_frames,
+          culprit_frame: culprit_frame,
+
           # Timing and environment
           occurred_at: Time.now.iso8601(3),
           environment: configuration.environment || 'development',
@@ -150,6 +181,7 @@ module ActiveRabbit
         # Log what we're sending
         log(:debug, "[ActiveRabbit] Built exception data:")
         log(:debug, "[ActiveRabbit] - Required fields: class=#{data[:exception_class]}, message=#{data[:message]}, backtrace=#{data[:backtrace]&.first}")
+        log(:debug, "[ActiveRabbit] - Structured frames: #{structured_frames.count} total, #{structured_frames.count { |f| f[:in_app] }} in-app")
         log(:debug, "[ActiveRabbit] - Error details: type=#{data[:error_type]}, source=#{data[:error_source]}, component=#{data[:error_component]}")
         log(:debug, "[ActiveRabbit] - Request info: path=#{data[:request_path]}, method=#{data[:request_method]}, action=#{data[:controller_action]}")
 
@@ -199,7 +231,8 @@ module ActiveRabbit
 
         # Take the first few frames from the application (not gems/stdlib)
         app_frames = backtrace
-          .select { |line| line.include?(Dir.pwd) } # Only app files
+          .compact # Remove any nil entries
+          .select { |line| line.is_a?(String) && line.include?(Dir.pwd) } # Only app files
           .first(3) # First 3 frames
           .map { |line| line.gsub(/:\d+/, ":LINE") } # Remove line numbers
 

data/lib/active_rabbit/client/source_code_reader.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module ActiveRabbit
+  module Client
+    # Reads source code context around error lines for rich stack traces
+    # Similar to how Sentry captures source context at error time
+    class SourceCodeReader
+      DEFAULT_CONTEXT_LINES = 5
+      MAX_LINE_LENGTH = 500
+
+      class << self
+        # Read source code context for a specific file and line
+        # Returns nil if file cannot be read
+        def read_context(file_path, line_number, context_lines: DEFAULT_CONTEXT_LINES)
+          return nil if blank?(file_path) || line_number.nil? || line_number < 1
+
+          # Resolve to absolute path
+          full_path = resolve_path(file_path)
+          return nil unless full_path && File.exist?(full_path) && File.readable?(full_path)
+
+          # Skip binary files and very large files
+          return nil if binary_file?(full_path)
+          return nil if File.size(full_path) > 1_000_000 # Skip files > 1MB
+
+          begin
+            lines = File.readlines(full_path)
+            total_lines = lines.length
+
+            return nil if line_number > total_lines
+
+            # Calculate range (0-indexed internally)
+            start_idx = [line_number - context_lines - 1, 0].max
+            end_idx = [line_number + context_lines - 1, total_lines - 1].min
+
+            # Build context structure
+            lines_before = []
+            (start_idx...(line_number - 1)).each do |i|
+              lines_before << truncate_line(lines[i]&.chomp || "")
+            end
+
+            line_content = truncate_line(lines[line_number - 1]&.chomp || "")
+
+            lines_after = []
+            (line_number..end_idx).each do |i|
+              lines_after << truncate_line(lines[i]&.chomp || "")
+            end
+
+            {
+              lines_before: lines_before,
+              line_content: line_content,
+              lines_after: lines_after,
+              start_line: start_idx + 1
+            }
+          rescue StandardError => e
+            # Log but don't fail
+            if defined?(Rails.logger)
+              Rails.logger.debug "[ActiveRabbit] Could not read source for #{file_path}: #{e.message}"
+            end
+            nil
+          end
+        end
+
+        # Parse a backtrace and add source context to each frame
+        def parse_backtrace_with_source(backtrace, context_lines: DEFAULT_CONTEXT_LINES)
+          return [] if blank?(backtrace)
+
+          frames = backtrace.is_a?(Array) ? backtrace : backtrace.split("\n")
+
+          frames.map.with_index do |frame_line, index|
+            parse_frame_with_source(frame_line, index, context_lines: context_lines)
+          end.compact
+        end
+
+        # Parse a single frame and add source context
+        def parse_frame_with_source(frame_line, index = 0, context_lines: DEFAULT_CONTEXT_LINES)
+          return nil if blank?(frame_line)
+
+          # Parse frame: "path/to/file.rb:123:in `method_name'"
+          pattern = /^(.+?):(\d+)(?::in [`'](.+?)'?)?\s*$/
+
+          if (match = frame_line.match(pattern))
+            file = match[1]
+            line = match[2].to_i
+            method_name = match[3]
+
+            in_app = in_app_frame?(file)
+            frame_type = classify_frame(file)
+
+            # Only read source for in-app frames to save bandwidth
+            source_context = if in_app
+                               read_context(file, line, context_lines: context_lines)
+                             end
+
+            {
+              file: file,
+              line: line,
+              method: method_name,
+              raw: frame_line,
+              in_app: in_app,
+              frame_type: frame_type,
+              index: index,
+              source_context: source_context
+            }
+          else
+            # Fallback for non-standard frame formats
+            {
+              file: nil,
+              line: nil,
+              method: nil,
+              raw: frame_line,
+              in_app: false,
+              frame_type: :unknown,
+              index: index,
+              source_context: nil
+            }
+          end
+        end
+
+        private
+
+        # Helper to check for blank values (works without Rails)
+        def blank?(value)
+          value.nil? || (value.respond_to?(:empty?) && value.empty?) || (value.is_a?(String) && value.strip.empty?)
+        end
+
+        def resolve_path(file_path)
+          return nil if blank?(file_path)
+
+          # Already absolute
+          if file_path.start_with?("/")
+            return file_path if File.exist?(file_path)
+          end
+
+          # Try relative to Rails root
+          if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+            full_path = Rails.root.join(file_path)
+            return full_path.to_s if File.exist?(full_path)
+          end
+
+          # Try relative to current directory
+          if File.exist?(file_path)
+            return File.expand_path(file_path)
+          end
+
+          # Try common app paths
+          ["app/", "lib/", "config/"].each do |prefix|
+            if file_path.start_with?(prefix) && defined?(Rails) && Rails.root
+              full_path = Rails.root.join(file_path)
+              return full_path.to_s if File.exist?(full_path)
+            end
+          end
+
+          nil
+        end
+
+        def in_app_frame?(file)
+          return false if blank?(file)
+
+          # In-app if it's in app/, lib/, or similar app directories
+          # and NOT in gems or ruby stdlib
+          (file.start_with?("app/") ||
+           file.start_with?("lib/") ||
+           file.start_with?("config/") ||
+           (file.include?("/app/") && !file.include?("/gems/"))) &&
+            !file.include?("/gems/") &&
+            !file.include?("/ruby/") &&
+            !file.include?("/rubygems/") &&
+            !file.include?("/.bundle/")
+        end
+
+        def classify_frame(file)
+          return :unknown if blank?(file)
+
+          case file
+          when /controllers/ then :controller
+          when /models/ then :model
+          when /services/ then :service
+          when /jobs/ then :job
+          when /views/ then :view
+          when /helpers/ then :helper
+          when /mailers/ then :mailer
+          when /concerns/ then :concern
+          when /lib\// then :library
+          when /gems?[\/\\]/ then :gem
+          else :other
+          end
+        end
+
+        def binary_file?(path)
+          # Check first few bytes for binary content
+          File.open(path, "rb") do |f|
+            bytes = f.read(512)
+            return false if bytes.nil? || bytes.empty?
+            # If more than 30% are non-printable, consider binary
+            non_printable = bytes.bytes.count { |b| b < 32 && ![9, 10, 13].include?(b) }
+            (non_printable.to_f / bytes.length) > 0.3
+          end
+        rescue StandardError
+          false
+        end
+
+        def truncate_line(line)
+          return "" if line.nil?
+          line.length > MAX_LINE_LENGTH ? line[0, MAX_LINE_LENGTH] + "..." : line
+        end
+      end
+    end
+  end
+end

data/lib/active_rabbit/client/version.rb

@@ -1,5 +1,5 @@
 module ActiveRabbit
   module Client
-    VERSION = "0.5.2"
+    VERSION = "0.6.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerabbit-ai
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Alex Shapalov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-23 00:00:00.000000000 Z
+date: 2026-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -101,6 +101,7 @@ files:
 - lib/active_rabbit/client/pii_scrubber.rb
 - lib/active_rabbit/client/railtie.rb
 - lib/active_rabbit/client/sidekiq_middleware.rb
+- lib/active_rabbit/client/source_code_reader.rb
 - lib/active_rabbit/client/version.rb
 - lib/active_rabbit/middleware/error_capture_middleware.rb
 - lib/active_rabbit/reporting.rb