SERVER-30778 Consolidate RecordStore interface to always use timestamps

42 files changed, 319 insertions, 323 deletions

diff --git a/src/mongo/db/catalog/collection_impl.cpp b/src/mongo/db/catalog/collection_impl.cpp
index 78f2d84c0d4..0824f877660 100644
--- a/src/mongo/db/catalog/collection_impl.cpp
+++ b/src/mongo/db/catalog/collection_impl.cpp
@@ -302,7 +302,7 @@ Status CollectionImpl::insertDocumentsForOplog(OperationContext* opCtx,
     invariant(!_indexCatalog.haveAnyIndexes());
     invariant(!_mustTakeCappedLockOnInsert);
 
-    Status status = _recordStore->insertRecordsWithDocWriterT(opCtx, docs, timestamps, nDocs);
+    Status status = _recordStore->insertRecordsWithDocWriter(opCtx, docs, timestamps, nDocs);
     if (!status.isOK())
         return status;
 
@@ -407,7 +407,7 @@ Status CollectionImpl::insertDocument(OperationContext* opCtx,
     // TODO SERVER-30638: using timestamp 0 for these inserts, which are non-oplog so we don't yet
     // care about their correct timestamps.
     StatusWith<RecordId> loc = _recordStore->insertRecord(
-        opCtx, doc.objdata(), doc.objsize(), _enforceQuota(enforceQuota));
+        opCtx, doc.objdata(), doc.objsize(), Timestamp(), _enforceQuota(enforceQuota));
 
     if (!loc.isOK())
         return loc.getStatus();
@@ -467,7 +467,7 @@ Status CollectionImpl::_insertDocuments(OperationContext* opCtx,
         timestamps.push_back(timestamp);
     }
     Status status =
-        _recordStore->insertRecordsT(opCtx, &records, &timestamps, _enforceQuota(enforceQuota));
+        _recordStore->insertRecords(opCtx, &records, &timestamps, _enforceQuota(enforceQuota));
     if (!status.isOK())
         return status;
 
@@ -689,7 +689,7 @@ StatusWith<RecordId> CollectionImpl::_updateDocumentWithMove(OperationContext* o
                                                              const SnapshotId& sid) {
     // Insert new record.
     // TODO SERVER-30638, thread through actual timestamps.
-    StatusWith<RecordId> newLocation = _recordStore->insertRecordT(
+    StatusWith<RecordId> newLocation = _recordStore->insertRecord(
         opCtx, newDoc.objdata(), newDoc.objsize(), Timestamp(), _enforceQuota(enforceQuota));
     if (!newLocation.isOK()) {
         return newLocation;
diff --git a/src/mongo/db/storage/devnull/devnull_kv_engine.cpp b/src/mongo/db/storage/devnull/devnull_kv_engine.cpp
index 8d22cdf0224..fcd36355cb3 100644
--- a/src/mongo/db/storage/devnull/devnull_kv_engine.cpp
+++ b/src/mongo/db/storage/devnull/devnull_kv_engine.cpp
@@ -96,16 +96,15 @@ public:
 
     virtual void deleteRecord(OperationContext* opCtx, const RecordId& dl) {}
 
-    virtual StatusWith<RecordId> insertRecord(OperationContext* opCtx,
-                                              const char* data,
-                                              int len,
-                                              bool enforceQuota) {
+    virtual StatusWith<RecordId> insertRecord(
+        OperationContext* opCtx, const char* data, int len, Timestamp, bool enforceQuota) {
         _numInserts++;
         return StatusWith<RecordId>(RecordId(6, 4));
     }
 
     virtual Status insertRecordsWithDocWriter(OperationContext* opCtx,
                                               const DocWriter* const* docs,
+                                              const Timestamp*,
                                               size_t nDocs,
                                               RecordId* idsOut) {
         _numInserts += nDocs;
diff --git a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_record_store.cpp b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_record_store.cpp
index 74662c82366..807cb94716e 100644
--- a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_record_store.cpp
+++ b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_record_store.cpp
@@ -391,10 +391,8 @@ StatusWith<RecordId> EphemeralForTestRecordStore::extractAndCheckLocForOplog(con
     return status;
 }
 
-StatusWith<RecordId> EphemeralForTestRecordStore::insertRecord(OperationContext* opCtx,
-                                                               const char* data,
-                                                               int len,
-                                                               bool enforceQuota) {
+StatusWith<RecordId> EphemeralForTestRecordStore::insertRecord(
+    OperationContext* opCtx, const char* data, int len, Timestamp, bool enforceQuota) {
     if (_isCapped && len > _cappedMaxSize) {
         // We use dataSize for capped rollover and we don't want to delete everything if we know
         // this won't fit.
@@ -426,6 +424,7 @@ StatusWith<RecordId> EphemeralForTestRecordStore::insertRecord(OperationContext*
 
 Status EphemeralForTestRecordStore::insertRecordsWithDocWriter(OperationContext* opCtx,
                                                                const DocWriter* const* docs,
+                                                               const Timestamp*,
                                                                size_t nDocs,
                                                                RecordId* idsOut) {
     stdx::lock_guard<stdx::mutex> lock(_data->recordsMutex);
diff --git a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_record_store.h b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_record_store.h
index b61e7f7e031..ffeb5b872fa 100644
--- a/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_record_store.h
+++ b/src/mongo/db/storage/ephemeral_for_test/ephemeral_for_test_record_store.h
@@ -62,13 +62,12 @@ public:
 
     virtual void deleteRecord(OperationContext* opCtx, const RecordId& dl);
 
-    virtual StatusWith<RecordId> insertRecord(OperationContext* opCtx,
-                                              const char* data,
-                                              int len,
-                                              bool enforceQuota);
+    virtual StatusWith<RecordId> insertRecord(
+        OperationContext* opCtx, const char* data, int len, Timestamp, bool enforceQuota);
 
     virtual Status insertRecordsWithDocWriter(OperationContext* opCtx,
                                               const DocWriter* const* docs,
+                                              const Timestamp*,
                                               size_t nDocs,
                                               RecordId* idsOut);
 
diff --git a/src/mongo/db/storage/kv/kv_catalog.cpp b/src/mongo/db/storage/kv/kv_catalog.cpp
index 5e23a27ff00..f92e1784294 100644
--- a/src/mongo/db/storage/kv/kv_catalog.cpp
+++ b/src/mongo/db/storage/kv/kv_catalog.cpp
@@ -247,7 +247,9 @@ void KVCatalog::FeatureTracker::putInfo(OperationContext* opCtx, const FeatureBi
         // This is the first time a feature is being marked as in-use or not in-use, so we must
         // insert the feature document rather than update it.
         const bool enforceQuota = false;
-        auto rid = _catalog->_rs->insertRecord(opCtx, obj.objdata(), obj.objsize(), enforceQuota);
+        // TODO SERVER-30638: using timestamp 0 for these inserts
+        auto rid = _catalog->_rs->insertRecord(
+            opCtx, obj.objdata(), obj.objsize(), Timestamp(), enforceQuota);
         fassert(40113, rid.getStatus());
         _rid = rid.getValue();
     } else {
@@ -364,8 +366,10 @@ Status KVCatalog::newCollection(OperationContext* opCtx,
         b.append("md", md.toBSON());
         obj = b.obj();
     }
-
-    StatusWith<RecordId> res = _rs->insertRecord(opCtx, obj.objdata(), obj.objsize(), false);
+    const bool enforceQuota = false;
+    // TODO SERVER-30638: using timestamp 0 for these inserts.
+    StatusWith<RecordId> res =
+        _rs->insertRecord(opCtx, obj.objdata(), obj.objsize(), Timestamp(), enforceQuota);
     if (!res.isOK())
         return res.getStatus();
 
diff --git a/src/mongo/db/storage/kv/kv_engine_test_harness.cpp b/src/mongo/db/storage/kv/kv_engine_test_harness.cpp
index 4661b92e7c6..bef9943d5c1 100644
--- a/src/mongo/db/storage/kv/kv_engine_test_harness.cpp
+++ b/src/mongo/db/storage/kv/kv_engine_test_harness.cpp
@@ -77,7 +77,7 @@ TEST(KVEngineTestHarness, SimpleRS1) {
     {
         MyOperationContext opCtx(engine);
         WriteUnitOfWork uow(&opCtx);
-        StatusWith<RecordId> res = rs->insertRecord(&opCtx, "abc", 4, false);
+        StatusWith<RecordId> res = rs->insertRecord(&opCtx, "abc", 4, Timestamp(), false);
         ASSERT_OK(res.getStatus());
         loc = res.getValue();
         uow.commit();
@@ -117,7 +117,7 @@ TEST(KVEngineTestHarness, Restart1) {
         {
             MyOperationContext opCtx(engine);
             WriteUnitOfWork uow(&opCtx);
-            StatusWith<RecordId> res = rs->insertRecord(&opCtx, "abc", 4, false);
+            StatusWith<RecordId> res = rs->insertRecord(&opCtx, "abc", 4, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
diff --git a/src/mongo/db/storage/kv/kv_engine_test_snapshots.cpp b/src/mongo/db/storage/kv/kv_engine_test_snapshots.cpp
index 5c3bd3f869a..d9d14c2e758 100644
--- a/src/mongo/db/storage/kv/kv_engine_test_snapshots.cpp
+++ b/src/mongo/db/storage/kv/kv_engine_test_snapshots.cpp
@@ -106,7 +106,8 @@ public:
     }
 
     RecordId insertRecord(OperationContext* opCtx, std::string contents = "abcd") {
-        auto id = rs->insertRecord(opCtx, contents.c_str(), contents.length() + 1, false);
+        auto id =
+            rs->insertRecord(opCtx, contents.c_str(), contents.length() + 1, Timestamp(), false);
         ASSERT_OK(id);
         return id.getValue();
     }
diff --git a/src/mongo/db/storage/mmap_v1/btree/btree_logic.cpp b/src/mongo/db/storage/mmap_v1/btree/btree_logic.cpp
index c50a8c15162..3c793c1534a 100644
--- a/src/mongo/db/storage/mmap_v1/btree/btree_logic.cpp
+++ b/src/mongo/db/storage/mmap_v1/btree/btree_logic.cpp
@@ -1855,7 +1855,8 @@ Status BtreeLogic<BtreeLayout>::initAsEmpty(OperationContext* opCtx) {
 template <class BtreeLayout>
 DiskLoc BtreeLogic<BtreeLayout>::_addBucket(OperationContext* opCtx) {
     DummyDocWriter docWriter(BtreeLayout::BucketSize);
-    StatusWith<RecordId> loc = _recordStore->insertRecordWithDocWriter(opCtx, &docWriter);
+    StatusWith<RecordId> loc =
+        _recordStore->insertRecordWithDocWriter(opCtx, &docWriter, Timestamp());
     // XXX: remove this(?) or turn into massert or sanely bubble it back up.
     uassertStatusOK(loc.getStatus());
 
diff --git a/src/mongo/db/storage/mmap_v1/btree/btree_logic_test.cpp b/src/mongo/db/storage/mmap_v1/btree/btree_logic_test.cpp
index d4274feaa4b..b3667b14e40 100644
--- a/src/mongo/db/storage/mmap_v1/btree/btree_logic_test.cpp
+++ b/src/mongo/db/storage/mmap_v1/btree/btree_logic_test.cpp
@@ -2238,7 +2238,8 @@ public:
         this->locate(key1, 0, true, this->_helper.headManager.getHead(&opCtx), 1);
 
         // Add another record to produce another diskloc.
-        StatusWith<RecordId> s = this->_helper.recordStore.insertRecord(&opCtx, "a", 1, false);
+        StatusWith<RecordId> s =
+            this->_helper.recordStore.insertRecord(&opCtx, "a", 1, Timestamp(), false);
 
         ASSERT_TRUE(s.isOK());
         ASSERT_EQUALS(3, this->_helper.recordStore.numRecords(NULL));
diff --git a/src/mongo/db/storage/mmap_v1/btree/btree_test_help.cpp b/src/mongo/db/storage/mmap_v1/btree/btree_test_help.cpp
index e02a01923f7..6e5bce9b553 100644
--- a/src/mongo/db/storage/mmap_v1/btree/btree_test_help.cpp
+++ b/src/mongo/db/storage/mmap_v1/btree/btree_test_help.cpp
@@ -74,8 +74,8 @@ BtreeLogicTestHelper<OnDiskFormat>::BtreeLogicTestHelper(const BSONObj& order)
     // Generate a valid record location for a "fake" record, which we will repeatedly use
     // thoughout the tests.
     OperationContextNoop opCtx;
-    StatusWith<RecordId> s =
-        recordStore.insertRecord(&opCtx, randomData.c_str(), randomData.length(), false);
+    StatusWith<RecordId> s = recordStore.insertRecord(
+        &opCtx, randomData.c_str(), randomData.length(), Timestamp(), false);
 
     ASSERT_TRUE(s.isOK());
     ASSERT_EQUALS(1, recordStore.numRecords(NULL));
diff --git a/src/mongo/db/storage/mmap_v1/catalog/namespace_details_collection_entry.cpp b/src/mongo/db/storage/mmap_v1/catalog/namespace_details_collection_entry.cpp
index ed7efe2b57d..c0ecd805ad1 100644
--- a/src/mongo/db/storage/mmap_v1/catalog/namespace_details_collection_entry.cpp
+++ b/src/mongo/db/storage/mmap_v1/catalog/namespace_details_collection_entry.cpp
@@ -280,8 +280,9 @@ Status NamespaceDetailsCollectionCatalogEntry::prepareForIndexBuild(OperationCon
                                                                     const IndexDescriptor* desc) {
     BSONObj spec = desc->infoObj();
     // 1) entry in system.indexs
+    // TODO SERVER-30638: using timestamp 0 for these inserts.
     StatusWith<RecordId> systemIndexesEntry =
-        _indexRecordStore->insertRecord(opCtx, spec.objdata(), spec.objsize(), false);
+        _indexRecordStore->insertRecord(opCtx, spec.objdata(), spec.objsize(), Timestamp(), false);
     if (!systemIndexesEntry.isOK())
         return systemIndexesEntry.getStatus();
 
@@ -391,8 +392,9 @@ void NamespaceDetailsCollectionCatalogEntry::_updateSystemNamespaces(OperationCo
         opCtx, _namespacesRecordId, newEntry.objdata(), newEntry.objsize(), false, NULL);
 
     if (ErrorCodes::NeedsDocumentMove == result) {
+        // TODO SERVER-30638: using timestamp 0 for these inserts.
         StatusWith<RecordId> newLocation = _namespacesRecordStore->insertRecord(
-            opCtx, newEntry.objdata(), newEntry.objsize(), false);
+            opCtx, newEntry.objdata(), newEntry.objsize(), Timestamp(), false);
         fassert(40074, newLocation.getStatus().isOK());
 
         // Invalidate old namespace record
diff --git a/src/mongo/db/storage/mmap_v1/heap_record_store_btree.cpp b/src/mongo/db/storage/mmap_v1/heap_record_store_btree.cpp
index bf761f2f2f0..093808ea9c8 100644
--- a/src/mongo/db/storage/mmap_v1/heap_record_store_btree.cpp
+++ b/src/mongo/db/storage/mmap_v1/heap_record_store_btree.cpp
@@ -65,10 +65,8 @@ void HeapRecordStoreBtree::deleteRecord(OperationContext* opCtx, const RecordId&
     invariant(_records.erase(loc) == 1);
 }
 
-StatusWith<RecordId> HeapRecordStoreBtree::insertRecord(OperationContext* opCtx,
-                                                        const char* data,
-                                                        int len,
-                                                        bool enforceQuota) {
+StatusWith<RecordId> HeapRecordStoreBtree::insertRecord(
+    OperationContext* opCtx, const char* data, int len, Timestamp, bool enforceQuota) {
     MmapV1RecordHeader rec(len);
     memcpy(rec.data.get(), data, len);
 
@@ -82,6 +80,7 @@ StatusWith<RecordId> HeapRecordStoreBtree::insertRecord(OperationContext* opCtx,
 
 Status HeapRecordStoreBtree::insertRecordsWithDocWriter(OperationContext* opCtx,
                                                         const DocWriter* const* docs,
+                                                        const Timestamp*,
                                                         size_t nDocs,
                                                         RecordId* idsOut) {
     // This class is only for unit tests of the mmapv1 btree code and this is how it is called.
diff --git a/src/mongo/db/storage/mmap_v1/heap_record_store_btree.h b/src/mongo/db/storage/mmap_v1/heap_record_store_btree.h
index 07583680edf..c5d5299a9b7 100644
--- a/src/mongo/db/storage/mmap_v1/heap_record_store_btree.h
+++ b/src/mongo/db/storage/mmap_v1/heap_record_store_btree.h
@@ -55,13 +55,12 @@ public:
 
     virtual void deleteRecord(OperationContext* opCtx, const RecordId& dl);
 
-    virtual StatusWith<RecordId> insertRecord(OperationContext* opCtx,
-                                              const char* data,
-                                              int len,
-                                              bool enforceQuota);
+    virtual StatusWith<RecordId> insertRecord(
+        OperationContext* opCtx, const char* data, int len, Timestamp, bool enforceQuota);
 
     virtual Status insertRecordsWithDocWriter(OperationContext* opCtx,
                                               const DocWriter* const* docs,
+                                              const Timestamp*,
                                               size_t nDocs,
                                               RecordId* idsOut);
 
diff --git a/src/mongo/db/storage/mmap_v1/mmap_v1_database_catalog_entry.cpp b/src/mongo/db/storage/mmap_v1/mmap_v1_database_catalog_entry.cpp
index 08ff6b26c21..75ca4cda551 100644
--- a/src/mongo/db/storage/mmap_v1/mmap_v1_database_catalog_entry.cpp
+++ b/src/mongo/db/storage/mmap_v1/mmap_v1_database_catalog_entry.cpp
@@ -289,9 +289,9 @@ Status MMAPV1DatabaseCatalogEntry::renameCollection(OperationContext* opCtx,
             }
             newIndexSpec = b.obj();
         }
-
+        // TODO SERVER-30638: using timestamp 0 for these inserts.
         StatusWith<RecordId> newIndexSpecLoc = systemIndexRecordStore->insertRecord(
-            opCtx, newIndexSpec.objdata(), newIndexSpec.objsize(), false);
+            opCtx, newIndexSpec.objdata(), newIndexSpec.objsize(), Timestamp(), false);
         if (!newIndexSpecLoc.isOK())
             return newIndexSpecLoc.getStatus();
 
@@ -847,8 +847,9 @@ RecordId MMAPV1DatabaseCatalogEntry::_addNamespaceToNamespaceCollection(Operatio
 
     RecordStoreV1Base* rs = _getNamespaceRecordStore();
     invariant(rs);
-
-    StatusWith<RecordId> loc = rs->insertRecord(opCtx, obj.objdata(), obj.objsize(), false);
+    // TODO SERVER-30638: using timestamp 0 for these inserts.
+    StatusWith<RecordId> loc =
+        rs->insertRecord(opCtx, obj.objdata(), obj.objsize(), Timestamp(), false);
     massertStatusOK(loc.getStatus());
     return loc.getValue();
 }
diff --git a/src/mongo/db/storage/mmap_v1/record_store_v1_base.cpp b/src/mongo/db/storage/mmap_v1/record_store_v1_base.cpp
index ebcf6d6e702..a82ec878315 100644
--- a/src/mongo/db/storage/mmap_v1/record_store_v1_base.cpp
+++ b/src/mongo/db/storage/mmap_v1/record_store_v1_base.cpp
@@ -301,6 +301,7 @@ DiskLoc RecordStoreV1Base::getPrevRecordInExtent(OperationContext* opCtx,
 
 Status RecordStoreV1Base::insertRecordsWithDocWriter(OperationContext* opCtx,
                                                      const DocWriter* const* docs,
+                                                     const Timestamp*,
                                                      size_t nDocs,
                                                      RecordId* idsOut) {
     for (size_t i = 0; i < nDocs; i++) {
@@ -339,10 +340,8 @@ Status RecordStoreV1Base::insertRecordsWithDocWriter(OperationContext* opCtx,
 }
 
 
-StatusWith<RecordId> RecordStoreV1Base::insertRecord(OperationContext* opCtx,
-                                                     const char* data,
-                                                     int len,
-                                                     bool enforceQuota) {
+StatusWith<RecordId> RecordStoreV1Base::insertRecord(
+    OperationContext* opCtx, const char* data, int len, Timestamp, bool enforceQuota) {
     if (len < 4) {
         return StatusWith<RecordId>(ErrorCodes::InvalidLength, "record has to be >= 4 bytes");
     }
diff --git a/src/mongo/db/storage/mmap_v1/record_store_v1_base.h b/src/mongo/db/storage/mmap_v1/record_store_v1_base.h
index 6dadf5487da..3dd86cfc0a8 100644
--- a/src/mongo/db/storage/mmap_v1/record_store_v1_base.h
+++ b/src/mongo/db/storage/mmap_v1/record_store_v1_base.h
@@ -189,13 +189,12 @@ public:
 
     void deleteRecord(OperationContext* opCtx, const RecordId& dl);
 
-    StatusWith<RecordId> insertRecord(OperationContext* opCtx,
-                                      const char* data,
-                                      int len,
-                                      bool enforceQuota);
+    StatusWith<RecordId> insertRecord(
+        OperationContext* opCtx, const char* data, int len, Timestamp, bool enforceQuota);
 
     Status insertRecordsWithDocWriter(OperationContext* opCtx,
                                       const DocWriter* const* docs,
+                                      const Timestamp*,
                                       size_t nDocs,
                                       RecordId* idsOut) final;
 
diff --git a/src/mongo/db/storage/mmap_v1/record_store_v1_capped_test.cpp b/src/mongo/db/storage/mmap_v1/record_store_v1_capped_test.cpp
index 2d95e1dad13..64c9ad1fbd7 100644
--- a/src/mongo/db/storage/mmap_v1/record_store_v1_capped_test.cpp
+++ b/src/mongo/db/storage/mmap_v1/record_store_v1_capped_test.cpp
@@ -72,9 +72,9 @@ void simpleInsertTest(const char* buf, int size) {
 
     rs.increaseStorageSize(&opCtx, 1024, false);
 
-    ASSERT_NOT_OK(rs.insertRecord(&opCtx, buf, 3, 1000).getStatus());
+    ASSERT_NOT_OK(rs.insertRecord(&opCtx, buf, 3, Timestamp(), true).getStatus());
 
-    rs.insertRecord(&opCtx, buf, size, 10000).status_with_transitional_ignore();
+    ASSERT_OK(rs.insertRecord(&opCtx, buf, size, Timestamp(), true).getStatus());
 
     {
         BSONObjBuilder b;
@@ -85,12 +85,12 @@ void simpleInsertTest(const char* buf, int size) {
     }
 
     for (int i = 0; i < 1000; i++) {
-        ASSERT_OK(rs.insertRecord(&opCtx, buf, size, 10000).getStatus());
+        ASSERT_OK(rs.insertRecord(&opCtx, buf, size, Timestamp(), true).getStatus());
     }
 
     long long start = md->numRecords();
     for (int i = 0; i < 1000; i++) {
-        ASSERT_OK(rs.insertRecord(&opCtx, buf, size, 10000).getStatus());
+        ASSERT_OK(rs.insertRecord(&opCtx, buf, size, Timestamp(), true).getStatus());
     }
     ASSERT_EQUALS(start, md->numRecords());
     ASSERT_GREATER_THAN(start, 100);
@@ -119,8 +119,10 @@ TEST(CappedRecordStoreV1, EmptySingleExtent) {
         initializeV1RS(&opCtx, records, drecs, NULL, &em, md);
     }
 
-    rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+
 
     {
         LocAndSize recs[] = {{DiskLoc(0, 1000), 100}, {}};
@@ -151,8 +153,9 @@ TEST(CappedRecordStoreV1, FirstLoopWithSingleExtentExactSize) {
         initializeV1RS(&opCtx, records, drecs, NULL, &em, md);
     }
 
-    rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
 
     {
         LocAndSize recs[] = {{DiskLoc(0, 1200), 100},  // first old record
@@ -190,8 +193,9 @@ TEST(CappedRecordStoreV1, NonFirstLoopWithSingleExtentExactSize) {
         initializeV1RS(&opCtx, records, drecs, NULL, &em, md);
     }
 
-    rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
 
     {
         LocAndSize recs[] = {{DiskLoc(0, 1200), 100},  // first old record
@@ -232,8 +236,9 @@ TEST(CappedRecordStoreV1, WillLoopWithout24SpareBytes) {
         initializeV1RS(&opCtx, records, drecs, NULL, &em, md);
     }
 
-    rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
 
     {
         LocAndSize recs[] = {{DiskLoc(0, 1200), 100},  // first old record
@@ -270,8 +275,9 @@ TEST(CappedRecordStoreV1, WontLoopWith24SpareBytes) {
         initializeV1RS(&opCtx, records, drecs, NULL, &em, md);
     }
 
-    rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
 
     {
         LocAndSize recs[] = {{DiskLoc(0, 1000), 100},
@@ -306,8 +312,9 @@ TEST(CappedRecordStoreV1, MoveToSecondExtentUnLooped) {
         initializeV1RS(&opCtx, records, drecs, NULL, &em, md);
     }
 
-    rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
 
     {
         LocAndSize recs[] = {{DiskLoc(0, 1000), 500},
@@ -345,8 +352,9 @@ TEST(CappedRecordStoreV1, MoveToSecondExtentLooped) {
         initializeV1RS(&opCtx, records, drecs, NULL, &em, md);
     }
 
-    rs.insertRecord(&opCtx, zeros, 200 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 200 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
 
     {
         LocAndSize recs[] = {{DiskLoc(0, 1000), 500},
@@ -379,7 +387,7 @@ TEST(CappedRecordStoreV1, OversizedRecordHuge) {
         initializeV1RS(&opCtx, records, drecs, NULL, &em, md);
     }
 
-    StatusWith<RecordId> status = rs.insertRecord(&opCtx, zeros, 16000, false);
+    StatusWith<RecordId> status = rs.insertRecord(&opCtx, zeros, 16000, Timestamp(), false);
     ASSERT_EQUALS(status.getStatus(), ErrorCodes::DocTooLargeForCapped);
     ASSERT_STRING_CONTAINS(status.getStatus().reason(), "larger than capped size");
 }
@@ -401,7 +409,7 @@ TEST(CappedRecordStoreV1, OversizedRecordMedium) {
     }
 
     StatusWith<RecordId> status =
-        rs.insertRecord(&opCtx, zeros, 1004 - MmapV1RecordHeader::HeaderSize, false);
+        rs.insertRecord(&opCtx, zeros, 1004 - MmapV1RecordHeader::HeaderSize, Timestamp(), false);
     ASSERT_EQUALS(status.getStatus(), ErrorCodes::DocTooLargeForCapped);
     ASSERT_STRING_CONTAINS(status.getStatus().reason(), "doesn't fit");
 }
@@ -431,16 +439,21 @@ TEST(CappedRecordStoreV1Scrambler, Minimal) {
         initializeV1RS(&opCtx, records, drecs, NULL, &em, md);
     }
 
-    rs.insertRecord(&opCtx, zeros, 500 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 300 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 400 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();  // won't fit at end so wraps
-    rs.insertRecord(&opCtx, zeros, 120 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();  // fits at end
-    rs.insertRecord(&opCtx, zeros, 60 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();  // fits in earlier hole
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 500 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 300 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 400 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());  // won't fit at end so wraps
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 120 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());  // fits at end
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 60 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());  // fits in earlier hole
 
     {
         LocAndSize recs[] = {{DiskLoc(0, 1500), 300},  // 2nd insert
@@ -477,62 +490,90 @@ TEST(CappedRecordStoreV1Scrambler, FourDeletedRecordsInSingleExtent) {
 
     // This list of sizes was empirically generated to achieve this outcome. Don't think too
     // much about them.
-    rs.insertRecord(&opCtx, zeros, 500 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 300 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 304 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 76 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 96 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 76 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 200 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 200 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 56 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 96 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 104 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 96 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 60 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 60 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 146 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 146 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 40 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 40 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 36 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 96 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 200 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 60 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
-    rs.insertRecord(&opCtx, zeros, 64 - MmapV1RecordHeader::HeaderSize, false)
-        .status_with_transitional_ignore();
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 500 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 300 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 304 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 76 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 96 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 76 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 200 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 200 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 56 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 96 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 104 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 96 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 60 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 60 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 146 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 146 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 40 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 40 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 36 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 100 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 96 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 200 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 60 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
+    ASSERT_OK(
+        rs.insertRecord(&opCtx, zeros, 64 - MmapV1RecordHeader::HeaderSize, Timestamp(), false)
+            .getStatus());
 
     {
         LocAndSize recs[] = {{DiskLoc(0, 1148), 148},
diff --git a/src/mongo/db/storage/mmap_v1/record_store_v1_simple.cpp b/src/mongo/db/storage/mmap_v1/record_store_v1_simple.cpp
index 42d2daedec1..fc30532ed31 100644
--- a/src/mongo/db/storage/mmap_v1/record_store_v1_simple.cpp
+++ b/src/mongo/db/storage/mmap_v1/record_store_v1_simple.cpp
@@ -369,7 +369,8 @@ void SimpleRecordStoreV1::_compactExtent(OperationContext* opCtx,
                 // start of the compact, this insert will allocate a record in a new extent.
                 // See the comment in compact() for more details.
                 CompactDocWriter writer(recOld, rawDataSize, allocationSize);
-                StatusWith<RecordId> status = insertRecordWithDocWriter(opCtx, &writer);
+                StatusWith<RecordId> status =
+                    insertRecordWithDocWriter(opCtx, &writer, Timestamp());
                 uassertStatusOK(status.getStatus());
                 const MmapV1RecordHeader* newRec =
                     recordFor(DiskLoc::fromRecordId(status.getValue()));
diff --git a/src/mongo/db/storage/mmap_v1/record_store_v1_simple_test.cpp b/src/mongo/db/storage/mmap_v1/record_store_v1_simple_test.cpp
index 47c85e38974..d1b3cb5c234 100644
--- a/src/mongo/db/storage/mmap_v1/record_store_v1_simple_test.cpp
+++ b/src/mongo/db/storage/mmap_v1/record_store_v1_simple_test.cpp
@@ -123,7 +123,8 @@ TEST(SimpleRecordStoreV1, AllocQuantized) {
     SimpleRecordStoreV1 rs(&opCtx, myns, md, &em, false);
 
     BSONObj obj = docForRecordSize(300);
-    StatusWith<RecordId> result = rs.insertRecord(&opCtx, obj.objdata(), obj.objsize(), false);
+    StatusWith<RecordId> result =
+        rs.insertRecord(&opCtx, obj.objdata(), obj.objsize(), Timestamp(), false);
     ASSERT(result.isOK());
 
     // The length of the allocated record is quantized.
@@ -141,7 +142,8 @@ TEST(SimpleRecordStoreV1, AllocNonQuantized) {
     SimpleRecordStoreV1 rs(&opCtx, myns, md, &em, false);
 
     BSONObj obj = docForRecordSize(300);
-    StatusWith<RecordId> result = rs.insertRecord(&opCtx, obj.objdata(), obj.objsize(), false);
+    StatusWith<RecordId> result =
+        rs.insertRecord(&opCtx, obj.objdata(), obj.objsize(), Timestamp(), false);
     ASSERT(result.isOK());
 
     // The length of the allocated record is quantized.
@@ -159,7 +161,8 @@ TEST(SimpleRecordStoreV1, AllocNonQuantizedStillAligned) {
     SimpleRecordStoreV1 rs(&opCtx, myns, md, &em, false);
 
     BSONObj obj = docForRecordSize(298);
-    StatusWith<RecordId> result = rs.insertRecord(&opCtx, obj.objdata(), obj.objsize(), false);
+    StatusWith<RecordId> result =
+        rs.insertRecord(&opCtx, obj.objdata(), obj.objsize(), Timestamp(), false);
     ASSERT(result.isOK());
 
     // The length of the allocated record is quantized.
@@ -177,7 +180,7 @@ TEST(SimpleRecordStoreV1, AllocQuantizedWithDocWriter) {
     SimpleRecordStoreV1 rs(&opCtx, myns, md, &em, false);
 
     BsonDocWriter docWriter(docForRecordSize(300), true);
-    StatusWith<RecordId> result = rs.insertRecordWithDocWriter(&opCtx, &docWriter);
+    StatusWith<RecordId> result = rs.insertRecordWithDocWriter(&opCtx, &docWriter, Timestamp());
     ASSERT(result.isOK());
 
     // The length of the allocated record is quantized.
@@ -197,7 +200,7 @@ TEST(SimpleRecordStoreV1, AllocNonQuantizedDocWriter) {
     SimpleRecordStoreV1 rs(&opCtx, myns + "$x", md, &em, false);
 
     BsonDocWriter docWriter(docForRecordSize(300), false);
-    StatusWith<RecordId> result = rs.insertRecordWithDocWriter(&opCtx, &docWriter);
+    StatusWith<RecordId> result = rs.insertRecordWithDocWriter(&opCtx, &docWriter, Timestamp());
     ASSERT(result.isOK());
 
     // The length of the allocated record is not quantized.
@@ -215,7 +218,7 @@ TEST(SimpleRecordStoreV1, AllocAlignedDocWriter) {
     SimpleRecordStoreV1 rs(&opCtx, myns + "$x", md, &em, false);
 
     BsonDocWriter docWriter(docForRecordSize(298), false);
-    StatusWith<RecordId> result = rs.insertRecordWithDocWriter(&opCtx, &docWriter);
+    StatusWith<RecordId> result = rs.insertRecordWithDocWriter(&opCtx, &docWriter, Timestamp());
     ASSERT(result.isOK());
 
     ASSERT_EQUALS(300,
@@ -236,7 +239,8 @@ TEST(SimpleRecordStoreV1, AllocUseQuantizedDeletedRecordWithoutSplit) {
     }
 
     BsonDocWriter docWriter(docForRecordSize(300), true);
-    StatusWith<RecordId> actualLocation = rs.insertRecordWithDocWriter(&opCtx, &docWriter);
+    StatusWith<RecordId> actualLocation =
+        rs.insertRecordWithDocWriter(&opCtx, &docWriter, Timestamp());
     ASSERT_OK(actualLocation.getStatus());
 
     {
@@ -261,7 +265,8 @@ TEST(SimpleRecordStoreV1, AllocUseQuantizedDeletedRecordWithSplit) {
     }
 
     BsonDocWriter docWriter(docForRecordSize(300), true);
-    StatusWith<RecordId> actualLocation = rs.insertRecordWithDocWriter(&opCtx, &docWriter);
+    StatusWith<RecordId> actualLocation =
+        rs.insertRecordWithDocWriter(&opCtx, &docWriter, Timestamp());
     ASSERT_OK(actualLocation.getStatus());
 
     {
@@ -286,7 +291,8 @@ TEST(SimpleRecordStoreV1, AllocUseNonQuantizedDeletedRecordWithoutSplit) {
     }
 
     BsonDocWriter docWriter(docForRecordSize(300), false);
-    StatusWith<RecordId> actualLocation = rs.insertRecordWithDocWriter(&opCtx, &docWriter);
+    StatusWith<RecordId> actualLocation =
+        rs.insertRecordWithDocWriter(&opCtx, &docWriter, Timestamp());
     ASSERT_OK(actualLocation.getStatus());
 
     {
@@ -311,7 +317,8 @@ TEST(SimpleRecordStoreV1, AllocUseNonQuantizedDeletedRecordWithSplit) {
     }
 
     BsonDocWriter docWriter(docForRecordSize(300), false);
-    StatusWith<RecordId> actualLocation = rs.insertRecordWithDocWriter(&opCtx, &docWriter);
+    StatusWith<RecordId> actualLocation =
+        rs.insertRecordWithDocWriter(&opCtx, &docWriter, Timestamp());
     ASSERT_OK(actualLocation.getStatus());
 
     {
@@ -338,7 +345,8 @@ TEST(SimpleRecordStoreV1, GrabBagIsUsed) {
     }
 
     BsonDocWriter docWriter(docForRecordSize(256), false);
-    StatusWith<RecordId> actualLocation = rs.insertRecordWithDocWriter(&opCtx, &docWriter);
+    StatusWith<RecordId> actualLocation =
+        rs.insertRecordWithDocWriter(&opCtx, &docWriter, Timestamp());
     ASSERT_OK(actualLocation.getStatus());
 
     {
@@ -366,7 +374,8 @@ TEST(SimpleRecordStoreV1, GrabBagIsPoppedEvenIfUnneeded) {
     }
 
     BsonDocWriter docWriter(docForRecordSize(1000), false);
-    StatusWith<RecordId> actualLocation = rs.insertRecordWithDocWriter(&opCtx, &docWriter);
+    StatusWith<RecordId> actualLocation =
+        rs.insertRecordWithDocWriter(&opCtx, &docWriter, Timestamp());
     ASSERT_OK(actualLocation.getStatus());
 
     {
@@ -394,7 +403,8 @@ TEST(SimpleRecordStoreV1, GrabBagIsPoppedEvenIfUnusable) {
     }
 
     BsonDocWriter docWriter(docForRecordSize(8 * 1024 * 1024), false);
-    StatusWith<RecordId> actualLocation = rs.insertRecordWithDocWriter(&opCtx, &docWriter);
+    StatusWith<RecordId> actualLocation =
+        rs.insertRecordWithDocWriter(&opCtx, &docWriter, Timestamp());
     ASSERT_OK(actualLocation.getStatus());
 
     {
@@ -415,7 +425,7 @@ TEST(SimpleRecordStoreV1, FullSimple1) {
 
 
     ASSERT_EQUALS(0, md->numRecords());
-    StatusWith<RecordId> result = rs.insertRecord(&opCtx, "abc", 4, 1000);
+    StatusWith<RecordId> result = rs.insertRecord(&opCtx, "abc", 4, Timestamp(), true);
     ASSERT_TRUE(result.isOK());
     ASSERT_EQUALS(1, md->numRecords());
     RecordData recordData = rs.dataFor(&opCtx, result.getValue());
diff --git a/src/mongo/db/storage/record_store.h b/src/mongo/db/storage/record_store.h
index ca5032c941e..c84dbdcf1f3 100644
--- a/src/mongo/db/storage/record_store.h
+++ b/src/mongo/db/storage/record_store.h
@@ -371,44 +371,23 @@ public:
 
     virtual void deleteRecord(OperationContext* opCtx, const RecordId& dl) = 0;
 
-    virtual StatusWith<RecordId> insertRecordT(OperationContext* opCtx,
-                                               const char* data,
-                                               int len,
-                                               Timestamp timestamp,
-                                               bool enforceQuota) {
-        return insertRecord(opCtx, data, len, enforceQuota);
-    }
-
     virtual StatusWith<RecordId> insertRecord(OperationContext* opCtx,
                                               const char* data,
                                               int len,
+                                              Timestamp timestamp,
                                               bool enforceQuota) = 0;
 
-    virtual Status insertRecordsT(OperationContext* opCtx,
-                                  std::vector<Record>* records,
-                                  std::vector<Timestamp>* timestamps,
-                                  bool enforceQuota) {
-        int index = 0;
-        for (auto& record : *records) {
-            StatusWith<RecordId> res = insertRecordT(opCtx,
-                                                     record.data.data(),
-                                                     record.data.size(),
-                                                     (*timestamps)[index++],
-                                                     enforceQuota);
-            if (!res.isOK())
-                return res.getStatus();
-
-            record.id = res.getValue();
-        }
-        return Status::OK();
-    }
-
     virtual Status insertRecords(OperationContext* opCtx,
                                  std::vector<Record>* records,
+                                 std::vector<Timestamp>* timestamps,
                                  bool enforceQuota) {
+        int index = 0;
         for (auto& record : *records) {
-            StatusWith<RecordId> res =
-                insertRecord(opCtx, record.data.data(), record.data.size(), enforceQuota);
+            StatusWith<RecordId> res = insertRecord(opCtx,
+                                                    record.data.data(),
+                                                    record.data.size(),
+                                                    (*timestamps)[index++],
+                                                    enforceQuota);
             if (!res.isOK())
                 return res.getStatus();
 
@@ -426,35 +405,20 @@ public:
      * On success, if idsOut is non-null the RecordIds of the inserted records will be written into
      * it. It must have space for nDocs RecordIds.
      */
-    virtual Status insertRecordsWithDocWriterT(OperationContext* opCtx,
-                                               const DocWriter* const* docs,
-                                               Timestamp* timestamps,
-                                               size_t nDocs,
-                                               RecordId* idsOut = nullptr) {
-        return insertRecordsWithDocWriter(opCtx, docs, nDocs, idsOut);
-    };
-
     virtual Status insertRecordsWithDocWriter(OperationContext* opCtx,
                                               const DocWriter* const* docs,
+                                              const Timestamp* timestamps,
                                               size_t nDocs,
                                               RecordId* idsOut = nullptr) = 0;
 
     /**
      * A thin wrapper around insertRecordsWithDocWriter() to simplify handling of single DocWriters.
      */
-    StatusWith<RecordId> insertRecordWithDocWriterT(OperationContext* opCtx,
-                                                    const DocWriter* doc,
-                                                    Timestamp timestamp) {
-        RecordId out;
-        Status status = insertRecordsWithDocWriterT(opCtx, &doc, &timestamp, 1, &out);
-        if (!status.isOK())
-            return status;
-        return out;
-    }
-
-    StatusWith<RecordId> insertRecordWithDocWriter(OperationContext* opCtx, const DocWriter* doc) {
+    StatusWith<RecordId> insertRecordWithDocWriter(OperationContext* opCtx,
+                                                   const DocWriter* doc,
+                                                   Timestamp timestamp) {
         RecordId out;
-        Status status = insertRecordsWithDocWriter(opCtx, &doc, 1, &out);
+        Status status = insertRecordsWithDocWriter(opCtx, &doc, &timestamp, 1, &out);
         if (!status.isOK())
             return status;
         return out;
diff --git a/src/mongo/db/storage/record_store_test_capped_visibility.cpp b/src/mongo/db/storage/record_store_test_capped_visibility.cpp
index a304614715c..6b778dd2dce 100644
--- a/src/mongo/db/storage/record_store_test_capped_visibility.cpp
+++ b/src/mongo/db/storage/record_store_test_capped_visibility.cpp
@@ -42,7 +42,7 @@ namespace {
 
 RecordId doInsert(unowned_ptr<OperationContext> opCtx, unowned_ptr<RecordStore> rs) {
     static char zeros[16];
-    return uassertStatusOK(rs->insertRecord(opCtx, zeros, sizeof(zeros), false));
+    return uassertStatusOK(rs->insertRecord(opCtx, zeros, sizeof(zeros), Timestamp(), false));
 }
 
 // macro to keep assert line numbers correct.
diff --git a/src/mongo/db/storage/record_store_test_datafor.cpp b/src/mongo/db/storage/record_store_test_datafor.cpp
index a1935dc0d93..672fa03e017 100644
--- a/src/mongo/db/storage/record_store_test_datafor.cpp
+++ b/src/mongo/db/storage/record_store_test_datafor.cpp
@@ -63,7 +63,7 @@ TEST(RecordStoreTestHarness, DataFor) {
         {
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -107,7 +107,7 @@ TEST(RecordStoreTestHarness, DataForMultiple) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             uow.commit();
diff --git a/src/mongo/db/storage/record_store_test_datasize.cpp b/src/mongo/db/storage/record_store_test_datasize.cpp
index a7f234ea7f4..3dad519623b 100644
--- a/src/mongo/db/storage/record_store_test_datasize.cpp
+++ b/src/mongo/db/storage/record_store_test_datasize.cpp
@@ -80,7 +80,7 @@ TEST(RecordStoreTestHarness, DataSizeNonEmpty) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             uow.commit();
         }
diff --git a/src/mongo/db/storage/record_store_test_deleterecord.cpp b/src/mongo/db/storage/record_store_test_deleterecord.cpp
index 0a7dc44d6f0..0d630c0d0be 100644
--- a/src/mongo/db/storage/record_store_test_deleterecord.cpp
+++ b/src/mongo/db/storage/record_store_test_deleterecord.cpp
@@ -63,7 +63,7 @@ TEST(RecordStoreTestHarness, DeleteRecord) {
         {
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -111,7 +111,7 @@ TEST(RecordStoreTestHarness, DeleteMultipleRecords) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             uow.commit();
diff --git a/src/mongo/db/storage/record_store_test_harness.cpp b/src/mongo/db/storage/record_store_test_harness.cpp
index d7bb992badd..52dcaec6766 100644
--- a/src/mongo/db/storage/record_store_test_harness.cpp
+++ b/src/mongo/db/storage/record_store_test_harness.cpp
@@ -60,7 +60,7 @@ TEST(RecordStoreTestHarness, Simple1) {
         {
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, false);
+                rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc1 = res.getValue();
             uow.commit();
@@ -87,7 +87,7 @@ TEST(RecordStoreTestHarness, Simple1) {
         {
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, false);
+                rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             uow.commit();
         }
@@ -132,7 +132,7 @@ TEST(RecordStoreTestHarness, Simple1InsertDocWroter) {
             WriteUnitOfWork uow(opCtx.get());
             DummyDocWriter dw;
             StatusWith<RecordId> res =
-                rs->insertRecordWithDocWriterT(opCtx.get(), &dw, Timestamp(1));
+                rs->insertRecordWithDocWriter(opCtx.get(), &dw, Timestamp(1));
             ASSERT_OK(res.getStatus());
             loc1 = res.getValue();
             uow.commit();
@@ -160,7 +160,7 @@ TEST(RecordStoreTestHarness, Delete1) {
         {
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, false);
+                rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -205,9 +205,9 @@ TEST(RecordStoreTestHarness, Delete2) {
         {
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, false);
+                rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
-            res = rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, false);
+            res = rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -248,7 +248,7 @@ TEST(RecordStoreTestHarness, Update1) {
         {
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), s1.c_str(), s1.size() + 1, false);
+                rs->insertRecord(opCtx.get(), s1.c_str(), s1.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -273,7 +273,7 @@ TEST(RecordStoreTestHarness, Update1) {
                 // provides an equivalent check as only MMAPv1 will/should return false.
                 ASSERT_FALSE(harnessHelper->supportsDocLocking());
                 StatusWith<RecordId> newLocation =
-                    rs->insertRecord(opCtx.get(), s2.c_str(), s2.size() + 1, false);
+                    rs->insertRecord(opCtx.get(), s2.c_str(), s2.size() + 1, Timestamp(), false);
                 ASSERT_OK(newLocation.getStatus());
                 rs->deleteRecord(opCtx.get(), loc);
                 loc = newLocation.getValue();
@@ -309,7 +309,7 @@ TEST(RecordStoreTestHarness, UpdateInPlace1) {
         {
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), s1Rec.data(), s1Rec.size(), -1);
+                rs->insertRecord(opCtx.get(), s1Rec.data(), s1Rec.size(), Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -363,7 +363,7 @@ TEST(RecordStoreTestHarness, Truncate1) {
         {
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, false);
+                rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -413,8 +413,8 @@ TEST(RecordStoreTestHarness, Cursor1) {
             WriteUnitOfWork uow(opCtx.get());
             for (int i = 0; i < N; i++) {
                 string s = str::stream() << "eliot" << i;
-                ASSERT_OK(
-                    rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, false).getStatus());
+                ASSERT_OK(rs->insertRecord(opCtx.get(), s.c_str(), s.size() + 1, Timestamp(), false)
+                              .getStatus());
             }
             uow.commit();
         }
diff --git a/src/mongo/db/storage/record_store_test_insertrecord.cpp b/src/mongo/db/storage/record_store_test_insertrecord.cpp
index 93f759c29b8..adcf2fc2300 100644
--- a/src/mongo/db/storage/record_store_test_insertrecord.cpp
+++ b/src/mongo/db/storage/record_store_test_insertrecord.cpp
@@ -61,7 +61,7 @@ TEST(RecordStoreTestHarness, InsertRecord) {
         {
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -96,7 +96,7 @@ TEST(RecordStoreTestHarness, InsertMultipleRecords) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             uow.commit();
@@ -128,7 +128,7 @@ TEST(RecordStoreTestHarness, InsertRecordUsingDocWriter) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecordWithDocWriterT(opCtx.get(), &docWriter, Timestamp(1));
+                rs->insertRecordWithDocWriter(opCtx.get(), &docWriter, Timestamp(1));
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -163,7 +163,7 @@ TEST(RecordStoreTestHarness, InsertMultipleRecordsUsingDocWriter) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecordWithDocWriterT(opCtx.get(), &docWriter, Timestamp(1));
+                rs->insertRecordWithDocWriter(opCtx.get(), &docWriter, Timestamp(1));
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             uow.commit();
diff --git a/src/mongo/db/storage/record_store_test_manyiter.cpp b/src/mongo/db/storage/record_store_test_manyiter.cpp
index 1f60d9f84b3..5b477f0d27a 100644
--- a/src/mongo/db/storage/record_store_test_manyiter.cpp
+++ b/src/mongo/db/storage/record_store_test_manyiter.cpp
@@ -87,7 +87,7 @@ TEST(RecordStoreTestHarness, GetManyIteratorsNonEmpty) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             uow.commit();
diff --git a/src/mongo/db/storage/record_store_test_randomiter.cpp b/src/mongo/db/storage/record_store_test_randomiter.cpp
index 4fa04ba7440..0644b07a83b 100644
--- a/src/mongo/db/storage/record_store_test_randomiter.cpp
+++ b/src/mongo/db/storage/record_store_test_randomiter.cpp
@@ -87,7 +87,7 @@ TEST(RecordStoreTestHarness, GetRandomIteratorNonEmpty) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             uow.commit();
@@ -141,7 +141,8 @@ TEST(RecordStoreTestHarness, GetRandomIteratorSingleton) {
     {
         ServiceContext::UniqueOperationContext opCtx(harnessHelper->newOperationContext());
         WriteUnitOfWork uow(opCtx.get());
-        StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "some data", 10, false);
+        StatusWith<RecordId> res =
+            rs->insertRecord(opCtx.get(), "some data", 10, Timestamp(), false);
         ASSERT_OK(res.getStatus());
         idToRetrieve = res.getValue();
         uow.commit();
diff --git a/src/mongo/db/storage/record_store_test_recorditer.cpp b/src/mongo/db/storage/record_store_test_recorditer.cpp
index aa6c158bf3e..37f6d284258 100644
--- a/src/mongo/db/storage/record_store_test_recorditer.cpp
+++ b/src/mongo/db/storage/record_store_test_recorditer.cpp
@@ -71,7 +71,7 @@ TEST(RecordStoreTestHarness, IterateOverMultipleRecords) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             datas[i] = data;
@@ -122,7 +122,7 @@ TEST(RecordStoreTestHarness, IterateOverMultipleRecordsReversed) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             datas[i] = data;
@@ -173,7 +173,7 @@ TEST(RecordStoreTestHarness, IterateStartFromMiddle) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             datas[i] = data;
@@ -225,7 +225,7 @@ TEST(RecordStoreTestHarness, IterateStartFromMiddleReversed) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             datas[i] = data;
@@ -278,7 +278,7 @@ TEST(RecordStoreTestHarness, RecordIteratorEOF) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             datas[i] = data;
@@ -315,7 +315,7 @@ TEST(RecordStoreTestHarness, RecordIteratorEOF) {
 
         WriteUnitOfWork uow(opCtx.get());
         StatusWith<RecordId> res =
-            rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+            rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
         ASSERT_OK(res.getStatus());
         uow.commit();
 
@@ -349,7 +349,7 @@ TEST(RecordStoreTestHarness, RecordIteratorSaveRestore) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             datas[i] = data;
@@ -406,7 +406,7 @@ TEST(RecordStoreTestHarness, SeekAfterEofAndContinue) {
 
         WriteUnitOfWork uow(opCtx.get());
         StatusWith<RecordId> res =
-            rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+            rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
         ASSERT_OK(res.getStatus());
         locs[i] = res.getValue();
         datas[i] = data;
diff --git a/src/mongo/db/storage/record_store_test_repairiter.cpp b/src/mongo/db/storage/record_store_test_repairiter.cpp
index b7423f964d6..f5397012cf8 100644
--- a/src/mongo/db/storage/record_store_test_repairiter.cpp
+++ b/src/mongo/db/storage/record_store_test_repairiter.cpp
@@ -89,7 +89,7 @@ TEST(RecordStoreTestHarness, GetIteratorForRepairNonEmpty) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             uow.commit();
@@ -136,7 +136,8 @@ TEST(RecordStoreTestHarness, GetIteratorForRepairInvalidateSingleton) {
     {
         ServiceContext::UniqueOperationContext opCtx(harnessHelper->newOperationContext());
         WriteUnitOfWork uow(opCtx.get());
-        StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "some data", 10, false);
+        StatusWith<RecordId> res =
+            rs->insertRecord(opCtx.get(), "some data", 10, Timestamp(), false);
         ASSERT_OK(res.getStatus());
         idToInvalidate = res.getValue();
         uow.commit();
diff --git a/src/mongo/db/storage/record_store_test_storagesize.cpp b/src/mongo/db/storage/record_store_test_storagesize.cpp
index d525446449a..521d879cfac 100644
--- a/src/mongo/db/storage/record_store_test_storagesize.cpp
+++ b/src/mongo/db/storage/record_store_test_storagesize.cpp
@@ -63,7 +63,7 @@ TEST(RecordStoreTestHarness, StorageSizeNonEmpty) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             uow.commit();
         }
diff --git a/src/mongo/db/storage/record_store_test_touch.cpp b/src/mongo/db/storage/record_store_test_touch.cpp
index fe45e3bf9de..eae3e0046b0 100644
--- a/src/mongo/db/storage/record_store_test_touch.cpp
+++ b/src/mongo/db/storage/record_store_test_touch.cpp
@@ -85,7 +85,7 @@ TEST(RecordStoreTestHarness, TouchNonEmpty) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             uow.commit();
         }
@@ -149,7 +149,7 @@ TEST(RecordStoreTestHarness, TouchNonEmptyWithNullStats) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             uow.commit();
         }
diff --git a/src/mongo/db/storage/record_store_test_truncate.cpp b/src/mongo/db/storage/record_store_test_truncate.cpp
index d1d79fbabaa..7fda629b4f9 100644
--- a/src/mongo/db/storage/record_store_test_truncate.cpp
+++ b/src/mongo/db/storage/record_store_test_truncate.cpp
@@ -89,7 +89,7 @@ TEST(RecordStoreTestHarness, TruncateNonEmpty) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             uow.commit();
         }
diff --git a/src/mongo/db/storage/record_store_test_updaterecord.cpp b/src/mongo/db/storage/record_store_test_updaterecord.cpp
index 4b55ae00e12..32c2545f65e 100644
--- a/src/mongo/db/storage/record_store_test_updaterecord.cpp
+++ b/src/mongo/db/storage/record_store_test_updaterecord.cpp
@@ -63,7 +63,7 @@ TEST(RecordStoreTestHarness, UpdateRecord) {
         {
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -84,8 +84,8 @@ TEST(RecordStoreTestHarness, UpdateRecord) {
                 rs->updateRecord(opCtx.get(), loc, data.c_str(), data.size() + 1, false, NULL);
 
             if (ErrorCodes::NeedsDocumentMove == res) {
-                StatusWith<RecordId> newLocation =
-                    rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                StatusWith<RecordId> newLocation = rs->insertRecord(
+                    opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
                 ASSERT_OK(newLocation.getStatus());
                 rs->deleteRecord(opCtx.get(), loc);
                 loc = newLocation.getValue();
@@ -128,7 +128,7 @@ TEST(RecordStoreTestHarness, UpdateMultipleRecords) {
 
             WriteUnitOfWork uow(opCtx.get());
             StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             locs[i] = res.getValue();
             uow.commit();
@@ -152,8 +152,8 @@ TEST(RecordStoreTestHarness, UpdateMultipleRecords) {
                 rs->updateRecord(opCtx.get(), locs[i], data.c_str(), data.size() + 1, false, NULL);
 
             if (ErrorCodes::NeedsDocumentMove == res) {
-                StatusWith<RecordId> newLocation =
-                    rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                StatusWith<RecordId> newLocation = rs->insertRecord(
+                    opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
                 ASSERT_OK(newLocation.getStatus());
                 rs->deleteRecord(opCtx.get(), locs[i]);
                 locs[i] = newLocation.getValue();
@@ -195,8 +195,8 @@ TEST(RecordStoreTestHarness, UpdateRecordWithMoveNotifier) {
         ServiceContext::UniqueOperationContext opCtx(harnessHelper->newOperationContext());
         {
             WriteUnitOfWork uow(opCtx.get());
-            StatusWith<RecordId> res =
-                rs->insertRecord(opCtx.get(), oldData.c_str(), oldData.size() + 1, false);
+            StatusWith<RecordId> res = rs->insertRecord(
+                opCtx.get(), oldData.c_str(), oldData.size() + 1, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -219,8 +219,8 @@ TEST(RecordStoreTestHarness, UpdateRecordWithMoveNotifier) {
                 opCtx.get(), loc, newData.c_str(), newData.size() + 1, false, &umn);
 
             if (ErrorCodes::NeedsDocumentMove == res) {
-                StatusWith<RecordId> newLocation =
-                    rs->insertRecord(opCtx.get(), newData.c_str(), newData.size() + 1, false);
+                StatusWith<RecordId> newLocation = rs->insertRecord(
+                    opCtx.get(), newData.c_str(), newData.size() + 1, Timestamp(), false);
                 ASSERT_OK(newLocation.getStatus());
                 rs->deleteRecord(opCtx.get(), loc);
                 loc = newLocation.getValue();
diff --git a/src/mongo/db/storage/record_store_test_updatewithdamages.cpp b/src/mongo/db/storage/record_store_test_updatewithdamages.cpp
index 207b70eaa5a..2e839f28421 100644
--- a/src/mongo/db/storage/record_store_test_updatewithdamages.cpp
+++ b/src/mongo/db/storage/record_store_test_updatewithdamages.cpp
@@ -64,7 +64,8 @@ TEST(RecordStoreTestHarness, UpdateWithDamages) {
         ServiceContext::UniqueOperationContext opCtx(harnessHelper->newOperationContext());
         {
             WriteUnitOfWork uow(opCtx.get());
-            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), rec.data(), rec.size(), false);
+            StatusWith<RecordId> res =
+                rs->insertRecord(opCtx.get(), rec.data(), rec.size(), Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -129,7 +130,8 @@ TEST(RecordStoreTestHarness, UpdateWithOverlappingDamageEvents) {
         ServiceContext::UniqueOperationContext opCtx(harnessHelper->newOperationContext());
         {
             WriteUnitOfWork uow(opCtx.get());
-            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), rec.data(), rec.size(), false);
+            StatusWith<RecordId> res =
+                rs->insertRecord(opCtx.get(), rec.data(), rec.size(), Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -192,7 +194,8 @@ TEST(RecordStoreTestHarness, UpdateWithOverlappingDamageEventsReversed) {
         ServiceContext::UniqueOperationContext opCtx(harnessHelper->newOperationContext());
         {
             WriteUnitOfWork uow(opCtx.get());
-            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), rec.data(), rec.size(), false);
+            StatusWith<RecordId> res =
+                rs->insertRecord(opCtx.get(), rec.data(), rec.size(), Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
@@ -253,7 +256,8 @@ TEST(RecordStoreTestHarness, UpdateWithNoDamages) {
         ServiceContext::UniqueOperationContext opCtx(harnessHelper->newOperationContext());
         {
             WriteUnitOfWork uow(opCtx.get());
-            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), rec.data(), rec.size(), false);
+            StatusWith<RecordId> res =
+                rs->insertRecord(opCtx.get(), rec.data(), rec.size(), Timestamp(), false);
             ASSERT_OK(res.getStatus());
             loc = res.getValue();
             uow.commit();
diff --git a/src/mongo/db/storage/record_store_test_validate.h b/src/mongo/db/storage/record_store_test_validate.h
index f76b100b0ef..7edc8e152ec 100644
--- a/src/mongo/db/storage/record_store_test_validate.h
+++ b/src/mongo/db/storage/record_store_test_validate.h
@@ -96,8 +96,8 @@ public:
                 ASSERT(_remain.insert(data).second);
 
                 WriteUnitOfWork uow(opCtx.get());
-                StatusWith<RecordId> res =
-                    _rs->insertRecord(opCtx.get(), data.c_str(), data.size() + 1, false);
+                StatusWith<RecordId> res = _rs->insertRecord(
+                    opCtx.get(), data.c_str(), data.size() + 1, Timestamp(), false);
                 ASSERT_OK(res.getStatus());
                 uow.commit();
             }
diff --git a/src/mongo/db/storage/wiredtiger/record_store_test_oplog.cpp b/src/mongo/db/storage/wiredtiger/record_store_test_oplog.cpp
index 55670cf30b5..90de4f17d61 100644
--- a/src/mongo/db/storage/wiredtiger/record_store_test_oplog.cpp
+++ b/src/mongo/db/storage/wiredtiger/record_store_test_oplog.cpp
@@ -44,7 +44,8 @@ StatusWith<RecordId> insertBSON(ServiceContext::UniqueOperationContext& opCtx,
     Status status = rs->oplogDiskLocRegister(opCtx.get(), opTime);
     if (!status.isOK())
         return StatusWith<RecordId>(status);
-    StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), obj.objdata(), obj.objsize(), false);
+    StatusWith<RecordId> res =
+        rs->insertRecord(opCtx.get(), obj.objdata(), obj.objsize(), opTime, false);
     if (res.isOK())
         wuow.commit();
     return res;
@@ -57,7 +58,7 @@ RecordId _oplogOrderInsertOplog(OperationContext* opCtx,
     Status status = rs->oplogDiskLocRegister(opCtx, opTime);
     ASSERT_OK(status);
     BSONObj obj = BSON("ts" << opTime);
-    StatusWith<RecordId> res = rs->insertRecord(opCtx, obj.objdata(), obj.objsize(), false);
+    StatusWith<RecordId> res = rs->insertRecord(opCtx, obj.objdata(), obj.objsize(), opTime, false);
     ASSERT_OK(res.getStatus());
     return res.getValue();
 }
@@ -79,7 +80,8 @@ TEST(RecordStore_Oplog, OplogHack) {
             WriteUnitOfWork wuow(opCtx.get());
             BSONObj obj = BSON("not_ts" << Timestamp(2, 1));
             ASSERT_EQ(
-                rs->insertRecord(opCtx.get(), obj.objdata(), obj.objsize(), false).getStatus(),
+                rs->insertRecord(opCtx.get(), obj.objdata(), obj.objsize(), Timestamp(2, 1), false)
+                    .getStatus(),
                 ErrorCodes::BadValue);
         }
         {
@@ -87,7 +89,8 @@ TEST(RecordStore_Oplog, OplogHack) {
             BSONObj obj = BSON("ts"
                                << "not a Timestamp");
             ASSERT_EQ(
-                rs->insertRecord(opCtx.get(), obj.objdata(), obj.objsize(), false).getStatus(),
+                rs->insertRecord(opCtx.get(), obj.objdata(), obj.objsize(), Timestamp(), false)
+                    .getStatus(),
                 ErrorCodes::BadValue);
         }
 
@@ -164,7 +167,9 @@ TEST(RecordStore_Oplog, OplogHackOnNonOplog) {
     BSONObj obj = BSON("ts" << Timestamp(2, -1));
     {
         WriteUnitOfWork wuow(opCtx.get());
-        ASSERT_OK(rs->insertRecord(opCtx.get(), obj.objdata(), obj.objsize(), false).getStatus());
+        ASSERT_OK(
+            rs->insertRecord(opCtx.get(), obj.objdata(), obj.objsize(), Timestamp(2, -1), false)
+                .getStatus());
         wuow.commit();
     }
     ASSERT_EQ(rs->oplogStartHack(opCtx.get(), RecordId(0, 1)), boost::none);
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_prefixed_record_store_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_prefixed_record_store_test.cpp
index 94606dc57cc..b7ad562b308 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_prefixed_record_store_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_prefixed_record_store_test.cpp
@@ -205,7 +205,7 @@ TEST(WiredTigerRecordStoreTest, PrefixedTableScan) {
         ServiceContext::UniqueOperationContext opCtx(harnessHelper->newOperationContext());
         for (int num = 0; num < numDocs; ++num) {
             WriteUnitOfWork uow(opCtx.get());
-            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, false);
+            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             uow.commit();
         }
@@ -231,7 +231,7 @@ TEST(WiredTigerRecordStoreTest, PrefixedSeekingCursor) {
         ServiceContext::UniqueOperationContext opCtx(harnessHelper->newOperationContext());
         for (int num = 0; num < numDocs; ++num) {
             WriteUnitOfWork uow(opCtx.get());
-            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, false);
+            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, Timestamp(), false);
             if (startRecordId.isNull()) {
                 startRecordId = res.getValue();
             }
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp
index d0d19578afd..df8cc33266d 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp
@@ -1104,23 +1104,16 @@ void WiredTigerRecordStore::reclaimOplog(OperationContext* opCtx) {
            << " records totaling to " << _dataSize.load() << " bytes";
 }
 
-Status WiredTigerRecordStore::insertRecordsT(OperationContext* opCtx,
-                                             std::vector<Record>* records,
-                                             std::vector<Timestamp>* timestamps,
-                                             bool enforceQuota) {
-    return _insertRecords(opCtx, records->data(), timestamps->data(), records->size());
-}
-
 Status WiredTigerRecordStore::insertRecords(OperationContext* opCtx,
                                             std::vector<Record>* records,
+                                            std::vector<Timestamp>* timestamps,
                                             bool enforceQuota) {
-    invariant(false);
-    return Status::OK();
+    return _insertRecords(opCtx, records->data(), timestamps->data(), records->size());
 }
 
 Status WiredTigerRecordStore::_insertRecords(OperationContext* opCtx,
                                              Record* records,
-                                             Timestamp* timestamps,
+                                             const Timestamp* timestamps,
                                              size_t nRecords) {
     // We are kind of cheating on capped collections since we write all of them at once ....
     // Simplest way out would be to just block vector writes for everything except oplog ?
@@ -1198,7 +1191,7 @@ Status WiredTigerRecordStore::_insertRecords(OperationContext* opCtx,
     return Status::OK();
 }
 
-StatusWith<RecordId> WiredTigerRecordStore::insertRecordT(
+StatusWith<RecordId> WiredTigerRecordStore::insertRecord(
     OperationContext* opCtx, const char* data, int len, Timestamp timestamp, bool enforceQuota) {
     Record record = {RecordId(), RecordData(data, len)};
     Status status = _insertRecords(opCtx, &record, &timestamp, 1);
@@ -1207,18 +1200,6 @@ StatusWith<RecordId> WiredTigerRecordStore::insertRecordT(
     return StatusWith<RecordId>(record.id);
 }
 
-StatusWith<RecordId> WiredTigerRecordStore::insertRecord(OperationContext* opCtx,
-                                                         const char* data,
-                                                         int len,
-                                                         bool enforceQuota) {
-    Record record = {RecordId(), RecordData(data, len)};
-    Timestamp timestamp;
-    Status status = _insertRecords(opCtx, &record, &timestamp, 1);
-    if (!status.isOK())
-        return StatusWith<RecordId>(status);
-    return StatusWith<RecordId>(record.id);
-}
-
 bool WiredTigerRecordStore::isOpHidden_forTest(const RecordId& id) const {
     invariant(id.repr() > 0);
     invariant(_kvEngine->getOplogManager());
@@ -1234,11 +1215,11 @@ void WiredTigerRecordStore::notifyCappedWaitersIfNeeded() {
     }
 }
 
-Status WiredTigerRecordStore::insertRecordsWithDocWriterT(OperationContext* opCtx,
-                                                          const DocWriter* const* docs,
-                                                          Timestamp* timestamps,
-                                                          size_t nDocs,
-                                                          RecordId* idsOut) {
+Status WiredTigerRecordStore::insertRecordsWithDocWriter(OperationContext* opCtx,
+                                                         const DocWriter* const* docs,
+                                                         const Timestamp* timestamps,
+                                                         size_t nDocs,
+                                                         RecordId* idsOut) {
     std::unique_ptr<Record[]> records(new Record[nDocs]);
 
     // First get all the sizes so we can allocate a single buffer for all documents. Eventually it
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.h b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.h
index 95bf88ccd3e..a581e469264 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.h
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.h
@@ -139,36 +139,19 @@ public:
 
     virtual void deleteRecord(OperationContext* opCtx, const RecordId& id);
 
-    virtual Status insertRecordsT(OperationContext* opCtx,
-                                  std::vector<Record>* records,
-                                  std::vector<Timestamp>* timestamps,
-                                  bool enforceQuota);
-
-    virtual StatusWith<RecordId> insertRecordT(
-        OperationContext* opCtx, const char* data, int len, Timestamp timestamp, bool enforceQuota);
-
     virtual Status insertRecords(OperationContext* opCtx,
                                  std::vector<Record>* records,
+                                 std::vector<Timestamp>* timestamps,
                                  bool enforceQuota);
 
-    virtual StatusWith<RecordId> insertRecord(OperationContext* opCtx,
-                                              const char* data,
-                                              int len,
-                                              bool enforceQuota);
-
-    virtual Status insertRecordsWithDocWriterT(OperationContext* opCtx,
-                                               const DocWriter* const* docs,
-                                               Timestamp* timestamps,
-                                               size_t nDocs,
-                                               RecordId* idsOut);
+    virtual StatusWith<RecordId> insertRecord(
+        OperationContext* opCtx, const char* data, int len, Timestamp timestamp, bool enforceQuota);
 
     virtual Status insertRecordsWithDocWriter(OperationContext* opCtx,
                                               const DocWriter* const* docs,
+                                              const Timestamp* timestamps,
                                               size_t nDocs,
-                                              RecordId* idsOut) {
-        invariant(false);
-    };
-
+                                              RecordId* idsOut);
 
     virtual Status updateRecord(OperationContext* opCtx,
                                 const RecordId& oldLocation,
@@ -311,7 +294,7 @@ private:
 
     Status _insertRecords(OperationContext* opCtx,
                           Record* records,
-                          Timestamp* timestamps,
+                          const Timestamp* timestamps,
                           size_t nRecords);
 
     RecordId _nextId();
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store_test.cpp
index 5261cfc73ba..dfeb547094e 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store_test.cpp
@@ -113,11 +113,11 @@ TEST(WiredTigerRecordStoreTest, Isolation1) {
         {
             WriteUnitOfWork uow(opCtx.get());
 
-            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, false);
+            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             id1 = res.getValue();
 
-            res = rs->insertRecord(opCtx.get(), "a", 2, false);
+            res = rs->insertRecord(opCtx.get(), "a", 2, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             id2 = res.getValue();
 
@@ -164,11 +164,11 @@ TEST(WiredTigerRecordStoreTest, Isolation2) {
         {
             WriteUnitOfWork uow(opCtx.get());
 
-            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, false);
+            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             id1 = res.getValue();
 
-            res = rs->insertRecord(opCtx.get(), "a", 2, false);
+            res = rs->insertRecord(opCtx.get(), "a", 2, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             id2 = res.getValue();
 
@@ -215,7 +215,8 @@ StatusWith<RecordId> insertBSON(ServiceContext::UniqueOperationContext& opCtx,
     Status status = wrs->oplogDiskLocRegister(opCtx.get(), opTime);
     if (!status.isOK())
         return StatusWith<RecordId>(status);
-    StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), obj.objdata(), obj.objsize(), false);
+    StatusWith<RecordId> res =
+        rs->insertRecord(opCtx.get(), obj.objdata(), obj.objsize(), opTime, false);
     if (res.isOK())
         wuow.commit();
     return res;
@@ -229,7 +230,7 @@ TEST(WiredTigerRecordStoreTest, CappedCursorRollover) {
         ServiceContext::UniqueOperationContext opCtx(harnessHelper->newOperationContext());
         for (int i = 0; i < 3; ++i) {
             WriteUnitOfWork uow(opCtx.get());
-            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, false);
+            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             uow.commit();
         }
@@ -249,7 +250,7 @@ TEST(WiredTigerRecordStoreTest, CappedCursorRollover) {
         auto opCtx = harnessHelper->newOperationContext(client3.get());
         for (int i = 0; i < 100; i++) {
             WriteUnitOfWork uow(opCtx.get());
-            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, false);
+            StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, Timestamp(), false);
             ASSERT_OK(res.getStatus());
             uow.commit();
         }
@@ -267,7 +268,7 @@ RecordId _oplogOrderInsertOplog(OperationContext* opCtx,
     Status status = rs->oplogDiskLocRegister(opCtx, opTime);
     ASSERT_OK(status);
     BSONObj obj = BSON("ts" << opTime);
-    StatusWith<RecordId> res = rs->insertRecord(opCtx, obj.objdata(), obj.objsize(), false);
+    StatusWith<RecordId> res = rs->insertRecord(opCtx, obj.objdata(), obj.objsize(), opTime, false);
     ASSERT_OK(res.getStatus());
     return res.getValue();
 }
@@ -383,7 +384,7 @@ TEST(WiredTigerRecordStoreTest, CappedCursorYieldFirst) {
     {  // first insert a document
         ServiceContext::UniqueOperationContext opCtx(harnessHelper->newOperationContext());
         WriteUnitOfWork uow(opCtx.get());
-        StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, false);
+        StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, Timestamp(), false);
         ASSERT_OK(res.getStatus());
         id1 = res.getValue();
         uow.commit();
@@ -427,7 +428,7 @@ StatusWith<RecordId> insertBSONWithSize(OperationContext* opCtx,
     if (!status.isOK()) {
         return StatusWith<RecordId>(status);
     }
-    StatusWith<RecordId> res = rs->insertRecord(opCtx, obj.objdata(), obj.objsize(), false);
+    StatusWith<RecordId> res = rs->insertRecord(opCtx, obj.objdata(), obj.objsize(), opTime, false);
     if (res.isOK()) {
         wuow.commit();
     }
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp
index a1576eb7526..b6db2b8fd06 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_standard_record_store_test.cpp
@@ -223,7 +223,8 @@ TEST(WiredTigerRecordStoreTest, SizeStorer1) {
         {
             WriteUnitOfWork uow(opCtx.get());
             for (int i = 0; i < N; i++) {
-                StatusWith<RecordId> res = rs->insertRecord(opCtx.get(), "a", 2, false);
+                StatusWith<RecordId> res =
+                    rs->insertRecord(opCtx.get(), "a", 2, Timestamp(), false);
                 ASSERT_OK(res.getStatus());
             }
             uow.commit();
@@ -329,7 +330,7 @@ private:
             ServiceContext::UniqueOperationContext opCtx(harnessHelper->newOperationContext());
             WriteUnitOfWork uow(opCtx.get());
             for (int i = 0; i < expectedNumRecords; i++) {
-                ASSERT_OK(rs->insertRecord(opCtx.get(), "a", 2, false).getStatus());
+                ASSERT_OK(rs->insertRecord(opCtx.get(), "a", 2, Timestamp(), false).getStatus());
             }
             uow.commit();
         }