diff --git a/src/include/session.h b/src/include/session.h
index f4b82b8..55ea76b 100644
--- a/src/include/session.h
+++ b/src/include/session.h
@@ -47,6 +47,14 @@ typedef TAILQ_HEAD(__wt_cursor_list, __wt_cursor) WT_CURSOR_LIST;
 
 /* Maximum number of buckets to visit during cursor sweep. */
 #define WT_SESSION_CURSOR_SWEEP_MAX 32
+struct __sess_dbg {
+    uint64_t oldest_id;
+    uint64_t id;
+    uint64_t pinned_ts;
+    uint64_t ts;
+    bool ret;
+};
+
 /*
  * WT_SESSION_IMPL --
  *	Implementation of WT_SESSION.
@@ -135,6 +143,9 @@ struct __wt_session_impl {
 #define WT_SESSION_BG_SYNC_MSEC 1200000
     WT_LSN bg_sync_lsn; /* Background sync operation LSN. */
     u_int ncursors;     /* Count of active file cursors. */
+#define WT_SESS_DBG 128
+    struct __sess_dbg dbg[WT_SESS_DBG];
+    u_int dbg_i;
 
     void *block_manager; /* Block-manager support */
     int (*block_manager_cleanup)(WT_SESSION_IMPL *);
diff --git a/src/include/txn.i b/src/include/txn.i
index 757627d..9dba27c 100644
--- a/src/include/txn.i
+++ b/src/include/txn.i
@@ -517,6 +517,7 @@ __txn_visible_all_id(WT_SESSION_IMPL *session, uint64_t id)
     uint64_t oldest_id;
 
     oldest_id = __wt_txn_oldest_id(session);
+    session->dbg[session->dbg_i % WT_SESS_DBG].oldest_id = oldest_id;
 
     return (WT_TXNID_LT(id, oldest_id));
 }
@@ -538,19 +539,28 @@ __wt_txn_visible_all(WT_SESSION_IMPL *session, uint64_t id, wt_timestamp_t times
     if (F_ISSET(S2C(session), WT_CONN_CLOSING))
         return (true);
 
-    if (!__txn_visible_all_id(session, id))
+    session->dbg[++session->dbg_i % WT_SESS_DBG].id = id;
+    if (!__txn_visible_all_id(session, id)) {
+        session->dbg[session->dbg_i % WT_SESS_DBG].ret = false;
         return (false);
+    }
 
     /* Timestamp check. */
-    if (timestamp == WT_TS_NONE)
+    if (timestamp == WT_TS_NONE) {
+        session->dbg[session->dbg_i % WT_SESS_DBG].ret = true;
         return (true);
+    }
 
+    session->dbg[session->dbg_i % WT_SESS_DBG].ts = timestamp;
     /* If no oldest timestamp has been supplied, updates have to stay in cache. */
     if (S2C(session)->txn_global.has_pinned_timestamp) {
         __wt_txn_pinned_timestamp(session, &pinned_ts);
+        session->dbg[session->dbg_i % WT_SESS_DBG].pinned_ts = pinned_ts;
+        session->dbg[session->dbg_i % WT_SESS_DBG].ret = (timestamp <= pinned_ts);
         return (timestamp <= pinned_ts);
     }
 
+    session->dbg[session->dbg_i % WT_SESS_DBG].ret = false;
     return (false);
 }
 
diff --git a/test/format/format.h b/test/format/format.h
index 38755e4..6cf3e86 100644
--- a/test/format/format.h
+++ b/test/format/format.h
@@ -279,6 +279,8 @@ typedef struct {
     void *vdata; /* If not a delete, the value */
     size_t vsize;
     size_t vmemsize;
+
+    struct timespec commit_time;
 } SNAP_OPS;
 
 typedef struct {
@@ -301,6 +303,7 @@ typedef struct {
 
     WT_SESSION *session; /* WiredTiger session */
     WT_CURSOR *cursor;   /* WiredTiger cursor */
+    struct timespec start_time;
 
     uint64_t keyno;     /* key */
     WT_ITEM *key, _key; /* key, value */
@@ -357,7 +360,7 @@ void snap_init(TINFO *, uint64_t, bool);
 void snap_repeat_single(WT_CURSOR *, TINFO *);
 int snap_repeat_txn(WT_CURSOR *, TINFO *);
 void snap_repeat_update(TINFO *, bool);
-void snap_track(TINFO *, thread_op);
+void snap_track(WT_CURSOR *, TINFO *, thread_op);
 WT_THREAD_RET timestamp(void *);
 void timestamp_once(void);
 void track(const char *, uint64_t, TINFO *);
diff --git a/test/format/ops.c b/test/format/ops.c
index 2b4ae05..94ca52c 100644
--- a/test/format/ops.c
+++ b/test/format/ops.c
@@ -465,6 +465,7 @@ commit_transaction(TINFO *tinfo, bool prepared)
         testutil_check(pthread_rwlock_unlock(&g.ts_lock));
     }
     testutil_check(session->commit_transaction(session, NULL));
+    __wt_epoch(NULL, &tinfo->snap_first->commit_time);
 
     /* Remember our oldest commit timestamp. */
     tinfo->commit_ts = ts;
@@ -562,7 +563,7 @@ prepare_transaction(TINFO *tinfo)
 #define SNAP_TRACK(tinfo, op)                                          \
     do {                                                               \
         if (intxn && !ckpt_handle && iso_config == ISOLATION_SNAPSHOT) \
-            snap_track(tinfo, op);                                     \
+            snap_track(cursor, tinfo, op);                             \
     } while (0)
 
 /*
diff --git a/test/format/snap.c b/test/format/snap.c
index 15df14b..a0b2acf 100644
--- a/test/format/snap.c
+++ b/test/format/snap.c
@@ -35,21 +35,25 @@
 void
 snap_init(TINFO *tinfo, uint64_t read_ts, bool repeatable_reads)
 {
+
     ++tinfo->opid;
 
     tinfo->snap_first = tinfo->snap;
 
+    __wt_epoch(NULL, &tinfo->start_time);
     tinfo->read_ts = read_ts;
     tinfo->repeatable_reads = repeatable_reads;
     tinfo->repeatable_wrap = false;
 }
 
+static int snap_verify(WT_CURSOR *cursor, TINFO *tinfo, SNAP_OPS *snap);
+
 /*
  * snap_track --
  *     Add a single snapshot isolation returned value to the list.
  */
 void
-snap_track(TINFO *tinfo, thread_op op)
+snap_track(WT_CURSOR *cursor, TINFO *tinfo, thread_op op)
 {
     WT_ITEM *ip;
     SNAP_OPS *snap;
@@ -81,6 +85,11 @@ snap_track(TINFO *tinfo, thread_op op)
         memcpy(snap->vdata, ip->data, snap->vsize = ip->size);
     }
 
+    if (op == READ) {
+        __wt_yield();
+        snap_verify(cursor, tinfo, snap);
+    }
+
     /* Move to the next slot, wrap at the end of the circular buffer. */
     if (++tinfo->snap >= &tinfo->snap_list[WT_ELEMENTS(tinfo->snap_list)])
         tinfo->snap = tinfo->snap_list;
@@ -120,6 +129,52 @@ print_item_data(const char *tag, const uint8_t *data, size_t size)
 }
 
 /*
+ * snap_stop_all --
+ *     Stop all other threads. Set their quit flag.
+ */
+static void
+snap_stop_all()
+{
+    TINFO *tinfo;
+    uint32_t i;
+
+    for (i = 0; i < g.c_threads; ++i) {
+        tinfo = tinfo_list[i];
+        tinfo->quit = true;
+    }
+}
+
+/*
+ * snap_find_all --
+ *     Find any other threads that were committing at the same time we were.
+ */
+static int
+snap_find_all(TINFO *my_tinfo, SNAP_OPS *my_snap)
+{
+    SNAP_OPS *snap;
+    TINFO *tinfo;
+    uint32_t i, j;
+
+    if (my_snap->op != READ)
+        return (0);
+
+    for (i = 0; i < g.c_threads; ++i) {
+        tinfo = tinfo_list[i];
+        if (tinfo == my_tinfo)
+            continue;
+        for (j = 0; j < 512; ++j) {
+            snap = &tinfo->snap_list[j];
+            if (snap->keyno == my_snap->keyno)
+                fprintf(stderr, "KEY FOUND: tinfo[%" PRIu32 "] %p snap[%" PRIu32 "] %p\n", i, tinfo,
+                  j, snap);
+            if (WT_TIMECMP(tinfo->start_time, snap->commit_time) < 0)
+                fprintf(stderr, "CONCURRENT COMMIT: tinfo[%" PRIu32 "] %p snap[%" PRIu32 "] %p\n",
+                  i, tinfo, j, snap);
+        }
+    }
+}
+
+/*
  * snap_verify --
  *     Repeat a read and verify the contents.
  */
@@ -238,6 +293,10 @@ snap_verify(WT_CURSOR *cursor, TINFO *tinfo, SNAP_OPS *snap)
      */
     fprintf(stderr, "\n%s: run FAILED\n", progname);
     set_core_off();
+    fprintf(stderr, "\n%s: run FAILED stopping threads\n", progname);
+    snap_stop_all();
+    fprintf(stderr, "\n%s: Searching for concurrent snapshot operations\n", progname);
+    snap_find_all(tinfo, snap);
 
     fprintf(stderr, "snapshot-isolation error: Dumping page to %s\n", g.home_pagedump);
     testutil_check(__wt_debug_cursor_page(cursor, g.home_pagedump));
