diff --git a/centipede/BUILD b/centipede/BUILD
index 6366036..ef5c270 100644
--- a/centipede/BUILD
+++ b/centipede/BUILD
@@ -63,8 +63,7 @@
         ":util",
         "@abseil-cpp//absl/base:nullability",
         "@abseil-cpp//absl/flags:flag",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:remote_file",
     ],
 )
@@ -77,8 +76,6 @@
         ":rusage_profiler",
         "@abseil-cpp//absl/base:nullability",
         "@abseil-cpp//absl/flags:flag",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/strings:str_format",
         "@abseil-cpp//absl/time",
@@ -132,8 +129,6 @@
         ":thread_pool",
         ":util",
         "@abseil-cpp//absl/container:node_hash_set",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/types:span",
         "@com_google_fuzztest//common:logging",
@@ -168,9 +163,9 @@
     hdrs = ["pc_info.h"],
     visibility = PUBLIC_API_VISIBILITY,
     deps = [
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/types:span",
         "@com_google_fuzztest//common:defs",
+        "@com_google_fuzztest//common:logging",
     ],
 )
 
@@ -211,7 +206,6 @@
         ":feature",
         "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/base:nullability",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
         "@abseil-cpp//absl/synchronization",
@@ -264,8 +258,6 @@
         "@abseil-cpp//absl/flags:flag",
         "@abseil-cpp//absl/flags:parse",
         "@abseil-cpp//absl/flags:reflection",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:remote_file",
@@ -290,10 +282,10 @@
     visibility = ["//visibility:public"],
     deps = [
         "@abseil-cpp//absl/base:nullability",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
         "@abseil-cpp//absl/time",
+        "@com_google_fuzztest//common:logging",
     ],
 )
 
@@ -307,12 +299,11 @@
         ":rusage_stats",
         "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/base:nullability",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
         "@abseil-cpp//absl/synchronization",
         "@abseil-cpp//absl/time",
+        "@com_google_fuzztest//common:logging",
     ],
 )
 
@@ -323,12 +314,11 @@
     deps = [
         ":rusage_stats",
         "@abseil-cpp//absl/base:core_headers",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/synchronization",
         "@abseil-cpp//absl/time",
+        "@com_google_fuzztest//common:logging",
     ],
 )
 
@@ -360,8 +350,6 @@
         "@abseil-cpp//absl/base:nullability",
         "@abseil-cpp//absl/container:btree",
         "@abseil-cpp//absl/container:flat_hash_map",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
         "@abseil-cpp//absl/time",
@@ -385,8 +373,6 @@
         ":util",
         ":workdir",
         "@abseil-cpp//absl/base:core_headers",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/synchronization",
         "@com_google_fuzztest//common:defs",
         "@com_google_fuzztest//common:hash",
@@ -410,8 +396,6 @@
         ":workdir",
         "@abseil-cpp//absl/container:flat_hash_map",
         "@abseil-cpp//absl/container:flat_hash_set",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@com_google_fuzztest//common:defs",
         "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:remote_file",
@@ -519,9 +503,9 @@
         ":symbol_table",
         "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/container:flat_hash_set",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/synchronization",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:remote_file",
         "@com_google_fuzztest//common:status_macros",
     ],
@@ -544,8 +528,6 @@
         ":util",
         "@abseil-cpp//absl/container:flat_hash_map",
         "@abseil-cpp//absl/container:flat_hash_set",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@com_google_fuzztest//common:defs",
         "@com_google_fuzztest//common:logging",
@@ -569,7 +551,6 @@
         ":pc_info",
         "@abseil-cpp//absl/container:flat_hash_map",
         "@abseil-cpp//absl/container:flat_hash_set",
-        "@abseil-cpp//absl/log:check",
         "@com_google_fuzztest//common:logging",
     ],
 )
@@ -582,8 +563,6 @@
         ":control_flow",
         ":feature",
         ":util",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@com_google_fuzztest//common:logging",
     ],
@@ -602,8 +581,6 @@
         ":feature",
         ":feature_set",
         ":util",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@com_google_fuzztest//common:defs",
         "@com_google_fuzztest//common:logging",
@@ -621,8 +598,6 @@
         ":stop",
         ":util",
         "@abseil-cpp//absl/base:core_headers",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings",
@@ -647,9 +622,8 @@
         ":pc_info",
         ":symbol_table",
         ":util",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:remote_file",
     ],
 )
@@ -677,8 +651,6 @@
         ":util",
         ":workdir",
         "@abseil-cpp//absl/base:nullability",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/time",
@@ -697,8 +669,6 @@
         ":feature",
         ":rusage_profiler",
         ":util",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/time",
         "@abseil-cpp//absl/types:span",
@@ -737,8 +707,6 @@
         ":centipede_flags",
         ":environment",
         "@abseil-cpp//absl/flags:flag",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/time",
         "@com_google_fuzztest//common:logging",
@@ -783,8 +751,6 @@
         "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/base:nullability",
         "@abseil-cpp//absl/container:flat_hash_set",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
@@ -830,8 +796,6 @@
         "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/cleanup",
         "@abseil-cpp//absl/container:flat_hash_set",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings",
@@ -870,8 +834,6 @@
         "@abseil-cpp//absl/base:no_destructor",
         "@abseil-cpp//absl/container:flat_hash_map",
         "@abseil-cpp//absl/flags:marshalling",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/time",
         "@com_google_fuzztest//common:defs",
@@ -900,8 +862,6 @@
         ":workdir",
         "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/container:flat_hash_set",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/synchronization",
         "@abseil-cpp//absl/time",
@@ -925,8 +885,6 @@
         ":mutation_input",
         ":runner_result",
         ":stop",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:statusor",
         "@com_google_fuzztest//common:defs",
@@ -1151,8 +1109,6 @@
         ":util",
         ":workdir",
         "@abseil-cpp//absl/container:flat_hash_set",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/random",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:statusor",
@@ -1176,7 +1132,6 @@
         ":seed_corpus_config_cc_proto",
         ":seed_corpus_maker_lib",
         ":workdir",
-        "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings",
@@ -1206,8 +1161,6 @@
     visibility = PUBLIC_API_VISIBILITY,
     deps = [
         ":environment",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
         "@com_google_fuzztest//common:logging",
@@ -1227,7 +1180,6 @@
         ":mutation_input",
         ":runner_result",
         ":util",
-        "@abseil-cpp//absl/log:check",
         "@com_google_fuzztest//common:defs",
     ],
 )
@@ -1264,8 +1216,8 @@
     srcs = ["environment_test.cc"],
     deps = [
         ":environment",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/time",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:configuration",
         "@googletest//:gtest_main",
     ],
@@ -1318,9 +1270,9 @@
         ":thread_pool",
         ":util",
         "@abseil-cpp//absl/container:flat_hash_map",
-        "@abseil-cpp//absl/log",
         "@com_google_fuzztest//common:defs",
         "@com_google_fuzztest//common:hash",
+        "@com_google_fuzztest//common:logging",
         "@googletest//:gtest_main",
     ],
 )
@@ -1360,7 +1312,6 @@
         ":thread_pool",
         "@abseil-cpp//absl/base:nullability",
         "@abseil-cpp//absl/flags:flag",
-        "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/synchronization",
         "@abseil-cpp//absl/time",
         "@com_google_fuzztest//common:logging",
@@ -1379,9 +1330,9 @@
         ":util",
         ":workdir",
         "@abseil-cpp//absl/flags:reflection",
-        "@abseil-cpp//absl/log:check",
         "@com_google_fuzztest//common:blob_file",
         "@com_google_fuzztest//common:defs",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:test_util",
         "@googletest//:gtest_main",
     ],
@@ -1397,8 +1348,8 @@
         ":rusage_profiler",
         ":rusage_stats",
         "@abseil-cpp//absl/flags:flag",
-        "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/time",
+        "@com_google_fuzztest//common:logging",
         "@googletest//:gtest_main",
     ],
 )
@@ -1410,7 +1361,6 @@
         ":environment",
         ":stats",
         ":util",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/log:log_entry",
         "@abseil-cpp//absl/log:log_sink",
         "@abseil-cpp//absl/log:log_sink_registry",
@@ -1453,8 +1403,7 @@
         ":environment",
         ":symbol_table",
         ":test_coverage_util",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:remote_file",
         "@com_google_fuzztest//common:test_util",
         "@googletest//:gtest_main",
@@ -1606,10 +1555,10 @@
         ":feature",
         ":util",
         ":workdir",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/types:span",
         "@com_google_fuzztest//common:blob_file",
         "@com_google_fuzztest//common:defs",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:test_util",
         "@googletest//:gtest_main",
     ],
@@ -1650,9 +1599,9 @@
         ":command",
         ":stop",
         ":util",
-        "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/time",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:test_util",
         "@googletest//:gtest_main",
     ],
@@ -1683,8 +1632,6 @@
         ":symbol_table",
         ":thread_pool",
         "@abseil-cpp//absl/container:flat_hash_map",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:test_util",
         "@googletest//:gtest_main",
@@ -1720,7 +1667,6 @@
         ":feature",
         ":seed_corpus_maker_lib",
         ":workdir",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@com_google_fuzztest//common:defs",
         "@com_google_fuzztest//common:logging",
@@ -1778,7 +1724,6 @@
         ":resource_pool",
         ":rusage_stats",
         ":thread_pool",
-        "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/time",
         "@com_google_fuzztest//common:logging",
@@ -1871,8 +1816,6 @@
         ":workdir",
         "@abseil-cpp//absl/base:nullability",
         "@abseil-cpp//absl/container:flat_hash_set",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/time",
         "@com_google_fuzztest//common:defs",
diff --git a/centipede/analyze_corpora.cc b/centipede/analyze_corpora.cc
index 56e75c7..0216d83 100644
--- a/centipede/analyze_corpora.cc
+++ b/centipede/analyze_corpora.cc
@@ -24,8 +24,6 @@
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "./centipede/binary_info.h"
 #include "./centipede/control_flow.h"
 #include "./centipede/corpus.h"
@@ -48,17 +46,17 @@
   WorkDir workdir(std::string(workdir_path), std::string(binary_name),
                   std::string(binary_hash), /*my_shard_index=*/0);
   std::vector<std::string> corpus_paths;
-  CHECK_OK(
+  FUZZTEST_CHECK_OK(
       RemoteGlobMatch(workdir.CorpusFilePaths().AllShardsGlob(), corpus_paths));
   std::vector<std::string> features_paths;
-  CHECK_OK(RemoteGlobMatch(workdir.FeaturesFilePaths().AllShardsGlob(),
-                           features_paths));
+  FUZZTEST_CHECK_OK(RemoteGlobMatch(workdir.FeaturesFilePaths().AllShardsGlob(),
+                                    features_paths));
 
-  CHECK_EQ(corpus_paths.size(), features_paths.size());
+  FUZZTEST_CHECK_EQ(corpus_paths.size(), features_paths.size());
   std::vector<CorpusRecord> corpus;
   for (int i = 0; i < corpus_paths.size(); ++i) {
-    LOG(INFO) << "Reading corpus at: " << corpus_paths[i];
-    LOG(INFO) << "Reading features at: " << features_paths[i];
+    FUZZTEST_LOG(INFO) << "Reading corpus at: " << corpus_paths[i];
+    FUZZTEST_LOG(INFO) << "Reading features at: " << features_paths[i];
     ReadShard(corpus_paths[i], features_paths[i],
               [&corpus](ByteArray input, FeatureVec features) {
                 corpus.push_back({std::move(input), std::move(features)});
@@ -126,9 +124,10 @@
       a_only_pcs.insert(pc);
     }
   }
-  LOG(INFO) << VV(a.size()) << VV(b.size()) << VV(a_pcs.size())
-            << VV(a_only_pcs.size()) << VV(b_only_pcs.size())
-            << VV(b_shared_indices.size()) << VV(b_unique_indices.size());
+  FUZZTEST_LOG(INFO) << VV(a.size()) << VV(b.size()) << VV(a_pcs.size())
+                     << VV(a_only_pcs.size()) << VV(b_only_pcs.size())
+                     << VV(b_shared_indices.size())
+                     << VV(b_unique_indices.size());
 
   // Sort PCs to put them in the canonical order, as in pc_table.
   AnalyzeCorporaResults ret;
@@ -178,7 +177,7 @@
 
 void DumpCoverageReport(const CoverageResults &coverage_results,
                         std::string_view coverage_report_path) {
-  LOG(INFO) << "Dump coverage to file: " << coverage_report_path;
+  FUZZTEST_LOG(INFO) << "Dump coverage to file: " << coverage_report_path;
 
   const fuzztest::internal::PCTable &pc_table =
       coverage_results.binary_info.pc_table;
@@ -187,7 +186,7 @@
 
   fuzztest::internal::SymbolTable coverage_symbol_table;
   for (const PCIndex pc : coverage_results.pcs) {
-    CHECK_LE(pc, symbols.size());
+    FUZZTEST_CHECK_LE(pc, symbols.size());
     if (!pc_table[pc].has_flag(fuzztest::internal::PCInfo::kFuncEntry))
       continue;
     const SymbolTable::Entry entry = symbols.entry(pc);
@@ -197,7 +196,7 @@
   std::ostringstream symbol_table_stream;
   coverage_symbol_table.WriteToLLVMSymbolizer(symbol_table_stream);
 
-  CHECK_OK(
+  FUZZTEST_CHECK_OK(
       RemoteFileSetContents(coverage_report_path, symbol_table_stream.str()));
 }
 
@@ -210,8 +209,9 @@
   BinaryInfo binary_info_b =
       ReadBinaryInfo(binary_name, binary_hash, workdir_b);
 
-  CHECK_EQ(binary_info_a.pc_table.size(), binary_info_b.pc_table.size());
-  CHECK_EQ(binary_info_a.symbols.size(), binary_info_b.symbols.size());
+  FUZZTEST_CHECK_EQ(binary_info_a.pc_table.size(),
+                    binary_info_b.pc_table.size());
+  FUZZTEST_CHECK_EQ(binary_info_a.symbols.size(), binary_info_b.symbols.size());
 
   const std::vector<CorpusRecord> a =
       ReadCorpora(binary_name, binary_hash, workdir_a);
@@ -235,26 +235,26 @@
   CoverageLogger coverage_logger(pc_table, symbols);
 
   // TODO(kcc): use frontier_a to show the most interesting b-only PCs.
-  // TODO(kcc): these cause a CHECK-fail
+  // TODO(kcc): these cause a FUZZTEST_CHECK-fail
   // CoverageFrontier frontier_a(results.binary_info);
   // frontier_a.Compute(a);
 
   // First, print the newly covered functions (including partially covered).
-  LOG(INFO) << "B-only new functions:";
+  FUZZTEST_LOG(INFO) << "B-only new functions:";
   absl::flat_hash_set<std::string_view> b_only_new_functions;
   for (const auto pc : results.b_only_pcs) {
     if (!pc_table[pc].has_flag(PCInfo::kFuncEntry)) continue;
     auto str = coverage_logger.ObserveAndDescribeIfNew(pc);
-    if (!str.empty()) LOG(INFO).NoPrefix() << str;
+    if (!str.empty()) FUZZTEST_LOG(INFO).NoPrefix() << str;
     b_only_new_functions.insert(symbols.func(pc));
   }
 
   // Now, print newly covered edges in functions that were covered in `a`.
-  LOG(INFO) << "B-only new edges:";
+  FUZZTEST_LOG(INFO) << "B-only new edges:";
   for (const auto pc : results.b_only_pcs) {
     if (b_only_new_functions.contains(symbols.func(pc))) continue;
     auto str = coverage_logger.ObserveAndDescribeIfNew(pc);
-    if (!str.empty()) LOG(INFO).NoPrefix() << str;
+    if (!str.empty()) FUZZTEST_LOG(INFO).NoPrefix() << str;
   }
 }
 
diff --git a/centipede/analyze_corpora.h b/centipede/analyze_corpora.h
index 3343e05..d1731b8 100644
--- a/centipede/analyze_corpora.h
+++ b/centipede/analyze_corpora.h
@@ -62,7 +62,7 @@
                                      std::string_view workdir_a,
                                      std::string_view workdir_b);
 
-// Same as above but `LOG`s the results for human consumption.
+// Same as above but `FUZZTEST_LOG`s the results for human consumption.
 void AnalyzeCorporaToLog(std::string_view binary_name,
                          std::string_view binary_hash,
                          std::string_view workdir_a,
diff --git a/centipede/analyze_corpora_test.cc b/centipede/analyze_corpora_test.cc
index f65106d..cf00c54 100644
--- a/centipede/analyze_corpora_test.cc
+++ b/centipede/analyze_corpora_test.cc
@@ -24,12 +24,11 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "./centipede/binary_info.h"
 #include "./centipede/environment.h"
 #include "./centipede/symbol_table.h"
 #include "./centipede/test_coverage_util.h"
+#include "./common/logging.h"
 #include "./common/remote_file.h"
 #include "./common/test_util.h"
 
@@ -47,7 +46,7 @@
 }
 
 // TODO(ussuri): Implement.
-TEST(AnalyzeCorpora, AnalyzeCorpora) { LOG(INFO) << "Unimplemented"; }
+TEST(AnalyzeCorpora, AnalyzeCorpora) { FUZZTEST_LOG(INFO) << "Unimplemented"; }
 
 TEST(GetCoverage, SimpleCoverageResults) {
   Environment env;
diff --git a/centipede/binary_info.cc b/centipede/binary_info.cc
index d604be3..227bb88 100644
--- a/centipede/binary_info.cc
+++ b/centipede/binary_info.cc
@@ -22,14 +22,13 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
 #include "./centipede/command.h"
 #include "./centipede/control_flow.h"
 #include "./centipede/pc_info.h"
 #include "./centipede/util.h"
+#include "./common/logging.h"
 #include "./common/remote_file.h"
 
 namespace fuzztest::internal {
@@ -45,18 +44,18 @@
     std::string_view symbolizer_path, std::string_view tmp_dir_path) {
   if (binary_path_with_args.empty()) {
     // This usually happens in tests.
-    LOG(INFO) << __func__ << ": binary_path_with_args is empty";
+    FUZZTEST_LOG(INFO) << __func__ << ": binary_path_with_args is empty";
     return;
   }
   // Compute names for temp files.
   const std::filesystem::path tmp_dir = tmp_dir_path;
-  CHECK(std::filesystem::exists(tmp_dir) &&
-        std::filesystem::is_directory(tmp_dir));
+  FUZZTEST_CHECK(std::filesystem::exists(tmp_dir) &&
+                 std::filesystem::is_directory(tmp_dir));
   ScopedFile pc_table_path(tmp_dir_path, "pc_table_tmp");
   ScopedFile cf_table_path(tmp_dir_path, "cf_table_tmp");
   ScopedFile dso_table_path(tmp_dir_path, "dso_table_tmp");
   ScopedFile log_path(tmp_dir_path, "binary_info_log_tmp");
-  LOG(INFO) << __func__ << ": tmp_dir: " << tmp_dir;
+  FUZZTEST_LOG(INFO) << __func__ << ": tmp_dir: " << tmp_dir;
 
   Command::Options cmd_options;
   cmd_options.env_add = {absl::StrCat(
@@ -66,7 +65,7 @@
   Command cmd{binary_path_with_args, std::move(cmd_options)};
   int exit_code = cmd.Execute();
   if (exit_code != EXIT_SUCCESS) {
-    LOG(INFO) << __func__ << ": exit_code: " << exit_code;
+    FUZZTEST_LOG(INFO) << __func__ << ": exit_code: " << exit_code;
   }
 
   // Load PC Table.
@@ -80,24 +79,25 @@
   dso_table = ReadDsoTableFromFile(dso_table_path.path());
 
   if (pc_table.empty()) {
-    CHECK(dso_table.empty());
+    FUZZTEST_CHECK(dso_table.empty());
     // Fallback to GetPcTableFromBinaryWithTracePC().
-    LOG(WARNING)
+    FUZZTEST_LOG(WARNING)
         << "Failed to dump PC table directly from binary using linked-in "
            "runner; see target execution logs above; falling back to legacy PC "
            "table extraction using trace-pc and objdump";
     pc_table = GetPcTableFromBinaryWithTracePC(
         binary_path_with_args, objdump_path, pc_table_path.path());
     if (pc_table.empty()) {
-      LOG(ERROR) << "Failed to extract PC table from binary using objdump; see "
-                    "objdump execution logs above";
+      FUZZTEST_LOG(ERROR)
+          << "Failed to extract PC table from binary using objdump; see "
+             "objdump execution logs above";
     }
     // For the legacy trace-pc instrumentation, set the dso_table
     // to 1-element array consisting of the binary name
     const std::vector<std::string> args =
         absl::StrSplit(binary_path_with_args, absl::ByAnyChar{" \t\n"},
                        absl::SkipWhitespace{});
-    CHECK(!args.empty());
+    FUZZTEST_CHECK(!args.empty());
     dso_table.push_back({args[0], pc_table.size()});
     uses_legacy_trace_pc_instrumentation = true;
   } else {
@@ -110,7 +110,7 @@
     for (const auto& dso : dso_table) {
       num_instrumened_pcs_in_all_dsos += dso.num_instrumented_pcs;
     }
-    CHECK_EQ(num_instrumened_pcs_in_all_dsos, pc_table.size());
+    FUZZTEST_CHECK_EQ(num_instrumened_pcs_in_all_dsos, pc_table.size());
   }
 
   // Load symbols, if there is a PC table.
@@ -125,14 +125,14 @@
 void BinaryInfo::Read(std::string_view dir) {
   std::string symbol_table_contents;
   // TODO(b/295978603): move calculation of paths into WorkDir class.
-  CHECK_OK(RemoteFileGetContents(
+  FUZZTEST_CHECK_OK(RemoteFileGetContents(
       (std::filesystem::path(dir) / kSymbolTableFileName).c_str(),
       symbol_table_contents));
   std::istringstream symbol_table_stream(symbol_table_contents);
   symbols.ReadFromLLVMSymbolizer(symbol_table_stream);
 
   std::string pc_table_contents;
-  CHECK_OK(RemoteFileGetContents(
+  FUZZTEST_CHECK_OK(RemoteFileGetContents(
       (std::filesystem::path(dir) / kPCTableFileName).c_str(),
       pc_table_contents));
   std::istringstream pc_table_stream(pc_table_contents);
@@ -146,19 +146,19 @@
   std::ostringstream symbol_table_stream;
   symbols.WriteToLLVMSymbolizer(symbol_table_stream);
   // TODO(b/295978603): move calculation of paths into WorkDir class.
-  CHECK_OK(RemoteFileSetContents(
+  FUZZTEST_CHECK_OK(RemoteFileSetContents(
       (std::filesystem::path(dir) / kSymbolTableFileName).c_str(),
       symbol_table_stream.str()));
 
   std::ostringstream pc_table_stream;
   WritePcTable(pc_table, pc_table_stream);
-  CHECK_OK(RemoteFileSetContents(
+  FUZZTEST_CHECK_OK(RemoteFileSetContents(
       (std::filesystem::path(dir) / kPCTableFileName).c_str(),
       pc_table_stream.str()));
 
   std::ostringstream cf_table_stream;
   WriteCfTable(cf_table, cf_table_stream);
-  CHECK_OK(RemoteFileSetContents(
+  FUZZTEST_CHECK_OK(RemoteFileSetContents(
       (std::filesystem::path(dir) / kCfTableFileName).c_str(),
       cf_table_stream.str()));
 }
diff --git a/centipede/blob_file_converter.cc b/centipede/blob_file_converter.cc
index de21421..e9cb69b 100644
--- a/centipede/blob_file_converter.cc
+++ b/centipede/blob_file_converter.cc
@@ -19,8 +19,6 @@
 
 #include "absl/base/nullability.h"
 #include "absl/flags/flag.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/time/clock.h"
@@ -59,11 +57,11 @@
     const std::string stats = absl::StrFormat(
         "blobs: %9lld | blobs/s: %5.0f | bytes: %12lld | bytes/s: %8.0f",
         num_blobs_, num_blobs_ / secs, num_bytes_, num_bytes_ / secs);
-    if (ABSL_VLOG_IS_ON(3)) {
+    if (FUZZTEST_VLOG_IS_ON(3)) {
       const RUsageProfiler::Snapshot& snapshot = RPROF_SNAPSHOT(stats);
-      LOG(INFO) << stats << " | " << snapshot.memory.ShortStr();
+      FUZZTEST_LOG(INFO) << stats << " | " << snapshot.memory.ShortStr();
     } else {
-      LOG(INFO) << stats;
+      FUZZTEST_LOG(INFO) << stats;
     }
   }
 
@@ -90,45 +88,49 @@
 void Convert(               //
     const std::string& in,  //
     const std::string& out, const std::string& out_format) {
-  RPROF_THIS_FUNCTION_WITH_REPORT(/*enable=*/ABSL_VLOG_IS_ON(1));
+  RPROF_THIS_FUNCTION_WITH_REPORT(/*enable=*/FUZZTEST_VLOG_IS_ON(1));
 
-  LOG(INFO) << "Converting:\n" << VV(in) << "\n" << VV(out) << VV(out_format);
+  FUZZTEST_LOG(INFO) << "Converting:\n"
+                     << VV(in) << "\n"
+                     << VV(out) << VV(out_format);
 
   const bool out_is_riegeli = out_format == "riegeli";
 
   // Verify and prepare source and destination.
 
-  CHECK(RemotePathExists(in)) << VV(in);
-  CHECK_OK(RemoteMkdir(std::filesystem::path{out}.parent_path().c_str()));
+  FUZZTEST_CHECK(RemotePathExists(in)) << VV(in);
+  FUZZTEST_CHECK_OK(
+      RemoteMkdir(std::filesystem::path{out}.parent_path().c_str()));
 
   // Open blob file reader and writer.
 
   RPROF_START_TIMELAPSE(  //
-      absl::Seconds(20), /*also_log=*/ABSL_VLOG_IS_ON(3), "Opening --in");
+      absl::Seconds(20), /*also_log=*/FUZZTEST_VLOG_IS_ON(3), "Opening --in");
   const auto in_reader = DefaultBlobFileReaderFactory();
-  CHECK_OK(in_reader->Open(in)) << VV(in);
+  FUZZTEST_CHECK_OK(in_reader->Open(in)) << VV(in);
   RPROF_STOP_TIMELAPSE();
-  RPROF_SNAPSHOT_AND_LOG("Opened --in; opening --out");
+  RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Opened --in; opening --out");
   const auto out_writer = DefaultBlobFileWriterFactory(out_is_riegeli);
-  CHECK_OK(out_writer->Open(out, "w")) << VV(out);
-  RPROF_SNAPSHOT_AND_LOG("Opened --out");
+  FUZZTEST_CHECK_OK(out_writer->Open(out, "w")) << VV(out);
+  RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Opened --out");
 
   // Read and write blobs one-by-one.
 
   ByteSpan blob;
   absl::Status read_status = absl::OkStatus();
   StatsLogger stats_logger{
-      absl::Seconds(ABSL_VLOG_IS_ON(1) ? 20 : 60),
+      absl::Seconds(FUZZTEST_VLOG_IS_ON(1) ? 20 : 60),
       FUNCTION_LEVEL_RPROF_NAME,
   };
   while ((read_status = in_reader->Read(blob)).ok()) {
-    CHECK_OK(out_writer->Write(blob));
+    FUZZTEST_CHECK_OK(out_writer->Write(blob));
     stats_logger.UpdateStats(blob);
     stats_logger.MaybeLogIfTime();
   }
   stats_logger.Log();
-  CHECK(read_status.ok() || absl::IsOutOfRange(read_status)) << VV(read_status);
-  CHECK_OK(out_writer->Close()) << VV(out);
+  FUZZTEST_CHECK(read_status.ok() || absl::IsOutOfRange(read_status))
+      << VV(read_status);
+  FUZZTEST_CHECK_OK(out_writer->Close()) << VV(out);
 }
 
 }  // namespace
@@ -138,11 +140,12 @@
   (void)fuzztest::internal::InitRuntime(argc, argv);
 
   const std::string in = absl::GetFlag(FLAGS_in);
-  QCHECK(!in.empty());
+  FUZZTEST_QCHECK(!in.empty());
   const std::string out = absl::GetFlag(FLAGS_out);
-  QCHECK(!out.empty());
+  FUZZTEST_QCHECK(!out.empty());
   const std::string out_format = absl::GetFlag(FLAGS_out_format);
-  QCHECK(out_format == "legacy" || out_format == "riegeli") << VV(out_format);
+  FUZZTEST_QCHECK(out_format == "legacy" || out_format == "riegeli")
+      << VV(out_format);
 
   fuzztest::internal::Convert(in, out, out_format);
 
diff --git a/centipede/call_graph.cc b/centipede/call_graph.cc
index 9121557..b78c37f 100644
--- a/centipede/call_graph.cc
+++ b/centipede/call_graph.cc
@@ -18,9 +18,9 @@
 #include <cstdint>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "./centipede/control_flow.h"
 #include "./centipede/pc_info.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 
@@ -54,7 +54,7 @@
       ++j;
     }
     ++j;  // Step over the delimeter.
-    CHECK_LE(j, cf_table.size());
+    FUZZTEST_CHECK_LE(j, cf_table.size());
 
     if (current_callees.empty()) continue;
     basic_block_callees_[current_pc] = current_callees;
@@ -64,7 +64,7 @@
         current_callees.end());
   }
   // This should stay empty.
-  CHECK(empty_.empty());
+  FUZZTEST_CHECK(empty_.empty());
 }
 
 }  // namespace fuzztest::internal
diff --git a/centipede/call_graph.h b/centipede/call_graph.h
index 3e3c03b..2377e36 100644
--- a/centipede/call_graph.h
+++ b/centipede/call_graph.h
@@ -20,7 +20,6 @@
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
-#include "absl/log/check.h"
 #include "./centipede/control_flow.h"
 #include "./centipede/pc_info.h"
 #include "./common/logging.h"
@@ -34,13 +33,15 @@
   void InitializeCallGraph(const CFTable& cf_table, const PCTable& pc_table);
 
   const std::vector<uintptr_t>& GetFunctionCallees(uintptr_t pc) const {
-    CHECK(IsFunctionEntry(pc)) << VV(pc) << " is not a function entry.";
+    FUZZTEST_CHECK(IsFunctionEntry(pc))
+        << VV(pc) << " is not a function entry.";
     const auto it = call_graph_.find(pc);
     if (it == call_graph_.cend()) return empty_;
     return it->second;
   }
   const std::vector<uintptr_t>& GetBasicBlockCallees(uintptr_t pc) const {
-    CHECK(basic_blocks_.contains(pc)) << VV(pc) << " is not a basic block.";
+    FUZZTEST_CHECK(basic_blocks_.contains(pc))
+        << VV(pc) << " is not a basic block.";
     const auto it = basic_block_callees_.find(pc);
     if (it == basic_block_callees_.cend()) return empty_;
     return it->second;
diff --git a/centipede/centipede.cc b/centipede/centipede.cc
index 84490e4..d366c75 100644
--- a/centipede/centipede.cc
+++ b/centipede/centipede.cc
@@ -64,8 +64,6 @@
 #include "absl/base/const_init.h"  // NOLINT
 #include "absl/base/nullability.h"
 #include "absl/container/flat_hash_set.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
@@ -132,15 +130,15 @@
           /*raii_actions=*/RUsageProfiler::kRaiiOff,
           /*location=*/{__FILE__, __LINE__},
           /*description=*/"Engine") {
-  CHECK(env_.seed) << "env_.seed must not be zero";
+  FUZZTEST_CHECK(env_.seed) << "env_.seed must not be zero";
   if (!env_.input_filter.empty() && env_.fork_server)
     input_filter_cmd_.StartForkServer(TemporaryLocalDirPath(), "input_filter");
 }
 
 void Centipede::CorpusToFiles(const Environment &env, std::string_view dir) {
   std::vector<std::string> sharded_corpus_files;
-  CHECK_OK(RemoteGlobMatch(WorkDir{env}.CorpusFilePaths().AllShardsGlob(),
-                           sharded_corpus_files));
+  FUZZTEST_CHECK_OK(RemoteGlobMatch(
+      WorkDir{env}.CorpusFilePaths().AllShardsGlob(), sharded_corpus_files));
   ExportCorpus(sharded_corpus_files, dir);
 }
 
@@ -161,7 +159,7 @@
   // If the destination `workdir` is specified (note that empty means "use the
   // current directory"), we might need to create it.
   if (!env.workdir.empty()) {
-    CHECK_OK(RemoteMkdir(env.workdir));
+    FUZZTEST_CHECK_OK(RemoteMkdir(env.workdir));
   }
 
   // Iterate over all shards, adding inputs to the current shard.
@@ -184,23 +182,23 @@
     }
     // Add inputs to the current shard, if the shard doesn't have them already.
     auto appender = DefaultBlobFileWriterFactory(env.riegeli);
-    CHECK_OK(appender->Open(corpus_file_path, "a"))
+    FUZZTEST_CHECK_OK(appender->Open(corpus_file_path, "a"))
         << "Failed to open corpus file: " << corpus_file_path;
     ByteArray shard_data;
     for (const auto &path : sharded_paths[shard]) {
       std::string input;
-      CHECK_OK(RemoteFileGetContents(path, input));
+      FUZZTEST_CHECK_OK(RemoteFileGetContents(path, input));
       if (input.empty() || existing_hashes.contains(Hash(input))) {
         ++inputs_ignored;
         continue;
       }
-      CHECK_OK(appender->Write(ByteArray{input.begin(), input.end()}));
+      FUZZTEST_CHECK_OK(appender->Write(ByteArray{input.begin(), input.end()}));
       ++inputs_added;
     }
-    LOG(INFO) << VV(shard) << VV(inputs_added) << VV(inputs_ignored)
-              << VV(num_shard_bytes) << VV(shard_data.size());
+    FUZZTEST_LOG(INFO) << VV(shard) << VV(inputs_added) << VV(inputs_ignored)
+                       << VV(num_shard_bytes) << VV(shard_data.size());
   }
-  CHECK_EQ(total_paths, inputs_added + inputs_ignored);
+  FUZZTEST_CHECK_EQ(total_paths, inputs_added + inputs_ignored);
 }
 
 absl::Status Centipede::CrashesToFiles(const Environment &env,
@@ -228,7 +226,7 @@
           (std::filesystem::path{dir} / absl::StrCat(id, ".data")).string()));
       const auto shard_index = wd.CrashReproducerDirPaths().GetShardIndex(
           std::filesystem::path{reproducer_path}.parent_path().string());
-      CHECK(shard_index.has_value());
+      FUZZTEST_CHECK(shard_index.has_value());
       const auto metadata_dir = wd.CrashMetadataDirPaths().Shard(*shard_index);
       const auto description_filename = absl::StrCat(id, ".desc");
       const auto signature_filename = absl::StrCat(id, ".sig");
@@ -339,7 +337,7 @@
   os << " exec/s: "
      << (execs_per_sec < 1.0 ? execs_per_sec : std::round(execs_per_sec));
   os << " mb: " << (rusage_memory.mem_rss >> 20);
-  LOG(INFO) << os.str();
+  FUZZTEST_LOG(INFO) << os.str();
 }
 
 void Centipede::LogFeaturesAsSymbols(const FeatureVec &fv) {
@@ -349,7 +347,7 @@
     PCIndex pc_index = ConvertPCFeatureToPcIndex(feature);
     auto description = coverage_logger_.ObserveAndDescribeIfNew(pc_index);
     if (description.empty()) continue;
-    LOG(INFO) << description;
+    FUZZTEST_LOG(INFO) << description;
   }
 }
 
@@ -417,7 +415,7 @@
     BlobFileWriter *absl_nullable unconditional_features_file) {
   BatchResult batch_result;
   bool success = ExecuteAndReportCrash(env_.binary, input_vec, batch_result);
-  CHECK_EQ(input_vec.size(), batch_result.results().size());
+  FUZZTEST_CHECK_EQ(input_vec.size(), batch_result.results().size());
 
   for (const auto &extra_binary : env_.extra_binaries) {
     if (ShouldStop()) break;
@@ -428,11 +426,11 @@
   }
   if (EarlyStopRequested()) return false;
   if (!success && env_.exit_on_crash) {
-    LOG(INFO) << "--exit_on_crash is enabled; exiting soon";
+    FUZZTEST_LOG(INFO) << "--exit_on_crash is enabled; exiting soon";
     RequestEarlyStop(EXIT_FAILURE);
     return false;
   }
-  CHECK_EQ(batch_result.results().size(), input_vec.size());
+  FUZZTEST_CHECK_EQ(batch_result.results().size(), input_vec.size());
   num_runs_ += input_vec.size();
   bool batch_gained_new_coverage = false;
   for (size_t i = 0; i < input_vec.size(); i++) {
@@ -443,7 +441,7 @@
     if (env_.use_pcpair_features && AddPcPairFeatures(fv) != 0)
       input_gained_new_coverage = true;
     if (unconditional_features_file != nullptr) {
-      CHECK_OK(unconditional_features_file->Write(
+      FUZZTEST_CHECK_OK(unconditional_features_file->Write(
           PackFeaturesAndHash(input_vec[i], fv)));
     }
     if (input_gained_new_coverage) {
@@ -452,19 +450,20 @@
       fs_.IncrementFrequencies(fv);
       LogFeaturesAsSymbols(fv);
       batch_gained_new_coverage = true;
-      CHECK_GT(fv.size(), 0UL);
+      FUZZTEST_CHECK_GT(fv.size(), 0UL);
       if (function_filter_passed) {
         corpus_.Add(input_vec[i], fv, batch_result.results()[i].metadata(), fs_,
                     coverage_frontier_);
       }
       if (corpus_file != nullptr) {
-        CHECK_OK(corpus_file->Write(input_vec[i]));
+        FUZZTEST_CHECK_OK(corpus_file->Write(input_vec[i]));
       }
       if (!env_.corpus_dir.empty() && !env_.corpus_dir[0].empty()) {
         WriteToLocalHashedFileInDir(env_.corpus_dir[0], input_vec[i]);
       }
       if (features_file != nullptr) {
-        CHECK_OK(features_file->Write(PackFeaturesAndHash(input_vec[i], fv)));
+        FUZZTEST_CHECK_OK(
+            features_file->Write(PackFeaturesAndHash(input_vec[i], fv)));
       }
     }
   }
@@ -474,8 +473,8 @@
 // TODO(kcc): [impl] don't reread the same corpus twice.
 void Centipede::LoadShard(const Environment &load_env, size_t shard_index,
                           bool rerun) {
-  VLOG(1) << "Loading shard " << shard_index
-          << (rerun ? " with rerunning" : " without rerunning");
+  FUZZTEST_VLOG(1) << "Loading shard " << shard_index
+                   << (rerun ? " with rerunning" : " without rerunning");
   size_t num_added_inputs = 0;
   size_t num_skipped_inputs = 0;
   std::vector<ByteArray> inputs_to_rerun;
@@ -491,14 +490,14 @@
       const auto num_new_features =
           fs_.PruneFeaturesAndCountUnseen(input_features);
       if (num_new_features != 0) {
-        VLOG(10) << "Adding input " << Hash(input)
-                 << "; new features: " << num_new_features;
+        FUZZTEST_VLOG(10) << "Adding input " << Hash(input)
+                          << "; new features: " << num_new_features;
         fs_.IncrementFrequencies(input_features);
         // TODO(kcc): cmp_args are currently not saved to disk and not reloaded.
         corpus_.Add(input, input_features, {}, fs_, coverage_frontier_);
         ++num_added_inputs;
       } else {
-        VLOG(10) << "Skipping input: " << Hash(input);
+        FUZZTEST_VLOG(10) << "Skipping input: " << Hash(input);
         ++num_skipped_inputs;
       }
     }
@@ -517,8 +516,9 @@
     ReadShard(corpus_path, features_path, input_features_callback);
   }
 
-  VLOG(1) << "Loaded shard " << shard_index << ": added " << num_added_inputs
-          << " / skipped " << num_skipped_inputs << " inputs";
+  FUZZTEST_VLOG(1) << "Loaded shard " << shard_index << ": added "
+                   << num_added_inputs << " / skipped " << num_skipped_inputs
+                   << " inputs";
 
   if (num_added_inputs > 0) UpdateAndMaybeLogStats("load-shard", 1);
   if (!inputs_to_rerun.empty()) Rerun(inputs_to_rerun);
@@ -536,7 +536,8 @@
   for (size_t shard_idx : shard_idxs) {
     const bool rerun = rerun_my_shard && shard_idx == env_.my_shard_index;
     LoadShard(load_env, shard_idx, rerun);
-    LOG_IF(INFO, (++num_shards_loaded % 100) == 0) << VV(num_shards_loaded);
+    FUZZTEST_LOG_IF(INFO, (++num_shards_loaded % 100) == 0)
+        << VV(num_shards_loaded);
   }
 }
 
@@ -544,9 +545,9 @@
   if (to_rerun.empty()) return;
   auto features_file_path = wd_.FeaturesFilePaths().Shard(env_.my_shard_index);
   auto features_file = DefaultBlobFileWriterFactory(env_.riegeli);
-  CHECK_OK(features_file->Open(features_file_path, "a"));
+  FUZZTEST_CHECK_OK(features_file->Open(features_file_path, "a"));
 
-  LOG(INFO) << to_rerun.size() << " inputs to rerun";
+  FUZZTEST_LOG(INFO) << to_rerun.size() << " inputs to rerun";
   // Re-run all inputs for which we don't know their features.
   // Run in batches of at most env_.batch_size inputs each.
   while (!to_rerun.empty()) {
@@ -565,8 +566,8 @@
   if (pc_table_.empty()) return;
 
   auto coverage_path = wd_.CoverageReportPath(filename_annotation);
-  LOG(INFO) << "Generate coverage report [" << description << "]; "
-            << VV(coverage_path);
+  FUZZTEST_LOG(INFO) << "Generate coverage report [" << description << "]; "
+                     << VV(coverage_path);
   auto pci_vec = fs_.ToCoveragePCs();
   Coverage coverage(pc_table_, pci_vec);
   coverage.DumpReportToFile(symbols_, coverage_path, description);
@@ -575,8 +576,8 @@
 void Centipede::GenerateCorpusStats(std::string_view filename_annotation,
                                     std::string_view description) {
   auto stats_path = wd_.CorpusStatsPath(filename_annotation);
-  LOG(INFO) << "Generate corpus stats [" << description << "]; "
-            << VV(stats_path);
+  FUZZTEST_LOG(INFO) << "Generate corpus stats [" << description << "]; "
+                     << VV(stats_path);
   corpus_.DumpStatsToFile(fs_, stats_path, description);
 }
 
@@ -586,14 +587,14 @@
   if (env_.clang_coverage_binary.empty()) return;
 
   auto report_path = wd_.SourceBasedCoverageReportPath(filename_annotation);
-  LOG(INFO) << "Generate source based coverage report [" << description << "]; "
-            << VV(report_path);
-  CHECK_OK(RemoteMkdir(report_path));
+  FUZZTEST_LOG(INFO) << "Generate source based coverage report [" << description
+                     << "]; " << VV(report_path);
+  FUZZTEST_CHECK_OK(RemoteMkdir(report_path));
 
   std::vector<std::string> raw_profiles = wd_.EnumerateRawCoverageProfiles();
 
   if (raw_profiles.empty()) {
-    LOG(ERROR) << "No raw profiles found for coverage report";
+    FUZZTEST_LOG(ERROR) << "No raw profiles found for coverage report";
     return;
   }
 
@@ -610,7 +611,7 @@
   merge_cmd_options.args = std::move(merge_arguments);
   Command merge_command{"llvm-profdata", std::move(merge_cmd_options)};
   if (merge_command.Execute() != EXIT_SUCCESS) {
-    LOG(ERROR) << "Failed to run command " << merge_command.ToString();
+    FUZZTEST_LOG(ERROR) << "Failed to run command " << merge_command.ToString();
     return;
   }
 
@@ -622,8 +623,8 @@
   Command generate_report_command{"llvm-cov",
                                   std::move(generate_report_cmd_options)};
   if (generate_report_command.Execute() != EXIT_SUCCESS) {
-    LOG(ERROR) << "Failed to run command "
-               << generate_report_command.ToString();
+    FUZZTEST_LOG(ERROR) << "Failed to run command "
+                        << generate_report_command.ToString();
     return;
   }
 }
@@ -634,15 +635,16 @@
    public:
     explicit ReportDumper(std::string_view path)
         : file_{*RemoteFileOpen(path, "w")} {
-      CHECK(file_ != nullptr) << VV(path);
-      CHECK_OK(RemoteFileSetWriteBufferSize(file_, 10UL * 1024 * 1024));
+      FUZZTEST_CHECK(file_ != nullptr) << VV(path);
+      FUZZTEST_CHECK_OK(
+          RemoteFileSetWriteBufferSize(file_, 10UL * 1024 * 1024));
     }
 
-    ~ReportDumper() override { CHECK_OK(RemoteFileClose(file_)); }
+    ~ReportDumper() override { FUZZTEST_CHECK_OK(RemoteFileClose(file_)); }
 
     ReportDumper &operator<<(std::string_view fragment) override {
-      CHECK_OK(RemoteFileAppend(file_,
-                                ByteArray{fragment.cbegin(), fragment.cend()}));
+      FUZZTEST_CHECK_OK(RemoteFileAppend(
+          file_, ByteArray{fragment.cbegin(), fragment.cend()}));
       return *this;
     }
 
@@ -652,10 +654,11 @@
 
   const auto &snapshot = rusage_profiler_.TakeSnapshot(
       {__FILE__, __LINE__}, std::string{description});
-  VLOG(1) << "Rusage @ " << description << ": " << snapshot.ShortMetricsStr();
+  FUZZTEST_VLOG(1) << "Rusage @ " << description << ": "
+                   << snapshot.ShortMetricsStr();
   auto path = wd_.RUsageReportPath(filename_annotation);
-  LOG(INFO) << "Generate rusage report [" << description << "]; "
-            << VV(env_.my_shard_index) << VV(path);
+  FUZZTEST_LOG(INFO) << "Generate rusage report [" << description << "]; "
+                     << VV(env_.my_shard_index) << VV(path);
   ReportDumper dumper{path};
   rusage_profiler_.GenerateReport(&dumper);
 }
@@ -682,22 +685,23 @@
 
 void Centipede::MergeFromOtherCorpus(std::string_view merge_from_dir,
                                      size_t shard_index_to_merge) {
-  LOG(INFO) << __func__ << ": " << merge_from_dir;
+  FUZZTEST_LOG(INFO) << __func__ << ": " << merge_from_dir;
   Environment merge_from_env = env_;
   merge_from_env.workdir = merge_from_dir;
   size_t initial_corpus_size = corpus_.NumActive();
   LoadShard(merge_from_env, shard_index_to_merge, /*rerun=*/true);
   size_t new_corpus_size = corpus_.NumActive();
-  CHECK_GE(new_corpus_size, initial_corpus_size);  // Corpus can't shrink here.
+  FUZZTEST_CHECK_GE(new_corpus_size,
+                    initial_corpus_size);  // Corpus can't shrink here.
   if (new_corpus_size > initial_corpus_size) {
     auto appender = DefaultBlobFileWriterFactory(env_.riegeli);
-    CHECK_OK(
+    FUZZTEST_CHECK_OK(
         appender->Open(wd_.CorpusFilePaths().Shard(env_.my_shard_index), "a"));
     for (size_t idx = initial_corpus_size; idx < new_corpus_size; ++idx) {
-      CHECK_OK(appender->Write(corpus_.Get(idx)));
+      FUZZTEST_CHECK_OK(appender->Write(corpus_.Get(idx)));
     }
-    LOG(INFO) << "Merge: " << (new_corpus_size - initial_corpus_size)
-              << " new inputs added";
+    FUZZTEST_LOG(INFO) << "Merge: " << (new_corpus_size - initial_corpus_size)
+                       << " new inputs added";
   }
 }
 
@@ -712,16 +716,16 @@
   // Save the distilled corpus to a file in workdir and possibly to a hashed
   // file in the first corpus dir passed in `--corpus_dir`.
   const auto distill_to_path = wd_.DistilledCorpusFilePaths().MyShard();
-  LOG(INFO) << "Distilling: shard: " << env_.my_shard_index
-            << " output: " << distill_to_path << " "
-            << " distilled size: " << corpus_.NumActive();
+  FUZZTEST_LOG(INFO) << "Distilling: shard: " << env_.my_shard_index
+                     << " output: " << distill_to_path << " "
+                     << " distilled size: " << corpus_.NumActive();
   const auto appender = DefaultBlobFileWriterFactory(env_.riegeli);
   // NOTE: Always overwrite distilled corpus files -- never append, unlike
   // "regular", per-shard corpus files.
-  CHECK_OK(appender->Open(distill_to_path, "w"));
+  FUZZTEST_CHECK_OK(appender->Open(distill_to_path, "w"));
   for (size_t i = 0; i < corpus_.NumActive(); ++i) {
     const ByteArray &input = corpus_.Get(i);
-    CHECK_OK(appender->Write(input));
+    FUZZTEST_CHECK_OK(appender->Write(input));
     if (!env_.corpus_dir.empty() && !env_.corpus_dir[0].empty()) {
       WriteToLocalHashedFileInDir(env_.corpus_dir[0], input);
     }
@@ -734,21 +738,22 @@
   const size_t num_seeds_available =
       user_callbacks_.GetSeeds(env_.batch_size, seed_inputs);
   if (num_seeds_available > env_.batch_size) {
-    LOG(WARNING) << "More seeds available than requested: "
-                 << num_seeds_available << " > " << env_.batch_size;
+    FUZZTEST_LOG(WARNING) << "More seeds available than requested: "
+                          << num_seeds_available << " > " << env_.batch_size;
   }
   if (seed_inputs.empty()) {
-    QCHECK(!env_.require_seeds)
+    FUZZTEST_QCHECK(!env_.require_seeds)
         << "No seeds returned and --require_seeds=true, exiting early.";
-    LOG(WARNING)
+    FUZZTEST_LOG(WARNING)
         << "No seeds returned - will use the default seed of single byte {0}";
     seed_inputs.push_back({0});
   }
 
   RunBatch(seed_inputs, corpus_file, features_file,
            /*unconditional_features_file=*/nullptr);
-  LOG(INFO) << "Number of input seeds available: " << num_seeds_available
-            << ", number included in corpus: " << corpus_.NumTotal();
+  FUZZTEST_LOG(INFO) << "Number of input seeds available: "
+                     << num_seeds_available
+                     << ", number included in corpus: " << corpus_.NumTotal();
 
   // Forcely add all seed inputs to avoid empty corpus if none of them increased
   // coverage and passed the filters.
@@ -759,9 +764,10 @@
 }
 
 void Centipede::FuzzingLoop() {
-  LOG(INFO) << "Shard: " << env_.my_shard_index << "/" << env_.total_shards
-            << " " << TemporaryLocalDirPath() << " "
-            << "seed: " << env_.seed << "\n\n\n";
+  FUZZTEST_LOG(INFO) << "Shard: " << env_.my_shard_index << "/"
+                     << env_.total_shards << " " << TemporaryLocalDirPath()
+                     << " "
+                     << "seed: " << env_.seed << "\n\n\n";
 
   UpdateAndMaybeLogStats("begin-fuzz", 0);
 
@@ -780,10 +786,10 @@
 
   auto corpus_path = wd_.CorpusFilePaths().Shard(env_.my_shard_index);
   auto corpus_file = DefaultBlobFileWriterFactory(env_.riegeli);
-  CHECK_OK(corpus_file->Open(corpus_path, "a"));
+  FUZZTEST_CHECK_OK(corpus_file->Open(corpus_path, "a"));
   auto features_path = wd_.FeaturesFilePaths().Shard(env_.my_shard_index);
   auto features_file = DefaultBlobFileWriterFactory(env_.riegeli);
-  CHECK_OK(features_file->Open(features_path, "a"));
+  FUZZTEST_CHECK_OK(features_file->Open(features_path, "a"));
 
   LoadSeedInputs(corpus_file.get(), features_file.get());
 
@@ -809,7 +815,7 @@
   size_t corpus_size_at_last_prune = corpus_.NumActive();
   for (size_t batch_index = 0; batch_index < number_of_batches; batch_index++) {
     if (ShouldStop()) break;
-    CHECK_LT(new_runs, env_.num_runs);
+    FUZZTEST_CHECK_LT(new_runs, env_.num_runs);
     auto remaining_runs = env_.num_runs - new_runs;
     auto batch_size = std::min(env_.batch_size, remaining_runs);
     std::vector<MutationInputRef> mutation_inputs;
@@ -846,7 +852,7 @@
       size_t rand = rng_() % (env_.total_shards - 1);
       size_t other_shard_index =
           (env_.my_shard_index + 1 + rand) % env_.total_shards;
-      CHECK_NE(other_shard_index, env_.my_shard_index);
+      FUZZTEST_CHECK_NE(other_shard_index, env_.my_shard_index);
       LoadShard(env_, other_shard_index, /*rerun=*/false);
     }
 
@@ -870,49 +876,49 @@
 void Centipede::ReportCrash(std::string_view binary,
                             const std::vector<ByteArray> &input_vec,
                             const BatchResult &batch_result) {
-  CHECK_EQ(input_vec.size(), batch_result.results().size());
+  FUZZTEST_CHECK_EQ(input_vec.size(), batch_result.results().size());
 
   const size_t suspect_input_idx = std::clamp<size_t>(
       batch_result.num_outputs_read(), 0, input_vec.size() - 1);
   auto log_execution_failure = [&](std::string_view log_prefix) {
-    LOG(INFO) << log_prefix << "Batch execution failed:"
-              << "\nBinary               : " << binary
-              << "\nExit code            : " << batch_result.exit_code()
-              << "\nFailure              : "
-              << batch_result.failure_description()
-              << "\nSignature            : "
-              << AsPrintableString(AsByteSpan(batch_result.failure_signature()),
-                                   /*max_len=*/32)
-              << "\nNumber of inputs     : " << input_vec.size()
-              << "\nNumber of inputs read: " << batch_result.num_outputs_read()
-              << (batch_result.IsSetupFailure()
-                      ? ""
-                      : absl::StrCat("\nSuspect input index  : ",
-                                     suspect_input_idx))
-              << "\nCrash log            :\n\n";
+    FUZZTEST_LOG(INFO)
+        << log_prefix << "Batch execution failed:"
+        << "\nBinary               : " << binary
+        << "\nExit code            : " << batch_result.exit_code()
+        << "\nFailure              : " << batch_result.failure_description()
+        << "\nSignature            : "
+        << AsPrintableString(AsByteSpan(batch_result.failure_signature()),
+                             /*max_len=*/32)
+        << "\nNumber of inputs     : " << input_vec.size()
+        << "\nNumber of inputs read: " << batch_result.num_outputs_read()
+        << (batch_result.IsSetupFailure()
+                ? ""
+                : absl::StrCat("\nSuspect input index  : ", suspect_input_idx))
+        << "\nCrash log            :\n\n";
     for (const auto &log_line :
          absl::StrSplit(absl::StripAsciiWhitespace(batch_result.log()), '\n')) {
-      LOG(INFO).NoPrefix() << "CRASH LOG: " << log_line;
+      FUZZTEST_LOG(INFO).NoPrefix() << "CRASH LOG: " << log_line;
     }
-    LOG(INFO).NoPrefix() << "\n";
+    FUZZTEST_LOG(INFO).NoPrefix() << "\n";
   };
 
   if (batch_result.IsIgnoredFailure()) {
-    LOG(INFO) << "Skip further processing of "
-              << batch_result.failure_description();
+    FUZZTEST_LOG(INFO) << "Skip further processing of "
+                       << batch_result.failure_description();
     return;
   }
 
   if (batch_result.IsSkippedTest()) {
     log_execution_failure("Skipped Test: ");
-    LOG(INFO) << "Requesting early stop due to skipped test.";
+    FUZZTEST_LOG(INFO) << "Requesting early stop due to skipped test.";
     RequestEarlyStop(EXIT_SUCCESS);
     return;
   }
 
   if (batch_result.IsSetupFailure()) {
     log_execution_failure("Test Setup Failure: ");
-    LOG(INFO) << "Requesting early stop due to setup failure in the test.";
+    FUZZTEST_LOG(INFO)
+        << "Requesting early stop due to setup failure in the test.";
     RequestEarlyStop(EXIT_FAILURE);
     return;
   }
@@ -927,14 +933,15 @@
       absl::StrCat("ReportCrash[", num_crashes_, "]: ");
   log_execution_failure(log_prefix);
 
-  LOG_IF(INFO, num_crashes_ == env_.max_num_crash_reports)
+  FUZZTEST_LOG_IF(INFO, num_crashes_ == env_.max_num_crash_reports)
       << log_prefix
       << "Reached --max_num_crash_reports: further reports will be suppressed";
 
   if (batch_result.failure_description() == kExecutionFailurePerBatchTimeout) {
-    LOG(INFO) << log_prefix
-              << "Failure applies to entire batch: not executing inputs "
-                 "one-by-one, trying to find the reproducer";
+    FUZZTEST_LOG(INFO)
+        << log_prefix
+        << "Failure applies to entire batch: not executing inputs "
+           "one-by-one, trying to find the reproducer";
     return;
   }
 
@@ -952,14 +959,15 @@
     // primed for a crash by the sequence of inputs that preceded the crasher.
     std::iota(input_idxs_to_try.begin() + 1, input_idxs_to_try.end(), 0);
   } else {
-    LOG(INFO)
+    FUZZTEST_LOG(INFO)
         << log_prefix
         << "Skip finding the reproducer from the inputs other than the suspect";
   }
 
   // Try inputs one-by-one in the determined order.
-  LOG(INFO) << log_prefix
-            << "Executing inputs one-by-one, trying to find the reproducer";
+  FUZZTEST_LOG(INFO)
+      << log_prefix
+      << "Executing inputs one-by-one, trying to find the reproducer";
   for (auto input_idx : input_idxs_to_try) {
     if (ShouldStop()) return;
     const auto &one_input = input_vec[input_idx];
@@ -967,38 +975,38 @@
     if (!user_callbacks_.Execute(binary, {one_input}, one_input_batch_result)) {
       auto hash = Hash(one_input);
       auto crash_dir = wd_.CrashReproducerDirPaths().MyShard();
-      CHECK_OK(RemoteMkdir(crash_dir));
+      FUZZTEST_CHECK_OK(RemoteMkdir(crash_dir));
       std::string input_file_path = std::filesystem::path(crash_dir) / hash;
       auto crash_metadata_dir = wd_.CrashMetadataDirPaths().MyShard();
-      CHECK_OK(RemoteMkdir(crash_metadata_dir));
+      FUZZTEST_CHECK_OK(RemoteMkdir(crash_metadata_dir));
       std::string crash_metadata_path_prefix =
           std::filesystem::path(crash_metadata_dir) / hash;
-      LOG(INFO) << log_prefix << "Detected crash-reproducing input:"
-                << "\nInput index    : " << input_idx << "\nInput bytes    : "
-                << AsPrintableString(one_input, /*max_len=*/32)
-                << "\nExit code      : " << one_input_batch_result.exit_code()
-                << "\nFailure        : "
-                << one_input_batch_result.failure_description()
-                << "\nSignature      : "
-                << AsPrintableString(
-                       AsByteSpan(one_input_batch_result.failure_signature()),
-                       /*max_len=*/32)
-                << "\nSaving input to: " << input_file_path
-                << "\nSaving crash"  //
-                << "\nmetadata to    : " << crash_metadata_path_prefix << ".*";
-      CHECK_OK(RemoteFileSetContents(input_file_path, one_input));
-      CHECK_OK(RemoteFileSetContents(
+      FUZZTEST_LOG(INFO)
+          << log_prefix << "Detected crash-reproducing input:"
+          << "\nInput index    : " << input_idx << "\nInput bytes    : "
+          << AsPrintableString(one_input, /*max_len=*/32)
+          << "\nExit code      : " << one_input_batch_result.exit_code()
+          << "\nFailure        : "
+          << one_input_batch_result.failure_description()
+          << "\nSignature      : "
+          << AsPrintableString(
+                 AsByteSpan(one_input_batch_result.failure_signature()),
+                 /*max_len=*/32)
+          << "\nSaving input to: " << input_file_path << "\nSaving crash"  //
+          << "\nmetadata to    : " << crash_metadata_path_prefix << ".*";
+      FUZZTEST_CHECK_OK(RemoteFileSetContents(input_file_path, one_input));
+      FUZZTEST_CHECK_OK(RemoteFileSetContents(
           absl::StrCat(crash_metadata_path_prefix, ".desc"),
           one_input_batch_result.failure_description()));
-      CHECK_OK(RemoteFileSetContents(
+      FUZZTEST_CHECK_OK(RemoteFileSetContents(
           absl::StrCat(crash_metadata_path_prefix, ".sig"),
           one_input_batch_result.failure_signature()));
       return;
     }
   }
 
-  LOG(INFO) << log_prefix
-            << "Crash was not observed when running inputs one-by-one";
+  FUZZTEST_LOG(INFO) << log_prefix
+                     << "Crash was not observed when running inputs one-by-one";
 
   // There will be cases when several inputs collectively cause a crash, but no
   // single input does. Handle this by writing out the inputs from the batch
@@ -1011,27 +1019,28 @@
   const auto &suspect_input = input_vec[suspect_input_idx];
   auto suspect_hash = Hash(suspect_input);
   auto crash_dir = wd_.CrashReproducerDirPaths().MyShard();
-  CHECK_OK(RemoteMkdir(crash_dir));
+  FUZZTEST_CHECK_OK(RemoteMkdir(crash_dir));
   std::string crashing_batch_name =
       absl::StrCat("crashing_batch-", suspect_hash);
   std::string save_dir = std::filesystem::path(crash_dir) / crashing_batch_name;
-  CHECK_OK(RemoteMkdir(save_dir));
-  LOG(INFO) << log_prefix << "Saving used inputs from batch to: " << save_dir;
+  FUZZTEST_CHECK_OK(RemoteMkdir(save_dir));
+  FUZZTEST_LOG(INFO) << log_prefix
+                     << "Saving used inputs from batch to: " << save_dir;
   for (int i = 0; i <= suspect_input_idx; ++i) {
     const auto &one_input = input_vec[i];
     auto hash = Hash(one_input);
     std::string file_path = std::filesystem::path(save_dir).append(
         absl::StrFormat("input-%010d-%s", i, hash));
-    CHECK_OK(RemoteFileSetContents(file_path, one_input));
+    FUZZTEST_CHECK_OK(RemoteFileSetContents(file_path, one_input));
   }
   auto crash_metadata_dir = wd_.CrashMetadataDirPaths().MyShard();
-  CHECK_OK(RemoteMkdir(crash_metadata_dir));
+  FUZZTEST_CHECK_OK(RemoteMkdir(crash_metadata_dir));
   std::string crash_metadata_file_path =
       std::filesystem::path(crash_metadata_dir) / crashing_batch_name;
-  LOG(INFO) << log_prefix
-            << "Saving crash metadata to: " << crash_metadata_file_path;
-  CHECK_OK(RemoteFileSetContents(crash_metadata_file_path,
-                                 batch_result.failure_description()));
+  FUZZTEST_LOG(INFO) << log_prefix << "Saving crash metadata to: "
+                     << crash_metadata_file_path;
+  FUZZTEST_CHECK_OK(RemoteFileSetContents(crash_metadata_file_path,
+                                          batch_result.failure_description()));
 }
 
 }  // namespace fuzztest::internal
diff --git a/centipede/centipede_callbacks.cc b/centipede/centipede_callbacks.cc
index 8a2ec0c..5b010b4 100644
--- a/centipede/centipede_callbacks.cc
+++ b/centipede/centipede_callbacks.cc
@@ -24,8 +24,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
@@ -81,17 +79,18 @@
   // Check the PC table.
   if (binary_info.pc_table.empty()) {
     if (env_.require_pc_table) {
-      LOG(ERROR) << "Could not get PC table; exiting (override with "
-                    "--require_pc_table=false)";
+      FUZZTEST_LOG(ERROR) << "Could not get PC table; exiting (override with "
+                             "--require_pc_table=false)";
       exit(EXIT_FAILURE);
     }
-    LOG(WARNING) << "Could not get PC table; CF table and debug symbols will "
-                    "not be used";
+    FUZZTEST_LOG(WARNING)
+        << "Could not get PC table; CF table and debug symbols will "
+           "not be used";
     return;
   }
   // Check CF table.
   if (binary_info.cf_table.empty()) {
-    LOG(WARNING)
+    FUZZTEST_LOG(WARNING)
         << "Could not get CF table; binary should be built with Clang 16 (or "
            "later) and with -fsanitize-coverage=control-flow flag";
   } else {
@@ -197,7 +196,7 @@
   size_t num_inputs_written = 0;
 
   if (env_.has_input_wildcards) {
-    CHECK_EQ(inputs.size(), 1);
+    FUZZTEST_CHECK_EQ(inputs.size(), 1);
     WriteToLocalFile(temp_input_file_path_, inputs[0]);
     num_inputs_written = 1;
   } else {
@@ -206,9 +205,9 @@
   }
 
   if (num_inputs_written != inputs.size()) {
-    LOG(INFO) << "Wrote " << num_inputs_written << "/" << inputs.size()
-              << " inputs; shmem_size_mb might be too small: "
-              << env_.shmem_size_mb;
+    FUZZTEST_LOG(INFO) << "Wrote " << num_inputs_written << "/" << inputs.size()
+                       << " inputs; shmem_size_mb might be too small: "
+                       << env_.shmem_size_mb;
   }
 
   // Run.
@@ -219,7 +218,7 @@
   // Get results.
   batch_result.exit_code() = retval;
   const bool read_success = batch_result.Read(outputs_blobseq_);
-  LOG_IF(ERROR, !read_success) << "Failed to read batch result!";
+  FUZZTEST_LOG_IF(ERROR, !read_success) << "Failed to read batch result!";
   outputs_blobseq_.ReleaseSharedMemory();  // Outputs are already consumed.
 
   // We may have fewer feature blobs than inputs if
@@ -231,10 +230,10 @@
   //   * Logged by the following code.
   if (retval == 0 && read_success &&
       batch_result.num_outputs_read() != num_inputs_written) {
-    LOG(INFO) << "Read " << batch_result.num_outputs_read() << "/"
-              << num_inputs_written
-              << " outputs; shmem_size_mb might be too small: "
-              << env_.shmem_size_mb;
+    FUZZTEST_LOG(INFO) << "Read " << batch_result.num_outputs_read() << "/"
+                       << num_inputs_written
+                       << " outputs; shmem_size_mb might be too small: "
+                       << env_.shmem_size_mb;
   }
 
   if (env_.print_runner_log) PrintExecutionLog();
@@ -256,7 +255,7 @@
     std::filesystem::remove(failure_description_path_);
     std::filesystem::remove(failure_signature_path_);
   }
-  VLOG(1) << __FUNCTION__ << " took " << (absl::Now() - start_time);
+  FUZZTEST_VLOG(1) << __FUNCTION__ << " took " << (absl::Now() - start_time);
   return retval;
 }
 
@@ -266,8 +265,8 @@
     std::vector<ByteArray> &seeds) {
   const auto output_dir = std::filesystem::path{temp_dir_} / "seed_inputs";
   std::error_code error;
-  CHECK(std::filesystem::create_directories(output_dir, error));
-  CHECK(!error);
+  FUZZTEST_CHECK(std::filesystem::create_directories(output_dir, error));
+  FUZZTEST_CHECK(!error);
 
   std::string centipede_runner_flags = absl::StrCat(
       "CENTIPEDE_RUNNER_FLAGS=:dump_seed_inputs:test=", env_.test_name,
@@ -286,7 +285,8 @@
   const int retval = cmd.Execute();
 
   if (env_.print_runner_log) {
-    LOG(INFO) << "Getting seeds via external binary returns " << retval;
+    FUZZTEST_LOG(INFO) << "Getting seeds via external binary returns "
+                       << retval;
     PrintExecutionLog();
   }
 
@@ -344,7 +344,7 @@
   }
   std::error_code error;
   std::filesystem::remove(config_file_path, error);
-  CHECK(!error);
+  FUZZTEST_CHECK(!error);
 
   return is_success;
 }
@@ -353,7 +353,7 @@
 MutationResult CentipedeCallbacks::MutateViaExternalBinary(
     std::string_view binary, const std::vector<MutationInputRef> &inputs,
     size_t num_mutants) {
-  CHECK(!env_.has_input_wildcards)
+  FUZZTEST_CHECK(!env_.has_input_wildcards)
       << "Standalone binary does not support custom mutator";
 
   auto start_time = absl::Now();
@@ -362,7 +362,7 @@
 
   size_t num_inputs_written =
       RequestMutation(num_mutants, inputs, inputs_blobseq_);
-  LOG_IF(INFO, num_inputs_written != inputs.size())
+  FUZZTEST_LOG_IF(INFO, num_inputs_written != inputs.size())
       << VV(num_inputs_written) << VV(inputs.size());
 
   // Execute.
@@ -371,7 +371,7 @@
   inputs_blobseq_.ReleaseSharedMemory();  // Inputs are already consumed.
 
   if (retval != EXIT_SUCCESS) {
-    LOG(WARNING) << "Custom mutator failed with exit code: " << retval;
+    FUZZTEST_LOG(WARNING) << "Custom mutator failed with exit code: " << retval;
   }
   if (env_.print_runner_log || retval != EXIT_SUCCESS) {
     PrintExecutionLog();
@@ -382,7 +382,7 @@
   result.Read(num_mutants, outputs_blobseq_);
   outputs_blobseq_.ReleaseSharedMemory();  // Outputs are already consumed.
 
-  VLOG(1) << __FUNCTION__ << " took " << (absl::Now() - start_time);
+  FUZZTEST_VLOG(1) << __FUNCTION__ << " took " << (absl::Now() - start_time);
   return result;
 }
 
@@ -398,43 +398,44 @@
     env_.use_legacy_default_mutator
         ? byte_array_mutator_.AddToDictionary(entries)
         : fuzztest_mutator_.AddToDictionary(entries);
-    LOG(INFO) << "Loaded " << entries.size()
-              << " dictionary entries from AFL/libFuzzer dictionary "
-              << dictionary_path;
+    FUZZTEST_LOG(INFO) << "Loaded " << entries.size()
+                       << " dictionary entries from AFL/libFuzzer dictionary "
+                       << dictionary_path;
     return entries.size();
   }
   // Didn't parse as plain text. Assume encoded corpus format.
   auto reader = DefaultBlobFileReaderFactory();
-  CHECK_OK(reader->Open(dictionary_path))
+  FUZZTEST_CHECK_OK(reader->Open(dictionary_path))
       << "Error in opening dictionary file: " << dictionary_path;
   std::vector<ByteArray> unpacked_dictionary;
   ByteSpan blob;
   while (reader->Read(blob).ok()) {
     unpacked_dictionary.emplace_back(blob.begin(), blob.end());
   }
-  CHECK_OK(reader->Close())
+  FUZZTEST_CHECK_OK(reader->Close())
       << "Error in closing dictionary file: " << dictionary_path;
-  CHECK(!unpacked_dictionary.empty())
+  FUZZTEST_CHECK(!unpacked_dictionary.empty())
       << "Empty or corrupt dictionary file: " << dictionary_path;
   env_.use_legacy_default_mutator
       ? byte_array_mutator_.AddToDictionary(unpacked_dictionary)
       : fuzztest_mutator_.AddToDictionary(unpacked_dictionary);
-  LOG(INFO) << "Loaded " << unpacked_dictionary.size()
-            << " dictionary entries from " << dictionary_path;
+  FUZZTEST_LOG(INFO) << "Loaded " << unpacked_dictionary.size()
+                     << " dictionary entries from " << dictionary_path;
   return unpacked_dictionary.size();
 }
 
 void CentipedeCallbacks::PrintExecutionLog() const {
   if (!std::filesystem::exists(execute_log_path_)) {
-    LOG(WARNING) << "Log file for the last executed binary does not exist: "
-                 << execute_log_path_;
+    FUZZTEST_LOG(WARNING)
+        << "Log file for the last executed binary does not exist: "
+        << execute_log_path_;
     return;
   }
   std::string log_text;
   ReadFromLocalFile(execute_log_path_, log_text);
   for (const auto &log_line :
        absl::StrSplit(absl::StripAsciiWhitespace(log_text), '\n')) {
-    LOG(INFO).NoPrefix() << "LOG: " << log_line;
+    FUZZTEST_LOG(INFO).NoPrefix() << "FUZZTEST_LOG: " << log_line;
   }
 }
 
diff --git a/centipede/centipede_callbacks.h b/centipede/centipede_callbacks.h
index 57b9aab..94d8ec5 100644
--- a/centipede/centipede_callbacks.h
+++ b/centipede/centipede_callbacks.h
@@ -22,7 +22,6 @@
 #include <vector>
 
 #include "absl/base/nullability.h"
-#include "absl/log/check.h"
 #include "absl/status/statusor.h"
 #include "./centipede/binary_info.h"
 #include "./centipede/byte_array_mutator.h"
@@ -54,9 +53,9 @@
         outputs_blobseq_(shmem_name2_.c_str(), env.shmem_size_mb << 20,
                          env.use_posix_shmem) {
     if (env.use_legacy_default_mutator)
-      CHECK(byte_array_mutator_.set_max_len(env.max_len));
+      FUZZTEST_CHECK(byte_array_mutator_.set_max_len(env.max_len));
     else
-      CHECK(fuzztest_mutator_.set_max_len(env.max_len));
+      FUZZTEST_CHECK(fuzztest_mutator_.set_max_len(env.max_len));
   }
   virtual ~CentipedeCallbacks() {}
 
diff --git a/centipede/centipede_default_callbacks.cc b/centipede/centipede_default_callbacks.cc
index 20b2efa..ee54c2a 100644
--- a/centipede/centipede_default_callbacks.cc
+++ b/centipede/centipede_default_callbacks.cc
@@ -21,8 +21,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "./centipede/centipede_callbacks.h"
@@ -42,7 +40,7 @@
   }
 
   if (env_.has_input_wildcards) {
-    LOG(INFO) << "Disabling custom mutator for standalone target";
+    FUZZTEST_LOG(INFO) << "Disabling custom mutator for standalone target";
     custom_mutator_is_usable_ = false;
   }
 }
@@ -85,29 +83,33 @@
       if (!custom_mutator_is_usable_.has_value()) {
         custom_mutator_is_usable_ = result.has_custom_mutator();
         if (*custom_mutator_is_usable_) {
-          LOG(INFO) << "Custom mutator detected; will use it.";
+          FUZZTEST_LOG(INFO) << "Custom mutator detected; will use it.";
         } else {
-          LOG(INFO) << "Custom mutator not detected; falling back to the "
-                       "built-in mutator.";
+          FUZZTEST_LOG(INFO)
+              << "Custom mutator not detected; falling back to the "
+                 "built-in mutator.";
         }
       }
       if (*custom_mutator_is_usable_) {
         // TODO(b/398261908): Exit with failure instead of crashing.
-        CHECK(result.has_custom_mutator())
+        FUZZTEST_CHECK(result.has_custom_mutator())
             << "Test binary no longer has a custom mutator, even though it was "
                "previously detected.";
         if (!result.mutants().empty()) return std::move(result).mutants();
-        LOG_FIRST_N(WARNING, 5) << "Custom mutator returned no mutants; will "
-                                   "generate some using the built-in mutator.";
+        FUZZTEST_LOG_FIRST_N(WARNING, 5)
+            << "Custom mutator returned no mutants; will "
+               "generate some using the built-in mutator.";
       }
     } else if (ShouldStop()) {
-      LOG(WARNING) << "Custom mutator failed, but ignored since the stop "
-                      "condition it met. Possibly what triggered the stop "
-                      "condition also interrupted the mutator.";
+      FUZZTEST_LOG(WARNING)
+          << "Custom mutator failed, but ignored since the stop "
+             "condition it met. Possibly what triggered the stop "
+             "condition also interrupted the mutator.";
       // Returning whatever mutants we got before the failure.
       return std::move(result).mutants();
     } else {
-      LOG(ERROR) << "Test binary failed when asked to mutate inputs - exiting.";
+      FUZZTEST_LOG(ERROR)
+          << "Test binary failed when asked to mutate inputs - exiting.";
       RequestEarlyStop(EXIT_FAILURE);
       return {};
     }
diff --git a/centipede/centipede_interface.cc b/centipede/centipede_interface.cc
index 77b7a2d..1e74b45 100644
--- a/centipede/centipede_interface.cc
+++ b/centipede/centipede_interface.cc
@@ -33,8 +33,6 @@
 #include "absl/base/optimization.h"
 #include "absl/cleanup/cleanup.h"
 #include "absl/container/flat_hash_set.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/ascii.h"
@@ -85,7 +83,7 @@
   sigact.sa_flags = SA_ONSTACK;
   sigact.sa_handler = [](int received_signum) {
     if (received_signum == SIGINT) {
-      LOG(INFO) << "Ctrl-C pressed: winding down";
+      FUZZTEST_LOG(INFO) << "Ctrl-C pressed: winding down";
       RequestEarlyStop(EXIT_FAILURE);
       return;
     }
@@ -102,11 +100,11 @@
   std::string tmpfile = std::filesystem::path(tmpdir).append("t");
 
   for (const auto &arg : env.args) {
-    LOG(INFO) << "Running '" << env.for_each_blob << "' on " << arg;
+    FUZZTEST_LOG(INFO) << "Running '" << env.for_each_blob << "' on " << arg;
     auto blob_reader = DefaultBlobFileReaderFactory();
     absl::Status open_status = blob_reader->Open(arg);
     if (!open_status.ok()) {
-      LOG(INFO) << "Failed to open " << arg << ": " << open_status;
+      FUZZTEST_LOG(INFO) << "Failed to open " << arg << ": " << open_status;
       return EXIT_FAILURE;
     }
     ByteSpan blob;
@@ -132,8 +130,8 @@
 // provided, analyzes differences. If there is one arg provided, reports the
 // function coverage. Returns EXIT_SUCCESS on success, EXIT_FAILURE otherwise.
 int Analyze(const Environment &env) {
-  LOG(INFO) << "Analyze " << absl::StrJoin(env.args, ",");
-  CHECK(!env.binary.empty()) << "--binary must be used";
+  FUZZTEST_LOG(INFO) << "Analyze " << absl::StrJoin(env.args, ",");
+  FUZZTEST_CHECK(!env.binary.empty()) << "--binary must be used";
   if (env.args.size() == 1) {
     const CoverageResults coverage_results =
         GetCoverage(env.binary_name, env.binary_hash, env.args[0]);
@@ -145,8 +143,9 @@
     AnalyzeCorporaToLog(env.binary_name, env.binary_hash, env.args[0],
                         env.args[1]);
   } else {
-    LOG(FATAL) << "for now, --analyze supports only 1 or 2 work dirs; got "
-               << env.args.size();
+    FUZZTEST_LOG(FATAL)
+        << "for now, --analyze supports only 1 or 2 work dirs; got "
+        << env.args.size();
   }
   return EXIT_SUCCESS;
 }
@@ -167,8 +166,8 @@
   }
   if (env.save_binary_info) {
     const std::string binary_info_dir = WorkDir{env}.BinaryInfoDirPath();
-    CHECK_OK(RemoteMkdir(binary_info_dir));
-    LOG(INFO) << "Serializing binary info to: " << binary_info_dir;
+    FUZZTEST_CHECK_OK(RemoteMkdir(binary_info_dir));
+    FUZZTEST_LOG(INFO) << "Serializing binary info to: " << binary_info_dir;
     binary_info.Write(binary_info_dir);
   }
   if (binary_info.uses_legacy_trace_pc_instrumentation) {
@@ -176,7 +175,7 @@
     SavePCTableToFile(binary_info.pc_table, pcs_file_path);
   }
   if (env.use_pcpair_features) {
-    CHECK(!binary_info.pc_table.empty())
+    FUZZTEST_CHECK(!binary_info.pc_table.empty())
         << "--use_pcpair_features requires non-empty pc_table";
   }
   return binary_info;
@@ -215,7 +214,7 @@
             return absl::Minutes(std::clamp(iteration, 0UL, 10UL));
           },
       });
-  if (!envs.front().experiment.empty() || ABSL_VLOG_IS_ON(1)) {
+  if (!envs.front().experiment.empty() || FUZZTEST_VLOG_IS_ON(1)) {
     stats_reporters.emplace_back(
         [logger = StatsLogger{stats_vec, envs}]() mutable {
           logger.ReportCurrStats();
@@ -303,7 +302,8 @@
 
   for (const std::string &crashing_input_file : crashing_input_files) {
     ByteArray crashing_input;
-    CHECK_OK(RemoteFileGetContents(crashing_input_file, crashing_input));
+    FUZZTEST_CHECK_OK(
+        RemoteFileGetContents(crashing_input_file, crashing_input));
     const bool is_reproducible = !scoped_callbacks.callbacks()->Execute(
         env.binary, {crashing_input}, batch_result);
     const bool is_duplicate =
@@ -311,9 +311,10 @@
         !remaining_crash_signatures.insert(batch_result.failure_signature())
              .second;
     if (!is_reproducible || batch_result.IsSetupFailure() || is_duplicate) {
-      CHECK_OK(RemotePathDelete(crashing_input_file, /*recursively=*/false));
+      FUZZTEST_CHECK_OK(
+          RemotePathDelete(crashing_input_file, /*recursively=*/false));
     } else {
-      CHECK_OK(RemotePathTouchExistingFile(crashing_input_file));
+      FUZZTEST_CHECK_OK(RemotePathTouchExistingFile(crashing_input_file));
     }
   }
   return remaining_crash_signatures;
@@ -334,7 +335,7 @@
     const std::filesystem::path crash_metadata_dir =
         workdir.CrashMetadataDirPaths().Shard(shard_idx);
 
-    CHECK_OK(RemoteMkdir(crashing_dir.c_str()));
+    FUZZTEST_CHECK_OK(RemoteMkdir(crashing_dir.c_str()));
     for (const std::string &crashing_input_file : new_crashing_input_files) {
       const std::string crashing_input_file_name =
           std::filesystem::path(crashing_input_file).filename();
@@ -344,15 +345,15 @@
       const absl::Status status =
           RemoteFileGetContents(crash_signature_path, new_crash_signature);
       if (!status.ok()) {
-        LOG(WARNING) << "Ignoring crashing input " << crashing_input_file_name
-                     << " due to failure to read the crash signature: "
-                     << status;
+        FUZZTEST_LOG(WARNING)
+            << "Ignoring crashing input " << crashing_input_file_name
+            << " due to failure to read the crash signature: " << status;
         continue;
       }
       const bool is_duplicate =
           !crash_signatures.insert(new_crash_signature).second;
       if (is_duplicate) continue;
-      CHECK_OK(
+      FUZZTEST_CHECK_OK(
           RemoteFileRename(crashing_input_file,
                            (crashing_dir / crashing_input_file_name).c_str()));
     }
@@ -401,12 +402,13 @@
 
 absl::Duration ReadFuzzingTime(std::string_view fuzzing_time_file) {
   std::string fuzzing_time_str;
-  CHECK_OK(RemoteFileGetContents(fuzzing_time_file, fuzzing_time_str));
+  FUZZTEST_CHECK_OK(RemoteFileGetContents(fuzzing_time_file, fuzzing_time_str));
   absl::Duration fuzzing_time;
   if (!absl::ParseDuration(absl::StripAsciiWhitespace(fuzzing_time_str),
                            &fuzzing_time)) {
-    LOG(WARNING) << "Failed to parse fuzzing time of a resuming fuzz test: '"
-                 << fuzzing_time_str << "'. Assuming no fuzzing time so far.";
+    FUZZTEST_LOG(WARNING)
+        << "Failed to parse fuzzing time of a resuming fuzz test: '"
+        << fuzzing_time_str << "'. Assuming no fuzzing time so far.";
     return absl::ZeroDuration();
   }
   return fuzzing_time;
@@ -418,7 +420,7 @@
             absl::Status status = RemoteFileSetContents(
                 fuzzing_time_file,
                 absl::FormatDuration(absl::Now() - start_time));
-            LOG_IF(WARNING, !status.ok())
+            FUZZTEST_LOG_IF(WARNING, !status.ok())
                 << "Failed to write fuzzing time: " << status;
           },
           PeriodicAction::ZeroDelayConstInterval(absl::Seconds(15))};
@@ -431,9 +433,10 @@
   env.UpdateWithTargetConfig(fuzztest_config);
 
   absl::Time start_time = absl::Now();
-  LOG(INFO) << "Starting the update of the corpus database for fuzz tests:"
-            << "\nBinary: " << env.binary
-            << "\nCorpus database: " << fuzztest_config.corpus_database;
+  FUZZTEST_LOG(INFO)
+      << "Starting the update of the corpus database for fuzz tests:"
+      << "\nBinary: " << env.binary
+      << "\nCorpus database: " << fuzztest_config.corpus_database;
 
   // Step 1: Preliminary set up of test sharding, binary info, etc.
   const auto [test_shard_index, total_test_shards] = SetUpTestSharding();
@@ -457,7 +460,7 @@
   }();
   std::vector<std::string> fuzz_tests_to_run;
   if (env.fuzztest_single_test_mode) {
-    CHECK(fuzztest_config.fuzz_tests_in_current_shard.size() == 1)
+    FUZZTEST_CHECK(fuzztest_config.fuzz_tests_in_current_shard.size() == 1)
         << "Must select exactly one fuzz test when running in the single test "
            "mode";
     fuzz_tests_to_run = fuzztest_config.fuzz_tests_in_current_shard;
@@ -468,10 +471,11 @@
       }
     }
   }
-  LOG(INFO) << "Fuzz tests to run:" << absl::StrJoin(fuzz_tests_to_run, ", ");
+  FUZZTEST_LOG(INFO) << "Fuzz tests to run:"
+                     << absl::StrJoin(fuzz_tests_to_run, ", ");
 
   const bool is_workdir_specified = !env.workdir.empty();
-  CHECK(!is_workdir_specified || env.fuzztest_single_test_mode);
+  FUZZTEST_CHECK(!is_workdir_specified || env.fuzztest_single_test_mode);
   // When env.workdir is empty, the full workdir paths will be formed by
   // appending the fuzz test names to the base workdir path. We use different
   // path when only replaying to avoid replaying an unfinished fuzzing sessions.
@@ -489,8 +493,8 @@
   BinaryInfo binary_info = PopulateBinaryInfoAndSavePCsIfNecessary(
       env, callbacks_factory, pcs_file_path);
 
-  LOG(INFO) << "Test shard index: " << test_shard_index
-            << " Total test shards: " << total_test_shards;
+  FUZZTEST_LOG(INFO) << "Test shard index: " << test_shard_index
+                     << " Total test shards: " << total_test_shards;
 
   // Step 2: Iterate over the fuzz tests and run them.
   const std::string binary = env.binary;
@@ -504,7 +508,7 @@
       const absl::Status has_enough_time = VerifyBazelHasEnoughTimeToRunTest(
           start_time, test_time_limit,
           /*executed_tests_in_shard=*/i, fuzztest_config.fuzz_tests.size());
-      CHECK_OK(has_enough_time)
+      FUZZTEST_CHECK_OK(has_enough_time)
           << "Not enough time for running the fuzz test "
           << fuzz_tests_to_run[i] << " for " << test_time_limit;
     }
@@ -521,39 +525,41 @@
       // Use the execution IDs to resume or skip tests.
       const bool execution_id_matched = [&] {
         if (!RemotePathExists(execution_id_path)) return false;
-        CHECK(!RemotePathIsDirectory(execution_id_path));
+        FUZZTEST_CHECK(!RemotePathIsDirectory(execution_id_path));
         std::string prev_execution_id;
-        CHECK_OK(RemoteFileGetContents(execution_id_path, prev_execution_id));
+        FUZZTEST_CHECK_OK(
+            RemoteFileGetContents(execution_id_path, prev_execution_id));
         return prev_execution_id == *fuzztest_config.execution_id;
       }();
       if (execution_id_matched) {
         // If execution IDs match but the previous coverage is missing, it means
         // the test was previously finished, and we skip running for the test.
         if (!RemotePathExists(WorkDir{env}.CoverageDirPath())) {
-          LOG(INFO) << "Skipping running the fuzz test "
-                    << fuzz_tests_to_run[i];
+          FUZZTEST_LOG(INFO)
+              << "Skipping running the fuzz test " << fuzz_tests_to_run[i];
           continue;
         }
         // If execution IDs match and the previous coverage exists, it means
         // the same workflow got interrupted when running the test. So we resume
         // the test.
         is_resuming = true;
-        LOG(INFO) << "Resuming running the fuzz test " << fuzz_tests_to_run[i];
+        FUZZTEST_LOG(INFO) << "Resuming running the fuzz test "
+                           << fuzz_tests_to_run[i];
       } else {
         // If the execution IDs mismatch, we start a new run.
         is_resuming = false;
-        LOG(INFO) << "Starting a new run of the fuzz test "
-                  << fuzz_tests_to_run[i];
+        FUZZTEST_LOG(INFO) << "Starting a new run of the fuzz test "
+                           << fuzz_tests_to_run[i];
       }
     }
     if (RemotePathExists(env.workdir) && !is_resuming) {
       // This could be a workdir from a failed run that used a different version
       // of the binary. We delete it so that we don't have to deal with
       // the assumptions under which it is safe to reuse an old workdir.
-      CHECK_OK(RemotePathDelete(env.workdir, /*recursively=*/true));
+      FUZZTEST_CHECK_OK(RemotePathDelete(env.workdir, /*recursively=*/true));
     }
     const WorkDir workdir{env};
-    CHECK_OK(RemoteMkdir(
+    FUZZTEST_CHECK_OK(RemoteMkdir(
         workdir.CoverageDirPath()));  // Implicitly creates the workdir
 
     // Updating execution ID must be after creating the coverage dir. Otherwise
@@ -561,13 +567,13 @@
     // attempt would skip this test.
     if (!is_workdir_specified && fuzztest_config.execution_id.has_value() &&
         !is_resuming) {
-      CHECK_OK(RemoteFileSetContents(execution_id_path,
-                                     *fuzztest_config.execution_id));
+      FUZZTEST_CHECK_OK(RemoteFileSetContents(execution_id_path,
+                                              *fuzztest_config.execution_id));
     }
 
     absl::Cleanup clean_up_workdir = [is_workdir_specified, &env] {
       if (!is_workdir_specified && !EarlyStopRequested()) {
-        CHECK_OK(RemotePathDelete(env.workdir, /*recursively=*/true));
+        FUZZTEST_CHECK_OK(RemotePathDelete(env.workdir, /*recursively=*/true));
       }
     };
 
@@ -580,7 +586,7 @@
     // Seed the fuzzing session with the latest coverage corpus and regression
     // inputs from the previous fuzzing session.
     if (!is_resuming) {
-      CHECK_OK(GenerateSeedCorpusFromConfig(
+      FUZZTEST_CHECK_OK(GenerateSeedCorpusFromConfig(
           GetSeedCorpusConfig(env, regression_dir.c_str(),
                               fuzztest_config.replay_coverage_inputs
                                   ? coverage_dir.c_str()
@@ -612,14 +618,15 @@
     is_resuming = false;
 
     if (EarlyStopRequested()) {
-      LOG(INFO) << "Skipping test " << fuzz_tests_to_run[i]
-                << " because early stop requested.";
+      FUZZTEST_LOG(INFO) << "Skipping test " << fuzz_tests_to_run[i]
+                         << " because early stop requested.";
       continue;
     }
 
-    LOG(INFO) << (fuzztest_config.only_replay ? "Replaying " : "Fuzzing ")
-              << fuzz_tests_to_run[i] << " for " << time_limit
-              << "\n\tTest binary: " << env.binary;
+    FUZZTEST_LOG(INFO) << (fuzztest_config.only_replay ? "Replaying "
+                                                       : "Fuzzing ")
+                       << fuzz_tests_to_run[i] << " for " << time_limit
+                       << "\n\tTest binary: " << env.binary;
 
     const absl::Time start_time = absl::Now();
     ClearEarlyStopRequestAndSetStopTime(/*stop_time=*/start_time + time_limit);
@@ -631,15 +638,16 @@
 
     if (!stats_root_path.empty()) {
       const auto stats_dir = stats_root_path / fuzz_tests_to_run[i];
-      CHECK_OK(RemoteMkdir(stats_dir.c_str()));
-      CHECK_OK(RemoteFileRename(
+      FUZZTEST_CHECK_OK(RemoteMkdir(stats_dir.c_str()));
+      FUZZTEST_CHECK_OK(RemoteFileRename(
           workdir.FuzzingStatsPath(),
           (stats_dir / absl::StrCat("fuzzing_stats_", execution_stamp))
               .c_str()));
     }
 
     if (EarlyStopRequested()) {
-      LOG(INFO) << "Skip updating corpus database due to early stop requested.";
+      FUZZTEST_LOG(INFO)
+          << "Skip updating corpus database due to early stop requested.";
       continue;
     }
 
@@ -652,16 +660,18 @@
     if (RemotePathExists(coverage_dir.c_str())) {
       // In the future, we will store k latest coverage corpora for some k, but
       // for now we only keep the latest one.
-      CHECK_OK(RemotePathDelete(coverage_dir.c_str(), /*recursively=*/true));
+      FUZZTEST_CHECK_OK(
+          RemotePathDelete(coverage_dir.c_str(), /*recursively=*/true));
     }
-    CHECK_OK(RemoteMkdir(coverage_dir.c_str()));
+    FUZZTEST_CHECK_OK(RemoteMkdir(coverage_dir.c_str()));
     std::vector<std::string> distilled_corpus_files;
-    CHECK_OK(RemoteGlobMatch(workdir.DistilledCorpusFilePaths().AllShardsGlob(),
-                             distilled_corpus_files));
+    FUZZTEST_CHECK_OK(
+        RemoteGlobMatch(workdir.DistilledCorpusFilePaths().AllShardsGlob(),
+                        distilled_corpus_files));
     for (const std::string &corpus_file : distilled_corpus_files) {
       const std::string file_name =
           std::filesystem::path(corpus_file).filename();
-      CHECK_OK(
+      FUZZTEST_CHECK_OK(
           RemoteFileRename(corpus_file, (coverage_dir / file_name).c_str()));
     }
 
@@ -679,9 +689,9 @@
 
 int ListCrashIds(const Environment &env,
                  const fuzztest::internal::Configuration &target_config) {
-  CHECK(!env.list_crash_ids_file.empty())
+  FUZZTEST_CHECK(!env.list_crash_ids_file.empty())
       << "Need list_crash_ids_file to be set for listing crash IDs";
-  CHECK_EQ(target_config.fuzz_tests_in_current_shard.size(), 1);
+  FUZZTEST_CHECK_EQ(target_config.fuzz_tests_in_current_shard.size(), 1);
   std::vector<std::string> crash_paths;
   // TODO: b/406003594 - move the path construction to a library.
   const auto crash_dir = std::filesystem::path(target_config.corpus_database) /
@@ -689,7 +699,7 @@
                          target_config.fuzz_tests_in_current_shard[0] /
                          "crashing";
   if (RemotePathExists(crash_dir.string())) {
-    CHECK(RemotePathIsDirectory(crash_dir.string()))
+    FUZZTEST_CHECK(RemotePathIsDirectory(crash_dir.string()))
         << "Crash dir " << crash_dir << " in the corpus database "
         << target_config.corpus_database << " is not a directory";
     crash_paths =
@@ -701,16 +711,17 @@
     std::string crash_id = std::filesystem::path{crash_path}.filename();
     results.push_back(std::move(crash_id));
   }
-  CHECK_OK(RemoteFileSetContents(env.list_crash_ids_file,
-                                 absl::StrJoin(results, "\n")));
+  FUZZTEST_CHECK_OK(RemoteFileSetContents(env.list_crash_ids_file,
+                                          absl::StrJoin(results, "\n")));
   return EXIT_SUCCESS;
 }
 
 int ReplayCrash(const Environment &env,
                 const fuzztest::internal::Configuration &target_config,
                 CentipedeCallbacksFactory &callbacks_factory) {
-  CHECK(!env.crash_id.empty()) << "Need crash_id to be set for replay a crash";
-  CHECK(target_config.fuzz_tests_in_current_shard.size() == 1)
+  FUZZTEST_CHECK(!env.crash_id.empty())
+      << "Need crash_id to be set for replay a crash";
+  FUZZTEST_CHECK(target_config.fuzz_tests_in_current_shard.size() == 1)
       << "Expecting exactly one test for replay_crash";
   // TODO: b/406003594 - move the path construction to a library.
   const auto crash_dir = std::filesystem::path(target_config.corpus_database) /
@@ -732,8 +743,8 @@
               .filename(),
           /*shard_index_digits=*/WorkDir::kDigitsInShardIndex,
           /*num_shards=*/1}};
-  CHECK_OK(GenerateSeedCorpusFromConfig(crash_corpus_config, env.binary_name,
-                                        env.binary_hash));
+  FUZZTEST_CHECK_OK(GenerateSeedCorpusFromConfig(
+      crash_corpus_config, env.binary_name, env.binary_hash));
   Environment run_crash_env = env;
   run_crash_env.load_shards_only = true;
   return Fuzz(run_crash_env, {}, "", callbacks_factory);
@@ -741,11 +752,11 @@
 
 int ExportCrash(const Environment &env,
                 const fuzztest::internal::Configuration &target_config) {
-  CHECK(!env.crash_id.empty())
+  FUZZTEST_CHECK(!env.crash_id.empty())
       << "Need crash_id to be set for exporting a crash";
-  CHECK(!env.export_crash_file.empty())
+  FUZZTEST_CHECK(!env.export_crash_file.empty())
       << "Need export_crash_file to be set for exporting a crash";
-  CHECK(target_config.fuzz_tests_in_current_shard.size() == 1)
+  FUZZTEST_CHECK(target_config.fuzz_tests_in_current_shard.size() == 1)
       << "Expecting exactly one test for exporting a crash";
   // TODO: b/406003594 - move the path construction to a library.
   const auto crash_dir = std::filesystem::path(target_config.corpus_database) /
@@ -756,15 +767,15 @@
   const auto read_status =
       RemoteFileGetContents((crash_dir / env.crash_id).c_str(), crash_contents);
   if (!read_status.ok()) {
-    LOG(ERROR) << "Failed reading the crash " << env.crash_id << " from "
-               << crash_dir.c_str() << ": " << read_status;
+    FUZZTEST_LOG(ERROR) << "Failed reading the crash " << env.crash_id
+                        << " from " << crash_dir.c_str() << ": " << read_status;
     return EXIT_FAILURE;
   }
   const auto write_status =
       RemoteFileSetContents(env.export_crash_file, crash_contents);
   if (!write_status.ok()) {
-    LOG(ERROR) << "Failed write the crash " << env.crash_id << " to "
-               << env.export_crash_file << ": " << write_status;
+    FUZZTEST_LOG(ERROR) << "Failed write the crash " << env.crash_id << " to "
+                        << env.export_crash_file << ": " << write_status;
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
@@ -785,7 +796,8 @@
   if (!env.crashes_to_files.empty()) {
     const auto status = Centipede::CrashesToFiles(env, env.crashes_to_files);
     if (status.ok()) return EXIT_SUCCESS;
-    LOG(ERROR) << "Got error when exporting crashes to files: " << status;
+    FUZZTEST_LOG(ERROR) << "Got error when exporting crashes to files: "
+                        << status;
     return EXIT_FAILURE;
   }
 
@@ -830,21 +842,22 @@
       // to the unified execution model.
       if (!env.fuzztest_configuration.empty()) {
         std::string result;
-        CHECK(absl::WebSafeBase64Unescape(env.fuzztest_configuration, &result));
+        FUZZTEST_CHECK(
+            absl::WebSafeBase64Unescape(env.fuzztest_configuration, &result));
         return result;
       }
       ScopedCentipedeCallbacks scoped_callbacks(callbacks_factory, env);
       return scoped_callbacks.callbacks()->GetSerializedTargetConfig();
     }();
-    CHECK_OK(serialized_target_config.status());
+    FUZZTEST_CHECK_OK(serialized_target_config.status());
     if (!serialized_target_config->empty()) {
       const auto target_config = fuzztest::internal::Configuration::Deserialize(
           *serialized_target_config);
-      CHECK_OK(target_config.status())
+      FUZZTEST_CHECK_OK(target_config.status())
           << "Failed to deserialize target configuration";
       if (!target_config->corpus_database.empty()) {
-        LOG_IF(FATAL,
-               env.list_crash_ids + env.replay_crash + env.export_crash > 1)
+        FUZZTEST_LOG_IF(
+            FATAL, env.list_crash_ids + env.replay_crash + env.export_crash > 1)
             << "At most one of list_crash_ids/replay_crash/export_crash can "
                "be set, but seeing list_crash_ids: "
             << env.list_crash_ids << ", replay_crash: " << env.replay_crash
@@ -860,11 +873,11 @@
         }
 
         const auto time_limit_per_test = target_config->GetTimeLimitPerTest();
-        CHECK(target_config->only_replay ||
-              time_limit_per_test < absl::InfiniteDuration())
+        FUZZTEST_CHECK(target_config->only_replay ||
+                       time_limit_per_test < absl::InfiniteDuration())
             << "Updating corpus database requires specifying time limit per "
                "fuzz test.";
-        CHECK(time_limit_per_test >= absl::Seconds(1))
+        FUZZTEST_CHECK(time_limit_per_test >= absl::Seconds(1))
             << "Time limit per fuzz test must be at least 1 second.";
         return UpdateCorpusDatabaseForFuzzTests(env, *target_config,
                                                 callbacks_factory);
@@ -874,9 +887,9 @@
 
   // Create the remote coverage dirs once, before creating any threads.
   const auto coverage_dir = WorkDir{env}.CoverageDirPath();
-  CHECK_OK(RemoteMkdir(coverage_dir));
-  LOG(INFO) << "Coverage dir: " << coverage_dir
-            << "; temporary dir: " << tmpdir;
+  FUZZTEST_CHECK_OK(RemoteMkdir(coverage_dir));
+  FUZZTEST_LOG(INFO) << "Coverage dir: " << coverage_dir
+                     << "; temporary dir: " << tmpdir;
 
   std::string pcs_file_path;
   BinaryInfo binary_info = PopulateBinaryInfoAndSavePCsIfNecessary(
diff --git a/centipede/centipede_test.cc b/centipede/centipede_test.cc
index c66e7ab..b048e6e 100644
--- a/centipede/centipede_test.cc
+++ b/centipede/centipede_test.cc
@@ -31,8 +31,6 @@
 #include "gtest/gtest.h"
 #include "absl/base/nullability.h"
 #include "absl/container/flat_hash_set.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/time/time.h"
 #include "./centipede/centipede_callbacks.h"
@@ -360,14 +358,14 @@
   // Will not be called.
   bool Execute(std::string_view binary, const std::vector<ByteArray> &inputs,
                BatchResult &batch_result) override {
-    CHECK(false);
+    FUZZTEST_CHECK(false);
     return false;
   }
 
   // Will not be called.
   std::vector<ByteArray> Mutate(const std::vector<MutationInputRef> &inputs,
                                 size_t num_mutants) override {
-    CHECK(false);
+    FUZZTEST_CHECK(false);
   }
 
   // Redeclare a protected member function as public so the tests can call it.
@@ -505,7 +503,7 @@
                BatchResult &batch_result) override {
     batch_result.results().resize(inputs.size());
     for (size_t i = 0, n = inputs.size(); i < n; ++i) {
-      CHECK_EQ(inputs[i].size(), 1);
+      FUZZTEST_CHECK_EQ(inputs[i].size(), 1);
       batch_result.results()[i].mutable_features() = {inputs[i][0]};
     }
     return true;
@@ -582,8 +580,10 @@
       : CentipedeCallbacks(env) {
     std::vector<ByteArray> seed_inputs;
     const size_t num_seeds_available = GetSeeds(/*num_seeds=*/1, seed_inputs);
-    CHECK_EQ(num_seeds_available, 1) << "Default seeds must have size one.";
-    CHECK_EQ(seed_inputs.size(), 1) << "Default seeds must have size one.";
+    FUZZTEST_CHECK_EQ(num_seeds_available, 1)
+        << "Default seeds must have size one.";
+    FUZZTEST_CHECK_EQ(seed_inputs.size(), 1)
+        << "Default seeds must have size one.";
     seed_inputs_.insert(seed_inputs.begin(), seed_inputs.end());
   }
 
@@ -646,7 +646,7 @@
   FunctionFilterMock mock(env);
   MockFactory factory(mock);
   CentipedeMain(env, factory);
-  LOG(INFO) << mock.observed_inputs_.size();
+  FUZZTEST_LOG(INFO) << mock.observed_inputs_.size();
   std::vector<ByteArray> res(mock.observed_inputs_.begin(),
                              mock.observed_inputs_.end());
   std::sort(res.begin(), res.end());
@@ -808,7 +808,7 @@
   explicit UndetectedCrashingInputMock(const Environment &env,
                                        size_t crashing_input_idx)
       : CentipedeCallbacks{env}, crashing_input_idx_{crashing_input_idx} {
-    CHECK_LE(crashing_input_idx_, std::numeric_limits<uint8_t>::max());
+    FUZZTEST_CHECK_LE(crashing_input_idx_, std::numeric_limits<uint8_t>::max());
   }
 
   // Doesn't execute anything.
@@ -822,7 +822,7 @@
       num_inputs_triaged_ += inputs.size();
     }
     for (const auto &input : inputs) {
-      CHECK_EQ(input.size(), 1);  // By construction in `Mutate()`.
+      FUZZTEST_CHECK_EQ(input.size(), 1);  // By construction in `Mutate()`.
       // The contents of each mutant is its sequential number.
       if (input[0] == crashing_input_idx_) {
         if (first_pass_) {
@@ -881,8 +881,8 @@
   constexpr size_t kCrashingInputIdx =
       (kNumBatches / 2) * kBatchSize + kCrashingInputIdxInBatch;
 
-  LOG(INFO) << VV(kNumBatches) << VV(kBatchSize)
-            << VV(kCrashingInputIdxInBatch) VV(kCrashingInputIdx);
+  FUZZTEST_LOG(INFO) << VV(kNumBatches) << VV(kBatchSize)
+                     << VV(kCrashingInputIdxInBatch) VV(kCrashingInputIdx);
 
   TempDir temp_dir{test_info_->name()};
   Environment env;
diff --git a/centipede/command.cc b/centipede/command.cc
index d533bde..c5d7fd8 100644
--- a/centipede/command.cc
+++ b/centipede/command.cc
@@ -37,8 +37,6 @@
 #include <vector>
 
 #include "absl/base/const_init.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
@@ -125,13 +123,14 @@
   ~ForkServerProps() {
     for (int i = 0; i < 2; ++i) {
       if (pipe_[i] >= 0 && close(pipe_[i]) != 0) {
-        LOG(ERROR) << "Failed to close fork server pipe for " << fifo_path_[i];
+        FUZZTEST_LOG(ERROR)
+            << "Failed to close fork server pipe for " << fifo_path_[i];
       }
       std::error_code ec;
       if (!fifo_path_[i].empty() &&
           !std::filesystem::remove(fifo_path_[i], ec)) {
-        LOG(ERROR) << "Failed to remove fork server pipe file " << fifo_path_[i]
-                   << ": " << ec;
+        FUZZTEST_LOG(ERROR) << "Failed to remove fork server pipe file "
+                            << fifo_path_[i] << ": " << ec;
       }
     }
   }
@@ -171,7 +170,7 @@
   // Replace @@ with temp_file_path_.
   constexpr std::string_view kTempFileWildCard = "@@";
   if (absl::StrContains(path, kTempFileWildCard)) {
-    CHECK(!options_.temp_file_path.empty());
+    FUZZTEST_CHECK(!options_.temp_file_path.empty());
     path = absl::StrReplaceAll(path,
                                {{kTempFileWildCard, options_.temp_file_path}});
   }
@@ -198,10 +197,10 @@
 bool Command::StartForkServer(std::string_view temp_dir_path,
                               std::string_view prefix) {
   if (absl::StartsWith(path_, kNoForkServerRequestPrefix)) {
-    VLOG(2) << "Fork server disabled for " << path();
+    FUZZTEST_VLOG(2) << "Fork server disabled for " << path();
     return false;
   }
-  VLOG(2) << "Starting fork server for " << path();
+  FUZZTEST_VLOG(2) << "Starting fork server for " << path();
 
   fork_server_.reset(new ForkServerProps);
   fork_server_->fifo_path_[0] = std::filesystem::path(temp_dir_path)
@@ -212,7 +211,7 @@
       std::filesystem::path(temp_dir_path).append("pid");
   (void)std::filesystem::create_directory(temp_dir_path);  // it may not exist.
   for (int i = 0; i < 2; ++i) {
-    PCHECK(mkfifo(fork_server_->fifo_path_[i].c_str(), 0600) == 0)
+    FUZZTEST_PCHECK(mkfifo(fork_server_->fifo_path_[i].c_str(), 0600) == 0)
         << VV(i) << VV(fork_server_->fifo_path_[i]);
   }
 
@@ -231,7 +230,7 @@
   const std::string fork_server_command = absl::StrFormat(
       kForkServerCommandStub, fork_server_->fifo_path_[0],
       fork_server_->fifo_path_[1], command_line_, pid_file_path);
-  VLOG(2) << "Fork server command:" << fork_server_command;
+  FUZZTEST_VLOG(2) << "Fork server command:" << fork_server_command;
 
   const int exit_code = system(fork_server_command.c_str());
 
@@ -267,7 +266,7 @@
 
   std::string pid_str;
   ReadFromLocalFile(pid_file_path, pid_str);
-  CHECK(absl::SimpleAtoi(pid_str, &fork_server_->pid_)) << VV(pid_str);
+  FUZZTEST_CHECK(absl::SimpleAtoi(pid_str, &fork_server_->pid_)) << VV(pid_str);
   auto creation_stamp = GetProcessCreationStamp(fork_server_->pid_);
   if (!creation_stamp.ok()) {
     LogProblemInfo(
@@ -285,9 +284,10 @@
   // Preconditions: the callers (`Execute()`) should call us only when the fork
   // server is presumed to be running (`fork_server_pid_` >= 0). If it is, the
   // comms pipes are guaranteed to be opened by `StartForkServer()`.
-  CHECK(fork_server_ != nullptr) << "Fork server wasn't started";
-  CHECK(fork_server_->pid_ >= 0) << "Fork server process failed to start";
-  CHECK(fork_server_->pipe_[0] >= 0 && fork_server_->pipe_[1] >= 0)
+  FUZZTEST_CHECK(fork_server_ != nullptr) << "Fork server wasn't started";
+  FUZZTEST_CHECK(fork_server_->pid_ >= 0)
+      << "Fork server process failed to start";
+  FUZZTEST_CHECK(fork_server_->pipe_[0] >= 0 && fork_server_->pipe_[1] >= 0)
       << "Failed to connect to fork server";
 
   // A process with the fork server PID exists (_some_ process, possibly with a
@@ -309,13 +309,13 @@
 }
 
 int Command::Execute() {
-  VLOG(1) << "Executing command '" << command_line_ << "'...";
+  FUZZTEST_VLOG(1) << "Executing command '" << command_line_ << "'...";
 
   int exit_code = EXIT_SUCCESS;
 
   if (fork_server_ != nullptr) {
-    VLOG(1) << "Sending execution request to fork server: "
-            << VV(options_.timeout);
+    FUZZTEST_VLOG(1) << "Sending execution request to fork server: "
+                     << VV(options_.timeout);
 
     if (const auto status = VerifyForkServerIsHealthy(); !status.ok()) {
       LogProblemInfo(absl::StrCat("Fork server should be running, but isn't: ",
@@ -325,7 +325,7 @@
 
     // Wake up the fork server.
     char x = ' ';
-    CHECK_EQ(1, write(fork_server_->pipe_[0], &x, 1));
+    FUZZTEST_CHECK_EQ(1, write(fork_server_->pipe_[0], &x, 1));
 
     // The fork server forks, the child is running. Block until some readable
     // data appears in the pipe (that is, after the fork server writes the
@@ -361,10 +361,10 @@
     }
 
     // The fork server wrote the execution result to the pipe: read it.
-    CHECK_EQ(sizeof(exit_code),
-             read(fork_server_->pipe_[1], &exit_code, sizeof(exit_code)));
+    FUZZTEST_CHECK_EQ(sizeof(exit_code), read(fork_server_->pipe_[1],
+                                              &exit_code, sizeof(exit_code)));
   } else {
-    VLOG(1) << "Fork server disabled - executing command directly";
+    FUZZTEST_VLOG(1) << "Fork server disabled - executing command directly";
     // No fork server, use system().
     exit_code = system(command_line_.c_str());
   }
@@ -454,21 +454,21 @@
   static absl::Mutex mu{absl::kConstInit};
   absl::MutexLock lock(&mu);
 
-  LOG(ERROR) << message;
-  LOG(ERROR).NoPrefix() << "=== COMMAND ===";
-  LOG(ERROR).NoPrefix() << command_line_;
-  LOG(ERROR).NoPrefix() << "=== STDOUT ===";
+  FUZZTEST_LOG(ERROR) << message;
+  FUZZTEST_LOG(ERROR).NoPrefix() << "=== COMMAND ===";
+  FUZZTEST_LOG(ERROR).NoPrefix() << command_line_;
+  FUZZTEST_LOG(ERROR).NoPrefix() << "=== STDOUT ===";
   for (const auto &line : absl::StrSplit(ReadRedirectedStdout(), '\n')) {
-    LOG(ERROR).NoPrefix() << line;
+    FUZZTEST_LOG(ERROR).NoPrefix() << line;
   }
-  LOG(ERROR).NoPrefix() << "=== STDERR ===";
+  FUZZTEST_LOG(ERROR).NoPrefix() << "=== STDERR ===";
   for (const auto &line : absl::StrSplit(ReadRedirectedStderr(), '\n')) {
-    LOG(ERROR).NoPrefix() << line;
+    FUZZTEST_LOG(ERROR).NoPrefix() << line;
   }
 }
 
 void Command::VlogProblemInfo(std::string_view message, int vlog_level) const {
-  if (ABSL_VLOG_IS_ON(vlog_level)) LogProblemInfo(message);
+  if (FUZZTEST_VLOG_IS_ON(vlog_level)) LogProblemInfo(message);
 }
 
 }  // namespace fuzztest::internal
diff --git a/centipede/command.h b/centipede/command.h
index 80c7877..66095a6 100644
--- a/centipede/command.h
+++ b/centipede/command.h
@@ -101,8 +101,8 @@
   // by the the command line, followed by the redirected stdout and stderr read
   // from `options_.out` and `options_.err` files, if any.
   void LogProblemInfo(std::string_view message) const;
-  // Just as `LogCrashInfo()`, but logging occurs only when the VLOG level (set
-  // via `--v` or its equivalents) is >= `min_vlog`.
+  // Just as `LogCrashInfo()`, but logging occurs only when the FUZZTEST_VLOG
+  // level (set via `--v` or its equivalents) is >= `min_vlog`.
   void VlogProblemInfo(std::string_view message, int vlog_level) const;
 
   const std::string path_;
diff --git a/centipede/command_test.cc b/centipede/command_test.cc
index 3129a41..bd75068 100644
--- a/centipede/command_test.cc
+++ b/centipede/command_test.cc
@@ -24,11 +24,11 @@
 #include <utility>
 
 #include "gtest/gtest.h"
-#include "absl/log/log.h"
 #include "absl/strings/substitute.h"
 #include "absl/time/time.h"
 #include "./centipede/stop.h"
 #include "./centipede/util.h"
+#include "./common/logging.h"
 #include "./common/test_util.h"
 
 namespace fuzztest::internal {
@@ -96,7 +96,7 @@
     Command self_sigint{"bash -c 'kill -SIGINT $$'"};
     self_sigint.Execute();
     if (ShouldStop()) {
-      LOG(INFO) << "Early stop requested";
+      FUZZTEST_LOG(INFO) << "Early stop requested";
       exit(ExitCode());
     }
   };
diff --git a/centipede/concurrent_bitset.h b/centipede/concurrent_bitset.h
index 09d1aa1..2e38d79 100644
--- a/centipede/concurrent_bitset.h
+++ b/centipede/concurrent_bitset.h
@@ -22,7 +22,7 @@
 //
 // This library must not depend on anything other than libc so that fuzz targets
 // using it doesn't gain redundant coverage. For the same reason this library
-// uses raw __builtin_trap instead of CHECKs.
+// uses raw __builtin_trap instead of FUZZTEST_CHECKs.
 // We make an exception for <algorithm> for std::sort/std::unique,
 // since <algorithm> is very lightweight.
 // This library is also header-only, with all functions defined as inline.
diff --git a/centipede/config_file.cc b/centipede/config_file.cc
index 2b288f1..89c0613 100644
--- a/centipede/config_file.cc
+++ b/centipede/config_file.cc
@@ -29,8 +29,6 @@
 #include "absl/flags/flag.h"
 #include "absl/flags/parse.h"
 #include "absl/flags/reflection.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
@@ -116,7 +114,9 @@
     const std::string& new_arg = argv_.emplace_back(
         absl::StrReplaceAll(flag_replaced_arg.value_or(old_arg), replacements));
     if (new_arg != old_arg) {
-      VLOG(1) << "Augmented argv arg:\n" << VV(old_arg) << "\n" << VV(new_arg);
+      FUZZTEST_VLOG(1) << "Augmented argv arg:\n"
+                       << VV(old_arg) << "\n"
+                       << VV(new_arg);
       was_augmented_ = true;
     }
   }
@@ -147,7 +147,7 @@
   const std::filesystem::path path = absl::GetFlag(FLAGS_config);
 
   if (!path.empty()) {
-    CHECK_NE(path, absl::GetFlag(FLAGS_save_config))
+    FUZZTEST_CHECK_NE(path, absl::GetFlag(FLAGS_save_config))
         << "To update config in place, use " << DASHED_FLAG_NAME(update_config);
   }
 
@@ -162,15 +162,16 @@
   if (!path.empty() && !std::filesystem::exists(path)) {  // assume remote
     // Read the remote file.
     std::string contents;
-    CHECK_OK(RemoteFileGetContents(path.c_str(), contents));
+    FUZZTEST_CHECK_OK(RemoteFileGetContents(path.c_str(), contents));
 
     // Save a temporary local copy.
     const std::filesystem::path tmp_dir = TemporaryLocalDirPath();
     const std::filesystem::path local_path = tmp_dir / path.filename();
-    LOG(INFO) << "Localizing remote config: " << VV(path) << VV(local_path);
+    FUZZTEST_LOG(INFO) << "Localizing remote config: " << VV(path)
+                       << VV(local_path);
     // NOTE: Ignore "Remote" in the API names here: the paths are always local.
-    CHECK_OK(RemoteMkdir(tmp_dir.c_str()));
-    CHECK_OK(RemoteFileSetContents(local_path.c_str(), contents));
+    FUZZTEST_CHECK_OK(RemoteMkdir(tmp_dir.c_str()));
+    FUZZTEST_CHECK_OK(RemoteFileSetContents(local_path.c_str(), contents));
 
     // Augment the argv to point at the local copy and ensure it is cleaned up.
     replacements.emplace_back(path.c_str(), local_path.c_str());
@@ -188,16 +189,16 @@
   // Initialize `path` if --save_config or --update_config is passed.
   if (!absl::GetFlag(FLAGS_save_config).empty()) {
     path = absl::GetFlag(FLAGS_save_config);
-    CHECK_NE(path, absl::GetFlag(FLAGS_config))
+    FUZZTEST_CHECK_NE(path, absl::GetFlag(FLAGS_config))
         << "To update config in place, use " << DASHED_FLAG_NAME(update_config);
-    CHECK(!absl::GetFlag(FLAGS_update_config))
+    FUZZTEST_CHECK(!absl::GetFlag(FLAGS_update_config))
         << DASHED_FLAG_NAME(save_config) << " and "
         << DASHED_FLAG_NAME(update_config) << " are mutually exclusive";
   } else if (absl::GetFlag(FLAGS_update_config)) {
     path = absl::GetFlag(FLAGS_config);
-    CHECK(!path.empty()) << DASHED_FLAG_NAME(update_config)
-                         << " must be used in combination with "
-                         << DASHED_FLAG_NAME(config);
+    FUZZTEST_CHECK(!path.empty())
+        << DASHED_FLAG_NAME(update_config)
+        << " must be used in combination with " << DASHED_FLAG_NAME(config);
   }
 
   // Save or update the config file.
@@ -244,7 +245,7 @@
     } else {
       file_contents = flags_str;
     }
-    CHECK_OK(RemoteFileSetContents(path.c_str(), file_contents));
+    FUZZTEST_CHECK_OK(RemoteFileSetContents(path.c_str(), file_contents));
   }
 
   return path;
@@ -269,7 +270,7 @@
   const AugmentedArgvWithCleanup localized_argv =
       LocalizeConfigFilesInArgv(saved_argv);
   if (localized_argv.was_augmented()) {
-    LOG(INFO) << "Command line was augmented; reparsing";
+    FUZZTEST_LOG(INFO) << "Command line was augmented; reparsing";
     runtime_state->leftover_argv() = CastArgv(absl::ParseCommandLine(
         localized_argv.argc(), CastArgv(localized_argv.argv()).data()));
   }
@@ -279,15 +280,15 @@
     const FlagInfosPerSource flags = GetFlagsPerSource("centipede");
     const std::string flags_str = FormatFlagfileString(
         flags, DefaultedFlags::kCommentedOut, FlagComments::kNone);
-    LOG(INFO) << "Final resolved config:\n" << flags_str;
+    FUZZTEST_LOG(INFO) << "Final resolved config:\n" << flags_str;
   }
 
   // If --save_config was passed, save the final resolved flags to the requested
   // file and exit the program.
   const auto path = MaybeSaveConfigToFile(leftover_argv);
   if (!path.empty()) {
-    LOG(INFO) << "Config written to file: " << VV(path);
-    LOG(INFO) << "Nothing left to do; exiting";
+    FUZZTEST_LOG(INFO) << "Config written to file: " << VV(path);
+    FUZZTEST_LOG(INFO) << "Nothing left to do; exiting";
     exit(EXIT_SUCCESS);
   }
 
diff --git a/centipede/config_init.cc b/centipede/config_init.cc
index 5c5c555..2d22a33 100644
--- a/centipede/config_init.cc
+++ b/centipede/config_init.cc
@@ -37,7 +37,7 @@
 ABSL_ATTRIBUTE_WEAK std::unique_ptr<RuntimeState> InitRuntime(int argc,
                                                               char* argv[]) {
   // NB: The invocation order below is very important. Do not change.
-  // Make `LOG(INFO)` to go to stderr by default. Note that an explicit
+  // Make `FUZZTEST_LOG(INFO)` to go to stderr by default. Note that an explicit
   // `--stderrthreshold=N` on the command line will override this.
   absl::SetStderrThreshold(absl::LogSeverityAtLeast::kInfo);
   // Make --help print any flags defined by any Centipede source.
diff --git a/centipede/config_init.h b/centipede/config_init.h
index 740d2cc..59436df 100644
--- a/centipede/config_init.h
+++ b/centipede/config_init.h
@@ -42,8 +42,8 @@
 };
 
 // * Initializes the relevant runtime subsystems in the correct order.
-// * Directs all `LOG(INFO)`s to also to stderr (by default, only `LOG(ERROR)`s
-//   and higher go to stderr).
+// * Directs all `FUZZTEST_LOG(INFO)`s to also to stderr (by default, only
+//   `FUZZTEST_LOG(ERROR)`s and higher go to stderr).
 // * Tweaks --help behavior to print any flags defined by any Centipede source
 //   (by default, --help only prints flags defined in the source named
 //   <program>.cc or <program_main>.cc).
diff --git a/centipede/control_flow.cc b/centipede/control_flow.cc
index 68c443e..e053a80 100644
--- a/centipede/control_flow.cc
+++ b/centipede/control_flow.cc
@@ -30,8 +30,6 @@
 #include <vector>
 
 #include "absl/container/flat_hash_set.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
@@ -47,11 +45,11 @@
 PCTable ReadPcTableFromFile(std::string_view file_path) {
   ByteArray pc_infos_as_bytes;
   ReadFromLocalFile(file_path, pc_infos_as_bytes);
-  CHECK_EQ(pc_infos_as_bytes.size() % sizeof(PCInfo), 0);
+  FUZZTEST_CHECK_EQ(pc_infos_as_bytes.size() % sizeof(PCInfo), 0);
   size_t pc_table_size = pc_infos_as_bytes.size() / sizeof(PCInfo);
   const auto *pc_infos = reinterpret_cast<PCInfo *>(pc_infos_as_bytes.data());
   PCTable pc_table{pc_infos, pc_infos + pc_table_size};
-  CHECK_EQ(pc_table.size(), pc_table_size);
+  FUZZTEST_CHECK_EQ(pc_table.size(), pc_table_size);
   return pc_table;
 }
 
@@ -68,9 +66,9 @@
   if (exit_code != EXIT_SUCCESS) {
     std::string log_text;
     ReadFromLocalFile(stderr_path, log_text);
-    LOG(ERROR) << "Failed to use objdump to get PC table; stderr is:";
+    FUZZTEST_LOG(ERROR) << "Failed to use objdump to get PC table; stderr is:";
     for (const auto &line : absl::StrSplit(log_text, '\n')) {
-      LOG(ERROR).NoPrefix() << line;
+      FUZZTEST_LOG(ERROR).NoPrefix() << line;
     }
     std::filesystem::remove(tmp_path);
     std::filesystem::remove(stderr_path);
@@ -79,7 +77,7 @@
   std::filesystem::remove(stderr_path);
   PCTable pc_table;
   std::ifstream in(std::string{tmp_path});
-  CHECK(in.good()) << VV(tmp_path);
+  FUZZTEST_CHECK(in.good()) << VV(tmp_path);
   bool saw_new_function = false;
 
   // Read the objdump output, find lines that start a function
@@ -107,7 +105,7 @@
 CFTable ReadCfTable(std::istream &in) {
   const std::string input_string(std::istreambuf_iterator<char>(in), {});
   const ByteArray cf_table_as_bytes(input_string.begin(), input_string.end());
-  CHECK_EQ(cf_table_as_bytes.size() % sizeof(CFTable::value_type), 0);
+  FUZZTEST_CHECK_EQ(cf_table_as_bytes.size() % sizeof(CFTable::value_type), 0);
   const size_t cf_table_size =
       cf_table_as_bytes.size() / sizeof(CFTable::value_type);
   const auto *cf_entries =
@@ -117,7 +115,7 @@
 
 CFTable ReadCfTable(std::string_view file_path) {
   std::string cf_table_contents;
-  CHECK_OK(RemoteFileGetContents(file_path, cf_table_contents));
+  FUZZTEST_CHECK_OK(RemoteFileGetContents(file_path, cf_table_contents));
   std::istringstream cf_table_stream(cf_table_contents);
   return ReadCfTable(cf_table_stream);
 }
@@ -135,7 +133,7 @@
     // Use std::string; there is no std::stoul for std::string_view.
     const std::vector<std::string> tokens =
         absl::StrSplit(line, ' ', absl::SkipEmpty());
-    CHECK_EQ(tokens.size(), 2) << VV(line);
+    FUZZTEST_CHECK_EQ(tokens.size(), 2) << VV(line);
     result.push_back(DsoInfo{tokens[0], std::stoul(tokens[1])});
   }
   return result;
@@ -143,7 +141,7 @@
 
 void ControlFlowGraph::InitializeControlFlowGraph(const CFTable &cf_table,
                                                   const PCTable &pc_table) {
-  CHECK(!cf_table.empty());
+  FUZZTEST_CHECK(!cf_table.empty());
   func_entries_.resize(pc_table.size());
   reachability_.resize(pc_table.size());
 
@@ -162,14 +160,14 @@
     // Record the list of successors
     graph_[curr_pc] = std::move(successors);
     // TODO(ussuri): Remove after debugging.
-    VLOG(100) << "Added PC: " << curr_pc;
+    FUZZTEST_VLOG(100) << "Added PC: " << curr_pc;
 
     // Iterate over callees.
     while (cf_table[j]) {
       ++j;
     }
     ++j;  // Step over the delimiter.
-    CHECK_LE(j, cf_table.size());
+    FUZZTEST_CHECK_LE(j, cf_table.size());
   }
   // Calculate cyclomatic complexity for all functions.
   for (PCIndex i = 0; i < pc_table.size(); ++i) {
@@ -186,7 +184,7 @@
 const std::vector<uintptr_t> &ControlFlowGraph::GetSuccessors(
     uintptr_t basic_block) const {
   auto it = graph_.find(basic_block);
-  CHECK(it != graph_.end()) << VV(basic_block);
+  FUZZTEST_CHECK(it != graph_.end()) << VV(basic_block);
   return it->second;
 }
 
diff --git a/centipede/control_flow.h b/centipede/control_flow.h
index f401d84..2feb9fa 100644
--- a/centipede/control_flow.h
+++ b/centipede/control_flow.h
@@ -25,7 +25,6 @@
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
-#include "absl/log/check.h"
 #include "./centipede/pc_info.h"
 #include "./common/defs.h"
 #include "./common/logging.h"
@@ -86,26 +85,27 @@
     return graph_.contains(basic_block);
   }
 
-  // Returns cyclomatic complexity of function PC. CHECK-fails if it is not a
-  // valid function PC.
+  // Returns cyclomatic complexity of function PC. FUZZTEST_CHECK-fails if it is
+  // not a valid function PC.
   uint32_t GetCyclomaticComplexity(uintptr_t pc) const {
     auto it = function_complexities_.find(pc);
-    CHECK(it != function_complexities_.end());
+    FUZZTEST_CHECK(it != function_complexities_.end());
     return it->second;
   }
 
   // Returns true if the given basic block is function entry.
   bool BlockIsFunctionEntry(PCIndex pc_index) const {
-    // TODO(ussuri): Change the following to use CHECK_LE(pc_index,
+    // TODO(ussuri): Change the following to use FUZZTEST_CHECK_LE(pc_index,
     // func_entries_.size()) and have a death test.
     return pc_index < func_entries_.size() ? func_entries_[pc_index] : false;
   }
 
-  // Returns the idx in pc_table associated with the PC, CHECK-fails if the PC
-  // is not in the pc_table.
+  // Returns the idx in pc_table associated with the PC, FUZZTEST_CHECK-fails if
+  // the PC is not in the pc_table.
   PCIndex GetPcIndex(uintptr_t pc) const {
     auto it = pc_index_map_.find(pc);
-    CHECK(it != pc_index_map_.end()) << VV(pc) << " is not in pc_table.";
+    FUZZTEST_CHECK(it != pc_index_map_.end())
+        << VV(pc) << " is not in pc_table.";
     return it->second;
   }
 
@@ -117,7 +117,7 @@
   // The method is const, under the hood it uses a mutable data member.
   // Thread-safe: can be called concurrently from multiple threads
   const std::vector<uintptr_t> &LazyGetReachabilityForPc(uintptr_t pc) const {
-    CHECK_EQ(reachability_.size(), pc_index_map_.size());
+    FUZZTEST_CHECK_EQ(reachability_.size(), pc_index_map_.size());
     auto pc_index = GetPcIndex(pc);
     std::call_once(*(reachability_[pc_index].once), [this, &pc, &pc_index]() {
       reachability_[pc_index].reach = ComputeReachabilityForPc(pc);
diff --git a/centipede/control_flow_test.cc b/centipede/control_flow_test.cc
index 4d63e59..2d21d21 100644
--- a/centipede/control_flow_test.cc
+++ b/centipede/control_flow_test.cc
@@ -25,8 +25,6 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/container/flat_hash_map.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "./centipede/binary_info.h"
 #include "./centipede/pc_info.h"
 #include "./centipede/symbol_table.h"
@@ -87,17 +85,17 @@
     EXPECT_TRUE(cfg.GetSuccessors(4).empty());
   }
 
-  CHECK_EQ(cfg.GetPcIndex(1), 0);
-  CHECK_EQ(cfg.GetPcIndex(2), 1);
-  CHECK_EQ(cfg.GetPcIndex(3), 2);
-  CHECK_EQ(cfg.GetPcIndex(4), 3);
+  FUZZTEST_CHECK_EQ(cfg.GetPcIndex(1), 0);
+  FUZZTEST_CHECK_EQ(cfg.GetPcIndex(2), 1);
+  FUZZTEST_CHECK_EQ(cfg.GetPcIndex(3), 2);
+  FUZZTEST_CHECK_EQ(cfg.GetPcIndex(4), 3);
 
   EXPECT_TRUE(cfg.BlockIsFunctionEntry(0));
   EXPECT_FALSE(cfg.BlockIsFunctionEntry(1));
   EXPECT_FALSE(cfg.BlockIsFunctionEntry(2));
   EXPECT_FALSE(cfg.BlockIsFunctionEntry(3));
 
-  CHECK_EQ(cfg.GetCyclomaticComplexity(1), 2);
+  FUZZTEST_CHECK_EQ(cfg.GetCyclomaticComplexity(1), 2);
 }
 
 TEST(CFTable, SerializesAndDeserializesCfTable) {
@@ -205,9 +203,9 @@
       target_path, GetObjDumpPath(), GetLLVMSymbolizerPath(),
       GetTestTempDir(test_info_->name()).string());
   const auto &cf_table = binary_info.cf_table;
-  LOG(INFO) << VV(target_path) << VV(tmp_path1) << VV(cf_table.size());
+  FUZZTEST_LOG(INFO) << VV(target_path) << VV(tmp_path1) << VV(cf_table.size());
   if (cf_table.empty()) {
-    LOG(INFO) << "__sancov_cfs is empty.";
+    FUZZTEST_LOG(INFO) << "__sancov_cfs is empty.";
     // TODO(ussuri): This should be removed once OSS clang supports
     //  control-flow.
     GTEST_SKIP();
@@ -215,7 +213,7 @@
 
   ASSERT_FALSE(
       std::filesystem::exists(tmp_path1.c_str()));  // tmp_path1 was deleted.
-  LOG(INFO) << VV(cf_table.size());
+  FUZZTEST_LOG(INFO) << VV(cf_table.size());
 
   const auto &pc_table = binary_info.pc_table;
   EXPECT_FALSE(binary_info.uses_legacy_trace_pc_instrumentation);
@@ -304,7 +302,7 @@
   for (size_t i = 0; i < symbols.size(); i++) {
     bool is_func_entry = pc_table[i].has_flag(PCInfo::kFuncEntry);
     if (is_func_entry) {
-      LOG(INFO) << symbols.full_description(i);
+      FUZZTEST_LOG(INFO) << symbols.full_description(i);
     }
     single_edge_func_num_edges += symbols.func(i) == "SingleEdgeFunc";
     multi_edge_func_num_edges += symbols.func(i) == "MultiEdgeFunc";
diff --git a/centipede/corpus.cc b/centipede/corpus.cc
index 42f3e4b..16f4b5d 100644
--- a/centipede/corpus.cc
+++ b/centipede/corpus.cc
@@ -22,8 +22,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/substitute.h"
@@ -80,7 +78,7 @@
                      const CoverageFrontier &coverage_frontier,
                      size_t max_corpus_size, Rng &rng) {
   // TODO(kcc): use coverage_frontier.
-  CHECK(max_corpus_size);
+  FUZZTEST_CHECK(max_corpus_size);
   if (records_.size() < 2UL) return 0;
   // Recompute the weights.
   size_t num_zero_weights = 0;
@@ -103,7 +101,7 @@
   RemoveSubset(subset_to_remove, records_);
 
   weighted_distribution_.RecomputeInternalState();
-  CHECK(!records_.empty());
+  FUZZTEST_CHECK(!records_.empty());
 
   // Features may have shrunk from CountUnseenAndPruneFrequentFeatures.
   // Call shrink_to_fit for the features that survived the pruning.
@@ -119,9 +117,9 @@
                  const ExecutionMetadata &metadata, const FeatureSet &fs,
                  const CoverageFrontier &coverage_frontier) {
   // TODO(kcc): use coverage_frontier.
-  CHECK(!data.empty())
+  FUZZTEST_CHECK(!data.empty())
       << "Got request to add empty element to corpus: ignoring";
-  CHECK_EQ(records_.size(), weighted_distribution_.size());
+  FUZZTEST_CHECK_EQ(records_.size(), weighted_distribution_.size());
   records_.push_back({data, fv, metadata});
   weighted_distribution_.AddWeight(ComputeWeight(fv, fs, coverage_frontier));
 }
@@ -137,8 +135,8 @@
 void Corpus::DumpStatsToFile(const FeatureSet &fs, std::string_view filepath,
                              std::string_view description) {
   auto *file = ValueOrDie(RemoteFileOpen(filepath, "w"));
-  CHECK(file != nullptr) << "Failed to open file: " << filepath;
-  CHECK_OK(RemoteFileSetWriteBufferSize(file, 100UL * 1024 * 1024));
+  FUZZTEST_CHECK(file != nullptr) << "Failed to open file: " << filepath;
+  FUZZTEST_CHECK_OK(RemoteFileSetWriteBufferSize(file, 100UL * 1024 * 1024));
   static constexpr std::string_view kHeaderStub = R"(# $0
 {
   "num_inputs": $1,
@@ -151,7 +149,7 @@
 )";
   const std::string header_str =
       absl::Substitute(kHeaderStub, description, records_.size());
-  CHECK_OK(RemoteFileAppend(file, header_str));
+  FUZZTEST_CHECK_OK(RemoteFileAppend(file, header_str));
   std::string before_record;
   for (const auto &record : records_) {
     std::vector<size_t> frequencies;
@@ -162,11 +160,11 @@
     const std::string frequencies_str = absl::StrJoin(frequencies, ", ");
     const std::string record_str = absl::Substitute(
         kRecordStub, before_record, record.data.size(), frequencies_str);
-    CHECK_OK(RemoteFileAppend(file, record_str));
+    FUZZTEST_CHECK_OK(RemoteFileAppend(file, record_str));
     before_record = ",";
   }
-  CHECK_OK(RemoteFileAppend(file, std::string{kFooter}));
-  CHECK_OK(RemoteFileClose(file));
+  FUZZTEST_CHECK_OK(RemoteFileAppend(file, std::string{kFooter}));
+  FUZZTEST_CHECK_OK(RemoteFileClose(file));
 }
 
 std::string Corpus::MemoryUsageString() const {
@@ -184,7 +182,7 @@
 //------------------------------------------------------------------------------
 
 void WeightedDistribution::AddWeight(uint64_t weight) {
-  CHECK_EQ(weights_.size(), cumulative_weights_.size());
+  FUZZTEST_CHECK_EQ(weights_.size(), cumulative_weights_.size());
   weights_.push_back(weight);
   if (cumulative_weights_.empty()) {
     cumulative_weights_.push_back(weight);
@@ -194,7 +192,7 @@
 }
 
 void WeightedDistribution::ChangeWeight(size_t idx, uint64_t new_weight) {
-  CHECK_LT(idx, size());
+  FUZZTEST_CHECK_LT(idx, size());
   weights_[idx] = new_weight;
   cumulative_weights_valid_ = false;
 }
@@ -212,15 +210,15 @@
 __attribute__((noinline))  // to see it in profile.
 size_t
 WeightedDistribution::RandomIndex(size_t random) const {
-  CHECK(!weights_.empty());
-  CHECK(cumulative_weights_valid_);
+  FUZZTEST_CHECK(!weights_.empty());
+  FUZZTEST_CHECK(cumulative_weights_valid_);
   uint64_t sum_of_all_weights = cumulative_weights_.back();
   if (sum_of_all_weights == 0)
     return random % size();  // can't do much else here.
   random = random % sum_of_all_weights;
   auto it = std::upper_bound(cumulative_weights_.begin(),
                              cumulative_weights_.end(), random);
-  CHECK(it != cumulative_weights_.end());
+  FUZZTEST_CHECK(it != cumulative_weights_.end());
   return it - cumulative_weights_.begin();
 }
 
diff --git a/centipede/corpus.h b/centipede/corpus.h
index e297f06..dc6bb00 100644
--- a/centipede/corpus.h
+++ b/centipede/corpus.h
@@ -23,7 +23,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "./centipede/binary_info.h"
 #include "./centipede/execution_metadata.h"
 #include "./centipede/feature.h"
@@ -180,7 +179,7 @@
 
   // Returns true iff `idx` belongs to the frontier.
   bool PcIndexIsFrontier(size_t idx) const {
-    CHECK_LT(idx, MaxPcIndex());
+    FUZZTEST_CHECK_LT(idx, MaxPcIndex());
     return frontier_[idx];
   }
 
@@ -189,7 +188,7 @@
 
   // Returns the frontier weight of pc at `idx`, weight of a non-frontier is 0.
   uint64_t FrontierWeight(size_t idx) const {
-    CHECK_LT(idx, MaxPcIndex());
+    FUZZTEST_CHECK_LT(idx, MaxPcIndex());
     return frontier_weight_[idx];
   }
 
diff --git a/centipede/corpus_io.cc b/centipede/corpus_io.cc
index 23e63c3..cdc6de9 100644
--- a/centipede/corpus_io.cc
+++ b/centipede/corpus_io.cc
@@ -22,8 +22,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/time/time.h"
 #include "absl/types/span.h"
@@ -46,13 +44,13 @@
       !features_path.empty() && RemotePathExists(features_path);
 
   if (!good_corpus_path) {
-    LOG(WARNING) << "Corpus file path empty or not found - returning: "
-                 << corpus_path;
+    FUZZTEST_LOG(WARNING) << "Corpus file path empty or not found - returning: "
+                          << corpus_path;
     return;
   }
 
   RPROF_THIS_FUNCTION_WITH_TIMELAPSE(            //
-      /*enable=*/ABSL_VLOG_IS_ON(10),            //
+      /*enable=*/FUZZTEST_VLOG_IS_ON(10),        //
       /*timelapse_interval=*/absl::Seconds(30),  //
       /*also_log_timelapses=*/false);
 
@@ -64,7 +62,7 @@
   std::multimap<std::string /*hash*/, ByteArray /*input*/> hash_to_input;
   // Read inputs from the corpus file into `hash_to_input`.
   auto corpus_reader = DefaultBlobFileReaderFactory();
-  CHECK_OK(corpus_reader->Open(corpus_path)) << VV(corpus_path);
+  FUZZTEST_CHECK_OK(corpus_reader->Open(corpus_path)) << VV(corpus_path);
   ByteSpan blob;
   while (corpus_reader->Read(blob).ok()) {
     std::string hash = Hash(blob);
@@ -82,15 +80,17 @@
 
   // If the features file is not passed or doesn't exist, simply ignore it.
   if (!good_features_path) {
-    LOG(WARNING) << "Features file path empty or not found - ignoring: "
-                 << features_path;
+    FUZZTEST_LOG(WARNING)
+        << "Features file path empty or not found - ignoring: "
+        << features_path;
   } else {
     // Read features from the features file. For each feature, find a matching
     // input in `hash_to_input`, call `callback` for the pair, and remove the
     // entry from `hash_to_input`. In the end, `hash_to_input` will contain
     // only inputs without matching features.
     auto features_reader = DefaultBlobFileReaderFactory();
-    CHECK_OK(features_reader->Open(features_path)) << VV(features_path);
+    FUZZTEST_CHECK_OK(features_reader->Open(features_path))
+        << VV(features_path);
     ByteSpan hash_and_features;
     while (features_reader->Read(hash_and_features).ok()) {
       // Every valid feature record must contain the hash at the end.
@@ -127,7 +127,7 @@
 
   RPROF_SNAPSHOT("Reported inputs with no matching features");
 
-  VLOG(1)  //
+  FUZZTEST_VLOG(1)  //
       << "Finished shard reading:\n"
       << "Corpus path                : " << corpus_path << "\n"
       << "Features path              : " << features_path << "\n"
@@ -140,17 +140,17 @@
 
 void ExportCorpus(absl::Span<const std::string> sharded_file_paths,
                   std::string_view out_dir) {
-  LOG(INFO) << "Exporting corpus to " << out_dir;
+  FUZZTEST_LOG(INFO) << "Exporting corpus to " << out_dir;
   for (const std::string &file : sharded_file_paths) {
     auto reader = DefaultBlobFileReaderFactory();
-    CHECK_OK(reader->Open(file)) << VV(file);
+    FUZZTEST_CHECK_OK(reader->Open(file)) << VV(file);
     ByteSpan blob;
     size_t num_read = 0;
     while (reader->Read(blob).ok()) {
       ++num_read;
       WriteToRemoteHashedFileInDir(out_dir, blob);
     }
-    LOG(INFO) << "Exported " << num_read << " inputs from " << file;
+    FUZZTEST_LOG(INFO) << "Exported " << num_read << " inputs from " << file;
   }
 }
 
diff --git a/centipede/corpus_io_test.cc b/centipede/corpus_io_test.cc
index a97572d..f368a31 100644
--- a/centipede/corpus_io_test.cc
+++ b/centipede/corpus_io_test.cc
@@ -22,7 +22,6 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "absl/log/check.h"
 #include "absl/types/span.h"
 #include "./centipede/corpus.h"
 #include "./centipede/feature.h"
@@ -30,6 +29,7 @@
 #include "./centipede/workdir.h"
 #include "./common/blob_file.h"
 #include "./common/defs.h"
+#include "./common/logging.h"
 #include "./common/test_util.h"
 
 namespace fuzztest::internal {
@@ -40,11 +40,11 @@
 void WriteBlobsToFile(std::string_view blob_file_path,
                       absl::Span<const ByteArray> blobs) {
   auto writer = DefaultBlobFileWriterFactory();
-  CHECK_OK(writer->Open(blob_file_path, "w"));
+  FUZZTEST_CHECK_OK(writer->Open(blob_file_path, "w"));
   for (const ByteArray& blob : blobs) {
-    CHECK_OK(writer->Write(blob));
+    FUZZTEST_CHECK_OK(writer->Write(blob));
   }
-  CHECK_OK(writer->Close());
+  FUZZTEST_CHECK_OK(writer->Close());
 }
 
 std::vector<ByteArray> ReadInputsFromFiles(std::string_view dir) {
@@ -109,7 +109,7 @@
 TEST(ExportCorpusTest, ExportsCorpusToIndividualFiles) {
   const std::filesystem::path temp_dir = GetTestTempDir(test_info_->name());
   const std::filesystem::path out_dir = temp_dir / "out_dir";
-  CHECK(std::filesystem::create_directory(out_dir));
+  FUZZTEST_CHECK(std::filesystem::create_directory(out_dir));
   const WorkDir workdir{temp_dir.c_str(), "fake_binary_name",
                         "fake_binary_hash", /*my_shard_index=*/0};
   const auto corpus_file_paths = workdir.CorpusFilePaths();
diff --git a/centipede/corpus_test.cc b/centipede/corpus_test.cc
index 13b576c..8975571 100644
--- a/centipede/corpus_test.cc
+++ b/centipede/corpus_test.cc
@@ -135,7 +135,7 @@
   EXPECT_EQ(corpus.Prune(fs, coverage_frontier, 1, rng), 1);
   EXPECT_EQ(corpus.NumActive(), 1);
   EXPECT_DEATH(corpus.Prune(fs, coverage_frontier, 0, rng),
-               "max_corpus_size");  // CHECK-fail.
+               "max_corpus_size");  // FUZZTEST_CHECK-fail.
   EXPECT_EQ(corpus.NumTotal(), 6);
 }
 
diff --git a/centipede/coverage.cc b/centipede/coverage.cc
index 28373ea..a5a96e2 100644
--- a/centipede/coverage.cc
+++ b/centipede/coverage.cc
@@ -25,13 +25,13 @@
 #include <vector>
 
 #include "absl/container/flat_hash_set.h"
-#include "absl/log/check.h"
 #include "absl/strings/str_split.h"
 #include "absl/synchronization/mutex.h"
 #include "./centipede/control_flow.h"
 #include "./centipede/feature.h"
 #include "./centipede/pc_info.h"
 #include "./centipede/symbol_table.h"
+#include "./common/logging.h"
 #include "./common/remote_file.h"
 #include "./common/status_macros.h"
 
@@ -41,7 +41,7 @@
     : func_entries_(pc_table.size()),
       fully_covered_funcs_vec_(pc_table.size()),
       covered_pcs_vec_(pc_table.size()) {
-  CHECK_LT(pc_table.size(), std::numeric_limits<PCIndex>::max());
+  FUZZTEST_CHECK_LT(pc_table.size(), std::numeric_limits<PCIndex>::max());
   absl::flat_hash_set<PCIndex> covered_pcs(pci_vec.begin(), pci_vec.end());
   // Iterate though all the pc_table entries.
   // The first one is some function's kFuncEntry.
@@ -51,7 +51,7 @@
   // to fully_covered_funcs or uncovered_funcs correspondingly.
   // For all others add them to partially_covered_funcs.
   for (size_t this_func = 0; this_func < pc_table.size();) {
-    CHECK(pc_table[this_func].has_flag(PCInfo::kFuncEntry));
+    FUZZTEST_CHECK(pc_table[this_func].has_flag(PCInfo::kFuncEntry));
     func_entries_[this_func] = true;
     // Find next entry.
     size_t next_func = this_func + 1;
@@ -78,9 +78,10 @@
     } else if (pcf.covered.empty()) {
       uncovered_funcs.push_back(this_func);
     } else {
-      CHECK(!pcf.covered.empty());
-      CHECK(!pcf.uncovered.empty());
-      CHECK_EQ(pcf.covered.size() + pcf.uncovered.size(), num_func_pcs);
+      FUZZTEST_CHECK(!pcf.covered.empty());
+      FUZZTEST_CHECK(!pcf.uncovered.empty());
+      FUZZTEST_CHECK_EQ(pcf.covered.size() + pcf.uncovered.size(),
+                        num_func_pcs);
       partially_covered_funcs.push_back(pcf);
     }
     // Move to the next function.
@@ -92,46 +93,51 @@
                                 std::string_view filepath,
                                 std::string_view description) {
   auto *file = ValueOrDie(RemoteFileOpen(filepath, "w"));
-  CHECK(file != nullptr) << "Failed to open file: " << filepath;
-  CHECK_OK(RemoteFileSetWriteBufferSize(file, 100UL * 1024 * 1024));
+  FUZZTEST_CHECK(file != nullptr) << "Failed to open file: " << filepath;
+  FUZZTEST_CHECK_OK(RemoteFileSetWriteBufferSize(file, 100UL * 1024 * 1024));
   if (!description.empty()) {
-    CHECK_OK(RemoteFileAppend(file, "# "));
-    CHECK_OK(RemoteFileAppend(file, std::string{description}));
-    CHECK_OK(RemoteFileAppend(file, ":\n\n"));
+    FUZZTEST_CHECK_OK(RemoteFileAppend(file, "# "));
+    FUZZTEST_CHECK_OK(RemoteFileAppend(file, std::string{description}));
+    FUZZTEST_CHECK_OK(RemoteFileAppend(file, ":\n\n"));
   }
   // Print symbolized function names for all covered functions.
   for (auto pc_index : fully_covered_funcs) {
-    CHECK_OK(RemoteFileAppend(file, "FULL: "));
-    CHECK_OK(RemoteFileAppend(file, symbols.full_description(pc_index)));
-    CHECK_OK(RemoteFileAppend(file, "\n"));
+    FUZZTEST_CHECK_OK(RemoteFileAppend(file, "FULL: "));
+    FUZZTEST_CHECK_OK(
+        RemoteFileAppend(file, symbols.full_description(pc_index)));
+    FUZZTEST_CHECK_OK(RemoteFileAppend(file, "\n"));
   }
-  CHECK_OK(RemoteFileFlush(file));
+  FUZZTEST_CHECK_OK(RemoteFileFlush(file));
   // Same for uncovered functions.
   for (auto pc_index : uncovered_funcs) {
-    CHECK_OK(RemoteFileAppend(file, "NONE: "));
-    CHECK_OK(RemoteFileAppend(file, symbols.full_description(pc_index)));
-    CHECK_OK(RemoteFileAppend(file, "\n"));
+    FUZZTEST_CHECK_OK(RemoteFileAppend(file, "NONE: "));
+    FUZZTEST_CHECK_OK(
+        RemoteFileAppend(file, symbols.full_description(pc_index)));
+    FUZZTEST_CHECK_OK(RemoteFileAppend(file, "\n"));
   }
-  CHECK_OK(RemoteFileFlush(file));
+  FUZZTEST_CHECK_OK(RemoteFileFlush(file));
   // For every partially covered function, first print its name,
   // then print its covered edges, then uncovered edges.
   for (auto &pcf : partially_covered_funcs) {
-    CHECK_OK(RemoteFileAppend(file, "PARTIAL: "));
-    CHECK_OK(RemoteFileAppend(file, symbols.full_description(pcf.covered[0])));
-    CHECK_OK(RemoteFileAppend(file, "\n"));
+    FUZZTEST_CHECK_OK(RemoteFileAppend(file, "PARTIAL: "));
+    FUZZTEST_CHECK_OK(
+        RemoteFileAppend(file, symbols.full_description(pcf.covered[0])));
+    FUZZTEST_CHECK_OK(RemoteFileAppend(file, "\n"));
     for (auto pc_index : pcf.covered) {
-      CHECK_OK(RemoteFileAppend(file, "  + "));
-      CHECK_OK(RemoteFileAppend(file, symbols.full_description(pc_index)));
-      CHECK_OK(RemoteFileAppend(file, "\n"));
+      FUZZTEST_CHECK_OK(RemoteFileAppend(file, "  + "));
+      FUZZTEST_CHECK_OK(
+          RemoteFileAppend(file, symbols.full_description(pc_index)));
+      FUZZTEST_CHECK_OK(RemoteFileAppend(file, "\n"));
     }
     for (auto pc_index : pcf.uncovered) {
-      CHECK_OK(RemoteFileAppend(file, "  - "));
-      CHECK_OK(RemoteFileAppend(file, symbols.full_description(pc_index)));
-      CHECK_OK(RemoteFileAppend(file, "\n"));
+      FUZZTEST_CHECK_OK(RemoteFileAppend(file, "  - "));
+      FUZZTEST_CHECK_OK(
+          RemoteFileAppend(file, symbols.full_description(pc_index)));
+      FUZZTEST_CHECK_OK(RemoteFileAppend(file, "\n"));
     }
   }
-  CHECK_OK(RemoteFileFlush(file));
-  CHECK_OK(RemoteFileClose(file));
+  FUZZTEST_CHECK_OK(RemoteFileFlush(file));
+  FUZZTEST_CHECK_OK(RemoteFileClose(file));
 }
 
 std::string CoverageLogger::ObserveAndDescribeIfNew(PCIndex pc_index) {
@@ -215,7 +221,7 @@
     auto cyclomatic_comp = cfg.GetCyclomaticComplexity(callee);
     // Determine knob based on callee coverage kind.
     auto callee_idx = cfg.GetPcIndex(callee);
-    CHECK(cfg.BlockIsFunctionEntry(callee_idx));
+    FUZZTEST_CHECK(cfg.BlockIsFunctionEntry(callee_idx));
     auto coverage_multiplier = SelectMultiplierByCoverageKind(
         uncovered_knob, partially_covered_knob, fully_covered_knob, callee_idx,
         coverage);
diff --git a/centipede/coverage.h b/centipede/coverage.h
index 7e681c0..340027c 100644
--- a/centipede/coverage.h
+++ b/centipede/coverage.h
@@ -26,7 +26,6 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_set.h"
-#include "absl/log/check.h"
 #include "absl/synchronization/mutex.h"
 #include "./centipede/control_flow.h"
 #include "./centipede/feature.h"
@@ -55,7 +54,7 @@
   // Returns true if the function is fully covered. pc_index is for a function
   // entry.
   bool FunctionIsFullyCovered(PCIndex pc_index) const {
-    CHECK(func_entries_[pc_index]);
+    FUZZTEST_CHECK(func_entries_[pc_index]);
     return fully_covered_funcs_vec_[pc_index];
   }
   // Returns true if the given basic block is covered. pc_index is for any BB.
diff --git a/centipede/distill.cc b/centipede/distill.cc
index 1b16a2b..74ecf67 100644
--- a/centipede/distill.cc
+++ b/centipede/distill.cc
@@ -30,8 +30,6 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_set.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/synchronization/mutex.h"
@@ -136,9 +134,10 @@
   CorpusEltVec ReadShard(size_t shard_idx) {
     const auto corpus_path = workdir_.CorpusFilePaths().Shard(shard_idx);
     const auto features_path = workdir_.FeaturesFilePaths().Shard(shard_idx);
-    VLOG(1) << log_prefix_ << "reading input shard " << shard_idx << ":\n"
-            << VV(corpus_path) << "\n"
-            << VV(features_path);
+    FUZZTEST_VLOG(1) << log_prefix_ << "reading input shard " << shard_idx
+                     << ":\n"
+                     << VV(corpus_path) << "\n"
+                     << VV(features_path);
     CorpusEltVec elts;
     // Read elements from the current shard.
     fuzztest::internal::ReadShard(  //
@@ -171,8 +170,9 @@
         features_path_{workdir_.DistilledFeaturesFilePaths().MyShard()},
         corpus_writer_{DefaultBlobFileWriterFactory()},
         feature_writer_{DefaultBlobFileWriterFactory()} {
-    CHECK_OK(corpus_writer_->Open(corpus_path_, append ? "a" : "w"));
-    CHECK_OK(feature_writer_->Open(features_path_, append ? "a" : "w"));
+    FUZZTEST_CHECK_OK(corpus_writer_->Open(corpus_path_, append ? "a" : "w"));
+    FUZZTEST_CHECK_OK(
+        feature_writer_->Open(features_path_, append ? "a" : "w"));
   }
 
   virtual ~CorpusShardWriter() = default;
@@ -184,10 +184,10 @@
 
   void WriteBatch(CorpusEltVec elts) {
     absl::MutexLock lock(&mu_);
-    VLOG(1) << log_prefix_ << "writing " << elts.size()
-            << " elements to output shard:\n"
-            << VV(corpus_path_) << "\n"
-            << VV(features_path_);
+    FUZZTEST_VLOG(1) << log_prefix_ << "writing " << elts.size()
+                     << " elements to output shard:\n"
+                     << VV(corpus_path_) << "\n"
+                     << VV(features_path_);
     for (auto &elt : elts) {
       WriteEltImpl(std::move(elt));
     }
@@ -214,8 +214,9 @@
     const auto preprocessed_elt = PreprocessElt(std::move(elt));
     if (preprocessed_elt.has_value()) {
       // Append to the distilled corpus and features files.
-      CHECK_OK(corpus_writer_->Write(preprocessed_elt->input));
-      CHECK_OK(feature_writer_->Write(preprocessed_elt->PackedFeatures()));
+      FUZZTEST_CHECK_OK(corpus_writer_->Write(preprocessed_elt->input));
+      FUZZTEST_CHECK_OK(
+          feature_writer_->Write(preprocessed_elt->PackedFeatures()));
       ++stats_.num_written_elts;
     }
   }
@@ -337,9 +338,9 @@
     DistillingInputFilter &input_filter,       //
     ResourcePool<RUsageMemory> &ram_pool,      //
     int parallelism) {
-  LOG(INFO) << LogPrefix(env) << "Distilling to output shard "
-            << env.my_shard_index << "; input shard indices:\n"
-            << absl::StrJoin(shard_indices, ", ");
+  FUZZTEST_LOG(INFO) << LogPrefix(env) << "Distilling to output shard "
+                     << env.my_shard_index << "; input shard indices:\n"
+                     << absl::StrJoin(shard_indices, ", ");
 
   // Read and write the shards in parallel, but gate reading of each on the
   // availability of free RAM to keep the peak RAM usage under control.
@@ -360,7 +361,7 @@
              /*mem_rss=*/reader.EstimateRamFootprint(shard_idx)},
             /*timeout=*/kRamLeaseTimeout,
         });
-        CHECK_OK(ram_lease.status());
+        FUZZTEST_CHECK_OK(ram_lease.status());
 
         CorpusEltVec shard_elts = reader.ReadShard(shard_idx);
         // Reverse the order of elements. The intuition is as follows:
@@ -371,23 +372,25 @@
         std::reverse(shard_elts.begin(), shard_elts.end());
         writer.WriteBatch(std::move(shard_elts));
         const CorpusShardWriter::Stats shard_stats = writer.GetStats();
-        LOG(INFO) << LogPrefix(env)
-                  << "batches: " << shard_stats.num_written_batches << "/"
-                  << num_shards << " inputs: " << shard_stats.num_total_elts
-                  << " written: " << shard_stats.num_written_elts;
+        FUZZTEST_LOG(INFO) << LogPrefix(env)
+                           << "batches: " << shard_stats.num_written_batches
+                           << "/" << num_shards
+                           << " inputs: " << shard_stats.num_total_elts
+                           << " written: " << shard_stats.num_written_elts;
       });
     }
   }  // The threads join here.
 
-  LOG(INFO) << LogPrefix(env) << "Done distilling to output shard "
-            << env.my_shard_index;
+  FUZZTEST_LOG(INFO) << LogPrefix(env) << "Done distilling to output shard "
+                     << env.my_shard_index;
 }
 
 int Distill(const Environment &env, const DistillOptions &opts) {
-  RPROF_THIS_FUNCTION_WITH_TIMELAPSE(                                      //
-      /*enable=*/ABSL_VLOG_IS_ON(1),                                       //
-      /*timelapse_interval=*/absl::Seconds(ABSL_VLOG_IS_ON(2) ? 10 : 60),  //
-      /*also_log_timelapses=*/ABSL_VLOG_IS_ON(10));
+  RPROF_THIS_FUNCTION_WITH_TIMELAPSE(                   //
+      /*enable=*/FUZZTEST_VLOG_IS_ON(1),                //
+                                                        /*timelapse_interval=*/
+      absl::Seconds(FUZZTEST_VLOG_IS_ON(2) ? 10 : 60),  //
+      /*also_log_timelapses=*/FUZZTEST_VLOG_IS_ON(10));
 
   // Prepare the per-thread envs.
   std::vector<Environment> envs_per_thread(env.num_threads, env);
@@ -423,16 +426,16 @@
     PeriodicAction progress_logger{
         [&input_filter]() {
           const auto stats = input_filter.GetStats();
-          LOG(INFO) << LogPrefix() << stats.coverage_str
-                    << " inputs: " << stats.num_total_elts
-                    << " unique: " << stats.num_byte_unique_elts
-                    << " distilled: " << stats.num_feature_unique_elts;
+          FUZZTEST_LOG(INFO) << LogPrefix() << stats.coverage_str
+                             << " inputs: " << stats.num_total_elts
+                             << " unique: " << stats.num_byte_unique_elts
+                             << " distilled: " << stats.num_feature_unique_elts;
         },
         // Seeing 0's at the beginning is not interesting, unless debugging.
         // Likewise, increase the frequency --v >= 1 to aid debugging.
         PeriodicAction::ConstDelayConstInterval(
-            absl::Seconds(ABSL_VLOG_IS_ON(1) ? 0 : 60),
-            absl::Seconds(ABSL_VLOG_IS_ON(1) ? 10 : 60)),
+            absl::Seconds(FUZZTEST_VLOG_IS_ON(1) ? 0 : 60),
+            absl::Seconds(FUZZTEST_VLOG_IS_ON(1) ? 10 : 60)),
     };
     // The RAM pool shared between all the `DistillToOneOutputShard()` threads.
     ResourcePool ram_pool{kRamQuota};
diff --git a/centipede/distill_test.cc b/centipede/distill_test.cc
index 2d88010..047f67f 100644
--- a/centipede/distill_test.cc
+++ b/centipede/distill_test.cc
@@ -25,7 +25,6 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/flags/reflection.h"
-#include "absl/log/check.h"
 #include "./centipede/corpus_io.h"
 #include "./centipede/environment.h"
 #include "./centipede/feature.h"
@@ -33,6 +32,7 @@
 #include "./centipede/workdir.h"
 #include "./common/blob_file.h"
 #include "./common/defs.h"
+#include "./common/logging.h"
 #include "./common/test_util.h"
 
 namespace fuzztest::internal {
@@ -70,10 +70,10 @@
   const auto features_path = wd.FeaturesFilePaths().Shard(shard_index);
   const auto corpus_appender = DefaultBlobFileWriterFactory(env.riegeli);
   const auto features_appender = DefaultBlobFileWriterFactory(env.riegeli);
-  CHECK_OK(corpus_appender->Open(corpus_path, "a"));
-  CHECK_OK(features_appender->Open(features_path, "a"));
-  CHECK_OK(corpus_appender->Write(record.input));
-  CHECK_OK(features_appender->Write(
+  FUZZTEST_CHECK_OK(corpus_appender->Open(corpus_path, "a"));
+  FUZZTEST_CHECK_OK(features_appender->Open(features_path, "a"));
+  FUZZTEST_CHECK_OK(corpus_appender->Write(record.input));
+  FUZZTEST_CHECK_OK(features_appender->Write(
       PackFeaturesAndHash(record.input, record.feature_vec)));
 }
 
diff --git a/centipede/environment.cc b/centipede/environment.cc
index 443a611..16da62c 100644
--- a/centipede/environment.cc
+++ b/centipede/environment.cc
@@ -27,8 +27,6 @@
 #include "absl/base/no_destructor.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/flags/marshalling.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
@@ -46,7 +44,7 @@
 namespace {
 
 size_t ComputeTimeoutPerBatch(size_t timeout_per_input, size_t batch_size) {
-  CHECK_GT(batch_size, 0);
+  FUZZTEST_CHECK_GT(batch_size, 0);
   // NOTE: If `timeout_per_input` == 0, leave `timeout_per_batch` at 0 too:
   // the implementation interprets both as "no limit".
   if (timeout_per_input == 0) return 0;
@@ -117,18 +115,19 @@
 
 // Returns true if `value` is one of "1", "true".
 // Returns true if `value` is one of "0", "false".
-// CHECK-fails otherwise.
+// FUZZTEST_CHECK-fails otherwise.
 static bool GetBoolFlag(std::string_view value) {
   if (value == "0" || value == "false") return false;
-  CHECK(value == "1" || value == "true") << value;
+  FUZZTEST_CHECK(value == "1" || value == "true") << value;
   return true;
 }
 
-// Returns `value` as a size_t, CHECK-fails on parse error.
+// Returns `value` as a size_t, FUZZTEST_CHECK-fails on parse error.
 static size_t GetIntFlag(std::string_view value) {
   size_t result{};
-  CHECK(std::from_chars(value.data(), value.data() + value.size(), result).ec ==
-        std::errc())
+  FUZZTEST_CHECK(
+      std::from_chars(value.data(), value.data() + value.size(), result).ec ==
+      std::errc())
       << value;
   return result;
 }
@@ -169,7 +168,8 @@
     return;
   }
 
-  LOG(FATAL) << "Unknown flag for experiment: " << name << "=" << value;
+  FUZZTEST_LOG(FATAL) << "Unknown flag for experiment: " << name << "="
+                      << value;
 }
 
 void Environment::UpdateForExperiment() {
@@ -183,7 +183,7 @@
   std::vector<Experiment> experiments;
   for (auto flag : absl::StrSplit(this->experiment, ':', absl::SkipEmpty())) {
     std::vector<std::string> flag_and_value = absl::StrSplit(flag, '=');
-    CHECK_EQ(flag_and_value.size(), 2) << flag;
+    FUZZTEST_CHECK_EQ(flag_and_value.size(), 2) << flag;
     experiments.emplace_back(
         Experiment{flag_and_value[0], absl::StrSplit(flag_and_value[1], ',')});
   }
@@ -191,15 +191,15 @@
   // Count the number of flag combinations.
   size_t num_combinations = 1;
   for (const auto &exp : experiments) {
-    CHECK_NE(exp.flag_values.size(), 0) << exp.flag_name;
+    FUZZTEST_CHECK_NE(exp.flag_values.size(), 0) << exp.flag_name;
     num_combinations *= exp.flag_values.size();
   }
-  CHECK_GT(num_combinations, 0);
-  CHECK_EQ(num_threads % num_combinations, 0)
+  FUZZTEST_CHECK_GT(num_combinations, 0);
+  FUZZTEST_CHECK_EQ(num_threads % num_combinations, 0)
       << VV(num_threads) << VV(num_combinations);
 
   // Update the flags for the current shard and compute experiment_name.
-  CHECK_LT(my_shard_index, num_threads);
+  FUZZTEST_CHECK_LT(my_shard_index, num_threads);
   size_t my_combination_num = my_shard_index % num_combinations;
   experiment_name.clear();
   experiment_flags.clear();
@@ -228,14 +228,14 @@
   if (knobs_file_path.empty()) return;
   ByteArray knob_bytes;
   auto *f = ValueOrDie(RemoteFileOpen(knobs_file, "r"));
-  CHECK(f) << "Failed to open remote file " << knobs_file;
-  CHECK_OK(RemoteFileRead(f, knob_bytes));
-  CHECK_OK(RemoteFileClose(f));
-  VLOG(1) << "Knobs: " << knob_bytes.size() << " knobs read from "
-          << knobs_file;
+  FUZZTEST_CHECK(f) << "Failed to open remote file " << knobs_file;
+  FUZZTEST_CHECK_OK(RemoteFileRead(f, knob_bytes));
+  FUZZTEST_CHECK_OK(RemoteFileClose(f));
+  FUZZTEST_VLOG(1) << "Knobs: " << knob_bytes.size() << " knobs read from "
+                   << knobs_file;
   knobs.Set(knob_bytes);
   knobs.ForEachKnob([](std::string_view name, Knobs::value_type value) {
-    VLOG(1) << "knob " << name << ": " << static_cast<uint32_t>(value);
+    FUZZTEST_VLOG(1) << "knob " << name << ": " << static_cast<uint32_t>(value);
   });
 }
 
@@ -248,11 +248,11 @@
   // enough.
   if (max_num_crash_reports == Default().max_num_crash_reports) {
     max_num_crash_reports = 20;
-    LOG(INFO) << "Overriding the default max_num_crash_reports to "
-              << max_num_crash_reports << " for FuzzTest.";
+    FUZZTEST_LOG(INFO) << "Overriding the default max_num_crash_reports to "
+                       << max_num_crash_reports << " for FuzzTest.";
   }
   if (config.jobs != 0) {
-    CHECK(j == Default().j || j == config.jobs)
+    FUZZTEST_CHECK(j == Default().j || j == config.jobs)
         << "Value for --j is inconsistent with the value for jobs in the "
            "target binary:"
         << VV(j) << VV(config.jobs);
@@ -266,7 +266,7 @@
       [&](absl::Duration duration, absl::string_view duration_name) -> size_t {
     if (duration == absl::InfiniteDuration()) return 0;
     // Centipede's time-related fields are in seconds, so we need at least 1s.
-    CHECK_GE(duration, absl::Seconds(1))
+    FUZZTEST_CHECK_GE(duration, absl::Seconds(1))
         << duration_name << " must not be less than one second";
     return static_cast<size_t>(absl::ToInt64Seconds(duration));
   };
@@ -274,9 +274,9 @@
   // Update `timeout_per_input` and consequently `timeout_per_batch`.
   const size_t time_limit_per_input_sec =
       convert_to_seconds(config.time_limit_per_input, "Time limit per input");
-  CHECK(timeout_per_input == 0 ||
-        timeout_per_input == Default().timeout_per_input ||
-        timeout_per_input == time_limit_per_input_sec)
+  FUZZTEST_CHECK(timeout_per_input == 0 ||
+                 timeout_per_input == Default().timeout_per_input ||
+                 timeout_per_input == time_limit_per_input_sec)
       << "Value for --timeout_per_input is inconsistent with the value for "
          "time_limit_per_input in the target binary:"
       << VV(timeout_per_input) << VV(config.time_limit_per_input);
@@ -300,8 +300,8 @@
   constexpr auto bytes_to_mb = [](size_t bytes) {
     return bytes == 0 ? 0 : (bytes - 1) / 1024 / 1024 + 1;
   };
-  CHECK(rss_limit_mb == Default().rss_limit_mb ||
-        rss_limit_mb == bytes_to_mb(config.rss_limit))
+  FUZZTEST_CHECK(rss_limit_mb == Default().rss_limit_mb ||
+                 rss_limit_mb == bytes_to_mb(config.rss_limit))
       << "Value for --rss_limit_mb is inconsistent with the value for "
          "rss_limit in the target binary:"
       << VV(rss_limit_mb) << VV(config.rss_limit);
@@ -311,8 +311,8 @@
   constexpr auto bytes_to_kb = [](size_t bytes) {
     return bytes == 0 ? 0 : (bytes - 1) / 1024 + 1;
   };
-  CHECK(stack_limit_kb == Default().stack_limit_kb ||
-        stack_limit_kb == bytes_to_kb(config.stack_limit))
+  FUZZTEST_CHECK(stack_limit_kb == Default().stack_limit_kb ||
+                 stack_limit_kb == bytes_to_kb(config.stack_limit))
       << "Value for --stack_limit_kb is inconsistent with the value for "
          "stack_limit in the target binary:"
       << VV(stack_limit_kb) << VV(config.stack_limit);
@@ -327,8 +327,8 @@
 void Environment::UpdateTimeoutPerBatchIfEqualTo(size_t val) {
   if (timeout_per_batch != val) return;
   timeout_per_batch = ComputeTimeoutPerBatch(timeout_per_input, batch_size);
-  VLOG(1) << "--timeout_per_batch auto-computed: " << timeout_per_batch
-          << " sec (see --help for details)";
+  FUZZTEST_VLOG(1) << "--timeout_per_batch auto-computed: " << timeout_per_batch
+                   << " sec (see --help for details)";
 }
 
 void Environment::UpdateBinaryHashIfEmpty() {
diff --git a/centipede/environment.h b/centipede/environment.h
index aeaeb44..4871fc8 100644
--- a/centipede/environment.h
+++ b/centipede/environment.h
@@ -56,7 +56,7 @@
   Knobs knobs;  // Read from a file by `ReadKnobsFileIfSpecified`, see knobs.h.
 
   // Defines internal logging level. Set to zero to reduce logging in tests.
-  // TODO(ussuri): Retire in favor of VLOGs?
+  // TODO(ussuri): Retire in favor of FUZZTEST_VLOGs?
   size_t log_level = 1;
 
   // Path to a file with PCs. This file is created and the field is set in
@@ -103,7 +103,7 @@
   //   shard 5 will have {foo=2,bar=30},
   // and so on.
   //
-  // CHECK-fails if the `--experiment` flag is not well-formed,
+  // FUZZTEST_CHECK-fails if the `--experiment` flag is not well-formed,
   // or if num_threads is not a multiple of the number of flag combinations
   // (which is 6 in this example).
   //
@@ -113,7 +113,7 @@
   // which means "value #0 is used for foo and value #1 is used for bar".
   void UpdateForExperiment();
 
-  // Sets flag 'name' to `value` for an experiment. CHECK-fails on
+  // Sets flag 'name' to `value` for an experiment. FUZZTEST_CHECK-fails on
   // invalid name/value combination. Used in `UpdateForExperiment()`.
   void SetFlagForExperiment(std::string_view name, std::string_view value);
 
@@ -121,9 +121,9 @@
 
   // Reads `knobs` from `knobs_file`. Does nothing if the `knobs_file` is empty.
   void ReadKnobsFileIfSpecified();
-  // Updates `this` with `config` obtained from the target binary. CHECK-fails
-  // if the fields are non-default and inconsistent with the corresponding
-  // values in `config`.
+  // Updates `this` with `config` obtained from the target binary.
+  // FUZZTEST_CHECK-fails if the fields are non-default and inconsistent with
+  // the corresponding values in `config`.
   void UpdateWithTargetConfig(const fuzztest::internal::Configuration& config);
   // If `timeout_per_batch` is `val`, computes it as a function of
   // `timeout_per_input` and `batch_size` and updates it. Otherwise, leaves it
diff --git a/centipede/environment_flags.cc b/centipede/environment_flags.cc
index 72b3d1c..8db3381 100644
--- a/centipede/environment_flags.cc
+++ b/centipede/environment_flags.cc
@@ -20,8 +20,6 @@
 #include <vector>
 
 #include "absl/flags/flag.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_split.h"
 #include "absl/time/clock.h"
@@ -64,7 +62,7 @@
 absl::Time GetStopAtTime(absl::Time stop_at, absl::Duration stop_after) {
   const bool stop_at_is_non_default = stop_at != absl::InfiniteFuture();
   const bool stop_after_is_non_default = stop_after != absl::InfiniteDuration();
-  CHECK_LE(stop_at_is_non_default + stop_after_is_non_default, 1)
+  FUZZTEST_CHECK_LE(stop_at_is_non_default + stop_after_is_non_default, 1)
       << "At most one of --stop_at and --stop_after should be specified, "
          "including via --config file: "
       << VV(stop_at) << VV(stop_after);
@@ -106,12 +104,12 @@
     env_from_flags.num_threads = j;
     env_from_flags.my_shard_index = 0;
   }
-  CHECK_GE(env_from_flags.total_shards, 1);
-  CHECK_GE(env_from_flags.batch_size, 1);
-  CHECK_GE(env_from_flags.num_threads, 1);
-  CHECK_LE(env_from_flags.num_threads, env_from_flags.total_shards);
-  CHECK_LE(env_from_flags.my_shard_index + env_from_flags.num_threads,
-           env_from_flags.total_shards)
+  FUZZTEST_CHECK_GE(env_from_flags.total_shards, 1);
+  FUZZTEST_CHECK_GE(env_from_flags.batch_size, 1);
+  FUZZTEST_CHECK_GE(env_from_flags.num_threads, 1);
+  FUZZTEST_CHECK_LE(env_from_flags.num_threads, env_from_flags.total_shards);
+  FUZZTEST_CHECK_LE(env_from_flags.my_shard_index + env_from_flags.num_threads,
+                    env_from_flags.total_shards)
       << VV(env_from_flags.my_shard_index) << VV(env_from_flags.num_threads);
 
   if (!argv.empty()) {
@@ -126,7 +124,8 @@
         env_from_flags.clang_coverage_binary);
 
   if (absl::StrContains(env_from_flags.binary, "@@")) {
-    LOG(INFO) << "@@ detected; running in standalone mode with batch_size=1";
+    FUZZTEST_LOG(INFO)
+        << "@@ detected; running in standalone mode with batch_size=1";
     env_from_flags.has_input_wildcards = true;
     env_from_flags.batch_size = 1;
     // TODO(kcc): do we need to check if extra_binaries have @@?
diff --git a/centipede/environment_test.cc b/centipede/environment_test.cc
index f78c1be..a906b99 100644
--- a/centipede/environment_test.cc
+++ b/centipede/environment_test.cc
@@ -18,8 +18,8 @@
 #include <string_view>
 
 #include "gtest/gtest.h"
-#include "absl/log/check.h"
 #include "absl/time/time.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/configuration.h"
 
 namespace fuzztest::internal {
@@ -152,7 +152,7 @@
   fuzztest::internal::Configuration config;
   config.time_limit = absl::Seconds(123);
   config.time_budget_type = fuzztest::internal::TimeBudgetType::kPerTest;
-  CHECK(config.GetTimeLimitPerTest() == absl::Seconds(123));
+  FUZZTEST_CHECK(config.GetTimeLimitPerTest() == absl::Seconds(123));
   env.UpdateWithTargetConfig(config);
   EXPECT_EQ(env.timeout_per_batch, 123)
       << "`timeout_per_batch` should be set to the test time limit when it was "
diff --git a/centipede/feature.h b/centipede/feature.h
index 80cee6b..e69d756 100644
--- a/centipede/feature.h
+++ b/centipede/feature.h
@@ -22,7 +22,7 @@
 //
 // This library must not depend on anything other than libc so that fuzz targets
 // using it doesn't gain redundant coverage. For the same reason this library
-// uses raw __builtin_trap instead of CHECKs.
+// uses raw __builtin_trap instead of FUZZTEST_CHECKs.
 // We make an exception for <algorithm> for std::sort/std::unique,
 // since <algorithm> is very lightweight.
 // This library is also header-only, with all functions defined as inline.
diff --git a/centipede/feature_set.cc b/centipede/feature_set.cc
index 09d9361..f13cc5a 100644
--- a/centipede/feature_set.cc
+++ b/centipede/feature_set.cc
@@ -21,7 +21,6 @@
 #include <string>
 #include <string_view>
 
-#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "./centipede/control_flow.h"
 #include "./centipede/feature.h"
@@ -102,10 +101,10 @@
     // The less frequent is the domain, the more valuable are its features.
     auto domain_id = feature_domains::Domain::FeatureToDomainId(feature);
     auto features_in_domain = features_per_domain_[domain_id];
-    CHECK(features_in_domain);
+    FUZZTEST_CHECK(features_in_domain);
     auto domain_weight = num_features_ / features_in_domain;
     auto feature_frequency = frequencies_[feature];
-    CHECK_GT(feature_frequency, 0)
+    FUZZTEST_CHECK_GT(feature_frequency, 0)
         << VV(feature) << VV(domain_id) << VV(features_in_domain)
         << VV(domain_weight) << VV((int)feature_frequency) << DebugString();
     weight += domain_weight * (256 / feature_frequency);
diff --git a/centipede/feature_set.h b/centipede/feature_set.h
index ce05712..59a5341 100644
--- a/centipede/feature_set.h
+++ b/centipede/feature_set.h
@@ -22,10 +22,10 @@
 #include <ostream>
 #include <string>
 
-#include "absl/log/log.h"
 #include "./centipede/control_flow.h"
 #include "./centipede/feature.h"
 #include "./centipede/util.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 
@@ -111,7 +111,7 @@
     size_t domain_id = feature_domains::Domain::FeatureToDomainId(feature);
     // TODO(b/385774476): Remove this check once the root cause is fixed.
     if (domain_id >= feature_domains::kNumDomains) {
-      LOG(ERROR) << "Unexpected feature with id: " << feature;
+      FUZZTEST_LOG(WARNING) << "Unexpected feature with id: " << feature;
       return true;
     }
     return should_discard_domain_.test(domain_id);
diff --git a/centipede/hashed_ring_buffer.h b/centipede/hashed_ring_buffer.h
index f7bc646..86d555c 100644
--- a/centipede/hashed_ring_buffer.h
+++ b/centipede/hashed_ring_buffer.h
@@ -22,7 +22,7 @@
 //
 // This library must not depend on anything other than libc so that fuzz targets
 // using it doesn't gain redundant coverage. For the same reason this library
-// uses raw __builtin_trap instead of CHECKs.
+// uses raw __builtin_trap instead of FUZZTEST_CHECKs.
 // We make an exception for <algorithm> for std::sort/std::unique,
 // since <algorithm> is very lightweight.
 // This library is also header-only, with all functions defined as inline.
@@ -69,7 +69,8 @@
   // Resets the current state, sets the ring buffer size to `size_` (<= kSize).
   void Reset(size_t size) {
     memset(this, 0, sizeof(*this));
-    if (size > kSize) __builtin_trap();  // can't use CHECK in the runner.
+    if (size > kSize)
+      __builtin_trap();  // can't use FUZZTEST_CHECK in the runner.
     size_ = size;
     hash_.Reset(size);
   }
diff --git a/centipede/minimize_crash.cc b/centipede/minimize_crash.cc
index a9c081f..66d417a 100644
--- a/centipede/minimize_crash.cc
+++ b/centipede/minimize_crash.cc
@@ -23,8 +23,6 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/synchronization/mutex.h"
 #include "./centipede/centipede_callbacks.h"
 #include "./centipede/environment.h"
@@ -65,7 +63,7 @@
   // The crasher must be smaller than the original one.
   void AddCrasher(ByteArray crasher) {
     absl::MutexLock lock(&mutex_);
-    CHECK_LT(crasher.size(), crashers_.front().size());
+    FUZZTEST_CHECK_LT(crasher.size(), crashers_.front().size());
     crashers_.emplace_back(crasher);
     // Write the crasher to disk.
     auto hash = Hash(crasher);
@@ -96,13 +94,14 @@
 
   size_t num_batches = env.num_runs / env.batch_size;
   for (size_t i = 0; i < num_batches; ++i) {
-    LOG_EVERY_POW_2(INFO) << "[" << i << "] Minimizing... Interrupt to stop";
+    FUZZTEST_LOG_EVERY_POW_2(INFO)
+        << "[" << i << "] Minimizing... Interrupt to stop";
     if (ShouldStop()) break;
     // Get up to kMaxNumCrashersToGet most recent crashers. We don't want just
     // the most recent crasher to avoid being stuck in local minimum.
     constexpr size_t kMaxNumCrashersToGet = 20;
     const auto recent_crashers = queue.GetRecentCrashers(kMaxNumCrashersToGet);
-    CHECK(!recent_crashers.empty());
+    FUZZTEST_CHECK(!recent_crashers.empty());
     // Compute the minimal known crasher size.
     size_t min_known_size = recent_crashers.front().size();
     for (const auto &crasher : recent_crashers) {
@@ -125,10 +124,10 @@
     // Execute all mutants. If a new crasher is found, add it to `queue`.
     if (!callbacks->Execute(env.binary, smaller_mutants, batch_result)) {
       size_t crash_inputs_idx = batch_result.num_outputs_read();
-      CHECK_LT(crash_inputs_idx, smaller_mutants.size());
+      FUZZTEST_CHECK_LT(crash_inputs_idx, smaller_mutants.size());
       const auto &new_crasher = smaller_mutants[crash_inputs_idx];
-      LOG(INFO) << "Crasher: size: " << new_crasher.size() << ": "
-                << AsPrintableString(new_crasher, /*max_len=*/40);
+      FUZZTEST_LOG(INFO) << "Crasher: size: " << new_crasher.size() << ": "
+                         << AsPrintableString(new_crasher, /*max_len=*/40);
       queue.AddCrasher(new_crasher);
     }
   }
@@ -139,17 +138,17 @@
   ScopedCentipedeCallbacks scoped_callback(callbacks_factory, env);
   auto callbacks = scoped_callback.callbacks();
 
-  LOG(INFO) << "MinimizeCrash: trying the original crashy input";
+  FUZZTEST_LOG(INFO) << "MinimizeCrash: trying the original crashy input";
 
   BatchResult batch_result;
   ByteArray original_crashy_input(crashy_input.begin(), crashy_input.end());
   if (callbacks->Execute(env.binary, {original_crashy_input}, batch_result)) {
-    LOG(INFO) << "The original crashy input did not crash; exiting";
+    FUZZTEST_LOG(INFO) << "The original crashy input did not crash; exiting";
     return EXIT_FAILURE;
   }
 
-  LOG(INFO) << "Starting the crash minimization loop in " << env.num_threads
-            << "threads";
+  FUZZTEST_LOG(INFO) << "Starting the crash minimization loop in "
+                     << env.num_threads << "threads";
 
   MinimizerWorkQueue queue(WorkDir{env}.CrashReproducerDirPaths().MyShard(),
                            original_crashy_input);
diff --git a/centipede/pc_info.cc b/centipede/pc_info.cc
index 9d99cb5..bbabced 100644
--- a/centipede/pc_info.cc
+++ b/centipede/pc_info.cc
@@ -20,9 +20,9 @@
 #include <ostream>
 #include <string>
 
-#include "absl/log/check.h"
 #include "absl/types/span.h"
 #include "./common/defs.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 
@@ -34,11 +34,11 @@
   std::string input_string(std::istreambuf_iterator<char>(in), {});
 
   ByteArray pc_infos_as_bytes(input_string.begin(), input_string.end());
-  CHECK_EQ(pc_infos_as_bytes.size() % sizeof(PCInfo), 0);
+  FUZZTEST_CHECK_EQ(pc_infos_as_bytes.size() % sizeof(PCInfo), 0);
   size_t pc_table_size = pc_infos_as_bytes.size() / sizeof(PCInfo);
   const auto *pc_infos = reinterpret_cast<PCInfo *>(pc_infos_as_bytes.data());
   PCTable pc_table{pc_infos, pc_infos + pc_table_size};
-  CHECK_EQ(pc_table.size(), pc_table_size);
+  FUZZTEST_CHECK_EQ(pc_table.size(), pc_table_size);
 
   return pc_table;
 }
diff --git a/centipede/periodic_action.h b/centipede/periodic_action.h
index 302d9a0..8af5b21 100644
--- a/centipede/periodic_action.h
+++ b/centipede/periodic_action.h
@@ -19,7 +19,7 @@
 // Example:
 //   MyStats stats = ...;
 //   PeriodicAction stats_logger{
-//       [&stats]() { LOG(INFO) << "Current stats are: " << stats; },
+//       [&stats]() { FUZZTEST_LOG(INFO) << "Current stats are: " << stats; },
 //       {.delay = absl::Minutes(5), .interval = absl::Minutes(1)}
 //   };
 //   while (true) {
diff --git a/centipede/resource_pool.cc b/centipede/resource_pool.cc
index 28a2aec..a499a8f 100644
--- a/centipede/resource_pool.cc
+++ b/centipede/resource_pool.cc
@@ -19,14 +19,13 @@
 #include <thread>  // NOLINT: For thread IDs.
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/synchronization/mutex.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 #include "./centipede/rusage_stats.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 
@@ -44,7 +43,7 @@
 
 template <typename ResourceT>
 ResourcePool<ResourceT>::LeaseToken::~LeaseToken() {
-  CHECK(status_checked_)  //
+  FUZZTEST_CHECK(status_checked_)  //
       << "status() was never consulted by caller: " << *this;
   if (status_.ok()) {
     leaser_.ReturnLease(*this);
@@ -88,18 +87,18 @@
 template <typename ResourceT>
 ResourcePool<ResourceT>::ResourcePool(const ResourceT& quota)
     : quota_{quota}, pool_{quota} {
-  LOG(INFO) << "Creating pool with quota=[" << quota.ShortStr() << "]";
+  FUZZTEST_LOG(INFO) << "Creating pool with quota=[" << quota.ShortStr() << "]";
 }
 
 template <typename ResourceT>
 typename ResourcePool<ResourceT>::LeaseToken
 ResourcePool<ResourceT>::AcquireLeaseBlocking(LeaseRequest&& request) {
-  if (ABSL_VLOG_IS_ON(1)) {
+  if (FUZZTEST_VLOG_IS_ON(1)) {
     absl::ReaderMutexLock lock{&pool_mu_};
-    VLOG(1) << "Received lease request " << request.id           //
-            << "\nrequested: " << request.amount.FormattedStr()  //
-            << "\nquota:     " << quota_.FormattedStr()          //
-            << "\navailable: " << pool_.FormattedStr();
+    FUZZTEST_VLOG(1) << "Received lease request " << request.id           //
+                     << "\nrequested: " << request.amount.FormattedStr()  //
+                     << "\nquota:     " << quota_.FormattedStr()          //
+                     << "\navailable: " << pool_.FormattedStr();
   }
 
   if (request.amount == ResourceT::Zero()) {
@@ -123,7 +122,7 @@
     pool_mu_.AssertReaderHeld();
     const bool got_pool = request.amount <= pool_;
     if (!got_pool) {
-      VLOG(10)                                                     //
+      FUZZTEST_VLOG(10)                                            //
           << "Pending lease '" << request.id << "':"               //
           << "\nreq age   : " << request.age()                     //
           << "\navailable : " << pool_.FormattedStr()              //
@@ -138,7 +137,7 @@
   // the timeout is reached, proceed to the else-branch.
   if (pool_mu_.LockWhenWithTimeout(  //
           absl::Condition{&got_enough_free_pool}, request.timeout)) {
-    VLOG(1)                                                    //
+    FUZZTEST_VLOG(1)                                           //
         << "Granting lease " << request.id                     //
         << "\nreq age : " << request.age()                     //
         << "\nbefore  : " << pool_.FormattedStr()              //
@@ -161,7 +160,7 @@
 template <typename ResourceT>
 void ResourcePool<ResourceT>::ReturnLease(const LeaseToken& lease) {
   absl::WriterMutexLock lock{&pool_mu_};
-  VLOG(1)                                                              //
+  FUZZTEST_VLOG(1)                                                     //
       << "Returning lease " << lease.request().id                      //
       << "\nreq age   : " << lease.request().age()                     //
       << "\nlease age : " << lease.age()                               //
diff --git a/centipede/resource_pool.h b/centipede/resource_pool.h
index 241150f..c33a8ff 100644
--- a/centipede/resource_pool.h
+++ b/centipede/resource_pool.h
@@ -76,7 +76,7 @@
 //                 .amount = RUsageMemory{.mem_rss = EstimateShardPeakRss()},
 //                 .timeout = absl::Minutes(10),
 //             });
-//         CHECK_OK(rss_lease.status());
+//         FUZZTEST_CHECK_OK(rss_lease.status());
 //         ...
 //       }
 //       // `rss_lease` dtor returns the leased RSS to `rss_pool` and unblocks
@@ -138,7 +138,7 @@
 
     // The outcome of resource acquisition (ie. of
     // `ResourcePool::AcquireLeaseBlocking()`). Must be consulted by the client
-    // at least once, otherwise the dtor will CHECK.
+    // at least once, otherwise the dtor will FUZZTEST_CHECK.
     const absl::Status& status() const;
     // The originating request.
     const LeaseRequest& request() const;
diff --git a/centipede/resource_pool_test.cc b/centipede/resource_pool_test.cc
index 23bf03b..c5b3f5e 100644
--- a/centipede/resource_pool_test.cc
+++ b/centipede/resource_pool_test.cc
@@ -21,7 +21,6 @@
 #include <utility>
 
 #include "gtest/gtest.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
diff --git a/centipede/runner_fork_server.cc b/centipede/runner_fork_server.cc
index 7467f94..db99a7e 100644
--- a/centipede/runner_fork_server.cc
+++ b/centipede/runner_fork_server.cc
@@ -84,8 +84,8 @@
 }
 
 // Maybe writes the `reason` to stderr; then calls _exit. We use this instead of
-// CHECK/RunnerCheck since the fork server runs at the very early stage of the
-// process, where the logging functions used there may not work.
+// FUZZTEST_CHECK/RunnerCheck since the fork server runs at the very early stage
+// of the process, where the logging functions used there may not work.
 void Exit(const char *absl_nonnull reason) {
   Log(reason);
   _exit(0);  // The exit code does not matter, it won't be checked anyway.
diff --git a/centipede/runner_utils.h b/centipede/runner_utils.h
index ff3b044..efa2b10 100644
--- a/centipede/runner_utils.h
+++ b/centipede/runner_utils.h
@@ -26,7 +26,7 @@
 // as it is a more common pattern.
 void PrintErrorAndExitIf(bool condition, const char* absl_nonnull error);
 
-// A rough equivalent of "CHECK(condition) << error;".
+// A rough equivalent of "FUZZTEST_CHECK(condition) << error;".
 inline void RunnerCheck(bool condition, const char* absl_nonnull error) {
   PrintErrorAndExitIf(!condition, error);
 }
diff --git a/centipede/rusage_profiler.cc b/centipede/rusage_profiler.cc
index ae99463..a8b2ec4 100644
--- a/centipede/rusage_profiler.cc
+++ b/centipede/rusage_profiler.cc
@@ -29,8 +29,6 @@
 #include "absl/base/attributes.h"
 #include "absl/base/const_init.h"
 #include "absl/base/nullability.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/synchronization/mutex.h"
@@ -38,6 +36,7 @@
 #include "absl/time/time.h"
 #include "./centipede/periodic_action.h"
 #include "./centipede/rusage_stats.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 
@@ -102,7 +101,7 @@
 
 const RUsageProfiler::Snapshot& RUsageProfiler::Snapshot::Log() const {
   if (id >= 0) {
-    LOG(INFO).AtLocation(location.file, location.line)
+    FUZZTEST_LOG(INFO).AtLocation(location.file, location.line)
         << "PROFILER [P." << profiler_id << (profiler_desc.empty() ? "" : " ")
         << profiler_desc << "] SNAPSHOT [S." << id << (title.empty() ? "" : " ")
         << title << "]:\n"
@@ -214,7 +213,7 @@
         low_water >= kZero ? 0 :
         std::floor(std::abs(low_water / notch_size));
     // clang-format on
-    CHECK_GE(kBarNotches, notch_zero);
+    FUZZTEST_CHECK_GE(kBarNotches, notch_zero);
     // Print a zero mark only if a delta metric goes negative.
     std::string zero_mark = low_water < kZero ? "|" : "";
 
@@ -231,7 +230,7 @@
           notch_size == kZero
               ? kBarNotches : std::floor((current - low_water) / notch_size);
       // clang-format on
-      CHECK_GE(kBarNotches, notches);
+      FUZZTEST_CHECK_GE(kBarNotches, notches);
 
       if (!is_delta) {
         // Non-delta metrics can't go negative, so the bar always looks like
@@ -422,7 +421,7 @@
     bool also_log,                    //
     std::string title) {
   absl::WriterMutexLock lock{&mutex_};
-  CHECK(!timelapse_recorder_) << "StopTimelapse() wasn't called";
+  FUZZTEST_CHECK(!timelapse_recorder_) << "StopTimelapse() wasn't called";
   timelapse_recorder_ = std::make_unique<PeriodicAction>(
       [this, loc = std::move(loc), title = std::move(title), also_log]() {
         const auto& s = TakeSnapshot(loc, title);
@@ -433,7 +432,7 @@
 
 void RUsageProfiler::StopTimelapse() {
   absl::WriterMutexLock lock{&mutex_};
-  CHECK(timelapse_recorder_) << "StartTimelapse() wasn't called";
+  FUZZTEST_CHECK(timelapse_recorder_) << "StartTimelapse() wasn't called";
   timelapse_recorder_.reset();
 }
 
@@ -441,30 +440,31 @@
     SourceLocation loc, const std::string& title) {
   if (metrics_ == kMetricsOff) return;
 
-  // Logs streamed-in text to LOG(INFO), while dropping the usual log prefix
-  // (date/time/thread/source). LOG()'s limit on the size of a single message
-  // applies to one streamed text fragment only (if needed, this can be reduced
-  // even further to a single line of text in a fragment): this is the main
-  // purpose of this class, as profiling reports can get very long. especially
-  // with automatic timelapse snapshotting.
+  // Logs streamed-in text to FUZZTEST_LOG(INFO), while dropping the usual log
+  // prefix (date/time/thread/source). FUZZTEST_LOG()'s limit on the size of a
+  // single message applies to one streamed text fragment only (if needed, this
+  // can be reduced even further to a single line of text in a fragment): this
+  // is the main purpose of this class, as profiling reports can get very long.
+  // especially with automatic timelapse snapshotting.
   class ReportLogger final : public ReportSink {
    public:
     ReportLogger(SourceLocation loc) : loc_{loc} {}
 
     ~ReportLogger() override {
       if (!buffer_.empty()) {
-        LOG(INFO).AtLocation(loc_.file, loc_.line).NoPrefix() << buffer_;
+        FUZZTEST_LOG(INFO).AtLocation(loc_.file, loc_.line).NoPrefix()
+            << buffer_;
       }
     }
 
     ReportLogger& operator<<(std::string_view fragment) override {
       const auto last_newline = fragment.rfind('\n');
       if (last_newline == std::string_view::npos) {
-        // Accumulate no-'\n' fragments: LOG() always wraps around.
+        // Accumulate no-'\n' fragments: FUZZTEST_LOG() always wraps around.
         buffer_ += fragment;
       } else {
         // Now we can log, but save the last bit of text
-        LOG(INFO).AtLocation(loc_.file, loc_.line).NoPrefix()
+        FUZZTEST_LOG(INFO).AtLocation(loc_.file, loc_.line).NoPrefix()
             << buffer_ << fragment.substr(0, last_newline);
         buffer_ = fragment.substr(last_newline + 1);
       }
@@ -476,7 +476,7 @@
     std::string buffer_;
   };
 
-  LOG(INFO).AtLocation(loc.file, loc.line) << title << "\n";
+  FUZZTEST_LOG(INFO).AtLocation(loc.file, loc.line) << title << "\n";
   ReportLogger report_logger{loc};
   GenerateReport(&report_logger);
 }
diff --git a/centipede/rusage_profiler.h b/centipede/rusage_profiler.h
index 7e12b96..a45e6d3 100644
--- a/centipede/rusage_profiler.h
+++ b/centipede/rusage_profiler.h
@@ -106,18 +106,21 @@
 //    ...
 //    profiler.TakeSnapshot(ABSL_LOC).Log();  // Records and logs a snapshot
 //    ...
-//    VLOG(1) << profiler.TakeSnapshot(ABSL_LOC);  // A different way to log
+//    FUZZTEST_VLOG(1) << profiler.TakeSnapshot(ABSL_LOC);  // A different way
+//    to log
 //    ...
 //  }  // Dtor logs a final snapshot
 //
 //                           EXAMPLE USAGE - MACROS
 //
 //  void foo() {
-//    RPROF_THIS_FUNCTION(VLOG_IS_ON(2));  // Profile the function @ --v>=2
+//    RPROF_THIS_FUNCTION(FUZZTEST_VLOG_IS_ON(2));  // Profile the function @
+//    --v>=2
 //    ...
-//    RPROF_SNAPSHOT_AND_LOG();  // Record and log a function-level snapshot
-//    for (...) {
-//        RPROF_THIS_SCOPE(VLOG_IS_ON(3));  // Profile loop iterations @ --v>=3
+//    RPROF_SNAPSHOT_AND_FUZZTEST_LOG();  // Record and log a function-level
+//    snapshot for (...) {
+//        RPROF_THIS_SCOPE(FUZZTEST_VLOG_IS_ON(3));  // Profile loop iterations
+//        @ --v>=3
 //        ...
 //    }
 //    RPROF_SNAPSHOT();  // Record (not log) another function-level snapshot
@@ -261,9 +264,9 @@
     // table-like formatting.
     std::string ShortMetricsStr() const;
 
-    // Logs this snapshot to LOG(INFO). The source location that annotates the
-    // log message is set to `location` instead of the actual call's location.
-    // Returns *this so clients can do either of
+    // Logs this snapshot to FUZZTEST_LOG(INFO). The source location that
+    // annotates the log message is set to `location` instead of the actual
+    // call's location. Returns *this so clients can do either of
     //   Snapshot s = profiler.TakeSnapshot();
     //   Snapshot s = profiler.TakeSnapshot().Log();
     const Snapshot& Log() const;
@@ -289,8 +292,8 @@
   };
 
   // An abstract interface used to stream in a profiling report in
-  // GenerateReport(). Also used inside PrintReport() to overcome the LOG()'s
-  // limitation on the size of a single printed message.
+  // GenerateReport(). Also used inside PrintReport() to overcome the
+  // FUZZTEST_LOG()'s limitation on the size of a single printed message.
   class ReportSink {
    public:
     virtual ~ReportSink() = default;
@@ -529,7 +532,7 @@
 // earlier RPROF_THIS_FUNCTION() in the same function. An optional snapshot
 // title can be passed as a macro argument.
 // clang-format off
-#define RPROF_SNAPSHOT_AND_LOG(...) \
+#define RPROF_SNAPSHOT_AND_FUZZTEST_LOG(...) \
   FUNCTION_LEVEL_RPROF_NAME.TakeSnapshot( \
       {__FILE__, __LINE__}, ##__VA_ARGS__).Log()
 // clang-format on
@@ -550,7 +553,7 @@
 // RPROF_THIS_FUNCTION in the same function. An optional report title can be
 // passed as a macro argument.
 // clang-format off
-#define RPROF_DUMP_REPORT_TO_LOG(...) \
+#define RPROF_DUMP_REPORT_TO_FUZZTEST_LOG(...) \
   FUNCTION_LEVEL_RPROF_NAME.PrintReport({__FILE__, __LINE__}, ##__VA_ARGS__)
 // clang-format on
 
diff --git a/centipede/rusage_profiler_test.cc b/centipede/rusage_profiler_test.cc
index 3960dd4..c8c0b9f 100644
--- a/centipede/rusage_profiler_test.cc
+++ b/centipede/rusage_profiler_test.cc
@@ -23,10 +23,10 @@
 
 #include "gtest/gtest.h"
 #include "absl/flags/flag.h"
-#include "absl/log/log.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 #include "./centipede/rusage_stats.h"
+#include "./common/logging.h"
 
 ABSL_FLAG(bool, verbose, false, "Print extra info for debugging");
 ABSL_FLAG(bool, enable_system_load_sensitive_tests, false,
@@ -99,7 +99,7 @@
   RPROF_START_TIMELAPSE(absl::Seconds(1), /*also_log=*/true, "Timelapse");
   WasteTimeAndGobbleBytes();
   RPROF_STOP_TIMELAPSE();
-  RPROF_DUMP_REPORT_TO_LOG("Report");
+  RPROF_DUMP_REPORT_TO_FUZZTEST_LOG("Report");
 }
 
 // NOTE: Exclude this test from MSAN: 1) MSAN messes with the system memory
@@ -144,16 +144,18 @@
   const RUsageMemory delta_memory = after_memory - before_memory;
 
   if (absl::GetFlag(FLAGS_verbose)) {
-    LOG(INFO) << "before_snapshot:\n" << before_snapshot.FormattedMetricsStr();
-    LOG(INFO) << "after_snapshot:\n" << after_snapshot.FormattedMetricsStr();
-    LOG(INFO) << "";
-    LOG(INFO) << "before_timing: " << before_timing.FormattedStr();
-    LOG(INFO) << "after_timing:  " << after_timing.FormattedStr();
-    LOG(INFO) << "delta_timing:  " << delta_timing.FormattedStr();
-    LOG(INFO) << "";
-    LOG(INFO) << "before_memory: " << before_memory.FormattedStr();
-    LOG(INFO) << "after_memory:  " << after_memory.FormattedStr();
-    LOG(INFO) << "delta_memory:  " << delta_memory.FormattedStr();
+    FUZZTEST_LOG(INFO) << "before_snapshot:\n"
+                       << before_snapshot.FormattedMetricsStr();
+    FUZZTEST_LOG(INFO) << "after_snapshot:\n"
+                       << after_snapshot.FormattedMetricsStr();
+    FUZZTEST_LOG(INFO) << "";
+    FUZZTEST_LOG(INFO) << "before_timing: " << before_timing.FormattedStr();
+    FUZZTEST_LOG(INFO) << "after_timing:  " << after_timing.FormattedStr();
+    FUZZTEST_LOG(INFO) << "delta_timing:  " << delta_timing.FormattedStr();
+    FUZZTEST_LOG(INFO) << "";
+    FUZZTEST_LOG(INFO) << "before_memory: " << before_memory.FormattedStr();
+    FUZZTEST_LOG(INFO) << "after_memory:  " << after_memory.FormattedStr();
+    FUZZTEST_LOG(INFO) << "delta_memory:  " << delta_memory.FormattedStr();
   }
 
   EXPECT_EQ(after_snapshot.delta_timing,
@@ -172,7 +174,8 @@
   EXPECT_SYS_TIMING_NEAR(after_snapshot.timing, after_timing);
   // EXPECT_SYS_TIMING_NEAR(after_snapshot.delta_timing, delta_timing);
 #else
-  LOG(WARNING) << "Validation of some test results omitted under *SANs";
+  FUZZTEST_LOG(WARNING)
+      << "Validation of some test results omitted under *SANs";
 #endif
 
   if (absl::GetFlag(FLAGS_enable_system_load_sensitive_tests)) {
@@ -207,7 +210,8 @@
     EXPECT_TIME_NEAR(snapshots[i].time - snapshots[i - 1].time, kInterval, .05);
   }
 #else
-  LOG(WARNING) << "Validation of some test results omitted under *SANs";
+  FUZZTEST_LOG(WARNING)
+      << "Validation of some test results omitted under *SANs";
 #endif
 }
 
@@ -232,7 +236,7 @@
    public:
     ~ReportCapture() override = default;
     ReportCapture& operator<<(std::string_view fragment) override {
-      LOG(INFO).NoPrefix() << fragment;
+      FUZZTEST_LOG(INFO).NoPrefix() << fragment;
       return *this;
     }
   };
diff --git a/centipede/rusage_stats.cc b/centipede/rusage_stats.cc
index 8ca674b..ec5df9d 100644
--- a/centipede/rusage_stats.cc
+++ b/centipede/rusage_stats.cc
@@ -39,11 +39,11 @@
 #include <thread>  // NOLINT: For hardware_concurrency() only.
 
 #include "absl/base/nullability.h"
-#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 
@@ -102,7 +102,7 @@
 
   // Returns a path to the /proc/<pid>/<file> or /proc/<pid>/task/<tid>/<file>.
   [[nodiscard]] const std::string& GetProcFilePath(ProcFile file) const {
-    CHECK_LT(file, proc_file_paths_.size());
+    FUZZTEST_CHECK_LT(file, proc_file_paths_.size());
     return proc_file_paths_[file];
   }
 
@@ -366,7 +366,8 @@
   int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, scope.info().pid()};
   struct kinfo_proc info = {};
   size_t size = sizeof(info);
-  CHECK(sysctl(mib, sizeof(mib) / sizeof(mib[0]), &info, &size, NULL, 0) == 0)
+  FUZZTEST_CHECK(
+      sysctl(mib, sizeof(mib) / sizeof(mib[0]), &info, &size, NULL, 0) == 0)
       << "Error getting process information: " << strerror(errno);
   cpu_utilization = info.kp_proc.p_pctcpu;
 #else   // __APPLE__
@@ -429,7 +430,7 @@
 }
 
 RUsageTiming operator/(const RUsageTiming& t, int64_t div) {
-  CHECK_NE(div, 0);
+  FUZZTEST_CHECK_NE(div, 0);
   // NOTE: Can't use RUsageTimingOp() as this operation is asymmetrical.
   // clang-format off
   return RUsageTiming{
@@ -519,13 +520,13 @@
 #ifdef __APPLE__
   if (scope.info().pid() != getpid()) return {};
   struct proc_taskinfo pti = {};
-  CHECK(proc_pidinfo(scope.info().pid(), PROC_PIDTASKINFO, 0, &pti,
-                     PROC_PIDTASKINFO_SIZE) == PROC_PIDTASKINFO_SIZE)
+  FUZZTEST_CHECK(proc_pidinfo(scope.info().pid(), PROC_PIDTASKINFO, 0, &pti,
+                              PROC_PIDTASKINFO_SIZE) == PROC_PIDTASKINFO_SIZE)
       << "Unable to get system resource information";
   vsize = pti.pti_virtual_size;
   rss = pti.pti_resident_size;
   struct rusage rusage = {};
-  CHECK(getrusage(RUSAGE_SELF, &rusage) == 0)
+  FUZZTEST_CHECK(getrusage(RUSAGE_SELF, &rusage) == 0)
       << "Failed to get memory stats by getrusage";
   // `data` and `shared` are not supported in MacOS.
   // MacOS does not have a builtin way to query the peak size of virtual memory.
@@ -608,7 +609,7 @@
 }
 
 RUsageMemory operator/(const RUsageMemory& m, int64_t div) {
-  CHECK_NE(div, 0);
+  FUZZTEST_CHECK_NE(div, 0);
   // NOTE: Can't use RUsageMemoryOp() as this operation is asymmetrical.
   // clang-format off
   return RUsageMemory{
diff --git a/centipede/rusage_stats.h b/centipede/rusage_stats.h
index ad6d04e..d0d1cde 100644
--- a/centipede/rusage_stats.h
+++ b/centipede/rusage_stats.h
@@ -31,8 +31,8 @@
 #include <ostream>
 #include <string>
 
-#include "absl/log/check.h"
 #include "absl/time/time.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 
@@ -78,7 +78,7 @@
 
   const PlatformInfo& info() const {
     // This can fail only when called after the object is moved.
-    CHECK(info_ != nullptr);
+    FUZZTEST_CHECK(info_ != nullptr);
     return *info_;
   }
 
diff --git a/centipede/rusage_stats_test.cc b/centipede/rusage_stats_test.cc
index 6d4ea55..69d1a76 100644
--- a/centipede/rusage_stats_test.cc
+++ b/centipede/rusage_stats_test.cc
@@ -23,7 +23,6 @@
 #include "gtest/gtest.h"
 #include "absl/base/nullability.h"
 #include "absl/flags/flag.h"
-#include "absl/log/log.h"
 #include "absl/synchronization/barrier.h"
 #include "absl/synchronization/mutex.h"
 #include "absl/synchronization/notification.h"
@@ -208,9 +207,9 @@
     }
 
     if (absl::GetFlag(FLAGS_verbose)) {
-      LOG(INFO) << "before: " << before;
-      LOG(INFO) << "after:  " << after;
-      LOG(INFO) << "delta:  " << delta;
+      FUZZTEST_LOG(INFO) << "before: " << before;
+      FUZZTEST_LOG(INFO) << "after:  " << after;
+      FUZZTEST_LOG(INFO) << "delta:  " << delta;
     }
 
     EXPECT_EQ(delta.user_time, after.user_time - before.user_time);
@@ -220,10 +219,10 @@
 
   if (absl::GetFlag(FLAGS_enable_system_load_sensitive_tests)) {
     if (absl::GetFlag(FLAGS_verbose)) {
-      LOG(INFO) << "user_time_histo:\n" << user_time_histo;
-      LOG(INFO) << "cpu_util_histo:\n" << cpu_util_histo;
-      LOG(INFO) << "wall_time_histo:\n" << wall_time_histo;
-      LOG(INFO) << "cpu_cores_histo:\n" << cpu_cores_histo;
+      FUZZTEST_LOG(INFO) << "user_time_histo:\n" << user_time_histo;
+      FUZZTEST_LOG(INFO) << "cpu_util_histo:\n" << cpu_util_histo;
+      FUZZTEST_LOG(INFO) << "wall_time_histo:\n" << wall_time_histo;
+      FUZZTEST_LOG(INFO) << "cpu_cores_histo:\n" << cpu_cores_histo;
     }
 
     EXPECT_NEAR(  //
@@ -260,9 +259,9 @@
     const auto delta = after - before;
 
     if (absl::GetFlag(FLAGS_verbose)) {
-      LOG(INFO) << "before: " << before;
-      LOG(INFO) << "after:  " << after;
-      LOG(INFO) << "delta:  " << delta;
+      FUZZTEST_LOG(INFO) << "before: " << before;
+      FUZZTEST_LOG(INFO) << "after:  " << after;
+      FUZZTEST_LOG(INFO) << "delta:  " << delta;
     }
 
 // NOTE: The sanitizers heavily instrument the code and skew any time
@@ -280,15 +279,16 @@
     EXPECT_LE(before.mem_rss, before.mem_vsize);
     EXPECT_LE(after.mem_rss, after.mem_vsize);
 #else
-    LOG(WARNING) << "Validation of test results omitted under *SAN: see code";
+    FUZZTEST_LOG(WARNING)
+        << "Validation of test results omitted under *SAN: see code";
 #endif
     mem_rss_histo.Add(delta.mem_rss);
     mem_data_histo.Add(delta.mem_data);
   }
 
   if (absl::GetFlag(FLAGS_verbose)) {
-    LOG(INFO) << "mem_rss_histo:\n" << mem_rss_histo;
-    LOG(INFO) << "mem_data_histo:\n" << mem_data_histo;
+    FUZZTEST_LOG(INFO) << "mem_rss_histo:\n" << mem_rss_histo;
+    FUZZTEST_LOG(INFO) << "mem_data_histo:\n" << mem_data_histo;
   }
 
 // NOTE: The sanitizers heavily instrument the code and skew any time
@@ -302,22 +302,19 @@
   EXPECT_NEAR(mem_data_histo.Average(), kBytes, kDataLeeway) << mem_data_histo;
 #endif
 #else
-  LOG(WARNING) << "Validation of test results omitted under *SAN: see code";
+  FUZZTEST_LOG(WARNING)
+      << "Validation of test results omitted under *SAN: see code";
 #endif
 }
 
 TEST(RUsageMemoryTest, BadScope) {
   constexpr pid_t kBadPid = 999999999;
   EXPECT_NO_FATAL_FAILURE(  //
-      const auto timing =
-          RUsageTiming::Snapshot(RUsageScope::Process(kBadPid));
-      VLOG(1) << "Timing: " << timing;
-  );
+      const auto timing = RUsageTiming::Snapshot(RUsageScope::Process(kBadPid));
+      FUZZTEST_VLOG(1) << "Timing: " << timing;);
   EXPECT_NO_FATAL_FAILURE(  //
-      const auto memory =
-          RUsageMemory::Snapshot(RUsageScope::Process(kBadPid));
-      VLOG(1) << "Memory: " << memory;
-  );
+      const auto memory = RUsageMemory::Snapshot(RUsageScope::Process(kBadPid));
+      FUZZTEST_VLOG(1) << "Memory: " << memory;);
 }
 
 TEST(RUsageTimingTest, ConstantsAndMath) {
diff --git a/centipede/seed_corpus_maker.cc b/centipede/seed_corpus_maker.cc
index 695ce07..01830d8 100644
--- a/centipede/seed_corpus_maker.cc
+++ b/centipede/seed_corpus_maker.cc
@@ -18,35 +18,35 @@
 
 #include "absl/base/nullability.h"
 #include "absl/flags/flag.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "./centipede/config_init.h"
 #include "./centipede/seed_corpus_maker_flags.h"
 #include "./centipede/seed_corpus_maker_proto_lib.h"
 #include "./centipede/util.h"
+#include "./common/logging.h"
 #include "./common/remote_file.h"
 
 int main(int argc, char** absl_nonnull argv) {
   (void)fuzztest::internal::InitRuntime(argc, argv);
 
   const std::string config = absl::GetFlag(FLAGS_config);
-  QCHECK(!config.empty());
+  FUZZTEST_QCHECK(!config.empty());
   const std::string override_out_dir = absl::GetFlag(FLAGS_override_out_dir);
   const std::string binary_path = absl::GetFlag(FLAGS_coverage_binary_path);
   const std::string binary_name = std::filesystem::path{binary_path}.filename();
-  QCHECK(!binary_name.empty())
+  FUZZTEST_QCHECK(!binary_name.empty())
       << "--coverage_binary_path yields empty basename";
   std::string binary_hash = absl::GetFlag(FLAGS_coverage_binary_hash);
   if (binary_hash.empty()) {
-    QCHECK(fuzztest::internal::RemotePathExists(binary_path))
+    FUZZTEST_QCHECK(fuzztest::internal::RemotePathExists(binary_path))
         << "--coverage_binary_path doesn't exist";
     binary_hash = fuzztest::internal::HashOfFileContents(binary_path);
-    LOG(INFO) << "--coverage_binary_hash was not provided: computed "
-              << binary_hash
-              << " from actual file at --coverage_binary_path=" << binary_path;
+    FUZZTEST_LOG(INFO) << "--coverage_binary_hash was not provided: computed "
+                       << binary_hash
+                       << " from actual file at --coverage_binary_path="
+                       << binary_path;
   }
 
-  QCHECK_OK(fuzztest::internal::GenerateSeedCorpusFromConfigProto(  //
+  FUZZTEST_QCHECK_OK(fuzztest::internal::GenerateSeedCorpusFromConfigProto(  //
       config, binary_name, binary_hash, override_out_dir));
 
   return EXIT_SUCCESS;
diff --git a/centipede/seed_corpus_maker_lib.cc b/centipede/seed_corpus_maker_lib.cc
index 0a3c701..f1f588f 100644
--- a/centipede/seed_corpus_maker_lib.cc
+++ b/centipede/seed_corpus_maker_lib.cc
@@ -37,8 +37,6 @@
 #include <vector>
 
 #include "absl/container/flat_hash_set.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
 #include "absl/strings/match.h"
@@ -71,7 +69,7 @@
 
 std::string ShardPathsForLogging(  //
     const std::string& corpus_fname, const std::string& features_fname) {
-  if (ABSL_VLOG_IS_ON(3)) {
+  if (FUZZTEST_VLOG_IS_ON(3)) {
     return absl::StrCat(  //
         ":\nCorpus:  ", corpus_fname, "\nFeatures:", features_fname);
   }
@@ -93,13 +91,15 @@
                      coverage_binary_name, ", and ", coverage_binary_hash));
   }
 
-  RPROF_THIS_FUNCTION_WITH_TIMELAPSE(                                      //
-      /*enable=*/ABSL_VLOG_IS_ON(1),                                       //
-      /*timelapse_interval=*/absl::Seconds(ABSL_VLOG_IS_ON(2) ? 10 : 60),  //
-      /*also_log_timelapses=*/ABSL_VLOG_IS_ON(10));
+  RPROF_THIS_FUNCTION_WITH_TIMELAPSE(                   //
+      /*enable=*/FUZZTEST_VLOG_IS_ON(1),                //
+                                                        /*timelapse_interval=*/
+      absl::Seconds(FUZZTEST_VLOG_IS_ON(2) ? 10 : 60),  //
+      /*also_log_timelapses=*/FUZZTEST_VLOG_IS_ON(10));
 
-  LOG(INFO) << "Reading/sampling seed corpus elements from source glob: "
-            << source.dir_glob;
+  FUZZTEST_LOG(INFO)
+      << "Reading/sampling seed corpus elements from source glob: "
+      << source.dir_glob;
 
   // Find `source.dir_glob()`-matching dirs and pick at most
   // `source.num_recent_dirs()` most recent ones.
@@ -109,14 +109,14 @@
       !match_status.ok() && !absl::IsNotFound(match_status)) {
     return match_status;
   }
-  LOG(INFO) << "Found " << src_dirs.size() << " corpus dir(s) matching "
-            << source.dir_glob;
+  FUZZTEST_LOG(INFO) << "Found " << src_dirs.size()
+                     << " corpus dir(s) matching " << source.dir_glob;
   // Sort in the ascending lexicographical order. We expect that dir names
   // contain timestamps and therefore will be sorted from oldest to newest.
   std::sort(src_dirs.begin(), src_dirs.end(), std::less<std::string>());
   if (source.num_recent_dirs < src_dirs.size()) {
     src_dirs.erase(src_dirs.begin(), src_dirs.end() - source.num_recent_dirs);
-    LOG(INFO) << "Selected " << src_dirs.size() << " corpus dir(s)";
+    FUZZTEST_LOG(INFO) << "Selected " << src_dirs.size() << " corpus dir(s)";
   }
 
   // Find all the corpus shard and individual input files in the found dirs.
@@ -130,16 +130,16 @@
       const std::string glob = fs::path{dir} / source.shard_rel_glob;
       const auto match_status = RemoteGlobMatch(glob, matched_fnames);
       if (!match_status.ok() && !absl::IsNotFound(match_status)) {
-        LOG(ERROR) << "Got error when glob-matching in " << dir << ": "
-                   << match_status;
+        FUZZTEST_LOG(ERROR) << "Got error when glob-matching in " << dir << ": "
+                            << match_status;
       } else {
         current_corpus_shard_fnames.insert(matched_fnames.begin(),
                                            matched_fnames.end());
         corpus_shard_fnames.insert(corpus_shard_fnames.end(),
                                    matched_fnames.begin(),
                                    matched_fnames.end());
-        LOG(INFO) << "Found " << matched_fnames.size() << " shard(s) matching "
-                  << glob;
+        FUZZTEST_LOG(INFO) << "Found " << matched_fnames.size()
+                           << " shard(s) matching " << glob;
       }
     }
     if (!source.individual_input_rel_glob.empty()) {
@@ -147,8 +147,8 @@
       const std::string glob = fs::path{dir} / source.individual_input_rel_glob;
       const auto match_status = RemoteGlobMatch(glob, matched_fnames);
       if (!match_status.ok() && !absl::IsNotFound(match_status)) {
-        LOG(ERROR) << "Got error when glob-matching in " << dir << ": "
-                   << match_status;
+        FUZZTEST_LOG(ERROR) << "Got error when glob-matching in " << dir << ": "
+                            << match_status;
       } else {
         size_t num_added_individual_inputs = 0;
         for (auto& fname : matched_fnames) {
@@ -157,17 +157,18 @@
           ++num_added_individual_inputs;
           individual_input_fnames.push_back(std::move(fname));
         }
-        LOG(INFO) << "Found " << num_added_individual_inputs
-                  << " individual input(s) with glob " << glob;
+        FUZZTEST_LOG(INFO) << "Found " << num_added_individual_inputs
+                           << " individual input(s) with glob " << glob;
       }
     }
   }
-  LOG(INFO) << "Found " << corpus_shard_fnames.size() << " shard(s) and "
-            << individual_input_fnames.size()
-            << " individual input(s) total in source " << source.dir_glob;
+  FUZZTEST_LOG(INFO) << "Found " << corpus_shard_fnames.size()
+                     << " shard(s) and " << individual_input_fnames.size()
+                     << " individual input(s) total in source "
+                     << source.dir_glob;
 
   if (corpus_shard_fnames.empty() && individual_input_fnames.empty()) {
-    LOG(WARNING) << "Skipping empty source " << source.dir_glob;
+    FUZZTEST_LOG(WARNING) << "Skipping empty source " << source.dir_glob;
     return absl::OkStatus();
   }
 
@@ -205,8 +206,8 @@
                 ? work_dir.DistilledFeaturesFilePaths().MyShard()
                 : "";
 
-        VLOG(2) << "Reading elements from source shard " << shard
-                << ShardPathsForLogging(corpus_fname, features_fname);
+        FUZZTEST_VLOG(2) << "Reading elements from source shard " << shard
+                         << ShardPathsForLogging(corpus_fname, features_fname);
 
         ReadShard(corpus_fname, features_fname,
                   [shard, &shard_elts, &shard_elts_with_features](  //
@@ -219,21 +220,23 @@
                       ++shard_elts_with_features;
                     }
                     shard_elts.emplace_back(input, std::move(features));
-                    VLOG_EVERY_N(10, 100000)
+                    FUZZTEST_VLOG_EVERY_N(10, 100000)
                         << "Read " << shard_elts.size()
                         << " elements from shard " << shard << " so far";
                   });
 
-        LOG(INFO) << "Read " << shard_elts.size() << " elements ("
-                  << shard_elts_with_features
-                  << " with computed features) from source shard " << shard
-                  << ShardPathsForLogging(corpus_fname, features_fname);
+        FUZZTEST_LOG(INFO) << "Read " << shard_elts.size() << " elements ("
+                           << shard_elts_with_features
+                           << " with computed features) from source shard "
+                           << shard
+                           << ShardPathsForLogging(corpus_fname,
+                                                   features_fname);
       };
 
       threads.Schedule(read_shard);
     }
 
-    RPROF_SNAPSHOT_AND_LOG("Done reading shards");
+    RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Done reading shards");
 
     src_elts.resize(individual_input_fnames.size());
     for (size_t index = 0; index < individual_input_fnames.size(); ++index) {
@@ -242,8 +245,8 @@
         const auto& path = individual_input_fnames[index];
         const auto read_status = RemoteFileGetContents(path, input);
         if (!read_status.ok()) {
-          LOG(WARNING) << "Skipping individual input path " << path
-                       << " due to read error: " << read_status;
+          FUZZTEST_LOG(WARNING) << "Skipping individual input path " << path
+                                << " due to read error: " << read_status;
           return;
         }
         src_elts[index] = {std::move(input), {}};
@@ -251,7 +254,7 @@
     }
   }
 
-  RPROF_SNAPSHOT_AND_LOG("Done reading");
+  RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Done reading");
 
   size_t src_num_features = 0;
 
@@ -270,21 +273,22 @@
   src_elts_with_features_per_shard.clear();
   src_elts_with_features_per_shard.shrink_to_fit();
 
-  RPROF_SNAPSHOT_AND_LOG("Done merging");
+  RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Done merging");
 
   // Remove empty inputs possibly due to read errors.
   auto remove_it =
       std::remove_if(src_elts.begin(), src_elts.end(),
                      [](const auto& elt) { return std::get<0>(elt).empty(); });
   if (remove_it != src_elts.end()) {
-    LOG(WARNING) << "Removed " << std::distance(remove_it, src_elts.end())
-                 << " empty inputs";
+    FUZZTEST_LOG(WARNING) << "Removed "
+                          << std::distance(remove_it, src_elts.end())
+                          << " empty inputs";
     src_elts.erase(remove_it, src_elts.end());
   }
 
-  LOG(INFO) << "Read total of " << src_elts.size() << " elements ("
-            << src_num_features << " with features) from source "
-            << source.dir_glob;
+  FUZZTEST_LOG(INFO) << "Read total of " << src_elts.size() << " elements ("
+                     << src_num_features << " with features) from source "
+                     << source.dir_glob;
 
   // Extract a sample of the elements of the size specified in
   // `source.sample_size`.
@@ -306,10 +310,10 @@
   }
 
   if (sample_size < src_elts.size()) {
-    LOG(INFO) << "Sampling " << sample_size << " elements out of "
-              << src_elts.size();
+    FUZZTEST_LOG(INFO) << "Sampling " << sample_size << " elements out of "
+                       << src_elts.size();
   } else {
-    LOG(INFO) << "Using all " << src_elts.size() << " elements";
+    FUZZTEST_LOG(INFO) << "Using all " << src_elts.size() << " elements";
   }
 
   // Extract a sample by shuffling the elements' indices and resizing to the
@@ -321,7 +325,7 @@
   std::shuffle(src_sample_idxs.begin(), src_sample_idxs.end(), absl::BitGen{});
   src_sample_idxs.resize(sample_size);
 
-  RPROF_SNAPSHOT_AND_LOG("Done sampling");
+  RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Done sampling");
 
   // Now move each sampled element from `src_elts` to `elements`.
   elements.reserve(elements.size() + sample_size);
@@ -329,7 +333,7 @@
     elements.emplace_back(std::move(src_elts[idx]));
   }
 
-  RPROF_SNAPSHOT_AND_LOG("Done appending");
+  RPROF_SNAPSHOT_AND_FUZZTEST_LOG("Done appending");
   return absl::OkStatus();
 }
 
@@ -356,13 +360,15 @@
         "Unable to write seed corpus to empty destination path");
   }
 
-  RPROF_THIS_FUNCTION_WITH_TIMELAPSE(                                      //
-      /*enable=*/ABSL_VLOG_IS_ON(1),                                       //
-      /*timelapse_interval=*/absl::Seconds(ABSL_VLOG_IS_ON(2) ? 10 : 60),  //
-      /*also_log_timelapses=*/ABSL_VLOG_IS_ON(10));
+  RPROF_THIS_FUNCTION_WITH_TIMELAPSE(                   //
+      /*enable=*/FUZZTEST_VLOG_IS_ON(1),                //
+                                                        /*timelapse_interval=*/
+      absl::Seconds(FUZZTEST_VLOG_IS_ON(2) ? 10 : 60),  //
+      /*also_log_timelapses=*/FUZZTEST_VLOG_IS_ON(10));
 
-  LOG(INFO) << "Writing " << elements.size()
-            << " seed corpus elements to destination: " << destination.dir_path;
+  FUZZTEST_LOG(INFO) << "Writing " << elements.size()
+                     << " seed corpus elements to destination: "
+                     << destination.dir_path;
 
   if (destination.num_shards <= 0) {
     return absl::InvalidArgumentError(
@@ -379,7 +385,7 @@
   // first N shards.
   const size_t num_shards =
       std::min<size_t>(destination.num_shards, elements.size());
-  CHECK_GT(num_shards, 0);
+  FUZZTEST_CHECK_GT(num_shards, 0);
   const size_t shard_size = elements.size() / num_shards;
   std::vector<size_t> shard_sizes(num_shards, shard_size);
   const size_t excess_elts = elements.size() % num_shards;
@@ -402,7 +408,7 @@
       const auto elt_range_begin = shard_elt_it;
       std::advance(shard_elt_it, shard_size);
       const auto elt_range_end = shard_elt_it;
-      CHECK(shard_elt_it <= elements.cend()) << VV(shard);
+      FUZZTEST_CHECK(shard_elt_it <= elements.cend()) << VV(shard);
 
       const auto write_shard = [shard, elt_range_begin, elt_range_end,
                                 coverage_binary_name, coverage_binary_hash,
@@ -436,11 +442,12 @@
             work_dir.CorpusFilePaths().IsShard(corpus_fname)
                 ? work_dir.FeaturesFilePaths().MyShard()
                 : work_dir.DistilledFeaturesFilePaths().MyShard();
-        CHECK(!features_fname.empty());
+        FUZZTEST_CHECK(!features_fname.empty());
 
-        VLOG(2) << "Writing " << std::distance(elt_range_begin, elt_range_end)
-                << " elements to destination shard " << shard
-                << ShardPathsForLogging(corpus_fname, features_fname);
+        FUZZTEST_VLOG(2) << "Writing "
+                         << std::distance(elt_range_begin, elt_range_end)
+                         << " elements to destination shard " << shard
+                         << ShardPathsForLogging(corpus_fname, features_fname);
 
         // Features files are always saved in a subdir of the workdir
         // (== `destination.dir_path` here), which might not exist yet, so we
@@ -463,12 +470,12 @@
 
         const std::unique_ptr<BlobFileWriter> corpus_writer =
             DefaultBlobFileWriterFactory();
-        CHECK(corpus_writer != nullptr);
+        FUZZTEST_CHECK(corpus_writer != nullptr);
         RETURN_IF_NOT_OK(corpus_writer->Open(corpus_fname, "w"));
 
         const std::unique_ptr<BlobFileWriter> features_writer =
             DefaultBlobFileWriterFactory();
-        CHECK(features_writer != nullptr);
+        FUZZTEST_CHECK(features_writer != nullptr);
         RETURN_IF_NOT_OK(features_writer->Open(features_fname, "w"));
 
         // Write the shard's elements to the corpus and features shard files.
@@ -486,10 +493,12 @@
           }
         }
 
-        LOG(INFO) << "Wrote " << std::distance(elt_range_begin, elt_range_end)
-                  << " elements (" << shard_elts_with_features
-                  << " with features) to destination shard " << shard
-                  << ShardPathsForLogging(corpus_fname, features_fname);
+        FUZZTEST_LOG(INFO) << "Wrote "
+                           << std::distance(elt_range_begin, elt_range_end)
+                           << " elements (" << shard_elts_with_features
+                           << " with features) to destination shard " << shard
+                           << ShardPathsForLogging(corpus_fname,
+                                                   features_fname);
 
         dst_elts_with_features += shard_elts_with_features;
 
@@ -506,10 +515,10 @@
     RETURN_IF_NOT_OK(write_status);
   }
 
-  LOG(INFO) << "Wrote total of " << elements.size() << " elements ("
-            << dst_elts_with_features
-            << " with precomputed features) to destination "
-            << destination.dir_path;
+  FUZZTEST_LOG(INFO) << "Wrote total of " << elements.size() << " elements ("
+                     << dst_elts_with_features
+                     << " with precomputed features) to destination "
+                     << destination.dir_path;
   return absl::OkStatus();
 }
 
@@ -524,19 +533,19 @@
     RETURN_IF_NOT_OK(SampleSeedCorpusElementsFromSource(  //
         source, coverage_binary_name, coverage_binary_hash, elements));
   }
-  LOG(INFO) << "Sampled " << elements.size() << " elements from "
-            << config.sources.size() << " seed corpus source(s)";
+  FUZZTEST_LOG(INFO) << "Sampled " << elements.size() << " elements from "
+                     << config.sources.size() << " seed corpus source(s)";
 
   // Write the sampled elements to the destination.
   if (elements.empty()) {
-    LOG(WARNING)
+    FUZZTEST_LOG(WARNING)
         << "No elements to write to seed corpus destination - doing nothing";
   } else {
     RETURN_IF_NOT_OK(WriteSeedCorpusElementsToDestination(  //
         elements, coverage_binary_name, coverage_binary_hash,
         config.destination));
-    LOG(INFO) << "Wrote " << elements.size()
-              << " elements to seed corpus destination";
+    FUZZTEST_LOG(INFO) << "Wrote " << elements.size()
+                       << " elements to seed corpus destination";
   }
   return absl::OkStatus();
 }
diff --git a/centipede/seed_corpus_maker_lib_test.cc b/centipede/seed_corpus_maker_lib_test.cc
index 2be35f0..d749ca3 100644
--- a/centipede/seed_corpus_maker_lib_test.cc
+++ b/centipede/seed_corpus_maker_lib_test.cc
@@ -25,7 +25,6 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "./centipede/feature.h"
 #include "./centipede/workdir.h"
@@ -207,7 +206,7 @@
         /*shard_index_digits=*/kIdxDigits,
         /*num_shards=*/kNumShards,
     };
-    CHECK_OK(WriteSeedCorpusElementsToDestination(  //
+    FUZZTEST_CHECK_OK(WriteSeedCorpusElementsToDestination(  //
         kShardedInputs, kCovBin, kCovHash, destination));
     const std::string workdir = (test_dir / kRelDir).c_str();
     ASSERT_NO_FATAL_FAILURE(VerifyShardsExist(  //
@@ -218,7 +217,8 @@
   for (int i = 0; i < kIndividualInputs.size(); ++i) {
     const auto path = std::filesystem::path(test_dir) / kRelDir /
                       absl::StrCat("individual_input_", i);
-    CHECK_OK(RemoteFileSetContents(path.string(), kIndividualInputs[i]));
+    FUZZTEST_CHECK_OK(
+        RemoteFileSetContents(path.string(), kIndividualInputs[i]));
   }
 
   // Test that sharded and individual inputs matches what we wrote.
diff --git a/centipede/seed_corpus_maker_proto_lib.cc b/centipede/seed_corpus_maker_proto_lib.cc
index 80ae4c9..fd44c58 100644
--- a/centipede/seed_corpus_maker_proto_lib.cc
+++ b/centipede/seed_corpus_maker_proto_lib.cc
@@ -19,7 +19,6 @@
 #include <utility>
 #include <variant>
 
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -48,16 +47,18 @@
   }
 
   if (RemotePathExists(config_spec)) {
-    LOG(INFO) << "Config spec points at an existing file; trying to parse "
-                 "textproto config from it: "
-              << VV(config_spec);
+    FUZZTEST_LOG(INFO)
+        << "Config spec points at an existing file; trying to parse "
+           "textproto config from it: "
+        << VV(config_spec);
     RETURN_IF_NOT_OK(RemoteFileGetContents(config_spec, config_str));
-    LOG(INFO) << "Raw config read from file:\n" << config_str;
+    FUZZTEST_LOG(INFO) << "Raw config read from file:\n" << config_str;
     base_dir = std::filesystem::path{config_spec}.parent_path();
   } else {
-    LOG(INFO) << "Config spec is not a file, or file doesn't exist; trying to "
-                 "parse textproto config verbatim: "
-              << VV(config_spec);
+    FUZZTEST_LOG(INFO)
+        << "Config spec is not a file, or file doesn't exist; trying to "
+           "parse textproto config verbatim: "
+        << VV(config_spec);
     config_str = config_spec;
     base_dir = fs::current_path();
   }
@@ -73,7 +74,7 @@
                      "destination, config_spec: ",
                      config_spec, ", config: ", config));
   }
-  LOG(INFO) << "Parsed config:\n" << config;
+  FUZZTEST_LOG(INFO) << "Parsed config:\n" << config;
 
   // Resolve relative `source.dir_glob`s in the config to absolute ones.
   for (auto& src : *config.mutable_sources()) {
@@ -99,7 +100,7 @@
         WorkDir::kDigitsInShardIndex);
   }
 
-  LOG(INFO) << "Resolved config:\n" << config;
+  FUZZTEST_LOG(INFO) << "Resolved config:\n" << config;
 
   return config;
 }
@@ -164,7 +165,7 @@
       const proto::SeedCorpusConfig config_proto,
       ResolveSeedCorpusConfigProto(config_spec, override_out_dir));
   if (config_proto.sources_size() == 0 || !config_proto.has_destination()) {
-    LOG(WARNING) << "Config is empty: skipping seed corpus generation";
+    FUZZTEST_LOG(WARNING) << "Config is empty: skipping seed corpus generation";
     return absl::OkStatus();
   }
   RETURN_IF_NOT_OK(DumpConfigProtoToDebugDir(config_proto, coverage_binary_name,
diff --git a/centipede/stats.cc b/centipede/stats.cc
index 748c6f5..50225ed 100644
--- a/centipede/stats.cc
+++ b/centipede/stats.cc
@@ -34,8 +34,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
@@ -60,7 +58,7 @@
 StatsReporter::StatsReporter(const std::vector<std::atomic<Stats>> &stats_vec,
                              const std::vector<Environment> &env_vec)
     : stats_vec_{stats_vec}, env_vec_{env_vec} {
-  CHECK_EQ(stats_vec.size(), env_vec.size());
+  FUZZTEST_CHECK_EQ(stats_vec.size(), env_vec.size());
   for (size_t i = 0; i < env_vec.size(); ++i) {
     const auto &env = env_vec[i];
     group_to_indices_[env.experiment_name].push_back(i);
@@ -162,7 +160,8 @@
 }
 
 void StatsLogger::DoneFieldSamplesBatch() {
-  LOG(INFO) << "Current stats:\n" << absl::StripAsciiWhitespace(os_.str());
+  FUZZTEST_LOG(INFO) << "Current stats:\n"
+                     << absl::StripAsciiWhitespace(os_.str());
   // Reset the stream for the next round of logging.
   os_.str("");
 }
@@ -173,7 +172,7 @@
 StatsCsvFileAppender::~StatsCsvFileAppender() {
   if (files_ == nullptr) return;
   for (const auto &[group_name, file] : *files_) {
-    CHECK_OK(RemoteFileClose(file.file));
+    FUZZTEST_CHECK_OK(RemoteFileClose(file.file));
   }
 }
 
@@ -195,7 +194,7 @@
 }
 
 void StatsCsvFileAppender::SetCurrGroup(const Environment &master_env) {
-  CHECK(files_ != nullptr);
+  FUZZTEST_CHECK(files_ != nullptr);
   BufferedRemoteFile &file = (*files_)[master_env.experiment_name];
   if (file.file == nullptr) {
     const std::string filename =
@@ -208,20 +207,21 @@
     bool append = false;
     if (RemotePathExists(filename)) {
       std::string contents;
-      CHECK_OK(RemoteFileGetContents(filename, contents));
+      FUZZTEST_CHECK_OK(RemoteFileGetContents(filename, contents));
       // NOTE: `csv_header_` ends with '\n', so the match is exact.
       if (absl::StartsWith(contents, csv_header_)) {
         append = true;
       } else {
         append = false;
-        CHECK_OK(RemoteFileSetContents(GetBackupFilename(filename), contents));
+        FUZZTEST_CHECK_OK(
+            RemoteFileSetContents(GetBackupFilename(filename), contents));
       }
     }
     file.file = *RemoteFileOpen(filename, append ? "a" : "w");
-    CHECK(file.file != nullptr) << VV(filename);
+    FUZZTEST_CHECK(file.file != nullptr) << VV(filename);
     if (!append) {
-      CHECK_OK(RemoteFileAppend(file.file, csv_header_));
-      CHECK_OK(RemoteFileFlush(file.file));
+      FUZZTEST_CHECK_OK(RemoteFileAppend(file.file, csv_header_));
+      FUZZTEST_CHECK_OK(RemoteFileFlush(file.file));
     }
   }
   // This is OK even though hash maps provide no pointer stability because the
@@ -245,7 +245,7 @@
   }
   double avg = !values.empty() ? (1.0 * sum / values.size()) : 0;
 
-  CHECK(curr_file_ != nullptr);
+  FUZZTEST_CHECK(curr_file_ != nullptr);
   std::string &values_str = curr_file_->buffer;
   if (curr_field_info_.traits & TraitBits::kMin)
     absl::StrAppendFormat(&values_str, "%" PRIu64 ",", min);
@@ -263,10 +263,11 @@
 }
 
 void StatsCsvFileAppender::DoneFieldSamplesBatch() {
-  CHECK(files_ != nullptr);
+  FUZZTEST_CHECK(files_ != nullptr);
   for (auto &[group_name, file] : *files_) {
-    CHECK_OK(RemoteFileAppend(file.file, absl::StrCat(file.buffer, "\n")));
-    CHECK_OK(RemoteFileFlush(file.file));
+    FUZZTEST_CHECK_OK(
+        RemoteFileAppend(file.file, absl::StrCat(file.buffer, "\n")));
+    FUZZTEST_CHECK_OK(RemoteFileFlush(file.file));
     file.buffer.clear();
   }
 }
@@ -286,7 +287,7 @@
 void PrintRewardValues(absl::Span<const std::atomic<Stats>> stats_vec,
                        std::ostream &os) {
   size_t n = stats_vec.size();
-  CHECK_GT(n, 0);
+  FUZZTEST_CHECK_GT(n, 0);
   std::vector<size_t> num_covered_pcs(n);
   for (size_t i = 0; i < n; ++i) {
     num_covered_pcs[i] = stats_vec[i].load().num_covered_pcs;
diff --git a/centipede/stats.h b/centipede/stats.h
index 603afcc..635533d 100644
--- a/centipede/stats.h
+++ b/centipede/stats.h
@@ -514,8 +514,9 @@
 inline StatsReporter::StatsReporter(StatsReporter &&) noexcept = default;
 
 // Takes a set of `Stats` objects and a corresponding set of `Environment`
-// objects and logs the current `Stats` values to LOG(INFO) on each invocation
-// of `ReportCurrStats()`. If the environments indicate the use of the
+// objects and logs the current `Stats` values to FUZZTEST_LOG(INFO) on each
+// invocation of `ReportCurrStats()`. If the environments indicate the use of
+// the
 // --experiment flag, the stats for each of the experiment are juxtaposed for
 // easy visual comparison.
 class StatsLogger : public StatsReporter {
diff --git a/centipede/stats_test.cc b/centipede/stats_test.cc
index d21221a..491a428 100644
--- a/centipede/stats_test.cc
+++ b/centipede/stats_test.cc
@@ -25,7 +25,6 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "absl/log/check.h"
 #include "absl/log/log_entry.h"
 #include "absl/log/log_sink.h"
 #include "absl/log/log_sink_registry.h"
@@ -847,7 +846,8 @@
     ReadFromLocalFile(kExpectedCsvBak, contents_bak);
     const std::vector<std::string> lines_bak =
         absl::StrSplit(contents_bak, '\n');
-    CHECK_NE(lines.size(), kFakeOldCsvLines.size());  // Prevent false positives
+    FUZZTEST_CHECK_NE(lines.size(),
+                      kFakeOldCsvLines.size());  // Prevent false positives
     EXPECT_EQ(lines_bak.size(), kFakeOldCsvLines.size());
   }
 }
diff --git a/centipede/symbol_table.cc b/centipede/symbol_table.cc
index d6aecb4..2168c00 100644
--- a/centipede/symbol_table.cc
+++ b/centipede/symbol_table.cc
@@ -27,8 +27,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
@@ -68,13 +66,15 @@
   if (lines_view.size() == 1 && lines_view.back().empty()) return;
 
   while (!lines_view.empty()) {
-    CHECK_GE(lines_view.size(), 3) << "Unexpected symbolizer output format.";
+    FUZZTEST_CHECK_GE(lines_view.size(), 3)
+        << "Unexpected symbolizer output format.";
 
     std::string_view func = lines_view[0];
     std::string_view file = lines_view[1];
     std::string_view empty = lines_view[2];
-    CHECK(empty.empty()) << "Unexpected symbolizer output format: " << VV(func)
-                         << VV(file) << VV(empty);
+    FUZZTEST_CHECK(empty.empty())
+        << "Unexpected symbolizer output format: " << VV(func) << VV(file)
+        << VV(empty);
     for (auto &useless_prefix : {"/proc/self/cwd/", "./"}) {
       file = absl::StripPrefix(file, useless_prefix);
     }
@@ -113,8 +113,8 @@
   WriteToLocalFile(pcs_file.path(), pcs_string);
 
   // Run the symbolizer.
-  LOG(INFO) << "Symbolizing " << pc_infos.size() << " PCs from "
-            << dso_basename;
+  FUZZTEST_LOG(INFO) << "Symbolizing " << pc_infos.size() << " PCs from "
+                     << dso_basename;
   Command::Options cmd_options;
   cmd_options.args = {
       "--no-inlines",
@@ -127,8 +127,9 @@
   Command cmd{symbolizer_path, std::move(cmd_options)};
   int exit_code = cmd.Execute();
   if (exit_code != EXIT_SUCCESS) {
-    LOG(ERROR) << "Symbolization failed, debug symbols will not be used: "
-               << VV(dso_path) << VV(cmd.ToString()) << VV(exit_code);
+    FUZZTEST_LOG(ERROR)
+        << "Symbolization failed, debug symbols will not be used: "
+        << VV(dso_path) << VV(cmd.ToString()) << VV(exit_code);
     return;
   }
 
@@ -139,9 +140,10 @@
   size_t new_size = size();
   size_t added_size = new_size - old_size;
   if (added_size != pc_infos.size()) {
-    LOG(ERROR) << "Symbolization failed: debug symbols will not be used: "
-               << VV(dso_path) << VV(cmd.ToString()) << VV(exit_code)
-               << VV(pc_infos.size()) << VV(added_size);
+    FUZZTEST_LOG(ERROR)
+        << "Symbolization failed: debug symbols will not be used: "
+        << VV(dso_path) << VV(cmd.ToString()) << VV(exit_code)
+        << VV(pc_infos.size()) << VV(added_size);
   }
 }
 
@@ -152,12 +154,14 @@
   // NOTE: --symbolizer_path=/dev/null is a somewhat expected alternative to
   // "" that users might pass.
   if (symbolizer_path.empty() || symbolizer_path == "/dev/null") {
-    LOG(WARNING) << "Symbolizer unspecified: debug symbols will not be used";
+    FUZZTEST_LOG(WARNING)
+        << "Symbolizer unspecified: debug symbols will not be used";
     SetAllToUnknown(pc_table.size());
     return;
   }
 
-  LOG(INFO) << "Symbolizing " << dso_table.size() << " instrumented DSOs.";
+  FUZZTEST_LOG(INFO) << "Symbolizing " << dso_table.size()
+                     << " instrumented DSOs.";
 
   // Iterate all DSOs, symbolize their respective PCs.
   // Symbolizing the PCs can take time, so we
@@ -173,7 +177,8 @@
     for (size_t dso_id = 0; dso_id < dso_table.size(); ++dso_id) {
       const auto &dso_info = dso_table[dso_id];
       auto &symbol_table = symbol_tables[dso_id];
-      CHECK_LE(pc_idx_begin + dso_info.num_instrumented_pcs, pc_table.size())
+      FUZZTEST_CHECK_LE(pc_idx_begin + dso_info.num_instrumented_pcs,
+                        pc_table.size())
           << VV(pc_idx_begin) << VV(dso_info.num_instrumented_pcs);
       const absl::Span<const PCInfo> pc_infos = {pc_table.data() + pc_idx_begin,
                                                  dso_info.num_instrumented_pcs};
@@ -188,7 +193,7 @@
   for (const auto &table : symbol_tables) {
     AddEntries(table);
   }
-  CHECK_EQ(pc_idx_begin, pc_table.size());
+  FUZZTEST_CHECK_EQ(pc_idx_begin, pc_table.size());
 
   if (size() != pc_table.size()) {
     // Something went wrong. Set symbols to unknown so the sizes of pc_table and
@@ -214,19 +219,19 @@
   }
   const std::vector<std::string_view> file_line_col_split =
       absl::StrSplit(file_line_col, ':');
-  CHECK_LE(file_line_col_split.size(), 3);
-  CHECK_GE(file_line_col_split.size(), 1)
+  FUZZTEST_CHECK_LE(file_line_col_split.size(), 3);
+  FUZZTEST_CHECK_GE(file_line_col_split.size(), 1)
       << "Unexpected symbolizer input format when getting source location: "
       << file_line_col;
   int line = -1;
   int col = -1;
   if (file_line_col_split.size() >= 2) {
-    CHECK(absl::SimpleAtoi(file_line_col_split[1], &line))
+    FUZZTEST_CHECK(absl::SimpleAtoi(file_line_col_split[1], &line))
         << "Unable to convert line number string to an int: "
         << file_line_col_split[1];
   }
   if (file_line_col_split.size() == 3) {
-    CHECK(absl::SimpleAtoi(file_line_col_split[2], &col))
+    FUZZTEST_CHECK(absl::SimpleAtoi(file_line_col_split[2], &col))
         << "Unable to convert column number string to an int: "
         << file_line_col_split[2];
   }
diff --git a/centipede/test_coverage_util.cc b/centipede/test_coverage_util.cc
index d65dff0..e499179 100644
--- a/centipede/test_coverage_util.cc
+++ b/centipede/test_coverage_util.cc
@@ -18,7 +18,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "./centipede/corpus.h"
 #include "./centipede/environment.h"
 #include "./centipede/feature.h"
@@ -46,7 +45,7 @@
   // Repackage execution results into a vector of CorpusRecords.
   std::vector<CorpusRecord> corpus_records;
   std::vector<ExecutionResult> &execution_results = batch_result.results();
-  CHECK_EQ(byte_array_inputs.size(), execution_results.size());
+  FUZZTEST_CHECK_EQ(byte_array_inputs.size(), execution_results.size());
 
   corpus_records.reserve(byte_array_inputs.size());
   for (int i = 0; i < byte_array_inputs.size(); ++i) {
diff --git a/centipede/test_coverage_util.h b/centipede/test_coverage_util.h
index 6a9b5d5..c06a9bf 100644
--- a/centipede/test_coverage_util.h
+++ b/centipede/test_coverage_util.h
@@ -21,7 +21,6 @@
 #include <string_view>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "./centipede/centipede_callbacks.h"
 #include "./centipede/corpus.h"
 #include "./centipede/environment.h"
@@ -48,7 +47,7 @@
                BatchResult &batch_result) override {
     int result =
         ExecuteCentipedeSancovBinaryWithShmem(binary, inputs, batch_result);
-    CHECK_EQ(EXIT_SUCCESS, result);
+    FUZZTEST_CHECK_EQ(EXIT_SUCCESS, result);
     return true;
   }
   std::vector<ByteArray> Mutate(const std::vector<MutationInputRef> &inputs,
diff --git a/centipede/thread_pool.h b/centipede/thread_pool.h
index a742ba6..7c22801 100644
--- a/centipede/thread_pool.h
+++ b/centipede/thread_pool.h
@@ -24,7 +24,6 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "absl/synchronization/mutex.h"
 
 namespace fuzztest::internal {
@@ -60,7 +59,7 @@
 
   // Schedules a function to be run on a ThreadPool thread immediately.
   void Schedule(absl::AnyInvocable<void()> func) {
-    CHECK(func != nullptr);
+    FUZZTEST_CHECK(func != nullptr);
     absl::MutexLock l{&mu_};
     queue_.push(std::move(func));
   }
diff --git a/centipede/util.cc b/centipede/util.cc
index c5e1b74..988f25e 100644
--- a/centipede/util.cc
+++ b/centipede/util.cc
@@ -45,7 +45,6 @@
 #include "absl/base/const_init.h"
 #include "absl/base/nullability.h"
 #include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_replace.h"
 #include "absl/strings/str_split.h"
@@ -86,11 +85,11 @@
   f.seekg(0, std::ios_base::end);
   auto size = f.tellg();
   f.seekg(0, std::ios_base::beg);
-  CHECK_EQ(size % sizeof(data[0]), 0);
+  FUZZTEST_CHECK_EQ(size % sizeof(data[0]), 0);
   data.resize(size / sizeof(data[0]));
   f.read(reinterpret_cast<char *>(data.data()), size);
-  CHECK(f) << "Failed to read from local file: " << VV(file_path) << VV(f.eof())
-           << VV(f.bad()) << VV(f.fail()) << VV(size);
+  FUZZTEST_CHECK(f) << "Failed to read from local file: " << VV(file_path)
+                    << VV(f.eof()) << VV(f.bad()) << VV(f.fail()) << VV(size);
   f.close();
 }
 
@@ -110,15 +109,15 @@
 
 void ClearLocalFileContents(std::string_view file_path) {
   std::ofstream f(std::string{file_path}, std::ios::out | std::ios::trunc);
-  CHECK(f) << "Failed to clear the file: " << file_path;
+  FUZZTEST_CHECK(f) << "Failed to clear the file: " << file_path;
 }
 
 void WriteToLocalFile(std::string_view file_path, ByteSpan data) {
   std::ofstream f(std::string{file_path});
-  CHECK(f) << "Failed to open local file: " << file_path;
+  FUZZTEST_CHECK(f) << "Failed to open local file: " << file_path;
   f.write(reinterpret_cast<const char *>(data.data()),
           static_cast<int64_t>(data.size()));
-  CHECK(f) << "Failed to write to local file: " << file_path;
+  FUZZTEST_CHECK(f) << "Failed to write to local file: " << file_path;
   f.close();
 }
 
@@ -140,14 +139,14 @@
 void WriteToRemoteHashedFileInDir(std::string_view dir_path, ByteSpan data) {
   if (dir_path.empty()) return;
   std::string file_path = std::filesystem::path(dir_path).append(Hash(data));
-  CHECK_OK(
+  FUZZTEST_CHECK_OK(
       RemoteFileSetContents(file_path, std::string(data.begin(), data.end())));
 }
 
 std::string HashOfFileContents(std::string_view file_path) {
   if (file_path.empty()) return "";
   std::string file_contents;
-  CHECK_OK(RemoteFileGetContents(file_path, file_contents));
+  FUZZTEST_CHECK_OK(RemoteFileGetContents(file_path, file_contents));
   return Hash(file_contents);
 }
 
@@ -183,7 +182,7 @@
 
 void CreateLocalDirRemovedAtExit(std::string_view path) {
   // Safeguard against removing dirs not created by TemporaryLocalDirPath().
-  CHECK_NE(path.find("/centipede-"), std::string::npos);
+  FUZZTEST_CHECK_NE(path.find("/centipede-"), std::string::npos);
   // Create the dir.
   std::filesystem::remove_all(path);
   std::filesystem::create_directories(path);
@@ -202,12 +201,12 @@
 ScopedFile::~ScopedFile() { std::filesystem::remove_all(my_path_); }
 
 void AppendHashToArray(ByteArray &ba, std::string_view hash) {
-  CHECK_EQ(hash.size(), kHashLen);
+  FUZZTEST_CHECK_EQ(hash.size(), kHashLen);
   ba.insert(ba.end(), hash.begin(), hash.end());
 }
 
 std::string ExtractHashFromArray(ByteArray &ba) {
-  CHECK_GE(ba.size(), kHashLen);
+  FUZZTEST_CHECK_GE(ba.size(), kHashLen);
   std::string res;
   res.insert(res.end(), ba.end() - kHashLen, ba.end());
   ba.resize(ba.size() - kHashLen);
@@ -223,7 +222,7 @@
                                         ByteSpan features) {
   ByteArray feature_bytes_with_hash(features.size() + kHashLen);
   auto hash = Hash(data);
-  CHECK_EQ(hash.size(), kHashLen);
+  FUZZTEST_CHECK_EQ(hash.size(), kHashLen);
   memcpy(feature_bytes_with_hash.data(), features.data(), features.size());
   memcpy(feature_bytes_with_hash.data() + features.size(), hash.data(),
          kHashLen);
@@ -350,13 +349,13 @@
 uint8_t *MmapNoReserve(size_t size) {
   auto result = mmap(0, size, PROT_READ | PROT_WRITE,
                      MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0);
-  CHECK(result != MAP_FAILED);
+  FUZZTEST_CHECK(result != MAP_FAILED);
   return reinterpret_cast<uint8_t *>(result);
 }
 
 void Munmap(uint8_t *ptr, size_t size) {
   auto result = munmap(ptr, size);
-  CHECK_EQ(result, 0);
+  FUZZTEST_CHECK_EQ(result, 0);
 }
 
 }  // namespace fuzztest::internal
diff --git a/centipede/util.h b/centipede/util.h
index 1f31e40..93ca1cb 100644
--- a/centipede/util.h
+++ b/centipede/util.h
@@ -23,10 +23,10 @@
 #include <vector>
 
 #include "absl/base/nullability.h"
-#include "absl/log/check.h"
 #include "absl/types/span.h"
 #include "./centipede/feature.h"
 #include "./common/defs.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 
@@ -158,13 +158,13 @@
                         std::vector<ByteArray> &dictionary_entries);
 
 // Maps `size` bytes with `mmap(NO_RESERVE)` or equivalent, returns the result.
-// CHECK-fails on error.
+// FUZZTEST_CHECK-fails on error.
 // The resulting memory is unreserved, and will be zero-initialized on first
 // access.
 uint8_t *MmapNoReserve(size_t size);
 
 // Unmaps memory returned by `MmapNoReserve`().
-// CHECK-fails on error.
+// FUZZTEST_CHECK-fails on error.
 void Munmap(uint8_t *ptr, size_t size);
 
 // Fixed size array allocated/deallocated with MmapNoReserve/Munmap.
@@ -179,11 +179,11 @@
   MmapNoReserveArray(MmapNoReserveArray &&) = delete;
   MmapNoReserveArray &operator=(MmapNoReserveArray &&) = delete;
   uint8_t operator[](size_t i) const {
-    CHECK_LT(i, kSize);
+    FUZZTEST_CHECK_LT(i, kSize);
     return array_[i];
   }
   uint8_t &operator[](size_t i) {
-    CHECK_LT(i, kSize);
+    FUZZTEST_CHECK_LT(i, kSize);
     return array_[i];
   }
 
diff --git a/centipede/util_test.cc b/centipede/util_test.cc
index 792c9f9..7be77e8 100644
--- a/centipede/util_test.cc
+++ b/centipede/util_test.cc
@@ -24,11 +24,11 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/container/flat_hash_map.h"
-#include "absl/log/log.h"
 #include "./centipede/feature.h"
 #include "./centipede/thread_pool.h"
 #include "./common/defs.h"
 #include "./common/hash.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 
@@ -106,7 +106,7 @@
   {
     // Check that repeated calls return the same path.
     auto temp_dir = TemporaryLocalDirPath();
-    LOG(INFO) << temp_dir;
+    FUZZTEST_LOG(INFO) << temp_dir;
     EXPECT_EQ(temp_dir, TemporaryLocalDirPath());
   }
 
diff --git a/centipede/workdir.cc b/centipede/workdir.cc
index 59b2e0f..c0f4090 100644
--- a/centipede/workdir.cc
+++ b/centipede/workdir.cc
@@ -23,8 +23,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
@@ -46,7 +44,7 @@
 std::string NormalizeAnnotation(std::string_view annotation) {
   std::string ret;
   if (!annotation.empty()) {
-    CHECK_NE(annotation.front(), '.');
+    FUZZTEST_CHECK_NE(annotation.front(), '.');
     ret = absl::StrCat(".", annotation);
   }
   return ret;
@@ -101,15 +99,16 @@
   const std::filesystem::path path{corpus_shard_path};
   const std::string dir = path.parent_path();
   const std::string stem = path.stem();
-  CHECK(stem == kCorpusShardStem ||
-        absl::StartsWith(stem, kDistilledCorpusShardStemPrefix))
+  FUZZTEST_CHECK(stem == kCorpusShardStem ||
+                 absl::StartsWith(stem, kDistilledCorpusShardStemPrefix))
       << VV(corpus_shard_path);
   const std::string dot_ext = path.extension();
-  CHECK(!dot_ext.empty() && dot_ext[0] == '.') << VV(corpus_shard_path);
+  FUZZTEST_CHECK(!dot_ext.empty() && dot_ext[0] == '.')
+      << VV(corpus_shard_path);
   const std::string ext = dot_ext.substr(1);
-  CHECK_EQ(ext.size(), kDigitsInShardIndex) << VV(corpus_shard_path);
+  FUZZTEST_CHECK_EQ(ext.size(), kDigitsInShardIndex) << VV(corpus_shard_path);
   size_t shard_index = -1;
-  CHECK(absl::SimpleAtoi(ext, &shard_index)) << VV(corpus_shard_path);
+  FUZZTEST_CHECK(absl::SimpleAtoi(ext, &shard_index)) << VV(corpus_shard_path);
   return WorkDir{
       dir,
       std::string{binary_name},
@@ -241,8 +240,8 @@
   const auto dir_iter =
       std::filesystem::directory_iterator(dir_path, dir_error);
   if (dir_error) {
-    LOG(ERROR) << "Failed to access coverage dir '" << dir_path
-               << "': " << dir_error.message();
+    FUZZTEST_LOG(ERROR) << "Failed to access coverage dir '" << dir_path
+                        << "': " << dir_error.message();
     return {};
   }
   std::vector<std::string> raw_profiles;
diff --git a/common/BUILD b/common/BUILD
index 753a042..d0fb585 100644
--- a/common/BUILD
+++ b/common/BUILD
@@ -40,7 +40,7 @@
     srcs = ["bazel.cc"],
     hdrs = ["bazel.h"],
     deps = [
-        "@abseil-cpp//absl/log:check",
+        ":logging",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/time",
@@ -64,8 +64,6 @@
         ":status_macros",
         "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/base:nullability",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings:str_format",
@@ -106,8 +104,8 @@
     name = "logging",
     hdrs = ["logging.h"],
     deps = [
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
+        "@abseil-cpp//absl/log:absl_check",
+        "@abseil-cpp//absl/log:absl_log",
     ],
 )
 
@@ -124,7 +122,6 @@
                ":logging",
                ":status_macros",
                "@abseil-cpp//absl/base:nullability",
-               "@abseil-cpp//absl/log:check",
                "@abseil-cpp//absl/status",
                "@abseil-cpp//absl/status:statusor",
                "@abseil-cpp//absl/strings",
@@ -156,8 +153,6 @@
         ":logging",
         ":status_macros",
         "@abseil-cpp//absl/base:nullability",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings",
@@ -186,8 +181,8 @@
     name = "status_macros",
     hdrs = ["status_macros.h"],
     deps = [
+        ":logging",
         "@abseil-cpp//absl/base:core_headers",
-        "@abseil-cpp//absl/log",
     ],
 )
 
@@ -200,8 +195,6 @@
         ":blob_file",
         ":defs",
         ":logging",
-        "@abseil-cpp//absl/log",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
         "@googletest//:gtest",
@@ -213,7 +206,7 @@
     srcs = ["temp_dir.cc"],
     hdrs = ["temp_dir.h"],
     deps = [
-        "@abseil-cpp//absl/log:check",
+        ":logging",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:string_view",
     ],
@@ -254,7 +247,6 @@
         ":logging",
         ":remote_file",
         ":test_util",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/time",
         "@googletest//:gtest",
diff --git a/common/bazel.cc b/common/bazel.cc
index 1a9780d..75f2141 100644
--- a/common/bazel.cc
+++ b/common/bazel.cc
@@ -18,12 +18,12 @@
 #include <cstdlib>
 #include <string>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 
@@ -40,7 +40,7 @@
     return absl::InfiniteDuration();
   }
   int timeout_s = 0;
-  CHECK(absl::SimpleAtoi(test_timeout_env, &timeout_s))
+  FUZZTEST_CHECK(absl::SimpleAtoi(test_timeout_env, &timeout_s))
       << "Failed to parse TEST_TIMEOUT: \"" << test_timeout_env << "\"";
   return absl::Seconds(timeout_s);
 }
@@ -52,18 +52,20 @@
     TestShard test_shard;
     if (const char *test_total_shards_env = std::getenv("TEST_TOTAL_SHARDS");
         test_total_shards_env != nullptr) {
-      CHECK(absl::SimpleAtoi(test_total_shards_env, &test_shard.total_shards))
+      FUZZTEST_CHECK(
+          absl::SimpleAtoi(test_total_shards_env, &test_shard.total_shards))
           << "Failed to parse TEST_TOTAL_SHARDS as an integer: \""
           << test_total_shards_env << "\"";
-      CHECK_GT(test_shard.total_shards, 0)
+      FUZZTEST_CHECK_GT(test_shard.total_shards, 0)
           << "TEST_TOTAL_SHARDS must be greater than 0.";
     }
     if (const char *test_shard_index_env = std::getenv("TEST_SHARD_INDEX");
         test_shard_index_env != nullptr) {
-      CHECK(absl::SimpleAtoi(test_shard_index_env, &test_shard.index))
+      FUZZTEST_CHECK(absl::SimpleAtoi(test_shard_index_env, &test_shard.index))
           << "Failed to parse TEST_SHARD_INDEX as an integer: \""
           << test_shard_index_env << "\"";
-      CHECK(0 <= test_shard.index && test_shard.index < test_shard.total_shards)
+      FUZZTEST_CHECK(0 <= test_shard.index &&
+                     test_shard.index < test_shard.total_shards)
           << "TEST_SHARD_INDEX must be in the range [0, "
           << test_shard.total_shards << ").";
     }
@@ -102,7 +104,7 @@
       // timeout. This case can only happen if we would in fact need more than
       // `kMaxShardCount` shards, indicating that there are simply too many fuzz
       // tests in a binary.
-      CHECK_EQ(suggested_shard_count, kMaxShardCount);
+      FUZZTEST_CHECK_EQ(suggested_shard_count, kMaxShardCount);
       absl::StrAppend(&error,
                       "split the fuzz tests into several test binaries where "
                       "each binary has at most ",
@@ -112,7 +114,7 @@
       // In this case, `suggested_shard_count` must be greater than
       // `shard_count`, otherwise we would have already executed all the tests
       // without a timeout.
-      CHECK_GT(suggested_shard_count, shard_count);
+      FUZZTEST_CHECK_GT(suggested_shard_count, shard_count);
       absl::StrAppend(&error, "increase the `shard_count` to ",
                       suggested_shard_count, ", ");
     }
diff --git a/common/blob_file.cc b/common/blob_file.cc
index dc9a40e..6193c4f 100644
--- a/common/blob_file.cc
+++ b/common/blob_file.cc
@@ -27,8 +27,6 @@
 
 #include "absl/base/nullability.h"
 #include "absl/base/optimization.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
@@ -71,7 +69,7 @@
   ~SimpleBlobFileReader() override {
     if (file_ && !closed_) {
       // Virtual resolution is off in dtors, so use a specific Close().
-      CHECK_OK(SimpleBlobFileReader::Close());
+      FUZZTEST_CHECK_OK(SimpleBlobFileReader::Close());
     }
   }
 
@@ -125,12 +123,12 @@
   ~SimpleBlobFileWriter() override {
     if (file_ && !closed_) {
       // Virtual resolution is off in dtors, so use a specific Close().
-      CHECK_OK(SimpleBlobFileWriter::Close());
+      FUZZTEST_CHECK_OK(SimpleBlobFileWriter::Close());
     }
   }
 
   absl::Status Open(std::string_view path, std::string_view mode) override {
-    CHECK(mode == "w" || mode == "a") << VV(mode);
+    FUZZTEST_CHECK(mode == "w" || mode == "a") << VV(mode);
     if (closed_) return absl::FailedPreconditionError("already closed");
     if (file_) return absl::FailedPreconditionError("already open");
     ASSIGN_OR_RETURN_IF_NOT_OK(file_, RemoteFileOpen(path, mode.data()));
@@ -170,7 +168,7 @@
  public:
   ~DefaultBlobFileReader() override {
     // Virtual resolution is off in dtors, so use a specific Close().
-    CHECK_OK(DefaultBlobFileReader::Close());
+    FUZZTEST_CHECK_OK(DefaultBlobFileReader::Close());
   }
 
   absl::Status Open(std::string_view path) override {
@@ -247,8 +245,8 @@
     // TODO(b/313706444): Reconsider error handling after experiments.
     // TODO(b/310701588): Try adding a test for this.
     if (riegeli_reader_.ok() && !riegeli_reader_.Close()) {
-      LOG(WARNING) << "Ignoring errors while closing Riegeli file: "
-                   << riegeli_reader_.status();
+      FUZZTEST_LOG(WARNING) << "Ignoring errors while closing Riegeli file: "
+                            << riegeli_reader_.status();
     }
     // Any non-ok status of `riegeli_reader_` persists for subsequent
     // operations; therefore, re-initialize it to a closed ok state.
@@ -272,11 +270,11 @@
  public:
   ~RiegeliWriter() override {
     // Virtual resolution is off in dtors, so use a specific Close().
-    CHECK_OK(RiegeliWriter::Close());
+    FUZZTEST_CHECK_OK(RiegeliWriter::Close());
   }
 
   absl::Status Open(std::string_view path, std::string_view mode) override {
-    CHECK(mode == "w" || mode == "a") << VV(mode);
+    FUZZTEST_CHECK(mode == "w" || mode == "a") << VV(mode);
     if (absl::Status s = Close(); !s.ok()) return s;
     const auto kWriterOpts =
         riegeli::RecordWriterBase::Options{}.set_chunk_size(kMaxBufferedBytes);
@@ -305,7 +303,7 @@
     if (!PostWriteFlush(blob.size())) return writer_.status();
     write_duration_ += absl::Now() - now;
     if (written_blobs_ + buffered_blobs_ % 10000 == 0)
-      VLOG(10) << "Current stats: " << StatsString();
+      FUZZTEST_VLOG(10) << "Current stats: " << StatsString();
     return absl::OkStatus();
   }
 
@@ -322,7 +320,7 @@
     written_bytes_ += buffered_bytes_;
     buffered_blobs_ = 0;
     buffered_bytes_ = 0;
-    VLOG(1) << "Final stats: " << StatsString();
+    FUZZTEST_VLOG(1) << "Final stats: " << StatsString();
     return absl::OkStatus();
   }
 
@@ -358,7 +356,8 @@
         : (absl::Now() - flushed_at_ > kMaxFlushInterval)     ? "time"
                                                               : "";
     if (!flush_reason.empty()) {
-      VLOG(20) << "Flushing b/c " << flush_reason << ": " << StatsString();
+      FUZZTEST_VLOG(20) << "Flushing b/c " << flush_reason << ": "
+                        << StatsString();
       if (!writer_.Flush(riegeli::FlushType::kFromMachine)) return false;
       flushed_at_ = absl::Now();
       written_blobs_ += buffered_blobs_;
@@ -376,7 +375,8 @@
   bool PostWriteFlush(size_t blob_size) {
     const auto record_size = blob_size + kRiegeliPerRecordMetadataSize;
     if (record_size >= kMaxBufferedBytes) {
-      VLOG(20) << "Post-write flushing b/c blob size: " << StatsString();
+      FUZZTEST_VLOG(20) << "Post-write flushing b/c blob size: "
+                        << StatsString();
       if (!writer_.Flush(riegeli::FlushType::kFromMachine)) return false;
       flushed_at_ = absl::Now();
       written_blobs_ += 1;
@@ -446,7 +446,7 @@
 ByteArray PackBytesForAppendFile(ByteSpan blob) {
   ByteArray res;
   auto hash = Hash(blob);
-  CHECK_EQ(hash.size(), kHashLen);
+  FUZZTEST_CHECK_EQ(hash.size(), kHashLen);
   size_t size = blob.size();
   uint8_t size_bytes[sizeof(size)];
   std::memcpy(size_bytes, &size, sizeof(size));
@@ -496,7 +496,8 @@
 std::unique_ptr<BlobFileWriter> DefaultBlobFileWriterFactory(bool riegeli) {
   if (riegeli)
 #ifdef CENTIPEDE_DISABLE_RIEGELI
-    LOG(FATAL) << "Riegeli unavailable: built with --use_riegeli set to false.";
+    FUZZTEST_LOG(FATAL)
+        << "Riegeli unavailable: built with --use_riegeli set to false.";
 #else
     return std::make_unique<RiegeliWriter>();
 #endif  // CENTIPEDE_DISABLE_RIEGELI
diff --git a/common/logging.h b/common/logging.h
index 7020085..8f25c92 100644
--- a/common/logging.h
+++ b/common/logging.h
@@ -15,13 +15,32 @@
 #ifndef FUZZTEST_COMMON_LOGGING_H_
 #define FUZZTEST_COMMON_LOGGING_H_
 
-// TODO(b/315519925): Temporary leftover from switching to now-available
-//  OSS Abseil VLOG and friends. Explicitly include these wherever necessary and
-//  remove from here.
-#include "absl/log/check.h"  // IWYU pragma: keep
-#include "absl/log/log.h"    // IWYU pragma: keep
+#include "absl/log/absl_check.h"
+#include "absl/log/absl_log.h"
 
-// Easy variable value logging: LOG(INFO) << VV(foo) << VV(bar);
+// Easy variable value logging: FUZZTEST_LOG(INFO) << VV(foo) << VV(bar);
 #define VV(x) #x ": " << (x) << " "
 
+// NOTE: these macros are for internal use within the fuzztest codebase.
+#define FUZZTEST_LOG(severity) ABSL_LOG(severity)
+#define FUZZTEST_LOG_EVERY_POW_2(severity) ABSL_LOG_EVERY_POW_2(severity)
+#define FUZZTEST_LOG_FIRST_N(severity, n) ABSL_LOG_FIRST_N(severity, n)
+#define FUZZTEST_VLOG(verbose_level) ABSL_VLOG(verbose_level)
+#define FUZZTEST_VLOG_EVERY_N(verbose_level, n) \
+  ABSL_VLOG_EVERY_N(verbose_level, n)
+#define FUZZTEST_VLOG_IS_ON(verbose_level) ABSL_VLOG_IS_ON(verbose_level)
+#define FUZZTEST_LOG_IF(severity, condition) ABSL_LOG_IF(severity, condition)
+#define FUZZTEST_CHECK(cond) ABSL_CHECK(cond) << "Internal error: "
+#define FUZZTEST_PCHECK(cond) ABSL_PCHECK(cond) << "Internal error: "
+#define FUZZTEST_PRECONDITION(cond) ABSL_CHECK(cond) << "Failed precondition: "
+#define FUZZTEST_CHECK_OK(status) ABSL_CHECK_OK(status)
+#define FUZZTEST_CHECK_GT(a, b) ABSL_CHECK_GT(a, b)
+#define FUZZTEST_CHECK_GE(a, b) ABSL_CHECK_GE(a, b)
+#define FUZZTEST_CHECK_EQ(a, b) ABSL_CHECK_EQ(a, b)
+#define FUZZTEST_CHECK_NE(a, b) ABSL_CHECK_NE(a, b)
+#define FUZZTEST_CHECK_LE(a, b) ABSL_CHECK_LE(a, b)
+#define FUZZTEST_CHECK_LT(a, b) ABSL_CHECK_LT(a, b)
+#define FUZZTEST_QCHECK(cond) ABSL_QCHECK(cond)
+#define FUZZTEST_QCHECK_OK(status) ABSL_QCHECK_OK(status)
+
 #endif  // FUZZTEST_COMMON_LOGGING_H_
diff --git a/common/remote_file.cc b/common/remote_file.cc
index 714855e..b628ad6 100644
--- a/common/remote_file.cc
+++ b/common/remote_file.cc
@@ -21,7 +21,6 @@
 #include <string_view>
 
 #include "absl/base/nullability.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "./common/defs.h"
 #include "./common/logging.h"
diff --git a/common/remote_file_oss.cc b/common/remote_file_oss.cc
index 0f0acba..fb6f23a 100644
--- a/common/remote_file_oss.cc
+++ b/common/remote_file_oss.cc
@@ -37,8 +37,6 @@
 #include <vector>
 
 #include "absl/base/nullability.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -69,7 +67,8 @@
   }
 
   ~LocalRemoteFile() {
-    CHECK(file_ == nullptr) << "Dtor called before Close(): " << VV(path_);
+    FUZZTEST_CHECK(file_ == nullptr)
+        << "Dtor called before Close(): " << VV(path_);
   }
 
   // Movable but not copyable.
@@ -123,7 +122,7 @@
                                              ": ", std::strerror(errno)));
     }
     static constexpr auto elt_size = sizeof(ba[0]);
-    CHECK_EQ(file_size % elt_size, 0)
+    FUZZTEST_CHECK_EQ(file_size % elt_size, 0)
         << VV(file_size) << VV(elt_size) << VV(path_);
     if (file_size % elt_size != 0) {
       return absl::FailedPreconditionError(
@@ -165,36 +164,36 @@
 #if defined(FUZZTEST_STUB_STD_FILESYSTEM)
 
 absl::Status RemoteMkdir(std::string_view path) {
-  LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 bool RemotePathExists(std::string_view path) {
-  LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 bool RemotePathIsDirectory(std::string_view path) {
-  LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 absl::StatusOr<std::vector<std::string>> RemoteListFiles(std::string_view path,
                                                          bool recursively) {
-  LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 absl::Status RemoteFileRename(std::string_view from, std::string_view to) {
-  LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 absl::Status RemoteFileCopy(std::string_view from, std::string_view to) {
-  LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 absl::Status RemotePathTouchExistingFile(std::string_view path) {
-  LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 absl::Status RemotePathDelete(std::string_view path, bool recursively) {
-  LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 #else
@@ -310,7 +309,7 @@
 
 // TODO(ussuri): For now, simulate the old behavior, where a failure to open
 //  a file returned nullptr. Adjust the clients to expect non-null and use a
-//  normal ctor with a CHECK instead of `Create()` here instead.
+//  normal ctor with a FUZZTEST_CHECK instead of `Create()` here instead.
 absl::StatusOr<RemoteFile *> RemoteFileOpen(std::string_view path,
                                             const char *mode) {
   return LocalRemoteFile::Create(std::string(path), mode);
@@ -367,7 +366,8 @@
 #if defined(FUZZTEST_HAS_OSS_GLOB)
 int HandleGlobError(const char *epath, int eerrno) {
   if (eerrno == ENOENT) return 0;
-  LOG(FATAL) << "Error while globbing path: " << VV(epath) << VV(eerrno);
+  FUZZTEST_LOG(FATAL) << "Error while globbing path: " << VV(epath)
+                      << VV(eerrno);
   return -1;
 }
 #endif  // defined(FUZZTEST_HAS_OSS_GLOB)
diff --git a/common/remote_file_test.cc b/common/remote_file_test.cc
index ade0988..82fd85b 100644
--- a/common/remote_file_test.cc
+++ b/common/remote_file_test.cc
@@ -23,7 +23,6 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
@@ -40,9 +39,9 @@
 
 void CreateFileOrDie(std::string_view path, std::string_view contents = "") {
   std::ofstream f{std::string(path)};
-  CHECK(f.good()) << VV(path);
+  FUZZTEST_CHECK(f.good()) << VV(path);
   f << contents;
-  CHECK(f.good()) << VV(path);
+  FUZZTEST_CHECK(f.good()) << VV(path);
 }
 
 TEST(RemoteFile, GetSize) {
@@ -137,7 +136,7 @@
 TEST(RemotePathDelete, RecursivelyDeletesAllFilesAndSubdirectories) {
   const fs::path temp_dir = GetTestTempDir(test_info_->name());
   const fs::path a_b_c = temp_dir / "a" / "b" / "c";
-  CHECK(fs::create_directories(a_b_c)) << VV(a_b_c);
+  FUZZTEST_CHECK(fs::create_directories(a_b_c)) << VV(a_b_c);
   const std::string file_path = a_b_c / "file";
   CreateFileOrDie(file_path);
 
diff --git a/common/status_macros.h b/common/status_macros.h
index 0fe940f..882f2f5 100644
--- a/common/status_macros.h
+++ b/common/status_macros.h
@@ -21,7 +21,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/optimization.h"
-#include "absl/log/log.h"
+#include "./common/logging.h"
 
 // If `status_expr` (an expression of type `absl::Status`) is not OK then return
 // it from the current function. Otherwise, do nothing.
@@ -55,8 +55,9 @@
                           std::uint_least32_t line = __builtin_LINE(),
                           const char* file_name = __builtin_FILE()) {
   if (ABSL_PREDICT_FALSE(!value.ok())) {
-    LOG(FATAL) << file_name << ":" << line
-               << ": ValueOrDie on non-OK status: " << value.status();
+    FUZZTEST_CHECK(false) << file_name << ":" << line
+                          << ": ValueOrDie on non-OK status: "
+                          << value.status();
   }
   return *std::forward<T>(value);
 }
diff --git a/common/temp_dir.cc b/common/temp_dir.cc
index e57e237..f9dba37 100644
--- a/common/temp_dir.cc
+++ b/common/temp_dir.cc
@@ -4,9 +4,9 @@
 #include <filesystem>    // NOLINT
 #include <system_error>  // NOLINT
 
-#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 
@@ -18,24 +18,24 @@
   if (temp_root.empty()) {
     std::error_code error;
     temp_root = std::filesystem::temp_directory_path(error);
-    CHECK(!error) << "Failed to get the root temp directory path: "
-                  << error.message();
+    FUZZTEST_CHECK(!error) << "Failed to get the root temp directory path: "
+                           << error.message();
   }
   absl::string_view prefix = custom_prefix.empty() ? "temp_dir" : custom_prefix;
   const fs::path path_template = temp_root / absl::StrCat(prefix, "_XXXXXX");
 #if !defined(_MSC_VER)
   path_ = mkdtemp(path_template.string().data());
 #else
-  CHECK(false) << "Windows is not supported yet.";
+  FUZZTEST_CHECK(false) << "Windows is not supported yet.";
 #endif
-  CHECK(std::filesystem::is_directory(path_));
+  FUZZTEST_CHECK(std::filesystem::is_directory(path_));
 }
 
 TempDir::~TempDir() {
   std::error_code error;
   std::filesystem::remove_all(path_, error);
-  CHECK(!error) << "Unable to clean up temporary dir " << path_ << ": "
-                << error.message();
+  FUZZTEST_CHECK(!error) << "Unable to clean up temporary dir " << path_ << ": "
+                         << error.message();
 }
 
 }  // namespace fuzztest::internal
diff --git a/common/test_util.cc b/common/test_util.cc
index 368f673..3232d55 100644
--- a/common/test_util.cc
+++ b/common/test_util.cc
@@ -19,8 +19,6 @@
 #include <system_error>  // NOLINT
 
 #include "gtest/gtest.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "./common/logging.h"
 
@@ -28,13 +26,14 @@
 
 std::filesystem::path GetTestTempDir(std::string_view subdir) {
   const std::filesystem::path test_tempdir = ::testing::TempDir();
-  CHECK(!test_tempdir.empty())
+  FUZZTEST_CHECK(!test_tempdir.empty())
       << "testing::TempDir() is expected to always return non-empty path";
   const auto dir = test_tempdir / subdir;
   if (!std::filesystem::exists(dir)) {
     std::error_code error;
     std::filesystem::create_directories(dir, error);
-    CHECK(!error) << "Failed to create dir: " VV(dir) << error.message();
+    FUZZTEST_CHECK(!error) << "Failed to create dir: " VV(dir)
+                           << error.message();
   }
   return std::filesystem::canonical(dir);
 }
@@ -45,13 +44,13 @@
 
 std::filesystem::path GetTestRunfilesDir() {
   const auto test_srcdir = ::testing::SrcDir();
-  CHECK(!test_srcdir.empty())
+  FUZZTEST_CHECK(!test_srcdir.empty())
       << "testing::SrcDir() is expected to always return non-empty path";
   const char* test_workspace = std::getenv("TEST_WORKSPACE");
-  CHECK(test_workspace != nullptr)
+  FUZZTEST_CHECK(test_workspace != nullptr)
       << "TEST_WORKSPACE envvar is expected to be set by build system";
   auto path = std::filesystem::path{test_srcdir}.append(test_workspace);
-  CHECK(std::filesystem::exists(path))  //
+  FUZZTEST_CHECK(std::filesystem::exists(path))  //
       << "No such dir: " << VV(path) << VV(test_srcdir) << VV(test_workspace);
   return path;
 }
@@ -60,19 +59,19 @@
   const auto runfiles_dir = GetTestRunfilesDir();
   auto path = runfiles_dir;
   path.append(rel_path);
-  CHECK(std::filesystem::exists(path))  //
+  FUZZTEST_CHECK(std::filesystem::exists(path))  //
       << "No such path: " << VV(path) << VV(runfiles_dir) << VV(rel_path);
   return path;
 }
 
 std::string GetLLVMSymbolizerPath() {
-  CHECK_EQ(system("which llvm-symbolizer"), EXIT_SUCCESS)
+  FUZZTEST_CHECK_EQ(system("which llvm-symbolizer"), EXIT_SUCCESS)
       << "llvm-symbolizer has to be installed and findable via PATH";
   return "llvm-symbolizer";
 }
 
 std::string GetObjDumpPath() {
-  CHECK_EQ(system("which objdump"), EXIT_SUCCESS)
+  FUZZTEST_CHECK_EQ(system("which objdump"), EXIT_SUCCESS)
       << "objdump has to be installed and findable via PATH";
   return "objdump";
 }
@@ -80,7 +79,7 @@
 void PrependDirToPathEnvvar(std::string_view dir) {
   const std::string new_path_envvar = absl::StrCat(dir, ":", getenv("PATH"));
   setenv("PATH", new_path_envvar.c_str(), /*replace*/ 1);
-  LOG(INFO) << "New PATH: " << new_path_envvar;
+  FUZZTEST_LOG(INFO) << "New PATH: " << new_path_envvar;
 }
 
 }  // namespace fuzztest::internal
diff --git a/common/test_util.h b/common/test_util.h
index 11cc60c..c859bff 100644
--- a/common/test_util.h
+++ b/common/test_util.h
@@ -22,10 +22,10 @@
 #include <string_view>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/strings/str_format.h"
 #include "./common/blob_file.h"
 #include "./common/defs.h"
+#include "./common/logging.h"
 
 #include "./common/logging.h"
 
@@ -116,7 +116,7 @@
     while (reader_->Read(blob).ok()) {
       corpus.emplace_back(blob.begin(), blob.end());
     }
-    CHECK_OK(reader_->Close());
+    FUZZTEST_CHECK_OK(reader_->Close());
     return corpus;
   }
 
diff --git a/domain_tests/BUILD b/domain_tests/BUILD
index a2584b1..a558db2 100644
--- a/domain_tests/BUILD
+++ b/domain_tests/BUILD
@@ -126,6 +126,7 @@
         "@abseil-cpp//absl/random:bit_gen_ref",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/strings",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:logging",
         "@com_google_fuzztest//fuzztest/internal:meta",
         "@com_google_fuzztest//fuzztest/internal:serialization",
diff --git a/domain_tests/domain_testing.h b/domain_tests/domain_testing.h
index e8b9009..9574b58 100644
--- a/domain_tests/domain_testing.h
+++ b/domain_tests/domain_testing.h
@@ -35,6 +35,7 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/domains/mutation_metadata.h"
 #include "./fuzztest/internal/logging.h"
 #include "./fuzztest/internal/meta.h"
@@ -145,8 +146,8 @@
   Value(const Domain& domain, T user_value)
       : corpus_value([&]() {
           auto corpus_value = domain.FromValue(user_value);
-          FUZZTEST_INTERNAL_CHECK_PRECONDITION(corpus_value.has_value(),
-                                               "Invalid user_value!");
+          FUZZTEST_PRECONDITION(corpus_value.has_value())
+              << "Invalid user_value!";
           return *corpus_value;
         }()),
         user_value(std::move(user_value)) {}
diff --git a/e2e_tests/BUILD b/e2e_tests/BUILD
index 78cb11b..9ca044f 100644
--- a/e2e_tests/BUILD
+++ b/e2e_tests/BUILD
@@ -25,10 +25,10 @@
     hdrs = ["test_binary_util.h"],
     deps = [
         "@abseil-cpp//absl/container:flat_hash_map",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:string_view",
         "@abseil-cpp//absl/time",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:flag_name",
         "@com_google_fuzztest//fuzztest/internal:subprocess",
     ],
@@ -65,6 +65,7 @@
         "@abseil-cpp//absl/strings:str_format",
         "@abseil-cpp//absl/time",
         "@com_google_fuzztest//centipede:weak_sancov_stubs",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:temp_dir",
         "@com_google_fuzztest//fuzztest/internal:escaping",
         "@com_google_fuzztest//fuzztest/internal:io",
@@ -91,7 +92,7 @@
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
         "@abseil-cpp//absl/time",
-        "@com_google_fuzztest//fuzztest/internal:logging",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:subprocess",
         "@re2",
     ],
@@ -146,7 +147,6 @@
         ":test_binary_util",
         "@abseil-cpp//absl/base:no_destructor",
         "@abseil-cpp//absl/container:flat_hash_map",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings",
diff --git a/e2e_tests/benchmark_test.cc b/e2e_tests/benchmark_test.cc
index feaa786..ef6146c 100644
--- a/e2e_tests/benchmark_test.cc
+++ b/e2e_tests/benchmark_test.cc
@@ -37,7 +37,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 #include "absl/time/time.h"
-#include "./fuzztest/internal/logging.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/subprocess.h"
 #include "re2/re2.h"
 
@@ -65,7 +65,7 @@
 std::string SelfPath() {
   char buf[4096];
   ssize_t len = readlink("/proc/self/exe", buf, sizeof(buf));
-  FUZZTEST_INTERNAL_CHECK(len < sizeof(buf), "Path too long!");
+  FUZZTEST_CHECK(len < sizeof(buf)) << "Path too long!";
   return std::string(buf, len);
 }
 std::string MicrobenchmarksBinaryPath() {
@@ -73,28 +73,30 @@
   const std::size_t dir_path_len = self_path.find_last_of('/');
   std::string binary_path = self_path.substr(0, dir_path_len) +
                             "/testdata/fuzz_tests_for_microbenchmarking";
-  FUZZTEST_INTERNAL_CHECK(std::filesystem::exists(binary_path), "Can't find ",
-                          binary_path);
+  FUZZTEST_CHECK(std::filesystem::exists(binary_path))
+      << "Can't find " << binary_path;
   return binary_path;
 }
 
 uint64_t ExtractTime(absl::string_view output) {
   static constexpr LazyRE2 kElapsedTimeRE = {"\nElapsed time: (.+)\n"};
   std::string duration_str;
-  FUZZTEST_INTERNAL_CHECK(
-      RE2::PartialMatch(output, *kElapsedTimeRE, &duration_str),
-      "\n\nCould not find:\n\nElapsed time:\n\nin:\n\n", output);
+  FUZZTEST_CHECK(RE2::PartialMatch(output, *kElapsedTimeRE, &duration_str))
+      << "\n\nCould not find:\n\nElapsed time:\n\nin:\n\n"
+      << output;
   absl::Duration duration;
-  FUZZTEST_INTERNAL_CHECK(absl::ParseDuration(duration_str, &duration),
-                          "Could not parse duration:", duration_str);
+  FUZZTEST_CHECK(absl::ParseDuration(duration_str, &duration))
+      << "Could not parse duration:" << duration_str;
   return absl::ToInt64Nanoseconds(duration);
 }
 
 uint64_t ExtractNumber(absl::string_view output, absl::string_view name) {
   uint64_t number;
-  FUZZTEST_INTERNAL_CHECK(
-      RE2::PartialMatch(output, absl::StrCat("\n", name, ": (.+)\n"), &number),
-      "\n\nCould not find\n\n", name, ":\n\nin:\n\n", output);
+  FUZZTEST_CHECK(
+      RE2::PartialMatch(output, absl::StrCat("\n", name, ": (.+)\n"), &number))
+      << "\n\nCould not find\n\n"
+      << name << ":\n\nin:\n\n"
+      << output;
   return number;
 }
 
@@ -141,8 +143,8 @@
       // This measures the cost of the framework on processing the edge map.
       // This way we can see if differences in a CL come from edge count
       // change or from implementation changes.
-      FUZZTEST_INTERNAL_CHECK(result.stats.total_edges != 0,
-                              "Total edges cannot be zero!");
+      FUZZTEST_CHECK(result.stats.total_edges != 0)
+          << "Total edges cannot be zero!";
       json_results.push_back(SingleJsonResult(
           "Control.Edges10000(time)",
           10000 * result.stats.nanos / result.stats.total_edges));
@@ -226,8 +228,7 @@
 int main(int argc, char** argv) {
 #if defined(__has_feature)
 #if !__has_feature(coverage_sanitizer)
-  FUZZTEST_INTERNAL_CHECK(false,
-                          "\n\nPlease compile with --config=fuzztest.\n");
+  FUZZTEST_CHECK(false) << "\n\nPlease compile with --config=fuzztest.\n";
 #endif
 #endif
   absl::ParseCommandLine(argc, argv);
diff --git a/e2e_tests/corpus_database_test.cc b/e2e_tests/corpus_database_test.cc
index 98422cd..af147ec 100644
--- a/e2e_tests/corpus_database_test.cc
+++ b/e2e_tests/corpus_database_test.cc
@@ -22,7 +22,6 @@
 #include "gtest/gtest.h"
 #include "absl/base/no_destructor.h"
 #include "absl/container/flat_hash_map.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -75,11 +74,12 @@
   static void SetUpTestSuite() {
 #if defined(__has_feature)
 #if !__has_feature(address_sanitizer)
-    CHECK(false) << "The test binary is not built with ASAN. Please run with "
-                    "--config=asan.";
+    FUZZTEST_CHECK(false)
+        << "The test binary is not built with ASAN. Please run with "
+           "--config=asan.";
 #elif !__has_feature(coverage_sanitizer) || !defined(FUZZTEST_USE_CENTIPEDE)
-    CHECK(false) << "The test binary is not built with coverage "
-                    "instrumentation for Centipede. "
+    FUZZTEST_CHECK(false) << "The test binary is not built with coverage "
+                             "instrumentation for Centipede. "
     "Please run with --config=fuzztest-experimental.";
 #endif
 #endif
@@ -146,7 +146,7 @@
         return RunBinary(CentipedePath(), centipede_options);
       }
     }
-    FUZZTEST_INTERNAL_CHECK(false, "Unsupported execution model!\n");
+    FUZZTEST_INTERNAL_FUZZTEST_CHECK(false, "Unsupported execution model!\n");
   }
 
  private:
diff --git a/e2e_tests/functional_test.cc b/e2e_tests/functional_test.cc
index 9ee676e..591013b 100644
--- a/e2e_tests/functional_test.cc
+++ b/e2e_tests/functional_test.cc
@@ -33,6 +33,7 @@
 #include "absl/strings/substitute.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
+#include "./common/logging.h"
 #include "./common/temp_dir.h"
 #include "./e2e_tests/test_binary_util.h"
 #include "./fuzztest/internal/escaping.h"
@@ -1288,7 +1289,7 @@
         return RunBinary(CentipedePath(), run_options);
       }
     }
-    FUZZTEST_INTERNAL_CHECK(false, "Unsupported execution model!\n");
+    FUZZTEST_CHECK(false) << "Unsupported execution model!\n";
   }
 };
 
diff --git a/e2e_tests/test_binary_util.cc b/e2e_tests/test_binary_util.cc
index 7aac989..0fe3112 100644
--- a/e2e_tests/test_binary_util.cc
+++ b/e2e_tests/test_binary_util.cc
@@ -20,10 +20,10 @@
 #include <system_error>  // NOLINT
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/flag_name.h"
 #include "./fuzztest/internal/subprocess.h"
 
@@ -34,12 +34,14 @@
 // root.
 std::string GetFullPath(const std::filesystem::path& relative_path) {
   const auto test_srcdir = absl::NullSafeStringView(std::getenv("TEST_SRCDIR"));
-  CHECK(!test_srcdir.empty()) << "Please set TEST_SRCDIR to non-empty value or "
-                                 "use bazel to run the test.";
+  FUZZTEST_CHECK(!test_srcdir.empty())
+      << "Please set TEST_SRCDIR to non-empty value or "
+         "use bazel to run the test.";
   const std::string full_path =
       std::filesystem::path(test_srcdir) / "_main"
       / relative_path;
-  CHECK(std::filesystem::exists(full_path)) << "Can't find " << full_path;
+  FUZZTEST_CHECK(std::filesystem::exists(full_path))
+      << "Can't find " << full_path;
   return full_path;
 }
 
diff --git a/e2e_tests/testdata/BUILD b/e2e_tests/testdata/BUILD
index 3c623f3..b21cb8f 100644
--- a/e2e_tests/testdata/BUILD
+++ b/e2e_tests/testdata/BUILD
@@ -50,7 +50,6 @@
         "@abseil-cpp//absl/algorithm:container",
         "@abseil-cpp//absl/container:flat_hash_map",
         "@abseil-cpp//absl/container:flat_hash_set",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/time",
         "@abseil-cpp//absl/types:span",
@@ -93,13 +92,13 @@
         "@abseil-cpp//absl/container:flat_hash_map",
         "@abseil-cpp//absl/container:flat_hash_set",
         "@abseil-cpp//absl/functional:function_ref",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/random:bit_gen_ref",
         "@abseil-cpp//absl/random:distributions",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
         "@abseil-cpp//absl/time",
         "@abseil-cpp//absl/types:span",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest",
         "@com_google_fuzztest//fuzztest:fuzztest_gtest_main",
         "@com_google_fuzztest//fuzztest:googletest_fixture_adapter",
diff --git a/e2e_tests/testdata/fuzz_tests_for_functional_testing.cc b/e2e_tests/testdata/fuzz_tests_for_functional_testing.cc
index 8049505..17df652 100644
--- a/e2e_tests/testdata/fuzz_tests_for_functional_testing.cc
+++ b/e2e_tests/testdata/fuzz_tests_for_functional_testing.cc
@@ -38,6 +38,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/logging.h"
 #include "./fuzztest/internal/test_protobuf.pb.h"
 #include "google/protobuf/descriptor.h"
@@ -735,12 +736,11 @@
     // where the callbacks from the signal handler happen in a separate stack.
     new_sigact.sa_flags = SA_SIGINFO | SA_ONSTACK;
 
-    FUZZTEST_INTERNAL_CHECK(sigaction(SIGUSR1, &new_sigact, nullptr) == 0,
-                            errno);
+    FUZZTEST_CHECK(sigaction(SIGUSR1, &new_sigact, nullptr) == 0) << errno;
     stack_t test_stack = {};
     test_stack.ss_size = 1 << 20;
     test_stack.ss_sp = malloc(test_stack.ss_size);
-    FUZZTEST_INTERNAL_CHECK(sigaltstack(&test_stack, &old_stack) == 0, errno);
+    FUZZTEST_CHECK(sigaltstack(&test_stack, &old_stack) == 0) << errno;
   }
 
   void StackCalculationWorksWithAlternateStackForSignalHandlers(int i) {
@@ -750,7 +750,7 @@
     // "stack overflow" detection and we will continue here.
     raise(SIGUSR1);
     // Just make sure the signal handler ran.
-    FUZZTEST_INTERNAL_CHECK(dummy_to_trigger_cmp_in_handler != 0, "");
+    FUZZTEST_CHECK(dummy_to_trigger_cmp_in_handler != 0);
 
     if (i == 123456789) {
       std::abort();
@@ -760,7 +760,7 @@
   ~AlternateSignalStackFixture() {
     stack_t test_stack = {};
     // Resume to the old signal stack.
-    FUZZTEST_INTERNAL_CHECK(sigaltstack(&old_stack, &test_stack) == 0, errno);
+    FUZZTEST_CHECK(sigaltstack(&old_stack, &test_stack) == 0) << errno;
     free(test_stack.ss_sp);
   }
 
diff --git a/e2e_tests/testdata/fuzz_tests_with_proto_inputs.cc b/e2e_tests/testdata/fuzz_tests_with_proto_inputs.cc
index 5fbc362..5cc7ee1 100644
--- a/e2e_tests/testdata/fuzz_tests_with_proto_inputs.cc
+++ b/e2e_tests/testdata/fuzz_tests_with_proto_inputs.cc
@@ -30,7 +30,6 @@
 #include "absl/algorithm/container.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
-#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
diff --git a/fuzztest/BUILD b/fuzztest/BUILD
index 7dc2a14..11ef509 100644
--- a/fuzztest/BUILD
+++ b/fuzztest/BUILD
@@ -79,6 +79,7 @@
         "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:string_view",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:logging",
         "@com_google_fuzztest//fuzztest/internal:registration",
         "@com_google_fuzztest//fuzztest/internal:registry",
@@ -91,9 +92,9 @@
     srcs = ["fuzztest_macros_test.cc"],
     deps = [
         ":fuzztest_macros",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/strings",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:temp_dir",
         "@googletest//:gtest_main",
     ],
@@ -124,6 +125,7 @@
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
         "@abseil-cpp//absl/time",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:configuration",
         "@com_google_fuzztest//fuzztest/internal:flag_name",
         "@com_google_fuzztest//fuzztest/internal:googletest_adaptor",
@@ -160,12 +162,11 @@
         "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/base:no_destructor",
         "@abseil-cpp//absl/flags:flag",
-        "@abseil-cpp//absl/log:absl_check",
         "@abseil-cpp//absl/random",
         "@abseil-cpp//absl/random:bit_gen_ref",
         "@abseil-cpp//absl/synchronization",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:io",
-        "@com_google_fuzztest//fuzztest/internal:logging",
         "@com_google_fuzztest//fuzztest/internal/domains:core_domains_impl",
     ],
     alwayslink = True,
@@ -193,6 +194,7 @@
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/strings:string_view",
         "@abseil-cpp//absl/types:span",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:any",
         "@com_google_fuzztest//fuzztest/internal:logging",
         "@com_google_fuzztest//fuzztest/internal:meta",
diff --git a/fuzztest/domain_core.h b/fuzztest/domain_core.h
index 926aba4..86a520e 100644
--- a/fuzztest/domain_core.h
+++ b/fuzztest/domain_core.h
@@ -44,6 +44,7 @@
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/any.h"
 #include "./fuzztest/internal/domains/aggregate_of_impl.h"
 #include "./fuzztest/internal/domains/arbitrary_impl.h"
@@ -83,18 +84,18 @@
   // values it can handle until we call Set on the name.
   template <typename T>
   Domain<T> Get(std::string_view name) {
-    FUZZTEST_INTERNAL_CHECK(domain_lookup_table_ != nullptr,
-                            "Finalize() has been called!");
+    FUZZTEST_CHECK(domain_lookup_table_ != nullptr)
+        << "Finalize() has been called!";
     return IndirectDomain<T>(GetIndirect<T>(name));
   }
 
   template <typename T>
   void Set(std::string_view name, const Domain<T>& domain) {
-    FUZZTEST_INTERNAL_CHECK(domain_lookup_table_ != nullptr,
-                            "Finalize() has been called!");
+    FUZZTEST_CHECK(domain_lookup_table_ != nullptr)
+        << "Finalize() has been called!";
     auto* indirect = GetIndirect<T>(name);
-    FUZZTEST_INTERNAL_CHECK(!indirect->has_value(),
-                            "Cannot set the same domain twice!");
+    FUZZTEST_CHECK(!indirect->has_value())
+        << "Cannot set the same domain twice!";
     *indirect = internal::MoveOnlyAny(std::in_place_type<Domain<T>>, domain);
   }
 
@@ -105,18 +106,17 @@
   // anymore.
   template <typename T>
   Domain<T> Finalize(std::string_view name) && {
-    FUZZTEST_INTERNAL_CHECK(domain_lookup_table_ != nullptr,
-                            "Finalize() has been called!");
-    FUZZTEST_INTERNAL_CHECK(
-        GetIndirect<T>(name)->has_value(),
-        // FUZZTEST_INTERNAL_CHECK uses absl::StrCat, which does not accept
+    FUZZTEST_CHECK(domain_lookup_table_ != nullptr)
+        << "Finalize() has been called!";
+    FUZZTEST_CHECK(GetIndirect<T>(name)->has_value())
+        <<
+        // FUZZTEST_CHECK uses absl::StrCat, which does not accept
         // std::string_view in iOS builds, so convert to absl::string_view.
-        "Finalize() has been called with an unknown name: ",
-        absl::string_view{name.data(), name.size()});
+        "Finalize() has been called with an unknown name: "
+        << absl::string_view{name.data(), name.size()};
     for (auto& iter : *domain_lookup_table_) {
-      FUZZTEST_INTERNAL_CHECK(
-          iter.second != nullptr && iter.second->has_value(),
-          "Some domain is not set yet!");
+      FUZZTEST_CHECK(iter.second != nullptr && iter.second->has_value())
+          << "Some domain is not set yet!";
     }
     auto domain = GetIndirect<T>(name)->template GetAs<Domain<T>>();
     return OwningDomain<T>(std::move(domain), std::move(domain_lookup_table_));
@@ -140,9 +140,8 @@
     if (!indirection) {
       indirection = std::make_unique<internal::MoveOnlyAny>();
     }
-    FUZZTEST_INTERNAL_CHECK(
-        !indirection->has_value() || indirection->Has<Domain<T>>(),
-        "The indirection must either be empty or hold a value of Domain<T>");
+    FUZZTEST_CHECK(!indirection->has_value() || indirection->Has<Domain<T>>())
+        << "The indirection must either be empty or hold a value of Domain<T>";
     return indirection.get();
   }
 
diff --git a/fuzztest/fuzztest_macros.cc b/fuzztest/fuzztest_macros.cc
index c8b5da3..ee3b1c5 100644
--- a/fuzztest/fuzztest_macros.cc
+++ b/fuzztest/fuzztest_macros.cc
@@ -32,6 +32,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/logging.h"
 #include "./fuzztest/internal/runtime.h"
 
@@ -88,17 +89,17 @@
     std::string_view dir, std::function<bool(std::string_view)> filter) {
   std::vector<std::tuple<std::string>> out;
   const std::filesystem::path fs_dir(dir);
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(std::filesystem::is_directory(fs_dir),
-                                       "Not a directory: ", fs_dir.string());
+  FUZZTEST_PRECONDITION(std::filesystem::is_directory(fs_dir))
+      << "Not a directory: " << fs_dir.string();
   for (const auto& entry :
        std::filesystem::recursive_directory_iterator(fs_dir)) {
     if (std::filesystem::is_directory(entry)) continue;
     if (!filter(entry.path().string())) continue;
 
     std::ifstream stream(entry.path());
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        stream.good(), "Cannot read input file: ", entry.path().string(), ": ",
-        strerror(errno));
+    FUZZTEST_PRECONDITION(stream.good())
+        << "Cannot read input file: " << entry.path().string() << ": "
+        << strerror(errno);
 
     std::stringstream buffer;
     buffer << stream.rdbuf();
@@ -145,20 +146,19 @@
 
 std::vector<std::string> ReadDictionaryFromFile(
     std::string_view dictionary_file) {
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-      !std::filesystem::is_directory(dictionary_file),
-      "Not a file: ", dictionary_file);
+  FUZZTEST_PRECONDITION(!std::filesystem::is_directory(dictionary_file))
+      << "Not a file: " << dictionary_file;
   const std::filesystem::path fs_path(dictionary_file);
   std::ifstream stream(fs_path);
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(stream.good(), "Error reading ",
-                                       fs_path.string(), ": ", strerror(errno));
+  FUZZTEST_PRECONDITION(stream.good())
+      << "Error reading " << fs_path.string() << ": " << strerror(errno);
   std::stringstream buffer;
   buffer << stream.rdbuf();
   absl::StatusOr<std::vector<std::string>> parsed_entries =
       ParseDictionary(buffer.str());
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-      parsed_entries.status().ok(), "Could not parse dictionary file ",
-      fs_path.string(), ": ", parsed_entries.status());
+  FUZZTEST_PRECONDITION(parsed_entries.status().ok())
+      << "Could not parse dictionary file " << fs_path.string() << ": "
+      << parsed_entries.status();
   return *parsed_entries;
 }
 
diff --git a/fuzztest/fuzztest_macros_test.cc b/fuzztest/fuzztest_macros_test.cc
index 0ddc009..41f44d9 100644
--- a/fuzztest/fuzztest_macros_test.cc
+++ b/fuzztest/fuzztest_macros_test.cc
@@ -8,9 +8,9 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/match.h"
+#include "./common/logging.h"
 #include "./common/temp_dir.h"
 
 namespace fuzztest::internal {
@@ -24,7 +24,7 @@
 
 void WriteFile(const std::string& file_name, const std::string& contents) {
   std::ofstream f(file_name);
-  CHECK(f.is_open());
+  FUZZTEST_CHECK(f.is_open());
   f << contents;
   f.close();
 }
diff --git a/fuzztest/init_fuzztest.cc b/fuzztest/init_fuzztest.cc
index 39b6d59..421c0d8 100644
--- a/fuzztest/init_fuzztest.cc
+++ b/fuzztest/init_fuzztest.cc
@@ -30,6 +30,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 #include "absl/time/time.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/configuration.h"
 #include "./fuzztest/internal/flag_name.h"
 #include "./fuzztest/internal/googletest_adaptor.h"
@@ -189,12 +190,12 @@
     "Internal-only flag - do not use directly. If set, only perform operations "
     "for the exact fuzz test regardless of other flags.")
     .OnUpdate([] {
-      FUZZTEST_INTERNAL_CHECK_PRECONDITION(
+      FUZZTEST_PRECONDITION(
           !absl::GetFlag(FUZZTEST_FLAG(internal_override_fuzz_test))
-                  .has_value() ||
-              std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr,
-          "must not set --" FUZZTEST_FLAG_PREFIX
-          "internal_override_fuzz_test directly");
+               .has_value() ||
+          std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr)
+          << "must not set --" FUZZTEST_FLAG_PREFIX
+             "internal_override_fuzz_test directly";
     });
 
 FUZZTEST_DEFINE_FLAG(
@@ -205,12 +206,12 @@
     "--" FUZZTEST_FLAG_PREFIX "fuzz_for / --" FUZZTEST_FLAG_PREFIX
     "replay_corpus_for with --time_budget_type set to total.")
     .OnUpdate([] {
-      FUZZTEST_INTERNAL_CHECK_PRECONDITION(
+      FUZZTEST_PRECONDITION(
           absl::GetFlag(FUZZTEST_FLAG(internal_override_total_time_limit)) ==
-                  absl::InfiniteDuration() ||
-              std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr,
-          "must not set --" FUZZTEST_FLAG_PREFIX
-          "internal_override_total_time_limit directly");
+              absl::InfiniteDuration() ||
+          std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr)
+          << "must not set --" FUZZTEST_FLAG_PREFIX
+             "internal_override_total_time_limit directly";
     });
 
 FUZZTEST_DEFINE_FLAG(std::optional<std::string>,
@@ -220,12 +221,12 @@
                      "internal_override_fuzz_test are set, replay "
                      "the input in the corpus database with the specified ID.")
     .OnUpdate([] {
-      FUZZTEST_INTERNAL_CHECK_PRECONDITION(
+      FUZZTEST_PRECONDITION(
           !absl::GetFlag(FUZZTEST_FLAG(internal_crashing_input_to_reproduce))
-                  .has_value() ||
-              std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr,
-          "must not set --" FUZZTEST_FLAG_PREFIX
-          "internal_crashing_input_to_reproduce directly");
+               .has_value() ||
+          std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr)
+          << "must not set --" FUZZTEST_FLAG_PREFIX
+             "internal_crashing_input_to_reproduce directly";
     });
 
 namespace fuzztest {
@@ -324,8 +325,9 @@
           ? internal::TimeBudgetType::kTotal
           : absl::GetFlag(FUZZTEST_FLAG(time_budget_type));
   const std::optional<size_t> jobs = absl::GetFlag(FUZZTEST_FLAG(jobs));
-  FUZZTEST_INTERNAL_CHECK(!jobs.has_value() || *jobs > 0, "If specified, --",
-                          FUZZTEST_FLAG(jobs).Name(), " must be positive.");
+  FUZZTEST_CHECK(!jobs.has_value() || *jobs > 0)
+      << "If specified, --" << FUZZTEST_FLAG(jobs).Name()
+      << " must be positive.";
   return internal::Configuration{
       absl::GetFlag(FUZZTEST_FLAG(corpus_database)),
       /*stats_root=*/"",
@@ -378,9 +380,8 @@
   std::optional<absl::Duration> fuzzing_time_limit = GetFuzzingTime();
   std::optional<absl::Duration> replay_corpus_time_limit =
       GetReplayCorpusTime();
-  FUZZTEST_INTERNAL_CHECK(
-      !fuzzing_time_limit || !replay_corpus_time_limit,
-      "Cannot run in fuzzing and corpus replay mode at the same time.");
+  FUZZTEST_CHECK(!fuzzing_time_limit || !replay_corpus_time_limit)
+      << "Cannot run in fuzzing and corpus replay mode at the same time.";
   const auto test_to_fuzz = absl::GetFlag(FUZZTEST_FLAG(fuzz));
   const auto test_to_replay_corpus =
       absl::GetFlag(FUZZTEST_FLAG(replay_corpus));
diff --git a/fuzztest/internal/BUILD b/fuzztest/internal/BUILD
index 5f88da0..01f5c94 100644
--- a/fuzztest/internal/BUILD
+++ b/fuzztest/internal/BUILD
@@ -24,6 +24,7 @@
     deps = [
         ":logging",
         ":meta",
+        "@com_google_fuzztest//common:logging",
     ],
 )
 
@@ -56,7 +57,6 @@
         "@abseil-cpp//absl/algorithm:container",
         "@abseil-cpp//absl/base:no_destructor",
         "@abseil-cpp//absl/functional:any_invocable",
-        "@abseil-cpp//absl/log:absl_log",
         "@abseil-cpp//absl/memory",
         "@abseil-cpp//absl/random",
         "@abseil-cpp//absl/random:distributions",
@@ -78,6 +78,7 @@
         "@com_google_fuzztest//centipede:stop",
         "@com_google_fuzztest//centipede:workdir",
         "@com_google_fuzztest//common:defs",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:remote_file",
         "@com_google_fuzztest//common:temp_dir",
         "@com_google_fuzztest//fuzztest/internal/domains:core_domains_impl",
@@ -107,12 +108,12 @@
     srcs = ["configuration.cc"],
     hdrs = ["configuration.h"],
     deps = [
-        "@abseil-cpp//absl/log:absl_check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:string_view",
         "@abseil-cpp//absl/time",
+        "@com_google_fuzztest//common:logging",
     ],
 )
 
@@ -155,7 +156,7 @@
         "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/strings:str_format",
         "@abseil-cpp//absl/types:span",
-        "@com_google_fuzztest//fuzztest/internal/domains:core_domains_impl",
+        "@com_google_fuzztest//common:logging",
     ],
 )
 
@@ -196,6 +197,7 @@
         ":registration",
         "@abseil-cpp//absl/functional:any_invocable",
         "@abseil-cpp//absl/types:span",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest:domain_core",
         "@googletest//:gtest_main",
     ],
@@ -243,6 +245,7 @@
         "@abseil-cpp//absl/types:span",
         "@com_google_fuzztest//common:blob_file",
         "@com_google_fuzztest//common:defs",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//common:remote_file",
     ] + select({
         "//conditions:default": [],
@@ -254,7 +257,6 @@
     srcs = ["io_test.cc"],
     deps = [
         ":io",
-        "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/time",
@@ -274,6 +276,7 @@
         "@abseil-cpp//absl/base:core_headers",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/synchronization",
+        "@com_google_fuzztest//common:logging",
     ],
 )
 
@@ -299,9 +302,9 @@
     deps = [
         "@abseil-cpp//absl/base:fast_type_id",
         "@abseil-cpp//absl/functional:function_ref",
-        "@abseil-cpp//absl/log:absl_check",
         "@abseil-cpp//absl/random:distributions",
         "@abseil-cpp//absl/types:span",
+        "@com_google_fuzztest//common:logging",
     ],
 )
 
@@ -360,7 +363,6 @@
         "@abseil-cpp//absl/functional:any_invocable",
         "@abseil-cpp//absl/functional:bind_front",
         "@abseil-cpp//absl/functional:function_ref",
-        "@abseil-cpp//absl/log:absl_check",
         "@abseil-cpp//absl/random",
         "@abseil-cpp//absl/random:bit_gen_ref",
         "@abseil-cpp//absl/random:distributions",
@@ -371,6 +373,7 @@
         "@abseil-cpp//absl/time",
         "@abseil-cpp//absl/types:span",
         "@com_google_fuzztest//common:bazel",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal/domains:core_domains_impl",
     ],
 )
@@ -400,6 +403,7 @@
         "@abseil-cpp//absl/random",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/types:span",
+        "@com_google_fuzztest//common:logging",
     ],
 )
 
@@ -454,12 +458,12 @@
     srcs = ["subprocess.cc"],
     hdrs = ["subprocess.h"],
     deps = [
-        ":logging",
         "@abseil-cpp//absl/container:flat_hash_map",
         "@abseil-cpp//absl/functional:function_ref",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/time",
         "@abseil-cpp//absl/types:span",
+        "@com_google_fuzztest//common:logging",
     ],
 )
 
diff --git a/fuzztest/internal/any.h b/fuzztest/internal/any.h
index 6c26c97..184e3a7 100644
--- a/fuzztest/internal/any.h
+++ b/fuzztest/internal/any.h
@@ -20,6 +20,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "./common/logging.h"
 #include "./fuzztest/internal/logging.h"
 #include "./fuzztest/internal/meta.h"
 
@@ -44,8 +45,8 @@
   }
 
   bool has_value() const {
-    FUZZTEST_INTERNAL_CHECK((vtable_ == nullptr) == (value_ == nullptr),
-                            "Inconsistent state between value and vtable.");
+    FUZZTEST_CHECK((vtable_ == nullptr) == (value_ == nullptr))
+        << "Inconsistent state between value and vtable.";
     return value_ != nullptr;
   }
 
@@ -56,29 +57,29 @@
 
   template <typename T>
   T& GetAs() & {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!");
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has<T>(), "Wrong type!");
+    FUZZTEST_PRECONDITION(has_value()) << "Object is empty!";
+    FUZZTEST_PRECONDITION(Has<T>()) << "Wrong type!";
     return *static_cast<T*>(value_);
   }
 
   template <typename T>
   const T& GetAs() const& {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!");
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has<T>(), "Wrong type!");
+    FUZZTEST_PRECONDITION(has_value()) << "Object is empty!";
+    FUZZTEST_PRECONDITION(Has<T>()) << "Wrong type!";
     return *static_cast<T*>(value_);
   }
 
   template <typename T>
   T&& GetAs() && {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!");
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has<T>(), "Wrong type!");
+    FUZZTEST_PRECONDITION(has_value()) << "Object is empty!";
+    FUZZTEST_PRECONDITION(Has<T>()) << "Wrong type!";
     return std::move(*static_cast<T*>(value_));
   }
 
   template <typename T>
   const T&& GetAs() const&& {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!");
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has<T>(), "Wrong type!");
+    FUZZTEST_PRECONDITION(has_value()) << "Object is empty!";
+    FUZZTEST_PRECONDITION(Has<T>()) << "Wrong type!";
     return std::move(*static_cast<const T*>(value_));
   }
 
@@ -104,7 +105,7 @@
   }
 
   void CopyFrom(const AnyBase& other) {
-    FUZZTEST_INTERNAL_CHECK(!has_value(), "CopyFrom called on a full object");
+    FUZZTEST_CHECK(!has_value()) << "CopyFrom called on a full object";
     if (other.has_value()) {
       vtable_ = other.vtable_;
       value_ = vtable_->copy(other.value_);
diff --git a/fuzztest/internal/centipede_adaptor.cc b/fuzztest/internal/centipede_adaptor.cc
index 13833ca..8266266 100644
--- a/fuzztest/internal/centipede_adaptor.cc
+++ b/fuzztest/internal/centipede_adaptor.cc
@@ -48,7 +48,6 @@
 #include "absl/algorithm/container.h"
 #include "absl/base/no_destructor.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/log/absl_log.h"
 #include "absl/memory/memory.h"
 #include "absl/random/distributions.h"
 #include "absl/random/random.h"
@@ -75,6 +74,7 @@
 #include "./centipede/stop.h"
 #include "./centipede/workdir.h"
 #include "./common/defs.h"
+#include "./common/logging.h"
 #include "./common/remote_file.h"
 #include "./common/temp_dir.h"
 #include "./fuzztest/internal/any.h"
@@ -209,19 +209,17 @@
         std::numeric_limits<decltype(env.timeout_per_input)>::max());
   }
   constexpr size_t kMiB = 1024 * 1024;
-  FUZZTEST_INTERNAL_CHECK(configuration.rss_limit % kMiB == 0,
-                          "configuration.rss_limit is not a multiple of MiB.");
+  FUZZTEST_CHECK(configuration.rss_limit % kMiB == 0)
+      << "configuration.rss_limit is not a multiple of MiB.";
   env.rss_limit_mb = configuration.rss_limit / kMiB;
   constexpr size_t kKiB = 1024;
-  FUZZTEST_INTERNAL_CHECK(
-      configuration.stack_limit % kKiB == 0,
-      "configuration.stack_limit is not a multiple of KiB.");
+  FUZZTEST_CHECK(configuration.stack_limit % kKiB == 0)
+      << "configuration.stack_limit is not a multiple of KiB.";
   env.stack_limit_kb = configuration.stack_limit / kKiB;
   env.populate_binary_info = false;
   const auto args = GetProcessArgs();
-  FUZZTEST_INTERNAL_CHECK(
-      args.ok(),
-      absl::StrCat("failed to get the original process args: ", args.status()));
+  FUZZTEST_CHECK(args.ok()) << absl::StrCat(
+      "failed to get the original process args: ", args.status());
   env.binary.clear();
   for (const auto& arg : *args) {
     // We need shell escaping, because env.binary will be passed to system(),
@@ -348,9 +346,9 @@
       // needs to be properly handled.
       new_sigact.sa_flags = SA_ONSTACK;
 
-      FUZZTEST_INTERNAL_CHECK(sigaction(signum, &new_sigact, nullptr) == 0,
-                              "Error installing signal handler: %s\n",
-                              strerror(errno));
+      FUZZTEST_CHECK(sigaction(signum, &new_sigact, nullptr) == 0)
+          << "Error installing signal handler: %s\n"
+          << strerror(errno);
     }
     return true;
   }();
@@ -387,8 +385,8 @@
       // Encoding signaled exit similarly as Bash.
       return 128 + static_cast<int>(std::get<SignalT>(status.Status()));
     }
-    FUZZTEST_INTERNAL_CHECK(
-        status.Exited(), "Termination status must be Exited if not Signaled");
+    FUZZTEST_CHECK(status.Exited())
+        << "Termination status must be Exited if not Signaled";
     return static_cast<int>(std::get<ExitCodeT>(status.Status()));
   }
   static absl::NoDestructor<DefaultCallbacksFactory<CentipedeDefaultCallbacks>>
@@ -557,8 +555,8 @@
     metadata->ForEachCmpEntry(
         [&cmp_tables](fuzztest::internal::ByteSpan a,
                       fuzztest::internal::ByteSpan b) {
-          FUZZTEST_INTERNAL_CHECK(a.size() == b.size(),
-                                  "cmp operands must have the same size");
+          FUZZTEST_CHECK(a.size() == b.size())
+              << "cmp operands must have the same size";
           const size_t size = a.size();
           if (size < kMinCmpEntrySize) return;
           if (size > kMaxCmpEntrySize) return;
@@ -627,8 +625,8 @@
 
   void RunFuzzTest(absl::AnyInvocable<void() &&> run_fuzz_test_once) override {
     orig_fixture_driver_->RunFuzzTest([&, this] {
-      FUZZTEST_INTERNAL_CHECK(configuration_ != nullptr,
-                              "Setting up a fuzz test without configuration!");
+      FUZZTEST_CHECK(configuration_ != nullptr)
+          << "Setting up a fuzz test without configuration!";
       PopulateTestLimitsToCentipedeRunner(*configuration_);
       std::move(run_fuzz_test_once)();
     });
@@ -675,8 +673,8 @@
       centipede_fixture_driver_(
           new CentipedeFixtureDriver(runtime_, std::move(fixture_driver))),
       fuzzer_impl_(test_, absl::WrapUnique(centipede_fixture_driver_)) {
-  FUZZTEST_INTERNAL_CHECK(centipede_fixture_driver_ != nullptr,
-                          "Invalid fixture driver!");
+  FUZZTEST_CHECK(centipede_fixture_driver_ != nullptr)
+      << "Invalid fixture driver!";
 }
 
 bool CentipedeFuzzerAdaptor::RunInUnitTestMode(
@@ -768,9 +766,8 @@
                     output.dir_path);
       break;
     default:
-      FUZZTEST_INTERNAL_CHECK(false,
-                              "unsupported reproducer output location type "
-                              "to report reproducers from Centipede");
+      FUZZTEST_CHECK(false) << "unsupported reproducer output location type "
+                               "to report reproducers from Centipede";
   }
 
   // Will be set when there is only one reproducer - nullopt otherwise.
@@ -903,26 +900,25 @@
           runner_callbacks);
       return;
     });
-    FUZZTEST_INTERNAL_CHECK(result.has_value(),
-                            "No result is set for running fuzz test");
+    FUZZTEST_CHECK(result.has_value())
+        << "No result is set for running fuzz test";
     return *result == EXIT_SUCCESS;
   } else if (is_running_property_function_in_this_process) {
     // If `is_running_property_function_in_this_process` holds at this point. We
     // assume it is for `ReplayInputsIfAvailable` to handle `FUZZTEST_REPLAY`
     // and `FUZZTEST_MINIMIZE_REPRODUCER`, which Centipede does not support.
     // This is fine because it does not require coverage instrumentation.
-    FUZZTEST_INTERNAL_CHECK(
-        std::getenv("FUZZTEST_REPLAY") ||
-            std::getenv("FUZZTEST_MINIMIZE_REPRODUCER"),
-        "Both env vars `FUZZTEST_REPLAY` and `FUZZTEST_MINIMIZE_REPRODUCER` "
-        "are not set when calling the legacy input replaying - this is a "
-        "FuzzTest bug!");
+    FUZZTEST_CHECK(std::getenv("FUZZTEST_REPLAY") ||
+                   std::getenv("FUZZTEST_MINIMIZE_REPRODUCER"))
+        << "Both env vars `FUZZTEST_REPLAY` and `FUZZTEST_MINIMIZE_REPRODUCER` "
+           "are not set when calling the legacy input replaying - this is a "
+           "FuzzTest bug!";
     fuzzer_impl_.fixture_driver_->RunFuzzTest([&, this]() {
-      FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-          fuzzer_impl_.ReplayInputsIfAvailable(configuration),
-          "ReplayInputsIfAvailable failed to handle env vars `FUZZTEST_REPLAY` "
-          "or `FUZZTEST_MINIMIZE_REPRODUCER`. Please check if they are set "
-          "properly.");
+      FUZZTEST_PRECONDITION(fuzzer_impl_.ReplayInputsIfAvailable(configuration))
+          << "ReplayInputsIfAvailable failed to handle env vars "
+             "`FUZZTEST_REPLAY` "
+             "or `FUZZTEST_MINIMIZE_REPRODUCER`. Please check if they are set "
+             "properly.";
       return;
     });
     return true;
@@ -942,9 +938,9 @@
       const std::string minimize_dir = minimize_dir_chars;
       const char* corpus_out_dir_chars =
           std::getenv("FUZZTEST_TESTSUITE_OUT_DIR");
-      FUZZTEST_INTERNAL_CHECK(corpus_out_dir_chars != nullptr,
-                              "FUZZTEST_TESTSUITE_OUT_DIR must be specified "
-                              "when minimizing testsuite");
+      FUZZTEST_CHECK(corpus_out_dir_chars != nullptr)
+          << "FUZZTEST_TESTSUITE_OUT_DIR must be specified "
+             "when minimizing testsuite";
       const std::string corpus_out_dir = corpus_out_dir_chars;
       absl::FPrintF(
           GetStderr(),
@@ -957,32 +953,32 @@
       // The first empty path means no output dir.
       replay_env.corpus_dir = {"", minimize_dir};
       replay_env.load_shards_only = true;
-      FUZZTEST_INTERNAL_CHECK(
-          RunCentipede(replay_env, configuration.centipede_command) == 0,
-          "Failed to replaying the testsuite for minimization");
+      FUZZTEST_CHECK(
+          RunCentipede(replay_env, configuration.centipede_command) == 0)
+          << "Failed to replaying the testsuite for minimization";
       absl::FPrintF(GetStderr(), "[.] Imported the corpus from %s.\n",
                     minimize_dir);
       // 2. Run Centipede distillation on the shard.
       auto distill_env = env;
       distill_env.distill = true;
-      FUZZTEST_INTERNAL_CHECK(
-          RunCentipede(distill_env, configuration.centipede_command) == 0,
-          "Failed to minimize the testsuite");
+      FUZZTEST_CHECK(
+          RunCentipede(distill_env, configuration.centipede_command) == 0)
+          << "Failed to minimize the testsuite";
       absl::FPrintF(GetStderr(),
                     "[.] Minimized the corpus using Centipede distillation.\n");
       // 3. Replace the shard corpus data with the distillation result.
       auto distill_workdir = fuzztest::internal::WorkDir(distill_env);
-      FUZZTEST_INTERNAL_CHECK(
+      FUZZTEST_CHECK(
           std::rename(
               distill_workdir.DistilledCorpusFilePaths().MyShard().c_str(),
-              distill_workdir.CorpusFilePaths().MyShard().c_str()) == 0,
-          "Failed to replace the corpus data with the minimized result");
+              distill_workdir.CorpusFilePaths().MyShard().c_str()) == 0)
+          << "Failed to replace the corpus data with the minimized result";
       // 4. Export the corpus of the shard.
       auto export_env = env;
       export_env.corpus_to_files = corpus_out_dir;
-      FUZZTEST_INTERNAL_CHECK(
-          RunCentipede(export_env, configuration.centipede_command) == 0,
-          "Failed to export the corpus to FUZZTEST_MINIMIZE_TESTSUITE_DIR");
+      FUZZTEST_CHECK(
+          RunCentipede(export_env, configuration.centipede_command) == 0)
+          << "Failed to export the corpus to FUZZTEST_MINIMIZE_TESTSUITE_DIR";
       absl::FPrintF(GetStderr(),
                     "[.] Exported the minimized the corpus to %s.\n",
                     corpus_out_dir);
diff --git a/fuzztest/internal/configuration.cc b/fuzztest/internal/configuration.cc
index f4f0ffc..ebe7304 100644
--- a/fuzztest/internal/configuration.cc
+++ b/fuzztest/internal/configuration.cc
@@ -22,12 +22,12 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/absl_check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 
@@ -99,14 +99,14 @@
 template <int&... ExplicitArgumentBarrier, typename IntT,
           typename = std::enable_if_t<std::is_integral_v<IntT>>>
 size_t WriteIntegral(std::string& out, size_t offset, IntT val) {
-  ABSL_CHECK_GE(out.size(), offset + SpaceFor(val));
+  FUZZTEST_CHECK_GE(out.size(), offset + SpaceFor(val));
   std::memcpy(out.data() + offset, &val, SpaceFor(val));
   offset += SpaceFor(val);
   return offset;
 }
 
 size_t WriteString(std::string& out, size_t offset, absl::string_view str) {
-  ABSL_CHECK_GE(out.size(), offset + SpaceFor(str));
+  FUZZTEST_CHECK_GE(out.size(), offset + SpaceFor(str));
   offset = WriteIntegral(out, offset, str.size());
   std::memcpy(out.data() + offset, str.data(), str.size());
   offset += str.size();
@@ -115,7 +115,7 @@
 
 size_t WriteOptionalString(std::string& out, size_t offset,
                            const std::optional<std::string>& str) {
-  ABSL_CHECK_GE(out.size(), offset + SpaceFor(str));
+  FUZZTEST_CHECK_GE(out.size(), offset + SpaceFor(str));
   offset = WriteIntegral(out, offset, str.has_value());
   if (str.has_value()) {
     offset = WriteString(out, offset, *str);
@@ -125,7 +125,7 @@
 
 size_t WriteVectorOfStrings(std::string& out, size_t offset,
                             const std::vector<std::string>& vec) {
-  ABSL_CHECK_GE(out.size(), offset + SpaceFor(vec));
+  FUZZTEST_CHECK_GE(out.size(), offset + SpaceFor(vec));
   offset = WriteIntegral(out, offset, vec.size());
   for (const std::string& str : vec) {
     offset = WriteString(out, offset, str);
@@ -236,7 +236,7 @@
   offset = WriteOptionalString(out, offset, centipede_command);
   offset = WriteOptionalString(out, offset, crashing_input_to_reproduce);
   offset = WriteOptionalString(out, offset, reproduction_command_template);
-  ABSL_CHECK_EQ(offset, out.size());
+  FUZZTEST_CHECK_EQ(offset, out.size());
   return out;
 }
 
diff --git a/fuzztest/internal/coverage.cc b/fuzztest/internal/coverage.cc
index bb647d4..43c25d7 100644
--- a/fuzztest/internal/coverage.cc
+++ b/fuzztest/internal/coverage.cc
@@ -26,6 +26,7 @@
 #include "absl/base/attributes.h"
 #include "absl/strings/str_format.h"
 #include "absl/types/span.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/flag_name.h"
 #include "./fuzztest/internal/logging.h"
 #include "./fuzztest/internal/table_of_recent_compares.h"
@@ -198,8 +199,8 @@
 FUZZTEST_INTERNAL_NOSANITIZE bool UpdateVectorized(
     const uint8_t *execution_data, uint8_t *corpus_data, size_t size,
     size_t offset_to_align) {
-  FUZZTEST_INTERNAL_CHECK(size >= kVectorSize,
-                          "size cannot be smaller than block size!");
+  FUZZTEST_CHECK(size >= kVectorSize)
+      << "size cannot be smaller than block size!";
 
   // Avoid collapsing the "greater than" vector until the end.
   Vector any_greater{};
@@ -290,8 +291,8 @@
   absl::Span<uint8_t> execution_map = execution_coverage->GetCounterMap();
   // Note: corpus_map_size_ will be larger than execution_map.size().
   // See the constructor for more details.
-  FUZZTEST_INTERNAL_CHECK(execution_map.size() <= corpus_map_size_,
-                          "Map size mismatch.");
+  FUZZTEST_CHECK(execution_map.size() <= corpus_map_size_)
+      << "Map size mismatch.";
 
   // Calculate the offset required to align `p` to alignof(Vector).
   void* p = execution_map.data();
@@ -348,10 +349,8 @@
 // where [start,end) is the array of 8-bit counters created for the current DSO.
 extern "C" void __sanitizer_cov_8bit_counters_init(uint8_t* start,
                                                    uint8_t* stop) {
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(start != nullptr,
-                                       "Invalid counter map address.");
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(start < stop,
-                                       "Invalid counter map size.");
+  FUZZTEST_PRECONDITION(start != nullptr) << "Invalid counter map address.";
+  FUZZTEST_PRECONDITION(start < stop) << "Invalid counter map size.";
   size_t map_size = stop - start;
 
   // For now, we assume single DSO. This means that this call back should get
diff --git a/fuzztest/internal/domains/BUILD b/fuzztest/internal/domains/BUILD
index 5a1d738..5e605dd 100644
--- a/fuzztest/internal/domains/BUILD
+++ b/fuzztest/internal/domains/BUILD
@@ -21,6 +21,7 @@
     hdrs = ["absl_helpers.h"],
     deps = [
         "@abseil-cpp//absl/time",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:logging",
     ],
 )
@@ -57,8 +58,6 @@
         ":absl_helpers",
         "@abseil-cpp//absl/container:flat_hash_set",
         "@abseil-cpp//absl/functional:function_ref",
-        "@abseil-cpp//absl/log:absl_check",
-        "@abseil-cpp//absl/log:absl_log",
         "@abseil-cpp//absl/numeric:bits",
         "@abseil-cpp//absl/numeric:int128",
         "@abseil-cpp//absl/random",
@@ -69,6 +68,7 @@
         "@abseil-cpp//absl/strings:str_format",
         "@abseil-cpp//absl/time",
         "@abseil-cpp//absl/types:span",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest:fuzzing_bit_gen",
         "@com_google_fuzztest//fuzztest/internal:any",
         "@com_google_fuzztest//fuzztest/internal:logging",
@@ -89,30 +89,18 @@
     ],
     deps = [
         ":core_domains_impl",
-        ":in_grammar_impl",
-        ":in_regexp_impl",
-        ":protobuf_domain_impl",
-        "@abseil-cpp//absl/base:core_headers",
-        "@abseil-cpp//absl/base:no_destructor",
-        "@abseil-cpp//absl/container:flat_hash_map",
-        "@abseil-cpp//absl/container:flat_hash_set",
         "@abseil-cpp//absl/functional:function_ref",
-        "@abseil-cpp//absl/random",
         "@abseil-cpp//absl/random:bit_gen_ref",
         "@abseil-cpp//absl/random:distributions",
         "@abseil-cpp//absl/status",
-        "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
-        "@abseil-cpp//absl/synchronization",
-        "@abseil-cpp//absl/types:span",
-        "@com_google_fuzztest//fuzztest:domain_core",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:any",
         "@com_google_fuzztest//fuzztest/internal:logging",
         "@com_google_fuzztest//fuzztest/internal:meta",
         "@com_google_fuzztest//fuzztest/internal:printer",
         "@com_google_fuzztest//fuzztest/internal:serialization",
-        "@com_google_fuzztest//fuzztest/internal:status",
         "@com_google_fuzztest//fuzztest/internal:type_support",
     ],
 )
@@ -154,6 +142,7 @@
         "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/types:span",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:logging",
         "@com_google_fuzztest//fuzztest/internal:serialization",
         "@com_google_fuzztest//fuzztest/internal:status",
@@ -177,6 +166,7 @@
         "@abseil-cpp//absl/strings:string_view",
         "@abseil-cpp//absl/synchronization",
         "@abseil-cpp//absl/types:span",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest:domain_core",
         "@com_google_fuzztest//fuzztest/internal:any",
         "@com_google_fuzztest//fuzztest/internal:logging",
@@ -199,6 +189,7 @@
         "@abseil-cpp//absl/status:statusor",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:string_view",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:logging",
         "@re2",
     ],
diff --git a/fuzztest/internal/domains/absl_helpers.h b/fuzztest/internal/domains/absl_helpers.h
index 57eafed..efcfe7c 100644
--- a/fuzztest/internal/domains/absl_helpers.h
+++ b/fuzztest/internal/domains/absl_helpers.h
@@ -20,6 +20,7 @@
 #include <utility>
 
 #include "absl/time/time.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/logging.h"
 
 namespace fuzztest::internal {
@@ -31,8 +32,8 @@
 inline absl::Duration MakeDuration(int64_t secs, uint32_t ticks) {
   // The granularity of a duration is as small as a quarter of a
   // nanosecond.
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(ticks >= 0u && ticks <= 3'999'999'999u,
-                                       "Ticks should be in range [0, 4B - 1]!");
+  FUZZTEST_PRECONDITION(ticks >= 0u && ticks <= 3'999'999'999u)
+      << "Ticks should be in range [0, 4B - 1]!";
   return absl::Seconds(secs) + (absl::Nanoseconds(1) / 4) * ticks;
 }
 
@@ -43,13 +44,13 @@
   int64_t ticks = (4 * rem) / absl::Nanoseconds(1);
   if (ticks < 0) {
     // It is impossible to have both a negative remainder and int64min seconds.
-    FUZZTEST_INTERNAL_CHECK(secs != std::numeric_limits<int64_t>::min(),
-                            "Seconds should not be int64 min!");
+    FUZZTEST_CHECK(secs != std::numeric_limits<int64_t>::min())
+        << "Seconds should not be int64 min!";
     secs -= 1;
     ticks += 4'000'000'000;
   }
-  FUZZTEST_INTERNAL_CHECK(0 <= ticks && ticks < 4'000'000'000,
-                          "Ticks should be in range [0, 4B - 1]!");
+  FUZZTEST_CHECK(0 <= ticks && ticks < 4'000'000'000)
+      << "Ticks should be in range [0, 4B - 1]!";
   return {secs, static_cast<uint32_t>(ticks)};
 }
 
diff --git a/fuzztest/internal/domains/bit_flag_combination_of_impl.h b/fuzztest/internal/domains/bit_flag_combination_of_impl.h
index 3ed7a52..6ad3deb 100644
--- a/fuzztest/internal/domains/bit_flag_combination_of_impl.h
+++ b/fuzztest/internal/domains/bit_flag_combination_of_impl.h
@@ -21,6 +21,7 @@
 #include "absl/random/bit_gen_ref.h"
 #include "absl/status/status.h"
 #include "absl/types/span.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/domains/domain_base.h"
 #include "./fuzztest/internal/logging.h"
 #include "./fuzztest/internal/type_support.h"
@@ -35,19 +36,18 @@
 
   explicit BitFlagCombinationOfImpl(absl::Span<const T> flags)
       : flags_(flags.begin(), flags.end()), all_flags_combo_{} {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        !flags.empty(), "BitFlagCombinationOf requires a non empty list.");
+    FUZZTEST_PRECONDITION(!flags.empty())
+        << "BitFlagCombinationOf requires a non empty list.";
     // Make sure they are mutually exclusive metadata, only_shrink and none are
     // empty.
     for (int i = 0; i < flags.size(); ++i) {
       T v1 = flags[i];
-      FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-          v1 != T{}, "BitFlagCombinationOf requires non zero flags.");
+      FUZZTEST_PRECONDITION(v1 != T{})
+          << "BitFlagCombinationOf requires non zero flags.";
       for (int j = i + 1; j < flags.size(); ++j) {
         T v2 = flags[j];
-        FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-            BitAnd(v1, v2) == T{},
-            "BitFlagCombinationOf requires flags to be mutually exclusive.");
+        FUZZTEST_PRECONDITION(BitAnd(v1, v2) == T{})
+            << "BitFlagCombinationOf requires flags to be mutually exclusive.";
       }
       all_flags_combo_ = BitOr(all_flags_combo_, v1);
     }
diff --git a/fuzztest/internal/domains/bit_gen_ref.h b/fuzztest/internal/domains/bit_gen_ref.h
index 980985d..824d35e 100644
--- a/fuzztest/internal/domains/bit_gen_ref.h
+++ b/fuzztest/internal/domains/bit_gen_ref.h
@@ -20,11 +20,10 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/absl_check.h"
-#include "absl/log/absl_log.h"
 #include "absl/random/bit_gen_ref.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
+#include "./common/logging.h"
 #include "./fuzztest/fuzzing_bit_gen.h"
 #include "./fuzztest/internal/domains/domain_base.h"
 #include "./fuzztest/internal/printer.h"
@@ -52,7 +51,7 @@
       : initializer_data_(o.initializer_data_), bitgen_(std::nullopt) {}
   BitGenCorpusValue& operator=(const BitGenCorpusValue& o) {
     // The internal URBG should be unused.
-    ABSL_CHECK(!bitgen_.has_value());
+    FUZZTEST_CHECK(!bitgen_.has_value());
     initializer_data_ = o.initializer_data_;
     return *this;
   }
@@ -61,8 +60,8 @@
         bitgen_(std::nullopt) {}
   BitGenCorpusValue& operator=(BitGenCorpusValue&& o) {
     // The internal URBG should be unused.
-    ABSL_CHECK(!o.bitgen_.has_value());
-    ABSL_CHECK(!bitgen_.has_value());
+    FUZZTEST_CHECK(!o.bitgen_.has_value());
+    FUZZTEST_CHECK(!bitgen_.has_value());
     initializer_data_ = std::move(o.initializer_data_);
     return *this;
   }
@@ -137,7 +136,7 @@
 
   value_type GetRandomValue(absl::BitGenRef prng) {
     // See b/404828355
-    ABSL_LOG(FATAL) << "The domain doesn't support GetRandomValue().";
+    FUZZTEST_LOG(FATAL) << "The domain doesn't support GetRandomValue().";
   }
 
   std::optional<corpus_type> FromValue(const value_type&) const {
diff --git a/fuzztest/internal/domains/container_of_impl.h b/fuzztest/internal/domains/container_of_impl.h
index 1db432c..d4202b8 100644
--- a/fuzztest/internal/domains/container_of_impl.h
+++ b/fuzztest/internal/domains/container_of_impl.h
@@ -31,6 +31,7 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/types/span.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/domains/container_mutation_helpers.h"
 #include "./fuzztest/internal/domains/domain_base.h"
 #include "./fuzztest/internal/logging.h"
@@ -113,9 +114,9 @@
               const domain_implementor::MutationMetadata& metadata,
               bool only_shrink) {
     permanent_dict_candidate_ = std::nullopt;
-    FUZZTEST_INTERNAL_CHECK(
-        min_size() <= val.size() && val.size() <= max_size(), "Size ",
-        val.size(), " is not between ", min_size(), " and ", max_size());
+    FUZZTEST_CHECK(min_size() <= val.size() && val.size() <= max_size())
+        << "Size " << val.size() << " is not between " << min_size() << " and "
+        << max_size();
 
     const bool can_shrink = val.size() > min_size();
     const bool can_grow = !only_shrink && val.size() < max_size();
@@ -220,16 +221,16 @@
     return Self();
   }
   Derived& WithMinSize(size_t s) {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        !max_size_.has_value() || s <= *max_size_, "Minimal size ", s,
-        " cannot be larger than maximal size ", *max_size_);
+    FUZZTEST_PRECONDITION(!max_size_.has_value() || s <= *max_size_)
+        << "Minimal size " << s << " cannot be larger than maximal size "
+        << *max_size_;
     min_size_ = s;
     return Self();
   }
   Derived& WithMaxSize(size_t s) {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        min_size_ <= s, "Maximal size ", s,
-        " cannot be smaller than minimal size ", min_size_);
+    FUZZTEST_PRECONDITION(min_size_ <= s)
+        << "Maximal size " << s << " cannot be smaller than minimal size "
+        << min_size_;
     max_size_ = s;
     return Self();
   }
@@ -238,9 +239,8 @@
                   "Manual Dictionary now only supports std::vector or "
                   "std::string or std::string_view.\n");
     for (const value_type& entry : manual_dict) {
-      FUZZTEST_INTERNAL_CHECK(
-          entry.size() <= max_size(),
-          "At least one dictionary entry is larger than max container size.");
+      FUZZTEST_CHECK(entry.size() <= max_size())
+          << "At least one dictionary entry is larger than max container size.";
       manual_dict_.AddEntry({std::nullopt, entry});
     }
     return Self();
diff --git a/fuzztest/internal/domains/domain_type_erasure.h b/fuzztest/internal/domains/domain_type_erasure.h
index 2dd3b08..442af9d 100644
--- a/fuzztest/internal/domains/domain_type_erasure.h
+++ b/fuzztest/internal/domains/domain_type_erasure.h
@@ -33,6 +33,7 @@
 #include "absl/random/bit_gen_ref.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/any.h"
 #include "./fuzztest/internal/domains/mutation_metadata.h"
 #include "./fuzztest/internal/logging.h"
@@ -228,9 +229,8 @@
       printer.PrintFormattedAggregateValue(val.GetAs<CorpusType>(), out, mode,
                                            prefix, suffix, element_formatter);
     } else {
-      FUZZTEST_INTERNAL_CHECK(false,
-                              "PrintFormattedAggregateValue() can only be "
-                              "called on AggregatePrinter!");
+      FUZZTEST_LOG(FATAL) << "PrintFormattedAggregateValue() can only be "
+                             "called on AggregatePrinter!";
     }
   }
 
diff --git a/fuzztest/internal/domains/element_of_impl.h b/fuzztest/internal/domains/element_of_impl.h
index 38fd281..0f3783f 100644
--- a/fuzztest/internal/domains/element_of_impl.h
+++ b/fuzztest/internal/domains/element_of_impl.h
@@ -24,6 +24,7 @@
 #include "absl/random/bit_gen_ref.h"
 #include "absl/random/distributions.h"
 #include "absl/time/time.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/domains/domain_base.h"
 #include "./fuzztest/internal/logging.h"
 #include "./fuzztest/internal/serialization.h"
@@ -42,8 +43,8 @@
   using typename ElementOfImpl::DomainBase::value_type;
 
   explicit ElementOfImpl(std::vector<T> values) : values_(values) {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        !values.empty(), "ElementOf requires a non empty list.");
+    FUZZTEST_PRECONDITION(!values.empty())
+        << "ElementOf requires a non empty list.";
   }
 
   corpus_type Init(absl::BitGenRef prng) {
diff --git a/fuzztest/internal/domains/filter_impl.h b/fuzztest/internal/domains/filter_impl.h
index a9b3130..f37b8f9 100644
--- a/fuzztest/internal/domains/filter_impl.h
+++ b/fuzztest/internal/domains/filter_impl.h
@@ -22,6 +22,7 @@
 #include "absl/random/bit_gen_ref.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/domains/domain.h"
 #include "./fuzztest/internal/domains/domain_base.h"
 #include "./fuzztest/internal/logging.h"
@@ -95,10 +96,10 @@
     bool res = predicate_(GetValue(v));
     if (!res) {
       ++num_skips_;
-      FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-          num_skips_ <= 100 || static_cast<double>(num_skips_) <=
-                                   .9 * static_cast<double>(num_values_),
-          absl::StrFormat(R"(
+      FUZZTEST_PRECONDITION(num_skips_ <= 100 ||
+                            static_cast<double>(num_skips_) <=
+                                .9 * static_cast<double>(num_values_))
+          << absl::StrFormat(R"(
 
 [!] Ineffective use of Filter() detected!
 
@@ -109,7 +110,7 @@
 chunk of the input domain, consider defining a custom domain by construction.
 See more details in the User Guide.
 )",
-                          num_skips_, num_values_));
+                             num_skips_, num_values_);
     }
     return res;
   }
diff --git a/fuzztest/internal/domains/in_grammar_impl.h b/fuzztest/internal/domains/in_grammar_impl.h
index ac34361..edcb72c 100644
--- a/fuzztest/internal/domains/in_grammar_impl.h
+++ b/fuzztest/internal/domains/in_grammar_impl.h
@@ -117,9 +117,8 @@
   static bool IsMutable(const ASTNode& /*val*/) { return false; }
 
   static IRObject SerializeCorpus(const ASTNode& astnode) {
-    FUZZTEST_INTERNAL_CHECK(
-        CheckASTNodeTypeIdAndChildType<std::monostate>(astnode, id),
-        "Invalid node!");
+    FUZZTEST_CHECK(CheckASTNodeTypeIdAndChildType<std::monostate>(astnode, id))
+        << "Invalid node!";
     return WrapASTIntoIRObject(astnode, {});
   }
 
@@ -166,9 +165,8 @@
   static ASTTypeId TypeId() { return id; }
 
   static void ToString(std::string& output, const ASTNode& val) {
-    FUZZTEST_INTERNAL_CHECK(
-        CheckASTNodeTypeIdAndChildType<RegexpDFA::Path>(val, id),
-        "Not a regex literal!");
+    FUZZTEST_CHECK(CheckASTNodeTypeIdAndChildType<RegexpDFA::Path>(val, id))
+        << "Not a regex literal!";
     absl::StrAppend(&output, GetInnerRegexpDomain().GetValue(
                                  std::get<RegexpDFA::Path>(val.children)));
   }
@@ -176,9 +174,8 @@
   static bool IsMutable(const ASTNode& /*val*/) { return true; }
 
   static IRObject SerializeCorpus(const ASTNode& astnode) {
-    FUZZTEST_INTERNAL_CHECK(
-        CheckASTNodeTypeIdAndChildType<RegexpDFA::Path>(astnode, id),
-        "Not a regex literal!");
+    FUZZTEST_CHECK(CheckASTNodeTypeIdAndChildType<RegexpDFA::Path>(astnode, id))
+        << "Not a regex literal!";
     return WrapASTIntoIRObject(
         astnode, GetInnerRegexpDomain().SerializeCorpus(
                      std::get<RegexpDFA::Path>(astnode.children)));
@@ -258,9 +255,9 @@
   static void Mutate(ASTNode& val, absl::BitGenRef prng,
                      const domain_implementor::MutationMetadata& metadata,
                      bool only_shrink) {
-    FUZZTEST_INTERNAL_CHECK(
-        CheckASTNodeTypeIdAndChildType<std::vector<ASTNode>>(val, id),
-        "Not a vector!");
+    FUZZTEST_CHECK(
+        CheckASTNodeTypeIdAndChildType<std::vector<ASTNode>>(val, id))
+        << "Not a vector!";
     std::vector<ASTNode>& elements =
         std::get<std::vector<ASTNode>>(val.children);
     if (only_shrink) {
@@ -272,7 +269,7 @@
         !elements.empty() && ElementT::IsMutable(elements.back());
     constexpr bool can_change_element_num = max > min;
     if (!can_mutate_element && !can_change_element_num) {
-      FUZZTEST_INTERNAL_CHECK(false, "We shouldn't pick an unmutable node.");
+      FUZZTEST_LOG(FATAL) << "We shouldn't pick an unmutable node.";
       return;
     }
     if (!can_mutate_element) {
@@ -301,9 +298,9 @@
   static bool IsMutable(const ASTNode& /*val*/) { return true; }
 
   static IRObject SerializeCorpus(const ASTNode& astnode) {
-    FUZZTEST_INTERNAL_CHECK(
-        CheckASTNodeTypeIdAndChildType<std::vector<ASTNode>>(astnode, id),
-        "Not a vector!");
+    FUZZTEST_CHECK(
+        CheckASTNodeTypeIdAndChildType<std::vector<ASTNode>>(astnode, id))
+        << "Not a vector!";
     IRObject expansion_obj;
     auto& inner_subs = expansion_obj.MutableSubs();
     for (auto& node : std::get<std::vector<ASTNode>>(astnode.children)) {
@@ -425,11 +422,11 @@
   static void Mutate(ASTNode& val, absl::BitGenRef prng,
                      const domain_implementor::MutationMetadata& metadata,
                      bool only_shrink) {
-    FUZZTEST_INTERNAL_CHECK(
+    FUZZTEST_CHECK(
         CheckASTNodeTypeIdAndChildType<std::vector<ASTNode>>(val, id) &&
-            std::get<std::vector<ASTNode>>(val.children).size() ==
-                sizeof...(ElementT),
-        "Tuple elements number doesn't match!");
+        std::get<std::vector<ASTNode>>(val.children).size() ==
+            sizeof...(ElementT))
+        << "Tuple elements number doesn't match!";
 
     std::vector<int> mutables;
     ApplyIndex<sizeof...(ElementT)>([&](auto... I) {
@@ -439,9 +436,8 @@
        ...);
     });
 
-    FUZZTEST_INTERNAL_CHECK(
-        !mutables.empty(),
-        "If the tuple is immutable it shouldn't be picked for mutation.");
+    FUZZTEST_CHECK(!mutables.empty())
+        << "If the tuple is immutable it shouldn't be picked for mutation.";
 
     int choice = mutables[absl::Uniform<int>(prng, 0, mutables.size())];
     ApplyIndex<sizeof...(ElementT)>([&](auto... I) {
@@ -472,9 +468,9 @@
   }
 
   static IRObject SerializeCorpus(const ASTNode& astnode) {
-    FUZZTEST_INTERNAL_CHECK(
-        CheckASTNodeTypeIdAndChildType<std::vector<ASTNode>>(astnode, id),
-        "Invalid node!");
+    FUZZTEST_CHECK(
+        CheckASTNodeTypeIdAndChildType<std::vector<ASTNode>>(astnode, id))
+        << "Invalid node!";
     IRObject expansion_obj;
     auto& inner_subs = expansion_obj.MutableSubs();
     ApplyIndex<sizeof...(ElementT)>([&](auto... I) {
@@ -571,8 +567,8 @@
           : (void)0),
      ...);
 
-    FUZZTEST_INTERNAL_CHECK(is_current_value_mutable || has_alternative,
-                            "Impossible at" + std::to_string(id));
+    FUZZTEST_CHECK(is_current_value_mutable || has_alternative)
+        << "Impossible at" << id;
     if (only_shrink) {
       if (is_current_value_mutable) {
         MutateCurrentValue(val, prng, metadata, only_shrink);
@@ -594,9 +590,8 @@
   }
 
   static void ToString(std::string& output, const ASTNode& val) {
-    FUZZTEST_INTERNAL_CHECK(
-        std::get<std::vector<ASTNode>>(val.children).size() == 1,
-        "This is not a variant ast node.");
+    FUZZTEST_CHECK(std::get<std::vector<ASTNode>>(val.children).size() == 1)
+        << "This is not a variant ast node.";
     auto child = std::get<std::vector<ASTNode>>(val.children).front();
     ((ElementT::TypeId() == child.type_id ? (ElementT::ToString(output, child))
                                           : (void)0),
@@ -618,9 +613,9 @@
   }
 
   static IRObject SerializeCorpus(const ASTNode& astnode) {
-    FUZZTEST_INTERNAL_CHECK(
-        CheckASTNodeTypeIdAndChildType<std::vector<ASTNode>>(astnode, id),
-        "Invalid node!");
+    FUZZTEST_CHECK(
+        CheckASTNodeTypeIdAndChildType<std::vector<ASTNode>>(astnode, id))
+        << "Invalid node!";
 
     ASTTypeId child_id =
         std::get<std::vector<ASTNode>>(astnode.children).front().type_id;
@@ -690,7 +685,7 @@
   }
   static void SwitchToAlternative(ASTNode& val, absl::BitGenRef prng) {
     constexpr int n_alternative = sizeof...(ElementT);
-    FUZZTEST_INTERNAL_CHECK(n_alternative > 1, "No alternative to switch!");
+    FUZZTEST_CHECK(n_alternative > 1) << "No alternative to switch!";
     int child_type_id =
         std::get<std::vector<ASTNode>>(val.children).front().type_id;
     int current_choice = 0;
@@ -751,7 +746,7 @@
   }
 
   std::optional<corpus_type> FromValue(const value_type& /*v*/) const {
-    FUZZTEST_INTERNAL_CHECK(false, "Parsing is not implemented yet!");
+    FUZZTEST_CHECK(false) << "Parsing is not implemented yet!";
     return std::nullopt;
   }
 
@@ -790,8 +785,8 @@
     size_t src_index =
         absl::Uniform<size_t>(prng, dst_index + 1, candidates.size());
 
-    FUZZTEST_INTERNAL_CHECK(src_index < candidates.size(), "Out of bound!");
-    FUZZTEST_INTERNAL_CHECK(dst_index < candidates.size(), "Out of bound!");
+    FUZZTEST_CHECK(src_index < candidates.size()) << "Out of bound!";
+    FUZZTEST_CHECK(dst_index < candidates.size()) << "Out of bound!";
     if (candidates[dst_index]->NodeCount() <
         candidates[src_index]->NodeCount()) {
       std::swap(dst_index, src_index);
diff --git a/fuzztest/internal/domains/in_range_impl.h b/fuzztest/internal/domains/in_range_impl.h
index 8b6cff5..0d77a50 100644
--- a/fuzztest/internal/domains/in_range_impl.h
+++ b/fuzztest/internal/domains/in_range_impl.h
@@ -29,6 +29,7 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/domains/domain_base.h"
 #include "./fuzztest/internal/domains/special_values.h"
 #include "./fuzztest/internal/domains/value_mutation_helpers.h"
@@ -53,15 +54,13 @@
                          IntegerDictionary<T>, bool>;
 
   explicit InRangeImpl(T min, T max) : min_(min), max_(max) {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        min <= max, "min must be less than or equal to max!");
+    FUZZTEST_PRECONDITION(min <= max)
+        << "min must be less than or equal to max!";
     if constexpr (!T_is_integer) {
-      FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-          !(min == std::numeric_limits<T>::lowest() &&
-            max == std::numeric_limits<T>::max()),
-          "Consider using the Finite<T>() domain instead.");
-      FUZZTEST_INTERNAL_CHECK_PRECONDITION(std::isfinite(max - min),
-                                           "Range is too large!");
+      FUZZTEST_PRECONDITION(!(min == std::numeric_limits<T>::lowest() &&
+                              max == std::numeric_limits<T>::max()))
+          << "Consider using the Finite<T>() domain instead.";
+      FUZZTEST_PRECONDITION(std::isfinite(max - min)) << "Range is too large!";
     }
     if constexpr (T_is_integer) {
       // Find the longest common prefix
diff --git a/fuzztest/internal/domains/in_regexp_impl.cc b/fuzztest/internal/domains/in_regexp_impl.cc
index 81d8141..ae97e62 100644
--- a/fuzztest/internal/domains/in_regexp_impl.cc
+++ b/fuzztest/internal/domains/in_regexp_impl.cc
@@ -28,6 +28,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/types/span.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/domains/domain_base.h"
 #include "./fuzztest/internal/domains/regexp_dfa.h"
 #include "./fuzztest/internal/logging.h"
@@ -44,8 +45,7 @@
   if (auto seed = MaybeGetRandomSeed(prng)) return *seed;
   absl::StatusOr<RegexpDFA::Path> path =
       dfa_.StringToPath(dfa_.GenerateString(prng));
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(path.ok(),
-                                       "Init should generate valid paths");
+  FUZZTEST_PRECONDITION(path.ok()) << "Init should generate valid paths";
   return *path;
 }
 
@@ -102,7 +102,7 @@
 
 InRegexpImpl::value_type InRegexpImpl::GetValue(const corpus_type& v) const {
   absl::StatusOr<std::string> val = dfa_.PathToString(v);
-  FUZZTEST_INTERNAL_CHECK(val.ok(), "Corpus is invalid!");
+  FUZZTEST_CHECK(val.ok()) << "Corpus is invalid!";
   return *val;
 }
 
@@ -150,9 +150,9 @@
 
 void InRegexpImpl::ValidatePathRoundtrip(const RegexpDFA::Path& path) const {
   absl::StatusOr<std::string> str = dfa_.PathToString(path);
-  FUZZTEST_INTERNAL_CHECK(str.ok(), "Invalid path in the DFA!");
+  FUZZTEST_CHECK(str.ok()) << "Invalid path in the DFA!";
   absl::StatusOr<RegexpDFA::Path> new_path = dfa_.StringToPath(*str);
-  FUZZTEST_INTERNAL_CHECK(new_path.ok(), "Invalid path in the DFA!");
+  FUZZTEST_CHECK(new_path.ok()) << "Invalid path in the DFA!";
 }
 
 bool InRegexpImpl::ShrinkByRemoveLoop(absl::BitGenRef prng,
diff --git a/fuzztest/internal/domains/optional_of_impl.h b/fuzztest/internal/domains/optional_of_impl.h
index e80b93d..812a92e 100644
--- a/fuzztest/internal/domains/optional_of_impl.h
+++ b/fuzztest/internal/domains/optional_of_impl.h
@@ -27,6 +27,7 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/domains/domain.h"
 #include "./fuzztest/internal/domains/domain_base.h"
 #include "./fuzztest/internal/domains/serialization_helpers.h"
@@ -98,12 +99,12 @@
 
   value_type GetValue(const corpus_type& v) const {
     if (v.index() == 0) {
-      FUZZTEST_INTERNAL_CHECK(policy_ != OptionalPolicy::kWithoutNull,
-                              "Value cannot be null!");
+      FUZZTEST_CHECK(policy_ != OptionalPolicy::kWithoutNull)
+          << "Value cannot be null!";
       return value_type();
     }
-    FUZZTEST_INTERNAL_CHECK(policy_ != OptionalPolicy::kAlwaysNull,
-                            "Value cannot be non-null!");
+    FUZZTEST_CHECK(policy_ != OptionalPolicy::kAlwaysNull)
+        << "Value cannot be non-null!";
     return value_type(inner_.GetValue(std::get<1>(v)));
   }
 
diff --git a/fuzztest/internal/domains/overlap_of_impl.h b/fuzztest/internal/domains/overlap_of_impl.h
index 92ed0b9..1e074cf 100644
--- a/fuzztest/internal/domains/overlap_of_impl.h
+++ b/fuzztest/internal/domains/overlap_of_impl.h
@@ -25,6 +25,7 @@
 #include "absl/random/distributions.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/domains/domain_base.h"
 #include "./fuzztest/internal/domains/serialization_helpers.h"
 #include "./fuzztest/internal/logging.h"
@@ -88,9 +89,9 @@
         Switch<kNumDomains>(mutation_index, [&](auto I) {
           auto& domain = std::get<I>(domains_);
           auto inner_corpus = domain.FromValue(*orig_value);
-          FUZZTEST_INTERNAL_CHECK(inner_corpus.has_value(),
-                                  "Mutate() called on a user value that is not "
-                                  "valid in all overlapping domains");
+          FUZZTEST_CHECK(inner_corpus.has_value())
+              << "Mutate() called on a user value that is not "
+                 "valid in all overlapping domains";
           domain.Mutate(*inner_corpus, prng, metadata, only_shrink);
           mutant_corpus =
               corpus_type(std::in_place_index<I>, *std::move(inner_corpus));
@@ -103,8 +104,8 @@
                         only_shrink);
         });
       }
-      FUZZTEST_INTERNAL_CHECK(mutant_corpus.has_value(),
-                              "mutant corpus value is missing");
+      FUZZTEST_CHECK(mutant_corpus.has_value())
+          << "mutant corpus value is missing";
       const bool valid =
           ValidateCorpusValueForOtherDomains(*mutant_corpus).ok();
       MaybeReportOnValidationResult(valid);
@@ -169,9 +170,9 @@
     return Switch<kNumDomains>(*serialization_domain_index_, [&](auto I) {
       auto& domain = std::get<I>(domains_);
       const auto inner_corpus = domain.FromValue(user_value);
-      FUZZTEST_INTERNAL_CHECK(inner_corpus.has_value(),
-                              "Mutate() called on a user value that is not "
-                              "valid in all overlapping domains");
+      FUZZTEST_CHECK(inner_corpus.has_value())
+          << "Mutate() called on a user value that is not "
+             "valid in all overlapping domains";
       return domain.SerializeCorpus(*inner_corpus);
     });
   }
@@ -199,10 +200,8 @@
   size_t num_validation_failures_ = 0;
 
   OverlapOfImpl& WithSerializationDomain(size_t index) {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        index < kNumDomains,
-        absl::StrFormat("Serialization domain index must be less than %d",
-                        kNumDomains));
+    FUZZTEST_PRECONDITION(index < kNumDomains)
+        << "Serialization domain index must be less than " << kNumDomains;
     serialization_domain_index_ = index;
     return *this;
   }
@@ -235,18 +234,19 @@
     ++num_validation_attempts_;
     if (!succeeded) {
       ++num_validation_failures_;
-      FUZZTEST_INTERNAL_CHECK_PRECONDITION(
+      FUZZTEST_PRECONDITION(
           num_validation_attempts_ <= 100 ||
-              static_cast<double>(num_validation_failures_) <=
-                  .9 * static_cast<double>(num_validation_attempts_),
-          absl::StrFormat(R"(
+          static_cast<double>(num_validation_failures_) <=
+              .9 * static_cast<double>(num_validation_attempts_))
+          << absl::StrFormat(R"(
 
 [!] Ineffective use of overlapping domains detected!
 
 Values were not valid on all of the overlapping domains on more than 90%% of the samples.
 %d out of %d have failed.
 )",
-                          num_validation_failures_, num_validation_attempts_));
+                             num_validation_failures_,
+                             num_validation_attempts_);
     }
   }
 };
diff --git a/fuzztest/internal/domains/protobuf_domain_impl.h b/fuzztest/internal/domains/protobuf_domain_impl.h
index 0a71274..be0e9b0 100644
--- a/fuzztest/internal/domains/protobuf_domain_impl.h
+++ b/fuzztest/internal/domains/protobuf_domain_impl.h
@@ -40,6 +40,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/synchronization/mutex.h"
 #include "absl/types/span.h"
+#include "./common/logging.h"
 #include "./fuzztest/domain_core.h"
 #include "./fuzztest/internal/any.h"
 #include "./fuzztest/internal/domains/arbitrary_impl.h"
@@ -284,39 +285,36 @@
   }
 
   OptionalPolicy GetOptionalPolicy(const FieldDescriptor* field) const {
-    FUZZTEST_INTERNAL_CHECK(
-        !field->is_required() && !field->is_repeated(),
-        "GetOptionalPolicy should apply to optional fields only!");
+    FUZZTEST_CHECK(!field->is_required() && !field->is_repeated())
+        << "GetOptionalPolicy should apply to optional fields only!";
     std::optional<OptionalPolicy> result =
         GetPolicyValue(optional_policies_, field);
-    FUZZTEST_INTERNAL_CHECK(result.has_value(), "optional policy is not set!");
+    FUZZTEST_CHECK(result.has_value()) << "optional policy is not set!";
     return *result;
   }
 
   std::optional<int64_t> GetMinRepeatedFieldSize(
       const FieldDescriptor* field) const {
-    FUZZTEST_INTERNAL_CHECK(
-        field->is_repeated(),
-        "GetMinRepeatedFieldSize should apply to repeated fields only!");
+    FUZZTEST_CHECK(field->is_repeated())
+        << "GetMinRepeatedFieldSize should apply to repeated fields only!";
     auto min = GetPolicyValue(min_repeated_fields_sizes_, field);
     auto max = GetPolicyValue(max_repeated_fields_sizes_, field);
     if (min.has_value() && max.has_value()) {
-      FUZZTEST_INTERNAL_CHECK(*min <= *max, "Repeated field ",
-                              field->full_name(), " size range is not valid!");
+      FUZZTEST_CHECK(*min <= *max) << "Repeated field " << field->full_name()
+                                   << " size range is not valid!";
     }
     return min;
   }
 
   std::optional<int64_t> GetMaxRepeatedFieldSize(
       const FieldDescriptor* field) const {
-    FUZZTEST_INTERNAL_CHECK(
-        field->is_repeated(),
-        "GetMaxRepeatedFieldSize should apply to repeated fields only!");
+    FUZZTEST_CHECK(field->is_repeated())
+        << "GetMaxRepeatedFieldSize should apply to repeated fields only!";
     auto min = GetPolicyValue(min_repeated_fields_sizes_, field);
     auto max = GetPolicyValue(max_repeated_fields_sizes_, field);
     if (min.has_value() && max.has_value()) {
-      FUZZTEST_INTERNAL_CHECK(*min <= *max, "Repeated field ",
-                              field->full_name(), " size range is not valid!");
+      FUZZTEST_CHECK(*min <= *max) << "Repeated field " << field->full_name()
+                                   << " size range is not valid!";
     }
     return max;
   }
@@ -344,13 +342,13 @@
         auto domain = filter_to_values[i].value;
         auto obj = domain.GetValue(domain.Init(gen));
         auto* descriptor = obj->GetDescriptor();
-        FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-            descriptor->full_name() == field->message_type()->full_name(),
-            "Input domain does not match the expected message type. The "
-            "domain produced a message of type `",
-            descriptor->full_name(),
-            "` but the field needs a message of type `",
-            field->message_type()->full_name(), "`.");
+        FUZZTEST_PRECONDITION(descriptor->full_name() ==
+                              field->message_type()->full_name())
+            << "Input domain does not match the expected message type. The "
+               "domain produced a message of type `"
+            << descriptor->full_name()
+            << "` but the field needs a message of type `"
+            << field->message_type()->full_name() << "`.";
       }
       return filter_to_values[i].value;
     }
@@ -414,8 +412,8 @@
       : prototype_factory_(std::move(prototype_factory)), prototype_(nullptr) {}
   PrototypePtr(const Prototype* prototype)
       : prototype_factory_(), prototype_(prototype) {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(prototype != nullptr,
-                                         "Prototype should not be nullptr");
+    FUZZTEST_PRECONDITION(prototype != nullptr)
+        << "Prototype should not be nullptr";
   }
 
   PrototypePtr& operator=(const PrototypePtr<Prototype>& other) = default;
@@ -471,10 +469,10 @@
   corpus_type Init(absl::BitGenRef prng) {
     if (auto seed = this->MaybeGetRandomSeed(prng)) return *seed;
     const auto* descriptor = prototype_.Get()->GetDescriptor();
-    FUZZTEST_INTERNAL_CHECK(
-        !IsCustomizedRecursivelyOnly() || !IsInfinitelyRecursive(descriptor),
-        absl::StrCat("Cannot set recursive fields for ",
-                     descriptor->full_name(), " by default."));
+    FUZZTEST_CHECK(!IsCustomizedRecursivelyOnly() ||
+                   !IsInfinitelyRecursive(descriptor))
+        << "Cannot set recursive fields for " << descriptor->full_name()
+        << " by default.";
     corpus_type val;
     absl::flat_hash_map<int, int> oneof_to_field;
 
@@ -593,7 +591,7 @@
     for (auto& [number, inner] : v) {
       if (IsMetadataEntry(number)) continue;
       auto* field = GetField(number);
-      FUZZTEST_INTERNAL_CHECK(field, "Field not found by number: ", number);
+      FUZZTEST_CHECK(field) << "Field not found by number: " << number;
       IRObject& pair = subs.emplace_back();
       auto& pair_subs = pair.MutableSubs();
       pair_subs.reserve(2);
@@ -1061,9 +1059,9 @@
       auto& domain = self.GetSubDomain<T, false>(field);
       auto value = domain.GetValue(data);
       if (!value.has_value()) {
-        FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-            !field->is_required(), "required field '",
-            std::string(field->full_name()), "' cannot have null values.");
+        FUZZTEST_PRECONDITION(!field->is_required())
+            << "required field '" << std::string(field->full_name())
+            << "' cannot have null values.";
         message.GetReflection()->ClearField(&message, field);
         return;
       }
@@ -1269,10 +1267,9 @@
     template <typename T, typename DomainT, bool is_repeated>
     void ApplyDomain(const FieldDescriptor* field) {
       if constexpr (!std::is_constructible_v<DomainT, Inner>) {
-        FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-            (std::is_constructible_v<DomainT, Inner>),
-            "Input domain does not match field `", field->full_name(),
-            "` type.");
+        FUZZTEST_PRECONDITION((std::is_constructible_v<DomainT, Inner>))
+            << "Input domain does not match field `" << field->full_name()
+            << "` type.";
       } else {
         if constexpr (std::is_same_v<T, ProtoMessageTag>) {
           // Verify that the type matches.
@@ -1285,22 +1282,22 @@
             domain.Mutate(val, gen, {}, false);
             descriptor = GetDescriptor<is_repeated>(val);
           }
-          FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-              !descriptor ||
-                  descriptor->full_name() == field->message_type()->full_name(),
-              "Input domain does not match the expected message type. The "
-              "domain produced a message of type `",
-              descriptor->full_name(),
-              "` but the field needs a message of type `",
-              field->message_type()->full_name(), "`.");
+          FUZZTEST_PRECONDITION(!descriptor ||
+                                descriptor->full_name() ==
+                                    field->message_type()->full_name())
+              << "Input domain does not match the expected message type. The "
+                 "domain produced a message of type `"
+              << descriptor->full_name()
+              << "` but the field needs a message of type `"
+              << field->message_type()->full_name() << "`.";
         }
         absl::MutexLock l(&self.mutex_);
         auto res = self.domains_.try_emplace(field->number(),
                                              std::in_place_type<DomainT>,
                                              std::forward<Inner>(domain));
-        FUZZTEST_INTERNAL_CHECK_PRECONDITION(res.second, "Domain for field `",
-                                             field->full_name(),
-                                             "` has been set multiple times.");
+        FUZZTEST_PRECONDITION(res.second)
+            << "Domain for field `" << field->full_name()
+            << "` has been set multiple times.";
       }
     }
 
@@ -1337,9 +1334,8 @@
 
   auto GetField(absl::string_view field_name) const {
     auto* field = GetFieldWithoutCheck(field_name);
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(field != nullptr,
-                                         "Invalid field name '",
-                                         std::string(field_name), "'.");
+    FUZZTEST_PRECONDITION(field != nullptr)
+        << "Invalid field name '" << std::string(field_name) << "'.";
     return field;
   }
 
@@ -1395,11 +1391,10 @@
   void WithOneofField(absl::string_view field_name, OptionalPolicy policy) {
     const FieldDescriptor* field = GetField(field_name);
     if (!field->containing_oneof()) return;
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        policy != OptionalPolicy::kWithoutNull ||
-            field->containing_oneof()->field_count() <= 1,
-        "Cannot always set oneof field ", field_name,
-        " (try using WithOneofAlwaysSet).");
+    FUZZTEST_PRECONDITION(policy != OptionalPolicy::kWithoutNull ||
+                          field->containing_oneof()->field_count() <= 1)
+        << "Cannot always set oneof field " << field_name
+        << " (try using WithOneofAlwaysSet).";
     if (policy == OptionalPolicy::kAlwaysNull) {
       MarkOneofFieldAsUnset(field);
     }
@@ -1416,15 +1411,13 @@
   void SetOneofAlwaysSet(absl::string_view oneof_name) {
     const std::string name(oneof_name);
     auto* oneof = prototype_.Get()->GetDescriptor()->FindOneofByName(name);
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(oneof != nullptr,
-                                         "Invalid oneof name '", name, "'.");
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        !always_set_oneofs_.contains(oneof->index()), "oneof '", name,
-        "' is AlwaysSet before.");
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        !uncustomizable_oneofs_.contains(oneof->index()),
-        "WithOneofAlwaysSet(\"", name,
-        "\") should be called before customizing sub-fields.");
+    FUZZTEST_PRECONDITION(oneof != nullptr)
+        << "Invalid oneof name '" << name << "'.";
+    FUZZTEST_PRECONDITION(!always_set_oneofs_.contains(oneof->index()))
+        << "oneof '" << name << "' is AlwaysSet before.";
+    FUZZTEST_PRECONDITION(!uncustomizable_oneofs_.contains(oneof->index()))
+        << "WithOneofAlwaysSet(\"" << name
+        << "\") should be called before customizing sub-fields.";
     always_set_oneofs_.insert(oneof->index());
   }
 
@@ -1478,11 +1471,10 @@
 
     template <typename T>
     auto VisitSingular(const FieldDescriptor* field) {
-      FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-          false,
-          "Customizing repeated field size is not applicable to non-repeated "
-          "field ",
-          field->full_name(), ".");
+      FUZZTEST_PRECONDITION(false) << "Customizing repeated field size is not "
+                                      "applicable to non-repeated "
+                                      "field "
+                                   << field->full_name() << ".";
     }
 
     template <typename T>
@@ -1550,10 +1542,9 @@
   }
 
   OptionalPolicy GetOneofFieldPolicy(const FieldDescriptor* field) const {
-    FUZZTEST_INTERNAL_CHECK(
-        field->containing_oneof(),
-        "GetOneofFieldPolicy should apply to oneof fields only! ",
-        field->full_name());
+    FUZZTEST_CHECK(field->containing_oneof())
+    "GetOneofFieldPolicy should apply to oneof fields only! "
+        << field->full_name();
     auto field_policy = policy_.GetOptionalPolicy(field);
     // Field being unset via a policy overwrites the oneof policy.
     if (field_policy == OptionalPolicy::kAlwaysNull) return field_policy;
@@ -1568,11 +1559,11 @@
   }
 
   void CheckIfPolicyCanBeUpdated() const {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        customized_fields_.empty(),
-        "All singular modifiers (i.e., .With_Field_()) should come after "
-        "plural modifiers (i.e., .With_Fields_()). Consider reordering .With_ "
-        "modifiers.");
+    FUZZTEST_PRECONDITION(customized_fields_.empty())
+        << "All singular modifiers (i.e., .With_Field_()) should come after "
+           "plural modifiers (i.e., .With_Fields_()). Consider reordering "
+           ".With_ "
+           "modifiers.";
   }
   // Get the existing domain for `field`, if exists.
   // Otherwise, create the appropriate `Arbitrary<>` domain for the field and
@@ -1730,7 +1721,7 @@
   // Returns true if there are subprotos in the `descriptor` that form an
   // infinite recursion.
   bool IsInfinitelyRecursive(const Descriptor* descriptor) const {
-    FUZZTEST_INTERNAL_CHECK(IsCustomizedRecursivelyOnly(), "Internal error.");
+    FUZZTEST_CHECK(IsCustomizedRecursivelyOnly()) << "Internal error.";
     absl::flat_hash_set<const FieldDescriptor*> parents;
     return IsProtoRecursive(/*field=*/nullptr, parents,
                             RecursionType::kInfinitelyRecursive, descriptor);
@@ -1741,14 +1732,14 @@
   // because all Fi-s have to be set (e.g., Fi is a required field, or is
   // customized using `WithFieldsAlwaysSet`).
   bool IsInfinitelyRecursive(const FieldDescriptor* field) const {
-    FUZZTEST_INTERNAL_CHECK(IsCustomizedRecursivelyOnly(), "Internal error.");
+    FUZZTEST_CHECK(IsCustomizedRecursivelyOnly()) << "Internal error.";
     absl::flat_hash_set<const FieldDescriptor*> parents;
     return IsProtoRecursive(field, parents,
                             RecursionType::kInfinitelyRecursive);
   }
 
   bool IsFieldFinitelyRecursive(const FieldDescriptor* field) {
-    FUZZTEST_INTERNAL_CHECK(IsCustomizedRecursivelyOnly(), "Internal error.");
+    FUZZTEST_CHECK(IsCustomizedRecursivelyOnly()) << "Internal error.";
     if (!field->message_type()) return false;
     ABSL_CONST_INIT static absl::Mutex mutex(absl::kConstInit);
     static absl::NoDestructor<
@@ -1801,7 +1792,7 @@
   }
 
   bool MustBeSet(const FieldDescriptor* field) const {
-    FUZZTEST_INTERNAL_CHECK(IsCustomizedRecursivelyOnly(), "Internal error.");
+    FUZZTEST_CHECK(IsCustomizedRecursivelyOnly()) << "Internal error.";
     if (IsRequired(field)) {
       return true;
     } else if (field->containing_oneof()) {
@@ -1812,13 +1803,12 @@
       return policy_.GetMinRepeatedFieldSize(field).has_value() &&
              *policy_.GetMinRepeatedFieldSize(field) > 0;
     }
-    FUZZTEST_INTERNAL_CHECK(false,
-                            "Field is not optional, repeated, or required");
+    FUZZTEST_CHECK(false) << "Field is not optional, repeated, or required";
     return false;
   }
 
   bool MustBeUnset(const FieldDescriptor* field) const {
-    FUZZTEST_INTERNAL_CHECK(IsCustomizedRecursivelyOnly(), "Internal error.");
+    FUZZTEST_CHECK(IsCustomizedRecursivelyOnly()) << "Internal error.";
     if (field->message_type() && IsInfinitelyRecursive(field)) {
       absl::FPrintF(
           GetStderr(),
@@ -1836,8 +1826,7 @@
       return policy_.GetMaxRepeatedFieldSize(field).has_value() &&
              *policy_.GetMaxRepeatedFieldSize(field) == 0;
     }
-    FUZZTEST_INTERNAL_CHECK(false,
-                            "Field is not optional, repeated, or required");
+    FUZZTEST_CHECK(false) << "Field is not optional, repeated, or required";
     return false;
   }
 
@@ -1851,8 +1840,8 @@
       parents.insert(field);
       descriptor = field->message_type();
     } else {
-      FUZZTEST_INTERNAL_CHECK(descriptor,
-                              "one of field or descriptor must be non-null!");
+      FUZZTEST_CHECK(descriptor)
+          << "one of field or descriptor must be non-null!";
     }
     for (int i = 0; i < descriptor->oneof_decl_count(); ++i) {
       const auto* oneof = descriptor->oneof_decl(i);
@@ -2314,10 +2303,10 @@
  private:
   void FailIfIsOneof(absl::string_view field) {
     const FieldDescriptor* descriptor = inner_.GetField(field);
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        !descriptor->containing_oneof(), "Cannot customize oneof field ", field,
-        " with WithOptional<Type>Field (try using "
-        "WithOneofAlwaysSet or WithOptional<Type>Unset).");
+    FUZZTEST_PRECONDITION(!descriptor->containing_oneof())
+        << "Cannot customize oneof field " << field
+        << " with WithOptional<Type>Field (try using "
+           "WithOneofAlwaysSet or WithOptional<Type>Unset).";
   }
 
   template <typename Inner>
diff --git a/fuzztest/internal/domains/regexp_dfa.cc b/fuzztest/internal/domains/regexp_dfa.cc
index ff6fa70..acca7e1 100644
--- a/fuzztest/internal/domains/regexp_dfa.cc
+++ b/fuzztest/internal/domains/regexp_dfa.cc
@@ -33,6 +33,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/logging.h"
 #include "re2/prog.h"
 #include "re2/regexp.h"
@@ -57,9 +58,8 @@
     result.insert(result.end(), fragment.begin(), fragment.end());
     state = &states_[next_id];
     if (state->is_end_state()) {
-      FUZZTEST_INTERNAL_CHECK(
-          fragment.back() == kEndOfString,
-          "The last character leading to the end state should be EOS!");
+      FUZZTEST_CHECK(fragment.back() == kEndOfString)
+          << "The last character leading to the end state should be EOS!";
       result.pop_back();
       break;
     }
@@ -73,8 +73,8 @@
   Path path;
   int cur_state_id = from_state_id;
   State* cur_state = &states_[cur_state_id];
-  FUZZTEST_INTERNAL_CHECK(!cur_state->is_end_state(),
-                          "Cannot start a DFA path from an end state!");
+  FUZZTEST_CHECK(!cur_state->is_end_state())
+      << "Cannot start a DFA path from an end state!";
   while (true) {
     // Pick a random next state.
     int offset = cur_state->edge_weight_distribution(prng);
@@ -146,7 +146,7 @@
       candidate_lens.push_back(len);
     }
   }
-  FUZZTEST_INTERNAL_CHECK(!candidate_lens.empty(), "Cannot find a path!");
+  FUZZTEST_CHECK(!candidate_lens.empty()) << "Cannot find a path!";
 
   int state_id = to_state_id;
   Path result;
@@ -156,8 +156,8 @@
     result.push_back(*(last_edges_and_counters[state_id][len].edge));
     state_id = result.back().from_state_id;
   }
-  FUZZTEST_INTERNAL_CHECK(state_id == from_state_id,
-                          "Cannot find a path from from_state");
+  FUZZTEST_CHECK(state_id == from_state_id)
+      << "Cannot find a path from from_state";
   std::reverse(result.begin(), result.end());
   return result;
 }
@@ -209,9 +209,8 @@
     const std::vector<std::int16_t>& fragment = transition.chars_to_match;
     result.insert(result.end(), fragment.begin(), fragment.end());
     if (next_state_id == end_state_id_) {
-      FUZZTEST_INTERNAL_CHECK(
-          fragment.back() == kEndOfString,
-          "The last character leading to the end state should be EOS!");
+      FUZZTEST_CHECK(fragment.back() == kEndOfString)
+          << "The last character leading to the end state should be EOS!";
       result.pop_back();
     }
   }
@@ -230,7 +229,7 @@
                   const std::vector<std::int16_t>& chars) {
         const size_t compare_size = std::min(transition.chars_to_match.size(),
                                              chars.size() - cur_index);
-        FUZZTEST_INTERNAL_CHECK(compare_size != 0, "Nothing to compare!");
+        FUZZTEST_CHECK(compare_size != 0) << "Nothing to compare!";
         for (size_t i = 0; i < compare_size; ++i) {
           if (transition.chars_to_match[i] == chars[cur_index + i]) continue;
           return transition.chars_to_match[i] < chars[cur_index + i];
@@ -262,10 +261,9 @@
       re2::Regexp::Parse(full_text_regexp, re2::Regexp::LikePerl, nullptr);
 
   // Is the regexp valid?
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(re != nullptr,
-                                       "Invalid RE2 regular expression.");
+  FUZZTEST_PRECONDITION(re != nullptr) << "Invalid RE2 regular expression.";
   re2::Prog* prog = re->CompileToProg(0);
-  FUZZTEST_INTERNAL_CHECK(prog != nullptr, "RE2 compilation failed!");
+  FUZZTEST_CHECK(prog != nullptr) << "RE2 compilation failed!";
   re->Decref();
   return std::unique_ptr<re2::Prog>(prog);
 }
@@ -279,14 +277,13 @@
   // Full match has no effect on re2::Prog::BuildEntireDFA.
   int state_n = compiled_regexp->BuildEntireDFA(
       re2::Prog::kFirstMatch, [&](const int* next, bool match) {
-        FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-            next != nullptr,
-            "The memory budget for building the state machine (DFA) for the "
-            "given regular expression has been exhausted. "
-            "You might try to reduce the number of states by using more "
-            "specific character classes (e.g., [[:alpha:]] instead of `.`, "
-            "i.e., any character) in your regular expression, or wait until "
-            "the issue is fixed.");
+        FUZZTEST_PRECONDITION(next != nullptr)
+            << "The memory budget for building the state machine (DFA) for the "
+               "given regular expression has been exhausted. "
+               "You might try to reduce the number of states by using more "
+               "specific character classes (e.g., [[:alpha:]] instead of `.`, "
+               "i.e., any character) in your regular expression, or wait until "
+               "the issue is fixed.";
 
         transition_table.emplace_back(
             next, next + compiled_regexp->bytemap_range() + 1);
@@ -328,8 +325,8 @@
           return a.chars_to_match.front() < b.chars_to_match.front();
         });
     if (end_vec[i]) end_state_id_ = i;
-    FUZZTEST_INTERNAL_CHECK((!end_vec[i] || state.next.empty()),
-                            "An end state must have no outgoing edges!");
+    FUZZTEST_CHECK((!end_vec[i] || state.next.empty()))
+        << "An end state must have no outgoing edges!";
   }
 }
 
@@ -365,9 +362,8 @@
         edge_to_unsafe_nodes.push_back(j);
       }
     }
-    FUZZTEST_INTERNAL_CHECK(
-        state_id == end_state_id_ || !edge_to_safe_nodes.empty(),
-        "A non-end node must have at least one safe edge");
+    FUZZTEST_CHECK(state_id == end_state_id_ || !edge_to_safe_nodes.empty())
+        << "A non-end node must have at least one safe edge";
     double probability_to_safe_node =
         edge_to_unsafe_nodes.empty() ? 1 : kProbToSafeNode;
 
@@ -402,9 +398,8 @@
     State& state = states_[i];
     if (state.next.size() != 1) continue;
     const auto& [chars_to_match, next_state_id] = state.next[0];
-    FUZZTEST_INTERNAL_CHECK(
-        next_state_id != i,
-        "A self-loop state should have at least two outgoing edges.");
+    FUZZTEST_CHECK(next_state_id != i)
+        << "A self-loop state should have at least two outgoing edges.";
     for (size_t j = 0; j < states_.size(); ++j) {
       for (auto& [next_chars_to_match, state_id] : states_[j].next) {
         if (state_id == i) {
diff --git a/fuzztest/internal/fixture_driver.h b/fuzztest/internal/fixture_driver.h
index 43286e3..e489e9f 100644
--- a/fuzztest/internal/fixture_driver.h
+++ b/fuzztest/internal/fixture_driver.h
@@ -260,10 +260,9 @@
         target_function_(target_function) {}
 
   void Test(MoveOnlyAny&& args_untyped) const override {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        fixture_ != nullptr,
-        "fixture is nullptr. Did you forget to instantiate it in one of the "
-        "SetUp methods?");
+    FUZZTEST_PRECONDITION(fixture_ != nullptr)
+        << "fixture is nullptr. Did you forget to instantiate it in one of the "
+           "SetUp methods?";
     std::apply(
         [&](auto&&... args) {
           (fixture_.get()->*target_function_)(
@@ -277,10 +276,10 @@
     if constexpr (std::is_invocable_v<SeedProvider, Fixture*>) {
       static_assert(std::is_same_v<std::invoke_result_t<SeedProvider, Fixture*>,
                                    std::vector<value_type_t<DomainT>>>);
-      FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-          fixture_ != nullptr,
-          "fixture is nullptr. Did you forget to instantiate it in one of the "
-          "SetUp methods?");
+      FUZZTEST_PRECONDITION(fixture_ != nullptr)
+          << "fixture is nullptr. Did you forget to instantiate it in one of "
+             "the "
+             "SetUp methods?";
       return this->GetSeedsFromUserValues(
           std::invoke(this->seed_provider(), fixture_.get()));
     } else if constexpr (std::is_invocable_v<SeedProvider>) {
diff --git a/fuzztest/internal/fixture_driver_test.cc b/fuzztest/internal/fixture_driver_test.cc
index b296e65..7995061 100644
--- a/fuzztest/internal/fixture_driver_test.cc
+++ b/fuzztest/internal/fixture_driver_test.cc
@@ -22,6 +22,7 @@
 #include "gtest/gtest.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/types/span.h"
+#include "./common/logging.h"
 #include "./fuzztest/domain_core.h"
 #include "./fuzztest/internal/any.h"
 #include "./fuzztest/internal/logging.h"
@@ -273,8 +274,7 @@
   std::vector<T> values;
   values.reserve(generic_values.size());
   for (const auto& generic_value : generic_values) {
-    FUZZTEST_INTERNAL_CHECK(generic_value.Has<T>(),
-                            "Generic value of a wrong type.");
+    FUZZTEST_CHECK(generic_value.Has<T>()) << "Generic value of a wrong type.";
     values.push_back(generic_value.GetAs<T>());
   }
   return values;
diff --git a/fuzztest/internal/io.cc b/fuzztest/internal/io.cc
index 760c830..70ba1c7 100644
--- a/fuzztest/internal/io.cc
+++ b/fuzztest/internal/io.cc
@@ -37,6 +37,7 @@
 #include "absl/types/span.h"
 #include "./common/blob_file.h"
 #include "./common/defs.h"
+#include "./common/logging.h"
 #include "./common/remote_file.h"
 #include "./fuzztest/internal/logging.h"
 
@@ -47,27 +48,27 @@
 // TODO(lszekeres): Return absl::Status instead of bool for these.
 
 bool WriteFile(absl::string_view path, absl::string_view contents) {
-  FUZZTEST_INTERNAL_CHECK(false, "Filesystem API not supported in iOS/MacOS");
+  FUZZTEST_LOG(FATAL)( << "Filesystem API not supported in iOS/MacOS";
 }
 
 std::optional<std::string> ReadFile(absl::string_view path) {
-  FUZZTEST_INTERNAL_CHECK(false, "Filesystem API not supported in iOS/MacOS");
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 bool IsDirectory(absl::string_view path) {
-  FUZZTEST_INTERNAL_CHECK(false, "Filesystem API not supported in iOS/MacOS");
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 bool CreateDirectory(absl::string_view path) {
-  FUZZTEST_INTERNAL_CHECK(false, "Filesystem API not supported in iOS/MacOS");
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 std::vector<std::string> ListDirectory(absl::string_view path) {
-  FUZZTEST_INTERNAL_CHECK(false, "Filesystem API not supported in iOS/MacOS");
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 std::vector<std::string> ListDirectoryRecursively(absl::string_view path) {
-  FUZZTEST_INTERNAL_CHECK(false, "Filesystem API not supported in iOS/MacOS");
+  FUZZTEST_LOG(FATAL) << "Filesystem API not supported in iOS/MacOS";
 }
 
 #else
@@ -214,12 +215,10 @@
   int total_invalid_inputs = 0;
   const absl::Time start_time = absl::Now();
   for (const std::string& file_path : file_paths) {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        fuzztest::internal::RemotePathExists(file_path), "File path ",
-        file_path, " does not exist.");
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        !fuzztest::internal::RemotePathIsDirectory(file_path), "File path ",
-        file_path, " is a directory.");
+    FUZZTEST_PRECONDITION(fuzztest::internal::RemotePathExists(file_path))
+        << "File path " << file_path << " does not exist.";
+    FUZZTEST_PRECONDITION(!fuzztest::internal::RemotePathIsDirectory(file_path))
+        << "File path " << file_path << " is a directory.";
     int loaded_inputs_from_file = 0;
     int invalid_inputs_from_file = 0;
     // The reader cannot be reused for multiple files because of the way it
@@ -273,9 +272,9 @@
     std::string contents;
     const absl::Status get_contents_status =
         fuzztest::internal::RemoteFileGetContents(file_path, contents);
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        get_contents_status.ok(), "RemoteFileGetContents failed on ", file_path,
-        ", status: ", get_contents_status.message());
+    FUZZTEST_PRECONDITION(get_contents_status.ok())
+        << "RemoteFileGetContents failed on " << file_path
+        << ", status: " << get_contents_status.message();
     absl::Status result = consume(file_path, std::nullopt, std::move(contents));
     if (result.ok()) {
       ++total_loaded_inputs;
diff --git a/fuzztest/internal/io_test.cc b/fuzztest/internal/io_test.cc
index be07851..5eb7c17 100644
--- a/fuzztest/internal/io_test.cc
+++ b/fuzztest/internal/io_test.cc
@@ -31,7 +31,6 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/time/clock.h"
@@ -200,14 +199,14 @@
   TestWrite(serialized_file, "Input1");
   std::unique_ptr<fuzztest::internal::BlobFileWriter> writer =
       fuzztest::internal::DefaultBlobFileWriterFactory();
-  CHECK(writer->Open(blob_file, "w").ok());
-  CHECK(
+  FUZZTEST_CHECK(writer->Open(blob_file, "w").ok());
+  FUZZTEST_CHECK(
       writer->Write(fuzztest::internal::AsByteSpan(absl::string_view("Input2")))
           .ok());
-  CHECK(
+  FUZZTEST_CHECK(
       writer->Write(fuzztest::internal::AsByteSpan(absl::string_view("Input3")))
           .ok());
-  CHECK(writer->Close().ok());
+  FUZZTEST_CHECK(writer->Close().ok());
 
   using InputInFile = std::tuple<std::string, std::optional<int>, std::string>;
   std::vector<InputInFile> inputs;
@@ -229,14 +228,14 @@
   const std::string file = tmp_dir.path() / "file";
   std::unique_ptr<fuzztest::internal::BlobFileWriter> writer =
       fuzztest::internal::DefaultBlobFileWriterFactory();
-  CHECK(writer->Open(file, "w").ok());
-  CHECK(
+  FUZZTEST_CHECK(writer->Open(file, "w").ok());
+  FUZZTEST_CHECK(
       writer->Write(fuzztest::internal::AsByteSpan(absl::string_view("Ignore")))
           .ok());
-  CHECK(
+  FUZZTEST_CHECK(
       writer->Write(fuzztest::internal::AsByteSpan(absl::string_view("Accept")))
           .ok());
-  CHECK(writer->Close().ok());
+  FUZZTEST_CHECK(writer->Close().ok());
 
   using InputInFile = std::tuple<std::string, std::optional<int>, std::string>;
   std::vector<InputInFile> inputs;
diff --git a/fuzztest/internal/logging.cc b/fuzztest/internal/logging.cc
index 4521afe..1418360 100644
--- a/fuzztest/internal/logging.cc
+++ b/fuzztest/internal/logging.cc
@@ -21,6 +21,7 @@
 #include "absl/base/const_init.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/synchronization/mutex.h"
+#include "./common/logging.h"
 
 #if defined(__linux__)
 #include <unistd.h>
@@ -47,10 +48,10 @@
 
 void Silence(int fd) {
   FILE* tmp = fopen("/dev/null", "w");
-  FUZZTEST_INTERNAL_CHECK(tmp, "fopen() error:", strerror(errno));
-  FUZZTEST_INTERNAL_CHECK(dup2(fileno(tmp), fd) != -1,
-                          "dup2() error:", strerror(errno));
-  FUZZTEST_INTERNAL_CHECK(fclose(tmp) == 0, "fclose() error:", strerror(errno));
+  FUZZTEST_CHECK(tmp) << "fopen() error: " << strerror(errno);
+  FUZZTEST_CHECK(dup2(fileno(tmp), fd) != -1) << "dup2() error: ",
+      strerror(errno);
+  FUZZTEST_CHECK(fclose(tmp) == 0) << "fclose() error: " << strerror(errno);
 }
 
 // Only accepts 1 or 2 (stdout or stderr).
@@ -59,12 +60,12 @@
 // If it's a stderr, silence it after duping it as the global stderr, which
 // will be used internally to log and be used when restoring the stderr.
 void DupAndSilence(int fd) {
-  FUZZTEST_INTERNAL_CHECK(fd == STDOUT_FILENO || fd == STDERR_FILENO,
-                          "DupAndSilence only accepts stderr or stdout.");
+  FUZZTEST_CHECK(fd == STDOUT_FILENO || fd == STDERR_FILENO)
+      << "DupAndSilence only accepts stderr or stdout.";
   int new_fd = dup(fd);
-  FUZZTEST_INTERNAL_CHECK(new_fd != -1, "dup() error:", strerror(errno));
+  FUZZTEST_CHECK(new_fd != -1) << "dup() error:" << strerror(errno);
   FILE* new_output_file = fdopen(new_fd, "w");
-  FUZZTEST_INTERNAL_CHECK(new_output_file, "fdopen error:", strerror(errno));
+  FUZZTEST_CHECK(new_output_file) << "fdopen error:" << strerror(errno);
   if (new_output_file) {
     if (fd == STDOUT_FILENO) {
       stdout_file_ = new_output_file;
@@ -90,21 +91,21 @@
   FILE* silenced_stderr = stderr_file_;
   stderr_file_ = stderr;
   stderr_file_guard_.Unlock();
-  FUZZTEST_INTERNAL_CHECK(silenced_stderr != stderr,
-                          "Error, calling RestoreStderr without calling"
-                          "DupandSilenceStderr first.");
-  FUZZTEST_INTERNAL_CHECK(dup2(fileno(silenced_stderr), STDERR_FILENO) != -1,
-                          "dup2 error:", strerror(errno));
-  FUZZTEST_INTERNAL_CHECK(fclose(silenced_stderr) == 0,
-                          "close() error:", strerror(errno));
+  FUZZTEST_CHECK(silenced_stderr != stderr)
+      << "Error, calling RestoreStderr without calling"
+         "DupandSilenceStderr first.";
+  FUZZTEST_CHECK(dup2(fileno(silenced_stderr), STDERR_FILENO) != -1)
+      << "dup2 error:" << strerror(errno);
+  FUZZTEST_CHECK(fclose(silenced_stderr) == 0)
+      << "close() error:" << strerror(errno);
 
-  FUZZTEST_INTERNAL_CHECK(stdout_file_ != stdout,
-                          "Error, calling RestoreStdout without calling"
-                          "DupandSilenceStdout first.");
-  FUZZTEST_INTERNAL_CHECK(dup2(fileno(stdout_file_), STDOUT_FILENO) != -1,
-                          "dup2() error:", strerror(errno));
-  FUZZTEST_INTERNAL_CHECK(fclose(stdout_file_) == 0,
-                          "close() error:", strerror(errno));
+  FUZZTEST_CHECK(stdout_file_ != stdout)
+      << "Error, calling RestoreStdout without calling"
+         "DupandSilenceStdout first.";
+  FUZZTEST_CHECK(dup2(fileno(stdout_file_), STDOUT_FILENO) != -1)
+      << "dup2() error:" << strerror(errno);
+  FUZZTEST_CHECK(fclose(stdout_file_) == 0)
+      << "close() error:" << strerror(errno);
   stdout_file_ = stdout;
 }
 
@@ -130,11 +131,6 @@
   return stderr_file_;
 }
 
-void Abort(const char* file, int line, const std::string& message) {
-  fprintf(GetStderr(), "%s:%d: %s\n", file, line, message.c_str());
-  std::abort();
-}
-
 const std::string* volatile test_abort_message = nullptr;
 void AbortInTest(const std::string& message) {
   // When we are within a test, we set the message here and call abort().
diff --git a/fuzztest/internal/logging.h b/fuzztest/internal/logging.h
index b7b8d4a..94c9b53 100644
--- a/fuzztest/internal/logging.h
+++ b/fuzztest/internal/logging.h
@@ -20,6 +20,7 @@
 
 #include "absl/strings/str_cat.h"
 
+// TODO(b/422182911): Remove this library.
 namespace fuzztest::internal {
 
 // Returns the current FILE pointing to the original stderr.
@@ -36,21 +37,6 @@
 // Check if FUZZTEST_SILENCE_TARGET env set.
 bool IsSilenceTargetEnabled();
 
-[[noreturn]] void Abort(const char* file, int line, const std::string& message);
-
-#define FUZZTEST_INTERNAL_CHECK_PRECONDITION(P, ...) \
-  ((P) ? (void)0                                     \
-       : ::fuzztest::internal::Abort(                \
-             __FILE__, __LINE__,                     \
-             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
-
-#define FUZZTEST_INTERNAL_CHECK(cond, ...)                     \
-  ((cond) ? (void)0                                            \
-          : ::fuzztest::internal::Abort(                       \
-                __FILE__, __LINE__,                            \
-                absl::StrCat("Internal error! Check (", #cond, \
-                             ") failed: ", __VA_ARGS__)))
-
 // This Abort function will inject `message` into the signal handler's output
 // along with the file, line and test name of the currently running test.
 // Meant for failures related to test setup and not the code under test itself.
diff --git a/fuzztest/internal/register_fuzzing_mocks.cc b/fuzztest/internal/register_fuzzing_mocks.cc
index 1a51cea..6bb05df 100644
--- a/fuzztest/internal/register_fuzzing_mocks.cc
+++ b/fuzztest/internal/register_fuzzing_mocks.cc
@@ -26,7 +26,6 @@
 
 #include "absl/base/fast_type_id.h"
 #include "absl/functional/function_ref.h"
-#include "absl/log/absl_check.h"
 #include "absl/random/bernoulli_distribution.h"
 #include "absl/random/beta_distribution.h"
 #include "absl/random/distributions.h"
@@ -36,6 +35,7 @@
 #include "absl/random/poisson_distribution.h"
 #include "absl/random/zipf_distribution.h"
 #include "absl/types/span.h"
+#include "./common/logging.h"
 
 namespace fuzztest::internal {
 namespace {
@@ -103,7 +103,7 @@
   // Returns a value in the closed-closed range [min, max].
   template <typename T>
   T ConsumeValueInRange(T min, T max) {
-    ABSL_CHECK_LE(min, max);
+    FUZZTEST_CHECK_LE(min, max);
 
     if (min == max) return min;
 
diff --git a/fuzztest/internal/runtime.cc b/fuzztest/internal/runtime.cc
index 6bb21fe..9db208f 100644
--- a/fuzztest/internal/runtime.cc
+++ b/fuzztest/internal/runtime.cc
@@ -40,7 +40,6 @@
 
 #include "absl/functional/bind_front.h"
 #include "absl/functional/function_ref.h"
-#include "absl/log/absl_check.h"
 #include "absl/random/bit_gen_ref.h"
 #include "absl/random/discrete_distribution.h"
 #include "absl/random/random.h"
@@ -58,6 +57,7 @@
 #include "absl/time/time.h"
 #include "absl/types/span.h"
 #include "./common/bazel.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/configuration.h"
 #include "./fuzztest/internal/corpus_database.h"
 #include "./fuzztest/internal/coverage.h"
@@ -107,7 +107,7 @@
                                    absl::string_view test_name) {
   const bool is_reproducer_in_corpus_db =
       configuration && configuration->crashing_input_to_reproduce;
-  ABSL_CHECK(!reproducer_path.empty() || is_reproducer_in_corpus_db);
+  FUZZTEST_CHECK(!reproducer_path.empty() || is_reproducer_in_corpus_db);
   if (!configuration || !configuration->reproduction_command_template) {
     absl::string_view reproducer =
         is_reproducer_in_corpus_db ? *configuration->crashing_input_to_reproduce
@@ -121,8 +121,8 @@
   }
   const std::string command_template =
       *configuration->reproduction_command_template;
-  ABSL_CHECK(absl::StrContains(command_template, kTestFilterPlaceholder));
-  ABSL_CHECK(absl::StrContains(command_template, kExtraArgsPlaceholder));
+  FUZZTEST_CHECK(absl::StrContains(command_template, kTestFilterPlaceholder));
+  FUZZTEST_CHECK(absl::StrContains(command_template, kExtraArgsPlaceholder));
   if (is_reproducer_in_corpus_db) {
     const std::string corpus_db = configuration->corpus_database;
     std::vector<std::string> extra_args = {absl::StrCat(
@@ -218,9 +218,8 @@
                                        Basename(reproducer_path));
         break;
       default:
-        FUZZTEST_INTERNAL_CHECK(false,
-                                "unsupported reproducer output location type "
-                                "to print reproduction command for");
+        FUZZTEST_CHECK(false) << "unsupported reproducer output location type "
+                                 "to print reproduction command for";
     }
   }
   absl::Format(
@@ -258,9 +257,9 @@
                   "- not writing the reproducer file.\n");
     return "";
   }
-  FUZZTEST_INTERNAL_CHECK(!out_location.dir_path.empty(),
-                          "Reproducer output directory must not be empty if "
-                          "not reporting to controller.");
+  FUZZTEST_CHECK(!out_location.dir_path.empty())
+      << "Reproducer output directory must not be empty if "
+         "not reporting to controller.";
   const std::string content =
       current_args_->domain.SerializeCorpus(current_args_->corpus_value)
           .ToString();
@@ -474,7 +473,7 @@
 
 void Runtime::SetCurrentTest(const FuzzTest* test,
                              const Configuration* configuration) {
-  ABSL_CHECK((test != nullptr) == (configuration != nullptr));
+  FUZZTEST_CHECK((test != nullptr) == (configuration != nullptr));
   current_test_ = test;
   current_configuration_ = configuration;
   if (configuration == nullptr) return;
@@ -484,11 +483,9 @@
         fuzztest::internal::VerifyBazelHasEnoughTimeToRunTest(
             creation_time_, test_time_limit, test_counter_,
             configuration->fuzz_tests.size());
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        has_enough_time.ok(),
-        absl::StrCat("Not enough time for running the fuzz test ",
-                     test->full_name(), " for ", test_time_limit, ": ",
-                     has_enough_time));
+    FUZZTEST_PRECONDITION(has_enough_time.ok())
+        << "Not enough time for running the fuzz test " << test->full_name()
+        << " for " << test_time_limit << ": " << has_enough_time;
   }
   ++test_counter_;
 }
@@ -678,8 +675,8 @@
       corpus_coverage_(execution_coverage_ != nullptr
                            ? execution_coverage_->GetCounterMap().size()
                            : 0) {
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(fixture_driver_ != nullptr,
-                                       "Invalid fixture driver!");
+  FUZZTEST_PRECONDITION(fixture_driver_ != nullptr)
+      << "Invalid fixture driver!";
   stats_.start_time = absl::Now();
   const char* corpus_out_dir_chars = getenv("FUZZTEST_TESTSUITE_OUT_DIR");
   if (corpus_out_dir_chars) corpus_out_dir_ = corpus_out_dir_chars;
@@ -807,12 +804,11 @@
   std::optional<corpus_type> reproducer;
   ForEachInput({std::string(file)},
                [&](absl::string_view, std::optional<int>, Input input) {
-                 FUZZTEST_INTERNAL_CHECK(!reproducer.has_value(),
-                                         "Multiple inputs found in ", file);
+                 FUZZTEST_CHECK(!reproducer.has_value())
+                     << "Multiple inputs found in " << file;
                  reproducer = std::move(input.args);
                });
-  FUZZTEST_INTERNAL_CHECK(reproducer.has_value(),
-                          "Failed to read minimizer file!");
+  FUZZTEST_CHECK(reproducer.has_value()) << "Failed to read minimizer file!";
   return *reproducer;
 }
 
@@ -1066,9 +1062,8 @@
     auto duration = absl::Seconds(1);
     const auto fuzz_for = absl::NullSafeStringView(getenv("FUZZTEST_FUZZ_FOR"));
     if (!fuzz_for.empty()) {
-      FUZZTEST_INTERNAL_CHECK(
-          absl::ParseDuration(fuzz_for, &duration),
-          "Could not parse duration in FUZZTEST_FUZZ_FOR=", fuzz_for);
+      FUZZTEST_CHECK(absl::ParseDuration(fuzz_for, &duration))
+          << "Could not parse duration in FUZZTEST_FUZZ_FOR=" << fuzz_for;
     }
     const auto time_limit = stats_.start_time + duration;
     Input mutation{params_domain_.Init(prng)};
@@ -1158,9 +1153,8 @@
   constexpr int kMaxTriedWithoutFailure = 10000;
   while (tries_without_failure < kMaxTriedWithoutFailure &&
          absl::Now() < deadline) {
-    FUZZTEST_INTERNAL_CHECK(
-        minimal_non_fatal_counterexample_.has_value(),
-        "Caller didn't populate minimal_non_fatal_counterexample_");
+    FUZZTEST_CHECK(minimal_non_fatal_counterexample_.has_value())
+        << "Caller didn't populate minimal_non_fatal_counterexample_";
     auto copy = *minimal_non_fatal_counterexample_;
     // Mutate a random number of times, in case one is not enough to
     // reach another failure, but prefer a low number of mutations (thus Zipf).
@@ -1238,9 +1232,9 @@
         corpus_database.GetCoverageInputsIfAny(test_.full_name()));
     InitializeCorpus(prng);
 
-    FUZZTEST_INTERNAL_CHECK(!corpus_.empty(),
-                            "No seed input coverage registered. Test function "
-                            "might be uninstrumented?");
+    FUZZTEST_CHECK(!corpus_.empty())
+        << "No seed input coverage registered. Test function "
+           "might be uninstrumented?";
 
     constexpr size_t kRunsPerInit = 32000;
     size_t next_init = kRunsPerInit;
@@ -1305,8 +1299,8 @@
           return {params_domain_.Init(prng)};
         } else {
           size_t idx = static_cast<size_t>(corpus_distribution_(prng));
-          FUZZTEST_INTERNAL_CHECK(0 <= idx && idx < corpus_.size(),
-                                  "Corpus input weights are outdated!\n");
+          FUZZTEST_CHECK(0 <= idx && idx < corpus_.size())
+              << "Corpus input weights are outdated!\n";
           return corpus_[idx];
         }
       }();
diff --git a/fuzztest/internal/seed_seq.cc b/fuzztest/internal/seed_seq.cc
index 1bf485c..2f8896b 100644
--- a/fuzztest/internal/seed_seq.cc
+++ b/fuzztest/internal/seed_seq.cc
@@ -29,6 +29,7 @@
 #include "absl/strings/escaping.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "./common/logging.h"
 #include "./fuzztest/internal/logging.h"
 
 namespace fuzztest::internal {
@@ -51,9 +52,9 @@
   }
   std::optional<std::vector<uint32_t>> seed_material =
       DecodeSeedMaterial(encoded_seed_material);
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-      seed_material.has_value(),
-      "Failed to decode seed material from the environment variable ", env_var);
+  FUZZTEST_PRECONDITION(seed_material.has_value())
+      << "Failed to decode seed material from the environment variable "
+      << env_var;
   return *std::move(seed_material);
 }
 
diff --git a/fuzztest/internal/subprocess.cc b/fuzztest/internal/subprocess.cc
index 1dbf7e8..54e0aff 100644
--- a/fuzztest/internal/subprocess.cc
+++ b/fuzztest/internal/subprocess.cc
@@ -45,7 +45,7 @@
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 #include "absl/types/span.h"
-#include "./fuzztest/internal/logging.h"
+#include "./common/logging.h"
 
 #if !defined(_MSC_VER)
 // Needed to pass the current environment to posix_spawn, which needs an
@@ -68,7 +68,7 @@
 
 std::variant<ExitCodeT, SignalT> TerminationStatus::Status() const {
   if (Exited()) return static_cast<ExitCodeT>(WEXITSTATUS(status_));
-  FUZZTEST_INTERNAL_CHECK(Signaled(), "!Exited && !Signaled");
+  FUZZTEST_CHECK(Signaled()) << "!Exited && !Signaled";
   return static_cast<SignalT>(WTERMSIG(status_));
 }
 
@@ -108,29 +108,28 @@
 void SubProcess::CreatePipes() {
   for (int channel : {kStdOutIdx, kStdErrIdx}) {
     int pipe_fds[2];
-    FUZZTEST_INTERNAL_CHECK(pipe(pipe_fds) == 0,
-                            "Cannot create pipe: ", strerror(errno));
+    FUZZTEST_CHECK(pipe(pipe_fds) == 0) << "Cannot create pipe: ",
+        strerror(errno);
 
     parent_pipe_[channel] = pipe_fds[0];
     child_pipe_[channel] = pipe_fds[1];
 
-    FUZZTEST_INTERNAL_CHECK(
-        fcntl(parent_pipe_[channel], F_SETFL, O_NONBLOCK) != -1,
-        "Cannot make pipe non-blocking: ", strerror(errno));
+    FUZZTEST_CHECK(fcntl(parent_pipe_[channel], F_SETFL, O_NONBLOCK) != -1)
+        << "Cannot make pipe non-blocking: " << strerror(errno);
   }
 }
 
 void SubProcess::CloseChildPipes() {
   for (int channel : {kStdOutIdx, kStdErrIdx}) {
-    FUZZTEST_INTERNAL_CHECK(close(child_pipe_[channel]) != -1,
-                            "Cannot close pipe: ", strerror(errno));
+    FUZZTEST_CHECK(close(child_pipe_[channel]) != -1)
+        << "Cannot close pipe: " << strerror(errno);
   }
 }
 
 void SubProcess::CloseParentPipes() {
   for (int channel : {kStdOutIdx, kStdErrIdx}) {
-    FUZZTEST_INTERNAL_CHECK(close(parent_pipe_[channel]) != -1,
-                            "Cannot close pipe: ", strerror(errno));
+    FUZZTEST_CHECK(close(parent_pipe_[channel]) != -1)
+        << "Cannot close pipe: " << strerror(errno);
   }
 }
 
@@ -141,28 +140,24 @@
 
   int err;
   err = posix_spawn_file_actions_init(&actions);
-  FUZZTEST_INTERNAL_CHECK(err == 0,
-                          "Cannot initialize file actions: ", strerror(err));
+  FUZZTEST_CHECK(err == 0) << "Cannot initialize file actions: "
+                           << strerror(err);
 
   // Close stdin.
   err = posix_spawn_file_actions_addclose(&actions, STDIN_FILENO);
-  FUZZTEST_INTERNAL_CHECK(err == 0,
-                          "Cannot add close() action: ", strerror(err));
+  FUZZTEST_CHECK(err == 0) << "Cannot add close() action: " << strerror(err);
 
   for (int channel : {kStdOutIdx, kStdErrIdx}) {
     // Close parent-side pipes.
     err = posix_spawn_file_actions_addclose(&actions, parent_pipe_[channel]);
-    FUZZTEST_INTERNAL_CHECK(err == 0,
-                            "Cannot add close() action: ", strerror(err));
+    FUZZTEST_CHECK(err == 0) << "Cannot add close() action: " << strerror(err);
 
     // Replace stdout/stderr file descriptors with the pipes.
     int fd = channel == kStdOutIdx ? STDOUT_FILENO : STDERR_FILENO;
     err = posix_spawn_file_actions_adddup2(&actions, child_pipe_[channel], fd);
-    FUZZTEST_INTERNAL_CHECK(err == 0,
-                            "Cannot add dup2() action: ", strerror(err));
+    FUZZTEST_CHECK(err == 0) << "Cannot add dup2() action: " << strerror(err);
     err = posix_spawn_file_actions_addclose(&actions, child_pipe_[channel]);
-    FUZZTEST_INTERNAL_CHECK(err == 0,
-                            "Cannot add close() action: ", strerror(err));
+    FUZZTEST_CHECK(err == 0) << "Cannot add close() action: " << strerror(err);
   }
 
   return actions;
@@ -198,16 +193,15 @@
   int err;
   err = posix_spawnp(&child_pid, argv[0], &actions, nullptr, argv.data(),
                      environment.has_value() ? envp.data() : environ);
-  FUZZTEST_INTERNAL_CHECK(err == 0,
-                          "Cannot spawn child process: ", strerror(err));
+  FUZZTEST_CHECK(err == 0) << "Cannot spawn child process: ", strerror(err);
 
   // Free up the used parameters.
   for (char* p : argv) free(p);
   for (char* p : envp) free(p);
 
   err = posix_spawn_file_actions_destroy(&actions);
-  FUZZTEST_INTERNAL_CHECK(err == 0,
-                          "Cannot destroy file actions: ", strerror(err));
+  FUZZTEST_CHECK(err == 0)
+  "Cannot destroy file actions: " << strerror(err);
 
   return child_pid;
 }
@@ -235,9 +229,9 @@
   while (fd_remain > 0) {
     int ret = poll(pfd, fd_count, -1);
     if ((ret == -1) && !ShouldRetry(errno)) {
-      FUZZTEST_INTERNAL_CHECK(false, "Cannot poll(): ", strerror(errno));
+      FUZZTEST_CHECK(false) << "Cannot poll(): " << strerror(errno);
     } else if (ret == 0) {
-      FUZZTEST_INTERNAL_CHECK(false, "Impossible timeout: ", strerror(errno));
+      FUZZTEST_CHECK(false) << "Impossible timeout: " << strerror(errno);
     } else if (ret > 0) {
       for (int channel : {kStdOutIdx, kStdErrIdx}) {
         // According to the poll() spec, use -1 for ignored entries.
@@ -274,7 +268,7 @@
     } else if (ret == pid && (WIFEXITED(status) || WIFSIGNALED(status))) {
       return status;
     } else {
-      FUZZTEST_INTERNAL_CHECK(false, "wait() error: ", strerror(errno));
+      FUZZTEST_CHECK(false) << "wait() error: " << strerror(errno);
     }
   }
 }
@@ -291,8 +285,8 @@
       continue;
     } else if (ret == 0) {  // Still running.
       if (should_stop()) {
-        FUZZTEST_INTERNAL_CHECK(kill(pid, SIGTERM) == 0,
-                                "Cannot kill(): ", strerror(errno));
+        FUZZTEST_CHECK(kill(pid, SIGTERM) == 0)
+            << "Cannot kill(): " << strerror(errno);
         return Wait(pid);
       } else {
         absl::SleepFor(sleep_duration);
@@ -301,7 +295,7 @@
     } else if (ret == pid && (WIFEXITED(status) || WIFSIGNALED(status))) {
       return status;
     } else {
-      FUZZTEST_INTERNAL_CHECK(false, "wait() error: ", strerror(errno));
+      FUZZTEST_CHECK(false) "wait() error: " << strerror(errno);
     }
   }
 }
@@ -336,15 +330,13 @@
     const std::optional<absl::flat_hash_map<std::string, std::string>>&
         environment) {
 #if defined(_MSC_VER)
-  FUZZTEST_INTERNAL_CHECK(false,
-                          "Subprocess library not implemented on Windows yet.");
+  FUZZTEST_CHECK(false) << "Subprocess library not implemented on Windows yet.";
 #elif defined(__ANDROID_MIN_SDK_VERSION__) && __ANDROID_MIN_SDK_VERSION__ < 28
-  FUZZTEST_INTERNAL_CHECK(
-      false,
-      "Subprocess library not implemented on older Android NDK versions yet");
+  FUZZTEST_CHECK(false)
+      << "Subprocess library not implemented on older Android NDK versions yet";
 #elif defined(TARGET_OS_TV) && TARGET_OS_TV
-  FUZZTEST_INTERNAL_CHECK(
-      false, "Subprocess library not implemented on Apple tvOS yet");
+  FUZZTEST_INTERNAL_CHECK(false)
+      << "Subprocess library not implemented on Apple tvOS yet";
 #else
   SubProcess proc;
   return proc.Run(command_line, on_stdout_output, on_stderr_output, should_stop,
diff --git a/fuzztest/llvm_fuzzer_wrapper.cc b/fuzztest/llvm_fuzzer_wrapper.cc
index 49c3235..c187773 100644
--- a/fuzztest/llvm_fuzzer_wrapper.cc
+++ b/fuzztest/llvm_fuzzer_wrapper.cc
@@ -12,17 +12,16 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/flags/declare.h"
 #include "absl/flags/flag.h"
-#include "absl/log/absl_check.h"
 #include "absl/random/bit_gen_ref.h"
 #include "absl/random/random.h"
 #include "absl/synchronization/mutex.h"
+#include "./common/logging.h"
 #include "./fuzztest/fuzztest.h"
 #include "./fuzztest/fuzztest_macros.h"
 #include "./fuzztest/internal/domains/arbitrary_impl.h"
 #include "./fuzztest/internal/domains/container_of_impl.h"
 #include "./fuzztest/internal/domains/domain_base.h"
 #include "./fuzztest/internal/io.h"
-#include "./fuzztest/internal/logging.h"
 
 ABSL_DECLARE_FLAG(std::string, llvm_fuzzer_wrapper_dict_file);
 ABSL_DECLARE_FLAG(std::string, llvm_fuzzer_wrapper_corpus_dir);
@@ -75,7 +74,7 @@
   for (const fuzztest::internal::FilePathAndData& file : files) {
     absl::StatusOr<std::vector<std::string>> parsed_entries =
         fuzztest::ParseDictionary(file.data);
-    ABSL_CHECK(parsed_entries.status().ok())
+    FUZZTEST_CHECK(parsed_entries.status().ok())
         << "Could not parse dictionary file " << file.path << ": "
         << parsed_entries.status();
     for (const std::string& parsed_entry : *parsed_entries) {
@@ -104,45 +103,38 @@
  public:
   void Activate(MutationMetadata mutation_metadata) {
     absl::MutexLock lock(&mu_);
-    FUZZTEST_INTERNAL_CHECK(
-        !mutation_metadata_.has_value(),
-        "MutationMetadata is already active before calling Activate()!");
-    FUZZTEST_INTERNAL_CHECK(
-        acquire_count_ == 0,
-        "MutationMetadata still has readers before being calling Activate()!");
+    FUZZTEST_CHECK(!mutation_metadata_.has_value())
+        << "MutationMetadata is already active before calling Activate()!";
+    FUZZTEST_CHECK(acquire_count_ == 0) << "MutationMetadata still has readers "
+                                           "before being calling Activate()!";
     mutation_metadata_ = std::move(mutation_metadata);
   }
 
   void Deactivate() {
     absl::MutexLock lock(&mu_);
-    FUZZTEST_INTERNAL_CHECK(
-        mutation_metadata_.has_value(),
-        "MutationMetadata is not active before calling Deactivate()!");
-    FUZZTEST_INTERNAL_CHECK(
-        acquire_count_ == 0,
-        "MutationMetadata still has readers before calling Deactivate()!");
+    FUZZTEST_CHECK(mutation_metadata_.has_value())
+        << "MutationMetadata is not active before calling Deactivate()!";
+    FUZZTEST_CHECK(acquire_count_ == 0)
+        << "MutationMetadata still has readers before calling Deactivate()!";
     mutation_metadata_ = std::nullopt;
   }
 
   const MutationMetadata& Acquire() {
     absl::MutexLock lock(&mu_);
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-        mutation_metadata_.has_value(),
-        "Cannot acquire unavailable mutation metadata, likely due to the "
-        "fuzzer calling LLVMFuzzerMutate() outside of "
-        "LLVMFuzzerCustomMutator() invocation, which is not allowed.");
+    FUZZTEST_PRECONDITION(mutation_metadata_.has_value())
+        << "Cannot acquire unavailable mutation metadata, likely due to the "
+           "fuzzer calling LLVMFuzzerMutate() outside of "
+           "LLVMFuzzerCustomMutator() invocation, which is not allowed.";
     ++acquire_count_;
     return *mutation_metadata_;
   }
 
   void Release() {
     absl::MutexLock lock(&mu_);
-    FUZZTEST_INTERNAL_CHECK(
-        mutation_metadata_.has_value(),
-        "MutationMetadata is not active before calling Release()!");
-    FUZZTEST_INTERNAL_CHECK(
-        acquire_count_ > 0,
-        "MutationMetadata has no readers before calling Release()!");
+    FUZZTEST_CHECK(mutation_metadata_.has_value())
+        << "MutationMetadata is not active before calling Release()!";
+    FUZZTEST_CHECK(acquire_count_ > 0)
+        << "MutationMetadata has no readers before calling Release()!";
     --acquire_count_;
   }
 
diff --git a/grammar_codegen/BUILD b/grammar_codegen/BUILD
index 8b6b140..f7155bd 100644
--- a/grammar_codegen/BUILD
+++ b/grammar_codegen/BUILD
@@ -29,9 +29,11 @@
     features = ["-use_header_modules"],  # Incompatible with -fexceptions.
     deps = [
         ":grammar_info",
+        "@abseil-cpp//absl/log:absl_check",
+        "@abseil-cpp//absl/log:absl_log",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
-        "@com_google_fuzztest//fuzztest/internal:logging",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//grammar_codegen/generated_antlr_parser",
     ],
 )
@@ -46,6 +48,7 @@
         "@abseil-cpp//absl/container:flat_hash_set",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:str_format",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//fuzztest/internal:logging",
     ],
 )
diff --git a/grammar_codegen/antlr_frontend.cc b/grammar_codegen/antlr_frontend.cc
index cabb68b..4174fdf 100644
--- a/grammar_codegen/antlr_frontend.cc
+++ b/grammar_codegen/antlr_frontend.cc
@@ -25,9 +25,9 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
+#include "./common/logging.h"
 #include "./grammar_codegen/generated_antlr_parser/ANTLRv4Lexer.h"
 #include "./grammar_codegen/grammar_info.h"
-#include "./fuzztest/internal/logging.h"
 
 namespace fuzztest::internal::grammar {
 
@@ -56,9 +56,9 @@
 // Add '^' to the char set if it is a NOT set.
 std::string ConstructCharSetString(absl::string_view raw_str,
                                    bool is_not_set = false) {
-  FUZZTEST_INTERNAL_CHECK(
-      raw_str.size() > 2 && raw_str.front() == '[' && raw_str.back() == ']',
-      "Passed argument is not a range string: `" + std::string(raw_str) + "`");
+  FUZZTEST_CHECK(raw_str.size() > 2 && raw_str.front() == '[' &&
+                 raw_str.back() == ']')
+      << "Passed argument is not a range string: `" << raw_str << "`";
   std::string result(raw_str);
   if (is_not_set) {
     result = absl::StrFormat("[^%s]", result.substr(1, result.size() - 2));
@@ -104,7 +104,7 @@
   if (lexer_atom_ctx->terminal() && lexer_atom_ctx->terminal()->TOKEN_REF()) {
     auto k = block.element.emplace<kNonTerminal>(
         NonTerminal{lexer_atom_ctx->getText()});
-    FUZZTEST_INTERNAL_CHECK(!k.name.empty(), "Empty name!");
+    FUZZTEST_CHECK(!k.name.empty()) << "Empty name!";
   } else {
     auto& terminal = block.element.emplace<kTerminal>();
     std::string text = lexer_atom_ctx->getText();
@@ -123,16 +123,16 @@
           terminal.content =
               ConstructCharSetString(set_element_p->getText(), true);
         } else {
-          FUZZTEST_INTERNAL_CHECK(false, "Not lexer char set!");
+          FUZZTEST_CHECK(false) << "Not lexer char set!";
         }
       } else {
-        FUZZTEST_INTERNAL_CHECK(false, "Unhandled case!");
+        FUZZTEST_CHECK(false) << "Unhandled case!";
       }
     } else if (lexer_atom_ctx->DOT()) {
       terminal.type = TerminalType::kCharSet;
       terminal.content = EscapeString(lexer_atom_ctx->DOT()->getText());
     } else {
-      FUZZTEST_INTERNAL_CHECK(false, "Unhandled case!");
+      FUZZTEST_CHECK(false) << "Unhandled case!";
     }
   }
   return block;
@@ -152,7 +152,7 @@
     } else if (element->lexerAtom() != NULL) {
       block = ConstructBlock(element->lexerAtom());
     } else {
-      FUZZTEST_INTERNAL_CHECK(false, "Unhandled case!");
+      FUZZTEST_CHECK(false) << "Unhandled case!";
     }
     if (element->ebnfSuffix()) {
       block.range = ParseRange(element->ebnfSuffix()->getText());
@@ -175,13 +175,14 @@
 }
 
 Range GrammarInfoBuilder::ParseRange(absl::string_view s) {
-  return (s == "?")                ? Range::kOptional
-         : (s == "+" || s == "+?") ? Range::kNonEmpty
-         : (s == "*" || s == "*?")
-             ? Range::kUnlimited
-             : (FUZZTEST_INTERNAL_CHECK(false,
-                                        absl::StrCat("Unhandled case: ", s)),
-                Range::kNoRange);
+  if (s == "?") {
+    return Range::kOptional;
+  } else if (s == "+" || s == "*?") {
+    return Range::kNonEmpty;
+  } else if (s == "*" || s == "*?") {
+    return Range::kUnlimited;
+  }
+  FUZZTEST_CHECK(false) << "Unhandled case: " << s;
 }
 
 Block GrammarInfoBuilder::ConstructBlock(
@@ -209,7 +210,7 @@
     ChangeStringQuote(node_name);
     terminal_node.content = node_name;
   } else {
-    FUZZTEST_INTERNAL_CHECK(false, "Unhandled case!");
+    FUZZTEST_CHECK(false) << "Unhandled case!";
   }
   return constructed_block;
 }
@@ -231,15 +232,14 @@
     } else if (labeled_element->block()) {
       constructed_block = ConstructBlock(labeled_element->block());
     } else {
-      FUZZTEST_INTERNAL_CHECK(false, "Impossible case!");
+      FUZZTEST_CHECK(false) << "Impossible case!";
     }
   } else {
-    FUZZTEST_INTERNAL_CHECK(false, "Unhandled case!");
+    FUZZTEST_CHECK(false) << "Unhandled case!";
   }
 
   if (element->ebnfSuffix()) {
-    FUZZTEST_INTERNAL_CHECK(!suffix.has_value(),
-                            "It should have only one suffix.");
+    FUZZTEST_CHECK(!suffix.has_value()) << "It should have only one suffix.";
     suffix = element->ebnfSuffix()->getText();
   }
 
@@ -272,7 +272,7 @@
   auto labeledAlt_vec = pctx->ruleBlock()->ruleAltList()->labeledAlt();
   for (auto labeled_alt : pctx->ruleBlock()->ruleAltList()->labeledAlt()) {
     auto ctx = labeled_alt->alternative();
-    FUZZTEST_INTERNAL_CHECK(ctx != nullptr, "Unhandeled case!");
+    FUZZTEST_CHECK(ctx != nullptr) << "Unhandeled case!";
     grammar_rule.productions.production_rules.push_back(
         ConstructProductionRule(ctx));
   }
@@ -282,8 +282,7 @@
 Grammar GrammarInfoBuilder::BuildGrammarInfo(
     const std::vector<std::string>& input_grammar_specs,
     std::optional<std::string> grammar_name, bool insert_space_between_blocks) {
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(!input_grammar_specs.empty(),
-                                       "No input files!");
+  FUZZTEST_PRECONDITION(!input_grammar_specs.empty()) << "No input files!";
 
   insert_space_between_blocks_ = insert_space_between_blocks;
 
@@ -297,18 +296,18 @@
       antlr4::tree::ParseTree* tree = parser.grammarSpec();
       antlr4::tree::ParseTreeWalker::DEFAULT.walk(this, tree);
     } catch (antlr4::ParseCancellationException) {
-      FUZZTEST_INTERNAL_CHECK(false, "Cannot parse the grammar files!");
+      FUZZTEST_CHECK(false) << "Cannot parse the grammar files!";
     } catch (...) {
       // The ParseCancellationException might miss some errors. So we need to
       // catch everything here.
-      FUZZTEST_INTERNAL_CHECK(false, "Unknown errors!");
+      FUZZTEST_CHECK(false) << "Unknown errors!";
     }
   }
   if (grammar_name.has_value()) {
     grammar_name_ = *grammar_name;
   }
-  FUZZTEST_INTERNAL_CHECK(!grammar_name_.empty() && !rules_.empty(),
-                          "Wrong grammar file!");
+  FUZZTEST_CHECK(!grammar_name_.empty() && !rules_.empty())
+      << "Wrong grammar file!";
   return Grammar{std::move(grammar_name_), std::move(rules_)};
 }
 
diff --git a/grammar_codegen/backend.cc b/grammar_codegen/backend.cc
index c3dae47..532318f 100644
--- a/grammar_codegen/backend.cc
+++ b/grammar_codegen/backend.cc
@@ -24,6 +24,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
+#include "./common/logging.h"
 #include "./grammar_codegen/grammar_info.h"
 #include "./fuzztest/internal/logging.h"
 
@@ -45,11 +46,9 @@
 
 std::string CreateIRNodeNameForClass(absl::string_view symbol_name) {
   static int counter = 0;
-  FUZZTEST_INTERNAL_CHECK(
-      symbol_name.size() > 4 &&
-          symbol_name.substr(symbol_name.size() - 4) == "Node",
-      std::string("Not a valid symbol class name: ") + "  " +
-          std::string(symbol_name));
+  FUZZTEST_CHECK(symbol_name.size() > 4 &&
+                 symbol_name.substr(symbol_name.size() - 4) == "Node")
+      << "Not a valid symbol class name: " << symbol_name;
   return absl::StrFormat(
       "%sSubNode%d", symbol_name.substr(0, symbol_name.size() - 4), counter++);
 }
@@ -284,18 +283,16 @@
   std::string class_name = GetClassNameForSymbol(rule.symbol_name);
   const std::vector<ProductionRule>& prod_rules =
       rule.productions.production_rules;
-  FUZZTEST_INTERNAL_CHECK(!prod_rules.empty(), "No expansion!");
+  FUZZTEST_CHECK(!prod_rules.empty()) << "No expansion!";
   if (prod_rules.size() > 1) {
     // This is a variant.
     std::vector<std::string> production_child_types;
     for (const ProductionRule& prod_rule : prod_rules) {
-      FUZZTEST_INTERNAL_CHECK(prod_rule.blocks.size() == 1,
-                              "Incorrect preprocess.");
+      FUZZTEST_CHECK(prod_rule.blocks.size() == 1) << "Incorrect preprocess.";
       auto block = prod_rule.blocks[0];
-      FUZZTEST_INTERNAL_CHECK(
-          block.range == Range::kNoRange &&
-              block.element.index() != BlockType::kSubProductions,
-          "Incorrect preprocess.");
+      FUZZTEST_CHECK(block.range == Range::kNoRange &&
+                     block.element.index() != BlockType::kSubProductions)
+          << "Incorrect preprocess.";
       production_child_types.push_back(GetClassName(block));
     }
     return absl::StrFormat("VariantDomain<k%s, %d, %s>", class_name,
@@ -312,10 +309,9 @@
     std::vector<std::string> production_child_types;
     auto blocks = prod_rules[0].blocks;
     for (const auto& block : blocks) {
-      FUZZTEST_INTERNAL_CHECK(
-          block.range == Range::kNoRange &&
-              block.element.index() != BlockType::kSubProductions,
-          "Incorrect preprocess.");
+      FUZZTEST_CHECK(block.range == Range::kNoRange &&
+                     block.element.index() != BlockType::kSubProductions)
+          << "Incorrect preprocess.";
       production_child_types.push_back(GetClassName(block));
     }
     return absl::StrFormat("TupleDomain<k%s, %s>", class_name,
@@ -390,7 +386,7 @@
       return is_safe;
     }
     default:
-      FUZZTEST_INTERNAL_CHECK(false, "The execution should never reach here!");
+      FUZZTEST_LOG(FATAL) << "unreachable";
   }
 }
 
@@ -422,9 +418,8 @@
   } while (has_change);
 
   for (size_t i = 0; i < safe_rule_indexes.size(); ++i) {
-    FUZZTEST_INTERNAL_CHECK(
-        safe_rule_indexes[i],
-        absl::StrCat("Some node is not safe: ", rules[i].symbol_name));
+    FUZZTEST_CHECK(safe_rule_indexes[i])
+        << "Some node is not safe: " << rules[i].symbol_name;
   }
 
   // Ensure that every sub-block is marked safe. For example, a grammar rule
@@ -453,13 +448,13 @@
       return GetClassNameForSymbol(
           std::get<BlockType::kNonTerminal>(block.element).name);
     default:
-      FUZZTEST_INTERNAL_CHECK(false, "A sub-block doesn't have a name!");
+      FUZZTEST_LOG(FATAL) << "A sub-block doesn't have a name!";
   }
   return "";
 }
 
 std::string CodeGenerator::GetClassNameForSymbol(std::string id) {
-  FUZZTEST_INTERNAL_CHECK(!id.empty(), "Empty node name!");
+  FUZZTEST_CHECK(!id.empty()) << "Empty node name!";
   id[0] = toupper(id[0]);
   if (std::isdigit(id.back())) {
     return id;
diff --git a/tools/BUILD b/tools/BUILD
index 4587e7a..e441ce5 100644
--- a/tools/BUILD
+++ b/tools/BUILD
@@ -29,7 +29,7 @@
     deps = [
         "@abseil-cpp//absl/flags:flag",
         "@abseil-cpp//absl/flags:parse",
-        "@com_google_fuzztest//fuzztest/internal:logging",
+        "@com_google_fuzztest//common:logging",
         "@com_google_fuzztest//grammar_codegen:code_generation",
     ],
 )
diff --git a/tools/grammar_domain_code_generator.cc b/tools/grammar_domain_code_generator.cc
index 66ba9bc..0e0377e 100644
--- a/tools/grammar_domain_code_generator.cc
+++ b/tools/grammar_domain_code_generator.cc
@@ -27,8 +27,8 @@
 
 #include "absl/flags/flag.h"
 #include "absl/flags/parse.h"
+#include "./common/logging.h"
 #include "./grammar_codegen/code_generation.h"
-#include "./fuzztest/internal/logging.h"
 
 ABSL_FLAG(std::string, output_header_file_path, "",
           "Required. The path of the generated grammar header file.");
@@ -62,19 +62,16 @@
   absl::ParseCommandLine(argc, argv);
 
   std::string output_file_path = absl::GetFlag(FLAGS_output_header_file_path);
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-      !output_file_path.empty(),
-      "You must specify output file with --output_header_file_path");
+  FUZZTEST_PRECONDITION(!output_file_path.empty())
+      << "You must specify output file with --output_header_file_path";
   std::ofstream output_file(output_file_path);
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(output_file.is_open(),
-                                       "Cannot open output file!");
+  FUZZTEST_PRECONDITION(output_file.is_open()) << "Cannot open output file!";
 
   std::vector<std::string> input_files =
       absl::GetFlag(FLAGS_input_grammar_files);
 
-  FUZZTEST_INTERNAL_CHECK_PRECONDITION(
-      !input_files.empty(),
-      "You must provide the list of input files, separated by ','");
+  FUZZTEST_PRECONDITION(!input_files.empty())
+      << "You must provide the list of input files, separated by ','";
 
   std::optional<std::string> grammar_name = std::nullopt;
   if (!absl::GetFlag(FLAGS_top_level_rule).empty()) {
@@ -83,8 +80,8 @@
 
   std::vector<std::string> input_grammar_specs;
   for (const std::string& input_file : input_files) {
-    FUZZTEST_INTERNAL_CHECK_PRECONDITION(std::filesystem::exists(input_file),
-                                         input_file.c_str(), " not exist!");
+    FUZZTEST_PRECONDITION(std::filesystem::exists(input_file))
+        << input_file.c_str() << " not exist!";
     input_grammar_specs.push_back(GetContents(input_file));
   }
   output_file << fuzztest::internal::grammar::GenerateGrammarHeader(