lapsoss 0.3.1 → 0.4.2

data/lib/lapsoss/sampling/time_based_sampler.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  module Sampling
-    class TimeBasedSampler < Base
-      def initialize(schedule: {})
-        @schedule = schedule
-        @default_rate = schedule.fetch(:default, 1.0)
-      end
-
-      def sample?(_event, _hint = {})
-        now = Time.zone.now
-        rate = find_rate_for_time(now)
-        rate > rand
-      end
-
-      private
-
-      def find_rate_for_time(time)
-        hour = time.hour
-        day_of_week = time.wday # 0 = Sunday
-
-        # Check specific hour
-        hour_key = :"hour_#{hour}"
-        return @schedule[hour_key] if @schedule.key?(hour_key)
-
-        # Check day of week
-        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)
-
-        # Check business hours
-        if @schedule.key?(:business_hours) && (9..17).cover?(hour) && (1..5).cover?(day_of_week)
-          return @schedule[:business_hours]
-        end
-
-        # Check weekends
-        return @schedule[:weekends] if @schedule.key?(:weekends) && [ 0, 6 ].include?(day_of_week)
-
-        @default_rate
-      end
-    end
-  end
-end

data/lib/lapsoss/sampling/user_based_sampler.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  module Sampling
-    class UserBasedSampler < Base
-      def initialize(rates: {})
-        @rates = rates
-        @default_rate = rates.fetch(:default, 1.0)
-      end
-
-      def sample?(event, _hint = {})
-        user = event.context[:user]
-        return @default_rate > rand unless user
-
-        rate = find_rate_for_user(user)
-        rate > rand
-      end
-
-      private
-
-      def find_rate_for_user(user)
-        # Check specific 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"]
-          end
-        end
-
-        @default_rate
-      end
-    end
-  end
-end

data/lib/lapsoss/user_context.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  # Enhanced user context handling with privacy controls
-  class UserContext
-    SENSITIVE_FIELDS = %i[
-      email phone mobile telephone
-      address street city state zip postal_code country
-      ssn social_security_number
-      credit_card card_number cvv
-      password password_confirmation
-      secret token api_key
-      ip_address last_login_ip
-      birth_date date_of_birth dob
-      salary income wage
-    ].freeze
-
-    def initialize(privacy_mode: false, allowed_fields: nil, field_transformers: {})
-      @privacy_mode = privacy_mode
-      @allowed_fields = allowed_fields&.map(&:to_sym)
-      @field_transformers = field_transformers
-    end
-
-    def process_user_data(user_data)
-      return {} unless user_data.is_a?(Hash)
-
-      processed = {}
-
-      user_data.each do |key, value|
-        key_sym = key.to_sym
-
-        # Skip if not in allowed fields list (when specified)
-        next if @allowed_fields&.exclude?(key_sym)
-
-        # Apply privacy filtering
-        processed[key] = if @privacy_mode && sensitive_field?(key_sym)
-                           apply_privacy_filter(key_sym, value)
-        else
-                           transform_field(key_sym, value)
-        end
-      end
-
-      processed
-    end
-
-    def merge_user_data(existing_data, new_data)
-      existing_processed = process_user_data(existing_data || {})
-      new_processed = process_user_data(new_data || {})
-
-      existing_processed.merge(new_processed)
-    end
-
-    def extract_user_id(user_data)
-      return nil unless user_data.is_a?(Hash)
-
-      # Try common user ID fields in order of preference
-      %i[id user_id uuid guid].each do |field|
-        value = user_data[field] || user_data[field.to_s]
-        return value if value
-      end
-
-      nil
-    end
-
-    def extract_user_segment(user_data)
-      return nil unless user_data.is_a?(Hash)
-
-      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?
-
-      # Check role-based segments
-      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"]
-        segments[:plan] = plan.to_s.downcase
-      end
-
-      segments.compact
-    end
-
-    def sanitize_for_logging(user_data)
-      return {} unless user_data.is_a?(Hash)
-
-      sanitized = {}
-
-      user_data.each do |key, value|
-        key_sym = key.to_sym
-
-        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
-    end
-
-    private
-
-    def sensitive_field?(field)
-      SENSITIVE_FIELDS.include?(field) || field.to_s.match?(/password|secret|token|key|ssn|credit|card/i)
-    end
-
-    def apply_privacy_filter(field, value)
-      case field
-      when :email
-        mask_email(value)
-      when :phone, :mobile, :telephone
-        mask_phone(value)
-      when :ip_address, :last_login_ip
-        mask_ip(value)
-      else
-        "[FILTERED]"
-      end
-    end
-
-    def transform_field(field, value)
-      if transformer = @field_transformers[field]
-        transformer.call(value)
-      else
-        value
-      end
-    end
-
-    def mask_email(email)
-      return "[INVALID_EMAIL]" unless email.is_a?(String) && email.include?("@")
-
-      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)
-
-      # Remove all non-digits
-      digits = phone.gsub(/\D/, "")
-      return "[INVALID_PHONE]" if digits.length < 4
-
-      # Show last 4 digits
-      ("*" * (digits.length - 4)) + digits[-4..]
-    end
-
-    def mask_ip(ip)
-      return "[INVALID_IP]" unless ip.is_a?(String)
-
-      if ip.include?(":")
-        # IPv6 - mask last 4 groups
-        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
-end

data/lib/lapsoss/user_context_integrations.rb

@@ -1,39 +0,0 @@
-# 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

@@ -1,50 +0,0 @@
-# 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

@@ -1,93 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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