SERVER-41375 Add successfulDurationMicros to commitTypes in mongos transactions serverStatus output

(cherry picked from commit 2a0c2ce0f12dd1bbe485da1c2fdcb9d6a7a30bee)

6 files changed, 112 insertions, 6 deletions

diff --git a/jstests/noPassthrough/router_transactions_metrics.js b/jstests/noPassthrough/router_transactions_metrics.js
index eecb21261ec..a8b6089d603 100644
--- a/jstests/noPassthrough/router_transactions_metrics.js
+++ b/jstests/noPassthrough/router_transactions_metrics.js
@@ -41,7 +41,7 @@
             "twoPhaseCommit",
             "recoverWithToken",
         ];
-        const commitTypeFields = ["initiated", "successful"];
+        const commitTypeFields = ["initiated", "successful", "successfulDurationMicros"];
 
         assert.hasFields(res.transactions.commitTypes,
                          commitTypes,
@@ -72,6 +72,7 @@
         constructor() {
             this.initiated = 0;
             this.successful = 0;
+            this.successfulDurationMicros = 0;
         }
     }
 
@@ -129,6 +130,20 @@
                       commitTypes[commitType].successful,
                       "unexpected successful for " + commitType + ", commit types: " +
                           tojson(commitTypes));
+
+            assert.lte(expectedStats.commitTypes[commitType].successfulDurationMicros,
+                       commitTypes[commitType].successfulDurationMicros,
+                       "unexpected successfulDurationMicros for " + commitType +
+                           ", commit types: " + tojson(commitTypes));
+            expectedStats.commitTypes[commitType].successfulDurationMicros =
+                commitTypes[commitType].successfulDurationMicros;
+
+            if (commitTypes[commitType].successful != 0) {
+                assert.gt(commitTypes[commitType].successfulDurationMicros,
+                          0,
+                          "unexpected successfulDurationMicros for " + commitType +
+                              ", commit types: " + tojson(commitTypes));
+            }
         });
     }
 
diff --git a/src/mongo/s/router_transactions_metrics.cpp b/src/mongo/s/router_transactions_metrics.cpp
index 2c6f2db4fa4..12724520fd2 100644
--- a/src/mongo/s/router_transactions_metrics.cpp
+++ b/src/mongo/s/router_transactions_metrics.cpp
@@ -146,28 +146,40 @@ void RouterTransactionsMetrics::incrementCommitInitiated(TransactionRouter::Comm
     }
 }
 
-void RouterTransactionsMetrics::incrementCommitSuccessful(
-    TransactionRouter::CommitType commitType) {
+void RouterTransactionsMetrics::incrementCommitSuccessful(TransactionRouter::CommitType commitType,
+                                                          Microseconds durationMicros) {
     switch (commitType) {
         case TransactionRouter::CommitType::kNotInitiated:
             MONGO_UNREACHABLE;
         case TransactionRouter::CommitType::kNoShards:
             _noShardsCommitStats.successful.fetchAndAdd(1);
+            _noShardsCommitStats.successfulDurationMicros.fetchAndAdd(
+                durationCount<Microseconds>(durationMicros));
             break;
         case TransactionRouter::CommitType::kSingleShard:
             _singleShardCommitStats.successful.fetchAndAdd(1);
+            _singleShardCommitStats.successfulDurationMicros.fetchAndAdd(
+                durationCount<Microseconds>(durationMicros));
             break;
         case TransactionRouter::CommitType::kSingleWriteShard:
             _singleWriteShardCommitStats.successful.fetchAndAdd(1);
+            _singleWriteShardCommitStats.successfulDurationMicros.fetchAndAdd(
+                durationCount<Microseconds>(durationMicros));
             break;
         case TransactionRouter::CommitType::kReadOnly:
             _readOnlyCommitStats.successful.fetchAndAdd(1);
+            _readOnlyCommitStats.successfulDurationMicros.fetchAndAdd(
+                durationCount<Microseconds>(durationMicros));
             break;
         case TransactionRouter::CommitType::kTwoPhaseCommit:
             _twoPhaseCommitStats.successful.fetchAndAdd(1);
+            _twoPhaseCommitStats.successfulDurationMicros.fetchAndAdd(
+                durationCount<Microseconds>(durationMicros));
             break;
         case TransactionRouter::CommitType::kRecoverWithToken:
             _recoverWithTokenCommitStats.successful.fetchAndAdd(1);
+            _recoverWithTokenCommitStats.successfulDurationMicros.fetchAndAdd(
+                durationCount<Microseconds>(durationMicros));
             break;
     }
 }
@@ -176,6 +188,7 @@ CommitTypeStats RouterTransactionsMetrics::_constructCommitTypeStats(const Commi
     CommitTypeStats commitStats;
     commitStats.setInitiated(stats.initiated.load());
     commitStats.setSuccessful(stats.successful.load());
+    commitStats.setSuccessfulDurationMicros(stats.successfulDurationMicros.load());
     return commitStats;
 }
 
diff --git a/src/mongo/s/router_transactions_metrics.h b/src/mongo/s/router_transactions_metrics.h
index b96489dee0e..dbd946f4626 100644
--- a/src/mongo/s/router_transactions_metrics.h
+++ b/src/mongo/s/router_transactions_metrics.h
@@ -51,6 +51,9 @@ public:
 
         // Total number of times this commit completed successfully.
         AtomicWord<std::int64_t> successful{0};
+
+        // Total commit duration of successful transactions in microseconds.
+        AtomicWord<std::int64_t> successfulDurationMicros{0};
     };
 
     RouterTransactionsMetrics() = default;
@@ -78,7 +81,8 @@ public:
 
     const CommitStats& getCommitTypeStats_forTest(TransactionRouter::CommitType commitType);
     void incrementCommitInitiated(TransactionRouter::CommitType commitType);
-    void incrementCommitSuccessful(TransactionRouter::CommitType commitType);
+    void incrementCommitSuccessful(TransactionRouter::CommitType commitType,
+                                   Microseconds durationMicros);
 
     /**
      * Appends the accumulated stats to a sharded transactions stats object for reporting.
diff --git a/src/mongo/s/router_transactions_stats.idl b/src/mongo/s/router_transactions_stats.idl
index b0a7ed7aae7..243c3866981 100644
--- a/src/mongo/s/router_transactions_stats.idl
+++ b/src/mongo/s/router_transactions_stats.idl
@@ -47,6 +47,9 @@ structs:
       successful:
         type: long
         default: 0
+      successfulDurationMicros:
+        type: long
+        default: 0
 
   CommitTypes:
     description: "Contains metrics for each type of commit"
diff --git a/src/mongo/s/transaction_router.cpp b/src/mongo/s/transaction_router.cpp
index 47f4728fb54..b899386cbb9 100644
--- a/src/mongo/s/transaction_router.cpp
+++ b/src/mongo/s/transaction_router.cpp
@@ -1195,7 +1195,8 @@ void TransactionRouter::_endTransactionTrackingIfNecessary(OperationContext* opC
         routerTxnMetrics->incrementTotalAborted();
     } else {
         routerTxnMetrics->incrementTotalCommitted();
-        routerTxnMetrics->incrementCommitSuccessful(_commitType);
+        routerTxnMetrics->incrementCommitSuccessful(
+            _commitType, _timingStats.getCommitDuration(tickSource, curTicks));
     }
 }
 
diff --git a/src/mongo/s/transaction_router_test.cpp b/src/mongo/s/transaction_router_test.cpp
index 4fc83724956..e3e083797d4 100644
--- a/src/mongo/s/transaction_router_test.cpp
+++ b/src/mongo/s/transaction_router_test.cpp
@@ -3561,7 +3561,7 @@ TEST_F(TransactionRouterMetricsTest, CommitDurationAdvancesDuringCommit) {
 
     auto future = beginAndPauseCommit();
 
-    // The clock hasn't advance since commit started, so the duration should be 0.
+    // The clock hasn't advanced since commit started, so the duration should be 0.
     assertCommitDurationIs(Microseconds(0));
 
     // Advancing the clock during commit should increase commit duration.
@@ -3933,6 +3933,10 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsCommitTypeStatsNotUpdatedOnUnk
     ASSERT_EQUALS(
         0L,
         routerTxnMetrics()->getCommitTypeStats_forTest(CommitType::kSingleShard).successful.load());
+    ASSERT_EQUALS(0L,
+                  routerTxnMetrics()
+                      ->getCommitTypeStats_forTest(CommitType::kSingleShard)
+                      .successfulDurationMicros.load());
 
     runCommit(kDummyRetryableErrorRes, true /* expectRetries */);
 
@@ -3943,6 +3947,72 @@ TEST_F(TransactionRouterMetricsTest, RouterMetricsCommitTypeStatsNotUpdatedOnUnk
     ASSERT_EQUALS(
         0L,
         routerTxnMetrics()->getCommitTypeStats_forTest(CommitType::kSingleShard).successful.load());
+    ASSERT_EQUALS(0L,
+                  routerTxnMetrics()
+                      ->getCommitTypeStats_forTest(CommitType::kSingleShard)
+                      .successfulDurationMicros.load());
+}
+
+TEST_F(TransactionRouterMetricsTest, RouterMetricsCommitTypeStatsSuccessfulDurationMicros) {
+    beginTxnWithDefaultTxnNumber();
+
+    // Advancing the clock before beginning commit shouldn't affect commit duration or successful
+    // commit duration.
+    tickSource()->advance(Microseconds(100));
+
+    auto future = beginAndPauseCommit();
+
+    // The clock hasn't advanced since commit started, so commit duration and successful commit
+    // duration should be 0.
+    assertCommitDurationIs(Microseconds(0));
+    ASSERT_EQUALS(0L,
+                  routerTxnMetrics()
+                      ->getCommitTypeStats_forTest(CommitType::kSingleShard)
+                      .successfulDurationMicros.load());
+
+    tickSource()->advance(Microseconds(100));
+
+    // Advancing the clock during commit should increase commit duration but not successful commit
+    // duration.
+    assertCommitDurationIs(Microseconds(100));
+    ASSERT_EQUALS(0L,
+                  routerTxnMetrics()
+                      ->getCommitTypeStats_forTest(CommitType::kSingleShard)
+                      .successfulDurationMicros.load());
+
+    expectCommitTransaction();
+    future.default_timed_get();
+
+    // Finishing the commit successfully should now increase successful commit duration but not
+    // commit duration.
+    assertCommitDurationIs(Microseconds(100));
+    ASSERT_EQUALS(100L,
+                  routerTxnMetrics()
+                      ->getCommitTypeStats_forTest(CommitType::kSingleShard)
+                      .successfulDurationMicros.load());
+
+    // Commit duration and successful commit duration shouldn't change now that commit has finished.
+    tickSource()->advance(Microseconds(100));
+    assertCommitDurationIs(Microseconds(100));
+    ASSERT_EQUALS(100L,
+                  routerTxnMetrics()
+                      ->getCommitTypeStats_forTest(CommitType::kSingleShard)
+                      .successfulDurationMicros.load());
+
+    // Start a new transaction and verify that successful commit duration is cumulative.
+    txnRouter().beginOrContinueTxn(
+        operationContext(), kTxnNumber + 1, TransactionRouter::TransactionActions::kStart);
+    txnRouter().setDefaultAtClusterTime(operationContext());
+    future = beginAndPauseCommit();
+    tickSource()->advance(Microseconds(100));
+    expectCommitTransaction();
+    future.default_timed_get();
+
+    assertCommitDurationIs(Microseconds(100));
+    ASSERT_EQUALS(200L,
+                  routerTxnMetrics()
+                      ->getCommitTypeStats_forTest(CommitType::kSingleShard)
+                      .successfulDurationMicros.load());
 }
 
 }  // unnamed namespace