Refactor: unify trace data structures (#815)

Author: kraleppa

lib/live_debugger/api/traces_storage.ex

@@ -5,10 +5,9 @@ defmodule LiveDebugger.API.TracesStorage do
   """
 
   alias LiveDebugger.Structs.Trace
-  alias LiveDebugger.Structs.DiffTrace
   alias LiveDebugger.CommonTypes
 
-  @type trace() :: Trace.t() | DiffTrace.t()
+  import Trace, only: [is_trace: 1, is_trace_id: 1]
 
   @typedoc """
   Pid is used to store mapping to table references.
@@ -21,8 +20,8 @@ defmodule LiveDebugger.API.TracesStorage do
 
   @callback init() :: :ok
   @callback insert(Trace.t()) :: true
-  @callback insert!(table_ref :: reference(), trace()) :: true
-  @callback get_by_id!(table_identifier(), trace_id :: integer()) :: Trace.t() | nil
+  @callback insert!(table_ref :: reference(), Trace.t()) :: true
+  @callback get_by_id!(table_identifier(), trace_id :: Trace.id()) :: Trace.t() | nil
   @callback get!(table_identifier(), opts :: keyword()) ::
               {[Trace.t()], continuation()} | :end_of_table
   @callback clear!(table_identifier(), node_id :: pid() | CommonTypes.cid() | nil) :: true
@@ -33,7 +32,6 @@ defmodule LiveDebugger.API.TracesStorage do
   @callback table_size(table_identifier()) :: non_neg_integer()
 
   defguard is_table_identifier(id) when is_pid(id) or is_reference(id)
-  defguard is_trace(trace) when is_struct(trace, Trace) or is_struct(trace, DiffTrace)
 
   @doc """
   Initializes ets table.
@@ -45,9 +43,9 @@ defmodule LiveDebugger.API.TracesStorage do
   @doc """
   Inserts a new trace into the storage.
   It has worse performance then `insert/2` as it has to perform lookup for reference.
-  It stores the trace in table associated with `pid` given in `Trace` struct.
+  It stores the trace in table associated with `pid` given in trace struct.
   """
-  @spec insert(trace()) :: true
+  @spec insert(Trace.t()) :: true
   def insert(trace) when is_trace(trace) do
     impl().insert(trace)
   end
@@ -57,7 +55,7 @@ defmodule LiveDebugger.API.TracesStorage do
   It has better performance then `insert/1` as it does not perform lookup for reference.
   In order to use it properly you have to store the reference returned by `get_table/1`.
   """
-  @spec insert!(table_ref :: reference(), trace()) :: true
+  @spec insert!(table_ref :: reference(), Trace.t()) :: true
   def insert!(table_ref, trace) when is_reference(table_ref) and is_trace(trace) do
     impl().insert!(table_ref, trace)
   end
@@ -68,9 +66,9 @@ defmodule LiveDebugger.API.TracesStorage do
     * `table_id` - PID or reference to an existing table. Using reference increases performance as it skips lookup step.
     * `trace_id` - Id of a trace stored in a table.
   """
-  @spec get_by_id!(table_identifier(), trace_id :: integer()) :: trace() | nil
+  @spec get_by_id!(table_identifier(), trace_id :: Trace.id()) :: Trace.t() | nil
   def get_by_id!(table_id, trace_id)
-      when is_table_identifier(table_id) and is_integer(trace_id) do
+      when is_table_identifier(table_id) and is_trace_id(trace_id) do
     impl().get_by_id!(table_id, trace_id)
   end
 
@@ -90,7 +88,7 @@ defmodule LiveDebugger.API.TracesStorage do
     * `:trace_diffs` - Boolean flag to include DiffTrace structs in results
   """
   @spec get!(table_identifier(), opts :: keyword()) ::
-          {[trace()], continuation()} | :end_of_table
+          {[Trace.t()], continuation()} | :end_of_table
   def get!(table_id, opts \\ []) when is_table_identifier(table_id) and is_list(opts) do
     impl().get!(table_id, opts)
   end
@@ -168,7 +166,7 @@ defmodule LiveDebugger.API.TracesStorage do
     @traces_table_name :lvdbg_traces
     @processes_table_name :lvdbg_traces_processes
 
-    @type ets_elem() :: {integer(), TracesStorage.trace()}
+    @type ets_elem() :: {integer(), Trace.t()}
     @type continuation() :: TracesStorage.continuation()
     @type ets_table_id() :: TracesStorage.ets_table_id()
     @type table_identifier() :: TracesStorage.table_identifier()
@@ -348,10 +346,10 @@ defmodule LiveDebugger.API.TracesStorage do
 
     # Applies simple case-sensitive substring search on entire struct
     @spec filter_by_search(
-            {[TracesStorage.trace()], continuation() | :searched_without_limit} | :end_of_table,
+            {[Trace.t()], continuation() | :searched_without_limit} | :end_of_table,
             String.t()
           ) ::
-            {[TracesStorage.trace()], continuation() | :searched_without_limit} | :end_of_table
+            {[Trace.t()], continuation() | :searched_without_limit} | :end_of_table
     defp filter_by_search(:end_of_table, _phrase), do: :end_of_table
     defp filter_by_search({traces, cont}, ""), do: {traces, cont}
 
@@ -380,19 +378,19 @@ defmodule LiveDebugger.API.TracesStorage do
 
     # Formats the continuation token and handles end-of-table marker.
     @spec format_response(
-            {[TracesStorage.trace()], continuation() | :searched_without_limit}
+            {[Trace.t()], continuation() | :searched_without_limit}
             | :end_of_table
           ) ::
-            {[TracesStorage.trace()], continuation() | :searched_without_limit} | :end_of_table
+            {[Trace.t()], continuation() | :searched_without_limit} | :end_of_table
     defp format_response(:end_of_table), do: :end_of_table
     defp format_response({traces, :"$end_of_table"}), do: {traces, :end_of_table}
     defp format_response({traces, cont}), do: {traces, cont}
 
     @spec limit_response(
-            {[TracesStorage.trace()], :searched_without_limit} | :end_of_table,
+            {[Trace.t()], :searched_without_limit} | :end_of_table,
             limit :: pos_integer()
           ) ::
-            {[TracesStorage.trace()], continuation()} | :end_of_table
+            {[Trace.t()], continuation()} | :end_of_table
     defp limit_response(:end_of_table, _), do: :end_of_table
 
     defp limit_response({traces, :searched_without_limit}, limit) do
@@ -475,7 +473,7 @@ defmodule LiveDebugger.API.TracesStorage do
       [
         {{:_,
           %{
-            __struct__: LiveDebugger.Structs.Trace,
+            __struct__: LiveDebugger.Structs.Trace.FunctionTrace,
             function: :"$1",
             execution_time: :"$2",
             arity: :"$3",
@@ -489,7 +487,7 @@ defmodule LiveDebugger.API.TracesStorage do
       [
         {{:_,
           %{
-            __struct__: LiveDebugger.Structs.Trace,
+            __struct__: LiveDebugger.Structs.Trace.FunctionTrace,
             function: :"$1",
             execution_time: :"$2",
             arity: :"$3",
@@ -502,7 +500,7 @@ defmodule LiveDebugger.API.TracesStorage do
       [
         {{:_,
           %{
-            __struct__: LiveDebugger.Structs.Trace,
+            __struct__: LiveDebugger.Structs.Trace.FunctionTrace,
             function: :"$1",
             execution_time: :"$2",
             arity: :"$3"
@@ -513,7 +511,7 @@ defmodule LiveDebugger.API.TracesStorage do
     defp maybe_attach_diff_spec(trace_spec, true) do
       trace_spec ++
         [
-          {{:_, %{__struct__: LiveDebugger.Structs.DiffTrace}}, [], [:"$_"]}
+          {{:_, %{__struct__: LiveDebugger.Structs.Trace.DiffTrace}}, [], [:"$_"]}
         ]
     end
 

lib/live_debugger/app/debugger/callback_tracing/structs/trace_display.ex

@@ -8,7 +8,8 @@ defmodule LiveDebugger.App.Debugger.CallbackTracing.Structs.TraceDisplay do
   """
 
   alias LiveDebugger.Structs.Trace
-  alias LiveDebugger.Structs.DiffTrace
+  alias LiveDebugger.Structs.Trace.FunctionTrace
+  alias LiveDebugger.Structs.Trace.DiffTrace
   alias LiveDebugger.App.Utils.Parsers
   alias LiveDebugger.CommonTypes
 
@@ -43,7 +44,7 @@ defmodule LiveDebugger.App.Debugger.CallbackTracing.Structs.TraceDisplay do
           side_section_right: side_section_right()
         }
 
-  @spec from_trace(Trace.t() | DiffTrace.t(), boolean()) :: t()
+  @spec from_trace(Trace.t(), boolean()) :: t()
   def from_trace(trace, from_event? \\ false) do
     %__MODULE__{
       id: trace.id,
@@ -72,13 +73,13 @@ defmodule LiveDebugger.App.Debugger.CallbackTracing.Structs.TraceDisplay do
   end
 
   defp get_type(%{type: :exception_from}), do: :error
-  defp get_type(%LiveDebugger.Structs.DiffTrace{}), do: :diff
+  defp get_type(%DiffTrace{}), do: :diff
   defp get_type(_), do: :normal
 
-  defp get_title(%Trace{} = trace), do: Trace.callback_name(trace)
+  defp get_title(%FunctionTrace{} = trace), do: FunctionTrace.callback_name(trace)
   defp get_title(%DiffTrace{}), do: "Diff sent"
 
-  defp get_subtitle(%Trace{module: module, cid: cid}) do
+  defp get_subtitle(%FunctionTrace{module: module, cid: cid}) do
     module_string = Parsers.module_to_string(module)
     cid_string = if cid, do: " (#{cid})", else: ""
 
@@ -87,15 +88,15 @@ defmodule LiveDebugger.App.Debugger.CallbackTracing.Structs.TraceDisplay do
 
   defp get_subtitle(%DiffTrace{}), do: nil
 
-  defp get_subtitle_link_data(%Trace{pid: pid, cid: cid}) do
+  defp get_subtitle_link_data(%FunctionTrace{pid: pid, cid: cid}) do
     %{pid: pid, cid: cid}
   end
 
   defp get_subtitle_link_data(%DiffTrace{}), do: nil
 
-  defp get_body(%Trace{args: args} = trace) do
+  defp get_body(%FunctionTrace{args: args} = trace) do
     Enum.with_index(args, fn arg, index ->
-      {"Arg #{index} (#{Trace.arg_name(trace, index)})", arg}
+      {"Arg #{index} (#{FunctionTrace.arg_name(trace, index)})", arg}
     end)
   end
 
@@ -105,7 +106,7 @@ defmodule LiveDebugger.App.Debugger.CallbackTracing.Structs.TraceDisplay do
     {:timestamp, timestamp}
   end
 
-  defp get_side_section_right(%Trace{execution_time: execution_time}) do
+  defp get_side_section_right(%FunctionTrace{execution_time: execution_time}) do
     {:execution_time, execution_time}
   end
 

lib/live_debugger/app/debugger/callback_tracing/web/hooks/display_new_traces.ex

@@ -10,7 +10,7 @@ defmodule LiveDebugger.App.Debugger.CallbackTracing.Web.Hooks.DisplayNewTraces d
 
   use LiveDebugger.App.Web, :hook
 
-  alias LiveDebugger.Structs.Trace
+  alias LiveDebugger.Structs.Trace.FunctionTrace
   alias LiveDebugger.API.TracesStorage
   alias LiveDebugger.App.Debugger.CallbackTracing.Structs.TraceDisplay
   alias LiveDebugger.App.Debugger.CallbackTracing.Web.Helpers.Filters, as: FiltersHelpers
@@ -115,7 +115,7 @@ defmodule LiveDebugger.App.Debugger.CallbackTracing.Web.Hooks.DisplayNewTraces d
     )
   end
 
-  defp matches_execution_time_filter?(socket, %Trace{execution_time: execution_time}) do
+  defp matches_execution_time_filter?(socket, %FunctionTrace{execution_time: execution_time}) do
     execution_time_limits = FiltersHelpers.get_execution_times(socket.assigns.current_filters)
 
     min_time = Map.get(execution_time_limits, "exec_time_min", 0)

lib/live_debugger/services/callback_tracer/actions/diff_trace.ex

@@ -3,7 +3,7 @@ defmodule LiveDebugger.Services.CallbackTracer.Actions.DiffTrace do
   This module provides actions for LiveView diffs.
   """
 
-  alias LiveDebugger.Structs.DiffTrace
+  alias LiveDebugger.Structs.Trace.DiffTrace
   alias LiveDebugger.Bus
   alias LiveDebugger.Services.CallbackTracer.Events.DiffTraceCreated
   alias LiveDebugger.API.TracesStorage

…ervices/callback_tracer/actions/trace.ex …allback_tracer/actions/function_trace.exlib/live_debugger/services/callback_tracer/actions/trace.ex renamed to lib/live_debugger/services/callback_tracer/actions/function_trace.ex lib/live_debugger/services/callback_tracer/actions/trace.ex renamed to lib/live_debugger/services/callback_tracer/actions/function_trace.ex

@@ -1,9 +1,9 @@
-defmodule LiveDebugger.Services.CallbackTracer.Actions.Trace do
+defmodule LiveDebugger.Services.CallbackTracer.Actions.FunctionTrace do
   @moduledoc """
   This module provides actions for traces.
   """
 
-  alias LiveDebugger.Structs.Trace
+  alias LiveDebugger.Structs.Trace.FunctionTrace
   alias LiveDebugger.API.TracesStorage
   alias LiveDebugger.API.LiveViewDebug
   alias LiveDebugger.Utils.Modules, as: UtilsModules
@@ -20,9 +20,9 @@ defmodule LiveDebugger.Services.CallbackTracer.Actions.Trace do
           args :: list(),
           pid :: pid(),
           timestamp :: :erlang.timestamp()
-        ) :: {:ok, Trace.t()} | {:error, term()}
+        ) :: {:ok, FunctionTrace.t()} | {:error, term()}
   def create_trace(n, module, fun, args, pid, timestamp) do
-    trace = Trace.new(n, module, fun, args, pid, timestamp)
+    trace = FunctionTrace.new(n, module, fun, args, pid, timestamp)
 
     case trace.transport_pid do
       nil ->
@@ -39,7 +39,7 @@ defmodule LiveDebugger.Services.CallbackTracer.Actions.Trace do
           pid :: pid(),
           cid :: String.t(),
           timestamp :: :erlang.timestamp()
-        ) :: {:ok, Trace.t()} | :live_debugger_trace | {:error, term()}
+        ) :: {:ok, FunctionTrace.t()} | :live_debugger_trace | {:error, term()}
   def create_delete_component_trace(n, args, pid, cid, timestamp) do
     pid
     |> LiveViewDebug.socket()
@@ -49,7 +49,7 @@ defmodule LiveDebugger.Services.CallbackTracer.Actions.Trace do
           :live_debugger_trace
         else
           trace =
-            Trace.new(
+            FunctionTrace.new(
               n,
               Phoenix.LiveView.Diff,
               :delete_component,
@@ -69,13 +69,13 @@ defmodule LiveDebugger.Services.CallbackTracer.Actions.Trace do
     end
   end
 
-  @spec update_trace(Trace.t(), map()) :: {:ok, Trace.t()}
-  def update_trace(%Trace{} = trace, params) do
+  @spec update_trace(FunctionTrace.t(), map()) :: {:ok, FunctionTrace.t()}
+  def update_trace(%FunctionTrace{} = trace, params) do
     {:ok, Map.merge(trace, params)}
   end
 
-  @spec persist_trace(Trace.t()) :: {:ok, reference()} | {:error, term()}
-  def persist_trace(%Trace{pid: pid} = trace) do
+  @spec persist_trace(FunctionTrace.t()) :: {:ok, reference()} | {:error, term()}
+  def persist_trace(%FunctionTrace{pid: pid} = trace) do
     with ref when is_reference(ref) <- TracesStorage.get_table(pid),
          true <- TracesStorage.insert!(ref, trace) do
       {:ok, ref}
@@ -85,15 +85,15 @@ defmodule LiveDebugger.Services.CallbackTracer.Actions.Trace do
     end
   end
 
-  @spec persist_trace(Trace.t(), reference()) :: {:ok, reference()}
-  def persist_trace(%Trace{} = trace, ref) do
+  @spec persist_trace(FunctionTrace.t(), reference()) :: {:ok, reference()}
+  def persist_trace(%FunctionTrace{} = trace, ref) do
     TracesStorage.insert!(ref, trace)
 
     {:ok, ref}
   end
 
-  @spec publish_trace(Trace.t(), reference() | nil) :: :ok | {:error, term()}
-  def publish_trace(%Trace{pid: pid} = trace, ref \\ nil) do
+  @spec publish_trace(FunctionTrace.t(), reference() | nil) :: :ok | {:error, term()}
+  def publish_trace(%FunctionTrace{pid: pid} = trace, ref \\ nil) do
     trace
     |> get_event(ref)
     |> Bus.broadcast_trace!(pid)
@@ -102,7 +102,7 @@ defmodule LiveDebugger.Services.CallbackTracer.Actions.Trace do
       {:error, err}
   end
 
-  defp get_event(%Trace{type: :call} = trace, ref) do
+  defp get_event(%FunctionTrace{type: :call} = trace, ref) do
     %TraceCalled{
       trace_id: trace.id,
       ets_ref: ref,
@@ -115,7 +115,7 @@ defmodule LiveDebugger.Services.CallbackTracer.Actions.Trace do
     }
   end
 
-  defp get_event(%Trace{type: :return_from} = trace, ref) do
+  defp get_event(%FunctionTrace{type: :return_from} = trace, ref) do
     %TraceReturned{
       trace_id: trace.id,
       ets_ref: ref,
@@ -128,7 +128,7 @@ defmodule LiveDebugger.Services.CallbackTracer.Actions.Trace do
     }
   end
 
-  defp get_event(%Trace{type: :exception_from} = trace, ref) do
+  defp get_event(%FunctionTrace{type: :exception_from} = trace, ref) do
     %TraceErrored{
       trace_id: trace.id,
       ets_ref: ref,

lib/live_debugger/services/callback_tracer/actions/state.ex

@@ -5,7 +5,7 @@ defmodule LiveDebugger.Services.CallbackTracer.Actions.State do
 
   alias LiveDebugger.API.StatesStorage
   alias LiveDebugger.API.LiveViewDebug
-  alias LiveDebugger.Structs.Trace
+  alias LiveDebugger.Structs.Trace.FunctionTrace
   alias LiveDebugger.Structs.LvState
 
   alias LiveDebugger.Bus
@@ -14,17 +14,22 @@ defmodule LiveDebugger.Services.CallbackTracer.Actions.State do
   @doc """
   It checks if the trace is state changing and if so, it saves the state.
   """
-  @spec maybe_save_state!(Trace.t()) :: :ok
-  def maybe_save_state!(%Trace{pid: pid, function: :render, type: :return_from}) do
+  @spec maybe_save_state!(FunctionTrace.t()) :: :ok
+  def maybe_save_state!(%FunctionTrace{pid: pid, function: :render, type: :return_from}) do
     do_save_state!(pid)
   end
 
-  def maybe_save_state!(%Trace{pid: pid, function: function, type: type, args: [_, _, socket]})
+  def maybe_save_state!(%FunctionTrace{
+        pid: pid,
+        function: function,
+        type: type,
+        args: [_, _, socket]
+      })
       when function in [:mount, :handle_params] and type in [:return_from, :exception_from] do
     do_save_initial_state!(pid, socket)
   end
 
-  def maybe_save_state!(%Trace{pid: pid, function: :delete_component, type: :call}) do
+  def maybe_save_state!(%FunctionTrace{pid: pid, function: :delete_component, type: :call}) do
     do_save_state!(pid)
   end