Add events for ActorMesh (#1938)

Summary:
Pull Request resolved: #1938

As title.

Reviewed By: mariusae, vidhyav

Differential Revision: D87382588

fbshipit-source-id: 8cf97b71f17c21f5546633ad3a2e7877893a60b8

Author: pzhan9

hyperactor_mesh/src/v1/actor_mesh.rs

@@ -76,7 +76,7 @@ impl<A: Referable> ActorMesh<A> {
 
     /// Detach this mesh from the lifetime of `self`, and return its reference.
     pub(crate) fn detach(self) -> ActorMeshRef<A> {
-        self.current_ref
+        self.current_ref.clone()
     }
 
     /// Stop actors on this mesh across all procs.
@@ -113,6 +113,16 @@ impl<A: Referable> Clone for ActorMesh<A> {
     }
 }
 
+impl<A: Referable> Drop for ActorMesh<A> {
+    fn drop(&mut self) {
+        tracing::info!(
+            name = "ActorMeshStatus",
+            actor_mesh = %self.name,
+            status = "Dropped",
+        );
+    }
+}
+
 /// Influences paging behavior for the lazy cache. Smaller pages
 /// reduce over-allocation for sparse access; larger pages reduce the
 /// number of heap allocations for contiguous scans.

hyperactor_mesh/src/v1/proc_mesh.rs

@@ -688,6 +688,10 @@ impl ProcMeshRef {
         &self.name
     }
 
+    fn host_mesh_name(&self) -> Option<&Name> {
+        self.host_mesh.as_ref().map(|h| h.name())
+    }
+
     /// Returns the HostMeshRef that this ProcMeshRef might be backed by.
     /// Returns None if this ProcMeshRef is backed by an Alloc instead of a host mesh.
     pub fn hosts(&self) -> Option<&HostMeshRef> {
@@ -875,12 +879,48 @@ impl ProcMeshRef {
     ///   inside the `ActorMesh`.
     /// - `A::Params: RemoteMessage` - spawn parameters must be
     ///   serializable and routable.
+    #[hyperactor::instrument(fields(
+        host_mesh=self.host_mesh_name().map(|n| n.to_string()),
+        proc_mesh=self.name.to_string(),
+        actor_mesh=name.to_string(),
+    ))]
     pub(crate) async fn spawn_with_name<A: Actor + Referable>(
         &self,
         cx: &impl context::Actor,
         name: Name,
         params: &A::Params,
     ) -> v1::Result<ActorMesh<A>>
+    where
+        A::Params: RemoteMessage,
+    {
+        tracing::info!(
+            name = "ProcMeshStatus",
+            status = "ActorMesh::Spawn::Attempt",
+        );
+        tracing::info!(name = "ActorMeshStatus", status = "Spawn::Attempt");
+        let result = self.spawn_with_name_inner(cx, name, params).await;
+        match &result {
+            Ok(_) => {
+                tracing::info!(
+                    name = "ProcMeshStatus",
+                    status = "ActorMesh::Spawn::Success",
+                );
+                tracing::info!(name = "ActorMeshStatus", status = "Spawn::Success");
+            }
+            Err(error) => {
+                tracing::error!(name = "ProcMeshStatus", status = "ActorMesh::Spawn::Failed", %error);
+                tracing::error!(name = "ActorMeshStatus", status = "Spawn::Failed", %error);
+            }
+        }
+        result
+    }
+
+    async fn spawn_with_name_inner<A: Actor + Referable>(
+        &self,
+        cx: &impl context::Actor,
+        name: Name,
+        params: &A::Params,
+    ) -> v1::Result<ActorMesh<A>>
     where
         A::Params: RemoteMessage,
     {
@@ -998,10 +1038,36 @@ impl ProcMeshRef {
     }
 
     /// Send stop actors message to all mesh agents for a specific mesh name
+    #[hyperactor::instrument(fields(
+        host_mesh = self.host_mesh_name().map(|n| n.to_string()),
+        proc_mesh = self.name.to_string(),
+        actor_mesh = mesh_name.to_string(),
+    ))]
     pub(crate) async fn stop_actor_by_name(
         &self,
         cx: &impl context::Actor,
         mesh_name: Name,
+    ) -> v1::Result<()> {
+        tracing::info!(name = "ProcMeshStatus", status = "ActorMesh::Stop::Attempt");
+        tracing::info!(name = "ActorMeshStatus", status = "Stop::Attempt");
+        let result = self.stop_actor_by_name_inner(cx, mesh_name).await;
+        match &result {
+            Ok(_) => {
+                tracing::info!(name = "ProcMeshStatus", status = "ActorMesh::Stop::Success");
+                tracing::info!(name = "ActorMeshStatus", status = "Stop::Success");
+            }
+            Err(error) => {
+                tracing::error!(name = "ProcMeshStatus", status = "ActorMesh::Stop::Failed", %error);
+                tracing::error!(name = "ActorMeshStatus", status = "Stop::Failed", %error);
+            }
+        }
+        result
+    }
+
+    async fn stop_actor_by_name_inner(
+        &self,
+        cx: &impl context::Actor,
+        mesh_name: Name,
     ) -> v1::Result<()> {
         let region = self.region().clone();
         let agent_mesh = self.agent_mesh();