From: Yingxin Cheng <yingxin.cheng@intel.com>
Date: Tue, 11 May 2021 07:45:27 +0000 (+0800)
Subject: crimson/onode-staged-tree: switch to use seastore logger macros
X-Git-Tag: v17.1.0~2001^2
X-Git-Url: http://git.apps.os.sepia.ceph.com/?a=commitdiff_plain;h=c53464a1ff65e842ab7af47a1d787414d48af435;p=ceph-ci.git

crimson/onode-staged-tree: switch to use seastore logger macros

Signed-off-by: Yingxin Cheng <yingxin.cheng@intel.com>
---

diff --git a/src/crimson/os/seastore/logging.h b/src/crimson/os/seastore/logging.h
index 68805b03c74..9efe5b0e17a 100644
--- a/src/crimson/os/seastore/logging.h
+++ b/src/crimson/os/seastore/logging.h
@@ -17,6 +17,9 @@
 #define DEBUG(...) LOG(debug, __VA_ARGS__)
 #define DEBUGT(...) LOGT(debug, __VA_ARGS__)
 
+#define INFO(...) LOG(info, __VA_ARGS__)
+#define INFOT(...) LOGT(info, __VA_ARGS__)
+
 #define WARN(...) LOG(warn, __VA_ARGS__)
 #define WARNT(...) LOGT(warn, __VA_ARGS__)
 
diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.cc
index 82a12eb1d06..cfede0b511a 100644
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.cc
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.cc
@@ -1,15 +1,11 @@
 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:nil -*-
 // vim: ts=8 sw=2 smarttab
 
+#include "crimson/os/seastore/logging.h"
+
 #include "crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.h"
 #include "crimson/os/seastore/onode_manager/staged-fltree/stages/key_layout.h"
 
-namespace {
-[[maybe_unused]] seastar::logger& logger() {
-  return crimson::get_logger(ceph_subsys_test);
-}
-}
-
 namespace crimson::os::seastore::onode {
 
 FLTreeOnodeManager::contains_onode_ret FLTreeOnodeManager::contains_onode(
@@ -30,15 +26,13 @@ FLTreeOnodeManager::get_onode_ret FLTreeOnodeManager::get_onode(
   Transaction &trans,
   const ghobject_t &hoid)
 {
+  LOG_PREFIX(FLTreeOnodeManager::get_onode);
   return tree.find(
     trans, hoid
-  ).safe_then([this, &hoid](auto cursor)
+  ).safe_then([this, &hoid, &trans, FNAME](auto cursor)
               -> get_onode_ret {
     if (cursor == tree.end()) {
-      logger().debug(
-        "FLTreeOnodeManager::{}: no entry for {}",
-        __func__,
-        hoid);
+      DEBUGT("no entry for {}", trans, hoid);
       return crimson::ct_error::enoent::make();
     }
     auto val = OnodeRef(new FLTreeOnode(cursor.value()));
@@ -58,6 +52,7 @@ FLTreeOnodeManager::get_or_create_onode(
   Transaction &trans,
   const ghobject_t &hoid)
 {
+  LOG_PREFIX(FLTreeOnodeManager::get_or_create_onode);
   if (hoid.hobj.oid.name.length() + hoid.hobj.nspace.length()
       > key_view_t::MAX_NS_OID_LENGTH) {
     return crimson::ct_error::value_too_large::make();
@@ -65,15 +60,12 @@ FLTreeOnodeManager::get_or_create_onode(
   return tree.insert(
     trans, hoid,
     OnodeTree::tree_value_config_t{sizeof(onode_layout_t)}
-  ).safe_then([&trans, &hoid](auto p)
+  ).safe_then([&trans, &hoid, FNAME](auto p)
               -> get_or_create_onode_ret {
     auto [cursor, created] = std::move(p);
     auto val = OnodeRef(new FLTreeOnode(cursor.value()));
     if (created) {
-      logger().debug(
-        "FLTreeOnodeManager::{}: created onode for entry for {}",
-        __func__,
-        hoid);
+      DEBUGT("created onode for entry for {}", trans, hoid);
       val->get_mutable_layout(trans) = onode_layout_t{};
     }
     return seastar::make_ready_future<OnodeRef>(
diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc
index 8e505d66f85..d90ac454f55 100644
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node.cc
@@ -8,20 +8,12 @@
 #include <sstream>
 
 #include "common/likely.h"
-#include "crimson/common/log.h"
+#include "crimson/os/seastore/logging.h"
+
 #include "node_extent_manager.h"
 #include "node_impl.h"
 #include "stages/node_stage_layout.h"
 
-namespace {
-
-seastar::logger& logger()
-{
-  return crimson::get_logger(ceph_subsys_filestore);
-}
-
-}
-
 namespace crimson::os::seastore::onode {
 
 using node_ertr = Node::node_ertr;
@@ -403,24 +395,24 @@ void Node::test_make_destructable(
 
 node_future<> Node::mkfs(context_t c, RootNodeTracker& root_tracker)
 {
+  LOG_PREFIX(OTree::Node::mkfs);
   return LeafNode::allocate_root(c, root_tracker
-  ).safe_then([](auto ret) {
-    logger().info("OTree::Node::Mkfs: allocated root {}",
-                  ret->get_name());
+  ).safe_then([c, FNAME](auto ret) {
+    INFOT("allocated root {}", c.t, ret->get_name());
   });
 }
 
 node_future<Ref<Node>> Node::load_root(context_t c, RootNodeTracker& root_tracker)
 {
+  LOG_PREFIX(OTree::Node::load_root);
   return c.nm.get_super(c.t, root_tracker
-  ).safe_then([c, &root_tracker](auto&& _super) {
+  ).safe_then([c, &root_tracker, FNAME](auto&& _super) {
     auto root_addr = _super->get_root_laddr();
     assert(root_addr != L_ADDR_NULL);
     return Node::load(c, root_addr, true
     ).safe_then([c, _super = std::move(_super),
-                 &root_tracker](auto root) mutable {
-      logger().trace("OTree::Node::LoadRoot: loaded {}",
-                     root->get_name());
+                 &root_tracker, FNAME](auto root) mutable {
+      TRACET("loaded {}", c.t, root->get_name());
       assert(root->impl->field_type() == field_type_t::N0);
       root->as_root(std::move(_super));
       std::ignore = c; // as only used in an assert
@@ -448,15 +440,16 @@ void Node::as_root(Super::URef&& _super)
 
 node_future<> Node::upgrade_root(context_t c)
 {
+  LOG_PREFIX(OTree::Node::upgrade_root);
   assert(is_root());
   assert(impl->is_level_tail());
   assert(impl->field_type() == field_type_t::N0);
   super->do_untrack_root(*this);
   return InternalNode::allocate_root(c, impl->level(), impl->laddr(), std::move(super)
-  ).safe_then([this](auto new_root) {
+  ).safe_then([this, c, FNAME](auto new_root) {
     as_child(search_position_t::end(), new_root);
-    logger().info("OTree::Node::UpgradeRoot: upgraded from {} to {}",
-                  get_name(), new_root->get_name());
+    INFOT("upgraded from {} to {}",
+          c.t, get_name(), new_root->get_name());
   });
 }
 
@@ -502,6 +495,7 @@ node_future<>
 Node::try_merge_adjacent(
     context_t c, bool update_parent_index, Ref<Node>&& this_ref)
 {
+  LOG_PREFIX(OTree::Node::try_merge_adjacent);
   assert(this == this_ref.get());
   impl->validate_non_empty();
   assert(!is_root());
@@ -517,7 +511,7 @@ Node::try_merge_adjacent(
   }
 
   return parent_info().ptr->get_child_peers(c, parent_info().position
-  ).safe_then([c, this_ref = std::move(this_ref), this,
+  ).safe_then([c, this_ref = std::move(this_ref), this, FNAME,
                update_parent_index] (auto lr_nodes) mutable -> node_future<> {
     auto& [lnode, rnode] = lr_nodes;
     Ref<Node> left_for_merge;
@@ -565,10 +559,10 @@ Node::try_merge_adjacent(
         } else {
           update_index_after_merge = update_parent_index;
         }
-        logger().info("OTree::Node::MergeAdjacent: merge {} and {} "
-                      "at merge_stage={}, merge_size={}B, update_index={}, is_left={} ...",
-                      left_for_merge->get_name(), right_for_merge->get_name(),
-                      merge_stage, merge_size, update_index_after_merge, is_left);
+        INFOT("merge {} and {} at merge_stage={}, merge_size={}B, "
+              "update_index={}, is_left={} ...",
+              c.t, left_for_merge->get_name(), right_for_merge->get_name(),
+              merge_stage, merge_size, update_index_after_merge, is_left);
         // we currently cannot generate delta depends on another extent content,
         // so use rebuild_extent() as a workaround to rebuild the node from a
         // fresh extent, thus no need to generate delta.
@@ -658,7 +652,8 @@ node_future<Ref<Node>> Node::load(
 
 node_future<NodeExtentMutable> Node::rebuild_extent(context_t c)
 {
-  logger().debug("OTree::Node::Rebuild: {} ...", get_name());
+  LOG_PREFIX(OTree::Node::rebuild_extent);
+  DEBUGT("{} ...", c.t, get_name());
   assert(!is_root());
   // assume I'm already ref counted by caller
 
@@ -669,7 +664,8 @@ node_future<NodeExtentMutable> Node::rebuild_extent(context_t c)
 
 node_future<> Node::retire(context_t c, Ref<Node>&& this_ref)
 {
-  logger().debug("OTree::Node::Retire: {} ...", get_name());
+  LOG_PREFIX(OTree::Node::retire);
+  DEBUGT("{} ...", c.t, get_name());
   assert(this_ref.get() == this);
   assert(!is_tracking());
   assert(!super);
@@ -683,9 +679,10 @@ node_future<> Node::retire(context_t c, Ref<Node>&& this_ref)
 
 void Node::make_tail(context_t c)
 {
+  LOG_PREFIX(OTree::Node::make_tail);
   assert(!impl->is_level_tail());
   assert(!impl->is_keys_empty());
-  logger().debug("OTree::Node::MakeTail: {} ...", get_name());
+  DEBUGT("{} ...", c.t, get_name());
   impl->prepare_mutate(c);
   auto tail_pos = impl->make_tail();
   if (impl->node_type() == node_type_t::INTERNAL) {
@@ -731,6 +728,7 @@ node_future<> InternalNode::apply_child_split(
     context_t c, Ref<Node>&& left_child, Ref<Node>&& right_child,
     bool update_right_index)
 {
+  LOG_PREFIX(OTree::InternalNode::apply_child_split);
   auto& left_pos = left_child->parent_info().position;
 
 #ifndef NDEBUG
@@ -745,10 +743,9 @@ node_future<> InternalNode::apply_child_split(
 
   impl->prepare_mutate(c);
 
-  logger().debug("OTree::Internal::ApplyChildSplit: apply {}'s child "
-                 "{} to split to {}, update_index={} ...",
-                 get_name(), left_child->get_name(),
-                 right_child->get_name(), update_right_index);
+  DEBUGT("apply {}'s child {} to split to {}, update_index={} ...",
+         c.t, get_name(), left_child->get_name(),
+         right_child->get_name(), update_right_index);
 
   // update layout from left_pos => left_child_addr to right_child_addr
   auto left_child_addr = left_child->impl->laddr();
@@ -791,6 +788,7 @@ node_future<> InternalNode::apply_child_split(
 
 node_future<> InternalNode::erase_child(context_t c, Ref<Node>&& child_ref)
 {
+  LOG_PREFIX(OTree::InternalNode::erase_child);
   // this is a special version of recursive merge
   impl->validate_non_empty();
   assert(child_ref->use_count() == 1);
@@ -809,15 +807,14 @@ node_future<> InternalNode::erase_child(context_t c, Ref<Node>&& child_ref)
     } else {
       return node_ertr::make_ready_future<Ref<Node>>();
     }
-  }).safe_then([c, this, child_ref = std::move(child_ref)]
+  }).safe_then([c, this, child_ref = std::move(child_ref), FNAME]
                (auto&& new_tail_child) mutable {
     auto child_pos = child_ref->parent_info().position;
     if (new_tail_child) {
-      logger().info("OTree::Internal::EraseChild: erase {}'s child {} at pos({}), "
-                    "and fix new child tail {} at pos({}) ...",
-                    get_name(), child_ref->get_name(), child_pos,
-                    new_tail_child->get_name(),
-                    new_tail_child->parent_info().position);
+      INFOT("erase {}'s child {} at pos({}), "
+            "and fix new child tail {} at pos({}) ...",
+            c.t, get_name(), child_ref->get_name(), child_pos,
+            new_tail_child->get_name(), new_tail_child->parent_info().position);
       assert(!new_tail_child->impl->is_level_tail());
       new_tail_child->make_tail(c);
       assert(new_tail_child->impl->is_level_tail());
@@ -826,21 +823,21 @@ node_future<> InternalNode::erase_child(context_t c, Ref<Node>&& child_ref)
         new_tail_child.reset();
       }
     } else {
-      logger().info("OTree::Internal::EraseChild: erase {}'s child {} at pos({}) ...",
-                    get_name(), child_ref->get_name(), child_pos);
+      INFOT("erase {}'s child {} at pos({}) ...",
+            c.t, get_name(), child_ref->get_name(), child_pos);
     }
 
     do_untrack_child(*child_ref);
     Ref<Node> this_ref = this;
     child_ref->_parent_info.reset();
     return child_ref->retire(c, std::move(child_ref)
-    ).safe_then([c, this, child_pos, this_ref = std::move(this_ref)] () mutable {
+    ).safe_then([c, this, child_pos, FNAME,
+                 this_ref = std::move(this_ref)] () mutable {
       if ((impl->is_level_tail() && impl->is_keys_empty()) ||
           (!impl->is_level_tail() && impl->is_keys_one())) {
         // there is only one value left
         // fast path without mutating the extent
-        logger().debug("OTree::Internal::EraseChild: {} has one value left, erase ...",
-                       get_name());
+        DEBUGT("{} has one value left, erase ...", c.t, get_name());
 #ifndef NDEBUG
         if (impl->is_level_tail()) {
           assert(child_pos.is_end());
@@ -914,6 +911,7 @@ template <bool FORCE_MERGE>
 node_future<> InternalNode::fix_index(
     context_t c, Ref<Node>&& child, bool check_downgrade)
 {
+  LOG_PREFIX(OTree::InternalNode::fix_index);
   impl->validate_non_empty();
 
   auto& child_pos = child->parent_info().position;
@@ -924,9 +922,8 @@ node_future<> InternalNode::fix_index(
   impl->prepare_mutate(c);
 
   key_view_t new_key = *child->impl->get_pivot_index();
-  logger().debug("OTree::Internal::FixIndex: fix {}'s index of child {} at pos({}), "
-                 "new_key={} ...",
-                 get_name(), child->get_name(), child_pos, new_key);
+  DEBUGT("fix {}'s index of child {} at pos({}), new_key={} ...",
+         c.t, get_name(), child->get_name(), child_pos, new_key);
 
   // erase the incorrect item
   auto [erase_stage, next_pos] = impl->erase(child_pos);
@@ -977,14 +974,15 @@ node_future<> InternalNode::apply_children_merge(
     context_t c, Ref<Node>&& left_child, laddr_t origin_left_addr,
     Ref<Node>&& right_child, bool update_index)
 {
+  LOG_PREFIX(OTree::InternalNode::apply_children_merge);
   auto left_pos = left_child->parent_info().position;
   auto left_addr = left_child->impl->laddr();
   auto& right_pos = right_child->parent_info().position;
   auto right_addr = right_child->impl->laddr();
-  logger().debug("OTree::Internal::ApplyChildMerge: apply {}'s child {} (was {:#x}) "
-                 "at pos({}), to merge with {} at pos({}), update_index={} ...",
-                 get_name(), left_child->get_name(), origin_left_addr, left_pos,
-                 right_child->get_name(), right_pos, update_index);
+  DEBUGT("apply {}'s child {} (was {:#x}) at pos({}), "
+         "to merge with {} at pos({}), update_index={} ...",
+         c.t, get_name(), left_child->get_name(), origin_left_addr, left_pos,
+         right_child->get_name(), right_pos, update_index);
 
 #ifndef NDEBUG
   assert(left_child->parent_info().ptr == this);
@@ -1315,6 +1313,7 @@ node_future<> InternalNode::test_clone_root(
 node_future<> InternalNode::try_downgrade_root(
     context_t c, Ref<Node>&& this_ref)
 {
+  LOG_PREFIX(OTree::InternalNode::try_downgrade_root);
   assert(this_ref.get() == this);
   assert(is_root());
   assert(impl->is_level_tail());
@@ -1326,9 +1325,10 @@ node_future<> InternalNode::try_downgrade_root(
   // proceed downgrade root to the only child
   laddr_t child_addr = impl->get_tail_value()->value;
   return get_or_track_child(c, search_position_t::end(), child_addr
-  ).safe_then([c, this, this_ref = std::move(this_ref)] (auto child) mutable {
-    logger().info("OTree::Internal::DownGradeRoot: downgrade {} to new root {}",
-                  get_name(), child->get_name());
+  ).safe_then([c, this, FNAME,
+               this_ref = std::move(this_ref)] (auto child) mutable {
+    INFOT("downgrade {} to new root {}",
+          c.t, get_name(), child->get_name());
     // Invariant, see InternalNode::erase_child()
     // the new internal root should have at least 2 children.
     assert(child->impl->is_level_tail());
@@ -1352,6 +1352,7 @@ node_future<Ref<InternalNode>> InternalNode::insert_or_split(
     Ref<Node> insert_child,
     Ref<Node> outdated_child)
 {
+  LOG_PREFIX(OTree::InternalNode::insert_or_split);
   // XXX: check the insert_child is unlinked from this node
 #ifndef NDEBUG
   auto _insert_key = *insert_child->impl->get_pivot_index();
@@ -1359,11 +1360,10 @@ node_future<Ref<InternalNode>> InternalNode::insert_or_split(
 #endif
   auto insert_value = insert_child->impl->laddr();
   auto insert_pos = pos;
-  logger().debug("OTree::Internal::InsertSplit: insert {} "
-                 "with insert_key={}, insert_child={}, insert_pos({}), "
-                 "outdated_child={} ...",
-                 get_name(), insert_key, insert_child->get_name(),
-                 insert_pos, (outdated_child ? "True" : "False"));
+  DEBUGT("insert {} with insert_key={}, insert_child={}, insert_pos({}), "
+         "outdated_child={} ...",
+         c.t, get_name(), insert_key, insert_child->get_name(),
+         insert_pos, (outdated_child ? "True" : "False"));
   auto [insert_stage, insert_size] = impl->evaluate_insert(
       insert_key, insert_value, insert_pos);
   auto free_size = impl->free_size();
@@ -1398,14 +1398,14 @@ node_future<Ref<InternalNode>> InternalNode::insert_or_split(
         c, impl->field_type(), impl->is_level_tail(), impl->level());
   }).safe_then([this, insert_key, insert_child, insert_pos,
                 insert_stage=insert_stage, insert_size=insert_size,
-                outdated_child](auto fresh_right) mutable {
+                outdated_child, c, FNAME](auto fresh_right) mutable {
     // I'm the left_node and need to split into the right_node
     auto right_node = fresh_right.node;
-    logger().info("OTree::Internal::InsertSplit: proceed split {} to fresh {} "
-                  "with insert_child={}, outdated_child={} ...",
-                  get_name(), right_node->get_name(),
-                  insert_child->get_name(),
-                  (outdated_child ? outdated_child->get_name() : "N/A"));
+    INFOT("proceed split {} to fresh {} with insert_child={},"
+          " outdated_child={} ...",
+          c.t, get_name(), right_node->get_name(),
+          insert_child->get_name(),
+          (outdated_child ? outdated_child->get_name() : "N/A"));
     auto insert_value = insert_child->impl->laddr();
     auto [split_pos, is_insert_left, p_value] = impl->split_insert(
         fresh_right.mut, *right_node->impl, insert_key, insert_value,
@@ -1442,20 +1442,21 @@ node_future<Ref<InternalNode>> InternalNode::insert_or_split(
 node_future<Ref<Node>> InternalNode::get_or_track_child(
     context_t c, const search_position_t& position, laddr_t child_addr)
 {
+  LOG_PREFIX(OTree::InternalNode::get_or_track_child);
   bool level_tail = position.is_end();
   Ref<Node> child;
   auto found = tracked_child_nodes.find(position);
   Ref<Node> this_ref = this;
   return (found == tracked_child_nodes.end()
     ? (Node::load(c, child_addr, level_tail
-       ).safe_then([this, position] (auto child) {
+       ).safe_then([this, position, c, FNAME] (auto child) {
          child->as_child(position, this);
-         logger().trace("OTree::Internal::GetTrackChild: loaded child untracked {} at pos({})",
-                        child->get_name(), position);
+         TRACET("loaded child untracked {} at pos({})",
+                c.t, child->get_name(), position);
          return child;
        }))
-    : (logger().trace("OTree::Internal::GetTrackChild: loaded child tracked {} at pos({})",
-                      found->second->get_name(), position),
+    : (TRACET("loaded child tracked {} at pos({})",
+              c.t, found->second->get_name(), position),
        node_ertr::make_ready_future<Ref<Node>>(found->second))
   ).safe_then([this_ref, this, position, child_addr] (auto child) {
     assert(child_addr == child->impl->laddr());
@@ -1694,11 +1695,12 @@ template <bool FORCE_MERGE>
 node_future<Ref<tree_cursor_t>>
 LeafNode::erase(context_t c, const search_position_t& pos, bool get_next)
 {
+  LOG_PREFIX(OTree::LeafNode::erase);
   assert(!pos.is_end());
   assert(!impl->is_keys_empty());
   Ref<Node> this_ref = this;
-  logger().debug("OTree::Leaf::Erase: erase {}'s pos({}), get_next={} ...",
-                 get_name(), pos, get_next);
+  DEBUGT("erase {}'s pos({}), get_next={} ...",
+         c.t, get_name(), pos, get_next);
 
   // get the next cursor
   return node_ertr::now().safe_then([c, &pos, get_next, this] {
@@ -1708,13 +1710,14 @@ LeafNode::erase(context_t c, const search_position_t& pos, bool get_next)
       return node_ertr::make_ready_future<Ref<tree_cursor_t>>();
     }
   }).safe_then([c, &pos, this_ref = std::move(this_ref),
-                this] (Ref<tree_cursor_t> next_cursor) {
+                this, FNAME] (Ref<tree_cursor_t> next_cursor) {
     if (next_cursor && next_cursor->is_end()) {
       // reset the node reference from the end cursor
       next_cursor.reset();
     }
     return node_ertr::now(
-    ).safe_then([c, &pos, this_ref = std::move(this_ref), this] () mutable {
+    ).safe_then([c, &pos, this_ref = std::move(this_ref),
+                 this, FNAME] () mutable {
 #ifndef NDEBUG
       assert(!impl->is_keys_empty());
       if (impl->is_keys_one()) {
@@ -1725,8 +1728,7 @@ LeafNode::erase(context_t c, const search_position_t& pos, bool get_next)
         // we need to keep the root as an empty leaf node
         // fast path without mutating the extent
         // track_erase
-        logger().debug("OTree::Leaf::Erase: {} has one value left, erase ...",
-                       get_name());
+        DEBUGT("{} has one value left, erase ...", c.t, get_name());
         assert(tracked_cursors.size() == 1);
         auto iter = tracked_cursors.begin();
         assert(iter->first == pos);
@@ -1916,15 +1918,15 @@ node_future<Ref<tree_cursor_t>> LeafNode::insert_value(
     const search_position_t& pos, const MatchHistory& history,
     match_stat_t mstat)
 {
+  LOG_PREFIX(OTree::LeafNode::insert_value);
 #ifndef NDEBUG
   if (pos.is_end()) {
     assert(impl->is_level_tail());
   }
 #endif
-  logger().debug("OTree::Leaf::InsertValue: insert {} "
-                 "with insert_key={}, insert_value={}, insert_pos({}), "
-                 "history={}, mstat({}) ...",
-                 get_name(), key, vconf, pos, history, mstat);
+  DEBUGT("insert {} with insert_key={}, insert_value={}, insert_pos({}), "
+         "history={}, mstat({}) ...",
+         c.t, get_name(), key, vconf, pos, history, mstat);
   search_position_t insert_pos = pos;
   auto [insert_stage, insert_size] = impl->evaluate_insert(
       key, vconf, history, mstat, insert_pos);
@@ -1946,11 +1948,11 @@ node_future<Ref<tree_cursor_t>> LeafNode::insert_value(
   return (is_root() ? upgrade_root(c) : node_ertr::now()
   ).safe_then([this, c] {
     return LeafNode::allocate(c, impl->field_type(), impl->is_level_tail());
-  }).safe_then([this_ref = std::move(this_ref), this, c, &key, vconf,
+  }).safe_then([this_ref = std::move(this_ref), this, c, &key, vconf, FNAME,
                 insert_pos, insert_stage=insert_stage, insert_size=insert_size](auto fresh_right) mutable {
     auto right_node = fresh_right.node;
-    logger().info("OTree::Leaf::InsertValue: proceed split {} to fresh {} ...",
-                  get_name(), right_node->get_name());
+    INFOT("proceed split {} to fresh {} ...",
+          c.t, get_name(), right_node->get_name());
     // no need to bump version for right node, as it is fresh
     on_layout_change();
     impl->prepare_mutate(c);
diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h
index db93d9570a9..b72759f9afd 100644
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_accessor.h
@@ -3,7 +3,8 @@
 
 #pragma once
 
-#include "crimson/common/log.h"
+#include "crimson/os/seastore/logging.h"
+
 #include "node_extent_manager.h"
 #include "node_delta_recorder.h"
 #include "node_layout_replayable.h"
@@ -110,6 +111,7 @@ class DeltaRecorderT final: public DeltaRecorder {
   void apply_delta(ceph::bufferlist::const_iterator& delta,
                    NodeExtentMutable& node,
                    laddr_t node_laddr) override {
+    LOG_PREFIX(OTree::Extent::Replay);
     assert(is_empty());
     node_stage_t stage(reinterpret_cast<const FieldType*>(node.get_read()));
     node_delta_op_t op;
@@ -117,7 +119,7 @@ class DeltaRecorderT final: public DeltaRecorder {
       ceph::decode(op, delta);
       switch (op) {
       case node_delta_op_t::INSERT: {
-        logger().debug("OTree::Extent::Replay: decoding INSERT ...");
+        DEBUG("decoding INSERT ...");
         auto key = key_hobj_t::decode(delta);
         auto value = decode_value(delta);
         auto insert_pos = position_t::decode(delta);
@@ -125,22 +127,22 @@ class DeltaRecorderT final: public DeltaRecorder {
         ceph::decode(insert_stage, delta);
         node_offset_t insert_size;
         ceph::decode(insert_size, delta);
-        logger().debug("OTree::Extent::Replay: apply {}, {}, "
-                       "insert_pos({}), insert_stage={}, insert_size={}B ...",
-                       key, value, insert_pos, insert_stage, insert_size);
+        DEBUG("apply {}, {}, insert_pos({}), insert_stage={}, "
+              "insert_size={}B ...",
+              key, value, insert_pos, insert_stage, insert_size);
         layout_t::template insert<KeyT::HOBJ>(
           node, stage, key, value, insert_pos, insert_stage, insert_size);
         break;
       }
       case node_delta_op_t::SPLIT: {
-        logger().debug("OTree::Extent::Replay: decoding SPLIT ...");
+        DEBUG("decoding SPLIT ...");
         auto split_at = StagedIterator::decode(stage.p_start(), delta);
-        logger().debug("OTree::Extent::Replay: apply split_at={} ...", split_at);
+        DEBUG("apply split_at={} ...", split_at);
         layout_t::split(node, stage, split_at);
         break;
       }
       case node_delta_op_t::SPLIT_INSERT: {
-        logger().debug("OTree::Extent::Replay: decoding SPLIT_INSERT ...");
+        DEBUG("decoding SPLIT_INSERT ...");
         auto split_at = StagedIterator::decode(stage.p_start(), delta);
         auto key = key_hobj_t::decode(delta);
         auto value = decode_value(delta);
@@ -149,47 +151,45 @@ class DeltaRecorderT final: public DeltaRecorder {
         ceph::decode(insert_stage, delta);
         node_offset_t insert_size;
         ceph::decode(insert_size, delta);
-        logger().debug("OTree::Extent::Replay: apply split_at={}, {}, {}, "
-                       "insert_pos({}), insert_stage={}, insert_size={}B ...",
-                       split_at, key, value, insert_pos, insert_stage, insert_size);
+        DEBUG("apply split_at={}, {}, {}, insert_pos({}), insert_stage={}, "
+              "insert_size={}B ...",
+              split_at, key, value, insert_pos, insert_stage, insert_size);
         layout_t::template split_insert<KeyT::HOBJ>(
           node, stage, split_at, key, value, insert_pos, insert_stage, insert_size);
         break;
       }
       case node_delta_op_t::UPDATE_CHILD_ADDR: {
-        logger().debug("OTree::Extent::Replay: decoding UPDATE_CHILD_ADDR ...");
+        DEBUG("decoding UPDATE_CHILD_ADDR ...");
         laddr_t new_addr;
         ceph::decode(new_addr, delta);
         node_offset_t update_offset;
         ceph::decode(update_offset, delta);
         auto p_addr = reinterpret_cast<laddr_packed_t*>(
             node.get_write() + update_offset);
-        logger().debug("OTree::Extent::Replay: apply {:#x} to offset {:#x} ...",
-                       new_addr, update_offset);
+        DEBUG("apply {:#x} to offset {:#x} ...",
+              new_addr, update_offset);
         layout_t::update_child_addr(node, new_addr, p_addr);
         break;
       }
       case node_delta_op_t::ERASE: {
-        logger().debug("OTree::Extent::Replay: decoding ERASE ...");
+        DEBUG("decoding ERASE ...");
         auto erase_pos = position_t::decode(delta);
-        logger().debug("OTree::Extent::Replay: apply erase_pos({}) ...",
-                       erase_pos);
+        DEBUG("apply erase_pos({}) ...", erase_pos);
         layout_t::erase(node, stage, erase_pos);
         break;
       }
       case node_delta_op_t::MAKE_TAIL: {
-        logger().debug("OTree::Extent::Replay: decoded MAKE_TAIL, apply ...");
+        DEBUG("decoded MAKE_TAIL, apply ...");
         layout_t::make_tail(node, stage);
         break;
       }
       case node_delta_op_t::SUBOP_UPDATE_VALUE: {
-        logger().debug("OTree::Extent::Replay: decoding SUBOP_UPDATE_VALUE ...");
+        DEBUG("decoding SUBOP_UPDATE_VALUE ...");
         node_offset_t value_header_offset;
         ceph::decode(value_header_offset, delta);
         auto p_header = node.get_read() + value_header_offset;
         auto p_header_ = reinterpret_cast<const value_header_t*>(p_header);
-        logger().debug("OTree::Extent::Replay: update {} at {:#x} ...",
-                       *p_header_, value_header_offset);
+        DEBUG("update {} at {:#x} ...", *p_header_, value_header_offset);
         auto payload_mut = p_header_->get_payload_mutable(node);
         auto value_addr = node_laddr + payload_mut.get_node_offset();
         get_value_replayer(p_header_->magic)->apply_value_delta(
@@ -197,13 +197,13 @@ class DeltaRecorderT final: public DeltaRecorder {
         break;
       }
       default:
-        logger().error("OTree::Extent::Replay: got unknown op {} when replay {:#x}",
-                       op, node_laddr);
+        ERROR("got unknown op {} when replay {:#x}",
+              op, node_laddr);
         ceph_abort();
       }
     } catch (buffer::error& e) {
-      logger().error("OTree::Extent::Replay: got decode error {} when replay {:#x}",
-                     e, node_laddr);
+      ERROR("got decode error {} when replay {:#x}",
+            e, node_laddr);
       ceph_abort();
     }
   }
@@ -254,10 +254,6 @@ class DeltaRecorderT final: public DeltaRecorder {
     }
   }
 
-  static seastar::logger& logger() {
-    return crimson::get_logger(ceph_subsys_filestore);
-  }
-
   std::unique_ptr<ValueDeltaRecorder> value_replayer;
 };
 
@@ -498,6 +494,7 @@ class NodeExtentAccessorT {
 
   using ertr = NodeExtentManager::tm_ertr;
   ertr::future<NodeExtentMutable> rebuild(context_t c) {
+    LOG_PREFIX(OTree::Extent::rebuild);
     assert(extent->is_valid());
     if (state == nextent_state_t::FRESH) {
       assert(extent->is_initial_pending());
@@ -506,9 +503,9 @@ class NodeExtentAccessorT {
     }
     assert(!extent->is_initial_pending());
     return c.nm.alloc_extent(c.t, node_stage_t::EXTENT_SIZE
-    ).safe_then([this, c] (auto fresh_extent) {
-      logger().debug("OTree::Extent::Rebuild: update addr from {:#x} to {:#x} ...",
-                     extent->get_laddr(), fresh_extent->get_laddr());
+    ).safe_then([this, c, FNAME] (auto fresh_extent) {
+      DEBUGT("update addr from {:#x} to {:#x} ...",
+             c.t, extent->get_laddr(), fresh_extent->get_laddr());
       assert(fresh_extent->is_initial_pending());
       assert(fresh_extent->get_recorder() == nullptr);
       assert(extent->get_length() == fresh_extent->get_length());
@@ -535,10 +532,6 @@ class NodeExtentAccessorT {
   }
 
  private:
-  static seastar::logger& logger() {
-    return crimson::get_logger(ceph_subsys_filestore);
-  }
-
   NodeExtentRef extent;
   node_stage_t node_stage;
   nextent_state_t state;
diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/dummy.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/dummy.h
index 297cd98b7c0..32c09d23248 100644
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/dummy.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/dummy.h
@@ -7,8 +7,8 @@
 #include <seastar/core/sleep.hh>
 
 #include "include/buffer_raw.h"
+#include "crimson/os/seastore/logging.h"
 
-#include "crimson/common/log.h"
 #include "crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h"
 
 /**
@@ -26,14 +26,12 @@ class DummySuper final: public Super {
   ~DummySuper() override = default;
  protected:
   laddr_t get_root_laddr() const override { return *p_root_laddr; }
-  void write_root_laddr(context_t, laddr_t addr) override {
-    logger().debug("OTree::Dummy: update root {:#x} ...", addr);
+  void write_root_laddr(context_t c, laddr_t addr) override {
+    LOG_PREFIX(OTree::Dummy);
+    DEBUGT("update root {:#x} ...", c.t, addr);
     *p_root_laddr = addr;
   }
  private:
-  static seastar::logger& logger() {
-    return crimson::get_logger(ceph_subsys_filestore);
-  }
   laddr_t* p_root_laddr;
 };
 
@@ -78,7 +76,7 @@ class DummyNodeExtentManager final: public NodeExtentManager {
 
   tm_future<NodeExtentRef> read_extent(
       Transaction& t, laddr_t addr, extent_len_t len) override {
-    logger().trace("OTree::Dummy: reading {}B at {:#x} ...", len, addr);
+    TRACET("reading {}B at {:#x} ...", t, len, addr);
     if constexpr (SYNC) {
       return read_extent_sync(t, addr, len);
     } else {
@@ -91,7 +89,7 @@ class DummyNodeExtentManager final: public NodeExtentManager {
 
   tm_future<NodeExtentRef> alloc_extent(
       Transaction& t, extent_len_t len) override {
-    logger().trace("OTree::Dummy: allocating {}B ...", len);
+    TRACET("allocating {}B ...", t, len);
     if constexpr (SYNC) {
       return alloc_extent_sync(t, len);
     } else {
@@ -104,8 +102,8 @@ class DummyNodeExtentManager final: public NodeExtentManager {
 
   tm_future<> retire_extent(
       Transaction& t, NodeExtentRef extent) override {
-    logger().trace("OTree::Dummy: retiring {}B at {:#x} ...",
-                   extent->get_length(), extent->get_laddr());
+    TRACET("retiring {}B at {:#x} ...",
+           t, extent->get_length(), extent->get_laddr());
     if constexpr (SYNC) {
       return retire_extent_sync(t, extent);
     } else {
@@ -118,7 +116,7 @@ class DummyNodeExtentManager final: public NodeExtentManager {
 
   tm_future<Super::URef> get_super(
       Transaction& t, RootNodeTracker& tracker) override {
-    logger().trace("OTree::Dummy: get root ...");
+    TRACET("get root ...", t);
     if constexpr (SYNC) {
       return get_super_sync(t, tracker);
     } else {
@@ -139,8 +137,7 @@ class DummyNodeExtentManager final: public NodeExtentManager {
     auto iter = allocate_map.find(addr);
     assert(iter != allocate_map.end());
     auto extent = iter->second;
-    logger().trace("OTree::Dummy: read {}B at {:#x}",
-                   extent->get_length(), extent->get_laddr());
+    TRACET("read {}B at {:#x}", t, extent->get_length(), extent->get_laddr());
     assert(extent->get_laddr() == addr);
     assert(extent->get_length() == len);
     return tm_ertr::make_ready_future<NodeExtentRef>(extent);
@@ -156,8 +153,7 @@ class DummyNodeExtentManager final: public NodeExtentManager {
     extent->set_laddr(addr);
     assert(allocate_map.find(extent->get_laddr()) == allocate_map.end());
     allocate_map.insert({extent->get_laddr(), extent});
-    logger().debug("OTree::Dummy: allocated {}B at {:#x}",
-                   extent->get_length(), extent->get_laddr());
+    DEBUGT("allocated {}B at {:#x}", t, extent->get_length(), extent->get_laddr());
     assert(extent->get_length() == len);
     return tm_ertr::make_ready_future<NodeExtentRef>(extent);
   }
@@ -171,20 +167,18 @@ class DummyNodeExtentManager final: public NodeExtentManager {
     auto iter = allocate_map.find(addr);
     assert(iter != allocate_map.end());
     allocate_map.erase(iter);
-    logger().debug("OTree::Dummy: retired {}B at {:#x}", len, addr);
+    DEBUGT("retired {}B at {:#x}", t, len, addr);
     return tm_ertr::now();
   }
 
   tm_future<Super::URef> get_super_sync(
       Transaction& t, RootNodeTracker& tracker) {
-    logger().trace("OTree::Dummy: got root {:#x}", root_laddr);
+    TRACET("got root {:#x}", t, root_laddr);
     return tm_ertr::make_ready_future<Super::URef>(
         Super::URef(new DummySuper(t, tracker, &root_laddr)));
   }
 
-  static seastar::logger& logger() {
-    return crimson::get_logger(ceph_subsys_filestore);
-  }
+  static LOG_PREFIX(OTree::Dummy);
 
   std::map<laddr_t, Ref<DummyNodeExtent>> allocate_map;
   laddr_t root_laddr = L_ADDR_NULL;
diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.cc b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.cc
index 037311619c3..57bb50dc1cb 100644
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.cc
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.cc
@@ -7,12 +7,7 @@
 #include "crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage_layout.h"
 
 namespace {
-
-seastar::logger& logger()
-{
-  return crimson::get_logger(ceph_subsys_filestore);
-}
-
+LOG_PREFIX(OTree::Seastore);
 }
 
 namespace crimson::os::seastore::onode {
@@ -51,7 +46,7 @@ static DeltaRecorderURef create_replay_recorder(
 
 void SeastoreSuper::write_root_laddr(context_t c, laddr_t addr)
 {
-  logger().debug("OTree::Seastore: update root {:#x} ...", addr);
+  DEBUGT("update root {:#x} ...", c.t, addr);
   root_addr = addr;
   auto nm = static_cast<SeastoreNodeExtentManager*>(&c.nm);
   nm->get_tm().write_onode_root(c.t, addr);
@@ -60,7 +55,7 @@ void SeastoreSuper::write_root_laddr(context_t c, laddr_t addr)
 NodeExtentRef SeastoreNodeExtent::mutate(
     context_t c, DeltaRecorderURef&& _recorder)
 {
-  logger().debug("OTree::Seastore: mutate {:#x} ...", get_laddr());
+  DEBUGT("mutate {:#x} ...", c.t, get_laddr());
   auto nm = static_cast<SeastoreNodeExtentManager*>(&c.nm);
   auto extent = nm->get_tm().get_mutable_extent(c.t, this);
   auto ret = extent->cast<SeastoreNodeExtent>();
@@ -73,7 +68,7 @@ NodeExtentRef SeastoreNodeExtent::mutate(
 
 void SeastoreNodeExtent::apply_delta(const ceph::bufferlist& bl)
 {
-  logger().debug("OTree::Seastore: replay {:#x} ...", get_laddr());
+  DEBUG("replay {:#x} ...", get_laddr());
   if (!recorder) {
     auto [node_type, field_type] = get_types();
     recorder = create_replay_recorder(node_type, field_type);
diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.h
index 5adb708c8cc..baef71ff4df 100644
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager/seastore.h
@@ -3,7 +3,8 @@
 
 #pragma once
 
-#include "crimson/common/log.h"
+#include "crimson/os/seastore/logging.h"
+
 #include "crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h"
 #include "crimson/os/seastore/onode_manager/staged-fltree/node_delta_recorder.h"
 
@@ -27,9 +28,6 @@ class SeastoreSuper final: public Super {
   }
   void write_root_laddr(context_t c, laddr_t addr) override;
  private:
-  static seastar::logger& logger() {
-    return crimson::get_logger(ceph_subsys_filestore);
-  }
   laddr_t root_addr;
   TransactionManager& tm;
 };
@@ -74,11 +72,10 @@ class SeastoreNodeExtentManager final: public NodeExtentManager {
 
   tm_future<NodeExtentRef> read_extent(
       Transaction& t, laddr_t addr, extent_len_t len) override {
-    logger().trace("OTree::Seastore: reading {}B at {:#x} ...", len, addr);
+    TRACET("reading {}B at {:#x} ...", t, len, addr);
     return tm.read_extent<SeastoreNodeExtent>(t, addr, len
-    ).safe_then([addr, len](auto&& e) {
-      logger().trace("OTree::Seastore: read {}B at {:#x}",
-                     e->get_length(), e->get_laddr());
+    ).safe_then([addr, len, this, &t](auto&& e) {
+      TRACET("read {}B at {:#x}", t, e->get_length(), e->get_laddr());
       assert(e->get_laddr() == addr);
       assert(e->get_length() == len);
       std::ignore = addr;
@@ -89,11 +86,11 @@ class SeastoreNodeExtentManager final: public NodeExtentManager {
 
   tm_future<NodeExtentRef> alloc_extent(
       Transaction& t, extent_len_t len) override {
-    logger().trace("OTree::Seastore: allocating {}B ...", len);
+    TRACET("allocating {}B ...", t, len);
     return tm.alloc_extent<SeastoreNodeExtent>(t, addr_min, len
-    ).safe_then([len](auto extent) {
-      logger().debug("OTree::Seastore: allocated {}B at {:#x}",
-                     extent->get_length(), extent->get_laddr());
+    ).safe_then([len, this, &t](auto extent) {
+      DEBUGT("allocated {}B at {:#x}",
+             t, extent->get_length(), extent->get_laddr());
       assert(extent->get_length() == len);
       std::ignore = len;
       return NodeExtentRef(extent);
@@ -105,18 +102,18 @@ class SeastoreNodeExtentManager final: public NodeExtentManager {
     LogicalCachedExtentRef extent = _extent;
     auto addr = extent->get_laddr();
     auto len = extent->get_length();
-    logger().debug("OTree::Seastore: retiring {}B at {:#x} ...", len, addr);
-    return tm.dec_ref(t, extent).safe_then([addr, len] (unsigned cnt) {
+    DEBUGT("retiring {}B at {:#x} ...", t, len, addr);
+    return tm.dec_ref(t, extent).safe_then([addr, len, this, &t] (unsigned cnt) {
       assert(cnt == 0);
-      logger().trace("OTree::Seastore: retired {}B at {:#x} ...", len, addr);
+      TRACET("retired {}B at {:#x} ...", t, len, addr);
     });
   }
 
   tm_future<Super::URef> get_super(
       Transaction& t, RootNodeTracker& tracker) override {
-    logger().trace("OTree::Seastore: get root ...");
+    TRACET("get root ...", t);
     return tm.read_onode_root(t).safe_then([this, &t, &tracker](auto root_addr) {
-      logger().trace("OTree::Seastore: got root {:#x}", root_addr);
+      TRACET("got root {:#x}", t, root_addr);
       return Super::URef(new SeastoreSuper(t, tracker, root_addr, tm));
     });
   }
@@ -126,9 +123,8 @@ class SeastoreNodeExtentManager final: public NodeExtentManager {
   }
 
  private:
-  static seastar::logger& logger() {
-    return crimson::get_logger(ceph_subsys_filestore);
-  }
+  static LOG_PREFIX(OTree::Seastore);
+
   TransactionManager& tm;
   const laddr_t addr_min;
 };
diff --git a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h
index 55c0dbdb952..9c754bab1df 100644
--- a/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h
+++ b/src/crimson/os/seastore/onode_manager/staged-fltree/node_layout.h
@@ -7,7 +7,8 @@
 #include <sstream>
 
 #include "common/likely.h"
-#include "crimson/common/log.h"
+#include "crimson/os/seastore/logging.h"
+
 #include "node_extent_accessor.h"
 #include "node_impl.h"
 #include "stages/node_stage_layout.h"
@@ -159,19 +160,19 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
 
   std::tuple<match_stage_t, search_position_t>
   erase(const search_position_t& pos) override {
-    logger().debug("OTree::Layout::Erase: begin at erase_pos({}) ...", pos);
-    if (unlikely(logger().is_enabled(seastar::log_level::trace))) {
+    LOG_PREFIX(OTree::Layout::erase);
+    DEBUG("begin at erase_pos({}) ...", pos);
+    if (unlikely(LOGGER.is_enabled(seastar::log_level::trace))) {
       std::ostringstream sos;
       dump(sos);
-      logger().trace("OTree::Layout::Erase: -- dump\n{}", sos.str());
+      TRACE("-- dump\n{}", sos.str());
     }
     auto [stage, next_or_last_pos] = extent.erase_replayable(cast_down<STAGE>(pos));
-    logger().debug("OTree::Layout::Erase: done  at erase_stage={}, n/l_pos({})",
-                   stage, next_or_last_pos);
-    if (unlikely(logger().is_enabled(seastar::log_level::trace))) {
+    DEBUG("done  at erase_stage={}, n/l_pos({})", stage, next_or_last_pos);
+    if (unlikely(LOGGER.is_enabled(seastar::log_level::trace))) {
       std::ostringstream sos;
       dump(sos);
-      logger().trace("OTree::Layout::Erase: -- dump\n{}", sos.str());
+      TRACE("-- dump\n{}", sos.str());
     }
 #ifndef NDEBUG
     if (!is_keys_empty()) {
@@ -205,19 +206,20 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
 
   search_position_t merge(NodeExtentMutable& mut, NodeImpl& _right_node,
                           match_stage_t merge_stage, node_offset_t merge_size) override {
+    LOG_PREFIX(OTree::Layout::merge);
     assert(NODE_TYPE == _right_node.node_type());
     assert(FIELD_TYPE == _right_node.field_type());
     auto& right_node = dynamic_cast<NodeLayoutT&>(_right_node);
-    if (unlikely(logger().is_enabled(seastar::log_level::debug))) {
+    if (unlikely(LOGGER.is_enabled(seastar::log_level::debug))) {
       {
         std::ostringstream sos;
         dump(sos);
-        logger().debug("OTree::Layout::Merge: -- left node dump\n{}", sos.str());
+        DEBUG("-- left node dump\n{}", sos.str());
       }
       {
         std::ostringstream sos;
         right_node.dump(sos);
-        logger().debug("OTree::Layout::Merge: -- right node dump\n{}", sos.str());
+        DEBUG("-- right node dump\n{}", sos.str());
       }
     }
 
@@ -247,10 +249,10 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
       build_name();
     }
 
-    if (unlikely(logger().is_enabled(seastar::log_level::debug))) {
+    if (unlikely(LOGGER.is_enabled(seastar::log_level::debug))) {
       std::ostringstream sos;
       dump(sos);
-      logger().debug("OTree::Layout::Merge: -- merged node dump\n{}", sos.str());
+      DEBUG("-- merged node dump\n{}", sos.str());
     }
     assert(merge_size == filled_size());
     return normalize(std::move(left_last_pos));
@@ -510,23 +512,22 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
       const full_key_t<KEY_TYPE>& key, const value_input_t& value,
       search_position_t& insert_pos, match_stage_t& insert_stage,
       node_offset_t& insert_size) override {
-    logger().debug("OTree::Layout::Insert: begin at "
-                   "insert_pos({}), insert_stage={}, insert_size={}B ...",
-                   insert_pos, insert_stage, insert_size);
-    if (unlikely(logger().is_enabled(seastar::log_level::trace))) {
+    LOG_PREFIX(OTree::Layout::insert);
+    DEBUG("begin at insert_pos({}), insert_stage={}, insert_size={}B ...",
+          insert_pos, insert_stage, insert_size);
+    if (unlikely(LOGGER.is_enabled(seastar::log_level::trace))) {
       std::ostringstream sos;
       dump(sos);
-      logger().trace("OTree::Layout::Insert: -- dump\n{}", sos.str());
+      TRACE("-- dump\n{}", sos.str());
     }
     auto ret = extent.template insert_replayable<KEY_TYPE>(
         key, value, cast_down<STAGE>(insert_pos), insert_stage, insert_size);
-    logger().debug("OTree::Layout::Insert: done  at "
-                   "insert_pos({}), insert_stage={}, insert_size={}B",
-                   insert_pos, insert_stage, insert_size);
-    if (unlikely(logger().is_enabled(seastar::log_level::trace))) {
+    DEBUG("done  at insert_pos({}), insert_stage={}, insert_size={}B",
+          insert_pos, insert_stage, insert_size);
+    if (unlikely(LOGGER.is_enabled(seastar::log_level::trace))) {
       std::ostringstream sos;
       dump(sos);
-      logger().trace("OTree::Layout::Insert: -- dump\n{}", sos.str());
+      TRACE("-- dump\n{}", sos.str());
     }
     validate_layout();
 #ifndef NDEBUG
@@ -542,16 +543,16 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
       const full_key_t<KEY_TYPE>& key, const value_input_t& value,
       search_position_t& _insert_pos, match_stage_t& insert_stage,
       node_offset_t& insert_size) override {
+    LOG_PREFIX(OTree::Layout::split_insert);
     assert(_right_impl.node_type() == NODE_TYPE);
     assert(_right_impl.field_type() == FIELD_TYPE);
     auto& right_impl = dynamic_cast<NodeLayoutT&>(_right_impl);
-    logger().info("OTree::Layout::Split: begin at "
-                  "insert_pos({}), insert_stage={}, insert_size={}B ...",
-                  _insert_pos, insert_stage, insert_size);
-    if (unlikely(logger().is_enabled(seastar::log_level::debug))) {
+    INFO("begin at insert_pos({}), insert_stage={}, insert_size={}B ...",
+         _insert_pos, insert_stage, insert_size);
+    if (unlikely(LOGGER.is_enabled(seastar::log_level::debug))) {
       std::ostringstream sos;
       dump(sos);
-      logger().debug("OTree::Layout::Split: -- dump\n{}", sos.str());
+      DEBUG("-- dump\n{}", sos.str());
     }
 #ifdef UNIT_TESTS_BUILT
     auto insert_stage_pre = insert_stage;
@@ -647,11 +648,10 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
           split_size, 0, target_split_size, insert_pos,
           insert_stage, insert_size, _is_insert_left, split_at);
       is_insert_left = *_is_insert_left;
-      logger().debug("OTree::Layout::Split: -- located "
-          "split_at({}), insert_pos({}), is_insert_left={}, "
-          "split_size={}B(target={}B, current={}B)",
-          split_at, insert_pos, is_insert_left,
-          split_size, target_split_size, filled_size());
+      DEBUG("-- located split_at({}), insert_pos({}), is_insert_left={}, "
+            "split_size={}B(target={}B, current={}B)",
+            split_at, insert_pos, is_insert_left,
+            split_size, target_split_size, filled_size());
       // split_size can be larger than target_split_size in strategy B
       // assert(split_size <= target_split_size);
       if (locate_nxt) {
@@ -671,9 +671,9 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
       // right node: append [start(append_at), insert_pos)
       STAGE_T::template append_until<KEY_TYPE>(
           append_at, right_appender, insert_pos, insert_stage);
-      logger().debug("OTree::Layout::Split: -- right appended until "
-                     "insert_pos({}), insert_stage={}, insert/append the rest ...",
-                     insert_pos, insert_stage);
+      DEBUG("-- right appended until "
+            "insert_pos({}), insert_stage={}, insert/append the rest ...",
+            insert_pos, insert_stage);
       // right node: append [insert_pos(key, value)]
       bool is_front_insert = (insert_pos == position_t::begin());
       [[maybe_unused]] bool is_end = STAGE_T::template append_insert<KEY_TYPE>(
@@ -681,7 +681,7 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
           is_front_insert, insert_stage, p_value);
       assert(append_at.is_end() == is_end);
     } else {
-      logger().debug("OTree::Layout::Split: -- right appending ...");
+      DEBUG("-- right appending ...");
     }
 
     // right node: append (insert_pos, end)
@@ -690,18 +690,17 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
         append_at, right_appender, pos_end, STAGE);
     assert(append_at.is_end());
     right_appender.wrap();
-    if (unlikely(logger().is_enabled(seastar::log_level::debug))) {
+    if (unlikely(LOGGER.is_enabled(seastar::log_level::debug))) {
       std::ostringstream sos;
       right_impl.dump(sos);
-      logger().debug("OTree::Layout::Split: -- right node dump\n{}", sos.str());
+      DEBUG("-- right node dump\n{}", sos.str());
     }
     right_impl.validate_layout();
 
     // mutate left node
     if (is_insert_left) {
-      logger().debug("OTree::Layout::Split: -- left trim/insert at "
-                     "insert_pos({}), insert_stage={} ...",
-                     insert_pos, insert_stage);
+      DEBUG("-- left trim/insert at insert_pos({}), insert_stage={} ...",
+            insert_pos, insert_stage);
       p_value = extent.template split_insert_replayable<KEY_TYPE>(
           split_at, key, value, insert_pos, insert_stage, insert_size);
 #ifndef NDEBUG
@@ -710,7 +709,7 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
       assert(index.compare_to(key) == MatchKindCMP::EQ);
 #endif
     } else {
-      logger().debug("OTree::Layout::Split: -- left trim ...");
+      DEBUG("-- left trim ...");
 #ifndef NDEBUG
       full_key_t<KeyT::VIEW> index;
       right_impl.get_slot(_insert_pos, &index, nullptr);
@@ -722,20 +721,19 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
       // is_level_tail of left is changed by split/split_insert
       build_name();
     }
-    if (unlikely(logger().is_enabled(seastar::log_level::debug))) {
+    if (unlikely(LOGGER.is_enabled(seastar::log_level::debug))) {
       std::ostringstream sos;
       dump(sos);
-      logger().debug("OTree::Layout::Split: -- left node dump\n{}", sos.str());
+      DEBUG("-- left node dump\n{}", sos.str());
     }
     validate_layout();
     assert(p_value);
 
     auto split_pos = normalize(split_at.get_pos());
-    logger().info("OTree::Layout::Split: done  at "
-                  "insert_pos({}), insert_stage={}, insert_size={}B, split_at({}), "
-                  "is_insert_left={}, split_size={}B(target={}B)",
-                  _insert_pos, insert_stage, insert_size, split_pos,
-                  is_insert_left, split_size, target_split_size);
+    INFO("done  at insert_pos({}), insert_stage={}, insert_size={}B, "
+         "split_at({}), is_insert_left={}, split_size={}B(target={}B)",
+         _insert_pos, insert_stage, insert_size, split_pos,
+         is_insert_left, split_size, target_split_size);
     assert(split_size == filled_size());
 
 #ifdef UNIT_TESTS_BUILT
@@ -776,9 +774,8 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
   void replace_child_addr(
       const search_position_t& pos, laddr_t dst, laddr_t src) override {
     if constexpr (NODE_TYPE == node_type_t::INTERNAL) {
-      logger().debug("OTree::Layout::ReplaceChildAddr: "
-                     "update from {:#x} to {:#x} at pos({}) ...",
-                     src, dst, pos);
+      LOG_PREFIX(OTree::Layout::replace_child_addr);
+      DEBUG("update from {:#x} to {:#x} at pos({}) ...", src, dst, pos);
       const laddr_packed_t* p_value;
       if (pos.is_end()) {
         assert(is_level_tail());
@@ -864,10 +861,6 @@ class NodeLayoutT final : public InternalNodeImpl, public LeafNodeImpl {
     name = sos.str();
   }
 
-  static seastar::logger& logger() {
-    return crimson::get_logger(ceph_subsys_filestore);
-  }
-
   extent_t extent;
   std::string name = "Node-N/A";
 };