lapsoss 0.1.0

data/lib/lapsoss/configuration.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require_relative "validators"
+require "active_support/configurable"
+
+module Lapsoss
+  class Configuration
+    include Validators
+    include ActiveSupport::Configurable
+
+    attr_accessor :async, :logger, :enabled, :release,
+                  :scrub_fields, :scrub_all, :whitelist_fields, :randomize_scrub_length,
+                  :transport_jitter, :fingerprint_patterns,
+                  :normalize_fingerprint_paths, :normalize_fingerprint_ids, :fingerprint_include_environment,
+                  :backtrace_context_lines, :backtrace_in_app_patterns, :backtrace_exclude_patterns,
+                  :backtrace_strip_load_path, :backtrace_max_frames, :backtrace_enable_code_context,
+                  :enable_pipeline, :pipeline_builder, :sampling_strategy,
+                  :skip_rails_cache_errors
+    attr_reader :fingerprint_callback
+    attr_reader :environment, :before_send, :sample_rate, :error_handler,
+                :transport_timeout, :transport_max_retries, :transport_initial_backoff,
+                :transport_max_backoff, :transport_backoff_multiplier, :transport_ssl_verify
+    attr_reader :default_context, :adapter_configs
+
+    def initialize
+      @adapter_configs = {}
+      @async = true
+      @logger = nil
+      @environment = nil
+      @enabled = true
+      @release = nil
+      @before_send = nil
+      @sample_rate = 1.0
+      @default_context = {}
+      @error_handler = nil
+      @scrub_fields = nil  # Will use defaults from Scrubber
+      @scrub_all = false
+      @whitelist_fields = []
+      @randomize_scrub_length = false
+      # Transport reliability settings
+      @transport_timeout = 5
+      @transport_max_retries = 3
+      @transport_initial_backoff = 1.0
+      @transport_max_backoff = 64.0
+      @transport_backoff_multiplier = 2.0
+      @transport_jitter = true
+      @transport_ssl_verify = true
+      # Fingerprinting settings
+      @fingerprint_callback = nil
+      @fingerprint_patterns = nil  # Will use defaults from Fingerprinter
+      @normalize_fingerprint_paths = true
+      @normalize_fingerprint_ids = true
+      @fingerprint_include_environment = false
+      # Backtrace processing settings
+      @backtrace_context_lines = 3
+      @backtrace_in_app_patterns = []
+      @backtrace_exclude_patterns = []
+      @backtrace_strip_load_path = true
+      @backtrace_max_frames = 100
+      @backtrace_enable_code_context = true
+      # Pipeline settings
+      @enable_pipeline = true
+      @pipeline_builder = nil
+      @sampling_strategy = nil
+      # Rails error filtering
+      @skip_rails_cache_errors = true
+    end
+
+
+    # Register a named adapter configuration
+    #
+    # @param name [Symbol] Unique name for this adapter instance
+    # @param type [Symbol] The adapter type (e.g., :sentry, :appsignal)
+    # @param settings [Hash] Configuration settings for the adapter
+    def register_adapter(name, type, **settings)
+      @adapter_configs[name.to_sym] = {
+        type: type&.to_sym,
+        settings: settings
+      }
+    end
+
+    # Convenience method for Sentry
+    def use_sentry(name: :sentry, **settings)
+      register_adapter(name, :sentry, **settings)
+    end
+
+    # Convenience method for AppSignal
+    def use_appsignal(name: :appsignal, **settings)
+      register_adapter(name, :appsignal, **settings)
+    end
+
+    # Convenience method for Insight Hub
+    def use_insight_hub(name: :insight_hub, **settings)
+      register_adapter(name, :insight_hub, **settings)
+    end
+
+    # Backwards compatibility for Bugsnag
+    def use_bugsnag(name: :bugsnag, **settings)
+      register_adapter(name, :bugsnag, **settings)
+    end
+
+
+    # Convenience method for Rollbar
+    def use_rollbar(name: :rollbar, **settings)
+      register_adapter(name, :rollbar, **settings)
+    end
+
+    # Convenience method for Logger
+    def use_logger(name: :logger, **settings)
+      register_adapter(name, :logger, **settings)
+    end
+
+    # Apply configuration by registering all adapters
+    def apply!
+      Registry.instance.clear!
+
+      @adapter_configs.each do |name, config|
+        Registry.instance.register(
+          name,
+          config[:type],
+          **config[:settings]
+        )
+      end
+    end
+
+    # Check if any adapters are configured
+    def adapters_configured?
+      !@adapter_configs.empty?
+    end
+
+    # Get configured adapter names
+    def adapter_names
+      @adapter_configs.keys
+    end
+
+    # Default tags setter/getter
+    def default_tags=(tags)
+      @default_context[:tags] = tags
+    end
+
+    def default_tags
+      @default_context[:tags] ||= {}
+    end
+
+    # Default user setter/getter
+    def default_user=(user)
+      @default_context[:user] = user
+    end
+
+    def default_user
+      @default_context[:user]
+    end
+
+    # Default extra context setter/getter
+    def default_extra=(extra)
+      @default_context[:extra] = extra
+    end
+
+    def default_extra
+      @default_context[:extra] ||= {}
+    end
+
+    def clear!
+      initialize
+    end
+
+    # Pipeline configuration
+    def configure_pipeline(&block)
+      require_relative "pipeline"
+      @pipeline_builder = PipelineBuilder.new
+      yield(@pipeline_builder) if block_given?
+      @pipeline_builder
+    end
+
+    def pipeline
+      @pipeline_builder&.pipeline
+    end
+
+    # Sampling configuration
+    def configure_sampling(strategy = nil, &block)
+      require_relative "sampling"
+
+      if strategy
+        @sampling_strategy = strategy
+      elsif block_given?
+        @sampling_strategy = block
+      end
+    end
+
+    def create_sampling_strategy
+      require_relative "sampling"
+
+      case @sampling_strategy
+      when Symbol
+        case @sampling_strategy
+        when :production
+          Sampling::SamplingFactory.create_production_sampling
+        when :development
+          Sampling::SamplingFactory.create_development_sampling
+        when :user_focused
+          Sampling::SamplingFactory.create_user_focused_sampling
+        else
+          Sampling::UniformSampler.new(@sample_rate)
+        end
+      when Proc
+        @sampling_strategy
+      when nil
+        Sampling::UniformSampler.new(@sample_rate)
+      else
+        @sampling_strategy
+      end
+    end
+
+    # Validation and setter overrides
+    def sample_rate=(value)
+      validate_sample_rate!(value, "sample_rate") if value
+      @sample_rate = value
+    end
+
+    def before_send=(value)
+      validate_callable!(value, "before_send")
+      @before_send = value
+    end
+
+    def error_handler=(value)
+      validate_callable!(value, "error_handler")
+      @error_handler = value
+    end
+
+    def environment=(value)
+      validate_environment!(value, "environment") if value
+      @environment = value&.to_s
+    end
+
+    def transport_timeout=(value)
+      validate_timeout!(value, "transport_timeout") if value
+      @transport_timeout = value
+    end
+
+    def transport_max_retries=(value)
+      validate_retries!(value, "transport_max_retries") if value
+      @transport_max_retries = value
+    end
+
+    def transport_initial_backoff=(value)
+      validate_timeout!(value, "transport_initial_backoff") if value
+      @transport_initial_backoff = value
+    end
+
+    def transport_max_backoff=(value)
+      validate_timeout!(value, "transport_max_backoff") if value
+      @transport_max_backoff = value
+    end
+
+    def transport_backoff_multiplier=(value)
+      if value
+        validate_type!(value, [Numeric], "transport_backoff_multiplier")
+        validate_numeric_range!(value, 1.0..10.0, "transport_backoff_multiplier")
+      end
+      @transport_backoff_multiplier = value
+    end
+
+    def transport_ssl_verify=(value)
+      validate_boolean!(value, "transport_ssl_verify") if value
+      @transport_ssl_verify = value
+    end
+
+    def fingerprint_callback=(value)
+      validate_callable!(value, "fingerprint_callback")
+      @fingerprint_callback = value
+    end
+
+    # Configuration validation
+    def validate!
+      validate_sample_rate!(@sample_rate, "sample_rate") if @sample_rate
+      validate_callable!(@before_send, "before_send")
+      validate_callable!(@error_handler, "error_handler")
+      validate_callable!(@fingerprint_callback, "fingerprint_callback")
+      validate_environment!(@environment, "environment") if @environment
+
+      # Validate transport settings
+      validate_timeout!(@transport_timeout, "transport_timeout")
+      validate_retries!(@transport_max_retries, "transport_max_retries")
+      validate_timeout!(@transport_initial_backoff, "transport_initial_backoff")
+      validate_timeout!(@transport_max_backoff, "transport_max_backoff")
+
+      if @transport_backoff_multiplier
+        validate_type!(@transport_backoff_multiplier, [Numeric], "transport_backoff_multiplier")
+        validate_numeric_range!(@transport_backoff_multiplier, 1.0..10.0, "transport_backoff_multiplier")
+      end
+
+      # Validate that initial backoff is less than max backoff
+      if @transport_initial_backoff && @transport_max_backoff && @transport_initial_backoff > @transport_max_backoff
+        raise ValidationError, "transport_initial_backoff (#{@transport_initial_backoff}) must be less than transport_max_backoff (#{@transport_max_backoff})"
+      end
+
+      # Validate adapter configurations
+      @adapter_configs.each do |name, config|
+        validate_adapter_config!(name, config)
+      end
+    end
+
+    private
+
+    def validate_adapter_config!(name, config)
+      validate_presence!(config[:type], "adapter type for '#{name}'")
+      validate_type!(config[:settings], [Hash], "adapter settings for '#{name}'")
+    end
+  end
+end

data/lib/lapsoss/current.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "active_support/all"
+
+module Lapsoss
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :scope
+  end
+end

data/lib/lapsoss/event.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "scrubber"
+require_relative "fingerprinter"
+require_relative "backtrace_processor"
+
+module Lapsoss
+  class Event
+    attr_accessor :type, :timestamp, :level, :message, :exception, :context, :environment, :fingerprint, :backtrace_frames
+
+    def initialize(type:, level: :info, **attributes)
+      @type = type
+      @level = level
+      @timestamp = Time.now
+      @context = {}
+      @environment = Lapsoss.configuration.environment
+
+      attributes.each do |key, value|
+        instance_variable_set("@#{key}", value) if respond_to?("#{key}=")
+      end
+
+      # Process backtrace if we have an exception
+      @backtrace_frames = process_backtrace if @exception
+
+      # Generate fingerprint after all attributes are set (unless explicitly set to nil or a value)
+      @fingerprint = generate_fingerprint if @fingerprint.nil? && !attributes.key?(:fingerprint)
+    end
+
+    def to_h
+      data = {
+        type: type,
+        timestamp: timestamp,
+        level: level,
+        message: message,
+        exception: exception_data,
+        backtrace: backtrace_data,
+        context: context,
+        environment: environment,
+        fingerprint: fingerprint
+      }.compact
+
+      scrub_sensitive_data(data)
+    end
+
+    def scrub_sensitive_data(data)
+      config = Lapsoss.configuration
+
+      scrubber = Scrubber.new(
+        scrub_fields: config.scrub_fields,
+        scrub_all: config.scrub_all,
+        whitelist_fields: config.whitelist_fields,
+        randomize_scrub_length: config.randomize_scrub_length
+      )
+
+      scrubber.scrub(data)
+    end
+
+    def generate_fingerprint
+      config = Lapsoss.configuration
+
+      fingerprinter = Fingerprinter.new(
+        custom_callback: config.fingerprint_callback,
+        patterns: config.fingerprint_patterns,
+        normalize_paths: config.normalize_fingerprint_paths,
+        normalize_ids: config.normalize_fingerprint_ids,
+        include_environment: config.fingerprint_include_environment
+      )
+
+      fingerprinter.generate_fingerprint(self)
+    end
+
+    def process_backtrace
+      return nil unless @exception&.backtrace
+
+      config = Lapsoss.configuration
+
+      processor = BacktraceProcessor.new(
+        context_lines: config.backtrace_context_lines,
+        max_frames: config.backtrace_max_frames,
+        enable_code_context: config.backtrace_enable_code_context,
+        strip_load_path: config.backtrace_strip_load_path,
+        in_app_patterns: config.backtrace_in_app_patterns,
+        exclude_patterns: config.backtrace_exclude_patterns
+      )
+
+      processor.process_exception_backtrace(@exception)
+    end
+
+    private
+
+    def exception_data
+      return nil unless exception
+
+      {
+        class: exception.class.name,
+        message: exception.message,
+        backtrace: exception.backtrace&.first(20)
+      }
+    end
+
+    def backtrace_data
+      return nil unless @backtrace_frames&.any?
+
+      @backtrace_frames.map(&:to_h)
+    end
+  end
+end