lapsoss 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c6f63828ebac1dc0ff437bc6bc2371170c244fe0ff5195ce8ddc0f2cec21731
-  data.tar.gz: d0678fb7bda03a75851b6ab06590cd9ab7bd6464878367a7d5e48d9631d26be4
+  metadata.gz: c0faf08671ef4e1b0b36ccc9e29900b8e8b5e4a78ac61ffea6269294efee5881
+  data.tar.gz: b2c76c33817f3a939388970d21c5fc341ad6ce46e0ce20ef9b71ca5b5c565ae0
 SHA512:
-  metadata.gz: 6e725dfbd5841bfd68af3deaa61d5106f966ada89b7e47515eb2d8e1b04327501fa51ba475ff6e6deb971cf3a2370b87b3da7da0f539f35e109b1d555897e55d
-  data.tar.gz: 3a2ece11a9adaf5738a05c90da27096e7060be9e7fa93f90a64616f8bb1776040dcf27d1f375bb5c21593e3580f2af63edeed53296582db77088067e2181b474
+  metadata.gz: 5cfb22826215ffc2473410d6e984ecbd93f74ec0c011e742d7246549b29c1d77b9cb81c774cab311748c0b39cbfd9b9eccfdbb4324aa6da7a632ba8634eb3b19
+  data.tar.gz: f641a491be8007a0bc6780094803724f66efc79aa1e10cadbb1ac96c84a8ff30af119c763e1611dc3e2218305c4d0b5958b6f5c5f2863c7b5694b5ff7c9f0856

data/README.md

@@ -31,6 +31,11 @@ Lapsoss.configure do |config|
 end
 ```
 
+## Requirements
+
+- Ruby 3.3+
+- Rails 7.2+
+
 ## Installation
 
 ```ruby

data/lib/lapsoss/adapters/appsignal_adapter.rb

@@ -8,7 +8,6 @@ module Lapsoss
     class AppsignalAdapter < Base
       PUSH_API_URI = "https://push.appsignal.com"
       ERRORS_API_URI = "https://appsignal-endpoint.net"
-      JSON_CONTENT_TYPE = "application/json; charset=UTF-8"
 
       def initialize(name, settings = {})
         super
@@ -17,7 +16,20 @@ module Lapsoss
         @app_name = settings[:app_name] || ENV.fetch("APPSIGNAL_APP_NAME", nil)
         @environment = Lapsoss.configuration.environment
 
-        validate_settings!
+        # Just log if keys look unusual but don't fail
+        if @push_api_key.present?
+          validate_api_key!(@push_api_key, "AppSignal push API key", format: :uuid)
+        end
+
+        if @frontend_api_key.present?
+          validate_api_key!(@frontend_api_key, "AppSignal frontend API key", format: :uuid)
+        end
+
+        if @push_api_key.blank? && @frontend_api_key.blank?
+          Lapsoss.configuration.logger&.warn "[Lapsoss::AppsignalAdapter] No API keys provided, adapter disabled"
+          @enabled = false
+          return
+        end
 
         @push_client = create_http_client(PUSH_API_URI) if @push_api_key
         @errors_client = create_http_client(ERRORS_API_URI) if @frontend_api_key
@@ -30,10 +42,10 @@ module Lapsoss
         return unless payload
 
         path = "/errors?api_key=#{@frontend_api_key}"
-        headers = { "Content-Type" => JSON_CONTENT_TYPE }
+        headers = default_headers(content_type: json_content_type)
 
         begin
-          @errors_client.post(path, body: JSON.generate(payload), headers: headers)
+          @errors_client.post(path, body: ActiveSupport::JSON.encode(payload), headers: headers)
         rescue DeliveryError => e
           # Log the error and potentially notify error handler
           Lapsoss.configuration.logger&.error("[Lapsoss::AppsignalAdapter] Failed to deliver event: #{e.message}")
@@ -120,15 +132,9 @@ module Lapsoss
         (hash || {}).transform_keys(&:to_s).transform_values(&:to_s)
       end
 
+      # No longer need strict validation
       def validate_settings!
-        unless @push_api_key || @frontend_api_key
-          raise ValidationError, "AppSignal API key is required (either push_api_key or frontend_api_key)"
-        end
-
-        validate_api_key!(@push_api_key, "AppSignal push API key", format: :uuid) if @push_api_key
-        validate_api_key!(@frontend_api_key, "AppSignal frontend API key", format: :uuid) if @frontend_api_key
-        validate_presence!(@app_name, "AppSignal app name") if @app_name
-        validate_environment!(@environment, "AppSignal environment") if @environment
+        # Validation moved to initialize with logging
       end
     end
   end

data/lib/lapsoss/adapters/base.rb

@@ -5,6 +5,9 @@ module Lapsoss
     class Base
       include Validators
 
+      USER_AGENT = "lapsoss/#{Lapsoss::VERSION}".freeze
+      JSON_CONTENT_TYPE = "application/json; charset=UTF-8".freeze
+
       attr_reader :name, :settings
 
       def initialize(name, settings = {})
@@ -80,6 +83,22 @@ module Lapsoss
 
         HttpClient.new(uri, transport_config)
       end
+
+      def user_agent
+        USER_AGENT
+      end
+
+      def json_content_type
+        JSON_CONTENT_TYPE
+      end
+
+      def default_headers(content_type: nil, gzip: false, extra: {})
+        headers = { "User-Agent" => user_agent }
+        headers["Content-Type"] = content_type if content_type
+        headers["Content-Encoding"] = "gzip" if gzip
+        headers.merge!(extra) if extra && !extra.empty?
+        headers
+      end
     end
   end
 end

data/lib/lapsoss/adapters/concerns/envelope_builder.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/object/blank"
+require "active_support/json"
+require "active_support/core_ext/numeric/bytes"
+require "active_support/gzip"
+require "securerandom"
+
+module Lapsoss
+  module Adapters
+    module Concerns
+      module EnvelopeBuilder
+        extend ActiveSupport::Concern
+
+        GZIP_THRESHOLD = 30.kilobytes
+
+        included do
+          class_attribute :envelope_format, default: :json
+          class_attribute :compress_threshold, default: GZIP_THRESHOLD
+        end
+
+        # Build envelope with common structure
+        def build_envelope_wrapper(event)
+          envelope = {
+            id: event.fingerprint.presence || SecureRandom.uuid,
+            timestamp: format_timestamp(event.timestamp),
+            environment: event.environment.presence || "production",
+            level: map_level(event.level),
+            platform: "ruby",
+            sdk: sdk_info
+          }
+
+          # Add event-specific data
+          envelope.merge!(build_event_data(event))
+
+          # Add context data
+          envelope.merge!(
+            tags: event.tags.presence,
+            user: event.user_context.presence,
+            extra: event.extra.presence,
+            breadcrumbs: format_breadcrumbs(event.breadcrumbs)
+          ).compact_blank
+        end
+
+        # Format timestamp using AS helpers
+        def format_timestamp(time)
+          time = Time.current if time.blank?
+          time.in_time_zone("UTC").iso8601
+        end
+
+        # Format breadcrumbs consistently
+        def format_breadcrumbs(breadcrumbs)
+          return nil if breadcrumbs.blank?
+
+          breadcrumbs.map do |crumb|
+            {
+              timestamp: format_timestamp(crumb[:timestamp]),
+              type: crumb[:type].presence || "default",
+              message: crumb[:message],
+              data: crumb.except(:timestamp, :type, :message).presence
+            }.compact_blank
+          end
+        end
+
+        # SDK info for all adapters
+        def sdk_info
+          {
+            name: "lapsoss",
+            version: Lapsoss::VERSION,
+            packages: [ {
+              name: "lapsoss-ruby",
+              version: Lapsoss::VERSION
+            } ]
+          }
+        end
+
+        # Serialize and optionally compress
+        def serialize_payload(data, compress: :auto)
+          json = ActiveSupport::JSON.encode(data)
+
+          should_compress = case compress
+          when :auto then json.bytesize >= compress_threshold
+          when true then true
+          else false
+          end
+
+          if should_compress
+            [ ActiveSupport::Gzip.compress(json), true ]
+          else
+            [ json, false ]
+          end
+        end
+
+        private
+
+        # Override in adapter for specific event data
+        def build_event_data(event)
+          case event.type
+          in :exception
+            build_exception_data(event)
+          in :message
+            build_message_data(event)
+          else
+            {}
+          end
+        end
+
+        def build_exception_data(event)
+          {
+            exception: {
+              type: event.exception_type,
+              message: event.exception_message,
+              backtrace: event.backtrace_frames&.map(&:to_h)
+            }.compact_blank
+          }
+        end
+
+        def build_message_data(event)
+          {
+            message: event.message
+          }
+        end
+      end
+    end
+  end
+end

data/lib/lapsoss/adapters/concerns/http_delivery.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/notifications"
+require "active_support/core_ext/numeric/bytes"
+
+module Lapsoss
+  module Adapters
+    module Concerns
+      module HttpDelivery
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :api_endpoint, instance_writer: false
+          class_attribute :api_path, default: "/", instance_writer: false
+
+          # Memoized git info using AS
+          mattr_accessor :git_info_cache, default: {}
+        end
+
+        # Unified HTTP delivery with instrumentation
+        def deliver(event)
+          return unless enabled?
+
+          payload = build_payload(event)
+          return if payload.blank?
+
+          body, compressed = serialize_payload(payload)
+          headers = build_delivery_headers(compressed: compressed)
+
+          ActiveSupport::Notifications.instrument("deliver.lapsoss",
+            adapter: self.class.name,
+            event_type: event.type,
+            compressed: compressed,
+            size: body.bytesize
+          ) do
+            response = http_client.post(api_path, body: body, headers: headers)
+            handle_response(response)
+          end
+        rescue => error
+          handle_delivery_error(error)
+        end
+
+        # Common headers for all adapters
+        def build_delivery_headers(compressed: false, content_type: "application/json")
+          {
+            "User-Agent" => user_agent,
+            "Content-Type" => content_type,
+            "Content-Encoding" => ("gzip" if compressed),
+            "X-Lapsoss-Version" => Lapsoss::VERSION
+          }.merge(adapter_specific_headers).compact_blank
+        end
+
+        # Override for adapter-specific headers
+        def adapter_specific_headers
+          {}
+        end
+
+        # Git info with AS memoization
+        def git_branch
+          self.class.git_info_cache[:branch] ||= begin
+            `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip.presence
+          rescue
+            nil
+          end
+        end
+
+        def git_sha
+          self.class.git_info_cache[:sha] ||= begin
+            `git rev-parse HEAD 2>/dev/null`.strip.presence
+          rescue
+            nil
+          end
+        end
+
+        # Common response handling
+        def handle_response(response)
+          code = response.respond_to?(:status) ? response.status.to_i : response.code.to_i
+          case code
+          when 200..299
+            ActiveSupport::Notifications.instrument("success.lapsoss",
+              adapter: self.class.name,
+              response_code: code
+            )
+            true
+          when 429
+            raise DeliveryError.new("Rate limit exceeded", response: response)
+          when 401, 403
+            raise DeliveryError.new("Authentication failed", response: response)
+          when 400..499
+            handle_client_error(response)
+          else
+            raise DeliveryError.new("Server error: #{code}", response: response)
+          end
+        end
+
+        def handle_client_error(response)
+          body = ActiveSupport::JSON.decode(response.body) rescue {}
+          message = body["message"].presence || body["error"].presence || "Bad request"
+          raise DeliveryError.new("Client error: #{message}", response: response)
+        end
+
+        def handle_delivery_error(error)
+          ActiveSupport::Notifications.instrument("error.lapsoss",
+            adapter: self.class.name,
+            error: error.class.name,
+            message: error.message
+          )
+
+          Lapsoss.configuration.logger&.error("[#{self.class.name}] Delivery failed: #{error.message}")
+          Lapsoss.configuration.error_handler&.call(error)
+
+          raise error if error.is_a?(DeliveryError)
+          raise DeliveryError.new("Delivery failed: #{error.message}", cause: error)
+        end
+
+        private
+
+        def http_client
+          @http_client ||= create_http_client(api_endpoint)
+        end
+
+        def user_agent
+          "Lapsoss/#{Lapsoss::VERSION} Ruby/#{RUBY_VERSION} Rails/#{Rails.version if defined?(Rails)}"
+        end
+      end
+    end
+  end
+end

data/lib/lapsoss/adapters/concerns/level_mapping.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/hash/indifferent_access"
+
+module Lapsoss
+  module Adapters
+    module Concerns
+      module LevelMapping
+        extend ActiveSupport::Concern
+
+        # Single source of truth for level mappings
+        LEVEL_MAPPINGS = {
+          sentry: {
+            debug: "debug",
+            info: "info",
+            warn: "warning",
+            warning: "warning",
+            error: "error",
+            fatal: "fatal"
+          }.with_indifferent_access,
+
+          rollbar: {
+            debug: "debug",
+            info: "info",
+            warning: "warning",
+            error: "error",
+            fatal: "critical"
+          }.with_indifferent_access,
+
+          bugsnag: {
+            debug: "info",
+            info: "info",
+            warning: "warning",
+            error: "error",
+            fatal: "error"
+          }.with_indifferent_access,
+
+          appsignal: {
+            debug: "debug",
+            info: "info",
+            warning: "warning",
+            error: "error",
+            fatal: "error",
+            critical: "error"
+          }.with_indifferent_access
+        }.freeze
+
+        included do
+          # Define which mapping this adapter uses
+          class_attribute :level_mapping_type, default: :sentry
+        end
+
+        # Map level using the adapter's configured mapping
+        def map_level(level)
+          mapping = LEVEL_MAPPINGS[self.class.level_mapping_type]
+          mapping[level] || mapping[:info]
+        end
+
+        # Map severity (alias for bugsnag compatibility)
+        alias_method :map_severity, :map_level
+      end
+    end
+  end
+end

data/lib/lapsoss/adapters/insight_hub_adapter.rb

@@ -1,18 +1,23 @@
 # frozen_string_literal: true
 
-require "json"
+require "active_support/json"
 
 module Lapsoss
   module Adapters
     class InsightHubAdapter < Base
       API_URI = "https://notify.bugsnag.com"
-      JSON_CONTENT_TYPE = "application/json"
 
       def initialize(name, settings = {})
         super
         @api_key = settings[:api_key] || ENV.fetch("INSIGHT_HUB_API_KEY", nil)
 
-        validate_settings!
+        if @api_key.blank?
+          Lapsoss.configuration.logger&.warn "[Lapsoss::InsightHubAdapter] No API key provided, adapter disabled"
+          @enabled = false
+          return
+        else
+          validate_api_key!(@api_key, "Insight Hub API key", format: :alphanumeric)
+        end
 
         @client = create_http_client(API_URI)
         @backtrace_processor = BacktraceProcessor.new
@@ -24,11 +29,15 @@ module Lapsoss
         payload = build_payload(event)
         return unless payload
 
-        response = @client.post("/", body: payload.to_json, headers: {
-                                  "Content-Type" => JSON_CONTENT_TYPE,
-                                  "Bugsnag-Api-Key" => @api_key,
-                                  "Bugsnag-Payload-Version" => "5"
-                                })
+        headers = default_headers(
+          content_type: json_content_type,
+          extra: {
+            "Bugsnag-Api-Key" => @api_key,
+            "Bugsnag-Payload-Version" => "5"
+          }
+        )
+
+        response = @client.post("/", body: ActiveSupport::JSON.encode(payload), headers: headers)
 
         handle_response(response, event)
       rescue StandardError => e
@@ -116,16 +125,7 @@ module Lapsoss
       end
 
       def build_breadcrumbs(event)
-        breadcrumbs = event.context[:breadcrumbs] || []
-
-        breadcrumbs.map do |crumb|
-          {
-            timestamp: crumb[:timestamp]&.iso8601,
-            name: crumb[:message],
-            type: crumb[:type] || "manual",
-            metaData: crumb[:data] || {}
-          }
-        end
+        Breadcrumb.for_insight_hub(event.context[:breadcrumbs] || [])
       end
 
       def build_user_data(event)
@@ -161,7 +161,7 @@ module Lapsoss
           true
         when 400
           body = begin
-            JSON.parse(response.body)
+            ActiveSupport::JSON.decode(response.body)
           rescue
             {}
           end
@@ -177,9 +177,9 @@ module Lapsoss
         end
       end
 
+      # No longer need strict validation
       def validate_settings!
-        validate_presence!(@api_key, "Insight Hub API key")
-        validate_api_key!(@api_key, "Insight Hub API key", format: :alphanumeric) if @api_key
+        # Validation moved to initialize with logging
       end
 
       def handle_delivery_error(error, response = nil)