Filtered process list

lib/phoenix/live_dashboard/components/table_component.ex

@@ -10,7 +10,8 @@ defmodule Phoenix.LiveDashboard.TableComponent do
           sort_by: :atom,
           sort_dir: :desc | :asc,
           search: binary(),
-          hint: binary() | nil
+          hint: binary() | nil,
+          filter: binary() | nil
         }
 
   @impl true
@@ -30,6 +31,7 @@ defmodule Phoenix.LiveDashboard.TableComponent do
     |> validate_required_one_sortable_column()
     |> Map.put_new(:search, true)
     |> Map.put_new(:limit, @limit)
+    |> Map.put_new(:filter, nil)
     |> Map.put_new(:row_attrs, [])
     |> Map.put_new(:hint, nil)
     |> Map.put_new(:dom_id, nil)
@@ -91,14 +93,23 @@ defmodule Phoenix.LiveDashboard.TableComponent do
   defp fetch_rows(row_fetcher, table_params, page_node, socket)
        when is_function(row_fetcher, 2) do
     {rows, total} = row_fetcher.(table_params, page_node)
-    {rows, total, socket}
+    {rows, total, assign(socket, :active_filter, nil)}
   end
 
   defp fetch_rows({row_fetcher, initial_state}, table_params, page_node, socket)
        when is_function(row_fetcher, 3) do
     state = Map.get(socket.assigns, :row_fetcher_state, initial_state)
-    {rows, total, state} = row_fetcher.(table_params, page_node, state)
-    {rows, total, assign(socket, :row_fetcher_state, state)}
+
+    {active_filter, available_filters, rows, total, state} =
+      with {rows, total, state} <- row_fetcher.(table_params, page_node, state) do
+        {nil, nil, rows, total, state}
+      end
+
+    {rows, total,
+     socket
+     |> assign(:row_fetcher_state, state)
+     |> assign(:filter_list, available_filters)
+     |> assign(:active_filter, active_filter)}
   end
 
   defp normalize_table_params(assigns) do
@@ -125,7 +136,15 @@ defmodule Phoenix.LiveDashboard.TableComponent do
     search = all_params["search"]
     search = if search == "", do: nil, else: search
 
-    table_params = %{sort_by: sort_by, sort_dir: sort_dir, limit: limit, search: search}
+    filter = all_params["filter"]
+
+    table_params = %{
+      sort_by: sort_by,
+      sort_dir: sort_dir,
+      limit: limit,
+      search: search,
+      filter: filter
+    }
 
     assigns
     |> Map.put(:table_params, table_params)
@@ -186,6 +205,19 @@ defmodule Phoenix.LiveDashboard.TableComponent do
         </div>
       </form>
 
+      <form :if={@active_filter} phx-change="select_filter" phx-target={@myself} class="form-inline">
+          <div class="form-row align-items-center">
+              <div class="col-auto">Filter</div>
+              <div class="col-auto">
+                <div class="input-group input-group-sm">
+                  <select name="filter" class="custom-select" id="filter-select">
+                    <%= options_for_select(@filter_list, @active_filter) %>
+                  </select>
+                </div>
+              </div>
+          </div>
+        </form>
+
       <div class="card tabular-card mb-4 mt-4">
         <div class="card-body p-0">
           <div class="dash-table-wrapper">
@@ -249,6 +281,12 @@ defmodule Phoenix.LiveDashboard.TableComponent do
     {:noreply, push_patch(socket, to: to)}
   end
 
+  def handle_event("select_filter", %{"filter" => filter}, socket) do
+    table_params = %{socket.assigns.table_params | filter: filter}
+    to = PageBuilder.live_dashboard_path(socket, socket.assigns.page, table_params)
+    {:noreply, push_patch(socket, to: to)}
+  end
+
   defp sort_link(assigns) do
     if assigns.table_params.sort_by == assigns.column.field do
       ~H"""

lib/phoenix/live_dashboard/page_builder.ex

@@ -96,7 +96,7 @@ defmodule Phoenix.LiveDashboard.PageBuilder do
 
   We currently support `card/1`, `fields_card/1`, `row/1`,
   `shared_usage_card/1`, and `usage_card/1`;
-  and the live components `live_layered_graph/1`, `live_nav_bar/1`, 
+  and the live components `live_layered_graph/1`, `live_nav_bar/1`,
   and `live_table/1`.
 
   ## Helpers
@@ -256,6 +256,11 @@ defmodule Phoenix.LiveDashboard.PageBuilder do
     In this case, the function will receive the state as third argument and must return
     a tuple with the rows, the total number, and the new state for the following call:
     `{(params(), node(), term() -> {list(), integer() | binary(), term()}), term()}`
+    Optionally for latter case: if the page decides to implement custom page filter
+    (please see `Phoenix.LiveDashboard.PageFilter` for details), the function must return
+    a tuple with the active filter, list of available filters, the rows, the total number,
+    and the new state for the following call:
+    `(params(), node(), term() -> {binary() | nil, list() | nil, list(), integer() | binary(), term()})`
     """
 
   attr :rows_name, :string,
@@ -287,6 +292,8 @@ defmodule Phoenix.LiveDashboard.PageBuilder do
 
   attr :hint, :string, default: nil, doc: "A textual hint to show close to the title."
   attr :dom_id, :string, default: nil, doc: "id attribute for the HTML the main tag."
+  attr :filter, :string, default: nil, doc: "To filter table rows"
+
   @spec live_table(assigns :: Socket.assigns()) :: Phoenix.LiveView.Rendered.t()
   def live_table(assigns) do
     ~H"""

lib/phoenix/live_dashboard/page_filter.ex

@@ -0,0 +1,73 @@
+defmodule Phoenix.LiveDashboard.PageFilter do
+  @moduledoc """
+  Page filter allows to customize the list of items for table components.
+  This could be useful for cases where there are too many items and/or
+  the customized list of items is desired.
+  For instance, you may have millions of processes per node. Then, using the standard Processes page
+  may present a performance problem. Besides, you may want to look at the application-specific groups of processes,
+  rather then going through the whole list.
+
+  Example of custom page filter implementation:
+
+  defmodule ProcessFilter.Demo do
+  @behaviour Phoenix.LiveDashboard.PageFilter
+
+  @impl true
+  def list() do
+    ["All", "Registered", "Phoenix"]
+  end
+
+  @impl true
+  def default_filter() do
+    "Phoenix"
+  end
+
+  @impl true
+  def filter("Registered") do
+    Process.registered() |> Enum.map(fn name -> Process.whereis(name) end)
+  end
+
+  def filter("All") do
+    Process.list()
+  end
+
+  def filter("Phoenix") do
+    Process.registered() |> Enum.flat_map(fn name -> String.contains?(to_string(name), "Phoenix") &&
+      [Process.whereis(name)]  || []
+  end)
+  end
+  end
+
+
+   To enable the filter for Processes page, add this to your config.exs:
+
+   config :phoenix_live_dashboard, :process_filter, ProcessFilter.Demo
+
+  What will happen:
+
+  - The Processes page will have Filter dropdown defined in list() function;
+  - The groups of processes will be displayed according to selected filter
+
+  """
+
+  @callback list() :: [String.t()]
+
+  @callback filter(filter_name :: String.t()) :: [any()]
+
+  @callback default_filter() :: String.t()
+
+  defmacro __using__(_) do
+    quote do
+      @behaviour Phoenix.LiveDashboard.PageFilter
+      def default_filter() do
+        case list() do
+          nil -> nil
+          [] -> nil
+          [first | _rest] -> first
+        end
+      end
+
+      defoverridable default_filter: 0
+    end
+  end
+end

lib/phoenix/live_dashboard/pages/processes_page.ex

@@ -35,12 +35,8 @@ defmodule Phoenix.LiveDashboard.ProcessesPage do
   end
 
   defp fetch_processes(params, node, state) do
-    %{search: search, sort_by: sort_by, sort_dir: sort_dir, limit: limit} = params
-
-    {processes, count, state} =
-      SystemInfo.fetch_processes(node, search, sort_by, sort_dir, limit, state)
-
-    {processes, count, state}
+    %{search: search, sort_by: sort_by, sort_dir: sort_dir, limit: limit, filter: filter} = params
+    SystemInfo.fetch_processes(node, filter, search, sort_by, sort_dir, limit, state)
   end
 
   defp row_attrs(process) do

lib/phoenix/live_dashboard/system_info.ex

@@ -44,10 +44,19 @@ defmodule Phoenix.LiveDashboard.SystemInfo do
 
   ## Fetchers
 
-  def fetch_processes(node, search, sort_by, sort_dir, limit, prev_reductions \\ nil) do
+  def fetch_processes(
+        node,
+        filter,
+        search,
+        sort_by,
+        sort_dir,
+        limit,
+        prev_reductions \\ nil
+      ) do
     search = search && String.downcase(search)
 
     :rpc.call(node, __MODULE__, :processes_callback, [
+      filter,
       search,
       sort_by,
       sort_dir,
@@ -205,11 +214,12 @@ defmodule Phoenix.LiveDashboard.SystemInfo do
   ]
 
   @doc false
-  def processes_callback(search, sort_by, sort_dir, limit, prev_reductions) do
+  def processes_callback(filter, search, sort_by, sort_dir, limit, prev_reductions) do
     multiplier = sort_dir_multipler(sort_dir)
+    {active_filter, available_filters, process_list} = get_process_filter_data(filter)
 
     processes =
-      for pid <- Process.list(),
+      for pid <- process_list,
           info = process_info(pid, prev_reductions[pid]),
           show_process?(info, search) do
         sorter = info[sort_by] * multiplier
@@ -218,10 +228,23 @@ defmodule Phoenix.LiveDashboard.SystemInfo do
 
     next_state = for {_sorter, info} <- processes, into: %{}, do: {info[:pid], info[:reductions]}
 
-    count = if search, do: length(processes), else: :erlang.system_info(:process_count)
+    count = length(processes)
     processes = processes |> Enum.sort() |> Enum.take(limit) |> Enum.map(&elem(&1, 1))
 
-    {processes, count, next_state}
+    {active_filter, available_filters, processes, count, next_state}
+  end
+
+  def get_process_filter_data(filter) do
+    case Application.get_env(:phoenix_live_dashboard, :process_filter) do
+      nil ->
+        {nil, nil, Process.list()}
+
+      filter_mod ->
+        available_filters = filter_mod.list()
+        active_filter = (filter in available_filters && filter) || filter_mod.default_filter()
+        process_list = filter_mod.filter(active_filter)
+        {active_filter, available_filters, process_list}
+    end
   end
 
   defp process_info(pid, prev_reductions) do
@@ -722,6 +745,10 @@ defmodule Phoenix.LiveDashboard.SystemInfo do
   defp pid_or_port_details(port) when is_port(port), do: to_port_details(port)
   defp pid_or_port_details(reference) when is_reference(reference), do: reference
 
+  def to_process_details(detail_map) when is_map(detail_map) do
+    struct(ProcessDetails, detail_map)
+  end
+
   def to_process_details(pid) when is_pid(pid) and node(pid) == node() do
     {name, initial_call} =
       case Process.info(pid, [:initial_call, :dictionary, :registered_name]) do

test/phoenix/live_dashboard/pages/applications_page_test.exs

@@ -75,6 +75,6 @@ defmodule Phoenix.LiveDashboard.ApplicationsPageTest do
 
   defp applications_path(limit, search, sort_by, sort_dir) do
     "/dashboard/applications?" <>
-      "limit=#{limit}&search=#{search}&sort_by=#{sort_by}&sort_dir=#{sort_dir}"
+      "filter=&limit=#{limit}&search=#{search}&sort_by=#{sort_by}&sort_dir=#{sort_dir}"
   end
 end

test/phoenix/live_dashboard/pages/ets_page_test.exs

@@ -93,6 +93,6 @@ defmodule Phoenix.LiveDashboard.EtsPageTest do
 
   defp ets_path(limit, search, sort_by, sort_dir) do
     "/dashboard/ets?" <>
-      "limit=#{limit}&search=#{search}&sort_by=#{sort_by}&sort_dir=#{sort_dir}"
+      "filter=&limit=#{limit}&search=#{search}&sort_by=#{sort_by}&sort_dir=#{sort_dir}"
   end
 end

test/phoenix/live_dashboard/pages/ports_page_test.exs

@@ -98,6 +98,6 @@ defmodule Phoenix.LiveDashboard.PortsPageTest do
 
   defp ports_path(limit, search, sort_by, sort_dir) do
     "/dashboard/ports?" <>
-      "limit=#{limit}&search=#{search}&sort_by=#{sort_by}&sort_dir=#{sort_dir}"
+      "filter=&limit=#{limit}&search=#{search}&sort_by=#{sort_by}&sort_dir=#{sort_dir}"
   end
 end

test/phoenix/live_dashboard/pages/processes_live_test.exs

@@ -149,6 +149,6 @@ defmodule Phoenix.LiveDashboard.ProcessesLiveTest do
 
   defp processes_path(prefix \\ "dashboard", limit, search, sort_by, sort_dir) do
     "/#{prefix}/processes?" <>
-      "limit=#{limit}&search=#{search}&sort_by=#{sort_by}&sort_dir=#{sort_dir}"
+      "filter=&limit=#{limit}&search=#{search}&sort_by=#{sort_by}&sort_dir=#{sort_dir}"
   end
 end

test/phoenix/live_dashboard/pages/sockets_page_test.exs

@@ -98,7 +98,7 @@ defmodule Phoenix.LiveDashboard.SocketsPageTest do
 
   defp sockets_path(limit, search, sort_by, sort_dir) do
     "/dashboard/sockets?" <>
-      "limit=#{limit}&search=#{search}&sort_by=#{sort_by}&sort_dir=#{sort_dir}"
+      "filter=&limit=#{limit}&search=#{search}&sort_by=#{sort_by}&sort_dir=#{sort_dir}"
   end
 
   defp open_socket() do