chore: Format code and fix bench.

Author: GSMLG-BOT

.formatter.exs

@@ -1,4 +1,4 @@
 # Used by "mix format"
 [
-  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test,bench,examples}/**/*.{ex,exs}"]
 ]

bench/session_benchmark.exs

@@ -12,11 +12,16 @@
 alias Phoenix.SessionProcess
 alias Phoenix.SessionProcess.Helpers
 
+Code.ensure_loaded?(Logger) or require Logger
+Logger.configure(level: :info)
+
 IO.puts("🚀 Phoenix Session Process Benchmarking")
 IO.puts(String.duplicate("=", 50))
+{:ok, _} = Phoenix.SessionProcess.Supervisor.start_link([])
 
 # Warm up the system
 IO.puts("Warming up...")
+
 for _i <- 1..100 do
   SessionProcess.start("warmup_#{System.unique_integer()}")
 end
@@ -34,15 +39,16 @@ concurrent_ops = [10, 50, 100]
 
 # 1. Session Creation Performance
 IO.puts("\n📊 Session Creation Benchmark")
-IO.puts("-" * 30)
+IO.puts(String.duplicate("-", 30))
 
 Enum.each(num_sessions, fn count ->
-  {time, _} = :timer.tc(fn ->
-    1..count
-    |> Enum.map(&"session_#{&1}")
-    |> Helpers.start_sessions()
-  end)
-  
+  {time, _} =
+    :timer.tc(fn ->
+      1..count
+      |> Enum.map(&"session_#{&1}")
+      |> Helpers.start_sessions()
+    end)
+
   rate = Float.round(count / (time / 1_000_000), 2)
   IO.puts("Created #{count} sessions in #{time / 1_000}ms (#{rate} sessions/sec)")
 end)
@@ -54,7 +60,7 @@ end)
 
 # 2. Session Communication Performance
 IO.puts("\n📊 Session Communication Benchmark")
-IO.puts("-" * 35)
+IO.puts(String.duplicate("-", 35))
 
 # Create test sessions
 Enum.each(1..100, fn i ->
@@ -63,33 +69,35 @@ end)
 
 # Benchmark calls vs casts
 Enum.each(concurrent_ops, fn ops ->
-  {call_time, _} = :timer.tc(fn ->
-    1..ops
-    |> Enum.map(fn i ->
-      Task.async(fn ->
-        SessionProcess.call("comm_test_#{i}", :ping)
+  {call_time, _} =
+    :timer.tc(fn ->
+      1..ops
+      |> Enum.map(fn i ->
+        Task.async(fn ->
+          SessionProcess.call("comm_test_#{i}", :ping)
+        end)
       end)
+      |> Task.await_many(5000)
     end)
-    |> Task.await_many(5000)
-  end)
 
-  {cast_time, _} = :timer.tc(fn ->
-    1..ops
-    |> Enum.map(fn i ->
-      Task.async(fn ->
-        SessionProcess.cast("comm_test_#{i}", :ping)
+  {cast_time, _} =
+    :timer.tc(fn ->
+      1..ops
+      |> Enum.map(fn i ->
+        Task.async(fn ->
+          SessionProcess.cast("comm_test_#{i}", :ping)
+        end)
       end)
+      |> Task.await_many(5000)
     end)
-    |> Task.await_many(5000)
-  end)
 
   IO.puts("#{ops} concurrent calls: #{call_time / 1000}ms")
   IO.puts("#{ops} concurrent casts: #{cast_time / 1000}ms")
 end)
 
 # 3. Memory Usage Analysis
 IO.puts("\n📊 Memory Usage Analysis")
-IO.puts("-" * 25)
+IO.puts(String.duplicate("-", 25))
 
 # Create varying session counts
 memory_tests = [100, 500, 1000]
@@ -110,12 +118,14 @@ Enum.each(memory_tests, fn count ->
   memory_mb = stats.memory_usage / 1024 / 1024
   avg_memory_kb = stats.avg_memory_per_session / 1024
 
-  IO.puts("#{count} sessions: #{Float.round(memory_mb, 2)}MB total, #{Float.round(avg_memory_kb, 2)}KB per session")
+  IO.puts(
+    "#{count} sessions: #{Float.round(memory_mb, 2)}MB total, #{Float.round(avg_memory_kb, 2)}KB per session"
+  )
 end)
 
 # 4. Registry Lookup Performance
 IO.puts("\n📊 Registry Lookup Performance")
-IO.puts("-" * 32)
+IO.puts(String.duplicate("-", 32))
 
 # Create sessions for lookup tests
 Enum.each(1..1000, fn i ->
@@ -125,19 +135,20 @@ end)
 lookup_tests = [100, 1000, 5000]
 
 Enum.each(lookup_tests, fn iterations ->
-  {time, _} = :timer.tc(fn ->
-    Enum.each(1..iterations, fn i ->
-      SessionProcess.started?("lookup_test_#{rem(i, 1000) + 1}")
+  {time, _} =
+    :timer.tc(fn ->
+      Enum.each(1..iterations, fn i ->
+        SessionProcess.started?("lookup_test_#{rem(i, 1000) + 1}")
+      end)
     end)
-  end)
 
   rate = Float.round(iterations / (time / 1_000_000), 0)
   IO.puts("#{iterations} registry lookups: #{time / 1000}ms (#{rate} lookups/sec)")
 end)
 
 # 5. Error Handling Performance
 IO.puts("\n📊 Error Handling Performance")
-IO.puts("-" * 30)
+IO.puts(String.duplicate("-", 30))
 
 error_tests = [
   {:invalid_session_id, "invalid@session"},
@@ -146,80 +157,107 @@ error_tests = [
 ]
 
 Enum.each(error_tests, fn {scenario, test_id} ->
-  {time, result} = :timer.tc(fn ->
-    case scenario do
-      :invalid_session_id ->
-        SessionProcess.start(test_id)
-      :session_not_found ->
-        SessionProcess.call(test_id, :ping)
-      :timeout_scenario ->
-        SessionProcess.start(test_id)
-        SessionProcess.call(test_id, :slow_operation, 1)
-    end
-  end)
+  {time, result} =
+    :timer.tc(fn ->
+      case scenario do
+        :invalid_session_id ->
+          SessionProcess.start(test_id)
+
+        :session_not_found ->
+          SessionProcess.call(test_id, :ping)
+
+        :timeout_scenario ->
+          SessionProcess.start(test_id)
+          SessionProcess.call(test_id, :slow_operation, 1)
+      end
+    end)
 
   IO.puts("#{scenario}: #{time / 1000}ms - #{inspect(result)}")
 end)
 
 # 6. Cleanup Performance
 IO.puts("\n📊 Cleanup Performance")
-IO.puts("-" * 23)
+IO.puts(String.duplicate("-", 23))
+
+1..10_000
+|> Enum.each(fn i ->
+  SessionProcess.start("cleanup_test_#{i}")
+end)
 
 session_count = length(SessionProcess.list_session())
-{cleanup_time, _} = :timer.tc(fn ->
-  Enum.each(SessionProcess.list_session(), fn {session_id, _pid} ->
-    SessionProcess.terminate(session_id)
+
+{cleanup_time, _} =
+  :timer.tc(fn ->
+    Enum.each(SessionProcess.list_session(), fn {session_id, _pid} ->
+      SessionProcess.terminate(session_id)
+    end)
   end)
-end)
 
-cleanup_rate = Float.round(session_count / (cleanup_time / 1_000_000), 2)
-IO.puts("Cleaned up #{session_count} sessions in #{cleanup_time / 1000}ms (#{cleanup_rate} sessions/sec)")
+cleanup_rate =
+  if cleanup_time == 0 do
+    :infinity
+  else
+    Float.round(session_count / (cleanup_time / 1_000_000), 2)
+  end
+
+IO.puts(
+  "Cleaned up #{session_count} sessions in #{cleanup_time / 1000}ms (#{cleanup_rate} sessions/sec)"
+)
 
 # 7. Helper Functions Performance
 IO.puts("\n📊 Helper Functions Performance")
-IO.puts("-" * 33)
+IO.puts(String.duplicate("-", 33))
 
 # Test batch operations
 Enum.each([100, 200], fn count ->
   session_ids = Enum.map(1..count, &"batch_test_#{&1}")
-  
-  {start_time, _} = :timer.tc(fn ->
-    Helpers.start_sessions(session_ids)
-  end)
-  
-  {terminate_time, _} = :timer.tc(fn ->
-    Helpers.terminate_sessions(session_ids)
-  end)
+
+  {start_time, _} =
+    :timer.tc(fn ->
+      Helpers.start_sessions(session_ids)
+    end)
+
+  {terminate_time, _} =
+    :timer.tc(fn ->
+      Helpers.terminate_sessions(session_ids)
+    end)
 
   IO.puts("#{count} sessions batch start: #{start_time / 1000}ms")
   IO.puts("#{count} sessions batch terminate: #{terminate_time / 1000}ms")
 end)
 
 # 8. Concurrent Stress Test
 IO.puts("\n📊 Concurrent Stress Test")
-IO.puts("-" * 27)
+IO.puts(String.duplicate("-", 27))
 
 stress_test = fn concurrent_ops ->
-  {time, results} = :timer.tc(fn ->
-    1..concurrent_ops
-    |> Enum.map(fn i ->
-      Task.async(fn ->
-        session_id = "stress_#{i}_#{System.unique_integer()}"
-        case SessionProcess.start(session_id) do
-          {:ok, _pid} ->
-            SessionProcess.call(session_id, :ping)
-            SessionProcess.terminate(session_id)
-            :ok
-          error -> error
-        end
+  {time, results} =
+    :timer.tc(fn ->
+      1..concurrent_ops
+      |> Enum.map(fn i ->
+        Task.async(fn ->
+          session_id = "stress_#{i}_#{System.unique_integer()}"
+
+          case SessionProcess.start(session_id) do
+            {:ok, _pid} ->
+              SessionProcess.call(session_id, :ping)
+              SessionProcess.terminate(session_id)
+              :ok
+
+            error ->
+              error
+          end
+        end)
       end)
+      |> Task.await_many(10000)
     end)
-    |> Task.await_many(10000)
-  end)
 
   success_count = Enum.count(results, &(&1 == :ok))
   rate = Float.round(concurrent_ops / (time / 1_000_000), 2)
-  IO.puts("#{concurrent_ops} concurrent ops: #{time / 1000}ms (#{rate} ops/sec) - #{success_count}/#{concurrent_ops} successful")
+
+  IO.puts(
+    "#{concurrent_ops} concurrent ops: #{time / 1000}ms (#{rate} ops/sec) - #{success_count}/#{concurrent_ops} successful"
+  )
 end
 
 stress_test.(100)
@@ -231,4 +269,4 @@ IO.puts(String.duplicate("=", 50))
 # Final system stats
 final_stats = SessionProcess.session_stats()
 IO.puts("Final system state:")
-IO.inspect(final_stats, label: "Session Stats")
+IO.inspect(final_stats, label: "Session Stats")

bench/simple_bench.exs

@@ -8,37 +8,52 @@ alias Phoenix.SessionProcess
 alias Phoenix.SessionProcess.Helpers
 
 # Configure and start required processes
-Application.put_env(:phoenix_session_process, :session_process, Phoenix.SessionProcess.DefaultSessionProcess)
+Application.put_env(
+  :phoenix_session_process,
+  :session_process,
+  Phoenix.SessionProcess.DefaultSessionProcess
+)
+
 {:ok, _} = Phoenix.SessionProcess.Supervisor.start_link([])
 
 IO.puts("🔍 Simple Phoenix Session Process Benchmark")
 IO.puts(String.duplicate("=", 45))
 
 # Quick session creation test
 IO.puts("\n1. Session Creation (100 sessions)")
-{time, results} = :timer.tc(fn ->
-  Enum.map(1..100, fn i ->
-    SessionProcess.start("quick_test_#{i}")
+
+{time, results} =
+  :timer.tc(fn ->
+    Enum.map(1..100, fn i ->
+      SessionProcess.start("quick_test_#{i}")
+    end)
   end)
-end)
 
 success_count = Enum.count(results, &match?({:ok, _}, &1))
-IO.puts("Created #{success_count}/100 sessions in #{time / 1000}ms (#{Float.round(success_count / (time / 1_000_000), 2)} sessions/sec)")
+
+IO.puts(
+  "Created #{success_count}/100 sessions in #{time / 1000}ms (#{Float.round(success_count / (time / 1_000_000), 2)} sessions/sec)"
+)
 
 # Quick communication test
 IO.puts("\n2. Session Communication (50 calls)")
-{call_time, call_results} = :timer.tc(fn ->
-  1..50
-  |> Enum.map(fn i ->
-    Task.async(fn ->
-      SessionProcess.call("quick_test_#{i}", :ping)
+
+{call_time, call_results} =
+  :timer.tc(fn ->
+    1..50
+    |> Enum.map(fn i ->
+      Task.async(fn ->
+        SessionProcess.call("quick_test_#{i}", :ping)
+      end)
     end)
+    |> Task.await_many(5000)
   end)
-  |> Task.await_many(5000)
-end)
 
 call_success = Enum.count(call_results, &match?({:ok, _}, &1))
-IO.puts("#{call_success}/50 calls completed in #{call_time / 1000}ms (#{Float.round(call_success / (call_time / 1_000_000), 2)} calls/sec)")
+
+IO.puts(
+  "#{call_success}/50 calls completed in #{call_time / 1000}ms (#{Float.round(call_success / (call_time / 1_000_000), 2)} calls/sec)"
+)
 
 # Memory usage
 stats = SessionProcess.session_stats()
@@ -49,12 +64,14 @@ IO.puts("Avg per session: #{Float.round(stats.avg_memory_per_session / 1024, 2)}
 
 # Cleanup
 IO.puts("\n4. Cleanup Test")
-{cleanup_time, _} = :timer.tc(fn ->
-  Enum.each(1..100, fn i ->
-    SessionProcess.terminate("quick_test_#{i}")
+
+{cleanup_time, _} =
+  :timer.tc(fn ->
+    Enum.each(1..100, fn i ->
+      SessionProcess.terminate("quick_test_#{i}")
+    end)
   end)
-end)
 
 IO.puts("Cleaned up 100 sessions in #{cleanup_time / 1000}ms")
 
-IO.puts("\n✅ Quick benchmark complete!")
+IO.puts("\n✅ Quick benchmark complete!")