Adding Graph with telemetry

Author: thiagoesteves

lib/observer_web/apps/port.ex

@@ -5,6 +5,15 @@ defmodule ObserverWeb.Apps.Port do
 
   alias ObserverWeb.Rpc
 
+  @type t :: %{
+          name: charlist() | String.t(),
+          id: non_neg_integer(),
+          connected: pid(),
+          os_pid: non_neg_integer() | :undefined
+        }
+
+  defstruct [:name, :id, :connected, :os_pid]
+
   @doc """
   Return port information
 
@@ -16,14 +25,13 @@ defmodule ObserverWeb.Apps.Port do
     ...> assert :undefined = Port.info(nil)
     ...> assert :undefined = Port.info("")
   """
-  @spec info(atom(), port()) ::
-          :undefined | %{connected: any(), id: any(), name: any(), os_pid: any()}
+  @spec info(atom(), port()) :: :undefined | __MODULE__.t()
   def info(node \\ Node.self(), port)
 
   def info(node, port) when is_port(port) do
     case Rpc.call(node, :erlang, :port_info, [port], :infinity) do
       data when is_list(data) ->
-        %{
+        %__MODULE__{
           name: Keyword.get(data, :name, 0),
           id: Keyword.get(data, :id, 0),
           connected: Keyword.get(data, :connected, 0),

lib/observer_web/apps/process.ex

@@ -11,6 +11,54 @@ defmodule ObserverWeb.Apps.Process do
 
   @default_get_state_timeout 100
 
+  @type t :: %{
+          pid: pid(),
+          registered_name: atom() | nil,
+          priority: :low | :normal | :high | :max,
+          trap_exit: boolean(),
+          message_queue_len: non_neg_integer(),
+          error_handler: module() | :none,
+          relations: %{
+            group_leader: pid() | nil,
+            ancestors: [pid()],
+            links: [pid()] | nil,
+            monitored_by: [pid()] | nil,
+            monitors: [pid() | {module(), term()}] | nil
+          },
+          memory: %{
+            total: non_neg_integer(),
+            stack_and_heap: non_neg_integer(),
+            heap_size: non_neg_integer(),
+            stack_size: non_neg_integer(),
+            gc_min_heap_size: non_neg_integer(),
+            gc_full_sweep_after: non_neg_integer()
+          },
+          meta: %{
+            init: String.t(),
+            current: String.t(),
+            status: :running | :waiting | :exiting | :garbage_collecting | :suspended | :runnable,
+            class: :supervisor | :application | :unknown | atom()
+          },
+          state: String.t(),
+          dictionary: keyword() | nil,
+          phx_lv_socket: Phoenix.LiveView.Socket.t() | nil
+        }
+
+  defstruct [
+    :pid,
+    :registered_name,
+    :priority,
+    :trap_exit,
+    :message_queue_len,
+    :error_handler,
+    :relations,
+    :memory,
+    :meta,
+    :state,
+    :dictionary,
+    :phx_lv_socket
+  ]
+
   @process_full [
     :registered_name,
     :priority,
@@ -36,7 +84,7 @@ defmodule ObserverWeb.Apps.Process do
   @doc """
   Creates a complete overview of process stats based on the given `pid`.
   """
-  @spec info(pid :: pid(), timeout :: non_neg_integer()) :: :undefined | map
+  @spec info(pid :: pid(), timeout :: non_neg_integer()) :: :undefined | __MODULE__.t()
   def info(pid, timeout \\ @default_get_state_timeout) do
     process_info(pid, @process_full, &structure_full/3, timeout)
   end
@@ -119,7 +167,7 @@ defmodule ObserverWeb.Apps.Process do
         end
       end
 
-    %{
+    %__MODULE__{
       pid: pid,
       registered_name: Keyword.get(data, :registered_name, nil),
       priority: Keyword.get(data, :priority, :normal),

lib/observer_web/monitor.ex

@@ -12,7 +12,7 @@ defmodule ObserverWeb.Monitor do
   @doc """
   Starts monitoring a process's memory usage
   """
-  @spec start_process_monitor(pid :: pid()) :: :ok
+  @spec start_process_monitor(pid :: pid()) :: {:ok, ObserverWeb.Monitor.Process.t()}
   def start_process_monitor(pid), do: Process.start_process_monitor(pid)
 
   @doc """
@@ -24,8 +24,9 @@ defmodule ObserverWeb.Monitor do
   @doc """
   Checks if memory monitoring is enabled for a process
   """
-  @spec process_enabled?(pid :: pid()) :: boolean()
-  def process_enabled?(pid), do: Process.enabled?(pid)
+  @spec process_info(pid :: pid()) ::
+          {:ok, ObserverWeb.Monitor.Process.t()} | {:error, :not_found | :rescued}
+  def process_info(pid), do: Process.process_info(pid)
 
   ### ==========================================================================
   ### Private functions

lib/observer_web/monitor/process.ex

@@ -41,18 +41,17 @@ defmodule ObserverWeb.Monitor.Process do
   end
 
   @impl true
-  def handle_call({:enabled?, pid}, _from, monitored_processes) do
+  def handle_call({:process_info, pid}, _from, monitored_processes) do
     case monitored_processes[pid] do
       nil ->
-        {:reply, false, monitored_processes}
+        {:reply, {:error, :not_found}, monitored_processes}
 
-      _atomized_pid ->
-        {:reply, true, monitored_processes}
+      process ->
+        {:reply, {:ok, process}, monitored_processes}
     end
   end
 
-  @impl true
-  def handle_cast({:attach_process_pid, pid}, monitored_processes) do
+  def handle_call({:attach_process_pid, pid}, _from, monitored_processes) do
     case monitored_processes[pid] do
       nil ->
         process = pid_to_struct(pid)
@@ -64,18 +63,18 @@ defmodule ObserverWeb.Monitor.Process do
           {[process.metric_summary], nil, Node.self()}
         )
 
-        {:noreply, Map.put(monitored_processes, pid, process)}
+        {:reply, {:ok, process}, Map.put(monitored_processes, pid, process)}
 
-      _atomized_pid ->
+      process ->
         # Already in the list of monitored processes
-        {:noreply, monitored_processes}
+        {:reply, {:ok, process}, monitored_processes}
     end
   end
 
-  def handle_cast({:detach_process_pid, pid}, monitored_processes) do
+  def handle_call({:detach_process_pid, pid}, _from, monitored_processes) do
     case monitored_processes[pid] do
       nil ->
-        {:noreply, monitored_processes}
+        {:reply, :ok, monitored_processes}
 
       process ->
         # Add a gap in the chart to indicate that data sending was disabled
@@ -88,7 +87,7 @@ defmodule ObserverWeb.Monitor.Process do
         # Detach the telemetry handler
         :telemetry.detach({__MODULE__, process.event, self()})
 
-        {:noreply, Map.drop(monitored_processes, [pid])}
+        {:reply, :ok, Map.drop(monitored_processes, [pid])}
     end
   end
 
@@ -121,22 +120,34 @@ defmodule ObserverWeb.Monitor.Process do
   ### Public APIs
   ### ==========================================================================
 
-  @spec start_process_monitor(pid :: pid()) :: :ok
+  @spec start_process_monitor(pid :: pid()) :: {:ok, __MODULE__.t()}
   def start_process_monitor(pid) do
     target_node = node(pid)
-    GenServer.cast({__MODULE__, target_node}, {:attach_process_pid, pid})
+    GenServer.call({__MODULE__, target_node}, {:attach_process_pid, pid})
   end
 
   @spec stop_process_monitor(pid :: pid()) :: :ok
   def stop_process_monitor(pid) do
     target_node = node(pid)
-    GenServer.cast({__MODULE__, target_node}, {:detach_process_pid, pid})
+
+    try do
+      GenServer.call({__MODULE__, target_node}, {:detach_process_pid, pid})
+    catch
+      _, _ ->
+        :ok
+    end
   end
 
-  @spec enabled?(pid :: pid()) :: boolean()
-  def enabled?(pid) do
+  @spec process_info(pid :: pid()) :: {:ok, map} | {:error, :not_found | :rescued}
+  def process_info(pid) do
     target_node = node(pid)
-    GenServer.call({__MODULE__, target_node}, {:enabled?, pid})
+
+    try do
+      GenServer.call({__MODULE__, target_node}, {:process_info, pid})
+    catch
+      _, _ ->
+        {:error, :rescued}
+    end
   end
 
   ### ==========================================================================

lib/web/pages/apps/identifier.ex

@@ -0,0 +1,24 @@
+defmodule Observer.Web.Apps.Identifier do
+  @moduledoc """
+  This module provides Identifier Structure
+  """
+
+  # NOTE: Debouncing for reading the selected process
+  @tooltip_debouncing 50
+
+  @type t :: %__MODULE__{
+          info: ObserverWeb.Apps.Process.t() | ObserverWeb.Apps.Port.t() | nil,
+          id_string: String.t() | nil,
+          type: nil,
+          debouncing: non_neg_integer(),
+          node: atom() | nil,
+          metric: String.t() | nil
+        }
+
+  defstruct info: nil,
+            id_string: nil,
+            type: nil,
+            debouncing: @tooltip_debouncing,
+            node: nil,
+            metric: nil
+end