lapsoss 0.2.0 → 0.3.0

data/lib/lapsoss/scrubber.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support/parameter_filter'
+require "active_support/parameter_filter"
 
 module Lapsoss
   class Scrubber
@@ -31,7 +31,7 @@ module Lapsoss
       @scrub_all = config[:scrub_all] || false
       @whitelist_fields = Array(config[:whitelist_fields] || [])
       @randomize_scrub_length = config[:randomize_scrub_length] || false
-      @scrub_value = config[:scrub_value] || '**SCRUBBED**'
+      @scrub_value = config[:scrub_value] || "**SCRUBBED**"
     end
 
     def scrub(data)
@@ -68,13 +68,13 @@ module Lapsoss
 
         result[key] = if should_scrub_field?(key_string)
                         generate_scrub_value(value)
-                      elsif value.is_a?(Hash)
+        elsif value.is_a?(Hash)
                         scrub_recursive(value)
-                      elsif value.is_a?(Array)
+        elsif value.is_a?(Array)
                         scrub_array(value)
-                      else
+        else
                         scrub_value(value)
-                      end
+        end
       end
     end
 
@@ -146,7 +146,7 @@ module Lapsoss
 
     def generate_scrub_value(_original_value)
       if @randomize_scrub_length
-        '*' * rand(6..12)
+        "*" * rand(6..12)
       else
         @scrub_value
       end

data/lib/lapsoss/user_context.rb

@@ -35,9 +35,9 @@ module Lapsoss
         # Apply privacy filtering
         processed[key] = if @privacy_mode && sensitive_field?(key_sym)
                            apply_privacy_filter(key_sym, value)
-                         else
+        else
                            transform_field(key_sym, value)
-                         end
+        end
       end
 
       processed
@@ -68,18 +68,18 @@ module Lapsoss
       segments = {}
 
       # Check for common user segments
-      segments[:internal] = !(user_data[:internal] || user_data['internal']).nil?
-      segments[:premium] = !(user_data[:premium] || user_data['premium']).nil?
-      segments[:beta] = !(user_data[:beta] || user_data['beta']).nil?
-      segments[:admin] = !(user_data[:admin] || user_data['admin']).nil?
+      segments[:internal] = !(user_data[:internal] || user_data["internal"]).nil?
+      segments[:premium] = !(user_data[:premium] || user_data["premium"]).nil?
+      segments[:beta] = !(user_data[:beta] || user_data["beta"]).nil?
+      segments[:admin] = !(user_data[:admin] || user_data["admin"]).nil?
 
       # Check role-based segments
-      if role = user_data[:role] || user_data['role']
+      if role = user_data[:role] || user_data["role"]
         segments[:role] = role.to_s.downcase
       end
 
       # Check plan-based segments
-      if plan = user_data[:plan] || user_data['plan']
+      if plan = user_data[:plan] || user_data["plan"]
         segments[:plan] = plan.to_s.downcase
       end
 
@@ -95,14 +95,14 @@ module Lapsoss
         key_sym = key.to_sym
 
         sanitized[key] = if sensitive_field?(key_sym)
-                           '[REDACTED]'
-                         elsif value.is_a?(Hash)
+                           "[REDACTED]"
+        elsif value.is_a?(Hash)
                            sanitize_for_logging(value)
-                         elsif value.is_a?(Array)
+        elsif value.is_a?(Array)
                            value.map { |v| v.is_a?(Hash) ? sanitize_for_logging(v) : v }
-                         else
+        else
                            value
-                         end
+        end
       end
 
       sanitized
@@ -123,7 +123,7 @@ module Lapsoss
       when :ip_address, :last_login_ip
         mask_ip(value)
       else
-        '[FILTERED]'
+        "[FILTERED]"
       end
     end
 
@@ -136,212 +136,39 @@ module Lapsoss
     end
 
     def mask_email(email)
-      return '[INVALID_EMAIL]' unless email.is_a?(String) && email.include?('@')
+      return "[INVALID_EMAIL]" unless email.is_a?(String) && email.include?("@")
 
-      local, domain = email.split('@', 2)
-      masked_local = local.length > 2 ? "#{local[0]}***#{local[-1]}" : '***'
+      local, domain = email.split("@", 2)
+      masked_local = local.length > 2 ? "#{local[0]}***#{local[-1]}" : "***"
       "#{masked_local}@#{domain}"
     end
 
     def mask_phone(phone)
-      return '[INVALID_PHONE]' unless phone.is_a?(String)
+      return "[INVALID_PHONE]" unless phone.is_a?(String)
 
       # Remove all non-digits
-      digits = phone.gsub(/\D/, '')
-      return '[INVALID_PHONE]' if digits.length < 4
+      digits = phone.gsub(/\D/, "")
+      return "[INVALID_PHONE]" if digits.length < 4
 
       # Show last 4 digits
-      ('*' * (digits.length - 4)) + digits[-4..]
+      ("*" * (digits.length - 4)) + digits[-4..]
     end
 
     def mask_ip(ip)
-      return '[INVALID_IP]' unless ip.is_a?(String)
+      return "[INVALID_IP]" unless ip.is_a?(String)
 
-      if ip.include?(':')
+      if ip.include?(":")
         # IPv6 - mask last 4 groups
-        parts = ip.split(':')
-        parts[-4..-1] = ['****'] * 4 if parts.length >= 4
-        parts.join(':')
+        parts = ip.split(":")
+        parts[-4..-1] = [ "****" ] * 4 if parts.length >= 4
+        parts.join(":")
       else
         # IPv4 - mask last octet
-        parts = ip.split('.')
-        return '[INVALID_IP]' if parts.length != 4
-
-        parts[-1] = '***'
-        parts.join('.')
-      end
-    end
-  end
-
-  # User context provider that integrates with various authentication systems
-  class UserContextProvider
-    def initialize(providers: {})
-      @providers = providers
-    end
-
-    def get_user_context(event, hint = {})
-      context = {}
-
-      # Try each provider in order
-      @providers.each do |name, provider|
-        if provider_context = provider.call(event, hint)
-          context.merge!(provider_context)
-        end
-      rescue StandardError => e
-        # Log provider error but don't fail
-        warn "User context provider #{name} failed: #{e.message}"
-      end
-
-      context
-    end
-
-    # Built-in providers for common authentication systems
-    def self.devise_provider
-      lambda do |_event, hint|
-        return {} unless defined?(Devise) && defined?(Warden)
-
-        # Try to get user from Warden (used by Devise)
-        if request = hint[:request]
-          user = request.env['warden']&.user
-          return {} unless user
-
-          {
-            id: user.id,
-            email: user.email,
-            username: user.respond_to?(:username) ? user.username : nil,
-            created_at: user.created_at,
-            role: user.respond_to?(:role) ? user.role : nil
-          }.compact
-        end
-
-        {}
-      end
-    end
-
-    def self.omniauth_provider
-      lambda do |_event, hint|
-        return {} unless defined?(OmniAuth)
-
-        if (request = hint[:request]) && (auth_info = request.env['omniauth.auth'])
-          {
-            provider: auth_info['provider'],
-            uid: auth_info['uid'],
-            name: auth_info.dig('info', 'name'),
-            email: auth_info.dig('info', 'email'),
-            username: auth_info.dig('info', 'nickname')
-          }.compact
-        end
-
-        {}
-      end
-    end
-
-    def self.session_provider
-      lambda do |_event, hint|
-        return {} unless hint[:request]
-
-        request = hint[:request]
-        session = begin
-          request.session
-        rescue StandardError
-          {}
-        end
-
-        {
-          session_id: session[:session_id] || session['session_id'],
-          user_id: session[:user_id] || session['user_id'],
-          csrf_token: session[:_csrf_token] || session['_csrf_token']
-        }.compact
-      end
-    end
-
-    def self.thread_local_provider
-      lambda do |_event, _hint|
-        # Get user from thread-local storage
-        Thread.current[:current_user] || {}
-      end
-    end
-  end
-
-  # Integration with popular authentication gems
-  module UserContextIntegrations
-    def self.setup_devise_integration
-      return unless defined?(Devise)
-
-      # Add middleware to capture user context
-      Rails.application.config.middleware.use(UserContextMiddleware) if defined?(Rails)
-    end
-
-    def self.setup_clearance_integration
-      return unless defined?(Clearance)
-
-      # Clearance integration
-      return unless defined?(Rails)
-
-      Rails.application.config.middleware.use(UserContextMiddleware) do |middleware|
-        middleware.user_provider = lambda do |request|
-          request.env[:clearance].current_user if request.env[:clearance]
-        end
-      end
-    end
-
-    def self.setup_authlogic_integration
-      return unless defined?(Authlogic)
-
-      # Authlogic integration
-      return unless defined?(Rails)
-
-      Rails.application.config.middleware.use(UserContextMiddleware) do |middleware|
-        middleware.user_provider = lambda do |_request|
-          UserSession.find&.user if defined?(UserSession)
-        end
-      end
-    end
-  end
-
-  # Middleware to automatically capture user context
-  class UserContextMiddleware
-    def initialize(app, user_provider: nil)
-      @app = app
-      @user_provider = user_provider
-    end
-
-    def call(env)
-      request = Rack::Request.new(env)
-
-      # Capture user context
-      user_context = extract_user_context(request)
-
-      # Store in thread-local for access during request processing
-      Thread.current[:lapsoss_user_context] = user_context
-
-      @app.call(env)
-    ensure
-      Thread.current[:lapsoss_user_context] = nil
-    end
-
-    private
-
-    def extract_user_context(request)
-      if @user_provider
-        user = @user_provider.call(request)
-        return {} unless user
+        parts = ip.split(".")
+        return "[INVALID_IP]" if parts.length != 4
 
-        context = {
-          id: user.id,
-          email: user.email,
-          username: user.respond_to?(:username) ? user.username : nil
-        }
-
-        # Add role information if available
-        context[:role] = user.role if user.respond_to?(:role)
-
-        # Add plan information if available
-        context[:plan] = user.plan if user.respond_to?(:plan)
-
-        context.compact
-      else
-        {}
+        parts[-1] = "***"
+        parts.join(".")
       end
     end
   end

data/lib/lapsoss/user_context_integrations.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  # Integration with popular authentication gems
+  module UserContextIntegrations
+    def self.setup_devise_integration
+      return unless defined?(Devise)
+
+      # Add middleware to capture user context
+      Rails.application.config.middleware.use(UserContextMiddleware) if defined?(Rails)
+    end
+
+    def self.setup_clearance_integration
+      return unless defined?(Clearance)
+
+      # Clearance integration
+      return unless defined?(Rails)
+
+      Rails.application.config.middleware.use(UserContextMiddleware) do |middleware|
+        middleware.user_provider = lambda do |request|
+          request.env[:clearance].current_user if request.env[:clearance]
+        end
+      end
+    end
+
+    def self.setup_authlogic_integration
+      return unless defined?(Authlogic)
+
+      # Authlogic integration
+      return unless defined?(Rails)
+
+      Rails.application.config.middleware.use(UserContextMiddleware) do |middleware|
+        middleware.user_provider = lambda do |_request|
+          UserSession.find&.user if defined?(UserSession)
+        end
+      end
+    end
+  end
+end

data/lib/lapsoss/user_context_middleware.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  # Middleware to automatically capture user context
+  class UserContextMiddleware
+    def initialize(app, user_provider: nil)
+      @app = app
+      @user_provider = user_provider
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      # Capture user context
+      user_context = extract_user_context(request)
+
+      # Store in thread-local for access during request processing
+      Thread.current[:lapsoss_user_context] = user_context
+
+      @app.call(env)
+    ensure
+      Thread.current[:lapsoss_user_context] = nil
+    end
+
+    private
+
+    def extract_user_context(request)
+      if @user_provider
+        user = @user_provider.call(request)
+        return {} unless user
+
+        context = {
+          id: user.id,
+          email: user.email,
+          username: user.respond_to?(:username) ? user.username : nil
+        }
+
+        # Add role information if available
+        context[:role] = user.role if user.respond_to?(:role)
+
+        # Add plan information if available
+        context[:plan] = user.plan if user.respond_to?(:plan)
+
+        context.compact
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/lapsoss/user_context_provider.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  # User context provider that integrates with various authentication systems
+  class UserContextProvider
+    def initialize(providers: {})
+      @providers = providers
+    end
+
+    def get_user_context(event, hint = {})
+      context = {}
+
+      # Try each provider in order
+      @providers.each do |name, provider|
+        if provider_context = provider.call(event, hint)
+          context.merge!(provider_context)
+        end
+      rescue StandardError => e
+        # Log provider error but don't fail
+        warn "User context provider #{name} failed: #{e.message}"
+      end
+
+      context
+    end
+
+    # Built-in providers for common authentication systems
+    def self.devise_provider
+      lambda do |_event, hint|
+        return {} unless defined?(Devise) && defined?(Warden)
+
+        # Try to get user from Warden (used by Devise)
+        if request = hint[:request]
+          user = request.env["warden"]&.user
+          return {} unless user
+
+          {
+            id: user.id,
+            email: user.email,
+            username: user.respond_to?(:username) ? user.username : nil,
+            created_at: user.created_at,
+            role: user.respond_to?(:role) ? user.role : nil
+          }.compact
+        end
+
+        {}
+      end
+    end
+
+    def self.omniauth_provider
+      lambda do |_event, hint|
+        return {} unless defined?(OmniAuth)
+
+        if (request = hint[:request]) && (auth_info = request.env["omniauth.auth"])
+          {
+            provider: auth_info["provider"],
+            uid: auth_info["uid"],
+            name: auth_info.dig("info", "name"),
+            email: auth_info.dig("info", "email"),
+            username: auth_info.dig("info", "nickname")
+          }.compact
+        end
+
+        {}
+      end
+    end
+
+    def self.session_provider
+      lambda do |_event, hint|
+        return {} unless hint[:request]
+
+        request = hint[:request]
+        session = begin
+          request.session
+        rescue StandardError
+          {}
+        end
+
+        {
+          session_id: session[:session_id] || session["session_id"],
+          user_id: session[:user_id] || session["user_id"],
+          csrf_token: session[:_csrf_token] || session["_csrf_token"]
+        }.compact
+      end
+    end
+
+    def self.thread_local_provider
+      lambda do |_event, _hint|
+        # Get user from thread-local storage
+        Thread.current[:current_user] || {}
+      end
+    end
+  end
+end

data/lib/lapsoss/utils.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lapsoss
+  module Utils
+    module_function
+
+    def current_time
+      if Time.respond_to?(:zone) && Time.zone
+      end
+      Time.zone.now
+    end
+  end
+end

data/lib/lapsoss/validators.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'uri'
+require "uri"
 
 module Lapsoss
   module Validators
@@ -17,7 +17,7 @@ module Lapsoss
     def validate_type!(value, types, name)
       types = Array(types)
       unless types.any? { |type| value.is_a?(type) }
-        type_names = types.map(&:name).join(' or ')
+        type_names = types.map(&:name).join(" or ")
         raise ValidationError, "#{name} must be a #{type_names}, got #{value.class} (#{value.inspect})"
       end
     end
@@ -29,7 +29,7 @@ module Lapsoss
     end
 
     def validate_numeric_range!(value, range, name)
-      validate_type!(value, [Numeric], name)
+      validate_type!(value, [ Numeric ], name)
       unless range.cover?(value)
         raise ValidationError, "#{name} must be between #{range.min} and #{range.max}, got #{value}"
       end
@@ -38,7 +38,7 @@ module Lapsoss
     def validate_url!(value, name)
       return if value.nil?
 
-      validate_type!(value, [String], name)
+      validate_type!(value, [ String ], name)
 
       begin
         uri = URI.parse(value)
@@ -49,10 +49,10 @@ module Lapsoss
       end
     end
 
-    def validate_dsn!(dsn_string, name = 'DSN')
+    def validate_dsn!(dsn_string, name = "DSN")
       return if dsn_string.nil?
 
-      validate_type!(dsn_string, [String], name)
+      validate_type!(dsn_string, [ String ], name)
 
       begin
         uri = URI.parse(dsn_string)
@@ -66,7 +66,7 @@ module Lapsoss
         raise ValidationError, "#{name} must use http or https scheme" unless %w[http https].include?(uri.scheme)
 
         # Extract project ID from path
-        path_parts = uri.path&.split('/') || []
+        path_parts = uri.path&.split("/") || []
         project_id = path_parts.last
         validate_presence!(project_id, "#{name} project ID")
 
@@ -81,7 +81,7 @@ module Lapsoss
 
     def validate_api_key!(value, name, format: nil)
       validate_presence!(value, name)
-      validate_type!(value, [String], name)
+      validate_type!(value, [ String ], name)
 
       case format
       when :uuid
@@ -95,10 +95,10 @@ module Lapsoss
       end
     end
 
-    def validate_environment!(value, name = 'environment')
+    def validate_environment!(value, name = "environment")
       return if value.nil?
 
-      validate_type!(value, [String, Symbol], name)
+      validate_type!(value, [ String, Symbol ], name)
 
       env_string = value.to_s
       unless env_string.match?(/\A[a-z0-9_-]+\z/i)
@@ -106,23 +106,23 @@ module Lapsoss
       end
     end
 
-    def validate_sample_rate!(value, name = 'sample_rate')
+    def validate_sample_rate!(value, name = "sample_rate")
       return if value.nil?
 
       validate_numeric_range!(value, 0.0..1.0, name)
     end
 
-    def validate_timeout!(value, name = 'timeout')
+    def validate_timeout!(value, name = "timeout")
       return if value.nil?
 
-      validate_type!(value, [Numeric], name)
+      validate_type!(value, [ Numeric ], name)
       raise ValidationError, "#{name} must be positive, got #{value}" if value <= 0
     end
 
-    def validate_retries!(value, name = 'max_retries')
+    def validate_retries!(value, name = "max_retries")
       return if value.nil?
 
-      validate_type!(value, [Integer], name)
+      validate_type!(value, [ Integer ], name)
       validate_numeric_range!(value, 0..10, name)
     end
   end

data/lib/lapsoss/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lapsoss
-  VERSION = '0.2.0'
+  VERSION = "0.3.0"
 end

data/lib/lapsoss.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'zeitwerk'
-require 'active_support/core_ext/module/delegation'
+require "zeitwerk"
+require "active_support/core_ext/module/delegation"
 
 loader = Zeitwerk::Loader.for_gem
 loader.do_not_eager_load("#{__dir__}/lapsoss/adapters")
 loader.setup
 
-require_relative 'lapsoss/railtie' if defined?(Rails)
+require_relative "lapsoss/railtie" if defined?(Rails::Railtie)
 
 module Lapsoss
   class Error < StandardError; end