lapsoss 0.1.0 → 0.3.0

data/lib/lapsoss/scrubber.rb

@@ -25,22 +25,20 @@ module Lapsoss
       @rails_parameter_filter = rails_parameter_filter
 
       # Only use custom scrubbing if Rails parameter filter is not available
-      unless @rails_parameter_filter
-        @scrub_fields = Array(config[:scrub_fields] || DEFAULT_SCRUB_FIELDS)
-        @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**"
-      end
+      return if @rails_parameter_filter
+
+      @scrub_fields = Array(config[:scrub_fields] || DEFAULT_SCRUB_FIELDS)
+      @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**"
     end
 
     def scrub(data)
       return data if data.nil?
 
       # If Rails parameter filter is available, use it exclusively
-      if @rails_parameter_filter
-        return @rails_parameter_filter.filter(data)
-      end
+      return @rails_parameter_filter.filter(data) if @rails_parameter_filter
 
       # Fallback to custom scrubbing logic only if Rails filter is not available
       @scrubbed_objects = {}.compare_by_identity
@@ -68,14 +66,14 @@ module Lapsoss
       hash.each_with_object({}) do |(key, value), result|
         key_string = key.to_s.downcase
 
-        if should_scrub_field?(key_string)
-          result[key] = generate_scrub_value(value)
+        result[key] = if should_scrub_field?(key_string)
+                        generate_scrub_value(value)
         elsif value.is_a?(Hash)
-          result[key] = scrub_recursive(value)
+                        scrub_recursive(value)
         elsif value.is_a?(Array)
-          result[key] = scrub_array(value)
+                        scrub_array(value)
         else
-          result[key] = scrub_value(value)
+                        scrub_value(value)
         end
       end
     end
@@ -118,7 +116,7 @@ module Lapsoss
       PROTECTED_EVENT_FIELDS.include?(field_name.to_s)
     end
 
-    def whitelisted_value?(value)
+    def whitelisted_value?(_value)
       # Basic implementation - could be extended
       false
     end
@@ -136,7 +134,7 @@ module Lapsoss
         original_filename: safe_call(attachment, :original_filename),
         size: safe_call(attachment, :size) || safe_call(attachment, :tempfile, :size)
       }
-    rescue => e
+    rescue StandardError => e
       { __attachment__: true, error: "Failed to extract attachment info: #{e.message}" }
     end
 
@@ -146,7 +144,7 @@ module Lapsoss
       end
     end
 
-    def generate_scrub_value(original_value)
+    def generate_scrub_value(_original_value)
       if @randomize_scrub_length
         "*" * rand(6..12)
       else

data/lib/lapsoss/user_context.rb

@@ -30,15 +30,13 @@ module Lapsoss
         key_sym = key.to_sym
 
         # Skip if not in allowed fields list (when specified)
-        if @allowed_fields && !@allowed_fields.include?(key_sym)
-          next
-        end
+        next if @allowed_fields&.exclude?(key_sym)
 
         # Apply privacy filtering
-        if @privacy_mode && sensitive_field?(key_sym)
-          processed[key] = apply_privacy_filter(key_sym, value)
+        processed[key] = if @privacy_mode && sensitive_field?(key_sym)
+                           apply_privacy_filter(key_sym, value)
         else
-          processed[key] = transform_field(key_sym, value)
+                           transform_field(key_sym, value)
         end
       end
 
@@ -70,18 +68,18 @@ module Lapsoss
       segments = {}
 
       # Check for common user segments
-      segments[:internal] = !!(user_data[:internal] || user_data["internal"])
-      segments[:premium] = !!(user_data[:premium] || user_data["premium"])
-      segments[:beta] = !!(user_data[:beta] || user_data["beta"])
-      segments[:admin] = !!(user_data[:admin] || user_data["admin"])
+      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
 
@@ -96,14 +94,14 @@ module Lapsoss
       user_data.each do |key, value|
         key_sym = key.to_sym
 
-        if sensitive_field?(key_sym)
-          sanitized[key] = "[REDACTED]"
+        sanitized[key] = if sensitive_field?(key_sym)
+                           "[REDACTED]"
         elsif value.is_a?(Hash)
-          sanitized[key] = sanitize_for_logging(value)
+                           sanitize_for_logging(value)
         elsif value.is_a?(Array)
-          sanitized[key] = value.map { |v| v.is_a?(Hash) ? sanitize_for_logging(v) : v }
+                           value.map { |v| v.is_a?(Hash) ? sanitize_for_logging(v) : v }
         else
-          sanitized[key] = value
+                           value
         end
       end
 
@@ -153,7 +151,7 @@ module Lapsoss
       return "[INVALID_PHONE]" if digits.length < 4
 
       # Show last 4 digits
-      "*" * (digits.length - 4) + digits[-4..-1]
+      ("*" * (digits.length - 4)) + digits[-4..]
     end
 
     def mask_ip(ip)
@@ -162,194 +160,16 @@ module Lapsoss
       if ip.include?(":")
         # IPv6 - mask last 4 groups
         parts = ip.split(":")
-        parts[-4..-1] = ["****"] * 4 if parts.length >= 4
+        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|
-        begin
-          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
-      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]
-          if 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
-    end
-
-    def self.session_provider
-      lambda do |event, hint|
-        return {} unless hint[:request]
-
-        request = hint[:request]
-        session = request.session rescue {}
-
-        {
-          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
-      if defined?(Rails)
-        Rails.application.config.middleware.use(UserContextMiddleware)
-      end
-    end
-
-    def self.setup_clearance_integration
-      return unless defined?(Clearance)
-
-      # Clearance integration
-      if 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
-    end
-
-    def self.setup_authlogic_integration
-      return unless defined?(Authlogic)
-
-      # Authlogic integration
-      if 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
-
-  # 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
-        if user.respond_to?(:role)
-          context[:role] = user.role
-        end
-
-        # Add plan information if available
-        if user.respond_to?(:plan)
-          context[:plan] = user.plan
-        end
-
-        context.compact
-      else
-        {}
-      end
-    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

@@ -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,16 +38,12 @@ 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)
-        unless uri.scheme && uri.host
-          raise ValidationError, "#{name} must be a valid URL with scheme and host"
-        end
-        unless %w[http https].include?(uri.scheme)
-          raise ValidationError, "#{name} must use http or https scheme"
-        end
+        raise ValidationError, "#{name} must be a valid URL with scheme and host" unless uri.scheme && uri.host
+        raise ValidationError, "#{name} must use http or https scheme" unless %w[http https].include?(uri.scheme)
       rescue URI::InvalidURIError => e
         raise ValidationError, "#{name} is not a valid URL: #{e.message}"
       end
@@ -56,7 +52,7 @@ module Lapsoss
     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)
@@ -67,9 +63,7 @@ module Lapsoss
         validate_presence!(uri.user, "#{name} public key")
 
         # Validate scheme
-        unless %w[http https].include?(uri.scheme)
-          raise ValidationError, "#{name} must use http or https scheme"
-        end
+        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("/") || []
@@ -80,7 +74,6 @@ module Lapsoss
         unless project_id.match?(/^\d+$/)
           raise ValidationError, "#{name} project ID must be numeric, got '#{project_id}'"
         end
-
       rescue URI::InvalidURIError => e
         raise ValidationError, "#{name} is not a valid URI: #{e.message}"
       end
@@ -88,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
@@ -96,20 +89,16 @@ module Lapsoss
           raise ValidationError, "#{name} must be a valid UUID format"
         end
       when :hex
-        unless value.match?(/\A[0-9a-f]+\z/i)
-          raise ValidationError, "#{name} must be a valid hexadecimal string"
-        end
+        raise ValidationError, "#{name} must be a valid hexadecimal string" unless value.match?(/\A[0-9a-f]+\z/i)
       when :alphanumeric
-        unless value.match?(/\A[a-z0-9]+\z/i)
-          raise ValidationError, "#{name} must be alphanumeric"
-        end
+        raise ValidationError, "#{name} must be alphanumeric" unless value.match?(/\A[a-z0-9]+\z/i)
       end
     end
 
     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)
@@ -126,16 +115,14 @@ module Lapsoss
     def validate_timeout!(value, name = "timeout")
       return if value.nil?
 
-      validate_type!(value, [Numeric], name)
-      if value <= 0
-        raise ValidationError, "#{name} must be positive, got #{value}"
-      end
+      validate_type!(value, [ Numeric ], name)
+      raise ValidationError, "#{name} must be positive, got #{value}" if value <= 0
     end
 
     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.1.0"
+  VERSION = "0.3.0"
 end