lazy_init 0.1.0

data/benchmarks/benchmark_performance.rb

@@ -0,0 +1,250 @@
+require 'benchmark'
+require 'lazy_init'
+
+
+# LazyInit vs Manual Performance Benchmark
+# Testing with realistic production-like expensive operations:
+
+# --- Configuration Parsing ---
+# Description: JSON/YAML parsing with complex nested structures
+
+# Warming up (performing actual expensive computation)...
+# Initial computation time:
+#   Manual: 14.25ms
+#   LazyInit: 13.28ms
+#   Difference: -0.96ms
+
+# Benchmarking cached access (100,000 iterations):
+#                  user     system      total        real
+# Manual       0.012272   0.000034   0.012306 (  0.012490)
+# LazyInit     0.041375   0.000231   0.041606 (  0.041994)
+
+# ============================================================
+
+# --- Cryptographic Operations ---
+# Description: Secure token generation with multiple hash rounds
+
+# Warming up (performing actual expensive computation)...
+# Initial computation time:
+#   Manual: 4.65ms
+#   LazyInit: 2.37ms
+#   Difference: -2.28ms
+
+# Benchmarking cached access (100,000 iterations):
+#                  user     system      total        real
+# Manual       0.012351   0.000057   0.012408 (  0.012445)
+# LazyInit     0.042226   0.000220   0.042446 (  0.042752)
+
+# ============================================================
+
+# --- Data Processing ---
+# Description: ETL-style data aggregation and grouping
+
+# Warming up (performing actual expensive computation)...
+# Initial computation time:
+#   Manual: 2.61ms
+#   LazyInit: 2.84ms
+#   Difference: 0.22ms
+
+# Benchmarking cached access (100,000 iterations):
+#                  user     system      total        real
+# Manual       0.012233   0.000048   0.012281 (  0.012375)
+# LazyInit     0.044622   0.000262   0.044884 (  0.045389)
+
+# ============================================================
+
+# Thread Safety Test
+# Testing concurrent access to verify no race conditions...
+# Computing in thread: 60
+# Thread safety results:
+#   Unique object IDs: 1 (should be 1)
+#   All threads got same object: ✅ PASS
+#   Total threads: 10
+# Test Environment: Ruby 3.0.2, x86_64
+# Platform: x86_64-darwin19
+#✅ Thread safety confirmed: All threads received the same computed object
+
+module ExpensiveOperations
+  def parse_configuration
+    config_data = {
+      database: {
+        host: 'localhost',
+        port: 5432,
+        pool_size: 20,
+        timeout: 30,
+        retries: 3
+      },
+      redis: {
+        url: 'redis://localhost:6379',
+        pool_size: 10,
+        timeout: 5
+      },
+      api_keys: Hash[(1..50).map { |i| ["key_#{i}", "secret_#{rand(100000)}"] }],
+      feature_flags: Hash[(1..100).map { |i| ["feature_#{i}", [true, false].sample] }]
+    }
+    
+    serialized = config_data.to_s
+    100.times { serialized.gsub(/\d+/, &:to_i) }
+    
+    config_data
+  end
+  
+  def generate_secure_token
+    require 'digest'
+    
+    base_string = "secure_token_#{Time.now.to_f}_#{rand(1000000)}"
+    
+    token = base_string
+    1000.times do |i|
+      token = Digest::SHA256.hexdigest("#{token}_#{i}")
+    end
+    
+    token
+  end
+  
+  def process_dataset
+    data = (1..1000).map do |i|
+      {
+        id: i,
+        timestamp: Time.now - rand(86400 * 30),
+        value: rand(1000.0).round(2),
+        category: ['A', 'B', 'C', 'D'][rand(4)],
+        metadata: { source: "system_#{rand(10)}", priority: rand(5) }
+      }
+    end
+    
+    grouped = data.group_by { |item| item[:category] }
+    aggregated = grouped.transform_values do |items|
+      {
+        count: items.size,
+        total_value: items.sum { |item| item[:value] },
+        avg_value: items.sum { |item| item[:value] } / items.size.to_f,
+        latest: items.max_by { |item| item[:timestamp] }
+      }
+    end
+    
+    aggregated
+  end
+end
+
+class ManualClass
+  include ExpensiveOperations
+  
+  def configuration
+    @configuration ||= parse_configuration
+  end
+  
+  def secure_token
+    @secure_token ||= generate_secure_token
+  end
+  
+  def processed_data
+    @processed_data ||= process_dataset
+  end
+end
+
+class LazyClass
+  extend LazyInit
+  include ExpensiveOperations
+  
+  lazy_attr_reader :configuration do
+    parse_configuration
+  end
+  
+  lazy_attr_reader :secure_token do
+    generate_secure_token
+  end
+  
+  lazy_attr_reader :processed_data do
+    process_dataset
+  end
+end
+
+puts "LazyInit vs Manual Performance Benchmark"
+puts "Testing with realistic production-like expensive operations:\n\n"
+
+scenarios = [
+  {
+    name: "Configuration Parsing",
+    method: :configuration,
+    description: "JSON/YAML parsing with complex nested structures"
+  },
+  {
+    name: "Cryptographic Operations", 
+    method: :secure_token,
+    description: "Secure token generation with multiple hash rounds"
+  },
+  {
+    name: "Data Processing",
+    method: :processed_data,
+    description: "ETL-style data aggregation and grouping"
+  }
+]
+
+scenarios.each do |scenario|
+  puts "--- #{scenario[:name]} ---"
+  puts "Description: #{scenario[:description]}\n\n"
+  
+  manual = ManualClass.new
+  lazy = LazyClass.new
+  
+  puts "Warming up (performing actual expensive computation)..."
+  manual_start = Time.now
+  manual.send(scenario[:method])
+  manual_time = Time.now - manual_start
+  
+  lazy_start = Time.now  
+  lazy.send(scenario[:method])
+  lazy_time = Time.now - lazy_start
+  
+  puts "Initial computation time:"
+  puts "  Manual: #{(manual_time * 1000).round(2)}ms"
+  puts "  LazyInit: #{(lazy_time * 1000).round(2)}ms"
+  puts "  Difference: #{((lazy_time - manual_time) * 1000).round(2)}ms\n\n"
+  
+  puts "Benchmarking cached access (100,000 iterations):"
+  Benchmark.bm(10) do |x|
+    x.report("Manual") { 100_000.times { manual.send(scenario[:method]) } }
+    x.report("LazyInit") { 100_000.times { lazy.send(scenario[:method]) } }
+  end
+  
+  puts "\n" + "="*60 + "\n\n"
+end
+
+puts "Thread Safety Test"
+puts "Testing concurrent access to verify no race conditions...\n"
+
+class ThreadTestClass
+  extend LazyInit
+  include ExpensiveOperations
+  
+  lazy_attr_reader :thread_safe_data do
+    puts "Computing in thread: #{Thread.current.object_id}"
+    process_dataset
+  end
+end
+
+service = ThreadTestClass.new
+
+results = []
+threads = 10.times.map do |i|
+  Thread.new do
+    data = service.thread_safe_data
+    results << data.object_id
+  end
+end
+
+threads.each(&:join)
+
+puts "Thread safety results:"
+puts "  Unique object IDs: #{results.uniq.size} (should be 1)"
+puts "  All threads got same object: #{results.uniq.size == 1 ? '✅ PASS' : '❌ FAIL'}"
+puts "  Total threads: #{results.size}"
+puts "Test Environment: Ruby #{RUBY_VERSION}, #{RbConfig::CONFIG['target_cpu']}"
+puts "Platform: #{RUBY_PLATFORM}"
+
+if results.uniq.size == 1
+  puts "\n✅ Thread safety confirmed: All threads received the same computed object"
+else
+  puts "\n❌ Thread safety failed: Race condition detected!"
+end

data/benchmarks/benchmark_threads.rb

@@ -0,0 +1,433 @@
+require 'lazy_init'
+require 'benchmark'
+
+#  ===  THREAD SAFETY TESTS ===
+# Testing LazyInit in production-like concurrent scenarios
+
+#  TEST 1: Traffic Spike Simulation
+# Simulating 200 simultaneous user requests hitting cached resources
+# ------------------------------------------------------------
+# Starting traffic spike test...
+#  Loading DB config in thread: 60
+# Creating connection pool in thread: 60
+# Fetching permissions in thread: 60
+
+#  Traffic Spike Results:
+#   Duration: 472.91ms
+#   Threads: 200
+#   Successful requests: 200
+#   Errors: 0
+
+#  Race Condition Analysis:
+#   DB Config - Unique objects: 1 (should be 1)
+#   Connection Pool - Unique objects: 1 (should be 1)
+#   Permissions - Unique objects: 1 (should be 1)
+#   Result: ✅ PASS - No race conditions detected
+
+# ============================================================
+# TEST 2: Sustained Load Simulation
+# Simulating background workers with sustained concurrent access
+# ------------------------------------------------------------
+# Starting sustained load test (30 workers x 50 operations each)...
+# Initializing API client in thread: 140
+# Fetching permissions in thread: 140
+
+#  Sustained Load Results:
+#   Duration: 0.25s
+#   Total operations: 1500
+#   Errors: 0
+#   Operations/second: 6039
+
+#   Consistency Analysis:
+#   API Client - Unique objects: 1 (should be 1)
+#   Shared Cache - Unique objects: 1 (should be 1)
+#   Result: ✅ PASS - Consistency maintained
+
+# ============================================================
+#  TEST 3: Dependency Chain Stress Test
+# Testing complex dependency resolution under concurrent pressure
+# ------------------------------------------------------------
+# Starting dependency chain test (100 concurrent accesses to complex dependency)...
+# Computing base_config in thread: 220
+#  Loading DB config in thread: 220
+# Computing connection_manager in thread: 220
+# Creating connection pool in thread: 220
+# Computing auth_service in thread: 220
+# Fetching permissions in thread: 220
+# Computing api_gateway in thread: 220
+# Initializing API client in thread: 220
+
+#  Dependency Chain Results:
+#   Duration: 550.29ms
+#   All dependencies computed: true
+#   Unique gateway objects: 1 (should be 1)
+#   Result: ✅ PASS - Dependency resolution works correctly
+
+# ============================================================
+# TEST 4: Reset and Recovery Under Load
+# Testing reset operations during concurrent access (production maintenance scenario)
+# ------------------------------------------------------------
+# Starting reset test (readers + periodic resets)...
+#  Loading DB config in thread: 260
+#   Reset 1 performed
+#   Reset 2 performed
+#  Loading DB config in thread: 300
+#   Reset 3 performed
+#  Loading DB config in thread: 340
+#   Reset 4 performed
+#  Loading DB config in thread: 380
+#   Reset 5 performed
+#  Loading DB config in thread: 420
+#   Reset 6 performed
+#  Loading DB config in thread: 460
+#   Reset 7 performed
+#  Loading DB config in thread: 300
+#   Reset 8 performed
+#  Loading DB config in thread: 300
+
+#  Reset and Recovery Results:
+#   Total access attempts: 1000
+#   Successful accesses: 1000
+#   Resets performed: 8
+#   Success rate: 100.0%
+#   Unique config objects: 8 (should be > 1 due to resets)
+#   Result: ✅ PASS - Reset and recovery works correctly
+
+# ============================================================
+#  === FINAL THREAD SAFETY SUMMARY ===
+# Test Environment: Ruby 3.0.2, x86_64
+# Platform: x86_64-darwin19
+
+# Results:
+#   ✅ Traffic Spike (200 concurrent): PASS
+#   ✅ Sustained Load (1500 operations): PASS
+#   ✅ Dependency Chain (100 concurrent): PASS
+#   ✅ Reset Recovery (periodic resets): PASS
+
+# Overall Result: ✅ ALL TESTS PASSED
+
+module ProductionOperations
+  def load_database_config
+    puts " Loading DB config in thread: #{Thread.current.object_id}"
+    sleep(0.1)
+    {
+      host: 'prod-db.company.com',
+      port: 5432,
+      pool_size: 20,
+      connections: Array.new(20) { |i| "conn_#{i}_#{rand(10000)}" }
+    }
+  end
+  
+  def create_connection_pool
+    puts "Creating connection pool in thread: #{Thread.current.object_id}"
+    sleep(0.2)
+    pool_id = rand(100000)
+    {
+      id: pool_id,
+      connections: Array.new(50) { |i| "active_conn_#{pool_id}_#{i}" },
+      created_at: Time.now
+    }
+  end
+  
+  def fetch_user_permissions
+    puts "Fetching permissions in thread: #{Thread.current.object_id}"
+    sleep(0.15)
+    permissions = {}
+    (1..1000).each { |i| permissions["user_#{i}"] = ["read", "write", "admin"].sample }
+    permissions
+  end
+  
+  def initialize_api_client
+    puts "Initializing API client in thread: #{Thread.current.object_id}"  
+    sleep(0.08)
+    {
+      client_id: "api_#{rand(50000)}",
+      token: "bearer_#{rand(1000000)}",
+      endpoints: %w[users orders payments analytics],
+      initialized_at: Time.now
+    }
+  end
+end
+
+puts " ===  THREAD SAFETY TESTS ==="
+puts "Testing LazyInit in production-like concurrent scenarios\n\n"
+
+puts " TEST 1: Traffic Spike Simulation"
+puts "Simulating 200 simultaneous user requests hitting cached resources"
+puts "-" * 60
+
+class TrafficSpikeService
+  extend LazyInit
+  include ProductionOperations
+  
+  lazy_attr_reader :db_config do
+    load_database_config
+  end
+  
+  lazy_attr_reader :connection_pool do
+    create_connection_pool  
+  end
+  
+  lazy_attr_reader :user_permissions do
+    fetch_user_permissions
+  end
+end
+
+spike_service = TrafficSpikeService.new
+spike_results = []
+spike_errors = []
+
+puts "Starting traffic spike test..."
+start_time = Time.now
+
+spike_threads = 200.times.map do |i|
+  Thread.new do
+    begin
+      config = spike_service.db_config
+      pool = spike_service.connection_pool  
+      permissions = spike_service.user_permissions
+      
+      spike_results << {
+        thread: i,
+        config_id: config.object_id,
+        pool_id: pool.object_id,
+        permissions_id: permissions.object_id,
+        timestamp: Time.now
+      }
+    rescue => e
+      spike_errors << { thread: i, error: e.message }
+    end
+  end
+end
+
+spike_threads.each(&:join)
+spike_duration = Time.now - start_time
+
+puts "\n Traffic Spike Results:"
+puts "  Duration: #{(spike_duration * 1000).round(2)}ms"
+puts "  Threads: #{spike_threads.size}"
+puts "  Successful requests: #{spike_results.size}"
+puts "  Errors: #{spike_errors.size}"
+
+config_ids = spike_results.map { |r| r[:config_id] }.uniq
+pool_ids = spike_results.map { |r| r[:pool_id] }.uniq  
+permission_ids = spike_results.map { |r| r[:permissions_id] }.uniq
+
+puts "\n Race Condition Analysis:"
+puts "  DB Config - Unique objects: #{config_ids.size} (should be 1)"
+puts "  Connection Pool - Unique objects: #{pool_ids.size} (should be 1)"
+puts "  Permissions - Unique objects: #{permission_ids.size} (should be 1)"
+
+spike_passed = config_ids.size == 1 && pool_ids.size == 1 && permission_ids.size == 1
+puts "  Result: #{spike_passed ? '✅ PASS' : '❌ FAIL'} - No race conditions detected"
+
+puts "\n" + "="*60 + "\n"
+
+puts "TEST 2: Sustained Load Simulation"  
+puts "Simulating background workers with sustained concurrent access"
+puts "-" * 60
+
+class WorkerService
+  extend LazyInit
+  include ProductionOperations
+  
+  lazy_attr_reader :api_client do
+    initialize_api_client
+  end
+  
+  lazy_attr_reader :shared_cache do
+    fetch_user_permissions
+  end
+end
+
+worker_service = WorkerService.new
+worker_results = []
+worker_errors = []
+
+puts "Starting sustained load test (30 workers x 50 operations each)..."
+
+worker_threads = 30.times.map do |worker_id|
+  Thread.new do
+    thread_results = []
+    50.times do |operation|
+      begin
+        api = worker_service.api_client
+        cache = worker_service.shared_cache
+        
+        thread_results << {
+          worker: worker_id,
+          operation: operation,
+          api_id: api.object_id,
+          cache_id: cache.object_id
+        }
+        
+        sleep(0.001) if operation % 10 == 0
+      rescue => e
+        worker_errors << { worker: worker_id, operation: operation, error: e.message }
+      end
+    end
+    
+    worker_results.concat(thread_results)
+  end
+end
+
+worker_start = Time.now
+worker_threads.each(&:join)
+worker_duration = Time.now - worker_start
+
+puts "\n Sustained Load Results:"
+puts "  Duration: #{worker_duration.round(2)}s"
+puts "  Total operations: #{worker_results.size}"
+puts "  Errors: #{worker_errors.size}"
+puts "  Operations/second: #{(worker_results.size / worker_duration).round(0)}"
+
+api_ids = worker_results.map { |r| r[:api_id] }.uniq
+cache_ids = worker_results.map { |r| r[:cache_id] }.uniq
+
+puts "\n  Consistency Analysis:"
+puts "  API Client - Unique objects: #{api_ids.size} (should be 1)"
+puts "  Shared Cache - Unique objects: #{cache_ids.size} (should be 1)"
+
+worker_passed = api_ids.size == 1 && cache_ids.size == 1
+puts "  Result: #{worker_passed ? '✅ PASS' : '❌ FAIL'} - Consistency maintained"
+
+puts "\n" + "="*60 + "\n"
+
+puts " TEST 3: Dependency Chain Stress Test"
+puts "Testing complex dependency resolution under concurrent pressure"
+puts "-" * 60
+
+class DependencyChainService
+  extend LazyInit
+  include ProductionOperations
+  
+  lazy_attr_reader :base_config do
+    puts "Computing base_config in thread: #{Thread.current.object_id}"
+    load_database_config
+  end
+  
+  lazy_attr_reader :connection_manager, depends_on: [:base_config] do
+    puts "Computing connection_manager in thread: #{Thread.current.object_id}"
+    create_connection_pool
+  end
+  
+  lazy_attr_reader :auth_service, depends_on: [:base_config] do
+    puts "Computing auth_service in thread: #{Thread.current.object_id}"
+    fetch_user_permissions
+  end
+  
+  lazy_attr_reader :api_gateway, depends_on: [:connection_manager, :auth_service] do
+    puts "Computing api_gateway in thread: #{Thread.current.object_id}"
+    initialize_api_client
+  end
+end
+
+dependency_service = DependencyChainService.new
+dependency_results = []
+
+puts "Starting dependency chain test (100 concurrent accesses to complex dependency)..."
+
+dependency_threads = 100.times.map do |i|
+  Thread.new do
+    gateway = dependency_service.api_gateway
+    
+    dependency_results << {
+      thread: i,
+      gateway_id: gateway.object_id,
+      base_config_computed: dependency_service.base_config_computed?,
+      connection_manager_computed: dependency_service.connection_manager_computed?,
+      auth_service_computed: dependency_service.auth_service_computed?,
+      api_gateway_computed: dependency_service.api_gateway_computed?
+    }
+  end
+end
+
+dependency_start = Time.now
+dependency_threads.each(&:join)
+dependency_duration = Time.now - dependency_start
+
+puts "\n Dependency Chain Results:"
+puts "  Duration: #{(dependency_duration * 1000).round(2)}ms"
+puts "  All dependencies computed: #{dependency_results.all? { |r| r[:api_gateway_computed] }}"
+
+gateway_ids = dependency_results.map { |r| r[:gateway_id] }.uniq
+puts "  Unique gateway objects: #{gateway_ids.size} (should be 1)"
+
+dependency_passed = gateway_ids.size == 1
+puts "  Result: #{dependency_passed ? '✅ PASS' : '❌ FAIL'} - Dependency resolution works correctly"
+
+puts "\n" + "="*60 + "\n"
+
+puts "TEST 4: Reset and Recovery Under Load"
+puts "Testing reset operations during concurrent access (production maintenance scenario)"
+puts "-" * 60
+
+class ResetTestService
+  extend LazyInit
+  include ProductionOperations
+  
+  lazy_attr_reader :service_config do
+    load_database_config
+  end
+end
+
+reset_service = ResetTestService.new
+reset_results = []
+reset_stats = { resets: 0, access_attempts: 0, successes: 0 }
+
+puts "Starting reset test (readers + periodic resets)..."
+
+reader_threads = 20.times.map do |i|
+  Thread.new do
+    50.times do |attempt|
+      begin
+        reset_stats[:access_attempts] += 1
+        config = reset_service.service_config
+        reset_results << { thread: i, attempt: attempt, config_id: config.object_id }
+        reset_stats[:successes] += 1
+        sleep(0.01)
+      rescue => e
+      end
+    end
+  end
+end
+
+reset_thread = Thread.new do
+  8.times do
+    sleep(0.1)
+    reset_service.reset_service_config!
+    reset_stats[:resets] += 1
+    puts "  Reset #{reset_stats[:resets]} performed"
+  end
+end
+
+[*reader_threads, reset_thread].each(&:join)
+
+puts "\n Reset and Recovery Results:"
+puts "  Total access attempts: #{reset_stats[:access_attempts]}"
+puts "  Successful accesses: #{reset_stats[:successes]}"
+puts "  Resets performed: #{reset_stats[:resets]}"
+puts "  Success rate: #{((reset_stats[:successes].to_f / reset_stats[:access_attempts]) * 100).round(1)}%"
+
+unique_configs = reset_results.map { |r| r[:config_id] }.uniq
+puts "  Unique config objects: #{unique_configs.size} (should be > 1 due to resets)"
+
+reset_passed = unique_configs.size > 1 && reset_stats[:successes] > 0
+puts "  Result: #{reset_passed ? '✅ PASS' : '❌ FAIL'} - Reset and recovery works correctly"
+
+puts "\n" + "="*60 + "\n"
+
+all_tests_passed = spike_passed && worker_passed && dependency_passed && reset_passed
+
+puts " === FINAL THREAD SAFETY SUMMARY ==="
+puts "Test Environment: Ruby #{RUBY_VERSION}, #{RbConfig::CONFIG['target_cpu']}"
+puts "Platform: #{RUBY_PLATFORM}"
+puts ""
+puts "Results:"
+puts "  ✅ Traffic Spike (200 concurrent): #{spike_passed ? 'PASS' : 'FAIL'}"
+puts "  ✅ Sustained Load (1500 operations): #{worker_passed ? 'PASS' : 'FAIL'}"  
+puts "  ✅ Dependency Chain (100 concurrent): #{dependency_passed ? 'PASS' : 'FAIL'}"
+puts "  ✅ Reset Recovery (periodic resets): #{reset_passed ? 'PASS' : 'FAIL'}"
+puts ""
+puts "Overall Result: #{all_tests_passed ? '✅ ALL TESTS PASSED' : '❌ SOME TESTS FAILED'}"
+puts ""