diff --git a/.clang-format b/.clang-format
index 04bec9bceec..bcf5df71785 100644
--- a/.clang-format
+++ b/.clang-format
@@ -166,7 +166,7 @@ SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
 SpaceBeforeSquareBrackets: false
-Standard:        Auto
+Standard:        c++17
 StatementMacros:
   - Q_UNUSED
   - QT_REQUIRE_VERSION
diff --git a/.github/PULL_REQUEST_TEMPLATE/bugfix.md b/.github/PULL_REQUEST_TEMPLATE/bugfix.md
deleted file mode 100644
index 5746f238589..00000000000
--- a/.github/PULL_REQUEST_TEMPLATE/bugfix.md
+++ /dev/null
@@ -1,24 +0,0 @@
-<!--
-Thank you for contributing to **Nebula Graph**! Please read the [CONTRIBUTING](https://github.com/vesoft-inc/nebula/blob/master/docs/manual-EN/4.contributions/how-to-contribute.md
-) document **BEFORE** filing this PR.
--->
-
-### What's the bug and how to reproduce?
-<!-- Link the related issue if exists -->
-
-### What's the expected behavior?
-<!-- Link the origin design if exists -->
-
-### How was this patch tested?
-<!--
-If tests were added, say they were added here. Please make sure to add some test cases that check the changes thoroughly including negative and positive cases if possible.
-If it was tested in a way different from regular unit tests, please clarify how you tested step by step, ideally copy and paste-able, so that other reviewers can test and check, and descendants can verify in the future.
-If tests were not added, please describe why they were not added and/or why it was difficult to add.
--->
-
-### Checklist
-<!--Tick the checkbox(es) below to choose what you have done.-->
-
-- [ ] I've run the tests to see all new and existing tests pass
-- [ ] If this Pull Request resolves an issue, I linked to the issue in the text above
-- [ ] I've informed the technical writer about the documentation change if necessary
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index f477bb6d05b..8090d5f54bd 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -114,10 +114,11 @@ jobs:
               -DENABLE_COVERAGE=on \
               -B build
           echo "::set-output name=j::10"
-          echo "::set-output name=t::10"
+          echo "::set-output name=t::6"
       - name: Make
         run: |
           ccache -z
+          cmake --build build/ -j $(nproc) --target nebula-metad nebula-storaged nebula-graphd
           cmake --build build/ -j ${{ steps.cmake.outputs.t }}
           ccache -s
       - name: CTest
diff --git a/.github/workflows/pull_request.yml b/.github/workflows/pull_request.yml
index 93edc0147b0..ff6427ae75f 100644
--- a/.github/workflows/pull_request.yml
+++ b/.github/workflows/pull_request.yml
@@ -97,7 +97,7 @@ jobs:
                   -DENABLE_COVERAGE=on \
                   -B build
               echo "::set-output name=j::10"
-              echo "::set-output name=t::10"
+              echo "::set-output name=t::6"
               ;;
             esac
             ;;
@@ -117,6 +117,7 @@ jobs:
       - name: Make
         run: |
           ccache -z
+          cmake --build build/ -j $(nproc) --target nebula-metad nebula-storaged nebula-graphd
           cmake --build build/ -j ${{ steps.cmake.outputs.t }}
           ccache -s
       - name: CTest
diff --git a/cmake/CPackage.cmake b/cmake/CPackage.cmake
index b26eda90e5a..36a9acbc149 100644
--- a/cmake/CPackage.cmake
+++ b/cmake/CPackage.cmake
@@ -129,10 +129,11 @@ macro(package to_one name home_page scripts_dir)
         set(HOST_SYSTEM_VER "Unknown")
     endif()
 
-    message(STATUS "HOST_SYSTEM_NAME is ${HOST_SYSTEM_NAME}")
-    message(STATUS "HOST_SYSTEM_VER is ${HOST_SYSTEM_VER}")
-    message(STATUS "CPACK_GENERATOR is ${CPACK_GENERATOR}")
-    message(STATUS "CMAKE_HOST_SYSTEM_PROCESSOR is ${CMAKE_HOST_SYSTEM_PROCESSOR}")
+    print_config(NEBULA_BUILD_VERSION)
+    print_config(HOST_SYSTEM_NAME)
+    print_config(HOST_SYSTEM_VER)
+    print_config(CPACK_GENERATOR)
+    print_config(CMAKE_HOST_SYSTEM_PROCESSOR)
 
     set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}.${HOST_SYSTEM_VER}.${CMAKE_HOST_SYSTEM_PROCESSOR})
     if (${to_one})
diff --git a/src/clients/meta/MetaClient.cpp b/src/clients/meta/MetaClient.cpp
index a3e46fc9c0d..d4766213d32 100644
--- a/src/clients/meta/MetaClient.cpp
+++ b/src/clients/meta/MetaClient.cpp
@@ -2335,9 +2335,7 @@ folly::Future<StatusOr<bool>> MetaClient::heartbeat() {
   req.set_host(options_.localHost_);
   req.set_role(options_.role_);
   req.set_git_info_sha(options_.gitInfoSHA_);
-#if defined(NEBULA_BUILD_VERSION)
-  req.set_version(versionString(false));
-#endif
+  req.set_version(getOriginVersion());
   if (options_.role_ == cpp2::HostRole::STORAGE) {
     if (options_.clusterId_.load() == 0) {
       options_.clusterId_ = FileBasedClusterIdMan::getClusterIdFromFile(FLAGS_cluster_id_path);
diff --git a/src/common/base/EitherOr.h b/src/common/base/EitherOr.h
index 595f35b24f8..620ed93035c 100644
--- a/src/common/base/EitherOr.h
+++ b/src/common/base/EitherOr.h
@@ -159,7 +159,7 @@ class EitherOr {
   template <typename U,
             typename V,
             typename = std::enable_if_t<std::is_constructible<LEFT, U>::value &&
-                                        std::is_constructible<RIGHT, V>::value> >
+                                        std::is_constructible<RIGHT, V>::value>>
   EitherOr(const EitherOr<U, V>& rhs) noexcept {
     switch (rhs.state_) {
       case State::VOID:
@@ -178,7 +178,7 @@ class EitherOr {
   template <typename U,
             typename V,
             typename = std::enable_if_t<std::is_constructible<LEFT, U>::value &&
-                                        std::is_constructible<RIGHT, V>::value> >
+                                        std::is_constructible<RIGHT, V>::value>>
   EitherOr(EitherOr<U, V>&& rhs) noexcept {
     switch (rhs.state_) {
       case State::VOID:
@@ -218,7 +218,7 @@ class EitherOr {
   // LEFT or RIGHT, not both
   template <class... Args,
             typename = std::enable_if_t<std::is_constructible<LEFT, Args...>::value ||
-                                        std::is_constructible<RIGHT, Args...>::value> >
+                                        std::is_constructible<RIGHT, Args...>::value>>
   EitherOr(Args&&... v) noexcept {  // NOLINT
     new (&val_) Variant(convert_to_t<Args...>, std::forward<Args>(v)...);
     state_ = convert_to_s<Args...>;
@@ -228,7 +228,7 @@ class EitherOr {
   // So we use a type tag to force selecting LEFT
   template <typename U,
             typename = std::enable_if_t<std::is_constructible<LEFT, U>::value &&
-                                        std::is_constructible<RIGHT, U>::value> >
+                                        std::is_constructible<RIGHT, U>::value>>
   EitherOr(const LeftType*, U&& v) noexcept {
     new (&val_) Variant(kConstructLeft, std::forward<U>(v));
     state_ = State::LEFT_TYPE;
@@ -238,7 +238,7 @@ class EitherOr {
   // So we use a type tag to force selecting RIGHT
   template <typename U,
             typename = std::enable_if_t<std::is_constructible<LEFT, U>::value &&
-                                        std::is_constructible<RIGHT, U>::value> >
+                                        std::is_constructible<RIGHT, U>::value>>
   EitherOr(const RightType*, U&& v) noexcept {
     new (&val_) Variant(kConstructRight, std::forward<U>(v));
     state_ = State::RIGHT_TYPE;
diff --git a/src/common/base/ErrorOr.h b/src/common/base/ErrorOr.h
index 40fe16d76bf..c8c2030404c 100644
--- a/src/common/base/ErrorOr.h
+++ b/src/common/base/ErrorOr.h
@@ -30,7 +30,7 @@ namespace nebula {
 template <typename ErrorCode,
           typename ResultType,
           typename = std::enable_if_t<std::is_integral<ErrorCode>::value ||
-                                      std::is_enum<ErrorCode>::value> >
+                                      std::is_enum<ErrorCode>::value>>
 using ErrorOr = EitherOr<ErrorCode, ResultType>;
 
 /***********************************************
diff --git a/src/common/datatypes/DataSetOps-inl.h b/src/common/datatypes/DataSetOps-inl.h
index e1871426c17..a0757d0b6c1 100644
--- a/src/common/datatypes/DataSetOps-inl.h
+++ b/src/common/datatypes/DataSetOps-inl.h
@@ -53,12 +53,12 @@ uint32_t Cpp2Ops<nebula::DataSet>::write(Protocol* proto, nebula::DataSet const*
 
   xfer += proto->writeFieldBegin("column_names", protocol::T_LIST, 1);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::binary>,
-                                       std::vector<std::string> >::write(*proto, obj->colNames);
+                                       std::vector<std::string>>::write(*proto, obj->colNames);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldBegin("rows", apache::thrift::protocol::T_LIST, 2);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Row> >::write(*proto, obj->rows);
+                                       std::vector<nebula::Row>>::write(*proto, obj->rows);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -81,7 +81,7 @@ void Cpp2Ops<nebula::DataSet>::read(Protocol* proto, nebula::DataSet* obj) {
 _readField_column_names : {
   obj->colNames = std::vector<std::string>();
   detail::pm::protocol_methods<type_class::list<type_class::binary>,
-                               std::vector<std::string> >::read(*proto, obj->colNames);
+                               std::vector<std::string>>::read(*proto, obj->colNames);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_LIST))) {
@@ -91,7 +91,7 @@ _readField_column_names : {
 _readField_rows : {
   obj->rows = std::vector<nebula::Row>();
   detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                               std::vector<nebula::Row> >::read(*proto, obj->rows);
+                               std::vector<nebula::Row>>::read(*proto, obj->rows);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 2, 0, protocol::T_STOP))) {
@@ -147,13 +147,13 @@ uint32_t Cpp2Ops<nebula::DataSet>::serializedSize(Protocol const* proto,
   xfer += proto->serializedFieldSize("column_names", protocol::T_LIST, 1);
   xfer +=
       detail::pm::protocol_methods<type_class::list<type_class::binary>,
-                                   std::vector<std::string> >::serializedSize<false>(*proto,
-                                                                                     obj->colNames);
+                                   std::vector<std::string>>::serializedSize<false>(*proto,
+                                                                                    obj->colNames);
 
   xfer += proto->serializedFieldSize("rows", apache::thrift::protocol::T_LIST, 2);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Row> >::serializedSize<false>(*proto,
-                                                                                         obj->rows);
+                                       std::vector<nebula::Row>>::serializedSize<false>(*proto,
+                                                                                        obj->rows);
 
   xfer += proto->serializedSizeStop();
   return xfer;
@@ -168,13 +168,13 @@ uint32_t Cpp2Ops<nebula::DataSet>::serializedSizeZC(Protocol const* proto,
   xfer += proto->serializedFieldSize("column_names", protocol::T_LIST, 1);
   xfer +=
       detail::pm::protocol_methods<type_class::list<type_class::binary>,
-                                   std::vector<std::string> >::serializedSize<false>(*proto,
-                                                                                     obj->colNames);
+                                   std::vector<std::string>>::serializedSize<false>(*proto,
+                                                                                    obj->colNames);
 
   xfer += proto->serializedFieldSize("rows", protocol::T_LIST, 2);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Row> >::serializedSize<false>(*proto,
-                                                                                         obj->rows);
+                                       std::vector<nebula::Row>>::serializedSize<false>(*proto,
+                                                                                        obj->rows);
 
   xfer += proto->serializedSizeStop();
   return xfer;
diff --git a/src/common/datatypes/EdgeOps-inl.h b/src/common/datatypes/EdgeOps-inl.h
index b236d5a62b8..93b74cd1e28 100644
--- a/src/common/datatypes/EdgeOps-inl.h
+++ b/src/common/datatypes/EdgeOps-inl.h
@@ -88,7 +88,7 @@ uint32_t Cpp2Ops<nebula::Edge>::write(Protocol* proto, nebula::Edge const* obj)
   xfer += proto->writeFieldBegin("props", apache::thrift::protocol::T_MAP, 6);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::write(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::write(*proto, obj->props);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -145,8 +145,8 @@ _readField_ranking : {
 _readField_props : {
   obj->props = std::unordered_map<std::string, nebula::Value>();
   detail::pm::protocol_methods<type_class::map<type_class::binary, type_class::structure>,
-                               std::unordered_map<std::string, nebula::Value> >::read(*proto,
-                                                                                      obj->props);
+                               std::unordered_map<std::string, nebula::Value>>::read(*proto,
+                                                                                     obj->props);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 6, 0, protocol::T_STOP))) {
@@ -248,7 +248,7 @@ uint32_t Cpp2Ops<nebula::Edge>::serializedSize(Protocol const* proto, nebula::Ed
   xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 6);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->props);
 
   xfer += proto->serializedSizeStop();
   return xfer;
@@ -281,7 +281,7 @@ uint32_t Cpp2Ops<nebula::Edge>::serializedSizeZC(Protocol const* proto, nebula::
   xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 6);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->props);
 
   xfer += proto->serializedSizeStop();
   return xfer;
diff --git a/src/common/datatypes/ListOps-inl.h b/src/common/datatypes/ListOps-inl.h
index ec05620c710..c1b80589718 100644
--- a/src/common/datatypes/ListOps-inl.h
+++ b/src/common/datatypes/ListOps-inl.h
@@ -45,7 +45,7 @@ uint32_t Cpp2Ops<nebula::List>::write(Protocol* proto, nebula::List const* obj)
 
   xfer += proto->writeFieldBegin("values", apache::thrift::protocol::T_LIST, 1);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Value> >::write(*proto, obj->values);
+                                       std::vector<nebula::Value>>::write(*proto, obj->values);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -68,7 +68,7 @@ void Cpp2Ops<nebula::List>::read(Protocol* proto, nebula::List* obj) {
 _readField_values : {
   obj->values = std::vector<nebula::Value>();
   detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                               std::vector<nebula::Value> >::read(*proto, obj->values);
+                               std::vector<nebula::Value>>::read(*proto, obj->values);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 1, 0, protocol::T_STOP))) {
@@ -116,8 +116,8 @@ uint32_t Cpp2Ops<nebula::List>::serializedSize(Protocol const* proto, nebula::Li
   xfer += proto->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 1);
   xfer +=
       detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                   std::vector<nebula::Value> >::serializedSize<false>(*proto,
-                                                                                       obj->values);
+                                   std::vector<nebula::Value>>::serializedSize<false>(*proto,
+                                                                                      obj->values);
   xfer += proto->serializedSizeStop();
   return xfer;
 }
@@ -130,8 +130,8 @@ uint32_t Cpp2Ops<nebula::List>::serializedSizeZC(Protocol const* proto, nebula::
   xfer += proto->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 1);
   xfer +=
       detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                   std::vector<nebula::Value> >::serializedSize<false>(*proto,
-                                                                                       obj->values);
+                                   std::vector<nebula::Value>>::serializedSize<false>(*proto,
+                                                                                      obj->values);
   xfer += proto->serializedSizeStop();
   return xfer;
 }
diff --git a/src/common/datatypes/MapOps-inl.h b/src/common/datatypes/MapOps-inl.h
index aa79503063c..332127e1a81 100644
--- a/src/common/datatypes/MapOps-inl.h
+++ b/src/common/datatypes/MapOps-inl.h
@@ -44,9 +44,10 @@ uint32_t Cpp2Ops<nebula::Map>::write(Protocol* proto, nebula::Map const* obj) {
   xfer += proto->writeStructBegin("NMap");
 
   xfer += proto->writeFieldBegin("kvs", apache::thrift::protocol::T_MAP, 1);
-  xfer += detail::pm::protocol_methods<
-      type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::write(*proto, obj->kvs);
+  xfer +=
+      detail::pm::protocol_methods<type_class::map<type_class::binary, type_class::structure>,
+                                   std::unordered_map<std::string, nebula::Value>>::write(*proto,
+                                                                                          obj->kvs);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -69,8 +70,8 @@ void Cpp2Ops<nebula::Map>::read(Protocol* proto, nebula::Map* obj) {
 _readField_kvs : {
   obj->kvs = std::unordered_map<std::string, nebula::Value>();
   detail::pm::protocol_methods<type_class::map<type_class::binary, type_class::structure>,
-                               std::unordered_map<std::string, nebula::Value> >::read(*proto,
-                                                                                      obj->kvs);
+                               std::unordered_map<std::string, nebula::Value>>::read(*proto,
+                                                                                     obj->kvs);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 1, 0, protocol::T_STOP))) {
@@ -118,7 +119,7 @@ uint32_t Cpp2Ops<nebula::Map>::serializedSize(Protocol const* proto, nebula::Map
   xfer += proto->serializedFieldSize("kvs", apache::thrift::protocol::T_MAP, 1);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->kvs);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->kvs);
   xfer += proto->serializedSizeStop();
   return xfer;
 }
@@ -131,7 +132,7 @@ uint32_t Cpp2Ops<nebula::Map>::serializedSizeZC(Protocol const* proto, nebula::M
   xfer += proto->serializedFieldSize("kvs", apache::thrift::protocol::T_MAP, 1);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->kvs);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->kvs);
   xfer += proto->serializedSizeStop();
   return xfer;
 }
diff --git a/src/common/datatypes/PathOps-inl.h b/src/common/datatypes/PathOps-inl.h
index 8e9f7bed7e0..677d32b822d 100644
--- a/src/common/datatypes/PathOps-inl.h
+++ b/src/common/datatypes/PathOps-inl.h
@@ -86,7 +86,7 @@ uint32_t Cpp2Ops<nebula::Step>::write(Protocol* proto, nebula::Step const* obj)
   xfer += proto->writeFieldBegin("props", apache::thrift::protocol::T_MAP, 5);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::write(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::write(*proto, obj->props);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -138,8 +138,8 @@ _readField_ranking : {
 _readField_props : {
   obj->props = std::unordered_map<std::string, nebula::Value>();
   detail::pm::protocol_methods<type_class::map<type_class::binary, type_class::structure>,
-                               std::unordered_map<std::string, nebula::Value> >::read(*proto,
-                                                                                      obj->props);
+                               std::unordered_map<std::string, nebula::Value>>::read(*proto,
+                                                                                     obj->props);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 5, 0, protocol::T_STOP))) {
@@ -231,7 +231,7 @@ uint32_t Cpp2Ops<nebula::Step>::serializedSize(Protocol const* proto, nebula::St
   xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 5);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->props);
 
   xfer += proto->serializedSizeStop();
   return xfer;
@@ -261,7 +261,7 @@ uint32_t Cpp2Ops<nebula::Step>::serializedSizeZC(Protocol const* proto, nebula::
   xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 5);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->props);
 
   xfer += proto->serializedSizeStop();
   return xfer;
@@ -306,7 +306,7 @@ uint32_t Cpp2Ops<nebula::Path>::write(Protocol* proto, nebula::Path const* obj)
 
   xfer += proto->writeFieldBegin("steps", apache::thrift::protocol::T_LIST, 2);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Step> >::write(*proto, obj->steps);
+                                       std::vector<nebula::Step>>::write(*proto, obj->steps);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -335,7 +335,7 @@ _readField_src : { Cpp2Ops<nebula::Vertex>::read(proto, &obj->src); }
 _readField_steps : {
   obj->steps = std::vector<nebula::Step>();
   detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                               std::vector<nebula::Step> >::read(*proto, obj->steps);
+                               std::vector<nebula::Step>>::read(*proto, obj->steps);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 2, 0, protocol::T_STOP))) {
@@ -393,8 +393,8 @@ uint32_t Cpp2Ops<nebula::Path>::serializedSize(Protocol const* proto, nebula::Pa
   xfer += proto->serializedFieldSize("steps", apache::thrift::protocol::T_LIST, 2);
   xfer +=
       detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                   std::vector<nebula::Step> >::serializedSize<false>(*proto,
-                                                                                      obj->steps);
+                                   std::vector<nebula::Step>>::serializedSize<false>(*proto,
+                                                                                     obj->steps);
 
   xfer += proto->serializedSizeStop();
   return xfer;
@@ -411,8 +411,8 @@ uint32_t Cpp2Ops<nebula::Path>::serializedSizeZC(Protocol const* proto, nebula::
   xfer += proto->serializedFieldSize("steps", apache::thrift::protocol::T_LIST, 2);
   xfer +=
       detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                   std::vector<nebula::Step> >::serializedSize<false>(*proto,
-                                                                                      obj->steps);
+                                   std::vector<nebula::Step>>::serializedSize<false>(*proto,
+                                                                                     obj->steps);
 
   xfer += proto->serializedSizeStop();
   return xfer;
diff --git a/src/common/datatypes/SetOps-inl.h b/src/common/datatypes/SetOps-inl.h
index 5fd138c5830..69fdc694bfe 100644
--- a/src/common/datatypes/SetOps-inl.h
+++ b/src/common/datatypes/SetOps-inl.h
@@ -46,7 +46,7 @@ uint32_t Cpp2Ops<nebula::Set>::write(Protocol* proto, nebula::Set const* obj) {
   xfer += proto->writeFieldBegin("values", apache::thrift::protocol::T_SET, 1);
   xfer +=
       detail::pm::protocol_methods<type_class::set<type_class::structure>,
-                                   std::unordered_set<nebula::Value> >::write(*proto, obj->values);
+                                   std::unordered_set<nebula::Value>>::write(*proto, obj->values);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -69,7 +69,7 @@ void Cpp2Ops<nebula::Set>::read(Protocol* proto, nebula::Set* obj) {
 _readField_values : {
   obj->values = std::unordered_set<nebula::Value>();
   detail::pm::protocol_methods<type_class::set<type_class::structure>,
-                               std::unordered_set<nebula::Value> >::read(*proto, obj->values);
+                               std::unordered_set<nebula::Value>>::read(*proto, obj->values);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 1, 0, protocol::T_STOP))) {
@@ -116,7 +116,7 @@ uint32_t Cpp2Ops<nebula::Set>::serializedSize(Protocol const* proto, nebula::Set
   xfer += proto->serializedFieldSize("values", apache::thrift::protocol::T_SET, 1);
   xfer += detail::pm::protocol_methods<
       type_class::set<type_class::structure>,
-      std::unordered_set<nebula::Value> >::serializedSize<false>(*proto, obj->values);
+      std::unordered_set<nebula::Value>>::serializedSize<false>(*proto, obj->values);
   xfer += proto->serializedSizeStop();
   return xfer;
 }
@@ -128,7 +128,7 @@ uint32_t Cpp2Ops<nebula::Set>::serializedSizeZC(Protocol const* proto, nebula::S
   xfer += proto->serializedFieldSize("values", apache::thrift::protocol::T_SET, 1);
   xfer += detail::pm::protocol_methods<
       type_class::set<type_class::structure>,
-      std::unordered_set<nebula::Value> >::serializedSize<false>(*proto, obj->values);
+      std::unordered_set<nebula::Value>>::serializedSize<false>(*proto, obj->values);
   xfer += proto->serializedSizeStop();
   return xfer;
 }
diff --git a/src/common/datatypes/VertexOps-inl.h b/src/common/datatypes/VertexOps-inl.h
index e2a6eed3fd0..79599f50c2d 100644
--- a/src/common/datatypes/VertexOps-inl.h
+++ b/src/common/datatypes/VertexOps-inl.h
@@ -58,7 +58,7 @@ uint32_t Cpp2Ops<nebula::Tag>::write(Protocol* proto, nebula::Tag const* obj) {
   xfer += proto->writeFieldBegin("props", apache::thrift::protocol::T_MAP, 2);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::write(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::write(*proto, obj->props);
   xfer += proto->writeFieldEnd();
 
   xfer += proto->writeFieldStop();
@@ -87,8 +87,8 @@ _readField_name : { proto->readBinary(obj->name); }
 _readField_props : {
   obj->props = std::unordered_map<std::string, nebula::Value>();
   detail::pm::protocol_methods<type_class::map<type_class::binary, type_class::structure>,
-                               std::unordered_map<std::string, nebula::Value> >::read(*proto,
-                                                                                      obj->props);
+                               std::unordered_map<std::string, nebula::Value>>::read(*proto,
+                                                                                     obj->props);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 2, 0, protocol::T_STOP))) {
@@ -146,7 +146,7 @@ uint32_t Cpp2Ops<nebula::Tag>::serializedSize(Protocol const* proto, nebula::Tag
   xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 2);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->props);
 
   xfer += proto->serializedSizeStop();
   return xfer;
@@ -163,7 +163,7 @@ uint32_t Cpp2Ops<nebula::Tag>::serializedSizeZC(Protocol const* proto, nebula::T
   xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 2);
   xfer += detail::pm::protocol_methods<
       type_class::map<type_class::binary, type_class::structure>,
-      std::unordered_map<std::string, nebula::Value> >::serializedSize<false>(*proto, obj->props);
+      std::unordered_map<std::string, nebula::Value>>::serializedSize<false>(*proto, obj->props);
 
   xfer += proto->serializedSizeStop();
   return xfer;
@@ -206,7 +206,7 @@ uint32_t Cpp2Ops<nebula::Vertex>::write(Protocol* proto, nebula::Vertex const* o
   xfer += proto->writeFieldEnd();
   xfer += proto->writeFieldBegin("tags", apache::thrift::protocol::T_LIST, 2);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Tag> >::write(*proto, obj->tags);
+                                       std::vector<nebula::Tag>>::write(*proto, obj->tags);
   xfer += proto->writeFieldEnd();
   xfer += proto->writeFieldStop();
   xfer += proto->writeStructEnd();
@@ -234,7 +234,7 @@ _readField_vid : { ::apache::thrift::Cpp2Ops<nebula::Value>::read(proto, &obj->v
 _readField_tags : {
   obj->tags = std::vector<nebula::Tag>();
   detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                               std::vector<nebula::Tag> >::read(*proto, obj->tags);
+                               std::vector<nebula::Tag>>::read(*proto, obj->tags);
 }
 
   if (UNLIKELY(!readState.advanceToNextField(proto, 2, 0, protocol::T_STOP))) {
@@ -289,8 +289,8 @@ uint32_t Cpp2Ops<nebula::Vertex>::serializedSize(Protocol const* proto, nebula::
   xfer += ::apache::thrift::Cpp2Ops<nebula::Value>::serializedSize(proto, &obj->vid);
   xfer += proto->serializedFieldSize("tags", apache::thrift::protocol::T_LIST, 2);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Tag> >::serializedSize<false>(*proto,
-                                                                                         obj->tags);
+                                       std::vector<nebula::Tag>>::serializedSize<false>(*proto,
+                                                                                        obj->tags);
   xfer += proto->serializedSizeStop();
   return xfer;
 }
@@ -304,8 +304,8 @@ uint32_t Cpp2Ops<nebula::Vertex>::serializedSizeZC(Protocol const* proto,
   xfer += ::apache::thrift::Cpp2Ops<nebula::Value>::serializedSizeZC(proto, &obj->vid);
   xfer += proto->serializedFieldSize("tags", apache::thrift::protocol::T_LIST, 2);
   xfer += detail::pm::protocol_methods<type_class::list<type_class::structure>,
-                                       std::vector<nebula::Tag> >::serializedSize<false>(*proto,
-                                                                                         obj->tags);
+                                       std::vector<nebula::Tag>>::serializedSize<false>(*proto,
+                                                                                        obj->tags);
   xfer += proto->serializedSizeStop();
   return xfer;
 }
diff --git a/src/common/thrift/ThriftClientManager.h b/src/common/thrift/ThriftClientManager.h
index 8c70b0352ce..04800dab4bd 100644
--- a/src/common/thrift/ThriftClientManager.h
+++ b/src/common/thrift/ThriftClientManager.h
@@ -32,7 +32,7 @@ class ThriftClientManager final {
 
  private:
   using ClientMap =
-      std::unordered_map<std::pair<HostAddr, folly::EventBase*>, std::shared_ptr<ClientType> >;
+      std::unordered_map<std::pair<HostAddr, folly::EventBase*>, std::shared_ptr<ClientType>>;
 
   folly::ThreadLocal<ClientMap> clientMap_;
   // whether enable ssl
diff --git a/src/graph/service/GraphService.cpp b/src/graph/service/GraphService.cpp
index 4fd914040fc..4d8141ed8c6 100644
--- a/src/graph/service/GraphService.cpp
+++ b/src/graph/service/GraphService.cpp
@@ -41,13 +41,16 @@ Status GraphService::init(std::shared_ptr<folly::IOThreadPoolExecutor> ioExecuto
   bool loadDataOk = metaClient_->waitForMetadReady(3);
   if (!loadDataOk) {
     // Resort to retrying in the background
-    LOG(WARNING) << "Failed to wait for meta service ready synchronously.";
+    LOG(ERROR) << "Failed to wait for meta service ready synchronously.";
+    return Status::Error("Failed to wait for meta service ready synchronously.");
   }
 
   sessionManager_ = std::make_unique<GraphSessionManager>(metaClient_.get(), hostAddr);
   auto initSessionMgrStatus = sessionManager_->init();
   if (!initSessionMgrStatus.ok()) {
-    LOG(WARNING) << "Failed to initialize session manager: " << initSessionMgrStatus.toString();
+    LOG(ERROR) << "Failed to initialize session manager: " << initSessionMgrStatus.toString();
+    return Status::Error("Failed to initialize session manager: %s",
+                         initSessionMgrStatus.toString().c_str());
   }
 
   queryEngine_ = std::make_unique<QueryEngine>();
diff --git a/src/meta/processors/parts/ListHostsProcessor.cpp b/src/meta/processors/parts/ListHostsProcessor.cpp
index ff4c7547468..cea7e8b7d66 100644
--- a/src/meta/processors/parts/ListHostsProcessor.cpp
+++ b/src/meta/processors/parts/ListHostsProcessor.cpp
@@ -90,7 +90,7 @@ nebula::cpp2::ErrorCode ListHostsProcessor::allMetaHostsStatus() {
     item.set_role(cpp2::HostRole::META);
     item.set_git_info_sha(gitInfoSha());
     item.set_status(cpp2::HostStatus::ONLINE);
-    item.set_version(versionString(false));
+    item.set_version(getOriginVersion());
     hostItems_.emplace_back(item);
   }
   return nebula::cpp2::ErrorCode::SUCCEEDED;
@@ -111,13 +111,11 @@ nebula::cpp2::ErrorCode ListHostsProcessor::allHostsWithStatus(cpp2::HostRole ro
     return retCode;
   }
 
-  auto iter = nebula::value(ret).get();
   auto now = time::WallClock::fastNowInMilliSec();
   std::vector<std::string> removeHostsKey;
-  while (iter->valid()) {
+  for (auto iter = nebula::value(ret).get(); iter->valid(); iter->next()) {
     HostInfo info = HostInfo::decode(iter->val());
     if (info.role_ != role) {
-      iter->next();
       continue;
     }
 
@@ -143,7 +141,6 @@ nebula::cpp2::ErrorCode ListHostsProcessor::allHostsWithStatus(cpp2::HostRole ro
     } else {
       removeHostsKey.emplace_back(iter->key());
     }
-    iter->next();
   }
 
   removeExpiredHosts(std::move(removeHostsKey));
diff --git a/src/version/Version.cpp.in b/src/version/Version.cpp.in
index f8675b605e0..c23cd34fc8e 100644
--- a/src/version/Version.cpp.in
+++ b/src/version/Version.cpp.in
@@ -15,10 +15,10 @@ namespace nebula {
 std::string gitInfoSha() { return "@GIT_INFO_SHA@"; }
 
 std::string versionString(bool verbose) {
-  std::string version;
-#if defined(NEBULA_BUILD_VERSION)
-  version = folly::stringPrintf("%s, ", "@NEBULA_BUILD_VERSION@");
-#endif
+  std::string version = getOriginVersion();
+  if (!version.empty()) {
+    version += ", ";
+  }
   if (verbose) {
     version += folly::sformat("Git: {}, ", gitInfoSha());
   }