diff --git a/src/block/block_ckpt.c b/src/block/block_ckpt.c
index addcd9b44..ed401fa82 100644
--- a/src/block/block_ckpt.c
+++ b/src/block/block_ckpt.c
@@ -42,6 +42,7 @@ __wt_block_checkpoint_load(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint
     WT_BLOCK_CKPT *ci, _ci;
     WT_DECL_RET;
     uint8_t *endp;
+    bool chk_verbose;
 
     /*
      * Sometimes we don't find a root page (we weren't given a checkpoint, or the checkpoint was
@@ -51,7 +52,8 @@ __wt_block_checkpoint_load(WT_SESSION_IMPL *session, WT_BLOCK *block, const uint
 
     ci = NULL;
 
-    if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT))
+    WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT, chk_verbose);
+    if (chk_verbose)
         __wt_ckpt_verbose(session, block, "load", NULL, addr, addr_size);
 
     /*
@@ -473,10 +475,11 @@ __ckpt_process(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_CKPT *ckptbase)
     WT_CKPT *ckpt, *next_ckpt;
     WT_DECL_RET;
     uint64_t ckpt_size;
-    bool deleting, fatal, locked;
+    bool deleting, fatal, locked, ckpt_verbose;
 
     ci = &block->live;
     fatal = locked = false;
+    WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT, ckpt_verbose);
 
 #ifdef HAVE_DIAGNOSTIC
     WT_RET(__ckpt_verify(session, ckptbase));
@@ -613,7 +616,7 @@ __ckpt_process(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_CKPT *ckptbase)
         if (F_ISSET(ckpt, WT_CKPT_FAKE) || !F_ISSET(ckpt, WT_CKPT_DELETE) || block->has_objects)
             continue;
 
-        if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT))
+        if (ckpt_verbose)
             __wt_ckpt_verbose(session, block, "delete", ckpt->name, ckpt->raw.data, ckpt->raw.size);
 
         /*
@@ -787,9 +790,10 @@ __ckpt_update(
     WT_DECL_ITEM(a);
     WT_DECL_RET;
     uint8_t *endp;
-    bool is_live;
+    bool is_live, ckpt_verbose;
 
     is_live = F_ISSET(ckpt, WT_CKPT_ADD);
+    WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT, ckpt_verbose);
 
 #ifdef HAVE_DIAGNOSTIC
     /* Check the extent list combinations for overlaps. */
@@ -886,7 +890,7 @@ __ckpt_update(
     WT_RET(__wt_block_ckpt_pack(session, block, &endp, ci, false));
     ckpt->raw.size = WT_PTRDIFF(endp, ckpt->raw.mem);
 
-    if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT))
+    if (ckpt_verbose)
         __wt_ckpt_verbose(session, block, "create", ckpt->name, ckpt->raw.data, ckpt->raw.size);
 
     return (0);
diff --git a/src/block/block_ckpt_scan.c b/src/block/block_ckpt_scan.c
index 74b2257b7..94ad497a2 100644
--- a/src/block/block_ckpt_scan.c
+++ b/src/block/block_ckpt_scan.c
@@ -171,11 +171,13 @@ __block_checkpoint_update(WT_SESSION_IMPL *session, WT_BLOCK *block, struct save
     WT_BLOCK_CKPT ci;
     WT_ITEM *checkpoint;
     uint8_t *endp;
+    bool ckpt_verbose;
 
     memset(&ci, 0, sizeof(ci));
     checkpoint = info->checkpoint;
 
-    if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT))
+    WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT, ckpt_verbose);
+    if (ckpt_verbose)
         __wt_ckpt_verbose(
           session, block, "import original", NULL, checkpoint->mem, checkpoint->size);
 
@@ -193,7 +195,7 @@ __block_checkpoint_update(WT_SESSION_IMPL *session, WT_BLOCK *block, struct save
     WT_RET(__wt_block_ckpt_pack(session, block, &endp, &ci, false));
     checkpoint->size = WT_PTRDIFF(endp, checkpoint->mem);
 
-    if (WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT))
+    if (ckpt_verbose)
         __wt_ckpt_verbose(
           session, block, "import replace", NULL, checkpoint->mem, checkpoint->size);
 
diff --git a/src/block/block_compact.c b/src/block/block_compact.c
index 6d7e87edb..1ca3a7f11 100644
--- a/src/block/block_compact.c
+++ b/src/block/block_compact.c
@@ -38,11 +38,14 @@ __wt_block_compact_start(WT_SESSION_IMPL *session, WT_BLOCK *block)
 int
 __wt_block_compact_end(WT_SESSION_IMPL *session, WT_BLOCK *block)
 {
+    bool compact_verbose;
+
     /* Restore the original allocation plan. */
     __wt_block_configure_first_fit(block, false);
 
+    WT_VERBOSE_ISSET(session, WT_VERB_COMPACT, compact_verbose);
     /* Dump the results of the compaction pass. */
-    if (WT_VERBOSE_ISSET(session, WT_VERB_COMPACT)) {
+    if (compact_verbose) {
         __wt_spin_lock(session, &block->live_lock);
         __block_dump_avail(session, block, false);
         __wt_spin_unlock(session, &block->live_lock);
@@ -60,6 +63,7 @@ __wt_block_compact_skip(WT_SESSION_IMPL *session, WT_BLOCK *block, bool *skipp)
     WT_EXT *ext;
     WT_EXTLIST *el;
     wt_off_t avail_eighty, avail_ninety, eighty, ninety;
+    bool verb_compact;
 
     *skipp = true; /* Return a default skip. */
 
@@ -74,7 +78,8 @@ __wt_block_compact_skip(WT_SESSION_IMPL *session, WT_BLOCK *block, bool *skipp)
     __wt_spin_lock(session, &block->live_lock);
 
     /* Dump the current state of the file. */
-    if (WT_VERBOSE_ISSET(session, WT_VERB_COMPACT))
+    WT_VERBOSE_ISSET(session, WT_VERB_COMPACT, verb_compact);
+    if (verb_compact)
         __block_dump_avail(session, block, true);
 
     /* Sum the available bytes in the initial 80% and 90% of the file. */
@@ -137,6 +142,7 @@ __wt_block_compact_page_skip(
     WT_EXTLIST *el;
     wt_off_t limit, offset;
     uint32_t checksum, objectid, size;
+    bool compact_verbose;
 
     *skipp = true; /* Return a default skip. */
 
@@ -165,8 +171,8 @@ __wt_block_compact_page_skip(
     }
     __wt_spin_unlock(session, &block->live_lock);
 
-    if (WT_VERBOSE_ISSET(session, WT_VERB_COMPACT) ||
-      WT_VERBOSE_ISSET(session, WT_VERB_COMPACT_PROGRESS)) {
+    WT_VERBOSE_ISSET(session, WT_VERB_COMPACT | WT_VERB_COMPACT_PROGRESS, compact_verbose);
+    if (compact_verbose) {
         ++block->compact_pages_reviewed;
         if (*skipp)
             ++block->compact_pages_skipped;
diff --git a/src/block/block_ext.c b/src/block/block_ext.c
index 37916e482..c3e138cc2 100644
--- a/src/block/block_ext.c
+++ b/src/block/block_ext.c
@@ -1334,8 +1334,10 @@ __block_extlist_dump(WT_SESSION_IMPL *session, WT_BLOCK *block, WT_EXTLIST *el,
     uint64_t pow, sizes[64];
     u_int i;
     const char *sep;
+    bool blk_verbose;
+    WT_VERBOSE_ISSET(session, WT_VERB_BLOCK, blk_verbose);
 
-    if (!block->verify_layout && !WT_VERBOSE_ISSET(session, WT_VERB_BLOCK))
+    if (!block->verify_layout && !blk_verbose)
         return (0);
 
     WT_ERR(__wt_scr_alloc(session, 0, &t1));
diff --git a/src/block/block_vrfy.c b/src/block/block_vrfy.c
index 01ec16f59..0c1878f32 100644
--- a/src/block/block_vrfy.c
+++ b/src/block/block_vrfy.c
@@ -388,6 +388,9 @@ static int
 __verify_filefrag_chk(WT_SESSION_IMPL *session, WT_BLOCK *block)
 {
     uint64_t count, first, last;
+    bool verify_verbose;
+
+    WT_VERBOSE_ISSET(session, WT_VERB_VERIFY, verify_verbose);
 
     /* If there's nothing to verify, it was a fast run. */
     if (block->frags == 0)
@@ -422,7 +425,7 @@ __verify_filefrag_chk(WT_SESSION_IMPL *session, WT_BLOCK *block)
             __bit_set(block->fragfile, last);
         }
 
-        if (!WT_VERBOSE_ISSET(session, WT_VERB_VERIFY))
+        if (!verify_verbose)
             continue;
 
         __wt_errx(session, "file range %" PRIuMAX "-%" PRIuMAX " never verified",
@@ -484,7 +487,9 @@ static int
 __verify_ckptfrag_chk(WT_SESSION_IMPL *session, WT_BLOCK *block)
 {
     uint64_t count, first, last;
+    bool verify_verbose;
 
+    WT_VERBOSE_ISSET(session, WT_VERB_VERIFY, verify_verbose);
     /*
      * The checkpoint fragment memory is only allocated as a checkpoint is successfully loaded;
      * don't check if there's nothing there.
@@ -507,7 +512,7 @@ __verify_ckptfrag_chk(WT_SESSION_IMPL *session, WT_BLOCK *block)
             __bit_clear(block->fragckpt, last);
         }
 
-        if (!WT_VERBOSE_ISSET(session, WT_VERB_VERIFY))
+        if (!verify_verbose)
             continue;
 
         __wt_errx(session, "checkpoint range %" PRIuMAX "-%" PRIuMAX " never verified",
diff --git a/src/btree/bt_compact.c b/src/btree/bt_compact.c
index edbb2b35c..423c64dfc 100644
--- a/src/btree/bt_compact.c
+++ b/src/btree/bt_compact.c
@@ -93,8 +93,10 @@ __compact_progress(WT_SESSION_IMPL *session)
     struct timespec cur_time;
     WT_BM *bm;
     uint64_t time_diff;
+    bool compact_prog_verbose;
 
-    if (!WT_VERBOSE_ISSET(session, WT_VERB_COMPACT_PROGRESS))
+    WT_VERBOSE_ISSET(session, WT_VERB_COMPACT_PROGRESS, compact_prog_verbose);
+    if (!compact_prog_verbose)
         return;
 
     bm = S2BT(session)->bm;
diff --git a/src/btree/bt_handle.c b/src/btree/bt_handle.c
index d52512689..963b43ede 100644
--- a/src/btree/bt_handle.c
+++ b/src/btree/bt_handle.c
@@ -318,14 +318,14 @@ __btree_conf(WT_SESSION_IMPL *session, WT_CKPT *ckpt)
     int64_t maj_version, min_version;
     uint32_t bitcnt;
     const char **cfg;
-    bool fixed;
+    bool fixed, ver_verbose;
 
     btree = S2BT(session);
     cfg = btree->dhandle->cfg;
     conn = S2C(session);
-
+    WT_VERBOSE_ISSET(session, WT_VERB_VERSION, ver_verbose);
     /* Dump out format information. */
-    if (WT_VERBOSE_ISSET(session, WT_VERB_VERSION)) {
+    if (ver_verbose) {
         WT_RET(__wt_config_gets(session, cfg, "version.major", &cval));
         maj_version = cval.val;
         WT_RET(__wt_config_gets(session, cfg, "version.minor", &cval));
diff --git a/src/btree/bt_sync.c b/src/btree/bt_sync.c
index 8888fa61a..664a71a58 100644
--- a/src/btree/bt_sync.c
+++ b/src/btree/bt_sync.c
@@ -459,7 +459,7 @@ __wt_sync_file(WT_SESSION_IMPL *session, WT_CACHE_OP syncop)
     internal_bytes = leaf_bytes = 0;
     internal_pages = leaf_pages = 0;
     saved_pinned_id = WT_SESSION_TXN_SHARED(session)->pinned_id;
-    timer = WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT);
+    WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT, timer);
     if (timer)
         time_start = __wt_clock(session);
 
diff --git a/src/conn/conn_api.c b/src/conn/conn_api.c
index 2e55aedcd..1773c9054 100644
--- a/src/conn/conn_api.c
+++ b/src/conn/conn_api.c
@@ -2011,20 +2011,31 @@ __wt_verbose_config(WT_SESSION_IMPL *session, const char *cfg[])
     WT_CONNECTION_IMPL *conn;
     WT_DECL_RET;
     const WT_NAME_FLAG *ft;
-    uint64_t flags;
+    int verb_idx;
+    int verbose_lvl;
 
     conn = S2C(session);
 
     WT_RET(__wt_config_gets(session, cfg, "verbose", &cval));
 
-    flags = 0;
     for (ft = verbtypes; ft->name != NULL; ft++) {
-        if ((ret = __wt_config_subgets(session, &cval, ft->name, &sval)) == 0 && sval.val != 0)
-            LF_SET(ft->flag);
+        WT_VERBOSE_EVENT_TO_IDX(ft->flag, verb_idx);
+        if ((ret = __wt_config_subgets(session, &cval, ft->name, &sval)) == 0 &&
+          sval.val >= WT_VERBOSE_LOG && sval.val <= WT_VERBOSE_DEBUG(5)) {
+            /*
+             * If no value is associated with the verbose (i.e passing verbose=[checkpoint]),
+             * default the event to WT_VERBOSE_DEBUG(1). All legacy uses of '__wt_verbose', being
+             * messages without an explict verbosity level, default to 'WT_VERBOSE_DEBUG(1)'.
+             */
+            verbose_lvl = sval.len == 0 ? WT_VERBOSE_DEBUG(1) : sval.val;
+            conn->verbose[verb_idx] = verbose_lvl;
+        } else if (ret == WT_NOTFOUND)
+            conn->verbose[verb_idx] = WT_VERBOSE_LOG;
+        else if (sval.val < WT_VERBOSE_LOG || sval.val > WT_VERBOSE_DEBUG(5))
+            ret = EINVAL;
         WT_RET_NOTFOUND_OK(ret);
     }
 
-    conn->verbose = flags;
     return (0);
 }
 
diff --git a/src/conn/conn_cache_pool.c b/src/conn/conn_cache_pool.c
index d7a317fd0..48e7fbd49 100644
--- a/src/conn/conn_cache_pool.c
+++ b/src/conn/conn_cache_pool.c
@@ -535,7 +535,7 @@ __cache_pool_adjust(WT_SESSION_IMPL *session, uint64_t highest, uint64_t bump_th
     WT_CONNECTION_IMPL *entry;
     double pct_full;
     uint64_t adjustment, highest_percentile, pressure, reserved, smallest;
-    bool busy, decrease_ok, grow, pool_full;
+    bool busy, decrease_ok, grow, pool_full, shared_cache_verbose;
 
     *adjustedp = false;
 
@@ -545,8 +545,9 @@ __cache_pool_adjust(WT_SESSION_IMPL *session, uint64_t highest, uint64_t bump_th
     pct_full = 0.0;
     /* Highest as a percentage, avoid 0 */
     highest_percentile = (highest / 100) + 1;
+    WT_VERBOSE_ISSET(session, WT_VERB_SHARED_CACHE, shared_cache_verbose);
 
-    if (WT_VERBOSE_ISSET(session, WT_VERB_SHARED_CACHE)) {
+    if (shared_cache_verbose) {
         __wt_verbose(session, WT_VERB_SHARED_CACHE, "%s", "Cache pool distribution: ");
         __wt_verbose(session, WT_VERB_SHARED_CACHE, "%s",
           "\t"
diff --git a/src/evict/evict_lru.c b/src/evict/evict_lru.c
index 0bfaf1c9f..e79fc2119 100644
--- a/src/evict/evict_lru.c
+++ b/src/evict/evict_lru.c
@@ -233,11 +233,13 @@ __wt_evict_server_wake(WT_SESSION_IMPL *session)
 {
     WT_CACHE *cache;
     WT_CONNECTION_IMPL *conn;
+    bool evict_verbose;
 
     conn = S2C(session);
     cache = conn->cache;
 
-    if (WT_VERBOSE_ISSET(session, WT_VERB_EVICTSERVER)) {
+    WT_VERBOSE_ISSET(session, WT_VERB_EVICTSERVER, evict_verbose);
+    if (evict_verbose) {
         uint64_t bytes_inuse, bytes_max;
 
         bytes_inuse = __wt_cache_bytes_inuse(cache);
@@ -378,12 +380,14 @@ __evict_server(WT_SESSION_IMPL *session, bool *did_work)
     WT_CACHE *cache;
     WT_CONNECTION_IMPL *conn;
     WT_DECL_RET;
+    bool evict_stuck_verbose;
 
     /* Assume there has been no progress. */
     *did_work = false;
 
     conn = S2C(session);
     cache = conn->cache;
+    WT_VERBOSE_ISSET(session, WT_VERB_EVICT_STUCK, evict_stuck_verbose);
 
     /* Evict pages from the cache as needed. */
     WT_RET(__evict_pass(session));
@@ -423,7 +427,7 @@ __evict_server(WT_SESSION_IMPL *session, bool *did_work)
     if (*did_work) {
 #if !defined(HAVE_DIAGNOSTIC)
         /* Need verbose check only if not in diagnostic build */
-        if (WT_VERBOSE_ISSET(session, WT_VERB_EVICT_STUCK))
+        if (evict_stuck_verbose)
 #endif
             __wt_epoch(session, &cache->stuck_time);
         return (0);
@@ -431,7 +435,7 @@ __evict_server(WT_SESSION_IMPL *session, bool *did_work)
 
 #if !defined(HAVE_DIAGNOSTIC)
     /* Need verbose check only if not in diagnostic build */
-    if (!WT_VERBOSE_ISSET(session, WT_VERB_EVICT_STUCK))
+    if (!evict_stuck_verbose)
         return (0);
 #endif
     /*
@@ -455,7 +459,7 @@ __evict_server(WT_SESSION_IMPL *session, bool *did_work)
         WT_RET(__wt_verbose_dump_cache(session));
         return (__wt_set_return(session, ETIMEDOUT));
 #else
-        if (WT_VERBOSE_ISSET(session, WT_VERB_EVICT_STUCK)) {
+        if (evict_stuck_verbose) {
             WT_RET(__wt_verbose_dump_txn(session));
             WT_RET(__wt_verbose_dump_cache(session));
 
@@ -476,8 +480,10 @@ __wt_evict_create(WT_SESSION_IMPL *session)
 {
     WT_CONNECTION_IMPL *conn;
     uint32_t session_flags;
+    bool evict_verbose;
 
     conn = S2C(session);
+    WT_VERBOSE_ISSET(session, WT_VERB_EVICTSERVER, evict_verbose);
 
     /*
      * In case recovery has allocated some transaction IDs, bump to the current state. This will
@@ -503,7 +509,7 @@ __wt_evict_create(WT_SESSION_IMPL *session)
  */
 #if !defined(HAVE_DIAGNOSTIC)
     /* Need verbose check only if not in diagnostic build */
-    if (WT_VERBOSE_ISSET(session, WT_VERB_EVICTSERVER))
+    if (evict_verbose)
 #endif
         __wt_epoch(session, &conn->cache->stuck_time);
 
diff --git a/src/history/hs_rec.c b/src/history/hs_rec.c
index 2da95291c..392a2e7cd 100644
--- a/src/history/hs_rec.c
+++ b/src/history/hs_rec.c
@@ -25,10 +25,13 @@ __hs_verbose_cache_stats(WT_SESSION_IMPL *session, WT_BTREE *btree)
     double pct_dirty, pct_full;
     uint64_t ckpt_gen_current, ckpt_gen_last;
     uint32_t btree_id;
+    bool hs_verbose, hs_verbose_activity;
 
     btree_id = btree->id;
+    WT_VERBOSE_ISSET(session, WT_VERB_HS, hs_verbose);
+    WT_VERBOSE_ISSET(session, WT_VERB_HS_ACTIVITY, hs_verbose_activity);
 
-    if (!WT_VERBOSE_ISSET(session, WT_VERB_HS | WT_VERB_HS_ACTIVITY))
+    if (!hs_verbose && !hs_verbose_activity)
         return;
 
     conn = S2C(session);
@@ -40,7 +43,7 @@ __hs_verbose_cache_stats(WT_SESSION_IMPL *session, WT_BTREE *btree)
      * Print a message if verbose history store, or once per checkpoint if only reporting activity.
      * Avoid an expensive atomic operation as often as possible when the message rate is limited.
      */
-    if (WT_VERBOSE_ISSET(session, WT_VERB_HS) ||
+    if (hs_verbose ||
       (ckpt_gen_current > ckpt_gen_last &&
         __wt_atomic_casv64(&cache->hs_verb_gen_write, ckpt_gen_last, ckpt_gen_current))) {
         WT_IGNORE_RET_BOOL(__wt_eviction_clean_needed(session, &pct_full));
@@ -54,7 +57,7 @@ __hs_verbose_cache_stats(WT_SESSION_IMPL *session, WT_BTREE *btree)
     }
 
     /* Never skip updating the tracked generation */
-    if (WT_VERBOSE_ISSET(session, WT_VERB_HS))
+    if (hs_verbose)
         cache->hs_verb_gen_write = ckpt_gen_current;
 }
 
diff --git a/src/include/connection.h b/src/include/connection.h
index 5b8f7e9f8..7444f779b 100644
--- a/src/include/connection.h
+++ b/src/include/connection.h
@@ -210,6 +210,27 @@ struct __wt_name_flag {
         (conn)->hot_backup_list = NULL;                      \
     } while (0)
 
+/*
+ * Permitted verbosity levels; to be used when defining verbose messages.
+ * The levels define a range of severity categories, with WT_VERBOSE_SEVERE being
+ * the lowest, most critical level (used by messages on critical failure paths)
+ * and WT_VERBOSE_DEBUG(5) being the highest verbosity/informational level
+ * (mostly adopted for debugging).
+ */
+#define WT_VERBOSE_DEBUG(lvl) WT_VERBOSE_DEBUG_##lvl
+typedef enum {
+    WT_VERBOSE_SEVERE = -4,
+    WT_VERBOSE_ERROR,
+    WT_VERBOSE_WARNING,
+    WT_VERBOSE_INFO,
+    WT_VERBOSE_LOG,
+    WT_VERBOSE_DEBUG(1),
+    WT_VERBOSE_DEBUG(2),
+    WT_VERBOSE_DEBUG(3),
+    WT_VERBOSE_DEBUG(4),
+    WT_VERBOSE_DEBUG(5)
+} WT_VERBOSE_LEVEL;
+
 /*
  * WT_CONNECTION_IMPL --
  *	Implementation of WT_CONNECTION
@@ -590,7 +611,8 @@ struct __wt_connection_impl {
 #define WT_VERB_VERSION 0x1000000000u
 #define WT_VERB_WRITE 0x2000000000u
     /* AUTOMATIC FLAG VALUE GENERATION STOP 64 */
-    uint64_t verbose;
+#define WT_VERBOSE_MAX_EVENTS 64
+    WT_VERBOSE_LEVEL verbose[WT_VERBOSE_MAX_EVENTS];
 
 /*
  * Variable with flags for which subsystems the diagnostic stress timing delays have been requested.
diff --git a/src/include/error.h b/src/include/error.h
index ef3019405..cf31c902d 100644
--- a/src/include/error.h
+++ b/src/include/error.h
@@ -169,8 +169,28 @@
     } while (0)
 #endif
 
+#define WT_VERBOSE_EVENT_TO_IDX(event, idx)              \
+    do {                                                 \
+        uint8_t __verb_lz = 0;                           \
+        WT_LEADING_ZERO_BITS(event, __verb_lz);          \
+        idx = (WT_VERBOSE_MAX_EVENTS - 1) - (__verb_lz); \
+    } while (0)
+
 /* Verbose messages. */
-#define WT_VERBOSE_ISSET(session, flag) (FLD_ISSET(S2C(session)->verbose, flag))
+#define WT_VERBOSE_ISSET(session, flag, is_set)                                   \
+    do {                                                                          \
+        uint64_t __verb_isset_flag = (flag);                                      \
+        uint64_t __verb_isset_idx = 0;                                            \
+        (is_set) = false;                                                         \
+        for (__verb_isset_flag; __verb_isset_flag != 0;) {                        \
+            WT_VERBOSE_EVENT_TO_IDX(__verb_isset_flag, __verb_isset_idx);         \
+            if (WT_VERBOSE_DEBUG(1) <= S2C(session)->verbose[__verb_isset_idx]) { \
+                (is_set) = true;                                                  \
+                break;                                                            \
+            }                                                                     \
+            __verb_isset_flag &= ~((uint64_t)1 << __verb_isset_idx);              \
+        }                                                                         \
+    } while (0)
 
 /*
  * __wt_verbose --
@@ -182,6 +202,8 @@
  */
 #define __wt_verbose(session, flag, fmt, ...)                              \
     do {                                                                   \
-        if (WT_VERBOSE_ISSET(session, flag))                               \
+        bool __verb_is_set;                                                \
+        WT_VERBOSE_ISSET(session, flag, __verb_is_set);                    \
+        if (__verb_is_set)                                                 \
             __wt_verbose_worker(session, "[" #flag "] " fmt, __VA_ARGS__); \
     } while (0)
diff --git a/src/include/intpack_inline.h b/src/include/intpack_inline.h
index b6e97cb13..23658ac97 100644
--- a/src/include/intpack_inline.h
+++ b/src/include/intpack_inline.h
@@ -78,6 +78,29 @@
     } while (0)
 #endif
 
+/* Count the leading zero bits. */
+#if defined(__GNUC__)
+#define WT_LEADING_ZERO_BITS(x, i) (i) = __builtin_clzll(x)
+#elif defined(_MSC_VER)
+#define WT_LEADING_ZERO_BITS(x, i)      \
+    do {                                \
+        unsigned long __index;          \
+        _BitScanReverse64(&__index, x); \
+        (i) = 63 - __index;             \
+    } while (0)
+#else
+#define WT_LEADING_ZERO_BITS(x, i)                    \
+    do {                                              \
+        uint64_t __m = (x);                           \
+        uint8_t __b;                                  \
+        for (i = 0, __b = 1; __b <= 64; __b++, i++) { \
+            if ((uint64_t)(__m & __x) == __x)         \
+                break;                                \
+            __m <<= (uint64_t)1;                      \
+        }                                             \
+    } while (0)
+#endif
+
 /*
  * __wt_vpack_posint --
  *     Packs a positive variable-length integer in the specified location.
diff --git a/src/lsm/lsm_merge.c b/src/lsm/lsm_merge.c
index 06808b6a7..42cbb0241 100644
--- a/src/lsm/lsm_merge.c
+++ b/src/lsm/lsm_merge.c
@@ -333,7 +333,7 @@ __wt_lsm_merge(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree, u_int id)
     int tret;
     const char *cfg[3];
     const char *drop_cfg[] = {WT_CONFIG_BASE(session, WT_SESSION_drop), "force", NULL};
-    bool created_chunk, create_bloom, locked, in_sync;
+    bool created_chunk, create_bloom, locked, in_sync, lsm_verbose;
 
     bloom = NULL;
     chunk = NULL;
@@ -372,7 +372,8 @@ __wt_lsm_merge(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree, u_int id)
      * We only want to do the chunk loop if we're running with verbose, so we wrap these statements
      * in the conditional. Avoid the loop in the normal path.
      */
-    if (WT_VERBOSE_ISSET(session, WT_VERB_LSM)) {
+    WT_VERBOSE_ISSET(session, WT_VERB_LSM, lsm_verbose);
+    if (lsm_verbose) {
         __wt_verbose(session, WT_VERB_LSM,
           "Merging %s chunks %u-%u into %u (%" PRIu64 " records), generation %" PRIu32,
           lsm_tree->name, start_chunk, end_chunk, dest_id, record_count, generation);
diff --git a/src/os_common/os_fhandle.c b/src/os_common/os_fhandle.c
index 18bdb7561..bea73e35f 100644
--- a/src/os_common/os_fhandle.c
+++ b/src/os_common/os_fhandle.c
@@ -160,8 +160,10 @@ __open_verbose(
     WT_DECL_ITEM(tmp);
     WT_DECL_RET;
     const char *sep;
+    bool fileops_verbose;
 
-    if (!WT_VERBOSE_ISSET(session, WT_VERB_FILEOPS))
+    WT_VERBOSE_ISSET(session, WT_VERB_FILEOPS, fileops_verbose);
+    if (!fileops_verbose)
         return (0);
 
     /*
diff --git a/src/reconcile/rec_track.c b/src/reconcile/rec_track.c
index 1eb85ece5..89ad749b7 100644
--- a/src/reconcile/rec_track.c
+++ b/src/reconcile/rec_track.c
@@ -79,10 +79,12 @@ __ovfl_discard_wrapup(WT_SESSION_IMPL *session, WT_PAGE *page)
     WT_CELL **cellp;
     WT_OVFL_TRACK *track;
     uint32_t i;
+    bool ovfl_verbose;
 
+    WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW, ovfl_verbose);
     track = page->modify->ovfl_track;
     for (i = 0, cellp = track->discard; i < track->discard_entries; ++i, ++cellp) {
-        if (WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW))
+        if (ovfl_verbose)
             WT_RET(__ovfl_discard_verbose(session, page, *cellp, "free"));
 
         /* Discard each cell's overflow item. */
@@ -118,6 +120,7 @@ int
 __wt_ovfl_discard_add(WT_SESSION_IMPL *session, WT_PAGE *page, WT_CELL *cell)
 {
     WT_OVFL_TRACK *track;
+    bool ovfl_verbose;
 
     if (page->modify->ovfl_track == NULL)
         WT_RET(__wt_ovfl_track_init(session, page));
@@ -127,7 +130,8 @@ __wt_ovfl_discard_add(WT_SESSION_IMPL *session, WT_PAGE *page, WT_CELL *cell)
       session, &track->discard_allocated, track->discard_entries + 1, &track->discard));
     track->discard[track->discard_entries++] = cell;
 
-    if (WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW))
+    WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW, ovfl_verbose);
+    if (ovfl_verbose)
         WT_RET(__ovfl_discard_verbose(session, page, cell, "add"));
 
     return (0);
@@ -296,9 +300,11 @@ __ovfl_reuse_wrapup(WT_SESSION_IMPL *session, WT_PAGE *page)
     WT_OVFL_REUSE **e, **head, *reuse;
     size_t decr;
     int i;
+    bool ovfl_verbose;
 
     bm = S2BT(session)->bm;
     head = page->modify->ovfl_track->ovfl_reuse;
+    WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW, ovfl_verbose);
 
     /*
      * Discard any overflow records that aren't in-use, freeing underlying blocks.
@@ -334,7 +340,7 @@ __ovfl_reuse_wrapup(WT_SESSION_IMPL *session, WT_PAGE *page)
 
         WT_ASSERT(session, !F_ISSET(reuse, WT_OVFL_REUSE_JUST_ADDED));
 
-        if (WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW))
+        if (ovfl_verbose)
             WT_RET(__ovfl_reuse_verbose(session, page, reuse, "free"));
 
         WT_RET(bm->free(bm, session, WT_OVFL_REUSE_ADDR(reuse), reuse->addr_size));
@@ -359,9 +365,11 @@ __ovfl_reuse_wrapup_err(WT_SESSION_IMPL *session, WT_PAGE *page)
     WT_OVFL_REUSE **e, **head, *reuse;
     size_t decr;
     int i;
+    bool ovfl_verbose;
 
     bm = S2BT(session)->bm;
     head = page->modify->ovfl_track->ovfl_reuse;
+    WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW, ovfl_verbose);
 
     /*
      * Discard any overflow records that were just added, freeing underlying blocks.
@@ -389,7 +397,7 @@ __ovfl_reuse_wrapup_err(WT_SESSION_IMPL *session, WT_PAGE *page)
         }
         *e = reuse->next[0];
 
-        if (WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW))
+        if (ovfl_verbose)
             WT_RET(__ovfl_reuse_verbose(session, page, reuse, "free"));
 
         WT_TRET(bm->free(bm, session, WT_OVFL_REUSE_ADDR(reuse), reuse->addr_size));
@@ -414,6 +422,7 @@ __wt_ovfl_reuse_search(WT_SESSION_IMPL *session, WT_PAGE *page, uint8_t **addrp,
 
     *addrp = NULL;
     *addr_sizep = 0;
+    bool ovfl_verbose;
 
     if (page->modify->ovfl_track == NULL)
         return (0);
@@ -430,8 +439,8 @@ __wt_ovfl_reuse_search(WT_SESSION_IMPL *session, WT_PAGE *page, uint8_t **addrp,
     *addrp = WT_OVFL_REUSE_ADDR(reuse);
     *addr_sizep = reuse->addr_size;
     F_SET(reuse, WT_OVFL_REUSE_INUSE);
-
-    if (WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW))
+    WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW, ovfl_verbose);
+    if (ovfl_verbose)
         WT_RET(__ovfl_reuse_verbose(session, page, reuse, "reclaim"));
     return (0);
 }
@@ -448,6 +457,7 @@ __wt_ovfl_reuse_add(WT_SESSION_IMPL *session, WT_PAGE *page, const uint8_t *addr
     size_t size;
     uint8_t *p;
     u_int i, skipdepth;
+    bool ovfl_verbose;
 
     if (page->modify->ovfl_track == NULL)
         WT_RET(__wt_ovfl_track_init(session, page));
@@ -486,7 +496,8 @@ __wt_ovfl_reuse_add(WT_SESSION_IMPL *session, WT_PAGE *page, const uint8_t *addr
         *stack[i] = reuse;
     }
 
-    if (WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW))
+    WT_VERBOSE_ISSET(session, WT_VERB_OVERFLOW, ovfl_verbose);
+    if (ovfl_verbose)
         WT_RET(__ovfl_reuse_verbose(session, page, reuse, "add"));
 
     return (0);
diff --git a/src/reconcile/rec_write.c b/src/reconcile/rec_write.c
index a4f006b82..9d41eb736 100644
--- a/src/reconcile/rec_write.c
+++ b/src/reconcile/rec_write.c
@@ -2088,12 +2088,14 @@ __rec_write_wrapup(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_PAGE *page)
     WT_REF *ref;
     WT_TIME_AGGREGATE ta;
     uint32_t i;
+    bool split_verbose;
 
     btree = S2BT(session);
     bm = btree->bm;
     mod = page->modify;
     ref = r->ref;
     WT_TIME_AGGREGATE_INIT(&ta);
+    WT_VERBOSE_ISSET(session, WT_VERB_SPLIT, split_verbose);
 
     /*
      * If using the history store table eviction path and we found updates that weren't globally
@@ -2229,7 +2231,7 @@ __rec_write_wrapup(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_PAGE *page)
             WT_STAT_DATA_INCR(session, rec_multiblock_leaf);
 
         /* Optionally display the actual split keys in verbose mode. */
-        if (WT_VERBOSE_ISSET(session, WT_VERB_SPLIT))
+        if (split_verbose)
             WT_RET(__rec_split_dump_keys(session, r));
 
         /*
diff --git a/src/txn/txn.c b/src/txn/txn.c
index 754860845..02b9f4811 100644
--- a/src/txn/txn.c
+++ b/src/txn/txn.c
@@ -457,12 +457,13 @@ __wt_txn_update_oldest(WT_SESSION_IMPL *session, uint32_t flags)
     WT_TXN_GLOBAL *txn_global;
     uint64_t current_id, last_running, metadata_pinned, oldest_id;
     uint64_t prev_last_running, prev_metadata_pinned, prev_oldest_id;
-    bool strict, wait;
+    bool strict, wait, txn_verbose;
 
     conn = S2C(session);
     txn_global = &conn->txn_global;
     strict = LF_ISSET(WT_TXN_OLDEST_STRICT);
     wait = LF_ISSET(WT_TXN_OLDEST_WAIT);
+    WT_VERBOSE_ISSET(session, WT_VERB_TRANSACTION, txn_verbose);
 
     current_id = last_running = metadata_pinned = txn_global->current;
     prev_last_running = txn_global->last_running;
@@ -530,8 +531,7 @@ __wt_txn_update_oldest(WT_SESSION_IMPL *session, uint32_t flags)
 
         /* Output a verbose message about long-running transactions,
          * but only when some progress is being made. */
-        if (WT_VERBOSE_ISSET(session, WT_VERB_TRANSACTION) && current_id - oldest_id > 10000 &&
-          oldest_session != NULL) {
+        if (txn_verbose && current_id - oldest_id > 10000 && oldest_session != NULL) {
             __wt_verbose(session, WT_VERB_TRANSACTION,
               "old snapshot %" PRIu64 " pinned in session %" PRIu32 " [%s] with snap_min %" PRIu64,
               oldest_id, oldest_session->id, oldest_session->lastop, oldest_session->txn->snap_min);
@@ -596,10 +596,9 @@ __wt_txn_config(WT_SESSION_IMPL *session, const char *cfg[])
 
     WT_ERR(__wt_config_gets_def(session, cfg, "isolation", 0, &cval));
     if (cval.len != 0)
-        txn->isolation = WT_STRING_MATCH("snapshot", cval.str, cval.len) ?
-          WT_ISO_SNAPSHOT :
-          WT_STRING_MATCH("read-committed", cval.str, cval.len) ? WT_ISO_READ_COMMITTED :
-                                                                  WT_ISO_READ_UNCOMMITTED;
+        txn->isolation = WT_STRING_MATCH("snapshot", cval.str, cval.len) ? WT_ISO_SNAPSHOT :
+          WT_STRING_MATCH("read-committed", cval.str, cval.len)          ? WT_ISO_READ_COMMITTED :
+                                                                           WT_ISO_READ_UNCOMMITTED;
 
     WT_ERR(__txn_config_operation_timeout(session, cfg, false));
 
@@ -686,7 +685,7 @@ __wt_txn_reconfigure(WT_SESSION_IMPL *session, const char *config)
     ret = __wt_config_getones(session, config, "isolation", &cval);
     if (ret == 0 && cval.len != 0) {
         session->isolation = txn->isolation = WT_STRING_MATCH("snapshot", cval.str, cval.len) ?
-          WT_ISO_SNAPSHOT :
+                                                                    WT_ISO_SNAPSHOT :
           WT_STRING_MATCH("read-uncommitted", cval.str, cval.len) ? WT_ISO_READ_UNCOMMITTED :
                                                                     WT_ISO_READ_COMMITTED;
     }
diff --git a/src/txn/txn_ckpt.c b/src/txn/txn_ckpt.c
index 86ba92740..f107df9c9 100644
--- a/src/txn/txn_ckpt.c
+++ b/src/txn/txn_ckpt.c
@@ -481,8 +481,10 @@ __checkpoint_verbose_track(WT_SESSION_IMPL *session, const char *msg)
     struct timespec stop;
     WT_CONNECTION_IMPL *conn;
     uint64_t msec;
+    bool chk_verbose;
 
-    if (!WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT))
+    WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT, chk_verbose);
+    if (!chk_verbose)
         return;
 
     conn = S2C(session);
