lapsoss 0.1.0

data/lib/lapsoss/adapters/sentry_adapter.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "../http_client"
+require_relative "../backtrace_processor"
+
+module Lapsoss
+  module Adapters
+    class SentryAdapter < Base
+      PROTOCOL_VERSION = 7
+      CONTENT_TYPE = "application/x-sentry-envelope"
+      GZIP_THRESHOLD = 1024 * 30 # 30KB
+      USER_AGENT = "lapsoss/#{Lapsoss::VERSION}"
+
+      def initialize(name, settings = {})
+        super(name, settings)
+        validate_settings!
+        return unless settings[:dsn]
+
+        @dsn = parse_dsn(settings[:dsn])
+        @protocol_version = settings[:protocol_version] || PROTOCOL_VERSION
+        @client = create_http_client(sentry_api_uri)
+        @backtrace_processor = BacktraceProcessor.new
+      end
+
+      def capture(event)
+        return unless @client
+
+        envelope = build_envelope(event)
+        body, compressed = serialize_envelope(envelope)
+
+        headers = build_headers(compressed)
+
+        begin
+          @client.post(@dsn[:path], body: body, headers: headers)
+        rescue DeliveryError => e
+          # Log the error and potentially notify error handler
+          Lapsoss.configuration.logger&.error("[Lapsoss::SentryAdapter] Failed to deliver event: #{e.message}")
+          Lapsoss.configuration.error_handler&.call(e)
+
+          # Re-raise to let the caller know delivery failed
+          raise
+        end
+      end
+
+      def shutdown
+        @client&.shutdown
+        super
+      end
+
+      def capabilities
+        super.merge(
+          code_context: true,
+          breadcrumbs: true
+        )
+      end
+
+      private
+
+      def build_envelope(event)
+        # This structure is specific to the Sentry Envelope format
+        header = {
+          event_id: event.context[:event_id] || SecureRandom.uuid,
+          sent_at: Time.now.iso8601,
+          sdk: { name: "lapsoss", version: Lapsoss::VERSION }
+        }
+
+        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]
+      end
+
+      def serialize_envelope(envelope)
+        header, item_header, item_payload = envelope
+
+        body = [
+          JSON.generate(header),
+          JSON.generate(item_header),
+          JSON.generate(item_payload)
+        ].join("\n")
+
+        if body.bytesize >= GZIP_THRESHOLD
+          [Zlib.gzip(body), true]
+        else
+          [body, false]
+        end
+      end
+
+      def build_event_payload(event)
+        {
+          platform: "ruby",
+          level: map_level(event.level),
+          timestamp: event.timestamp.to_f,
+          environment: @settings[:environment],
+          release: @settings[:release],
+          tags: event.context[:tags],
+          user: event.context[:user],
+          extra: event.context[:extra],
+          breadcrumbs: { values: event.context[:breadcrumbs] || [] }
+        }.merge(event_specific_payload(event))
+      end
+
+      def event_specific_payload(event)
+        case event.type
+        when :exception
+          {
+            exception: {
+              values: [{
+                type: event.exception.class.name,
+                value: event.exception.message,
+                stacktrace: { frames: parse_backtrace(event.exception.backtrace) }
+              }]
+            }
+          }
+        when :message
+          { message: event.message }
+        else
+          {}
+        end
+      end
+
+      def build_headers(compressed)
+        {
+          "Content-Type" => CONTENT_TYPE,
+          "X-Sentry-Auth" => auth_header,
+          "Content-Encoding" => ("gzip" if compressed)
+        }.compact
+      end
+
+      def auth_header
+        timestamp = Time.now.to_i
+        "Sentry sentry_version=#{@protocol_version}, sentry_client=#{USER_AGENT}, sentry_timestamp=#{timestamp}, sentry_key=#{@dsn[:public_key]}"
+      end
+
+      def parse_dsn(dsn_string)
+        uri = URI.parse(dsn_string)
+
+        # Trust the DSN path as provided - don't try to reconstruct it
+        # The DSN should contain the exact endpoint path to use
+        # Examples:
+        # - Standard Sentry: https://public_key@sentry.io/1 -> /api/1/envelope/
+        # - 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"
+
+        # Use the DSN path directly - this is what the service expects
+        api_path = uri.path
+
+        # For standard Sentry DSNs (just /project_id), build the envelope path
+        if path_parts.length == 1 && project_id.match?(/^\d+$/)
+          api_path = "/api/#{project_id}/envelope/"
+        end
+
+        {
+          public_key: uri.user,
+          project_id: project_id,
+          path: api_path
+        }
+      end
+
+      def sentry_api_uri
+        uri = URI.parse(@settings[:dsn])
+        "#{uri.scheme}://#{uri.host}:#{uri.port}"
+      end
+
+      def parse_backtrace(backtrace)
+        frames = @backtrace_processor.process(backtrace)
+        formatted_frames = @backtrace_processor.format_frames(frames, :sentry)
+        # Sentry expects frames in reverse order (most recent first)
+        formatted_frames.reverse
+      end
+
+      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"
+        end
+      end
+
+      def validate_settings!
+        if @settings[:dsn]
+          validate_dsn!(@settings[:dsn], "Sentry DSN")
+        else
+          raise ValidationError, "Sentry DSN is required"
+        end
+      end
+    end
+  end
+end

data/lib/lapsoss/backtrace_frame.rb

@@ -0,0 +1,258 @@
+# 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
+    attr_reader :function, :module_name, :code_context, :block_info
+
+    # Backward compatibility aliases
+    alias_method :lineno, :line_number
+    alias_method :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
+
+    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
+      }.compact
+    end
+
+    def add_code_context(processor, context_lines = 3)
+      return unless @filename && @line_number && File.exist?(@filename)
+
+      @code_context = processor.get_code_context(@filename, @line_number, context_lines)
+    end
+
+    def valid?
+      @filename && (@line_number.nil? || @line_number >= 0)
+    end
+
+    def library_frame?
+      !@in_app
+    end
+
+    def app_frame?
+      @in_app
+    end
+
+    def excluded?
+      return false if @exclude_patterns.empty?
+
+      @exclude_patterns.any? do |pattern|
+        case pattern
+        when Regexp
+          @raw_line.match?(pattern)
+        when String
+          @raw_line.include?(pattern)
+        else
+          false
+        end
+      end
+    end
+
+    def relative_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(/^#{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
+        if match.names.include?('line') && match[:line]
+          @line_number = match[:line].match?(/^\d+$/) ? match[:line].to_i : 0
+        else
+          @line_number = nil
+        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
+      if @method_name.match(/block (?:\([^)]+\)\s+)?in (.+)/)
+        @block_info[:in_method] = $1
+      end
+    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.any? { |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
+      if @filename.start_with?('./')
+        @filename = File.expand_path(@filename)
+      end
+
+      # Handle Windows paths on Unix systems (for cross-platform stack traces)
+      if @filename.include?('\\') && !@filename.include?('/')
+        @filename = @filename.tr('\\', '/')
+      end
+
+      # Strip load paths to make traces more readable
+      if @load_paths.any?
+        original = @filename
+        @filename = relative_filename
+
+        # Keep absolute path if relative didn't work well
+        if @filename.empty? || @filename == '.'
+          @filename = original
+        end
+      end
+    end
+  end
+end