progress on phoenix scope player

Author: NSHkr

test_apps/lib/phoenix_scope_player/data_provider.ex

@@ -11,24 +11,24 @@ defmodule PhoenixScopePlayer.DataProvider do
   Lists all available debug sessions.
   """
   def list_sessions do
-    IO.puts("\n=== Listing Sessions ===")
+    Logger.info("\n=== Listing Sessions ===")
     case File.ls(@sessions_dir) do
       {:ok, session_dirs} ->
-        IO.puts("Found #{length(session_dirs)} session directories")
+        Logger.info("Found #{length(session_dirs)} session directories")
         sessions = session_dirs
         |> Enum.map(&load_session_metadata/1)
         |> Enum.reject(&is_nil/1)
         |> Enum.sort_by(& &1["date"], :desc)
 
-        IO.puts("Processed #{length(sessions)} valid sessions:")
+        Logger.info("Processed #{length(sessions)} valid sessions:")
         Enum.each(sessions, fn session ->
-          IO.puts("  - #{session["id"]}: #{session["event_count"]} events")
+          Logger.info("  - #{session["id"]}: #{session["event_count"]} events")
         end)
 
         sessions
 
       {:error, reason} ->
-        IO.puts("Error listing sessions: #{inspect(reason)}")
+        Logger.error("Error listing sessions: #{inspect(reason)}")
         []
     end
   end
@@ -37,32 +37,70 @@ defmodule PhoenixScopePlayer.DataProvider do
   Gets the complete data for a specific session.
   """
   def get_session_data(session_id) do
-    IO.puts("\n=== Getting Session Data: #{session_id} ===")
+    Logger.info("\n=== Getting Session Data: #{session_id} ===")
     session_dir = Path.join(@sessions_dir, session_id)
 
     with {:ok, metadata} <- read_json_file(session_dir, "metadata.json"),
          {:ok, events} <- read_json_file(session_dir, "events.json"),
          {:ok, source_code} <- read_json_file(session_dir, "source_code.json") do
 
-      IO.puts("Metadata: #{inspect(metadata)}")
-      IO.puts("Events count: #{length(events || [])}")
+      # Transform events into the expected format
+      transformed_events = Enum.map(events, fn event ->
+        %{
+          "type" => event["type"],
+          "module" => get_in(event, ["data", "module"]),
+          "function" => get_in(event, ["data", "function"]),
+          "args" => format_args(get_in(event, ["data", "args"])),
+          "return_value" => format_return_value(get_in(event, ["data", "return_value"])),
+          "pid" => event["id"],
+          "timestamp" => event["timestamp_ns"],
+          "variables" => get_in(event, ["data", "variables"])
+        }
+      end)
+      
+      # Transform source code into the expected format
+      transformed_source_code = %{
+        "files" => Map.new(source_code, fn {module, content} ->
+          {module, %{
+            "content" => content,
+            "type" => "elixir"
+          }}
+        end)
+      }
+      
+      Logger.info("Metadata: #{inspect(metadata)}")
+      Logger.info("Events count: #{length(transformed_events)}")
+      Logger.info("Source code files: #{inspect(Map.keys(transformed_source_code["files"]))}")
 
       {:ok, %{
-        metadata: metadata,
-        events: events,  # The events are directly in the root of events.json
-        source_code: source_code
+        "metadata" => metadata,
+        "events" => transformed_events,
+        "source_code" => transformed_source_code
       }}
     else
       error -> 
-        IO.puts("Error reading session data: #{inspect(error)}")
+        Logger.error("Error reading session data: #{inspect(error)}")
         {:error, :not_found}
     end
   end
 
   # Private helpers
 
+  defp format_args(nil), do: nil
+  defp format_args(args) when is_list(args) do
+    Enum.map(args, &format_value/1)
+  end
+
+  defp format_return_value(nil), do: nil
+  defp format_return_value(value), do: format_value(value)
+
+  defp format_value(%{"type" => type, "value" => value}) do
+    "#{type}: #{value}"
+  end
+  defp format_value(value), do: inspect(value)
+
   defp load_session_metadata(session_dir) do
-    IO.puts("\nLoading metadata for session: #{session_dir}")
+    Logger.info("\nLoading metadata for session: #{session_dir}")
     case read_json_file(Path.join(@sessions_dir, session_dir), "metadata.json") do
       {:ok, metadata} ->
         # Read events file to get actual event count
@@ -78,36 +116,36 @@ defmodule PhoenixScopePlayer.DataProvider do
 
         session = Map.merge(metadata, %{
           "id" => session_dir,
-          "name" => session_dir |> String.replace("_", " ") |> String.capitalize(),
+          "name" => metadata["name"] || session_dir |> String.replace("_", " ") |> String.capitalize(),
           "date" => metadata["timestamp"] || "Unknown",
-          "description" => "Debug session with #{actual_event_count} events"
+          "description" => metadata["description"] || "Debug session with #{actual_event_count} events"
         })
 
-        IO.puts("  Loaded session: #{inspect(session, pretty: true)}")
+        Logger.info("  Loaded session: #{inspect(session, pretty: true)}")
         session
 
       error -> 
-        IO.puts("  Error loading metadata: #{inspect(error)}")
+        Logger.error("  Error loading metadata: #{inspect(error)}")
         nil
     end
   end
 
   defp read_json_file(dir, filename) do
     path = Path.join(dir, filename)
-    IO.puts("Reading JSON file: #{path}")
+    Logger.info("Reading JSON file: #{path}")
 
     case File.read(path) do
       {:ok, content} -> 
         case Jason.decode(content) do
           {:ok, data} -> 
-            IO.puts("  Successfully decoded JSON")
+            Logger.info("  Successfully decoded JSON: #{inspect(String.slice(content, 0..100))}...")
             {:ok, data}
           error -> 
-            IO.puts("  Error decoding JSON: #{inspect(error)}")
+            Logger.error("  Error decoding JSON: #{inspect(error)}")
             error
         end
       {:error, reason} -> 
-        IO.puts("  Error reading file: #{inspect(reason)}")
+        Logger.error("  Error reading file: #{inspect(reason)}")
         {:error, :not_found}
     end
   end

test_apps/lib/phoenix_scope_player_web/live/playback_live.ex

@@ -1,12 +1,19 @@
 defmodule PhoenixScopePlayerWeb.PlaybackLive do
   use PhoenixScopePlayerWeb, :live_view
   alias PhoenixScopePlayer.DataProvider
+  require Logger
 
   def mount(%{"id" => session_id}, _session, socket) do
+    Logger.info("Mounting PlaybackLive with session_id: #{session_id}")
+    
     case DataProvider.get_session_data(session_id) do
       {:ok, session_data} ->
-        events = session_data.events
+        Logger.info("Got session data: #{inspect(session_data, pretty: true)}")
+        events = session_data["events"] || []
         current_event = List.first(events)
+        
+        Logger.info("Events count: #{length(events)}")
+        Logger.info("First event: #{inspect(current_event)}")
 
         {:ok, assign(socket,
           session_id: session_id,
@@ -20,6 +27,7 @@ defmodule PhoenixScopePlayerWeb.PlaybackLive do
         )}
 
       {:error, :not_found} ->
+        Logger.error("Session not found: #{session_id}")
         {:ok, socket
         |> put_flash(:error, "Session not found")
         |> redirect(to: ~p"/")}
@@ -28,9 +36,11 @@ defmodule PhoenixScopePlayerWeb.PlaybackLive do
 
   def handle_event("next_event", _, socket) do
     %{current_event_index: index, session_data: data} = socket.assigns
-    events = data.events
+    events = data["events"] || []
     next_index = min(index + 1, length(events) - 1)
 
+    Logger.info("Moving to next event: #{next_index} of #{length(events)}")
+    
     {:noreply, assign(socket,
       current_event_index: next_index,
       current_event: Enum.at(events, next_index)
@@ -39,9 +49,11 @@ defmodule PhoenixScopePlayerWeb.PlaybackLive do
 
   def handle_event("prev_event", _, socket) do
     %{current_event_index: index, session_data: data} = socket.assigns
-    events = data.events
+    events = data["events"] || []
     prev_index = max(index - 1, 0)
 
+    Logger.info("Moving to previous event: #{prev_index} of #{length(events)}")
+    
     {:noreply, assign(socket,
       current_event_index: prev_index,
       current_event: Enum.at(events, prev_index)
@@ -53,7 +65,9 @@ defmodule PhoenixScopePlayerWeb.PlaybackLive do
   end
 
   def handle_event("select_file", %{"file" => file}, socket) do
-    content = get_in(socket.assigns.session_data.source_code, [file, "content"])
+    Logger.info("Selecting file: #{file}")
+    content = get_in(socket.assigns.session_data, ["source_code", "files", file, "content"])
+    Logger.info("Got content: #{inspect(String.slice(content || "", 0..100))}...")
 
     {:noreply, assign(socket,
       current_file: file,
@@ -68,7 +82,7 @@ defmodule PhoenixScopePlayerWeb.PlaybackLive do
         <div class="sm:flex-auto">
           <h1 class="text-base font-semibold leading-6 text-gray-900">Session Playback</h1>
           <p class="mt-2 text-sm text-gray-700">
-            <%= @session_data.metadata["name"] %>
+            <%= @session_data["metadata"]["name"] %>
           </p>
         </div>
         <div class="mt-4 sm:ml-16 sm:mt-0">
@@ -117,7 +131,7 @@ defmodule PhoenixScopePlayerWeb.PlaybackLive do
               <h3 class="text-base font-semibold leading-6 text-gray-900">Source Code</h3>
               <div class="mt-2">
                 <div class="flex space-x-2 mb-2">
-                  <%= for {file, _} <- @session_data.source_code do %>
+                  <%= for {file, _} <- get_in(@session_data, ["source_code", "files"]) || %{} do %>
                     <button
                       type="button"
                       class={"px-2 py-1 text-sm rounded #{if @current_file == file, do: "bg-indigo-600 text-white", else: "bg-gray-100 text-gray-700 hover:bg-gray-200"}"}
@@ -146,28 +160,30 @@ defmodule PhoenixScopePlayerWeb.PlaybackLive do
                   </div>
                   <div class="mb-4">
                     <div class="font-medium text-gray-700">Function</div>
-                    <div class="text-sm text-gray-900"><%= get_in(@current_event, ["data", "module"]) %>.<%= get_in(@current_event, ["data", "function"]) %></div>
+                    <div class="text-sm text-gray-900"><%= @current_event["module"] %>.<%= @current_event["function"] %></div>
                   </div>
-                  <%= if get_in(@current_event, ["data", "args"]) do %>
+                  <%= if @current_event["args"] do %>
                     <div class="mb-4">
                       <div class="font-medium text-gray-700">Arguments</div>
-                      <div class="text-sm text-gray-900"><%= inspect(get_in(@current_event, ["data", "args"])) %></div>
+                      <div class="text-sm text-gray-900"><%= inspect(@current_event["args"]) %></div>
                     </div>
                   <% end %>
-                  <%= if get_in(@current_event, ["data", "return_value"]) do %>
+                  <%= if @current_event["return_value"] do %>
                     <div class="mb-4">
                       <div class="font-medium text-gray-700">Return Value</div>
-                      <div class="text-sm text-gray-900"><%= inspect(get_in(@current_event, ["data", "return_value"])) %></div>
+                      <div class="text-sm text-gray-900"><%= @current_event["return_value"] %></div>
+                    </div>
+                  <% end %>
+                  <%= if @current_event["pid"] do %>
+                    <div class="mb-4">
+                      <div class="font-medium text-gray-700">Process ID</div>
+                      <div class="text-sm text-gray-900"><%= @current_event["pid"] %></div>
                     </div>
                   <% end %>
-                  <%= if get_in(@current_event, ["data", "variables"]) do %>
+                  <%= if @current_event["timestamp"] do %>
                     <div class="mb-4">
-                      <div class="font-medium text-gray-700">Variables</div>
-                      <div class="text-sm text-gray-900">
-                        <%= for {var, value} <- get_in(@current_event, ["data", "variables"]) do %>
-                          <div><span class="font-mono"><%= var %></span>: <%= inspect(value) %></div>
-                        <% end %>
-                      </div>
+                      <div class="font-medium text-gray-700">Timestamp</div>
+                      <div class="text-sm text-gray-900"><%= @current_event["timestamp"] %></div>
                     </div>
                   <% end %>
                 <% else %>

test_apps/phoenix_scope_player/lib/mix/tasks/clean.sessions.ex

@@ -0,0 +1,54 @@
+defmodule Mix.Tasks.Clean.Sessions do
+  @moduledoc """
+  Mix task to clean out all debug sessions.
+
+  ## Examples
+
+      mix clean.sessions         # Cleans all sessions
+      mix clean.sessions --keep-sample  # Keeps sample_session_1
+  """
+  
+  use Mix.Task
+  require Logger
+
+  @impl Mix.Task
+  def run(args) do
+    keep_sample = "--keep-sample" in args
+    
+    captured_data_dir = Path.join([
+      :code.priv_dir(:phoenix_scope_player),
+      "captured_data"
+    ])
+
+    Logger.info("\n=== Cleaning debug sessions ===")
+    
+    # Ensure directory exists
+    File.mkdir_p!(captured_data_dir)
+    
+    case File.ls(captured_data_dir) do
+      {:ok, files} ->
+        files
+        |> Enum.filter(fn file ->
+          if keep_sample do
+            file != "sample_session_1"
+          else
+            true
+          end
+        end)
+        |> Enum.each(fn file ->
+          path = Path.join(captured_data_dir, file)
+          case File.rm_rf(path) do
+            {:ok, _} ->
+              Logger.info("✓ Removed #{file}")
+            {:error, posix, reason} ->
+              Logger.error("✗ Failed to remove #{file}: #{inspect(posix)} - #{inspect(reason)}")
+          end
+        end)
+        
+        Logger.info("\n=== Session cleanup complete ===")
+
+      {:error, reason} ->
+        Logger.error("Error listing sessions: #{inspect(reason)}")
+    end
+  end
+end