diff --git a/clang-tools-extra/clangd/Selection.cpp b/clang-tools-extra/clangd/Selection.cpp
--- a/clang-tools-extra/clangd/Selection.cpp
+++ b/clang-tools-extra/clangd/Selection.cpp
@@ -9,6 +9,7 @@
 #include "Selection.h"
 #include "SourceCode.h"
 #include "support/Logger.h"
+#include "support/Trace.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
@@ -35,6 +36,23 @@
 using Node = SelectionTree::Node;
 using ast_type_traits::DynTypedNode;
 
+void recordMetrics(const SelectionTree &S) {
+  static constexpr trace::Metric Selection("selection", trace::Metric::Counter);
+  static constexpr trace::Metric SelectionRecoveryAST("selection_recovery_ast",
+                                                      trace::Metric::Counter);
+  const auto *Common = S.commonAncestor();
+  if (Common)
+    Selection.record(1); // account if something is actually selected.
+  for (const auto *N = Common; N; N = N->Parent) {
+    if (N->ASTNode.get<RecoveryExpr>()) {
+      // FIXME: tracing the type through the label?
+      SelectionRecoveryAST.record(1);
+      break;
+    }
+  }
+  return;
+}
+
 // An IntervalSet maintains a set of disjoint subranges of an array.
 //
 // Initially, it contains the entire array.
@@ -774,6 +792,7 @@
            .printToString(SM));
   Nodes = SelectionVisitor::collect(AST, Tokens, PrintPolicy, Begin, End, FID);
   Root = Nodes.empty() ? nullptr : &Nodes.front();
+  recordMetrics(*this);
   dlog("Built selection tree\n{0}", *this);
 }
 
diff --git a/clang-tools-extra/clangd/unittests/SelectionTests.cpp b/clang-tools-extra/clangd/unittests/SelectionTests.cpp
--- a/clang-tools-extra/clangd/unittests/SelectionTests.cpp
+++ b/clang-tools-extra/clangd/unittests/SelectionTests.cpp
@@ -9,6 +9,7 @@
 #include "Selection.h"
 #include "SourceCode.h"
 #include "TestTU.h"
+#include "support/TestTracer.h"
 #include "clang/AST/Decl.h"
 #include "llvm/Support/Casting.h"
 #include "gmock/gmock.h"
@@ -390,6 +391,7 @@
       )cpp", "DeclRefExpr"} // DeclRefExpr to the "operator->" method.
   };
   for (const Case &C : Cases) {
+    trace::TestTracer Tracer;
     Annotations Test(C.Code);
 
     TestTU TU;
@@ -407,6 +409,7 @@
     if (Test.ranges().empty()) {
       // If no [[range]] is marked in the example, there should be no selection.
       EXPECT_FALSE(T.commonAncestor()) << C.Code << "\n" << T;
+      EXPECT_THAT(Tracer.takeMetric("selection"), testing::IsEmpty());
     } else {
       // If there is an expected selection, common ancestor should exist
       // with the appropriate node type.
@@ -422,6 +425,9 @@
       // and no nodes outside it are selected.
       EXPECT_TRUE(verifyCommonAncestor(T.root(), T.commonAncestor(), C.Code))
           << C.Code;
+      EXPECT_THAT(Tracer.takeMetric("selection"), testing::SizeIs(1));
+      EXPECT_THAT(Tracer.takeMetric("selection_recovery_ast"),
+                  testing::IsEmpty());
     }
   }
 }
@@ -436,6 +442,20 @@
   EXPECT_FALSE(D->isInjectedClassName());
 }
 
+TEST(SelectionTree, Metrics) {
+  const char *Code = R"cpp(
+    // error-ok: testing behavior on recovery expression
+    int foo();
+    int foo(int, int);
+    int x = fo^o(42);
+  )cpp";
+  auto AST = TestTU::withCode(Annotations(Code).code()).build();
+  trace::TestTracer Tracer;
+  auto T = makeSelectionTree(Code, AST);
+  EXPECT_THAT(Tracer.takeMetric("selection"), testing::SizeIs(1));
+  EXPECT_THAT(Tracer.takeMetric("selection_recovery_ast"), testing::SizeIs(1));
+}
+
 // FIXME: Doesn't select the binary operator node in
 //          #define FOO(X) X + 1
 //          int a, b = [[FOO(a)]];