lapsoss 0.2.0 → 0.3.1

data/lib/lapsoss/adapters/sentry_adapter.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'securerandom'
+require "securerandom"
 
 module Lapsoss
   module Adapters
     class SentryAdapter < Base
       PROTOCOL_VERSION = 7
-      CONTENT_TYPE = 'application/x-sentry-envelope'
+      CONTENT_TYPE = "application/x-sentry-envelope"
       GZIP_THRESHOLD = 1024 * 30 # 30KB
       USER_AGENT = "lapsoss/#{Lapsoss::VERSION}".freeze
 
@@ -60,14 +60,14 @@ module Lapsoss
         header = {
           event_id: event.context[:event_id] || SecureRandom.uuid,
           sent_at: Time.now.iso8601,
-          sdk: { name: 'lapsoss', version: Lapsoss::VERSION }
+          sdk: { name: "lapsoss", version: Lapsoss::VERSION }
         }
 
-        item_type = event.type == :transaction ? 'transaction' : 'event'
-        item_header = { type: item_type, content_type: 'application/json' }
+        item_type = event.type == :transaction ? "transaction" : "event"
+        item_header = { type: item_type, content_type: "application/json" }
         item_payload = build_event_payload(event)
 
-        [header, item_header, item_payload]
+        [ header, item_header, item_payload ]
       end
 
       def serialize_envelope(envelope)
@@ -80,15 +80,15 @@ module Lapsoss
         ].join("\n")
 
         if body.bytesize >= GZIP_THRESHOLD
-          [Zlib.gzip(body), true]
+          [ Zlib.gzip(body), true ]
         else
-          [body, false]
+          [ body, false ]
         end
       end
 
       def build_event_payload(event)
         {
-          platform: 'ruby',
+          platform: "ruby",
           level: map_level(event.level),
           timestamp: event.timestamp.to_f,
           environment: @settings[:environment],
@@ -105,11 +105,11 @@ module Lapsoss
         when :exception
           {
             exception: {
-              values: [{
+              values: [ {
                 type: event.exception.class.name,
                 value: event.exception.message,
                 stacktrace: { frames: parse_backtrace(event.exception.backtrace) }
-              }]
+              } ]
             }
           }
         when :message
@@ -121,9 +121,9 @@ module Lapsoss
 
       def build_headers(compressed)
         {
-          'Content-Type' => CONTENT_TYPE,
-          'X-Sentry-Auth' => auth_header,
-          'Content-Encoding' => ('gzip' if compressed)
+          "Content-Type" => CONTENT_TYPE,
+          "X-Sentry-Auth" => auth_header,
+          "Content-Encoding" => ("gzip" if compressed)
         }.compact
       end
 
@@ -142,8 +142,8 @@ module Lapsoss
         # - Custom service: https://public_key@custom.com/api/v1/errors -> /api/v1/errors
 
         # Extract project ID for auth header (usually the last path segment)
-        path_parts = uri.path.split('/').reject(&:empty?)
-        project_id = path_parts.last || 'unknown'
+        path_parts = uri.path.split("/").reject(&:empty?)
+        project_id = path_parts.last || "unknown"
 
         # Use the DSN path directly - this is what the service expects
         api_path = uri.path
@@ -172,19 +172,19 @@ module Lapsoss
 
       def map_level(level)
         case level
-        when :debug then 'debug'
-        when :info then 'info'
-        when :warn, :warning then 'warning'
-        when :error then 'error'
-        when :fatal then 'fatal'
-        else 'info'
+        when :debug then "debug"
+        when :info then "info"
+        when :warn, :warning then "warning"
+        when :error then "error"
+        when :fatal then "fatal"
+        else "info"
         end
       end
 
       def validate_settings!
-        raise ValidationError, 'Sentry DSN is required' unless @settings[:dsn]
+        raise ValidationError, "Sentry DSN is required" unless @settings[:dsn]
 
-        validate_dsn!(@settings[:dsn], 'Sentry DSN')
+        validate_dsn!(@settings[:dsn], "Sentry DSN")
       end
     end
   end

data/lib/lapsoss/backtrace_frame.rb

@@ -1,248 +1,79 @@
 # frozen_string_literal: true
 
 module Lapsoss
-  class BacktraceFrame
-    # Backtrace line patterns for different Ruby implementations
-    BACKTRACE_PATTERNS = [
-      # Standard Ruby format: filename.rb:123:in `method_name'
-      /^(?<filename>[^:]+):(?<line>\d+):in [`'](?<method>.*?)[`']$/,
-
-      # Ruby format without method: filename.rb:123
-      /^(?<filename>[^:]+):(?<line>\d+)$/,
-
-      # JRuby format: filename.rb:123:in method_name
-      /^(?<filename>[^:]+):(?<line>\d+):in (?<method>.*)$/,
-
-      # Eval'd code: (eval):123:in `method_name'
-      /^\(eval\):(?<line>\d+):in [`'](?<method>.*?)[`']$/,
-
-      # Block format: filename.rb:123:in `block in method_name'
-      /^(?<filename>[^:]+):(?<line>\d+):in [`']block (?<block_level>\(\d+\s+levels\)\s+)?in (?<method>.*?)[`']$/,
-
-      # Native extension format: [native_gem] filename.c:123:in `method_name'
-      /^\[(?<native_gem>[^\]]+)\]\s*(?<filename>[^:]+):(?<line>\d+):in [`'](?<method>.*?)[`']$/,
-
-      # Java backtrace format: org.jruby.Ruby.runScript(Ruby.java:123)
-      /^(?<method>[^(]+)\((?<filename>[^:)]+):(?<line>\d+)\)$/,
-
-      # Java backtrace format without line number: org.jruby.Ruby.runScript(Ruby.java)
-      /^(?<method>[^(]+)\((?<filename>[^:)]+)\)$/,
-
-      # Malformed Ruby format with invalid line number: filename.rb:abc:in `method'
-      /^(?<filename>[^:]+):(?<line>[^:]*):in [`'](?<method>.*?)[`']$/,
-
-      # Malformed Ruby format with missing line number: filename.rb::in `method'
-      /^(?<filename>[^:]+)::in [`'](?<method>.*?)[`']$/,
-
-      # Malformed Ruby format with missing method: filename.rb:123:in
-      /^(?<filename>[^:]+):(?<line>\d+):in$/
-    ].freeze
-
-    # Common paths that indicate library/gem code
-    LIBRARY_INDICATORS = [
-      '/gems/',
-      '/.bundle/',
-      '/vendor/',
-      '/ruby/',
-      '(eval)',
-      '(irb)',
-      '/lib/ruby/',
-      '/rbenv/',
-      '/rvm/',
-      '/usr/lib/ruby',
-      '/System/Library/Frameworks'
-    ].freeze
-
-    attr_reader :filename, :line_number, :method_name, :in_app, :raw_line, :function, :module_name, :code_context,
-                :block_info
-
+  BacktraceFrame = Data.define(
+    :filename,
+    :line_number,
+    :method_name,
+    :in_app,
+    :raw_line,
+    :function,
+    :module_name,
+    :code_context,
+    :block_info
+  ) do
     # Backward compatibility aliases
-    alias lineno line_number
-    alias raw raw_line
-
-    def initialize(raw_line, in_app_patterns: [], exclude_patterns: [], load_paths: [])
-      @raw_line = raw_line.to_s.strip
-      @in_app_patterns = Array(in_app_patterns)
-      @exclude_patterns = Array(exclude_patterns)
-      @load_paths = Array(load_paths)
-
-      parse_backtrace_line
-      determine_app_status
-      normalize_paths
-    end
+    alias_method :lineno, :line_number
+    alias_method :raw, :raw_line
 
     def to_h
       {
-        filename: @filename,
-        line_number: @line_number,
-        method: @method_name,
-        function: @function,
-        module: @module_name,
-        in_app: @in_app,
-        code_context: @code_context,
-        raw: @raw_line
+        filename: filename,
+        line_number: line_number,
+        method: method_name,
+        function: function,
+        module: module_name,
+        in_app: in_app,
+        code_context: code_context,
+        raw: raw_line
       }.compact
     end
 
     def add_code_context(processor, context_lines = 3)
-      return unless @filename && @line_number && File.exist?(@filename)
+      return unless filename && line_number && File.exist?(filename)
 
-      @code_context = processor.get_code_context(@filename, @line_number, context_lines)
+      with(code_context: processor.get_code_context(filename, line_number, context_lines))
     end
 
     def valid?
-      @filename && (@line_number.nil? || @line_number >= 0)
+      filename && (line_number.nil? || line_number >= 0)
     end
 
     def library_frame?
-      !@in_app
+      !in_app
     end
 
     def app_frame?
-      @in_app
+      in_app
     end
 
-    def excluded?
-      return false if @exclude_patterns.empty?
+    def excluded?(exclude_patterns = [])
+      return false if exclude_patterns.empty?
 
-      @exclude_patterns.any? do |pattern|
+      exclude_patterns.any? do |pattern|
         case pattern
         when Regexp
-          @raw_line.match?(pattern)
+          raw_line.match?(pattern)
         when String
-          @raw_line.include?(pattern)
+          raw_line.include?(pattern)
         else
           false
         end
       end
     end
 
-    def relative_filename
-      return @filename unless @filename && @load_paths.any?
+    def relative_filename(load_paths = [])
+      return filename unless filename && load_paths.any?
 
       # Try to make path relative to load paths
-      @load_paths.each do |load_path|
-        if @filename.start_with?(load_path)
-          relative = @filename.sub(%r{^#{Regexp.escape(load_path)}/?}, '')
+      load_paths.each do |load_path|
+        if filename.start_with?(load_path)
+          relative = filename.sub(%r{^#{Regexp.escape(load_path)}/?}, "")
           return relative unless relative.empty?
         end
       end
 
-      @filename
-    end
-
-    private
-
-    def parse_backtrace_line
-      BACKTRACE_PATTERNS.each_with_index do |pattern, _pattern_index|
-        match = @raw_line.match(pattern)
-        next unless match
-
-        @filename = match[:filename]
-        # Handle malformed line numbers - convert invalid numbers to 0
-        @line_number = if match.names.include?('line') && match[:line]
-                         match[:line].match?(/^\d+$/) ? match[:line].to_i : 0
-                       end
-        @method_name = match.names.include?('method') ? match[:method] : nil
-        @native_gem = match.names.include?('native_gem') ? match[:native_gem] : nil
-        @block_level = match.names.include?('block_level') ? match[:block_level] : nil
-
-        # Set default method name for lines without methods (top-level execution)
-        @method_name = '<main>' if @method_name.nil?
-
-        process_method_info
-        return
-      end
-
-      # Fallback: treat entire line as filename if no pattern matches
-      @filename = @raw_line
-      @line_number = nil
-      @method_name = '<main>'
-    end
-
-    def process_method_info
-      return unless @method_name
-
-      # Extract module/class and method information
-      if @method_name.include?('.')
-        # Class method: Module.method
-        parts = @method_name.split('.', 2)
-        @module_name = parts[0] if parts[0] != @method_name
-        @function = parts[1] || @method_name
-      elsif @method_name.include?('#')
-        # Instance method: Module#method
-        parts = @method_name.split('#', 2)
-        @module_name = parts[0] if parts[0] != @method_name
-        @function = parts[1] || @method_name
-      elsif @method_name.start_with?('block')
-        # Block method: process specially
-        @function = @method_name
-        process_block_info
-      else
-        @function = @method_name
-      end
-
-      # Clean up function name
-      @function = @function&.strip
-      @module_name = @module_name&.strip
-    end
-
-    def process_block_info
-      return unless @method_name&.include?('block')
-
-      @block_info = {
-        type: :block,
-        level: @block_level,
-        in_method: nil
-      }
-
-      # Extract the method that contains the block
-      @block_info[:in_method] = ::Regexp.last_match(1) if @method_name =~ /block (?:\([^)]+\)\s+)?in (.+)/
-    end
-
-    def determine_app_status
-      return @in_app = false unless @filename
-
-      # Check explicit patterns first
-      if @in_app_patterns.any?
-        @in_app = @in_app_patterns.any? do |pattern|
-          case pattern
-          when Regexp
-            @filename.match?(pattern)
-          when String
-            @filename.include?(pattern)
-          else
-            false
-          end
-        end
-        return
-      end
-
-      # Default heuristics: check for library indicators
-      @in_app = LIBRARY_INDICATORS.none? { |indicator| @filename.include?(indicator) }
-
-      # Special cases
-      @in_app = false if @native_gem # Native extensions are not app code
-      @in_app = false if @filename.start_with?('(') && @filename.end_with?(')') # Eval, irb, etc.
-    end
-
-    def normalize_paths
-      return unless @filename
-
-      # Expand relative paths
-      @filename = File.expand_path(@filename) if @filename.start_with?('./')
-
-      # Handle Windows paths on Unix systems (for cross-platform stack traces)
-      @filename = @filename.tr('\\', '/') if @filename.include?('\\') && @filename.exclude?('/')
-
-      # Strip load paths to make traces more readable
-      return unless @load_paths.any?
-
-      original = @filename
-      @filename = relative_filename
-
-      # Keep absolute path if relative didn't work well
-      @filename = original if @filename.empty? || @filename == '.'
+      filename
     end
   end
 end

data/lib/lapsoss/backtrace_frame_factory.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  class BacktraceFrameFactory
+    # Backtrace line patterns for different Ruby implementations
+    BACKTRACE_PATTERNS = [
+      # Standard Ruby format: filename.rb:123:in `method_name'
+      /^(?<filename>[^:]+):(?<line>\d+):in [`'](?<method>.*?)[`']$/,
+
+      # Ruby format without method: filename.rb:123
+      /^(?<filename>[^:]+):(?<line>\d+)$/,
+
+      # JRuby format: filename.rb:123:in method_name
+      /^(?<filename>[^:]+):(?<line>\d+):in (?<method>.*)$/,
+
+      # Eval'd code: (eval):123:in `method_name'
+      /^\(eval\):(?<line>\d+):in [`'](?<method>.*?)[`']$/,
+
+      # Block format: filename.rb:123:in `block in method_name'
+      /^(?<filename>[^:]+):(?<line>\d+):in [`']block (?<block_level>\(\d+\s+levels\)\s+)?in (?<method>.*?)[`']$/,
+
+      # Native extension format: [native_gem] filename.c:123:in `method_name'
+      /^\[(?<native_gem>[^\]]+)\]\s*(?<filename>[^:]+):(?<line>\d+):in [`'](?<method>.*?)[`']$/,
+
+      # Java backtrace format: org.jruby.Ruby.runScript(Ruby.java:123)
+      /^(?<method>[^(]+)\((?<filename>[^:)]+):(?<line>\d+)\)$/,
+
+      # Java backtrace format without line number: org.jruby.Ruby.runScript(Ruby.java)
+      /^(?<method>[^(]+)\((?<filename>[^:)]+)\)$/,
+
+      # Malformed Ruby format with invalid line number: filename.rb:abc:in `method'
+      /^(?<filename>[^:]+):(?<line>[^:]*):in [`'](?<method>.*?)[`']$/,
+
+      # Malformed Ruby format with missing line number: filename.rb::in `method'
+      /^(?<filename>[^:]+)::in [`'](?<method>.*?)[`']$/,
+
+      # Malformed Ruby format with missing method: filename.rb:123:in
+      /^(?<filename>[^:]+):(?<line>\d+):in$/
+    ].freeze
+
+    # Common paths that indicate library/gem code
+    LIBRARY_INDICATORS = [
+      "/gems/",
+      "/.bundle/",
+      "/vendor/",
+      "/ruby/",
+      "(eval)",
+      "(irb)",
+      "/lib/ruby/",
+      "/rbenv/",
+      "/rvm/",
+      "/usr/lib/ruby",
+      "/System/Library/Frameworks"
+    ].freeze
+
+    def self.from_raw_line(raw_line, in_app_patterns: [], exclude_patterns: [], load_paths: [])
+      new(in_app_patterns: in_app_patterns, exclude_patterns: exclude_patterns, load_paths: load_paths)
+        .create_frame(raw_line)
+    end
+
+    def initialize(in_app_patterns: [], exclude_patterns: [], load_paths: [])
+      @in_app_patterns = Array(in_app_patterns)
+      @exclude_patterns = Array(exclude_patterns)
+      @load_paths = Array(load_paths)
+    end
+
+    def create_frame(raw_line)
+      @raw_line = raw_line.to_s.strip
+      parse_backtrace_line
+    end
+
+    private
+
+    def parse_backtrace_line
+      filename, line_number, method_name, function, module_name, block_info = parse_line_components
+
+      in_app = determine_app_status(filename)
+      filename = normalize_path(filename) if filename
+
+      BacktraceFrame.new(
+        filename: filename,
+        line_number: line_number,
+        method_name: method_name,
+        in_app: in_app,
+        raw_line: @raw_line,
+        function: function,
+        module_name: module_name,
+        code_context: nil,
+        block_info: block_info
+      )
+    end
+
+    def parse_line_components
+      BACKTRACE_PATTERNS.each do |pattern|
+        match = @raw_line.match(pattern)
+        next unless match
+
+        filename = match[:filename]
+        # Handle malformed line numbers - convert invalid numbers to 0
+        line_number = if match.names.include?("line") && match[:line]
+                        match[:line].match?(/^\d+$/) ? match[:line].to_i : 0
+        end
+        method_name = match.names.include?("method") ? match[:method] : nil
+        match.names.include?("native_gem") ? match[:native_gem] : nil
+        block_level = match.names.include?("block_level") ? match[:block_level] : nil
+
+        # Set default method name for lines without methods (top-level execution)
+        method_name = "<main>" if method_name.nil?
+
+        function, module_name, block_info = process_method_info(method_name, block_level)
+
+        return [ filename, line_number, method_name, function, module_name, block_info ]
+      end
+
+      # Fallback: treat entire line as filename if no pattern matches
+      [ @raw_line, nil, "<main>", "<main>", nil, nil ]
+    end
+
+    def process_method_info(method_name, block_level)
+      return [ nil, nil, nil ] unless method_name
+
+      function = nil
+      module_name = nil
+      block_info = nil
+
+      # Extract module/class and method information
+      if method_name.include?(".")
+        # Class method: Module.method
+        parts = method_name.split(".", 2)
+        module_name = parts[0] if parts[0] != method_name
+        function = parts[1] || method_name
+      elsif method_name.include?("#")
+        # Instance method: Module#method
+        parts = method_name.split("#", 2)
+        module_name = parts[0] if parts[0] != method_name
+        function = parts[1] || method_name
+      elsif method_name.start_with?("block")
+        # Block method: process specially
+        function = method_name
+        block_info = process_block_info(method_name, block_level)
+      else
+        function = method_name
+      end
+
+      # Clean up function name
+      function = function&.strip
+      module_name = module_name&.strip
+
+      [ function, module_name, block_info ]
+    end
+
+    def process_block_info(method_name, block_level)
+      return nil unless method_name&.include?("block")
+
+      block_info = {
+        type: :block,
+        level: block_level,
+        in_method: nil
+      }
+
+      # Extract the method that contains the block
+      block_info[:in_method] = ::Regexp.last_match(1) if method_name =~ /block (?:\([^)]+\)\s+)?in (.+)/
+
+      block_info
+    end
+
+    def determine_app_status(filename)
+      return false unless filename
+
+      # Check explicit patterns first
+      if @in_app_patterns.any?
+        return @in_app_patterns.any? do |pattern|
+          case pattern
+          when Regexp
+            filename.match?(pattern)
+          when String
+            filename.include?(pattern)
+          else
+            false
+          end
+        end
+      end
+
+      # Default heuristics: check for library indicators
+      in_app = LIBRARY_INDICATORS.none? { |indicator| filename.include?(indicator) }
+
+      # Special cases
+      in_app = false if filename.start_with?("(") && filename.end_with?(")") # Eval, irb, etc.
+
+      in_app
+    end
+
+    def normalize_path(filename)
+      return filename unless filename
+
+      # Expand relative paths
+      filename = File.expand_path(filename) if filename.start_with?("./")
+
+      # Handle Windows paths on Unix systems (for cross-platform stack traces)
+      filename = filename.tr("\\", "/") if filename.include?("\\") && filename.exclude?("/")
+
+      # Strip load paths to make traces more readable
+      return filename unless @load_paths.any?
+
+      original = filename
+      filename = make_relative_filename(filename)
+
+      # Keep absolute path if relative didn't work well
+      filename = original if filename.empty? || filename == "."
+
+      filename
+    end
+
+    def make_relative_filename(filename)
+      return filename unless filename && @load_paths.any?
+
+      # Try to make path relative to load paths
+      @load_paths.each do |load_path|
+        if filename.start_with?(load_path)
+          relative = filename.sub(%r{^#{Regexp.escape(load_path)}/?}, "")
+          return relative unless relative.empty?
+        end
+      end
+
+      filename
+    end
+  end
+end