[Enhancement](Log) Reduce usage of log fatal(PART I)

be/src/common/status.h

@@ -292,7 +292,8 @@ namespace ErrorCode {
     E(ENTRY_NOT_FOUND, -7002, false);                        \
     E(INVALID_TABLET_STATE, -7211, false);                   \
     E(ROWSETS_EXPIRED, -7311, false);                        \
-    E(CGROUP_ERROR, -7411, false);
+    E(CGROUP_ERROR, -7411, false);                           \
+    E(FATAL_ERROR, -7412, false);
 
 // Define constexpr int error_code_name = error_code_value
 #define M(NAME, ERRORCODE, ENABLESTACKTRACE) constexpr int NAME = ERRORCODE;
@@ -445,6 +446,14 @@ class [[nodiscard]] Status {
 
     static Status OK() { return {}; }
 
+    template <bool stacktrace = true, typename... Args>
+    static Status FatalError(std::string_view msg, Args&&... args) {
+#ifndef NDEBUG
+        LOG(FATAL) << fmt::format(msg, std::forward<Args>(args)...);
+#endif
+        return Error<ErrorCode::FATAL_ERROR, stacktrace>(msg, std::forward<Args>(args)...);
+    }
+
 // default have stacktrace. could disable manually.
 #define ERROR_CTOR(name, code)                                                       \
     template <bool stacktrace = true, typename... Args>                              \

be/src/exprs/hybrid_set.h

@@ -222,28 +222,24 @@ class HybridSetBase : public RuntimeFilterFuncBase {
 
     virtual void find_batch(const doris::vectorized::IColumn& column, size_t rows,
                             doris::vectorized::ColumnUInt8::Container& results) {
-        LOG(FATAL) << "HybridSetBase not support find_batch";
-        __builtin_unreachable();
+        throw Exception(Status::FatalError("HybridSetBase not support find_batch"));
     }
 
     virtual void find_batch_negative(const doris::vectorized::IColumn& column, size_t rows,
                                      doris::vectorized::ColumnUInt8::Container& results) {
-        LOG(FATAL) << "HybridSetBase not support find_batch_negative";
-        __builtin_unreachable();
+        throw Exception(Status::FatalError("HybridSetBase not support find_batch_negative"));
     }
 
     virtual void find_batch_nullable(const doris::vectorized::IColumn& column, size_t rows,
                                      const doris::vectorized::NullMap& null_map,
                                      doris::vectorized::ColumnUInt8::Container& results) {
-        LOG(FATAL) << "HybridSetBase not support find_batch_nullable";
-        __builtin_unreachable();
+        throw Exception(Status::FatalError("HybridSetBase not support find_batch_nullable"));
     }
 
     virtual void find_batch_nullable_negative(const doris::vectorized::IColumn& column, size_t rows,
                                               const doris::vectorized::NullMap& null_map,
                                               doris::vectorized::ColumnUInt8::Container& results) {
-        LOG(FATAL) << "HybridSetBase not support find_batch_nullable_negative";
-        __builtin_unreachable();
+        throw Exception(Status::FatalError("HybridSetBase not support find_batch_nullable_negative"));
     }
 
     class IteratorBase {

be/src/gutil/strings/escaping.cc

@@ -10,6 +10,8 @@
 #include <limits>
 #include <ostream>
 
+#include "common/exception.h"
+
 using std::numeric_limits;
 #include <vector>
 
@@ -1084,7 +1086,8 @@ int Base64UnescapeInternal(const char* src, int szsrc, char* dest, int szdest,
 
     default:
         // state should have no other values at this point.
-        LOG(FATAL) << "This can't happen; base64 decoder state = " << state;
+        throw doris::Exception(
+                doris::Status::FatalError("This can't happen; base64 decoder state = {}", state));
     }
 
     // The remainder of the string should be all whitespace, mixed with

be/src/gutil/strings/numbers.cc

@@ -19,6 +19,8 @@
 #include <limits>
 #include <ostream>
 
+#include "common/exception.h"
+
 using std::numeric_limits;
 #include <string>
 
@@ -772,8 +774,8 @@ uint64 atoi_kmgt(const char* s) {
             scale = GG_ULONGLONG(1) << 40;
             break;
         default:
-            LOG(FATAL) << "Invalid mnemonic: `" << c << "';"
-                       << " should be one of `K', `M', `G', and `T'.";
+            throw doris::Exception(doris::Status::FatalError(
+                    "Invalid mnemonic: `{}'; should be one of `K', `M', `G', and `T'.", c));
         }
     }
     return n * scale;

be/src/gutil/strings/util.cc

@@ -19,6 +19,8 @@
 #include <mutex>
 #include <ostream>
 
+#include "common/exception.h"
+
 using std::copy;
 using std::max;
 using std::min;
@@ -489,7 +491,7 @@ const char* strstr_delimited(const char* haystack, const char* needle, char deli
             ++haystack;
         }
     }
-    LOG(FATAL) << "Unreachable statement";
+    throw doris::Exception(doris::Status::FatalError("Unreachable statement"));
     return nullptr;
 }
 

be/src/gutil/threading/thread_collision_warner.cc

@@ -4,6 +4,9 @@
 
 #include "gutil/threading/thread_collision_warner.h"
 
+#include "common/exception.h"
+#include "common/status.h"
+
 #ifdef __linux__
 #include <syscall.h>
 #else
@@ -19,8 +22,9 @@
 namespace base {
 
 void DCheckAsserter::warn(int64_t previous_thread_id, int64_t current_thread_id) {
-    LOG(FATAL) << "Thread Collision! Previous thread id: " << previous_thread_id
-               << ", current thread id: " << current_thread_id;
+    throw doris::Exception(doris::Status::FatalError(
+            "Thread Collision! Previous thread id: {}, current thread id: {}", previous_thread_id,
+            current_thread_id));
 }
 
 static subtle::Atomic64 CurrentThread() {

be/src/io/file_factory.h

@@ -118,10 +118,9 @@ class FileFactory {
         case TStorageBackendType::HDFS:
             return TFileType::FILE_HDFS;
         default:
-            LOG(FATAL) << "not match type to convert, from type:" << type;
+            throw Exception(Status::FatalError("not match type to convert, from type:{}", type));
         }
-        LOG(FATAL) << "__builtin_unreachable";
-        __builtin_unreachable();
+        throw Exception(Status::FatalError("__builtin_unreachable"));
     }
 };
 

be/src/olap/block_column_predicate.h

@@ -74,24 +74,24 @@ class BlockColumnPredicate {
     }
 
     virtual bool can_do_apply_safely(PrimitiveType input_type, bool is_null) const {
-        LOG(FATAL) << "should not reach here";
+        throw Exception(Status::FatalError("should not reach here"));
         return true;
     }
 
     virtual bool support_zonemap() const { return true; }
 
     virtual bool evaluate_and(const std::pair<WrapperField*, WrapperField*>& statistic) const {
-        LOG(FATAL) << "should not reach here";
+        throw Exception(Status::FatalError("should not reach here"));
         return true;
     }
 
     virtual bool evaluate_and(const segment_v2::BloomFilter* bf) const {
-        LOG(FATAL) << "should not reach here";
+        throw Exception(Status::FatalError("should not reach here"));
         return true;
     }
 
     virtual bool evaluate_and(const StringRef* dict_words, const size_t dict_num) const {
-        LOG(FATAL) << "should not reach here";
+        throw Exception(Status::FatalError("should not reach here"));
         return true;
     }
 

be/src/olap/comparison_predicate.h

@@ -216,7 +216,7 @@ class ComparisonPredicateBase : public ColumnPredicate {
                 }
             }
         } else {
-            LOG(FATAL) << "Bloom filter is not supported by predicate type.";
+            throw Exception(Status::FatalError("Bloom filter is not supported by predicate type."));
             return true;
         }
     }

be/src/olap/data_dir.cpp

@@ -316,10 +316,10 @@ Status DataDir::_check_incompatible_old_format_tablet() {
                                           std::string_view value) -> bool {
         // if strict check incompatible old format, then log fatal
         if (config::storage_strict_check_incompatible_old_format) {
-            LOG(FATAL)
-                    << "There are incompatible old format metas, current version does not support "
-                    << "and it may lead to data missing!!! "
-                    << "tablet_id = " << tablet_id << " schema_hash = " << schema_hash;
+            throw Exception(Status::FatalError(
+                    "There are incompatible old format metas, current version does not support and "
+                    "it may lead to data missing!!! tablet_id = {} schema_hash = {}",
+                    tablet_id, schema_hash));
         } else {
             LOG(WARNING)
                     << "There are incompatible old format metas, current version does not support "
@@ -451,7 +451,8 @@ Status DataDir::load() {
                      << ", loaded tablet: " << tablet_ids.size()
                      << ", error tablet: " << failed_tablet_ids.size() << ", path: " << _path;
         if (!config::ignore_load_tablet_failure) {
-            LOG(FATAL) << "load tablets encounter failure. stop BE process. path: " << _path;
+            throw Exception(Status::FatalError(
+                    "load tablets encounter failure. stop BE process. path: {}", _path));
         }
     }
     if (!load_tablet_status) {
@@ -495,9 +496,9 @@ Status DataDir::load() {
         }
     }
     if (rowset_partition_id_eq_0_num > config::ignore_invalid_partition_id_rowset_num) {
-        LOG(FATAL) << fmt::format(
+        throw Exception(Status::FatalError(
                 "roswet partition id eq 0 is {} bigger than config {}, be exit, plz check be.INFO",
-                rowset_partition_id_eq_0_num, config::ignore_invalid_partition_id_rowset_num);
+                rowset_partition_id_eq_0_num, config::ignore_invalid_partition_id_rowset_num));
         exit(-1);
     }
 

be/src/olap/in_list_predicate.h

@@ -331,7 +331,7 @@ class InListPredicateBase : public ColumnPredicate {
             }
             return false;
         } else {
-            LOG(FATAL) << "Bloom filter is not supported by predicate type.";
+            throw Exception(Status::FatalError("Bloom filter is not supported by predicate type."));
             return true;
         }
     }
@@ -431,8 +431,8 @@ class InListPredicateBase : public ColumnPredicate {
                     }
                 }
             } else {
-                LOG(FATAL) << "column_dictionary must use StringRef predicate.";
-                __builtin_unreachable();
+                throw Exception(
+                        Status::FatalError("column_dictionary must use StringRef predicate."));
             }
         } else {
             auto& pred_col =
@@ -495,8 +495,8 @@ class InListPredicateBase : public ColumnPredicate {
                     }
                 }
             } else {
-                LOG(FATAL) << "column_dictionary must use StringRef predicate.";
-                __builtin_unreachable();
+                throw Exception(
+                        Status::FatalError("column_dictionary must use StringRef predicate."));
             }
         } else {
             auto* nested_col_ptr = vectorized::check_and_get_column<

be/src/olap/key_coder.h

@@ -109,8 +109,8 @@ class KeyCoderTraits<
             case 16:
                 return BigEndian::FromHost128(val);
             default:
-                LOG(FATAL) << "Invalid type to big endian, type=" << int(field_type)
-                           << ", size=" << sizeof(UnsignedCppType);
+                throw Exception(Status::FatalError("Invalid type to big endian, type={}, size={}",
+                                                   int(field_type), sizeof(UnsignedCppType)));
             }
         }
     }
@@ -300,7 +300,7 @@ class KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_CHAR> {
     }
 
     static Status decode_ascending(Slice* encoded_key, size_t index_size, uint8_t* cell_ptr) {
-        LOG(FATAL) << "decode_ascending is not implemented";
+        throw Exception(Status::FatalError("decode_ascending is not implemented"));
         return Status::OK();
     }
 };
@@ -320,7 +320,7 @@ class KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_VARCHAR> {
     }
 
     static Status decode_ascending(Slice* encoded_key, size_t index_size, uint8_t* cell_ptr) {
-        LOG(FATAL) << "decode_ascending is not implemented";
+        throw Exception(Status::FatalError("decode_ascending is not implemented"));
         return Status::OK();
     }
 };
@@ -340,7 +340,7 @@ class KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_STRING> {
     }
 
     static Status decode_ascending(Slice* encoded_key, size_t index_size, uint8_t* cell_ptr) {
-        LOG(FATAL) << "decode_ascending is not implemented";
+        throw Exception(Status::FatalError("decode_ascending is not implemented"));
         return Status::OK();
     }
 };

be/src/olap/like_column_predicate.h

@@ -128,8 +128,8 @@ class LikeColumnPredicate : public ColumnPredicate {
                     }
                 }
             } else {
-                LOG(FATAL) << "vectorized (not) like predicates should be dict column";
-                __builtin_unreachable();
+                throw Exception(Status::FatalError(
+                        "vectorized (not) like predicates should be dict column"));
             }
         } else {
             if (column.is_column_dictionary()) {
@@ -153,8 +153,8 @@ class LikeColumnPredicate : public ColumnPredicate {
                     }
                 }
             } else {
-                LOG(FATAL) << "vectorized (not) like predicates should be dict column";
-                __builtin_unreachable();
+                throw Exception(Status::FatalError(
+                        "vectorized (not) like predicates should be dict column"));
             }
         }
     }

be/src/olap/match_predicate.h

@@ -55,8 +55,7 @@ class MatchPredicate : public ColumnPredicate {
     //evaluate predicate on Bitmap
     Status evaluate(BitmapIndexIterator* iterator, uint32_t num_rows,
                     roaring::Roaring* roaring) const override {
-        LOG(FATAL) << "Not Implemented MatchPredicate::evaluate";
-        __builtin_unreachable();
+        throw Exception(Status::FatalError("Not Implemented MatchPredicate::evaluate"));
     }
 
     //evaluate predicate on inverted

be/src/olap/memtable.cpp

@@ -28,6 +28,7 @@
 
 #include "bvar/bvar.h"
 #include "common/config.h"
+#include "common/exception.h"
 #include "olap/memtable_memory_limiter.h"
 #include "olap/olap_define.h"
 #include "olap/tablet_schema.h"

be/src/olap/null_predicate.h

@@ -87,7 +87,8 @@ class NullPredicate : public ColumnPredicate {
         if (_is_null) {
             return bf->test_bytes(nullptr, 0);
         } else {
-            LOG(FATAL) << "Bloom filter is not supported by predicate type: is_null=" << _is_null;
+            throw Exception(Status::FatalError(
+                    "Bloom filter is not supported by predicate type: is_null="));
             return true;
         }
     }

be/src/olap/olap_common.h

@@ -35,6 +35,7 @@
 #include <unordered_set>
 #include <utility>
 
+#include "common/exception.h"
 #include "io/io_common.h"
 #include "olap/olap_define.h"
 #include "olap/rowset/rowset_fwd.h"
@@ -416,7 +417,8 @@ struct RowsetId {
             auto [_, ec] = std::from_chars(rowset_id_str.data(),
                                            rowset_id_str.data() + rowset_id_str.length(), high);
             if (ec != std::errc {}) [[unlikely]] {
-                LOG(FATAL) << "failed to init rowset id: " << rowset_id_str;
+                throw Exception(
+                        Status::FatalError("failed to init rowset id: {}", rowset_id_str));
             }
             init(1, high, 0, 0);
         } else {
@@ -436,7 +438,7 @@ struct RowsetId {
     void init(int64_t id_version, int64_t high, int64_t middle, int64_t low) {
         version = id_version;
         if (UNLIKELY(high >= MAX_ROWSET_ID)) {
-            LOG(FATAL) << "inc rowsetid is too large:" << high;
+            throw Exception(Status::FatalError("inc rowsetid is too large:{}", high));
         }
         hi = (id_version << 56) + (high & LOW_56_BITS);
         mi = middle;

be/src/olap/page_cache.h

@@ -176,11 +176,9 @@ class StoragePageCache {
             return _pk_index_page_cache.get();
         }
         default:
-            LOG(FATAL) << "get error type page cache";
-            __builtin_unreachable();
+            throw Exception(Status::FatalError("get error type page cache"));
         }
-        LOG(FATAL) << "__builtin_unreachable";
-        __builtin_unreachable();
+        throw Exception(Status::FatalError("__builtin_unreachable"));
     }
 };
 

be/src/olap/rowset/beta_rowset_writer_v2.h

@@ -99,7 +99,7 @@ class BetaRowsetWriterV2 : public RowsetWriter {
     };
 
     RowsetSharedPtr manual_build(const RowsetMetaSharedPtr& rowset_meta) override {
-        LOG(FATAL) << "not implemeted";
+        throw Exception(Status::FatalError("not implemeted"));
         return nullptr;
     }