lapsoss 0.3.1 → 0.4.2

data/lib/lapsoss/adapters/rollbar_adapter.rb

@@ -1,41 +1,33 @@
 # frozen_string_literal: true
 
-require "json"
+require "active_support/core_ext/object/blank"
 require "socket"
-require "securerandom"
 
 module Lapsoss
   module Adapters
     class RollbarAdapter < Base
-      API_URI = "https://api.rollbar.com"
-      API_VERSION = "1"
-      JSON_CONTENT_TYPE = "application/json"
+      include Concerns::LevelMapping
+      include Concerns::EnvelopeBuilder
+      include Concerns::HttpDelivery
+
+      self.level_mapping_type = :rollbar
+      self.api_endpoint = "https://api.rollbar.com"
+      self.api_path = "/api/1/item/"
 
       def initialize(name, settings = {})
         super
-        @access_token = settings[:access_token] || ENV.fetch("ROLLBAR_ACCESS_TOKEN", nil)
-        @environment = settings[:environment] || Lapsoss.configuration.environment || "development"
-
-        validate_settings!
+        @access_token = settings[:access_token].presence || ENV["ROLLBAR_ACCESS_TOKEN"]
 
-        @client = create_http_client(API_URI)
-        @backtrace_processor = BacktraceProcessor.new
+        if @access_token.blank?
+          Lapsoss.configuration.logger&.warn "[Lapsoss::RollbarAdapter] No access token provided, adapter disabled"
+          @enabled = false
+        else
+          validate_api_key!(@access_token, "Rollbar access token", format: :alphanumeric)
+        end
       end
 
       def capture(event)
-        return unless enabled?
-
-        payload = build_payload(event)
-        return unless payload
-
-        response = @client.post("/api/#{API_VERSION}/item/", body: payload.to_json, headers: {
-                                  "Content-Type" => JSON_CONTENT_TYPE,
-                                  "X-Rollbar-Access-Token" => @access_token
-                                })
-
-        handle_response(response, event)
-      rescue StandardError => e
-        handle_delivery_error(e)
+        deliver(event.scrubbed)
       end
 
       def capabilities
@@ -47,149 +39,99 @@ module Lapsoss
         )
       end
 
-      def validate!
-        validate_settings!
-        true
-      end
-
       private
 
       def build_payload(event)
         {
           access_token: @access_token,
-          data: {
-            environment: @environment,
-            body: build_body(event),
-            level: map_level(event.level),
-            timestamp: event.timestamp.to_i,
-            code_version: event.context[:release]&.dig(:commit_sha),
-            platform: "ruby",
-            language: "ruby",
-            framework: detect_framework,
-            server: build_server_data,
-            person: build_person_data(event),
-            request: event.request_context,
-            custom: event.context[:custom] || {}
-          }
+          data: build_rollbar_data(event)
         }
       end
 
-      def build_body(event)
+      def build_rollbar_data(event)
+        {
+          environment: event.environment.presence || @settings[:environment] || "production",
+          body: build_rollbar_body(event),
+          level: map_level(event.level),
+          timestamp: event.timestamp.to_i,
+          code_version: @settings[:release].presence || git_sha,
+          platform: "ruby",
+          language: "ruby",
+          framework: detect_framework,
+          server: {
+            host: Socket.gethostname,
+            root: Rails.root.to_s.presence || Dir.pwd,
+            branch: git_branch,
+            code_version: git_sha
+          }.compact_blank,
+          person: build_person_data(event),
+          request: event.request_context,
+          custom: event.extra
+        }.compact_blank
+      end
+
+      def build_rollbar_body(event)
         case event.type
-        when :exception
+        in :exception if event.has_exception?
           {
             trace: {
-              frames: build_backtrace_frames(event.exception),
+              frames: format_backtrace_frames(event),
               exception: {
                 class: event.exception_type,
-                message: event.message,
+                message: event.exception_message,
                 description: event.exception.to_s
               }
             }
           }
-        when :message
+        in :message
           {
             message: {
               body: event.message
             }
           }
+        else
+          { message: { body: event.message || "Unknown event" } }
         end
       end
 
-      def build_backtrace_frames(exception)
-        return [] unless exception
+      def format_backtrace_frames(event)
+        return [] unless event.has_backtrace?
 
-        frames = @backtrace_processor.process_exception(exception, follow_cause: true)
-        formatted_frames = @backtrace_processor.format_frames(frames, :rollbar)
-        # Rollbar expects frames in reverse order (most recent first)
-        formatted_frames.reverse
+        # Rollbar expects frames in reverse order
+        event.backtrace_frames.map do |frame|
+          {
+            filename: frame.filename,
+            lineno: frame.lineno,
+            method: frame.method_name,
+            code: frame.code_context && frame.code_context[:context_line]
+          }.compact_blank
+        end.reverse
       end
 
       def build_person_data(event)
-        user = event.context[:user]
-        return nil unless user
+        user = event.user_context
+        return nil if user.blank?
 
         {
           id: user[:id]&.to_s,
           username: user[:username],
           email: user[:email]
-        }.compact
-      end
-
-      def build_server_data
-        {
-          host: Socket.gethostname,
-          root: defined?(Rails) ? Rails.root.to_s : Dir.pwd,
-          branch: git_branch,
-          code_version: git_sha
-        }.compact
-      end
-
-      def map_level(level)
-        case level
-        when :debug then "debug"
-        when :info then "info"
-        when :warning then "warning"
-        when :error then "error"
-        when :fatal then "critical"
-        else "error"
-        end
+        }.compact_blank.presence
       end
 
       def detect_framework
         return "rails" if defined?(Rails)
         return "sinatra" if defined?(Sinatra)
-
         "ruby"
       end
 
-      def git_branch
-        `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip.presence
-      rescue StandardError
-        nil
-      end
-
-      def git_sha
-        `git rev-parse HEAD 2>/dev/null`.strip.presence
-      rescue StandardError
-        nil
-      end
-
-      def handle_response(response, event)
-        case response.code.to_i
-        when 200
-          true
-        when 400
-          handle_client_error(response, event)
-        when 401
-          raise DeliveryError.new("Unauthorized: Invalid access token", response: response)
-        when 429
-          raise DeliveryError.new("Rate limit exceeded", response: response)
-        else
-          raise DeliveryError.new("Unexpected response: #{response.code}", response: response)
-        end
-      end
-
-      def handle_client_error(response, _event)
-        body = begin
-          JSON.parse(response.body)
-        rescue
-          {}
-        end
-        error_msg = body["message"] || "Bad request"
-
-        raise DeliveryError.new("Client error: #{error_msg}", response: response)
+      def adapter_specific_headers
+        { "X-Rollbar-Access-Token" => @access_token }
       end
 
+      # No longer need strict validation
       def validate_settings!
-        validate_presence!(@access_token, "Rollbar access token")
-        validate_api_key!(@access_token, "Rollbar access token", format: :alphanumeric) if @access_token
-        validate_environment!(@environment, "Rollbar environment") if @environment
-      end
-
-      def handle_delivery_error(error, response = nil)
-        message = "Rollbar delivery failed: #{error.message}"
-        raise DeliveryError.new(message, response: response, cause: error)
+        # Validation moved to initialize with logging
       end
     end
   end

data/lib/lapsoss/adapters/sentry_adapter.rb

@@ -1,190 +1,124 @@
 # frozen_string_literal: true
 
-require "securerandom"
+require "active_support/core_ext/object/blank"
+require "uri"
 
 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}".freeze
+      include Concerns::LevelMapping
+      include Concerns::EnvelopeBuilder
+      include Concerns::HttpDelivery
+
+      self.level_mapping_type = :sentry
+      self.envelope_format = :sentry_envelope
 
       def initialize(name, settings = {})
         super
-        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)
+        if settings[:dsn].blank?
+          Lapsoss.configuration.logger&.warn "[Lapsoss::SentryAdapter] No DSN provided, adapter disabled"
+          @enabled = false
+          return
+        end
 
-          # Re-raise to let the caller know delivery failed
-          raise
+        if validate_dsn!(settings[:dsn], "Sentry DSN")
+          @dsn = parse_dsn(settings[:dsn])
+          setup_endpoint
+        else
+          @enabled = false
         end
       end
 
-      def shutdown
-        @client&.shutdown
-        super
+      def capture(event)
+        deliver(event.scrubbed)
       end
 
       def capabilities
         super.merge(
           code_context: true,
-          breadcrumbs: true
+          breadcrumbs: true,
+          data_scrubbing: 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
+      def setup_endpoint
+        uri = URI.parse(@settings[:dsn])
+        self.class.api_endpoint = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+        self.class.api_path = build_api_path(uri)
       end
 
-      def build_headers(compressed)
-        {
-          "Content-Type" => CONTENT_TYPE,
-          "X-Sentry-Auth" => auth_header,
-          "Content-Encoding" => ("gzip" if compressed)
-        }.compact
-      end
+      def build_api_path(uri)
+        # Extract project ID from DSN path
+        project_id = uri.path.split("/").last
 
-      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]}"
+        # Standard Sentry envelope endpoint
+        "/api/#{project_id}/envelope/"
       end
 
       def parse_dsn(dsn_string)
         uri = URI.parse(dsn_string)
+        {
+          public_key: uri.user,
+          project_id: uri.path.split("/").last
+        }
+      end
 
-        # 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"
+      # Build Sentry-specific payload format
+      def build_payload(event)
+        # Sentry uses envelope format with headers and items
+        envelope_header = {
+          event_id: event.fingerprint.presence || SecureRandom.uuid,
+          sent_at: format_timestamp(event.timestamp),
+          sdk: sdk_info
+        }
 
-        # Use the DSN path directly - this is what the service expects
-        api_path = uri.path
+        item_header = {
+          type: event.type == :transaction ? "transaction" : "event",
+          content_type: "application/json"
+        }
 
-        # For standard Sentry DSNs (just /project_id), build the envelope path
-        api_path = "/api/#{project_id}/envelope/" if path_parts.length == 1 && project_id.match?(/^\d+$/)
+        item_payload = build_envelope_wrapper(event)
 
-        {
-          public_key: uri.user,
-          project_id: project_id,
-          path: api_path
-        }
+        # Sentry envelope is newline-delimited JSON
+        [
+          ActiveSupport::JSON.encode(envelope_header),
+          ActiveSupport::JSON.encode(item_header),
+          ActiveSupport::JSON.encode(item_payload)
+        ].join("\n")
       end
 
-      def sentry_api_uri
-        uri = URI.parse(@settings[:dsn])
-        "#{uri.scheme}://#{uri.host}:#{uri.port}"
+      # Override serialization for Sentry's envelope format
+      def serialize_payload(envelope_string)
+        # Sentry envelopes are already formatted, just compress if needed
+        if envelope_string.bytesize >= compress_threshold
+          [ ActiveSupport::Gzip.compress(envelope_string), true ]
+        else
+          [ envelope_string, false ]
+        end
       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
+      def adapter_specific_headers
+        timestamp = Time.current.to_i
+        {
+          "X-Sentry-Auth" => [
+            "Sentry sentry_version=7",
+            "sentry_client=#{user_agent}",
+            "sentry_timestamp=#{timestamp}",
+            "sentry_key=#{@dsn[:public_key]}"
+          ].join(", ")
+        }
       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
+      def build_delivery_headers(compressed: false, content_type: nil)
+        super(compressed: compressed, content_type: "application/x-sentry-envelope")
       end
 
+      # No longer need strict validation
       def validate_settings!
-        raise ValidationError, "Sentry DSN is required" unless @settings[:dsn]
-
-        validate_dsn!(@settings[:dsn], "Sentry DSN")
+        # Validation moved to initialize with logging
       end
     end
   end

data/lib/lapsoss/backtrace_processor.rb

@@ -338,7 +338,7 @@ module Lapsoss
       paths << Dir.pwd
 
       # Add gem paths
-      paths.concat(Gem.path.map { |p| File.join(p, "gems") }) if defined?(Gem)
+      paths.concat(Gem.path.map { File.join(_1, "gems") }) if defined?(Gem)
 
       # Sort by length (longest first) for better matching
       paths.uniq.sort_by(&:length).reverse

data/lib/lapsoss/breadcrumb.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Breadcrumb
+    module_function
+
+    # Canonical breadcrumb builder used by SDK
+    # message: String, type: Symbol, metadata: Hash, timestamp: Time (UTC)
+    def build(message, type: :default, metadata: {})
+      {
+        message: message.to_s,
+        type: type.to_sym,
+        metadata: metadata || {},
+        timestamp: Time.now.utc
+      }
+    end
+
+    # Normalize an incoming breadcrumb-like hash to the canonical structure
+    def normalize(crumb)
+      msg = crumb[:message] || crumb["message"]
+      type = crumb[:type] || crumb["type"] || :default
+      metadata = crumb[:metadata] || crumb["metadata"] || crumb[:data] || crumb["data"] || {}
+      ts = crumb[:timestamp] || crumb["timestamp"]
+      ts = ts.utc if ts.respond_to?(:utc)
+
+      {
+        message: msg.to_s,
+        type: type.to_sym,
+        metadata: metadata.is_a?(Hash) ? metadata : Hash(metadata),
+        timestamp: ts || Time.now.utc
+      }
+    end
+
+    # Adapter conversions
+    def for_sentry(crumbs)
+      crumbs.map do |c|
+        c = normalize(c)
+        {
+          timestamp: c[:timestamp].utc.iso8601,
+          message: c[:message],
+          type: c[:type].to_s,
+          data: c[:metadata]
+        }
+      end
+    end
+
+    def for_insight_hub(crumbs)
+      crumbs.map do |c|
+        c = normalize(c)
+        {
+          timestamp: c[:timestamp].utc.iso8601,
+          name: c[:message],
+          type: c[:type].to_s,
+          metaData: c[:metadata]
+        }
+      end
+    end
+  end
+end

data/lib/lapsoss/client.rb

@@ -13,7 +13,7 @@ module Lapsoss
       return unless @configuration.enabled
 
       with_scope(context) do |scope|
-        event = Event.new(
+        event = Event.build(
           type: :exception,
           level: :error,
           exception: exception,
@@ -27,7 +27,7 @@ module Lapsoss
       return unless @configuration.enabled
 
       with_scope(context) do |scope|
-        event = Event.new(
+        event = Event.build(
           type: :message,
           level: level,
           message: message,
@@ -103,9 +103,7 @@ module Lapsoss
     end
 
     def handle_capture_error(error)
-      return unless @configuration.logger
-
-      @configuration.logger.error("[Lapsoss] Failed to capture event: #{error.message}")
+      @configuration.logger.error("Failed to capture event: #{error.message}")
     end
   end
 end