diff --git a/src/core/lib/channel/channel_trace.cc b/src/core/lib/channel/channel_trace.cc
index ba2b3bcad68..7d8bb391f87 100644
--- a/src/core/lib/channel/channel_trace.cc
+++ b/src/core/lib/channel/channel_trace.cc
@@ -41,14 +41,25 @@
 namespace grpc_core {
 namespace channelz {
 
-ChannelTrace::TraceEvent::TraceEvent(Severity severity, grpc_slice data,
-                                     RefCountedPtr<BaseNode> referenced_entity)
+ChannelTrace::TraceEvent::TraceEvent(
+    Severity severity, grpc_slice data,
+    RefCountedPtr<ChannelNode> referenced_channel)
     : severity_(severity),
       data_(data),
       timestamp_(grpc_millis_to_timespec(grpc_core::ExecCtx::Get()->Now(),
                                          GPR_CLOCK_REALTIME)),
       next_(nullptr),
-      referenced_entity_(std::move(referenced_entity)) {}
+      referenced_channel_(std::move(referenced_channel)) {}
+
+// ChannelTrace::TraceEvent::TraceEvent(Severity severity, grpc_slice data,
+//                                      RefCountedPtr<SubchannelNode>
+//                                      referenced_subchannel)
+//     : severity_(severity),
+//       data_(data),
+//       timestamp_(grpc_millis_to_timespec(grpc_core::ExecCtx::Get()->Now(),
+//                                          GPR_CLOCK_REALTIME)),
+//       next_(nullptr),
+//       referenced_subchannel_(std::move(referenced_subchannel)) {}
 
 ChannelTrace::TraceEvent::TraceEvent(Severity severity, grpc_slice data)
     : severity_(severity),
@@ -110,13 +121,22 @@ void ChannelTrace::AddTraceEvent(Severity severity, grpc_slice data) {
 
 void ChannelTrace::AddTraceEventReferencingChannel(
     Severity severity, grpc_slice data,
-    RefCountedPtr<BaseNode> referenced_entity) {
+    RefCountedPtr<ChannelNode> referenced_channel) {
   if (max_list_size_ == 0) return;  // tracing is disabled if max_events == 0
   // create and fill up the new event
   AddTraceEventHelper(
-      New<TraceEvent>(severity, data, std::move(referenced_entity)));
+      New<TraceEvent>(severity, data, std::move(referenced_channel)));
 }
 
+// void ChannelTrace::AddTraceEventReferencingSubchannel(
+//     Severity severity, grpc_slice data,
+//     RefCountedPtr<SubchannelNode> referenced_subchannel) {
+//   if (max_list_size_ == 0) return;  // tracing is disabled if max_events == 0
+//   // create and fill up the new event
+//   AddTraceEventHelper(
+//       New<TraceEvent>(severity, data, std::move(referenced_subchannel)));
+// }
+
 namespace {
 
 const char* severity_string(ChannelTrace::Severity severity) {
@@ -145,27 +165,26 @@ void ChannelTrace::TraceEvent::RenderTraceEvent(grpc_json* json) const {
   json_iterator = grpc_json_create_child(json_iterator, json, "timestamp",
                                          gpr_format_timespec(timestamp_),
                                          GRPC_JSON_STRING, true);
-  if (referenced_entity_ != nullptr) {
-    GPR_ASSERT(
-        referenced_entity_->type() == BaseNode::EntityType::kSubchannel ||
-        referenced_entity_->type() == BaseNode::EntityType::kTopLevelChannel ||
-        referenced_entity_->type() == BaseNode::EntityType::kInternalChannel);
+  if (referenced_channel_ != nullptr) {
     char* uuid_str;
-    gpr_asprintf(&uuid_str, "%" PRIdPTR, referenced_entity_->uuid());
+    gpr_asprintf(&uuid_str, "%" PRIdPTR, referenced_channel_->uuid());
     grpc_json* child_ref = grpc_json_create_child(
-        json_iterator, json,
-        (referenced_entity_->type() == BaseNode::EntityType::kSubchannel)
-            ? "subchannelRef"
-            : "channelRef",
-        nullptr, GRPC_JSON_OBJECT, false);
-    json_iterator = grpc_json_create_child(
-        nullptr, child_ref,
-        (referenced_entity_->type() == BaseNode::EntityType::kSubchannel)
-            ? "subchannelId"
-            : "channelId",
-        uuid_str, GRPC_JSON_STRING, true);
+        json_iterator, json, "channelRef", nullptr, GRPC_JSON_OBJECT, false);
+    json_iterator = grpc_json_create_child(nullptr, child_ref, "channelId",
+                                           uuid_str, GRPC_JSON_STRING, true);
     json_iterator = child_ref;
   }
+  // else {
+  //   char* uuid_str;
+  //   gpr_asprintf(&uuid_str, "%" PRIdPTR, referenced_subchannel_->uuid());
+  //   grpc_json* child_ref = grpc_json_create_child(
+  //       json_iterator, json, "subchannelRef",
+  //       nullptr, GRPC_JSON_OBJECT, false);
+  //   json_iterator = grpc_json_create_child(
+  //       nullptr, child_ref, "subchannelId",
+  //       uuid_str, GRPC_JSON_STRING, true);
+  //   json_iterator = child_ref;
+  // }
 }
 
 grpc_json* ChannelTrace::RenderJson() const {
diff --git a/src/core/lib/channel/channel_trace.h b/src/core/lib/channel/channel_trace.h
index cef8814d5fa..543eabf13a8 100644
--- a/src/core/lib/channel/channel_trace.h
+++ b/src/core/lib/channel/channel_trace.h
@@ -30,7 +30,8 @@
 namespace grpc_core {
 namespace channelz {
 
-class BaseNode;
+class ChannelNode;
+class SubchannelNode;
 
 // Object used to hold live data for a channel. This data is exposed via the
 // channelz service:
@@ -64,10 +65,10 @@ class ChannelTrace {
   // slice.
   void AddTraceEventReferencingChannel(
       Severity severity, grpc_slice data,
-      RefCountedPtr<BaseNode> referenced_entity);
-  // void AddTraceEventWithReference(
+      RefCountedPtr<ChannelNode> referenced_channel);
+  // void AddTraceEventReferencingSubchannel(
   //     Severity severity, grpc_slice data,
-  //     RefCountedPtr<SubchannelNode> referenced_entity);
+  //     RefCountedPtr<SubchannelNode> referenced_subchannel);
 
   // Creates and returns the raw grpc_json object, so a parent channelz
   // object may incorporate the json before rendering.
@@ -78,9 +79,13 @@ class ChannelTrace {
   // a trace event.
   class TraceEvent {
    public:
-    // Constructor for a TraceEvent that references a different channel.
+    // Constructor for a TraceEvent that references a channel.
     TraceEvent(Severity severity, grpc_slice data,
-               RefCountedPtr<BaseNode> referenced);
+               RefCountedPtr<ChannelNode> referenced_channel);
+
+    // Constructor for a TraceEvent that references a subchannel.
+    TraceEvent(Severity severity, grpc_slice data,
+               RefCountedPtr<SubchannelNode> referenced_subchannel);
 
     // Constructor for a TraceEvent that does not reverence a different
     // channel.
@@ -102,7 +107,8 @@ class ChannelTrace {
     gpr_timespec timestamp_;
     TraceEvent* next_;
     // the tracer object for the (sub)channel that this trace event refers to.
-    RefCountedPtr<BaseNode> referenced_entity_;
+    RefCountedPtr<ChannelNode> referenced_channel_;
+    // RefCountedPtr<SubchannelNode> referenced_subchannel_;
   };  // TraceEvent
 
   // Internal helper to add and link in a trace event
diff --git a/src/core/lib/gprpp/ref_counted.h b/src/core/lib/gprpp/ref_counted.h
index ddac5bd4755..3d6a32ddcff 100644
--- a/src/core/lib/gprpp/ref_counted.h
+++ b/src/core/lib/gprpp/ref_counted.h
@@ -73,7 +73,8 @@ class RefCounted {
 
  private:
   // Allow RefCountedPtr<> to access IncrementRefCount().
-  friend class RefCountedPtr<Child>;
+  template <typename T>
+  friend class RefCountedPtr;
 
   void IncrementRefCount() { gpr_ref(&refs_); }