lapsoss 0.4.0 → 0.4.4

data/lib/lapsoss/sampling/health_based_sampler.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  module Sampling
-    class HealthBasedSampler < Base
-      def initialize(health_check:, high_rate: 1.0, low_rate: 0.1)
-        @health_check = health_check
-        @high_rate = high_rate
-        @low_rate = low_rate
-      end
-
-      def sample?(_event, _hint = {})
-        healthy = @health_check.call
-        rate = healthy ? @high_rate : @low_rate
-        rate > rand
-      end
-    end
-  end
-end

data/lib/lapsoss/sampling/sampling_factory.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  module Sampling
-    # Factory for creating common sampling configurations
-    class SamplingFactory
-      def self.create_production_sampling
-        CompositeSampler.new(
-          samplers: [
-            # Rate limit to prevent overwhelming
-            RateLimiter.new(max_events_per_second: 50),
-
-            # Different rates for different exception types
-            ExceptionTypeSampler.new(rates: {
-                                       # Critical errors - always sample
-                                       SecurityError => 1.0,
-                                       SystemStackError => 1.0,
-                                       NoMemoryError => 1.0,
-
-                                       # Common errors - sample less
-                                       ArgumentError => 0.1,
-                                       TypeError => 0.1,
-
-                                       # Network errors - medium sampling
-                                       /timeout/i => 0.3,
-                                       /connection/i => 0.3,
-
-                                       # 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
-                                 })
-          ],
-          strategy: :all
-        )
-      end
-
-      def self.create_development_sampling
-        UniformSampler.new(1.0) # Sample everything in development
-      end
-
-      def self.create_user_focused_sampling
-        CompositeSampler.new(
-          samplers: [
-            # Higher sampling for internal users
-            UserBasedSampler.new(rates: {
-                                   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) }
-            )
-          ],
-          strategy: :any
-        )
-      end
-    end
-  end
-end

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,185 +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]"
-        else
-                           case value
-                           in Hash => h
-                             sanitize_for_logging(h)
-                           in Array => arr
-                             arr.map do |v|
-                               case v
-                               in Hash => h
-                                 sanitize_for_logging(h)
-                               else
-                                 v
-                               end
-                             end
-                           else
-                             value
-                           end
-        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,11 +0,0 @@
-# frozen_string_literal: true
-
-module Lapsoss
-  module Utils
-    module_function
-
-    def current_time
-      Time.zone.now
-    end
-  end
-end

data/lib/tasks/cassettes.rake

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-
-namespace :cassettes do
-  desc "Sanitize VCR cassettes by scrubbing sensitive data"
-  task :sanitize do
-    dir = File.expand_path("../../test/cassettes", __dir__)
-    files = Dir[File.join(dir, "*.yml")]
-    puts "Sanitizing #{files.size} cassette(s) in #{dir}..."
-
-    email_re = /\b[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\b/i
-    hostname_key_re = /"hostname":"[^"]+"/
-    home_path_re = Regexp.new(Regexp.escape(Dir.home))
-    api_key_pairs = [
-      [ /"apiKey":"[^"]+"/, '"apiKey":"<INSIGHT_HUB_API_KEY>"' ],
-      [ /"access_token":"[^"]+"/, '"access_token":"<ROLLBAR_ACCESS_TOKEN>"' ],
-      [ /api_key=[^&]+/, "api_key=<APPSIGNAL_FRONTEND_API_KEY>" ]
-    ]
-
-    header_key_map = {
-      "X-Rollbar-Access-Token" => "<ROLLBAR_ACCESS_TOKEN>",
-      "Bugsnag-Api-Key" => "<INSIGHT_HUB_API_KEY>",
-      "Authorization" => "<AUTHORIZATION>"
-    }
-
-    files.each do |file|
-      content = File.read(file)
-
-      # Replace patterns in raw content safely
-      content = content.gsub(email_re, "<EMAIL>")
-      content = content.gsub(hostname_key_re, '"hostname":"<HOSTNAME>"')
-      content = content.gsub(home_path_re, "/home/user")
-      api_key_pairs.each { |(re, rep)| content = content.gsub(re, rep) }
-
-      # Normalize User-Agent references to avoid machine leakage
-      content = content.gsub(/User-Agent:\n\s+-\s+.+/, "User-Agent:\n  - lapsoss/x.y.z") rescue nil
-
-      # Rewrite known header values
-      header_key_map.each do |hdr, placeholder|
-        content = content.gsub(/#{hdr}:(?:\n\s+-\s+.*)/, "#{hdr}:\n  - \"#{placeholder}\"")
-      end
-
-      File.write(file, content)
-      puts "  scrubbed: #{File.basename(file)}"
-    end
-
-    puts "Done."
-  end
-end