Hacking lemmy_server 0.18.2 with tons of extra logging to independent disk files

[RocketDerp]

saving here:

diff --git a/Cargo.lock b/Cargo.lock
index b2d3a7bf4..d3910dd51 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11,8 +11,6 @@ checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
 [[package]]
 name = "activitypub_federation"
 version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ab3ac148d9c0b4163a6d41040c17de7558a42224b9ecbd4e8f033aef6c254d9"
 dependencies = [
  "activitystreams-kinds",
  "actix-web",
@@ -22,7 +20,6 @@ dependencies = [
  "bytes",
  "chrono",
  "derive_builder",
- "displaydoc",
  "dyn-clone",
  "enum_delegate",
  "futures-core",
@@ -1548,17 +1545,6 @@ dependencies = [
  "chrono",
 ]
 
-[[package]]
-name = "displaydoc"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.25",
-]
-
 [[package]]
 name = "dlv-list"
 version = "0.3.0"
@@ -2397,17 +2383,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
-[[package]]
-name = "idna"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
-dependencies = [
- "matches",
- "unicode-bidi",
- "unicode-normalization",
-]
-
 [[package]]
 name = "idna"
 version = "0.3.0"
@@ -2869,6 +2844,7 @@ dependencies = [
  "tokio-postgres-rustls",
  "tracing",
  "tracing-actix-web",
+ "tracing-appender",
  "tracing-error",
  "tracing-log",
  "tracing-opentelemetry 0.19.0",
@@ -3162,12 +3138,6 @@ dependencies = [
  "regex-automata 0.1.10",
 ]
 
-[[package]]
-name = "matches"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
-
 [[package]]
 name = "matchit"
 version = "0.5.0"
@@ -3195,7 +3165,7 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5736ba45bbac8f7ccc99a897f88ce85e508a18baec973a040f2514e6cdbff0d2"
 dependencies = [
- "idna 0.2.3",
+ "idna 0.3.0",
  "once_cell",
  "regex",
 ]
@@ -5630,6 +5600,17 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "tracing-appender"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09d48f71a791638519505cefafe162606f706c25592e4bde4d97600c0195312e"
+dependencies = [
+ "crossbeam-channel",
+ "time 0.3.15",
+ "tracing-subscriber",
+]
+
 [[package]]
 name = "tracing-attributes"
 version = "0.1.23"
diff --git a/Cargo.toml b/Cargo.toml
index 9df383df4..c1829ac62 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -56,7 +56,7 @@ lemmy_routes = { version = "=0.18.1", path = "./crates/routes" }
 lemmy_db_views = { version = "=0.18.1", path = "./crates/db_views" }
 lemmy_db_views_actor = { version = "=0.18.1", path = "./crates/db_views_actor" }
 lemmy_db_views_moderator = { version = "=0.18.1", path = "./crates/db_views_moderator" }
-activitypub_federation = { version = "0.4.5", default-features = false, features = ["actix-web"] }
+activitypub_federation = { version = "0.4.5", default-features = false, features = ["actix-web"], path = "../activitypub-federation-rust" }
 diesel = "2.1.0"
 diesel_migrations = "2.1.0"
 diesel-async = "0.3.1"
@@ -147,3 +147,4 @@ tokio-postgres-rustls = { workspace = true }
 chrono = { workspace = true }
 prometheus = { version = "0.13.3", features = ["process"], optional = true }
 actix-web-prom = { version = "0.6.0", optional = true }
+tracing-appender = "0.2.2"
diff --git a/crates/api/src/local_user/notifications/unread_count.rs b/crates/api/src/local_user/notifications/unread_count.rs
index 21622ddbf..c89d62c89 100644
--- a/crates/api/src/local_user/notifications/unread_count.rs
+++ b/crates/api/src/local_user/notifications/unread_count.rs
@@ -27,6 +27,8 @@ impl Perform for GetUnreadCount {
     let private_messages =
       PrivateMessageView::get_unread_messages(&mut context.pool(), person_id).await?;
 
+    tracing::debug!(target: "api", "API GetUnreadCount person_id {:?} replies {:?} mentions {} private {}", person_id, replies, mentions, private_messages);
+
     Ok(Self::Response {
       replies,
       mentions,
diff --git a/crates/api/src/local_user/report_count.rs b/crates/api/src/local_user/report_count.rs
index 89bedc262..bf3ae9236 100644
--- a/crates/api/src/local_user/report_count.rs
+++ b/crates/api/src/local_user/report_count.rs
@@ -31,6 +31,8 @@ impl Perform for GetReportCount {
     let post_reports =
       PostReportView::get_report_count(&mut context.pool(), person_id, admin, community_id).await?;
 
+    tracing::debug!(target: "api", "API GetReportCount person_id {:?} admin {:?} comment {} post {}", person_id, admin, comment_reports, post_reports);
+
     let private_message_reports = if admin && community_id.is_none() {
       Some(PrivateMessageReportView::get_report_count(&mut context.pool()).await?)
     } else {
diff --git a/crates/api/src/post/feature.rs b/crates/api/src/post/feature.rs
index c59eba313..cac816c33 100644
--- a/crates/api/src/post/feature.rs
+++ b/crates/api/src/post/feature.rs
@@ -34,6 +34,8 @@ impl Perform for FeaturePost {
     let post_id = data.post_id;
     let orig_post = Post::read(&mut context.pool(), post_id).await?;
 
+    tracing::debug!(target: "api", "API Post FeaturePost {:?} person_id {:?} vs creator_id {:?}", post_id, local_user_view.person.id, orig_post.creator_id);
+      
     check_community_ban(
       local_user_view.person.id,
       orig_post.community_id,
diff --git a/crates/api/src/post/like.rs b/crates/api/src/post/like.rs
index 025129d31..50df92ec4 100644
--- a/crates/api/src/post/like.rs
+++ b/crates/api/src/post/like.rs
@@ -38,6 +38,8 @@ impl Perform for CreatePostLike {
     let post_id = data.post_id;
     let post = Post::read(&mut context.pool(), post_id).await?;
 
+    tracing::debug!(target: "api", "API Post CreatePostLike {:?} person_id {:?}", post_id, local_user_view.person.id);
+
     check_community_ban(
       local_user_view.person.id,
       post.community_id,
@@ -68,6 +70,8 @@ impl Perform for CreatePostLike {
     // Mark the post as read
     mark_post_as_read(person_id, post_id, &mut context.pool()).await?;
 
+    tracing::debug!(target: "api", "API Post CreatePostLike near-end {:?} person_id {:?}", post_id, local_user_view.person.id);
+
     build_post_response(
       context,
       post.community_id,
diff --git a/crates/api_common/src/build_response.rs b/crates/api_common/src/build_response.rs
index 8b96206cb..7f2a5f84f 100644
--- a/crates/api_common/src/build_response.rs
+++ b/crates/api_common/src/build_response.rs
@@ -69,9 +69,11 @@ pub async fn build_post_response(
   person_id: PersonId,
   post_id: PostId,
 ) -> Result<PostResponse, LemmyError> {
+  tracing::debug!(target: "api", "API api_common build_post_response start function post {}", post_id);
   let is_mod_or_admin = is_mod_or_admin(&mut context.pool(), person_id, community_id)
     .await
     .is_ok();
+  tracing::debug!(target: "api", "API api_common build_post_response after is_mod_or_admin post {} is_mod_or_admin {}", post_id, is_mod_or_admin);
   let post_view = PostView::read(
     &mut context.pool(),
     post_id,
@@ -79,6 +81,7 @@ pub async fn build_post_response(
     Some(is_mod_or_admin),
   )
   .await?;
+  tracing::debug!(target: "api", "API api_common build_post_response before Ok post {}", post_id);
   Ok(PostResponse { post_view })
 }
 
diff --git a/crates/api_crud/src/comment/delete.rs b/crates/api_crud/src/comment/delete.rs
index c42924de7..4e4724beb 100644
--- a/crates/api_crud/src/comment/delete.rs
+++ b/crates/api_crud/src/comment/delete.rs
@@ -23,11 +23,14 @@ impl PerformCrud for DeleteComment {
   #[tracing::instrument(skip(context))]
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
     let data: &DeleteComment = self;
+    tracing::debug!(target: "api", "API api_crud DeleteComment function perform start");
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let comment_id = data.comment_id;
     let orig_comment = CommentView::read(&mut context.pool(), comment_id, None).await?;
 
+    tracing::debug!(target: "api", "API api_crud DeleteComment {:?} person_id {:?} orig_deleted {}", comment_id, local_user_view.person.id, orig_comment.comment.deleted);
+
     // Dont delete it if its already been deleted.
     if orig_comment.comment.deleted == data.deleted {
       return Err(LemmyErrorType::CouldntUpdateComment)?;
@@ -42,10 +45,11 @@ impl PerformCrud for DeleteComment {
 
     // Verify that only the creator can delete
     if local_user_view.person.id != orig_comment.creator.id {
+      tracing::warn!(target: "api", "API DeleteComment ATTEMPTED by non-owner {:?} person_id {:?} vs creator_id {:?}", comment_id, local_user_view.person.id, orig_comment.creator.id);
       return Err(LemmyErrorType::NoCommentEditAllowed)?;
     }
 
-    // Do the delete
+    // Do the delete by updating the comment
     let deleted = data.deleted;
     let updated_comment = Comment::update(
       &mut context.pool(),
@@ -67,6 +71,8 @@ impl PerformCrud for DeleteComment {
     )
     .await?;
 
+    tracing::debug!(target: "api", "API api_crud DeleteComment completed_checkpointA {:?} person_id {:?} orig_deleted {}", comment_id, local_user_view.person.id, orig_comment.comment.deleted);
+
     build_comment_response(
       context,
       updated_comment.id,
diff --git a/crates/api_crud/src/comment/update.rs b/crates/api_crud/src/comment/update.rs
index 0129e87c2..f62fb17f8 100644
--- a/crates/api_crud/src/comment/update.rs
+++ b/crates/api_crud/src/comment/update.rs
@@ -31,6 +31,7 @@ impl PerformCrud for EditComment {
 
   #[tracing::instrument(skip(context))]
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<CommentResponse, LemmyError> {
+    tracing::debug!(target: "api", "api_crud/comment/perform.rs EditComment perform comment {:?}", self);
     let data: &EditComment = self;
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
     let local_site = LocalSite::read(&mut context.pool()).await?;
diff --git a/crates/api_crud/src/community/list.rs b/crates/api_crud/src/community/list.rs
index 80ad6129c..3e1afe407 100644
--- a/crates/api_crud/src/community/list.rs
+++ b/crates/api_crud/src/community/list.rs
@@ -23,6 +23,8 @@ impl PerformCrud for ListCommunities {
     let local_site = LocalSite::read(&mut context.pool()).await?;
     let is_admin = local_user_view.as_ref().map(|luv| is_admin(luv).is_ok());
 
+    tracing::debug!(target: "api", "API api_crud ListCommunities is_admion {:?}", is_admin);
+
     check_private_instance(&local_user_view, &local_site)?;
 
     let sort = data.sort;
diff --git a/crates/api_crud/src/post/create.rs b/crates/api_crud/src/post/create.rs
index a7aafe812..02b948885 100644
--- a/crates/api_crud/src/post/create.rs
+++ b/crates/api_crud/src/post/create.rs
@@ -50,6 +50,8 @@ impl PerformCrud for CreatePost {
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
     let local_site = LocalSite::read(&mut context.pool()).await?;
 
+    tracing::debug!(target: "api", "API api_crud Post CreatePost person_id {:?}", local_user_view.person.id);
+
     let slur_regex = local_site_to_slur_regex(&local_site);
     check_slurs(&data.name, &slur_regex)?;
     check_slurs_opt(&data.body, &slur_regex)?;
diff --git a/crates/api_crud/src/post/delete.rs b/crates/api_crud/src/post/delete.rs
index eaeb66c43..63bbf8e36 100644
--- a/crates/api_crud/src/post/delete.rs
+++ b/crates/api_crud/src/post/delete.rs
@@ -19,11 +19,14 @@ impl PerformCrud for DeletePost {
   #[tracing::instrument(skip(context))]
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
     let data: &DeletePost = self;
+    tracing::debug!(target: "api", "API api_crud DeletePost perform");
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let post_id = data.post_id;
     let orig_post = Post::read(&mut context.pool(), post_id).await?;
 
+    tracing::debug!(target: "api", "API api_crud DeletePost perform {:?} person_id {:?} vs creator_id {:?}", post_id, local_user_view.person.id, orig_post.creator_id);
+
     // Dont delete it if its already been deleted.
     if orig_post.deleted == data.deleted {
       return Err(LemmyErrorType::CouldntUpdatePost)?;
@@ -35,22 +38,32 @@ impl PerformCrud for DeletePost {
       &mut context.pool(),
     )
     .await?;
+    tracing::debug!(target: "api", "API DeletePost check_community_ban {:?}", post_id);
     check_community_deleted_or_removed(orig_post.community_id, &mut context.pool()).await?;
+    tracing::debug!(target: "api", "API DeletePost check_community_deleted_or_removed {:?}", post_id);
 
     // Verify that only the creator can delete
     if !Post::is_post_creator(local_user_view.person.id, orig_post.creator_id) {
+      tracing::warn!(target: "api", "API DeletePost ATTEMPTED by non-owner {:?} person_id {:?} vs creator_id {:?}", post_id, local_user_view.person.id, orig_post.creator_id);
       return Err(LemmyErrorType::NoPostEditAllowed)?;
     }
 
     // Update the post
     let post_id = data.post_id;
     let deleted = data.deleted;
+    tracing::debug!(target: "api", "API DeletePost before database update {:?}", post_id);
     Post::update(
       &mut context.pool(),
       post_id,
       &PostUpdateForm::builder().deleted(Some(deleted)).build(),
     )
     .await?;
+// there is error-logic in deleting of a comment missing here on deleting of a post?
+//  also in editing of a post
+//   .await
+//   .with_lemmy_type(LemmyErrorType::CouldntUpdatePost)?;
+
+    tracing::debug!(target: "api", "API api_crud DeletePost perform completed_checkpointA {:?} person_id {:?} vs creator_id {:?}", post_id, local_user_view.person.id, orig_post.creator_id);
 
     build_post_response(
       context,
diff --git a/crates/api_crud/src/post/read.rs b/crates/api_crud/src/post/read.rs
index af19402ee..09c49d782 100644
--- a/crates/api_crud/src/post/read.rs
+++ b/crates/api_crud/src/post/read.rs
@@ -33,6 +33,8 @@ impl PerformCrud for GetPost {
 
     let person_id = local_user_view.as_ref().map(|u| u.person.id);
 
+    tracing::debug!(target: "api", "API api_crud GetPost person_id {:?}", person_id);
+
     // I'd prefer fetching the post_view by a comment join, but it adds a lot of boilerplate
     let post_id = if let Some(id) = data.id {
       id
diff --git a/crates/api_crud/src/post/remove.rs b/crates/api_crud/src/post/remove.rs
index 7950d5047..499c3d36f 100644
--- a/crates/api_crud/src/post/remove.rs
+++ b/crates/api_crud/src/post/remove.rs
@@ -22,6 +22,7 @@ impl PerformCrud for RemovePost {
   #[tracing::instrument(skip(context))]
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
     let data: &RemovePost = self;
+    tracing::debug!(target: "api", "API api_crud RemovePost perform");
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
 
     let post_id = data.post_id;
diff --git a/crates/api_crud/src/post/update.rs b/crates/api_crud/src/post/update.rs
index fbbadbc61..7c92578a3 100644
--- a/crates/api_crud/src/post/update.rs
+++ b/crates/api_crud/src/post/update.rs
@@ -31,11 +31,14 @@ impl PerformCrud for EditPost {
   #[tracing::instrument(skip(context))]
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<PostResponse, LemmyError> {
     let data: &EditPost = self;
+    tracing::debug!(target: "api", "API api_crud EditPost perform function");
     let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
     let local_site = LocalSite::read(&mut context.pool()).await?;
 
     let data_url = data.url.as_ref();
 
+    tracing::debug!(target: "api", "API api_crud EditPost perform {:?} person_id {:?}", data.post_id, local_user_view.person.id);
+
     // TODO No good way to handle a clear.
     // Issue link: https://github.com/LemmyNet/lemmy/issues/2287
     let url = Some(data_url.map(clean_url_params).map(Into::into));
@@ -61,9 +64,12 @@ impl PerformCrud for EditPost {
       &mut context.pool(),
     )
     .await?;
+// Consistency: delete of a post does this next check:
+//check_community_deleted_or_removed(orig_post.community_id, &mut context.pool()).await?;
 
     // Verify that only the creator can edit
     if !Post::is_post_creator(local_user_view.person.id, orig_post.creator_id) {
+      tracing::warn!(target: "api", "API EditPost ATTEMPTED by non-owner {:?} person_id {:?} vs creator_id {:?}", post_id, local_user_view.person.id, orig_post.creator_id);
       return Err(LemmyErrorType::NoPostEditAllowed)?;
     }
 
@@ -101,6 +107,8 @@ impl PerformCrud for EditPost {
       .await
       .with_lemmy_type(LemmyErrorType::CouldntUpdatePost)?;
 
+    tracing::debug!(target: "api", "API api_crud EditPost completed_checkpointA {:?} person_id {:?} vs creator_id {:?}", data.post_id, local_user_view.person.id, orig_post.creator_id);
+
     build_post_response(
       context,
       orig_post.community_id,
diff --git a/crates/api_crud/src/site/read.rs b/crates/api_crud/src/site/read.rs
index e74eeefbd..53865f9dc 100644
--- a/crates/api_crud/src/site/read.rs
+++ b/crates/api_crud/src/site/read.rs
@@ -36,6 +36,8 @@ impl PerformCrud for GetSite {
   async fn perform(&self, context: &Data<LemmyContext>) -> Result<GetSiteResponse, LemmyError> {
     let data: &GetSite = self;
 
+    tracing::debug!(target: "api", "API GetSite");
+
     let site_view = SiteView::read_local(&mut context.pool()).await?;
 
     let admins = PersonView::admins(&mut context.pool()).await?;
diff --git a/crates/apub/src/activities/community/announce.rs b/crates/apub/src/activities/community/announce.rs
index e33e9fbf4..743730d19 100644
--- a/crates/apub/src/activities/community/announce.rs
+++ b/crates/apub/src/activities/community/announce.rs
@@ -24,6 +24,11 @@ use lemmy_api_common::context::LemmyContext;
 use lemmy_utils::error::{LemmyError, LemmyErrorType};
 use serde_json::Value;
 use url::Url;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+static CALL_COUNT: AtomicUsize = AtomicUsize::new(0);
+static CALL_COUNT1: AtomicUsize = AtomicUsize::new(0);
+static CALL_COUNT2: AtomicUsize = AtomicUsize::new(0);
 
 #[async_trait::async_trait]
 impl ActivityHandler for RawAnnouncableActivities {
@@ -40,12 +45,18 @@ impl ActivityHandler for RawAnnouncableActivities {
 
   #[tracing::instrument(skip_all)]
   async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+    tracing::info!(target: "federation", "apub/activities/community/announce.rs verify {:?}", &self);
     Ok(())
   }
 
   #[tracing::instrument(skip_all)]
   async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+    let c: usize = CALL_COUNT.fetch_add(1, Ordering::SeqCst);
+    tracing::info!(target: "federation", "CCC:0:{} apub/activities/community/announce.rs receive top of function {:?}", c, self);
     let activity: AnnouncableActivities = self.clone().try_into()?;
+
+    tracing::info!(target: "federation", "CCC:0:{} apub/activities/community/announce.rs receive after cast to activity from raw {:?}", c, self);
+
     // This is only for sending, not receiving so we reject it.
     if let AnnouncableActivities::Page(_) = activity {
       return Err(LemmyErrorType::CannotReceivePage)?;
@@ -54,13 +65,17 @@ impl ActivityHandler for RawAnnouncableActivities {
     let actor_id = activity.actor().clone().into();
 
     // verify and receive activity
+    // This transforms the generic RawAnnouncableActivities receive into the specific object type of receive.
     activity.verify(data).await?;
+    tracing::info!(target: "federation", "CCC:0:{} apub/activities/community/announce.rs receive before:activity.receive {:?}", c, self);
     activity.receive(data).await?;
 
     // send to community followers
     if community.local {
       verify_person_in_community(&actor_id, &community, data).await?;
+      tracing::info!(target: "federation", "CCC:0:{} apub/activities/community/announce.rs receive before:AnnounceActivity::send {:?}", c, self);
       AnnounceActivity::send(self, &community, data).await?;
+      tracing::info!(target: "federation", "CCC:0:{} apub/activities/community/announce.rs receive after:AnnounceActivity::send", c);
     }
     Ok(())
   }
@@ -72,6 +87,7 @@ impl AnnounceActivity {
     community: &ApubCommunity,
     context: &Data<LemmyContext>,
   ) -> Result<AnnounceActivity, LemmyError> {
+    tracing::info!(target: "federation", "apub/activities/community/announce.rs AnnounceActivity new {:?}", object);
     Ok(AnnounceActivity {
       actor: community.id().into(),
       to: vec![public()],
@@ -91,6 +107,8 @@ impl AnnounceActivity {
     community: &ApubCommunity,
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    let callcount: usize = CALL_COUNT2.fetch_add(1, Ordering::SeqCst);
+    tracing::debug!(target: "api", "CCC:2:{} API apub/activities/community/announce.rs AnnounceActivity send top of function {:?}", callcount, object);
     let announce = AnnounceActivity::new(object.clone(), community, context)?;
     let inboxes = community.get_follower_inboxes(context).await?;
     send_lemmy_activity(context, announce, community, inboxes.clone(), false).await?;
@@ -113,8 +131,11 @@ impl AnnounceActivity {
           .clone(),
       };
       let announce_compat = AnnounceActivity::new(announcable_page, community, context)?;
+      tracing::debug!(target: "api", "CCC:2:{} API apub/activities/community/announce.rs AnnounceActivity send before:send_lemmy_activity {:?}", callcount, announce_compat.clone());
       send_lemmy_activity(context, announce_compat, community, inboxes, false).await?;
+      tracing::debug!(target: "api", "CCC:2:{} API apub/activities/community/announce.rs AnnounceActivity send  after:send_lemmy_activity", callcount);
     }
+    tracing::debug!(target: "api", "CCC:2:{} API apub/activities/community/announce.rs AnnounceActivity send before:Ok", callcount);
     Ok(())
   }
 }
@@ -134,12 +155,15 @@ impl ActivityHandler for AnnounceActivity {
 
   #[tracing::instrument(skip_all)]
   async fn verify(&self, _context: &Data<Self::DataType>) -> Result<(), LemmyError> {
+    tracing::info!(target: "federation", "apub/activities/community/announce.rs AnnounceActivity verify {:?}", &self);
     verify_is_public(&self.to, &self.cc)?;
     Ok(())
   }
 
   #[tracing::instrument(skip_all)]
   async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
+    let c: usize = CALL_COUNT1.fetch_add(1, Ordering::SeqCst);
+    tracing::info!(target: "federation", "CCC:1:{} apub/activities/community/announce.rs AnnounceActivity recieve functionstart {:?}", c, self);
     insert_activity(&self.id, &self, false, false, context).await?;
     let object: AnnouncableActivities = self.object.object(context).await?.try_into()?;
     // This is only for sending, not receiving so we reject it.
@@ -149,7 +173,11 @@ impl ActivityHandler for AnnounceActivity {
 
     // verify here in order to avoid fetching the object twice over http
     object.verify(context).await?;
-    object.receive(context).await
+    tracing::info!(target: "federation", "CCC:1:{} apub/activities/community/announce.rs AnnounceActivity before:object.recieve", c);
+    let rec = object.receive(context).await;
+    // Rust study question: why no ? here, does the error not come from object.receive?
+    tracing::info!(target: "federation", "CCC:1:{} apub/activities/community/announce.rs AnnounceActivity after:object.recieve", c);
+    return rec;
   }
 }
 
diff --git a/crates/apub/src/activities/community/collection_add.rs b/crates/apub/src/activities/community/collection_add.rs
index d08b0cb48..b277d731b 100644
--- a/crates/apub/src/activities/community/collection_add.rs
+++ b/crates/apub/src/activities/community/collection_add.rs
@@ -89,6 +89,7 @@ impl CollectionAdd {
       audience: Some(community.id().into()),
     };
     let activity = AnnouncableActivities::CollectionAdd(add);
+    tracing::debug!(target: "api", "API send_add_featured_post csend_activity_in_community");
     send_activity_in_community(activity, actor, community, vec![], true, context).await
   }
 }
@@ -210,6 +211,7 @@ impl SendActivity for FeaturePost {
     response: &Self::Response,
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    tracing::debug!(target: "api", "API FeaturePost send_activity");
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
     let community = Community::read(&mut context.pool(), response.post_view.community.id)
       .await?
diff --git a/crates/apub/src/activities/community/lock_page.rs b/crates/apub/src/activities/community/lock_page.rs
index 0416b972a..f5da8921b 100644
--- a/crates/apub/src/activities/community/lock_page.rs
+++ b/crates/apub/src/activities/community/lock_page.rs
@@ -111,6 +111,7 @@ impl SendActivity for LockPost {
     response: &Self::Response,
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    tracing::debug!(target: "api", "API LockPost send_activity");
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
     let id = generate_activity_id(
       LockType::Lock,
diff --git a/crates/apub/src/activities/community/mod.rs b/crates/apub/src/activities/community/mod.rs
index 7a88b34b3..ac1775963 100644
--- a/crates/apub/src/activities/community/mod.rs
+++ b/crates/apub/src/activities/community/mod.rs
@@ -41,6 +41,8 @@ pub(crate) async fn send_activity_in_community(
   // send to any users which are mentioned or affected directly
   let mut inboxes = extra_inboxes;
 
+  tracing::debug!(target: "api", "API apub/activities/community/mod.rs send_activity_in_community start function");
+
   // send to user followers
   if !is_mod_action {
     inboxes.extend(
@@ -52,9 +54,11 @@ pub(crate) async fn send_activity_in_community(
   }
 
   if community.local {
+    tracing::debug!(target: "api", "API apub/activities/community/mod.rs send_activity_in_community local send");
     // send directly to community followers
     AnnounceActivity::send(activity.clone().try_into()?, community, context).await?;
   } else {
+    tracing::debug!(target: "api", "API apub/activities/community/mod.rs send_activity_in_community non-local");
     // send to the community, which will then forward to followers
     inboxes.push(community.shared_inbox_or_inbox());
   }
diff --git a/crates/apub/src/activities/community/update.rs b/crates/apub/src/activities/community/update.rs
index 3e697fddc..ee1125230 100644
--- a/crates/apub/src/activities/community/update.rs
+++ b/crates/apub/src/activities/community/update.rs
@@ -35,6 +35,7 @@ impl SendActivity for EditCommunity {
     _response: &Self::Response,
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    tracing::debug!(target: "api", "API apub.activities.community update.rs EditCommunity send_activity");
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
     let community = Community::read(&mut context.pool(), request.community_id).await?;
     UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await
@@ -48,6 +49,7 @@ impl UpdateCommunity {
     actor: &ApubPerson,
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    tracing::debug!(target: "api", "API apub.activities.community update.rs send");
     let id = generate_activity_id(
       UpdateType::Update,
       &context.settings().get_protocol_and_hostname(),
diff --git a/crates/apub/src/activities/create_or_update/comment.rs b/crates/apub/src/activities/create_or_update/comment.rs
index 804f1827b..0f0d39e23 100644
--- a/crates/apub/src/activities/create_or_update/comment.rs
+++ b/crates/apub/src/activities/create_or_update/comment.rs
@@ -71,6 +71,7 @@ impl SendActivity for EditComment {
     response: &Self::Response,
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    tracing::debug!(target: "federation", "apub/activities/create_or_update/comment.rs EditComment send_activity comment {}", &response.comment_view.comment.id);
     CreateOrUpdateNote::send(
       &response.comment_view.comment,
       response.comment_view.creator.id,
@@ -81,6 +82,11 @@ impl SendActivity for EditComment {
   }
 }
 
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+static CALL_COUNT: AtomicUsize = AtomicUsize::new(0);
+
 impl CreateOrUpdateNote {
   #[tracing::instrument(skip(comment, person_id, kind, context))]
   async fn send(
@@ -91,6 +97,7 @@ impl CreateOrUpdateNote {
   ) -> Result<(), LemmyError> {
     // TODO: might be helpful to add a comment method to retrieve community directly
     let post_id = comment.post_id;
+    tracing::debug!(target: "federation", "apub/activities/create_or_update/comment.rs CreateOrUpdateNote send comment {} post_id {}", comment.id, post_id);
     let post = Post::read(&mut context.pool(), post_id).await?;
     let community_id = post.community_id;
     let person: ApubPerson = Person::read(&mut context.pool(), person_id).await?.into();
@@ -134,7 +141,10 @@ impl CreateOrUpdateNote {
       inboxes.push(person.shared_inbox_or_inbox());
     }
 
+    tracing::debug!(target: "federation", "apub/activities/create_or_update/comment.rs CreateOrUpdateNote send post_id {} fed id {:?} inboxes {:?}", post_id, id.clone(), inboxes);
+
     let activity = AnnouncableActivities::CreateOrUpdateComment(create_or_update);
+    tracing::debug!(target: "federation", "apub/activities/create_or_update/comment.rs CreateOrUpdateNote send_activity_in_community post_id {} fed id {:?} inboxes {:?} activity {:?}", post_id, id.clone(), inboxes, activity);
     send_activity_in_community(activity, &person, &community, inboxes, false, context).await
   }
 }
@@ -154,6 +164,7 @@ impl ActivityHandler for CreateOrUpdateNote {
 
   #[tracing::instrument(skip_all)]
   async fn verify(&self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
+    tracing::debug!(target: "federation", "apub/activities/create_or_update/comment.rs CreateOrUpdateNote verify {} object.id {} actor {}", &self.id, &self.object.id, &self.actor.inner());
     verify_is_public(&self.to, &self.cc)?;
     let post = self.object.get_parents(context).await?.0;
     let community = self.community(context).await?;
@@ -169,6 +180,8 @@ impl ActivityHandler for CreateOrUpdateNote {
 
   #[tracing::instrument(skip_all)]
   async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
+    let c: usize = CALL_COUNT.fetch_add(1, Ordering::SeqCst);
+    tracing::debug!(target: "federation", "CCC:4:{} apub/activities/create_or_update/comment.rs CreateOrUpdateNote receive {} object.id {} actor {}", c, &self.id, &self.object.id, &self.actor.inner());
     insert_activity(&self.id, &self, false, false, context).await?;
     // Need to do this check here instead of Note::from_json because we need the person who
     // send the activity, not the comment author.
@@ -185,16 +198,21 @@ impl ActivityHandler for CreateOrUpdateNote {
 
     let comment = ApubComment::from_json(self.object, context).await?;
 
+    tracing::info!(target: "federation", "CCC:4:{} apub/activities/create_or_update/comment.rs CreateOrUpdateNote receive comment_id {} apn_id {}", c, comment.id, comment.ap_id);
+
     // author likes their own comment by default
-    let like_form = CommentLikeForm {
+    // REMINDER: we are in context of CreateOrUpdateNote, what if this is an Update/Edit? Do this?
+    let like_form: CommentLikeForm = CommentLikeForm {
       comment_id: comment.id,
       post_id: comment.post_id,
       person_id: comment.creator_id,
       score: 1,
     };
+
     CommentLike::like(&mut context.pool(), &like_form).await?;
 
     // Calculate initial hot_rank
+    // REMINDER: we are in context of CreateOrUpdateNote, what if this is an Update/Edit? how does an edit to a comment impact ranking?
     CommentAggregates::update_hot_rank(&mut context.pool(), comment.id).await?;
 
     let do_send_email = self.kind == CreateOrUpdateType::Create;
@@ -208,7 +226,9 @@ impl ActivityHandler for CreateOrUpdateNote {
     // anyway.
     // TODO: for compatibility with other projects, it would be much better to read this from cc or tags
     let mentions = scrape_text_for_mentions(&comment.content);
+    tracing::info!(target: "federation", "CCC:4:{} apub/activities/create_or_update/comment.rs CreateOrUpdateNote receive before:send_local_notifs comment_id {} apn_id {}", c, comment.id, comment.ap_id);
     send_local_notifs(mentions, &comment.0, &actor, &post, do_send_email, context).await?;
+    tracing::info!(target: "federation", "CCC:4:{} apub/activities/create_or_update/comment.rs CreateOrUpdateNote receive  after:send_local_notifs comment_id {} apn_id {}", c, comment.id, comment.ap_id);
     Ok(())
   }
 }
diff --git a/crates/apub/src/activities/create_or_update/post.rs b/crates/apub/src/activities/create_or_update/post.rs
index e0ce0fec4..cb86a0c13 100644
--- a/crates/apub/src/activities/create_or_update/post.rs
+++ b/crates/apub/src/activities/create_or_update/post.rs
@@ -48,6 +48,7 @@ impl SendActivity for CreatePost {
     response: &Self::Response,
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    tracing::debug!(target: "api", "API apub/activities/create_or_update/post.rs CreatePost send_activity");
     CreateOrUpdatePage::send(
       &response.post_view.post,
       response.post_view.creator.id,
@@ -67,6 +68,7 @@ impl SendActivity for EditPost {
     response: &Self::Response,
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    tracing::debug!(target: "api", "API apub/activities/create_or_update/post.rs EditPost send_activity");
     CreateOrUpdatePage::send(
       &response.post_view.post,
       response.post_view.creator.id,
@@ -85,6 +87,7 @@ impl CreateOrUpdatePage {
     kind: CreateOrUpdateType,
     context: &Data<LemmyContext>,
   ) -> Result<CreateOrUpdatePage, LemmyError> {
+    tracing::debug!(target: "api", "API apub/activities/create_or_update/post.rs CreateOrUpdatePage new");
     let id = generate_activity_id(
       kind.clone(),
       &context.settings().get_protocol_and_hostname(),
@@ -107,6 +110,7 @@ impl CreateOrUpdatePage {
     kind: CreateOrUpdateType,
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    tracing::debug!(target: "api", "API apub/activities/create_or_update/post.rs CreateOrUpdatePage send");
     let post = ApubPost(post.clone());
     let community_id = post.community_id;
     let person: ApubPerson = Person::read(&mut context.pool(), person_id).await?.into();
@@ -146,6 +150,7 @@ impl ActivityHandler for CreateOrUpdatePage {
 
   #[tracing::instrument(skip_all)]
   async fn verify(&self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
+    tracing::debug!(target: "federation", "apub/activities/create_or_update/post.rs CreateOrUpdatePage verify");
     verify_is_public(&self.to, &self.cc)?;
     let community = self.community(context).await?;
     verify_person_in_community(&self.actor, &community, context).await?;
@@ -180,6 +185,7 @@ impl ActivityHandler for CreateOrUpdatePage {
 
   #[tracing::instrument(skip_all)]
   async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
+    tracing::debug!(target: "federation", "apub/activities/create_or_update/post.rs CreateOrUpdatePage receive");
     insert_activity(&self.id, &self, false, false, context).await?;
     let post = ApubPost::from_json(self.object, context).await?;
 
diff --git a/crates/apub/src/activities/deletion/delete.rs b/crates/apub/src/activities/deletion/delete.rs
index 8ad104173..1af4e414b 100644
--- a/crates/apub/src/activities/deletion/delete.rs
+++ b/crates/apub/src/activities/deletion/delete.rs
@@ -43,12 +43,14 @@ impl ActivityHandler for Delete {
 
   #[tracing::instrument(skip_all)]
   async fn verify(&self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
+    tracing::debug!(target: "federation", "apub/activities/deletion/delete.rs Delete verify {}", self.object.id());
     verify_delete_activity(self, self.summary.is_some(), context).await?;
     Ok(())
   }
 
   #[tracing::instrument(skip_all)]
   async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
+    tracing::debug!(target: "federation", "apub/activities/deletion/delete.rs Delete receive {}", self.object.id());
     insert_activity(&self.id, &self, false, false, context).await?;
     if let Some(reason) = self.summary {
       // We set reason to empty string if it doesn't exist, to distinguish between delete and
@@ -66,6 +68,7 @@ impl ActivityHandler for Delete {
       )
       .await
     } else {
+      tracing::debug!(target: "federation", "apub/activities/deletion/delete.rs Delete receive before:receive_delete_action {}", self.object.id());
       receive_delete_action(self.object.id(), &self.actor, true, context).await
     }
   }
@@ -80,6 +83,7 @@ impl Delete {
     summary: Option<String>,
     context: &Data<LemmyContext>,
   ) -> Result<Delete, LemmyError> {
+    tracing::debug!(target: "federation", "apub/activities/deletion/delete.rs Delete new {}", object.id());
     let id = generate_activity_id(
       DeleteType::Delete,
       &context.settings().get_protocol_and_hostname(),
@@ -105,6 +109,7 @@ pub(in crate::activities) async fn receive_remove_action(
   reason: Option<String>,
   context: &Data<LemmyContext>,
 ) -> Result<(), LemmyError> {
+  tracing::debug!(target: "federation", "apub/activities/deletion/delete.rs Delete receive_remove_action {}", object.as_str());
   match DeletableObjects::read_from_db(object, context).await? {
     DeletableObjects::Community(community) => {
       if community.local {
diff --git a/crates/apub/src/activities/deletion/mod.rs b/crates/apub/src/activities/deletion/mod.rs
index 3b8c8b537..d23224a27 100644
--- a/crates/apub/src/activities/deletion/mod.rs
+++ b/crates/apub/src/activities/deletion/mod.rs
@@ -49,6 +49,9 @@ use lemmy_db_schema::{
 use lemmy_utils::error::LemmyError;
 use std::ops::Deref;
 use url::Url;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+static CALL_COUNT: AtomicUsize = AtomicUsize::new(0);
 
 pub mod delete;
 pub mod delete_user;
@@ -63,9 +66,11 @@ impl SendActivity for DeletePost {
     response: &Self::Response,
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    tracing::debug!(target: "api", "API apub/activities/deletion/mod.rs SendActivity for DeletePost send_activity start function post {:?}", response.post_view.post);
     let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
     let community = Community::read(&mut context.pool(), response.post_view.community.id).await?;
     let deletable = DeletableObjects::Post(response.post_view.post.clone().into());
+    tracing::debug!(target: "api", "API apub/activities/deletion/mod.rs SendActivity for DeletePost send_activity person {:?} post {:?}", local_user_view.person, response.post_view.post);
     send_apub_delete_in_community(
       local_user_view.person,
       community,
@@ -112,6 +117,7 @@ impl SendActivity for DeleteComment {
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let community_id = response.comment_view.community.id;
+    tracing::debug!(target: "api", "API apub/activities/deletion/mod.rs SendActivity DeleteComment send_activity community_id {:?}", response.comment_view.community.id);
     let community = Community::read(&mut context.pool(), community_id).await?;
     let person = Person::read(&mut context.pool(), response.comment_view.creator.id).await?;
     let deletable = DeletableObjects::Comment(response.comment_view.comment.clone().into());
@@ -225,6 +231,7 @@ async fn send_apub_delete_in_community(
   deleted: bool,
   context: &Data<LemmyContext>,
 ) -> Result<(), LemmyError> {
+  tracing::debug!(target: "api", "API apub/activities/deletion/mod.rs send_apub_delete_in_community");
   let actor = ApubPerson::from(actor);
   let is_mod_action = reason.is_some();
   let activity = if deleted {
@@ -314,6 +321,7 @@ pub(in crate::activities) async fn verify_delete_activity(
   context: &Data<LemmyContext>,
 ) -> Result<(), LemmyError> {
   let object = DeletableObjects::read_from_db(activity.object.id(), context).await?;
+  tracing::debug!(target: "federation", "apub/activities/deletion/mod.rs verify_delete_activity {:?}", activity.object.id().clone().as_str());
   match object {
     DeletableObjects::Community(community) => {
       verify_is_public(&activity.to, &[])?;
@@ -326,6 +334,7 @@ pub(in crate::activities) async fn verify_delete_activity(
       verify_mod_action(&activity.actor, activity.object.id(), community.id, context).await?;
     }
     DeletableObjects::Post(p) => {
+      tracing::info!(target: "federation", "apub/activities/deletion/mod.rs verify_delete_activity Post {:?}", p.ap_id);
       verify_is_public(&activity.to, &[])?;
       verify_delete_post_or_comment(
         &activity.actor,
@@ -363,6 +372,7 @@ async fn verify_delete_post_or_comment(
   is_mod_action: bool,
   context: &Data<LemmyContext>,
 ) -> Result<(), LemmyError> {
+  tracing::debug!(target: "federation", "apub/activities/deletion/mod.rs verify_delete_post_or_comment {:?}", object_id.clone().as_str());
   verify_person_in_community(actor, community, context).await?;
   if is_mod_action {
     verify_mod_action(actor, object_id, community.id, context).await?;
@@ -381,6 +391,8 @@ async fn receive_delete_action(
   deleted: bool,
   context: &Data<LemmyContext>,
 ) -> Result<(), LemmyError> {
+  let c: usize = CALL_COUNT.fetch_add(1, Ordering::SeqCst);
+  tracing::debug!(target: "federation", "CCC:6:{} apub/activities/deletion/mod.rs receive_delete_action {:?}", c, object.as_str());
   match DeletableObjects::read_from_db(object, context).await? {
     DeletableObjects::Community(community) => {
       if community.local {
@@ -400,6 +412,7 @@ async fn receive_delete_action(
       .await?;
     }
     DeletableObjects::Post(post) => {
+      tracing::debug!(target: "federation", "CCC:6:{} apub/activities/deletion/mod.rs receive_delete_action DeletableObjects::Post {:?} deleted {} vs post.deleted {}", c, object.as_str(), deleted, post.deleted);
       if deleted != post.deleted {
         Post::update(
           &mut context.pool(),
@@ -410,6 +423,7 @@ async fn receive_delete_action(
       }
     }
     DeletableObjects::Comment(comment) => {
+      tracing::debug!(target: "federation", "CCC:6:{} apub/activities/deletion/mod.rs receive_delete_action DeletableObjects::Comment {:?} deleted {} vs comment.deleted {}", c, object.as_str(), deleted, comment.deleted);
       if deleted != comment.deleted {
         Comment::update(
           &mut context.pool(),
@@ -430,5 +444,6 @@ async fn receive_delete_action(
       .await?;
     }
   }
+  tracing::debug!(target: "federation", "CCC:6:{} apub/activities/deletion/mod.rs receive_delete_action before:Ok {:?}", c, object.as_str());
   Ok(())
 }
diff --git a/crates/apub/src/activities/deletion/undo_delete.rs b/crates/apub/src/activities/deletion/undo_delete.rs
index e10bd0660..8b1345552 100644
--- a/crates/apub/src/activities/deletion/undo_delete.rs
+++ b/crates/apub/src/activities/deletion/undo_delete.rs
@@ -42,6 +42,7 @@ impl ActivityHandler for UndoDelete {
   }
 
   async fn verify(&self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+    tracing::debug!(target: "federation", "apub/activities/deletion/undo_deletes.rs UndoDelete verify {}", &self.id);
     self.object.verify(data).await?;
     verify_delete_activity(&self.object, self.object.summary.is_some(), data).await?;
     Ok(())
@@ -49,6 +50,7 @@ impl ActivityHandler for UndoDelete {
 
   #[tracing::instrument(skip_all)]
   async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
+    tracing::debug!(target: "federation", "apub/activities/deletion/undo_deletes.rs UndoDelete receive {}", &self.id);
     insert_activity(&self.id, &self, false, false, context).await?;
     if self.object.summary.is_some() {
       UndoDelete::receive_undo_remove_action(
@@ -73,6 +75,7 @@ impl UndoDelete {
     summary: Option<String>,
     context: &Data<LemmyContext>,
   ) -> Result<UndoDelete, LemmyError> {
+    tracing::debug!(target: "federation", "apub/activities/deletion/undo_deletes.rs UndoDelete new");
     let object = Delete::new(actor, object, to.clone(), community, summary, context)?;
 
     let id = generate_activity_id(
@@ -97,6 +100,7 @@ impl UndoDelete {
     object: &Url,
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    tracing::debug!(target: "federation", "apub/activities/deletion/undo_deletes.rs UndoDelete receive_undo_remove_action");
     match DeletableObjects::read_from_db(object, context).await? {
       DeletableObjects::Community(community) => {
         if community.local {
diff --git a/crates/apub/src/activities/mod.rs b/crates/apub/src/activities/mod.rs
index e0b46e0e7..dba8c0b43 100644
--- a/crates/apub/src/activities/mod.rs
+++ b/crates/apub/src/activities/mod.rs
@@ -92,6 +92,8 @@ pub(crate) async fn verify_mod_action(
 ) -> Result<(), LemmyError> {
   let mod_ = mod_id.dereference(context).await?;
 
+  tracing::info!(target: "federation", "apub/activities/mod.rs verify_mod_action {:?} {:?}", mod_.id, community_id);
+
   let is_mod_or_admin =
     CommunityView::is_mod_or_admin(&mut context.pool(), mod_.id, community_id).await?;
   if is_mod_or_admin {
@@ -171,6 +173,7 @@ where
       .time_to_live(DEAD_INSTANCE_LIST_CACHE_DURATION)
       .build()
   });
+  tracing::debug!(target: "api", "API Federating, apub/activities/mod.rs send_lemmy_activity checking dead {} actor {} inbox {:?}", activity.id().to_string(), activity.actor(), inbox);
   let dead_instances = CACHE
     .try_get_with((), async {
       Ok::<_, diesel::result::Error>(Arc::new(Instance::dead_instances(&mut data.pool()).await?))
@@ -182,10 +185,13 @@ where
     !dead_instances.contains(&domain)
   });
   info!("Sending activity {}", activity.id().to_string());
+  tracing::debug!(target: "api", "API Federating, apub/activities/mod.rs send_lemmy_activity {} actor {} inbox {:?}", activity.id().to_string(), activity.actor(), inbox);
   let activity = WithContext::new(activity, CONTEXT.deref().clone());
 
   insert_activity(activity.id(), &activity, true, sensitive, data).await?;
   send_activity(activity, actor, inbox, data).await?;
 
+  tracing::debug!(target: "api", "API Federating, apub/activities/mod.rs send_lemmy_activity after send_activity");
+
   Ok(())
 }
diff --git a/crates/apub/src/api/read_person.rs b/crates/apub/src/api/read_person.rs
index 71f4abd51..eac739e7b 100644
--- a/crates/apub/src/api/read_person.rs
+++ b/crates/apub/src/api/read_person.rs
@@ -28,6 +28,8 @@ pub async fn read_person(
   let local_site = LocalSite::read(&mut context.pool()).await?;
   let is_admin = local_user_view.as_ref().map(|luv| is_admin(luv).is_ok());
 
+  tracing::debug!(target: "api", "API read_person admin {:?}", is_admin);
+
   check_private_instance(&local_user_view, &local_site)?;
 
   let person_details_id = match data.person_id {
diff --git a/crates/apub/src/api/resolve_object.rs b/crates/apub/src/api/resolve_object.rs
index d86c28d60..7e1e2ead3 100644
--- a/crates/apub/src/api/resolve_object.rs
+++ b/crates/apub/src/api/resolve_object.rs
@@ -20,6 +20,7 @@ pub async fn resolve_object(
   let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
   let local_site = LocalSite::read(&mut context.pool()).await?;
   let person_id = local_user_view.person.id;
+  tracing::debug!(target: "api", "API resolve_object person_id {:?} data {:?}", person_id, &data.q);
   check_private_instance(&Some(local_user_view), &local_site)?;
 
   let res = search_query_to_object_id(&data.q, &context)
diff --git a/crates/apub/src/collections/community_featured.rs b/crates/apub/src/collections/community_featured.rs
index b3ee54db6..d7cf8013f 100644
--- a/crates/apub/src/collections/community_featured.rs
+++ b/crates/apub/src/collections/community_featured.rs
@@ -77,9 +77,13 @@ impl Collection for ApubCommunityFeatured {
       async {
         // use separate request counter for each item, otherwise there will be problems with
         // parallel processing
+        tracing::debug!(target: "federation", "apub/collections/community_featured.rs calling verify owner {:?}", _owner);
         let verify = post.verify(data).await;
         if verify.is_ok() {
+          tracing::debug!(target: "federation", "apub/collections/community_featured.rs calling receive owner {:?}", _owner);
           post.receive(data).await.ok();
+        } else {
+          tracing::warn!(target: "federation", "apub/collections/community_featured.rs verify failed owner {:?}", _owner);
         }
       }
     }))
diff --git a/crates/apub/src/collections/community_outbox.rs b/crates/apub/src/collections/community_outbox.rs
index 854db9349..cc3be3ae3 100644
--- a/crates/apub/src/collections/community_outbox.rs
+++ b/crates/apub/src/collections/community_outbox.rs
@@ -98,9 +98,13 @@ impl Collection for ApubCommunityOutbox {
       async {
         // use separate request counter for each item, otherwise there will be problems with
         // parallel processing
+        tracing::debug!(target: "federation", "apub/collections/community_outbox.rs calling verify owner {:?}", _owner);
         let verify = activity.verify(data).await;
         if verify.is_ok() {
+          tracing::debug!(target: "federation", "apub/collections/community_outbox.rs calling receive owner {:?}", _owner);
           activity.receive(data).await.ok();
+        } else {
+          tracing::warn!(target: "federation", "apub/collections/community_outbox.rs verify failed owner {:?}", _owner);
         }
       }
     }))
diff --git a/crates/apub/src/http/mod.rs b/crates/apub/src/http/mod.rs
index 52a014434..565461936 100644
--- a/crates/apub/src/http/mod.rs
+++ b/crates/apub/src/http/mod.rs
@@ -31,6 +31,7 @@ pub async fn shared_inbox(
   body: Bytes,
   data: Data<LemmyContext>,
 ) -> LemmyResult<HttpResponse> {
+  tracing::warn!(target: "federation", "apub/http/mod.rs shared_inbox");
   receive_activity::<SharedInboxActivities, UserOrCommunity, LemmyContext>(request, body, &data)
     .await
 }
@@ -80,6 +81,7 @@ pub(crate) async fn get_activity(
   info: web::Path<ActivityQuery>,
   context: web::Data<LemmyContext>,
 ) -> Result<HttpResponse, LemmyError> {
+  tracing::debug!(target: "federation", "apub/http/mod.rs get_activity start function");
   let settings = context.settings();
   let activity_id = Url::parse(&format!(
     "{}/activities/{}/{}",
@@ -89,6 +91,7 @@ pub(crate) async fn get_activity(
   ))?
   .into();
   let activity = Activity::read_from_apub_id(&mut context.pool(), &activity_id).await?;
+  tracing::debug!(target: "federation", "apub/http/mod.rs get_activity activity_id {}", activity_id);
 
   let sensitive = activity.sensitive;
   if !activity.local {
diff --git a/crates/apub/src/lib.rs b/crates/apub/src/lib.rs
index 8d8186022..d9026eaf7 100644
--- a/crates/apub/src/lib.rs
+++ b/crates/apub/src/lib.rs
@@ -62,6 +62,7 @@ impl UrlVerifier for VerifyUrlData {
 /// - URL not being in the blocklist (if it is active)
 #[tracing::instrument(skip(local_site_data))]
 fn check_apub_id_valid(apub_id: &Url, local_site_data: &LocalSiteData) -> Result<(), &'static str> {
+  // is this a typo? 'apud'?
   let domain = apub_id.domain().expect("apud id has domain").to_string();
 
   if !local_site_data
@@ -138,6 +139,7 @@ pub(crate) async fn check_apub_id_valid_with_strictness(
   is_strict: bool,
   context: &LemmyContext,
 ) -> Result<(), LemmyError> {
+  // is this a typo? 'apud'?
   let domain = apub_id.domain().expect("apud id has domain").to_string();
   let local_instance = context
     .settings()
@@ -170,6 +172,7 @@ pub(crate) async fn check_apub_id_valid_with_strictness(
       .expect("local hostname is valid");
     allowed_and_local.push(local_instance);
 
+    // is this a typo? 'apud'?
     let domain = apub_id.domain().expect("apud id has domain").to_string();
     if !allowed_and_local.contains(&domain) {
       return Err(LemmyErrorType::FederationDisabledByStrictAllowList)?;
@@ -193,7 +196,8 @@ async fn insert_activity<T>(
 where
   T: Serialize,
 {
-  let ap_id = ap_id.clone().into();
+  let ap_id1: lemmy_db_schema::newtypes::DbUrl = ap_id.clone().into();
+  let ap_id: lemmy_db_schema::newtypes::DbUrl = ap_id.clone().into();
   let form = ActivityInsertForm {
     ap_id,
     data: serde_json::to_value(activity)?,
@@ -201,7 +205,14 @@ where
     sensitive: Some(sensitive),
     updated: None,
   };
-  Activity::create(&mut data.pool(), &form).await?;
+
+  tracing::debug!(target: "federation", "apub/lib.rs insert_activity {:?} {:?}", ap_id1, form.data);
+
+  if let Err(e) = Activity::create(&mut data.pool(), &form).await {
+    tracing::warn!(target: "federation", "apub/lib.rs insert_activity ERROR {:?} {:?}", ap_id1, form.data);
+    return Err(e.into());
+  };
+
   Ok(())
 }
 
@@ -214,6 +225,7 @@ pub trait SendActivity: Sync {
     _response: &Self::Response,
     _context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    tracing::debug!(target: "api", "apub/lib.rs send_activity base function");
     Ok(())
   }
 }
diff --git a/crates/apub/src/objects/comment.rs b/crates/apub/src/objects/comment.rs
index 0a3185910..78470294c 100644
--- a/crates/apub/src/objects/comment.rs
+++ b/crates/apub/src/objects/comment.rs
@@ -83,6 +83,7 @@ impl Object for ApubComment {
 
   #[tracing::instrument(skip_all)]
   async fn into_json(self, context: &Data<Self::DataType>) -> Result<Note, LemmyError> {
+    tracing::debug!(target: "federation", "apub/objects/comment.rs ApubComment into_json {:?}", self);
     let creator_id = self.creator_id;
     let creator = Person::read(&mut context.pool(), creator_id).await?;
 
@@ -127,6 +128,7 @@ impl Object for ApubComment {
     expected_domain: &Url,
     context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    tracing::debug!(target: "federation", "apub/objects/comment.rs ApubComment verify {:?}", note);
     verify_domains_match(note.id.inner(), expected_domain)?;
     verify_domains_match(note.attributed_to.inner(), note.id.inner())?;
     verify_is_public(&note.to, &note.cc)?;
@@ -147,6 +149,7 @@ impl Object for ApubComment {
   /// If the parent community, post and comment(s) are not known locally, these are also fetched.
   #[tracing::instrument(skip_all)]
   async fn from_json(note: Note, context: &Data<LemmyContext>) -> Result<ApubComment, LemmyError> {
+    tracing::debug!(target: "federation", "apub/objects/comment.rs ApubComment from_json {:?}", note);
     let creator = note.attributed_to.dereference(context).await?;
     let (post, parent_comment) = note.get_parents(context).await?;
 
diff --git a/crates/apub/src/objects/mod.rs b/crates/apub/src/objects/mod.rs
index b204efb08..0a4b593c1 100644
--- a/crates/apub/src/objects/mod.rs
+++ b/crates/apub/src/objects/mod.rs
@@ -46,6 +46,7 @@ pub(crate) fn read_from_string_or_source_opt(
 pub(crate) fn verify_is_remote_object(id: &Url, settings: &Settings) -> Result<(), LemmyError> {
   let local_domain = settings.get_hostname_without_port()?;
   if id.domain() == Some(&local_domain) {
+    tracing::warn!(target: "federation", "apub/objects/mod.rs verify_is_remote_object {:?}", id.as_str());
     Err(anyhow!("cant accept local object from remote instance").into())
   } else {
     Ok(())
diff --git a/crates/apub/src/objects/post.rs b/crates/apub/src/objects/post.rs
index d252a8ea7..f7b5e5643 100644
--- a/crates/apub/src/objects/post.rs
+++ b/crates/apub/src/objects/post.rs
@@ -49,6 +49,7 @@ use lemmy_utils::{
 };
 use std::ops::Deref;
 use url::Url;
+use tracing::warn;
 
 const MAX_TITLE_LENGTH: usize = 200;
 
@@ -139,21 +140,36 @@ impl Object for ApubPost {
   ) -> Result<(), LemmyError> {
     // We can't verify the domain in case of mod action, because the mod may be on a different
     // instance from the post author.
+    let mut is_mod_path = 0;
     if !page.is_mod_action(context).await? {
+      warn!(target: "federation", "post is_mod_action {:?} vs {:?}", page.id.inner().as_str(), expected_domain.as_str());
       verify_domains_match(page.id.inner(), expected_domain)?;
+      tracing::debug!(target: "federation", "post is_mod_action verify_is_remote_object {:?} user {:?}", page.id.inner().as_str(), expected_domain.as_str());
       verify_is_remote_object(page.id.inner(), context.settings())?;
+      is_mod_path = 1;
     };
 
     let community = page.community(context).await?;
     check_apub_id_valid_with_strictness(page.id.inner(), community.local, context).await?;
     verify_person_in_community(&page.creator()?, &community, context).await?;
 
+    if is_mod_path > 0 {
+      warn!(target: "federation", "post is_mod_action spot_check_A {:?} user {:?}", page.id.inner().as_str(), expected_domain.as_str());
+    }
+
     let local_site_data = local_site_data_cached(&mut context.pool()).await?;
     let slur_regex = &local_site_opt_to_slur_regex(&local_site_data.local_site);
     check_slurs_opt(&page.name, slur_regex)?;
 
+    if is_mod_path > 0 {
+      warn!(target: "federation", "post is_mod_action spot_check_B {:?} user {:?}", page.id.inner().as_str(), expected_domain.as_str());
+    }
+
     verify_domains_match(page.creator()?.inner(), page.id.inner())?;
     verify_is_public(&page.to, &page.cc)?;
+    if is_mod_path > 0 {
+      warn!(target: "federation", "post is_mod_action passed checks {:?} user {:?}", page.id.inner().as_str(), expected_domain.as_str());
+    }
     Ok(())
   }
 
@@ -161,7 +177,9 @@ impl Object for ApubPost {
   async fn from_json(page: Page, context: &Data<Self::DataType>) -> Result<ApubPost, LemmyError> {
     let creator = page.creator()?.dereference(context).await?;
     let community = page.community(context).await?;
+
     if community.posting_restricted_to_mods {
+      warn!(target: "federation", "community posting_restricted_to_mods {:?}", community);
       is_mod_or_admin(&mut context.pool(), creator.id, community.id).await?;
     }
     let mut name = page
diff --git a/crates/db_views/src/post_view.rs b/crates/db_views/src/post_view.rs
index 07433667a..2b6ef4c82 100644
--- a/crates/db_views/src/post_view.rs
+++ b/crates/db_views/src/post_view.rs
@@ -70,6 +70,7 @@ impl PostView {
     my_person_id: Option<PersonId>,
     is_mod_or_admin: Option<bool>,
   ) -> Result<Self, Error> {
+    tracing::debug!(target: "api", "db_view post_view read {}", post_id);
     let conn = &mut get_conn(pool).await?;
 
     // The left join below will return None in this case
@@ -146,15 +147,23 @@ impl PostView {
       ))
       .into_boxed();
 
+    tracing::debug!(target: "api", "db_view post_view read after:into_boxed {}", post_id);
+
     // Hide deleted and removed for non-admins or mods
-    if !is_mod_or_admin.unwrap_or(false) {
-      query = query
-        .filter(community::removed.eq(false))
-        .filter(community::deleted.eq(false))
-        .filter(post::removed.eq(false))
-        .filter(post::deleted.eq(false));
+    // HACK: test if this code is causing the problem with deletes not federating.
+    //   this commit broke federation of deletes? https://github.com/LemmyNet/lemmy/commit/dce79b83bfe4eddbe94a4b3846bc20624ef8e4c4
+    if 1==2 {
+      if !is_mod_or_admin.unwrap_or(false) {
+        query = query
+          .filter(community::removed.eq(false))
+          .filter(community::deleted.eq(false))
+          .filter(post::removed.eq(false))
+          .filter(post::deleted.eq(false));
+      }
     }
 
+    tracing::debug!(target: "api", "db_view post_view read after:is_mod_or_admin.unwrap_or {}", post_id);
+
     let (
       post,
       creator,
@@ -169,6 +178,8 @@ impl PostView {
       unread_comments,
     ) = query.first::<PostViewTuple>(conn).await?;
 
+    tracing::debug!(target: "api", "db_view post_view read after:query.first::PostViewTuple {}", post_id);
+
     // If a person is given, then my_vote, if None, should be 0, not null
     // Necessary to differentiate between other person's votes
     let my_vote = if my_person_id.is_some() && post_like.is_none() {
@@ -177,6 +188,7 @@ impl PostView {
       post_like
     };
 
+    tracing::debug!(target: "api", "db_view post_view read before_Ok {}", post_id);
     Ok(PostView {
       post,
       creator,
diff --git a/crates/utils/src/version.rs b/crates/utils/src/version.rs
index ac0896a3c..87d40a273 100644
--- a/crates/utils/src/version.rs
+++ b/crates/utils/src/version.rs
@@ -1 +1 @@
-pub const VERSION: &str = "unknown version";
+pub const VERSION: &str = "0.18.1-20-g7d8cb93b5";
diff --git a/crates/utils/translations b/crates/utils/translations
index 713ceed9c..3638cde3b 160000
--- a/crates/utils/translations
+++ b/crates/utils/translations
@@ -1 +1 @@
-Subproject commit 713ceed9c7ef84deaa222e68361e670e0763cd83
+Subproject commit 3638cde3b3d59a969872d5f8e65f80faa9d3ab1c
diff --git a/src/api_routes_http.rs b/src/api_routes_http.rs
index cb735f807..511596744 100644
--- a/src/api_routes_http.rs
+++ b/src/api_routes_http.rs
@@ -107,6 +107,7 @@ use lemmy_apub::{
 };
 use lemmy_utils::{rate_limit::RateLimitCell, spawn_try_task, SYNCHRONOUS_FEDERATION};
 use serde::Deserialize;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
 pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
   cfg.service(
@@ -181,7 +182,8 @@ pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimitCell) {
         web::scope("/post")
           .wrap(rate_limit.message())
           .route("", web::get().to(route_get_crud::<GetPost>))
-          .route("", web::put().to(route_post_crud::<EditPost>))
+          // EditPost uses put() delete and remove use post(), but comment works and does same thing.
+          .route("",        web::put().to(route_post_crud::<EditPost>))
           .route("/delete", web::post().to(route_post_crud::<DeletePost>))
           .route("/remove", web::post().to(route_post_crud::<RemovePost>))
           .route(
@@ -381,6 +383,8 @@ where
     + Send
     + 'static,
 {
+  let c: usize = CALL_COUNT1.fetch_add(1, Ordering::SeqCst);
+  tracing::debug!(target: "api", "CCC:C:{} api_routes_http perform", c);
   let res = data.perform(&context).await?;
   let res_clone = res.clone();
   let fed_task = async move { SendActivity::send_activity(&data, &res_clone, &apub_data).await };
@@ -389,6 +393,7 @@ where
   } else {
     spawn_try_task(fed_task);
   }
+  tracing::debug!(target: "api", "CCC:C:{} api_routes_http perform before_Ok", c);
   Ok(HttpResponse::Ok().json(&res))
 }
 
@@ -424,6 +429,9 @@ where
   perform::<Data>(data.0, context, apub_data).await
 }
 
+static CALL_COUNT: AtomicUsize = AtomicUsize::new(0);
+static CALL_COUNT1: AtomicUsize = AtomicUsize::new(0);
+
 async fn perform_crud<'a, Data>(
   data: Data,
   context: web::Data<LemmyContext>,
@@ -437,14 +445,19 @@ where
     + Send
     + 'static,
 {
+  let c: usize = CALL_COUNT.fetch_add(1, Ordering::SeqCst);
+  tracing::debug!(target: "api", "CCC:B:{} api_routes_http perform_crud", c);
   let res = data.perform(&context).await?;
   let res_clone = res.clone();
   let fed_task = async move { SendActivity::send_activity(&data, &res_clone, &apub_data).await };
   if *SYNCHRONOUS_FEDERATION {
+    tracing::debug!(target: "api", "CCC:B:{} api_routes_http perform_crud fed_task.await", c);
     fed_task.await?;
   } else {
+    tracing::debug!(target: "api", "CCC:B:{} api_routes_http perform_crud before_spawn_try_task", c);
     spawn_try_task(fed_task);
   }
+  tracing::debug!(target: "api", "CCC:B:{} api_routes_http perform_crud before_Ok", c);
   Ok(HttpResponse::Ok().json(&res))
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index b50298b05..0be4ccf46 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -216,9 +216,81 @@ pub async fn start_lemmy_server() -> Result<(), LemmyError> {
   Ok(())
 }
 
-pub fn init_logging(opentelemetry_url: &Option<Url>) -> Result<(), LemmyError> {
+
+use tracing::Level;
+use tracing_appender::non_blocking::WorkerGuard;
+use tracing_subscriber::{
+    fmt::{self, writer::MakeWriterExt}
+};
+
+// https://stackoverflow.com/questions/66138104/how-to-write-logs-to-multiple-destinations-conditionally-with-tracing
+
+
+pub fn init_logging(opentelemetry_url: &Option<Url>) -> Result<Vec<Option<WorkerGuard>>, LemmyError> {
   LogTracer::init()?;
 
+  let log_dir = Some("/home/lemmy/logs");
+  // Code may have multiple log files (target tags) in the future, so return an array.
+  let mut guards = Vec::new();
+
+  let file_filter = Targets::new()
+    .with_target("federation", Level::TRACE);
+
+  let file_log = log_dir
+      .map(|p| tracing_appender::non_blocking(tracing_appender::rolling::daily(p, "federation")))
+      .map(|(appender_type, g)| {
+          let guard = Some(g);
+          guards.push(guard);
+          fmt::Layer::new()
+              .with_writer(appender_type.with_max_level(Level::TRACE))
+              .with_ansi(false)
+              .with_filter(file_filter)
+      });
+
+  let file_filter1 = Targets::new()
+    .with_target("misc", Level::TRACE);
+  
+  let file_log1 = log_dir
+      .map(|p| tracing_appender::non_blocking(tracing_appender::rolling::daily(p, "misc")))
+      .map(|(appender_type, g)| {
+          let guard = Some(g);
+          guards.push(guard);
+          fmt::Layer::new()
+              .with_writer(appender_type.with_max_level(Level::TRACE))
+              .with_ansi(false)
+              .with_filter(file_filter1)
+      });
+
+  let file_filter2 = Targets::new()
+    .with_target("api", Level::TRACE);
+  
+  let file_log2 = log_dir
+      .map(|p| tracing_appender::non_blocking(tracing_appender::rolling::daily(p, "api")))
+      .map(|(appender_type, g)| {
+          let guard = Some(g);
+          guards.push(guard);
+          fmt::Layer::new()
+              .with_writer(appender_type.with_max_level(Level::TRACE))
+              .with_ansi(false)
+              .with_filter(file_filter2)
+      });
+
+  // "fedlow" = federation low-level
+  let file_filter3 = Targets::new()
+  .with_target("fedlow", Level::TRACE);
+  
+  let file_log3 = log_dir
+      .map(|p| tracing_appender::non_blocking(tracing_appender::rolling::daily(p, "fedlow.log")))
+      .map(|(appender_type, g)| {
+          let guard = Some(g);
+          guards.push(guard);
+          fmt::Layer::new()
+              .with_writer(appender_type.with_max_level(Level::TRACE))
+              .with_ansi(false)
+              .with_filter(file_filter3)
+      });
+    
+
   let log_description = std::env::var("RUST_LOG").unwrap_or_else(|_| "info".into());
 
   let targets = log_description
@@ -237,7 +309,12 @@ pub fn init_logging(opentelemetry_url: &Option<Url>) -> Result<(), LemmyError> {
 
   let subscriber = Registry::default()
     .with(format_layer)
-    .with(ErrorLayer::default());
+    .with(ErrorLayer::default())
+    .with(file_log)
+    .with(file_log1)
+    .with(file_log2)
+    .with(file_log3)
+    ;
 
   if let Some(_url) = opentelemetry_url {
     #[cfg(feature = "console")]
@@ -248,5 +325,11 @@ pub fn init_logging(opentelemetry_url: &Option<Url>) -> Result<(), LemmyError> {
     set_global_default(subscriber)?;
   }
 
-  Ok(())
+  tracing::warn!("zebracat logging checkpoint A");
+  tracing::info!(target:"federation", "zebracat file logging startup federation");
+  tracing::info!(target:"misc",       "zebracat file logging startup misc");
+  tracing::info!(target:"api",        "zebracat file logging startup api");
+  tracing::info!(target:"fedlow",     "zebracat file logging startup fedlow");
+
+  Ok(guards)
 }
diff --git a/src/main.rs b/src/main.rs
index 5fc03ed02..c24e53580 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,7 +3,7 @@ use lemmy_utils::{error::LemmyError, settings::SETTINGS};
 
 #[tokio::main]
 pub async fn main() -> Result<(), LemmyError> {
-  init_logging(&SETTINGS.opentelemetry_url)?;
+  let _guards = init_logging(&SETTINGS.opentelemetry_url)?;
   #[cfg(not(feature = "embed-pictrs"))]
   start_lemmy_server().await?;
   #[cfg(feature = "embed-pictrs")]

[RocketDerp]

And changes to the lemmy federation project: activitypub_federation = { version = "0.4.5", default-features = false, features = ["actix-web"], path = "../activitypub-federation-rust" }

diff --git a/src/actix_web/inbox.rs b/src/actix_web/inbox.rs
index d4d1abf..a4f60d1 100644
--- a/src/actix_web/inbox.rs
+++ b/src/actix_web/inbox.rs
@@ -10,7 +10,14 @@ use crate::{
 use actix_web::{web::Bytes, HttpRequest, HttpResponse};
 use anyhow::Context;
 use serde::de::DeserializeOwned;
-use tracing::debug;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+
+static CALL_COUNT: AtomicUsize = AtomicUsize::new(0);
+
+fn log_type_of<T>(_: &T, c: usize) {
+    tracing::debug!(target: "fedlow", "CCC:A:{} receive_activity activity type_name is {}", c, std::any::type_name::<T>())
+}
 
 /// Handles incoming activities, verifying HTTP signatures and other checks
 ///
@@ -31,10 +38,13 @@ where
     <ActorT as Object>::Error: From<Error> + From<anyhow::Error>,
     Datatype: Clone,
 {
+    let c: usize = CALL_COUNT.fetch_add(1, Ordering::SeqCst);
+    tracing::debug!(target: "fedlow", "CCC:A:{} receive_activity start of function", c);
     verify_body_hash(request.headers().get("Digest"), &body)?;
 
     let activity: Activity = serde_json::from_slice(&body)
         .with_context(|| format!("deserializing body: {}", String::from_utf8_lossy(&body)))?;
+    log_type_of(&activity, c);
     data.config.verify_url_and_domain(&activity).await?;
     let actor = ObjectId::<ActorT>::from(activity.actor().clone())
         .dereference(data)
@@ -47,9 +57,14 @@ where
         actor.public_key_pem(),
     )?;
 
-    debug!("Receiving activity {}", activity.id().to_string());
+    tracing::info!("Receiving activity {} name: {:?}", activity.id().to_string(), activity.get_name());
+    tracing::debug!(target: "fedlow", "CCC:A:{} receive_activity before:verify {} activity name {} actor {:?} body: {}", c, activity.id().to_string(), activity.get_name(), actor, String::from_utf8_lossy(&body));
     activity.verify(data).await?;
+    tracing::debug!(target: "fedlow", "CCC:A:{} receive_activity before:receive {}", c, activity.id().to_string());
+    log_type_of(&activity, c);
+    log_type_of(&data, c);
     activity.receive(data).await?;
+    tracing::debug!(target: "fedlow", "CCC:A:{} receive_activity after:receive", c);
     Ok(HttpResponse::Ok().finish())
 }
 
diff --git a/src/fetch/object_id.rs b/src/fetch/object_id.rs
index 08c1d07..b566942 100644
--- a/src/fetch/object_id.rs
+++ b/src/fetch/object_id.rs
@@ -150,6 +150,7 @@ where
         let res = fetch_object_http(&self.0, data).await;
 
         if let Err(Error::ObjectDeleted) = &res {
+            tracing::warn!(target: "fedlow", "dereference_from_http found ObjectDeleted {}", &self);
             if let Some(db_object) = db_object {
                 db_object.delete(data).await?;
             }
diff --git a/src/traits.rs b/src/traits.rs
index c6f8741..67005c0 100644
--- a/src/traits.rs
+++ b/src/traits.rs
@@ -127,6 +127,7 @@ pub trait Object: Sized + Debug {
     ///
     /// Called when a `Delete` activity is received, or if fetch returns a `Tombstone` object.
     async fn delete(self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        tracing::debug!(target: "fedlow", "trait Object called with function delete");
         Ok(())
     }
 
@@ -226,6 +227,13 @@ pub trait ActivityHandler {
     /// Should perform validation and possibly write action to the database. In case the activity
     /// has a nested `object` field, must call `object.from_json` handler.
     async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error>;
+
+    /// Called for debugging sanity.
+    ///
+    /// Return the name of the trait.
+    fn get_name(&self) -> &'static str {
+        return std::any::type_name::<Self>();
+    }
 }
 
 /// Trait to allow retrieving common Actor data.

[RocketDerp]

There are changes after Lemmy 0.18.2 that create merge conflicts, so all this logging has to be hand-merged/added.

[RocketDerp]

This logging surgery was focused on trying to identify lemmy_server federation behavior regarding users deleting posts, deleting comments, and editing post and comments (editing works properly, deleting of a post/comment has troubles in 0.18.2).