Add live_component update telemetry event

lib/phoenix_live_view/diff.ex

@@ -629,7 +629,6 @@ defmodule Phoenix.LiveView.Diff do
     {{pending, diffs, components}, seen_ids} =
       Enum.reduce(pending, acc, fn {component, entries}, acc ->
         {{pending, diffs, components}, seen_ids} = acc
-        update_many? = function_exported?(component, :update_many, 1)
         entries = maybe_preload_components(component, Enum.reverse(entries))
 
         {assigns_sockets, metadata, components, seen_ids} =
@@ -653,26 +652,46 @@ defmodule Phoenix.LiveView.Diff do
                      put_cid(components, component, id, cid)}
                 end
 
-              assigns_sockets =
-                if update_many? do
-                  [{new_assigns, socket} | assigns_sockets]
-                else
-                  [Utils.maybe_call_update!(socket, component, new_assigns) | assigns_sockets]
-                end
-
+              assigns_sockets = [{new_assigns, socket} | assigns_sockets]
               metadata = [{cid, id, new?} | metadata]
               seen_ids = Map.put(seen_ids, [component | id], true)
               {assigns_sockets, metadata, components, seen_ids}
           end)
 
+        assigns_sockets = Enum.reverse(assigns_sockets)
+        metadata = Enum.reverse(metadata)
+        update_many? = function_exported?(component, :update_many, 1)
+
+        component_data=
+          assigns_sockets
+          |> Enum.zip(metadata)
+          |> Enum.map(fn {{assigns, socket}, {cid, _id, new?}} ->
+            %{
+              assigns: assigns,
+              socket: socket,
+              cid: cid,
+              new?: new?
+            }
+          end)
+
+        telemetry_metadata = %{socket: socket, component: component, component_data: component_data, update_many?: update_many?}
+
         sockets =
-          if update_many? do
-            component.update_many(Enum.reverse(assigns_sockets))
-          else
-            Enum.reverse(assigns_sockets)
-          end
+          :telemetry.span([:phoenix, :live_component, :update], telemetry_metadata, fn ->
+            sockets =
+              if update_many? do
+                component.update_many(assigns_sockets)
+              else
+                Enum.map(assigns_sockets, fn {assigns, socket} -> 
+                  Utils.maybe_call_update!(socket, component, assigns)
+                end)
+              end
+
+            component_data = sockets |> Enum.zip(component_data) |> Enum.map(fn {socket, data} -> %{data | socket: socket} end)
+
+            {sockets, Map.put(telemetry_metadata, :component_data, component_data)}
+          end)
 
-        metadata = Enum.reverse(metadata)
         triplet = zip_components(sockets, metadata, component, cids, {pending, diffs, components})
         {triplet, seen_ids}
       end)

test/phoenix_live_view/integrations/telemetry_test.exs

@@ -252,6 +252,45 @@ defmodule Phoenix.LiveView.TelemtryTest do
       assert metadata.component == Phoenix.LiveViewTest.StatefulComponent
       assert metadata.params == %{"op" => "boom"}
     end
+
+    test "emits telemetry events for update calls", %{conn: conn} do
+      attach_telemetry([:phoenix, :live_component, :update])
+
+      {:ok, view, _html} = live(conn, "/multi-targets")
+
+      assert_receive {:event, [:phoenix, :live_component, :update, :start], %{system_time: _},
+                      metadata}
+
+      assert metadata.socket
+      assert metadata.component == Phoenix.LiveViewTest.StatefulComponent
+      refute metadata.update_many?
+
+      assert [
+               %{
+                 cid: cid,
+                 assigns: %{id: _id, name: name},
+                 socket: component_socket,
+                 new?: true
+               },
+               _
+             ] = metadata.component_data
+
+      assert is_integer(cid)
+
+      assert_receive {:event, [:phoenix, :live_component, :update, :stop], %{duration: _},
+                      metadata}
+
+      assert metadata.socket
+      assert metadata.component == Phoenix.LiveViewTest.StatefulComponent
+      assert [%{socket: updated_component_socket}, _] = metadata.component_data
+
+      assert updated_component_socket != component_socket
+
+      render_click(view, "disable", %{"name" => name})
+
+      assert_receive {:event, [:phoenix, :live_component, :update, :start], %{system_time: _},
+                      %{component_data: [%{new?: false, assigns: %{name: ^name, disabled: true}} | _]}}
+    end
   end
 
   describe "logging configuration" do

test/support/live_views/components.ex

@@ -323,6 +323,10 @@ defmodule Phoenix.LiveViewTest.WithMultipleTargets do
   def handle_event("transform", %{"op" => _op}, socket) do
     {:noreply, assign(socket, :message, "Parent was updated")}
   end
+
+  def handle_event("disable", %{"name" => name}, socket) do
+    {:noreply, assign(socket, :disabled, Enum.uniq([name | socket.assigns.disabled]))}
+  end
 end
 
 defmodule Phoenix.LiveViewTest.WithLogOverride do