lapsoss 0.1.0 → 0.2.0

data/lib/lapsoss/sampling.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "digest"
+require 'digest'
 
 module Lapsoss
   module Sampling
     class Base
-      def sample?(event, hint = {})
+      def sample?(_event, _hint = {})
         true
       end
     end
@@ -15,7 +15,7 @@ module Lapsoss
         @rate = rate
       end
 
-      def sample?(event, hint = {})
+      def sample?(_event, _hint = {})
         rand < @rate
       end
     end
@@ -24,13 +24,13 @@ module Lapsoss
       def initialize(max_events_per_second: 10)
         @max_events_per_second = max_events_per_second
         @tokens = max_events_per_second
-        @last_refill = Time.now
+        @last_refill = Time.zone.now
         @mutex = Mutex.new
       end
 
-      def sample?(event, hint = {})
+      def sample?(_event, _hint = {})
         @mutex.synchronize do
-          now = Time.now
+          now = Time.zone.now
           time_passed = now - @last_refill
 
           # Refill tokens based on time passed
@@ -53,7 +53,7 @@ module Lapsoss
         @default_rate = rates.fetch(:default, 1.0)
       end
 
-      def sample?(event, hint = {})
+      def sample?(event, _hint = {})
         return @default_rate > rand unless event.exception
 
         exception_class = event.exception.class
@@ -92,7 +92,7 @@ module Lapsoss
         @default_rate = rates.fetch(:default, 1.0)
       end
 
-      def sample?(event, hint = {})
+      def sample?(event, _hint = {})
         user = event.context[:user]
         return @default_rate > rand unless user
 
@@ -104,18 +104,18 @@ module Lapsoss
 
       def find_rate_for_user(user)
         # Check specific user ID
-        user_id = user[:id] || user["id"]
+        user_id = user[:id] || user['id']
         return @rates[user_id] if user_id && @rates.key?(user_id)
 
         # Check user segments
         @rates.each do |segment, rate|
           case segment
-          when :internal, "internal"
-            return rate if user[:internal] || user["internal"]
-          when :premium, "premium"
-            return rate if user[:premium] || user["premium"]
-          when :beta, "beta"
-            return rate if user[:beta] || user["beta"]
+          when :internal, 'internal'
+            return rate if user[:internal] || user['internal']
+          when :premium, 'premium'
+            return rate if user[:premium] || user['premium']
+          when :beta, 'beta'
+            return rate if user[:beta] || user['beta']
           end
         end
 
@@ -140,7 +140,7 @@ module Lapsoss
 
       private
 
-      def default_key_extractor(event, hint)
+      def default_key_extractor(event, _hint)
         # Use fingerprint for consistent sampling
         event.fingerprint
       end
@@ -152,8 +152,8 @@ module Lapsoss
         @default_rate = schedule.fetch(:default, 1.0)
       end
 
-      def sample?(event, hint = {})
-        now = Time.now
+      def sample?(_event, _hint = {})
+        now = Time.zone.now
         rate = find_rate_for_time(now)
         rate > rand
       end
@@ -165,11 +165,11 @@ module Lapsoss
         day_of_week = time.wday # 0 = Sunday
 
         # Check specific hour
-        hour_key = "hour_#{hour}".to_sym
+        hour_key = :"hour_#{hour}"
         return @schedule[hour_key] if @schedule.key?(hour_key)
 
         # Check day of week
-        day_names = [:sunday, :monday, :tuesday, :wednesday, :thursday, :friday, :saturday]
+        day_names = %i[sunday monday tuesday wednesday thursday friday saturday]
         day_key = day_names[day_of_week]
         return @schedule[day_key] if @schedule.key?(day_key)
 
@@ -179,9 +179,7 @@ module Lapsoss
         end
 
         # Check weekends
-        if @schedule.key?(:weekends) && [0, 6].include?(day_of_week)
-          return @schedule[:weekends]
-        end
+        return @schedule[:weekends] if @schedule.key?(:weekends) && [0, 6].include?(day_of_week)
 
         @default_rate
       end
@@ -214,16 +212,16 @@ module Lapsoss
         @adjustment_period = adjustment_period
         @current_rate = target_rate
         @events_count = 0
-        @last_adjustment = Time.now
+        @last_adjustment = Time.zone.now
         @mutex = Mutex.new
       end
 
-      def sample?(event, hint = {})
+      def sample?(_event, _hint = {})
         @mutex.synchronize do
           @events_count += 1
 
           # Adjust rate periodically
-          now = Time.now
+          now = Time.zone.now
           if now - @last_adjustment > @adjustment_period
             adjust_rate
             @last_adjustment = now
@@ -234,9 +232,7 @@ module Lapsoss
         @current_rate > rand
       end
 
-      def current_rate
-        @current_rate
-      end
+      attr_reader :current_rate
 
       private
 
@@ -258,7 +254,7 @@ module Lapsoss
         @low_rate = low_rate
       end
 
-      def sample?(event, hint = {})
+      def sample?(_event, _hint = {})
         healthy = @health_check.call
         rate = healthy ? @high_rate : @low_rate
         rate > rand
@@ -275,29 +271,29 @@ module Lapsoss
 
             # Different rates for different exception types
             ExceptionTypeSampler.new(rates: {
-              # Critical errors - always sample
-              SecurityError => 1.0,
-              SystemStackError => 1.0,
-              NoMemoryError => 1.0,
+                                       # Critical errors - always sample
+                                       SecurityError => 1.0,
+                                       SystemStackError => 1.0,
+                                       NoMemoryError => 1.0,
 
-              # Common errors - sample less
-              ArgumentError => 0.1,
-              TypeError => 0.1,
+                                       # Common errors - sample less
+                                       ArgumentError => 0.1,
+                                       TypeError => 0.1,
 
-              # Network errors - medium sampling
-              /timeout/i => 0.3,
-              /connection/i => 0.3,
+                                       # Network errors - medium sampling
+                                       /timeout/i => 0.3,
+                                       /connection/i => 0.3,
 
-              # Default for unknown errors
-              default: 0.5
-            }),
+                                       # Default for unknown errors
+                                       default: 0.5
+                                     }),
 
             # Lower sampling during business hours
             TimeBasedSampler.new(schedule: {
-              business_hours: 0.3,
-              weekends: 0.8,
-              default: 0.5
-            })
+                                   business_hours: 0.3,
+                                   weekends: 0.8,
+                                   default: 0.5
+                                 })
           ],
           strategy: :all
         )
@@ -312,16 +308,16 @@ module Lapsoss
           samplers: [
             # Higher sampling for internal users
             UserBasedSampler.new(rates: {
-              internal: 1.0,
-              premium: 0.8,
-              beta: 0.9,
-              default: 0.1
-            }),
+                                   internal: 1.0,
+                                   premium: 0.8,
+                                   beta: 0.9,
+                                   default: 0.1
+                                 }),
 
             # Consistent sampling based on user ID
             ConsistentHashSampler.new(
               rate: 0.1,
-              key_extractor: ->(event, hint) { event.context.dig(:user, :id) }
+              key_extractor: ->(event, _hint) { event.context.dig(:user, :id) }
             )
           ],
           strategy: :any

data/lib/lapsoss/scope.rb

@@ -29,13 +29,11 @@ module Lapsoss
       @extra.merge!(context[:extra] || {})
 
       # Handle breadcrumbs if provided
-      if context[:breadcrumbs]
-        @breadcrumbs.concat(context[:breadcrumbs])
-        # Keep breadcrumbs to a reasonable limit
-        while @breadcrumbs.length > 20
-          @breadcrumbs.shift
-        end
-      end
+      return unless context[:breadcrumbs]
+
+      @breadcrumbs.concat(context[:breadcrumbs])
+      # Keep breadcrumbs to a reasonable limit
+      @breadcrumbs.shift while @breadcrumbs.length > 20
     end
 
     def clear
@@ -97,9 +95,7 @@ module Lapsoss
     def merge_breadcrumbs
       result = @base_scope.breadcrumbs.dup
       @scope_stack.each do |context|
-        if context[:breadcrumbs]
-          result.concat(context[:breadcrumbs])
-        end
+        result.concat(context[:breadcrumbs]) if context[:breadcrumbs]
       end
       # Add our own breadcrumbs
       result.concat(@own_breadcrumbs)

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
@@ -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,15 +66,15 @@ 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)
-        elsif value.is_a?(Hash)
-          result[key] = scrub_recursive(value)
-        elsif value.is_a?(Array)
-          result[key] = scrub_array(value)
-        else
-          result[key] = scrub_value(value)
-        end
+        result[key] = if should_scrub_field?(key_string)
+                        generate_scrub_value(value)
+                      elsif value.is_a?(Hash)
+                        scrub_recursive(value)
+                      elsif value.is_a?(Array)
+                        scrub_array(value)
+                      else
+                        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,9 +144,9 @@ module Lapsoss
       end
     end
 
-    def generate_scrub_value(original_value)
+    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

@@ -30,16 +30,14 @@ 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)
-        else
-          processed[key] = transform_field(key_sym, value)
-        end
+        processed[key] = if @privacy_mode && sensitive_field?(key_sym)
+                           apply_privacy_filter(key_sym, value)
+                         else
+                           transform_field(key_sym, value)
+                         end
       end
 
       processed
@@ -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,15 +94,15 @@ module Lapsoss
       user_data.each do |key, value|
         key_sym = key.to_sym
 
-        if sensitive_field?(key_sym)
-          sanitized[key] = "[REDACTED]"
-        elsif value.is_a?(Hash)
-          sanitized[key] = sanitize_for_logging(value)
-        elsif value.is_a?(Array)
-          sanitized[key] = value.map { |v| v.is_a?(Hash) ? sanitize_for_logging(v) : v }
-        else
-          sanitized[key] = value
-        end
+        sanitized[key] = if sensitive_field?(key_sym)
+                           '[REDACTED]'
+                         elsif value.is_a?(Hash)
+                           sanitize_for_logging(value)
+                         elsif value.is_a?(Array)
+                           value.map { |v| v.is_a?(Hash) ? sanitize_for_logging(v) : v }
+                         else
+                           value
+                         end
       end
 
       sanitized
@@ -125,7 +123,7 @@ module Lapsoss
       when :ip_address, :last_login_ip
         mask_ip(value)
       else
-        "[FILTERED]"
+        '[FILTERED]'
       end
     end
 
@@ -138,38 +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..-1]
+      ('*' * (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(".")
+        parts = ip.split('.')
+        return '[INVALID_IP]' if parts.length != 4
+
+        parts[-1] = '***'
+        parts.join('.')
       end
     end
   end
@@ -185,14 +184,12 @@ module Lapsoss
 
       # 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}"
+        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
@@ -200,12 +197,12 @@ module Lapsoss
 
     # Built-in providers for common authentication systems
     def self.devise_provider
-      lambda do |event, hint|
+      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
+          user = request.env['warden']&.user
           return {} unless user
 
           {
@@ -222,19 +219,17 @@ module Lapsoss
     end
 
     def self.omniauth_provider
-      lambda do |event, hint|
+      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
+        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
 
         {}
@@ -242,22 +237,26 @@ module Lapsoss
     end
 
     def self.session_provider
-      lambda do |event, hint|
+      lambda do |_event, hint|
         return {} unless hint[:request]
 
         request = hint[:request]
-        session = request.session rescue {}
+        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"]
+          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|
+      lambda do |_event, _hint|
         # Get user from thread-local storage
         Thread.current[:current_user] || {}
       end
@@ -270,20 +269,18 @@ module Lapsoss
       return unless defined?(Devise)
 
       # Add middleware to capture user context
-      if defined?(Rails)
-        Rails.application.config.middleware.use(UserContextMiddleware)
-      end
+      Rails.application.config.middleware.use(UserContextMiddleware) if defined?(Rails)
     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
+      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
@@ -292,11 +289,11 @@ module Lapsoss
       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
+      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
@@ -337,14 +334,10 @@ module Lapsoss
         }
 
         # Add role information if available
-        if user.respond_to?(:role)
-          context[:role] = user.role
-        end
+        context[:role] = user.role if user.respond_to?(:role)
 
         # Add plan information if available
-        if user.respond_to?(:plan)
-          context[:plan] = user.plan
-        end
+        context[:plan] = user.plan if user.respond_to?(:plan)
 
         context.compact
       else