use PhoenixProfiler on the Endpoint

CHANGELOG.md

@@ -6,6 +6,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+* Ensure dashboard profiles list respects the selected limit
+
+### Changed
+
+#### `use PhoenixProfiler` on your Endpoint
+
+PhoenixProfiler needs to wrap the whole Plug pipeline to get
+a complete picture of each request. Make the following changes
+in your Endpoint module(s):
+
+1. Add `use PhoenixProfiler` directly after `use Phoenix.Endpoint`:
+
+```diff
+defmodule MyAppWeb.Endpoint do
+  use Phoenix.Endpoint, otp_app: :my_app
++ use PhoenixProfiler
+```
+
+2. Remove the plug from the `code_reloading?` block:
+
+```diff
+if code_reloading? do
+-  plug PhoenixProfiler
+end
+```
+
 ## [0.2.0] - 2022-09-28
 
 ### Added

README.md

@@ -24,10 +24,10 @@ Provides a **development tool** that gives detailed information about the execut
 To start using the profiler, you will need the following steps:
 
 1. Add the `phoenix_profiler` dependency
-2. Define a profiler on your supervision tree
-3. Enable the profiler on your Endpoint
+2. Define a profiler server on your supervision tree
+3. Enable your profiler on your Endpoint config
 4. Configure LiveView
-5. Add the `PhoenixProfiler` plug
+5. Use `PhoenixProfiler` on your Endpoint module
 6. Mount the profiler on your LiveViews
 7. Add the profiler page on your LiveDashboard (optional)
 
@@ -39,10 +39,10 @@ Add phoenix_profiler to your `mix.exs`:
 {:phoenix_profiler, "~> 0.2.0"}
 ```
 
-### 2. Define a profiler on your supervision tree
+### 2. Define a profiler server on your supervision tree
 
-You define a profiler on your main application's telemetry supervision
-tree (usually in `lib/my_app_web/telemetry.ex`):
+You define a profiler on your telemetry supervision tree
+(usually in `lib/my_app_web/telemetry.ex`):
 
 ```elixir
     children = [
@@ -61,7 +61,7 @@ The following options are available:
 * `:request_sweep_interval` - How often to sweep the ETS table where
   the profiles are stored. Default is `24h` in milliseconds.
 
-### 3. Enable the profiler on your Endpoint
+### 3. Enable your profiler on your Endpoint config
 
 PhoenixProfiler is disabled by default. In order to enable it,
 you must update your endpoint's `:dev` configuration to include the
@@ -104,24 +104,26 @@ config :my_app, MyAppWeb.Endpoint,
   live_view: [signing_salt: "SECRET_SALT"]
 ```
 
-### 5. Add the PhoenixProfiler plug
+### 5. Use PhoenixProfiler
 
-Add the `PhoenixProfiler` plug within the `code_reloading?`
-block on your Endpoint (usually in `lib/my_app_web/endpoint.ex`):
+Add `use PhoenixProfiler` on your Endpoint module
+(usually in `lib/my_app_web/endpoint.ex`):
 
 ```elixir
-  if code_reloading? do
+  defmodule MyAppWeb.Endpoint do
+    use Phoenix.Endpoint, otp_app: :my_app
+    use PhoenixProfiler
+
     # plugs...
-    plug PhoenixProfiler
   end
 ```
 
-### 6. Mount the profiler on your LiveViews
+### 6. Mount PhoenixProfiler on your LiveViews
 
 Note this section is required only if you are using LiveView, otherwise you may skip it.
 
-Add the profiler hook to the `live_view` function on your
-web module (usually in `lib/my_app_web.ex`):
+Add PhoenixProfiler to the `live_view` function on your web
+module (usually in `lib/my_app_web.ex`):
 
 ```elixir
   def live_view do

dev.exs

@@ -224,8 +224,8 @@ defmodule DemoWeb.AppLive.Index do
 
   defp apply_profiler_toggle(socket) do
     if connected?(socket) do
-      profile = socket.private.phoenix_profiler
-      next = if profile.info == :enable, do: :disable, else: :enable
+      info = socket.private.phoenix_profiler.info
+      next = if info == :enable, do: :disable, else: :enable
       assign(socket, :toggle_text, String.capitalize(to_string(next)) <> " Profiler")
     else
       assign(socket, :toggle_text, nil)
@@ -269,8 +269,8 @@ defmodule DemoWeb.AppLive.Index do
   end
 
   def handle_event("toggle-profiler", _, socket) do
-    profile = socket.private.phoenix_profiler
-    next = if profile.info == :enable, do: :disable, else: :enable
+    info = socket.private.phoenix_profiler.info
+    next = if info == :enable, do: :disable, else: :enable
     socket = apply(PhoenixProfiler, next, [socket])
 
     {:noreply, apply_profiler_toggle(socket)}
@@ -335,8 +335,7 @@ end
 
 defmodule DemoWeb.Endpoint do
   use Phoenix.Endpoint, otp_app: :phoenix_profiler
-
-  plug PhoenixProfiler
+  use PhoenixProfiler
 
   @session_options [
     store: :cookie,

lib/phoenix_profiler.ex

@@ -5,25 +5,32 @@ defmodule PhoenixProfiler do
              |> String.split("<!-- MDOC -->")
              |> Enum.fetch!(1)
 
+  defmacro __using__(_) do
+    quote do
+      unquote(plug())
+
+      @before_compile PhoenixProfiler.Endpoint
+    end
+  end
+
+  defp plug do
+    # todo: ensure we are within a Phoenix.Endpoint
+    quote location: :keep do
+      plug PhoenixProfiler.Plug
+    end
+  end
+
   @doc """
   Returns the child specification to start the profiler
   under a supervision tree.
   """
   def child_spec(opts) do
     %{
       id: opts[:name] || PhoenixProfiler,
-      start: {PhoenixProfiler.Supervisor, :start_link, [opts]}
+      start: {PhoenixProfiler.Profiler, :start_link, [opts]}
     }
   end
 
-  @behaviour Plug
-
-  @impl Plug
-  defdelegate init(opts), to: PhoenixProfiler.Plug
-
-  @impl Plug
-  defdelegate call(conn, opts), to: PhoenixProfiler.Plug
-
   # TODO: Remove when we require LiveView v0.17+.
   @doc false
   def mount(params, session, socket) do
@@ -39,73 +46,63 @@ defmodule PhoenixProfiler do
 
   """
   def on_mount(_arg, _params, _session, socket) do
-    {:cont, PhoenixProfiler.Utils.maybe_mount_profile(socket)}
+    {:cont, PhoenixProfiler.Utils.maybe_mount_profiler(socket)}
   end
 
   @doc """
   Enables the profiler on a given `conn` or connected `socket`.
 
-  Normally you do not need to invoke this function manually. It is invoked
-  automatically by the PhoenixProfiler plug in the Endpoint when a
-  profiler is enabled. In LiveView v0.16+ it is invoked automatically when
-  you define `on_mount PhoenixProfiler` on your LiveView.
+  Useful when choosing to start a profiler with
+  `[enable: false]`, but normally you do not need to invoke it
+  manually.
 
-  This function will raise if the endpoint is not configured with a profiler,
-  or if the configured profiler is not running. For LiveView specifically,
-  this function also raises if the given socket is not connected.
+  Note the profiler server must be running and the `conn` or
+  `socket` must have been configured for profiling for this
+  function to have any effect.
 
   ## Example
 
-  Within a Phoenix Controller (for example, on a show callback):
+  Within a Phoenix Controller (for example on a `show` callback):
 
       def show(conn, params) do
         conn = PhoenixProfiler.enable(conn)
         # code...
       end
 
-  Within a LiveView (for example, on the mount callback):
-
-      def mount(params, session, socket) do
-        socket =
-          if connected?(socket) do
-            PhoenixProfiler.enable(socket)
-          else
-            socket
-          end
+  Within a LiveView (for example on a `handle_info` callback):
 
+      def handle_info(:debug_me, socket) do
+        socket = PhoenixProfiler.enable(socket)
         # code...
       end
 
   """
-  defdelegate enable(conn_or_socket), to: PhoenixProfiler.Utils, as: :enable_profiler
+  defdelegate enable(conn_or_socket), to: PhoenixProfiler.Profiler
 
   @doc """
   Disables profiling on a given `conn` or `socket`.
 
   ## Examples
 
-  Within a Phoenix Controller (for example, on an update callback):
+  Within a Phoenix Controller (for example on an `update` callback):
 
       def update(conn, params) do
         conn = PhoenixProfiler.disable(conn)
         # code...
       end
 
-  Within in a LiveView (for example, on a handle_event callback):
+  Within in a LiveView (for example on a `handle_event` callback):
 
       def handle_event("some-event", _, socket) do
         socket = PhoenixProfiler.disable(socket)
         # code...
       end
 
-  Note that only for LiveView, if you invoke `disable/1` on
-  the LiveView `mount` callback, the profiler may not be
-  registered yet and it will not receive the disable message.
-  If you need on-demand profiling, it is recommended you
-  start with the profiler in a disabled state and enable it
-  after the LiveView has mounted.
+  Note that for LiveView, you must invoke `disable/1` _after_
+  the LiveView has completed its connected mount for this function
+  to have any effect.
   """
-  defdelegate disable(conn_or_socket), to: PhoenixProfiler.Utils, as: :disable_profiler
+  defdelegate disable(conn_or_socket), to: PhoenixProfiler.Profiler
 
   @doc """
   Resets the storage of the given `profiler`.

lib/phoenix_profiler/dashboard.ex

@@ -15,6 +15,7 @@ if Code.ensure_loaded?(Phoenix.LiveDashboard) do
 
     """
     use Phoenix.LiveDashboard.PageBuilder
+    alias PhoenixProfiler.Profile
     alias PhoenixProfiler.ProfileStore
     alias PhoenixProfiler.Utils
 
@@ -188,7 +189,7 @@ if Code.ensure_loaded?(Phoenix.LiveDashboard) do
     end
 
     defp render_panel(:request, assigns) do
-      conn = assigns.profile.conn
+      conn = assigns.profile.data.conn
 
       nav_bar(
         items: [
@@ -297,29 +298,26 @@ if Code.ensure_loaded?(Phoenix.LiveDashboard) do
     defp fetch_profiles(params, profiler, node) do
       %{search: search, sort_by: sort_by, sort_dir: sort_dir, limit: limit} = params
 
-      {profiles, total} = fetch_profiles(node, profiler, search, sort_by, sort_dir, limit)
+      {profiles, total} =
+        ProfileStore.remote_list_advanced(node, profiler, search, sort_by, sort_dir, limit)
 
       rows =
-        for {token, prof} <- profiles do
-          %{at: at, conn: %Plug.Conn{} = conn} = prof
+        for {token, profile} <- profiles do
+          %Profile{
+            data: %{conn: %Plug.Conn{} = conn},
+            system_time: system_time
+          } = profile
 
           conn
           |> Map.take([:host, :status, :method, :remote_ip])
           |> Map.put(:url, Plug.Conn.request_url(conn))
           |> Map.put(:token, token)
-          |> Map.put(:at, at)
+          |> Map.put(:system_time, system_time)
         end
 
       {rows, total}
     end
 
-    defp fetch_profiles(node, profiler, search, sort_by, sort_dir, limit) do
-      profiles =
-        ProfileStore.remote_list_advanced(node, profiler, search, sort_by, sort_dir, limit)
-
-      {profiles, length(profiles)}
-    end
-
     defp columns do
       [
         %{
@@ -339,8 +337,8 @@ if Code.ensure_loaded?(Phoenix.LiveDashboard) do
           header: "URL"
         },
         %{
-          field: :at,
-          header: "Profiled at",
+          field: :system_time,
+          header: "Time",
           sortable: :desc,
           format: &format_time/1
         },