lapsoss 0.3.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d64055e7377f1d53c9c8ec93302e04c279a33cbad65686257e34d420ea00600b
-  data.tar.gz: e2e80f0d005f741607cc2b163cf51be796e9bfbdf36957f030249cab6a127269
+  metadata.gz: 93ff41a78372ad8d5080a5b7d87c2783a1f5834020df285e2db5eb28f0a54d61
+  data.tar.gz: 1cbceab257813d8e7659d9a31abd2cfba0a33a6f5585776ed426c984c32a61e4
 SHA512:
-  metadata.gz: 9af0fd3cbcd82dac58b2d38fa51aa648957e21f5e9b2e24c41237d93d3645ab56c27c7a3137768faad3026b980e8e985348cea906412171602530519ae357504
-  data.tar.gz: 8b53db58c0309885de19c514c5af321e772f48b54ebfd1c011d290078eff853efb57228bced817dccb34d66d58e4cc9916b611b00cf99e0941740200dbe34471
+  metadata.gz: da64a5b1ec01779137189432e8dfba438e3768a1af44f71de44f3827c6ef3f2eb27b49d1b6d88479a23c51218e328f4068a86b4e210a2f73b869d2ff7167bb30
+  data.tar.gz: 126e54769b4f4ad8dad6617c27b5a80aeba5ae073879b462c8c6e01346fbc6a78029aca8589b028b6eccf9900fd1cc24e8072d119098190dbb86ac0b88521eba

data/README.md

@@ -31,6 +31,11 @@ Lapsoss.configure do |config|
 end
 ```
 
+## Requirements
+
+- Ruby 3.3+
+- Rails 7.2+
+
 ## Installation
 
 ```ruby
@@ -191,23 +196,82 @@ Lapsoss.configure do |config|
   # Data scrubbing (uses Rails filter_parameters automatically)
   config.scrub_fields = %w[password credit_card ssn] # Or leave nil to use Rails defaults
 
-  # Error filtering
+  # Performance
+  config.async = true # Send errors in background
+
+  # Sampling (see docs/sampling_strategies.md for advanced examples)
+  config.sample_rate = Rails.env.production? ? 0.25 : 1.0
+  
+  # Transport settings
+  config.transport_timeout = 10 # seconds
+  config.transport_max_retries = 3
+end
+```
+
+### Filtering Errors
+
+You decide what errors to track. Lapsoss doesn't make assumptions:
+
+```ruby
+Lapsoss.configure do |config|
+  # Use the before_send callback for simple filtering
   config.before_send = lambda do |event|
     # Return nil to prevent sending
     return nil if event.exception.is_a?(ActiveRecord::RecordNotFound)
     event
   end
+  
+  # Or use the exclusion filter for more complex rules
+  config.exclusion_filter = Lapsoss::ExclusionFilter.new(
+    # Exclude specific exception types
+    excluded_exceptions: [
+      "ActionController::RoutingError",  # Your choice
+      "ActiveRecord::RecordNotFound"     # Your decision
+    ],
+    
+    # Exclude by pattern matching
+    excluded_patterns: [
+      /timeout/i,           # If timeouts are expected in your app
+      /user not found/i     # If these are normal in your workflow
+    ],
+    
+    # Exclude specific error messages
+    excluded_messages: [
+      "No route matches",
+      "Invalid authenticity token"
+    ]
+  )
+  
+  # Add custom exclusion logic
+  config.exclusion_filter.add_exclusion(:custom, lambda do |event|
+    # Your business logic here
+    event.context[:request]&.dig(:user_agent)&.match?(/bot/i)
+  end)
+end
+```
 
-  # Sampling
-  config.sample_rate = Rails.env.production? ? 0.25 : 1.0
+#### Common Patterns (Your Choice)
 
-  # Performance
-  config.async = true # Send errors in background
-  config.transport_timeout = 10 # seconds
-  config.transport_max_retries = 3
+```ruby
+# Development/Test exclusions
+if Rails.env.development?
+  config.exclusion_filter.add_exclusion(:exception, "RSpec::Expectations::ExpectationNotMetError")
+  config.exclusion_filter.add_exclusion(:exception, "Minitest::Assertion")
 end
+
+# User input errors (if you don't want to track them)
+config.exclusion_filter.add_exclusion(:exception, "ActiveRecord::RecordInvalid")
+config.exclusion_filter.add_exclusion(:exception, "ActionController::ParameterMissing")
+
+# Bot traffic (if you want to exclude it)
+config.exclusion_filter.add_exclusion(:custom, lambda do |event|
+  request = event.context[:request]
+  request && request[:user_agent]&.match?(/googlebot|bingbot/i)
+end)
 ```
 
+Your app, your rules. Lapsoss just provides the mechanism.
+
 ### Data Protection
 
 Lapsoss automatically integrates with Rails' parameter filtering:

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)