diff --git a/include/common/trow.h b/include/common/trow.h
index 6a71a8844ed54baa45836d16f2c3ccf9b114cc0a..8332c10ed278936ca77453e485d8dbb3147b4850 100644
--- a/include/common/trow.h
+++ b/include/common/trow.h
@@ -20,7 +20,6 @@
 #include "talgo.h"
 #include "taosdef.h"
 #include "taoserror.h"
-#include "tbuffer.h"
 #include "tdataformat.h"
 #include "tdef.h"
 #include "ttypes.h"
diff --git a/include/libs/function/function.h b/include/libs/function/function.h
index a58aed7e509f1e55bc7988385e28ce3251232baa..32db6773e07ce61ad1ef100713b3bb696a36f09d 100644
--- a/include/libs/function/function.h
+++ b/include/libs/function/function.h
@@ -20,7 +20,6 @@
 extern "C" {
 #endif
 
-#include "tbuffer.h"
 #include "tcommon.h"
 #include "tvariant.h"
 
diff --git a/include/util/tbuffer.h b/include/util/tbuffer.h
deleted file mode 100644
index 2ed1b7326bdb27ffe182b30d67a9369680898d23..0000000000000000000000000000000000000000
--- a/include/util/tbuffer.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Copyright (c) 2020 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_UTIL_BUFFER_H_
-#define _TD_UTIL_BUFFER_H_
-
-#include "os.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// usage example
-/*
-#include <stdio.h>
-#include "texception.h"
-
-int32_t main( int32_t argc, char** argv ) {
-  SBufferWriter bw = tbufInitWriter( NULL, false );
-
-  TRY( 1 ) {
-    //--------------------- write ------------------------
-    // reserve 1024 bytes for the buffer to improve performance
-    tbufEnsureCapacity( &bw, 1024 );
-
-    // reserve space for the interger count
-    size_t pos = tbufReserve( &bw, sizeof(int32_t) );
-    // write 5 integers to the buffer
-    for( int32_t i = 0; i < 5; i++) {
-      tbufWriteInt32( &bw, i );
-    }
-    // write the integer count to buffer at reserved position
-    tbufWriteInt32At( &bw, pos, 5 );
-
-    // write a string to the buffer
-    tbufWriteString( &bw, "this is a string.\n" );
-    // acquire the result and close the write buffer
-    size_t size = tbufTell( &bw );
-    char*  data = tbufGetData( &bw, false );
-
-    //------------------------ read -----------------------
-    SBufferReader br = tbufInitReader( data, size, false );
-    // read & print out all integers
-    int32_t count = tbufReadInt32( &br );
-    for( int32_t i = 0; i < count; i++ ) {
-      printf( "%d\n", tbufReadInt32(&br) );
-    }
-    // read & print out a string
-    puts( tbufReadString(&br, NULL) );
-    // try read another integer, this result in an error as there no this integer
-    tbufReadInt32( &br );
-    printf( "you should not see this message.\n" );
-  } CATCH( code ) {
-    printf( "exception code is: %d, you will see this message after print out 5 integers and a string.\n", code );
-  } END_TRY
-
-  tbufCloseWriter( &bw );
-  return 0;
-}
-*/
-
-typedef struct SBufferReader {
-  bool        endian;
-  const char* data;
-  size_t      pos;
-  size_t      size;
-} SBufferReader;
-
-typedef struct SBufferWriter {
-  bool   endian;
-  char*  data;
-  size_t pos;
-  size_t size;
-  void* (*allocator)(void*, size_t);
-} SBufferWriter;
-
-// common functions & macros for both reader & writer
-
-#define tbufTell(buf) ((buf)->pos)
-
-/* ------------------------ BUFFER WRITER FUNCTIONS AND MACROS ------------------------ */
-// *Allocator*, function to allocate memory, will use 'realloc' if NULL
-// *Endian*, if true, writer functions of primitive types will do 'hton' automatically
-#define tbufInitWriter(Allocator, Endian) \
-  { .endian = (Endian), .data = NULL, .pos = 0, .size = 0, .allocator = ((Allocator) == NULL ? realloc : (Allocator)) }
-
-void   tbufCloseWriter(SBufferWriter* buf);
-void   tbufEnsureCapacity(SBufferWriter* buf, size_t size);
-size_t tbufReserve(SBufferWriter* buf, size_t size);
-char*  tbufGetData(SBufferWriter* buf, bool takeOver);
-void   tbufWrite(SBufferWriter* buf, const void* data, size_t size);
-void   tbufWriteAt(SBufferWriter* buf, size_t pos, const void* data, size_t size);
-void   tbufWriteStringLen(SBufferWriter* buf, const char* str, size_t len);
-void   tbufWriteString(SBufferWriter* buf, const char* str);
-// the prototype of tbufWriteBinary and tbufWrite are identical
-// the difference is: tbufWriteBinary writes the length of the data to the buffer
-// first, then the actual data, which means the reader don't need to know data
-// size before read. Write only write the data itself, which means the reader
-// need to know data size before read.
-void tbufWriteBinary(SBufferWriter* buf, const void* data, size_t len);
-void tbufWriteBool(SBufferWriter* buf, bool data);
-void tbufWriteBoolAt(SBufferWriter* buf, size_t pos, bool data);
-void tbufWriteChar(SBufferWriter* buf, char data);
-void tbufWriteCharAt(SBufferWriter* buf, size_t pos, char data);
-void tbufWriteInt8(SBufferWriter* buf, int8_t data);
-void tbufWriteInt8At(SBufferWriter* buf, size_t pos, int8_t data);
-void tbufWriteUint8(SBufferWriter* buf, uint8_t data);
-void tbufWriteUint8At(SBufferWriter* buf, size_t pos, uint8_t data);
-void tbufWriteInt16(SBufferWriter* buf, int16_t data);
-void tbufWriteInt16At(SBufferWriter* buf, size_t pos, int16_t data);
-void tbufWriteUint16(SBufferWriter* buf, uint16_t data);
-void tbufWriteUint16At(SBufferWriter* buf, size_t pos, uint16_t data);
-void tbufWriteInt32(SBufferWriter* buf, int32_t data);
-void tbufWriteInt32At(SBufferWriter* buf, size_t pos, int32_t data);
-void tbufWriteUint32(SBufferWriter* buf, uint32_t data);
-void tbufWriteUint32At(SBufferWriter* buf, size_t pos, uint32_t data);
-void tbufWriteInt64(SBufferWriter* buf, int64_t data);
-void tbufWriteInt64At(SBufferWriter* buf, size_t pos, int64_t data);
-void tbufWriteUint64(SBufferWriter* buf, uint64_t data);
-void tbufWriteUint64At(SBufferWriter* buf, size_t pos, uint64_t data);
-void tbufWriteFloat(SBufferWriter* buf, float data);
-void tbufWriteFloatAt(SBufferWriter* buf, size_t pos, float data);
-void tbufWriteDouble(SBufferWriter* buf, double data);
-void tbufWriteDoubleAt(SBufferWriter* buf, size_t pos, double data);
-
-/* ------------------------ BUFFER READER FUNCTIONS AND MACROS ------------------------ */
-// *Endian*, if true, reader functions of primitive types will do 'ntoh' automatically
-#define tbufInitReader(Data, Size, Endian) \
-  { .endian = (Endian), .data = (Data), .pos = 0, .size = ((Data) == NULL ? 0 : (Size)) }
-
-size_t      tbufSkip(SBufferReader* buf, size_t size);
-const char* tbufRead(SBufferReader* buf, size_t size);
-void        tbufReadToBuffer(SBufferReader* buf, void* dst, size_t size);
-const char* tbufReadString(SBufferReader* buf, size_t* len);
-size_t      tbufReadToString(SBufferReader* buf, char* dst, size_t size);
-const char* tbufReadBinary(SBufferReader* buf, size_t* len);
-size_t      tbufReadToBinary(SBufferReader* buf, void* dst, size_t size);
-bool        tbufReadBool(SBufferReader* buf);
-char        tbufReadChar(SBufferReader* buf);
-int8_t      tbufReadInt8(SBufferReader* buf);
-uint8_t     tbufReadUint8(SBufferReader* buf);
-int16_t     tbufReadInt16(SBufferReader* buf);
-uint16_t    tbufReadUint16(SBufferReader* buf);
-int32_t     tbufReadInt32(SBufferReader* buf);
-uint32_t    tbufReadUint32(SBufferReader* buf);
-int64_t     tbufReadInt64(SBufferReader* buf);
-uint64_t    tbufReadUint64(SBufferReader* buf);
-float       tbufReadFloat(SBufferReader* buf);
-double      tbufReadDouble(SBufferReader* buf);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_UTIL_BUFFER_H_*/
diff --git a/source/dnode/mnode/impl/src/mndTelem.c b/source/dnode/mnode/impl/src/mndTelem.c
index 1d3209691adae6c917f430a2e6eb716951aefedf..b0b49b42dce114ffdf223f16eaad59abd822d700 100644
--- a/source/dnode/mnode/impl/src/mndTelem.c
+++ b/source/dnode/mnode/impl/src/mndTelem.c
@@ -17,7 +17,6 @@
 #include "mndTelem.h"
 #include "mndCluster.h"
 #include "mndSync.h"
-#include "tbuffer.h"
 #include "thttp.h"
 #include "tjson.h"
 
diff --git a/source/libs/executor/inc/executil.h b/source/libs/executor/inc/executil.h
index 51150ede3c6b31c1a75dd4dd1197a4fe4f7d20a1..4229e8808d061b030c4bf3f9813803ac5d4d86e9 100644
--- a/source/libs/executor/inc/executil.h
+++ b/source/libs/executor/inc/executil.h
@@ -18,7 +18,6 @@
 #include "function.h"
 #include "nodes.h"
 #include "plannodes.h"
-#include "tbuffer.h"
 #include "tcommon.h"
 #include "tpagedbuf.h"
 #include "tsimplehash.h"
diff --git a/source/libs/function/src/tfunctionInt.c b/source/libs/function/src/tfunctionInt.c
index 70378df0c3315c03989ae673ec50ecf1a47d8278..3afa0e5cdd402d43fa4a415468c4eda76a971e36 100644
--- a/source/libs/function/src/tfunctionInt.c
+++ b/source/libs/function/src/tfunctionInt.c
@@ -20,7 +20,6 @@
 #include "ttypes.h"
 
 #include "function.h"
-#include "tbuffer.h"
 #include "tcompression.h"
 #include "tdatablock.h"
 #include "tfunctionInt.h"
diff --git a/source/util/src/talgo.c b/source/util/src/talgo.c
index 057d3a620c714b22e0dea9643f672782c93424ed..d9319485b7c3bbed717c054f6d63f91ca2220063 100644
--- a/source/util/src/talgo.c
+++ b/source/util/src/talgo.c
@@ -39,7 +39,7 @@ static void median(void *src, int64_t size, int64_t s, int64_t e, const void *pa
     doswap(elePtrAt(src, size, s), elePtrAt(src, size, e), size, buf);
   }
 
-  assert(comparFn(elePtrAt(src, size, mid), elePtrAt(src, size, s), param) <= 0 &&
+  ASSERT(comparFn(elePtrAt(src, size, mid), elePtrAt(src, size, s), param) <= 0 &&
          comparFn(elePtrAt(src, size, s), elePtrAt(src, size, e), param) <= 0);
 
 #ifdef _DEBUG_VIEW
diff --git a/source/util/src/tbuffer.c b/source/util/src/tbuffer.c
deleted file mode 100644
index d2fac72c77dc55a1c9e7c087d1af8f78dc466409..0000000000000000000000000000000000000000
--- a/source/util/src/tbuffer.c
+++ /dev/null
@@ -1,424 +0,0 @@
-/*
- * Copyright (c) 2020 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#define _DEFAULT_SOURCE
-#include "tbuffer.h"
-#include "texception.h"
-
-typedef union Un4B {
-  uint32_t ui;
-  float    f;
-} Un4B;
-#if __STDC_VERSION__ >= 201112LL
-static_assert(sizeof(Un4B) == sizeof(uint32_t), "sizeof(Un4B) must equal to sizeof(uint32_t)");
-static_assert(sizeof(Un4B) == sizeof(float), "sizeof(Un4B) must equal to sizeof(float)");
-#endif
-
-typedef union Un8B {
-  uint64_t ull;
-  double   d;
-} Un8B;
-#if __STDC_VERSION__ >= 201112LL
-static_assert(sizeof(Un8B) == sizeof(uint64_t), "sizeof(Un8B) must equal to sizeof(uint64_t)");
-static_assert(sizeof(Un8B) == sizeof(double), "sizeof(Un8B) must equal to sizeof(double)");
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// reader functions
-
-size_t tbufSkip(SBufferReader* buf, size_t size) {
-  if ((buf->pos + size) > buf->size) {
-    THROW(-1);
-  }
-  size_t old = buf->pos;
-  buf->pos += size;
-  return old;
-}
-
-const char* tbufRead(SBufferReader* buf, size_t size) {
-  const char* ret = buf->data + buf->pos;
-  tbufSkip(buf, size);
-  return ret;
-}
-
-void tbufReadToBuffer(SBufferReader* buf, void* dst, size_t size) {
-  assert(dst != NULL);
-  // always using memcpy, leave optimization to compiler
-  memcpy(dst, tbufRead(buf, size), size);
-}
-
-static size_t tbufReadLength(SBufferReader* buf) {
-  // maximum length is 65535, if larger length is required
-  // this function and the corresponding write function need to be
-  // revised.
-  uint16_t l = tbufReadUint16(buf);
-  return l;
-}
-
-const char* tbufReadString(SBufferReader* buf, size_t* len) {
-  size_t      l = tbufReadLength(buf);
-  const char* ret = buf->data + buf->pos;
-  tbufSkip(buf, l + 1);
-  if (ret[l] != 0) {
-    THROW(-1);
-  }
-  if (len != NULL) {
-    *len = l;
-  }
-  return ret;
-}
-
-size_t tbufReadToString(SBufferReader* buf, char* dst, size_t size) {
-  assert(dst != NULL);
-  size_t      len;
-  const char* str = tbufReadString(buf, &len);
-  if (len >= size) {
-    len = size - 1;
-  }
-  memcpy(dst, str, len);
-  dst[len] = 0;
-  return len;
-}
-
-const char* tbufReadBinary(SBufferReader* buf, size_t* len) {
-  size_t      l = tbufReadLength(buf);
-  const char* ret = buf->data + buf->pos;
-  tbufSkip(buf, l);
-  if (len != NULL) {
-    *len = l;
-  }
-  return ret;
-}
-
-size_t tbufReadToBinary(SBufferReader* buf, void* dst, size_t size) {
-  assert(dst != NULL);
-  size_t      len;
-  const char* data = tbufReadBinary(buf, &len);
-  if (len >= size) {
-    len = size;
-  }
-  memcpy(dst, data, len);
-  return len;
-}
-
-bool tbufReadBool(SBufferReader* buf) {
-  bool ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  return ret;
-}
-
-char tbufReadChar(SBufferReader* buf) {
-  char ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  return ret;
-}
-
-int8_t tbufReadInt8(SBufferReader* buf) {
-  int8_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  return ret;
-}
-
-uint8_t tbufReadUint8(SBufferReader* buf) {
-  uint8_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  return ret;
-}
-
-int16_t tbufReadInt16(SBufferReader* buf) {
-  int16_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if (buf->endian) {
-    return (int16_t)ntohs(ret);
-  }
-  return ret;
-}
-
-uint16_t tbufReadUint16(SBufferReader* buf) {
-  uint16_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if (buf->endian) {
-    return ntohs(ret);
-  }
-  return ret;
-}
-
-int32_t tbufReadInt32(SBufferReader* buf) {
-  int32_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if (buf->endian) {
-    return (int32_t)ntohl(ret);
-  }
-  return ret;
-}
-
-uint32_t tbufReadUint32(SBufferReader* buf) {
-  uint32_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if (buf->endian) {
-    return ntohl(ret);
-  }
-  return ret;
-}
-
-int64_t tbufReadInt64(SBufferReader* buf) {
-  int64_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if (buf->endian) {
-    return (int64_t)htobe64(ret);  // TODO: ntohll
-  }
-  return ret;
-}
-
-uint64_t tbufReadUint64(SBufferReader* buf) {
-  uint64_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if (buf->endian) {
-    return htobe64(ret);  // TODO: ntohll
-  }
-  return ret;
-}
-
-float tbufReadFloat(SBufferReader* buf) {
-  Un4B _un;
-  tbufReadToBuffer(buf, &_un, sizeof(_un));
-  if (buf->endian) {
-    _un.ui = ntohl(_un.ui);
-  }
-  return _un.f;
-}
-
-double tbufReadDouble(SBufferReader* buf) {
-  Un8B _un;
-  tbufReadToBuffer(buf, &_un, sizeof(_un));
-  if (buf->endian) {
-    _un.ull = htobe64(_un.ull);
-  }
-  return _un.d;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// writer functions
-
-void tbufCloseWriter(SBufferWriter* buf) {
-  taosMemoryFreeClear(buf->data);
-  //  (*buf->allocator)( buf->data, 0 );  // potential memory leak.
-  buf->data = NULL;
-  buf->pos = 0;
-  buf->size = 0;
-}
-
-void tbufEnsureCapacity(SBufferWriter* buf, size_t size) {
-  size += buf->pos;
-  if (size > buf->size) {
-    size_t nsize = size + buf->size;
-    char*  data = (*buf->allocator)(buf->data, nsize);
-    // TODO: the exception should be thrown by the allocator function
-    if (data == NULL) {
-      THROW(-1);
-    }
-    buf->data = data;
-    buf->size = nsize;
-  }
-}
-
-size_t tbufReserve(SBufferWriter* buf, size_t size) {
-  tbufEnsureCapacity(buf, size);
-  size_t old = buf->pos;
-  buf->pos += size;
-  return old;
-}
-
-char* tbufGetData(SBufferWriter* buf, bool takeOver) {
-  char* ret = buf->data;
-  if (takeOver) {
-    buf->pos = 0;
-    buf->size = 0;
-    buf->data = NULL;
-  }
-  return ret;
-}
-
-void tbufWrite(SBufferWriter* buf, const void* data, size_t size) {
-  assert(data != NULL);
-  tbufEnsureCapacity(buf, size);
-  memcpy(buf->data + buf->pos, data, size);
-  buf->pos += size;
-}
-
-void tbufWriteAt(SBufferWriter* buf, size_t pos, const void* data, size_t size) {
-  assert(data != NULL);
-  // this function can only be called to fill the gap on previous writes,
-  // so 'pos + size <= buf->pos' must be true
-  assert(pos + size <= buf->pos);
-  memcpy(buf->data + pos, data, size);
-}
-
-static void tbufWriteLength(SBufferWriter* buf, size_t len) {
-  // maximum length is 65535, if larger length is required
-  // this function and the corresponding read function need to be
-  // revised.
-  assert(len <= 0xffff);
-  tbufWriteUint16(buf, (uint16_t)len);
-}
-
-void tbufWriteStringLen(SBufferWriter* buf, const char* str, size_t len) {
-  tbufWriteLength(buf, len);
-  tbufWrite(buf, str, len);
-  tbufWriteChar(buf, '\0');
-}
-
-void tbufWriteString(SBufferWriter* buf, const char* str) { tbufWriteStringLen(buf, str, strlen(str)); }
-
-void tbufWriteBinary(SBufferWriter* buf, const void* data, size_t len) {
-  tbufWriteLength(buf, len);
-  tbufWrite(buf, data, len);
-}
-
-void tbufWriteBool(SBufferWriter* buf, bool data) { tbufWrite(buf, &data, sizeof(data)); }
-
-void tbufWriteBoolAt(SBufferWriter* buf, size_t pos, bool data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
-
-void tbufWriteChar(SBufferWriter* buf, char data) { tbufWrite(buf, &data, sizeof(data)); }
-
-void tbufWriteCharAt(SBufferWriter* buf, size_t pos, char data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
-
-void tbufWriteInt8(SBufferWriter* buf, int8_t data) { tbufWrite(buf, &data, sizeof(data)); }
-
-void tbufWriteInt8At(SBufferWriter* buf, size_t pos, int8_t data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
-
-void tbufWriteUint8(SBufferWriter* buf, uint8_t data) { tbufWrite(buf, &data, sizeof(data)); }
-
-void tbufWriteUint8At(SBufferWriter* buf, size_t pos, uint8_t data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
-
-void tbufWriteInt16(SBufferWriter* buf, int16_t data) {
-  if (buf->endian) {
-    data = (int16_t)htons(data);
-  }
-  tbufWrite(buf, &data, sizeof(data));
-}
-
-void tbufWriteInt16At(SBufferWriter* buf, size_t pos, int16_t data) {
-  if (buf->endian) {
-    data = (int16_t)htons(data);
-  }
-  tbufWriteAt(buf, pos, &data, sizeof(data));
-}
-
-void tbufWriteUint16(SBufferWriter* buf, uint16_t data) {
-  if (buf->endian) {
-    data = htons(data);
-  }
-  tbufWrite(buf, &data, sizeof(data));
-}
-
-void tbufWriteUint16At(SBufferWriter* buf, size_t pos, uint16_t data) {
-  if (buf->endian) {
-    data = htons(data);
-  }
-  tbufWriteAt(buf, pos, &data, sizeof(data));
-}
-
-void tbufWriteInt32(SBufferWriter* buf, int32_t data) {
-  if (buf->endian) {
-    data = (int32_t)htonl(data);
-  }
-  tbufWrite(buf, &data, sizeof(data));
-}
-
-void tbufWriteInt32At(SBufferWriter* buf, size_t pos, int32_t data) {
-  if (buf->endian) {
-    data = (int32_t)htonl(data);
-  }
-  tbufWriteAt(buf, pos, &data, sizeof(data));
-}
-
-void tbufWriteUint32(SBufferWriter* buf, uint32_t data) {
-  if (buf->endian) {
-    data = htonl(data);
-  }
-  tbufWrite(buf, &data, sizeof(data));
-}
-
-void tbufWriteUint32At(SBufferWriter* buf, size_t pos, uint32_t data) {
-  if (buf->endian) {
-    data = htonl(data);
-  }
-  tbufWriteAt(buf, pos, &data, sizeof(data));
-}
-
-void tbufWriteInt64(SBufferWriter* buf, int64_t data) {
-  if (buf->endian) {
-    data = (int64_t)htobe64(data);
-  }
-  tbufWrite(buf, &data, sizeof(data));
-}
-
-void tbufWriteInt64At(SBufferWriter* buf, size_t pos, int64_t data) {
-  if (buf->endian) {
-    data = (int64_t)htobe64(data);
-  }
-  tbufWriteAt(buf, pos, &data, sizeof(data));
-}
-
-void tbufWriteUint64(SBufferWriter* buf, uint64_t data) {
-  if (buf->endian) {
-    data = htobe64(data);
-  }
-  tbufWrite(buf, &data, sizeof(data));
-}
-
-void tbufWriteUint64At(SBufferWriter* buf, size_t pos, uint64_t data) {
-  if (buf->endian) {
-    data = htobe64(data);
-  }
-  tbufWriteAt(buf, pos, &data, sizeof(data));
-}
-
-void tbufWriteFloat(SBufferWriter* buf, float data) {
-  Un4B _un;
-  _un.f = data;
-  if (buf->endian) {
-    _un.ui = htonl(_un.ui);
-  }
-  tbufWrite(buf, &_un, sizeof(_un));
-}
-
-void tbufWriteFloatAt(SBufferWriter* buf, size_t pos, float data) {
-  Un4B _un;
-  _un.f = data;
-  if (buf->endian) {
-    _un.ui = htonl(_un.ui);
-  }
-  tbufWriteAt(buf, pos, &_un, sizeof(_un));
-}
-
-void tbufWriteDouble(SBufferWriter* buf, double data) {
-  Un8B _un;
-  _un.d = data;
-  if (buf->endian) {
-    _un.ull = htobe64(_un.ull);
-  }
-  tbufWrite(buf, &_un, sizeof(_un));
-}
-
-void tbufWriteDoubleAt(SBufferWriter* buf, size_t pos, double data) {
-  Un8B _un;
-  _un.d = data;
-  if (buf->endian) {
-    _un.ull = htobe64(_un.ull);
-  }
-  tbufWriteAt(buf, pos, &_un, sizeof(_un));
-}
diff --git a/source/util/src/tcompare.c b/source/util/src/tcompare.c
index ca8b64fe1e7a9b8528fa15252d5f154ddc1f1f31..381ef118041c864845dd5dee8eadfcaeedd7fd68 100644
--- a/source/util/src/tcompare.c
+++ b/source/util/src/tcompare.c
@@ -244,7 +244,7 @@ int32_t compareJsonVal(const void *pLeft, const void *pRight) {
   } else if (leftType == TSDB_DATA_TYPE_NULL) {
     return 0;
   } else {
-    assert(0);
+    ASSERTS(0, "data type unexpected");
     return 0;
   }
 }
@@ -1285,7 +1285,7 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
       case TSDB_DATA_TYPE_TIMESTAMP:
         return setChkInBytes8;
       default:
-        assert(0);
+        ASSERTS(0, "data type unexpected");
     }
   }
 
@@ -1308,7 +1308,7 @@ __compar_fn_t getComparFunc(int32_t type, int32_t optr) {
       case TSDB_DATA_TYPE_TIMESTAMP:
         return setChkNotInBytes8;
       default:
-        assert(0);
+        ASSERTS(0, "data type unexpected");
     }
   }
 
diff --git a/source/util/src/tcompression.c b/source/util/src/tcompression.c
index 18305e594b7942019c955523109941b05779618c..edc99dbd93d9cf1d3b4a1bebc059f53d436c02cc 100644
--- a/source/util/src/tcompression.c
+++ b/source/util/src/tcompression.c
@@ -470,7 +470,7 @@ int32_t tsDecompressStringImp(const char *const input, int32_t compressedSize, c
 // TODO: Take care here, we assumes little endian encoding.
 int32_t tsCompressTimestampImp(const char *const input, const int32_t nelements, char *const output) {
   int32_t _pos = 1;
-  assert(nelements >= 0);
+  ASSERTS(nelements >= 0, "nelements is negative");
 
   if (nelements == 0) return 0;
 
@@ -565,7 +565,7 @@ _exit_over:
 }
 
 int32_t tsDecompressTimestampImp(const char *const input, const int32_t nelements, char *const output) {
-  assert(nelements >= 0);
+  ASSERTS(nelements >= 0, "nelements is negative");
   if (nelements == 0) return 0;
 
   if (input[0] == 0) {
@@ -629,7 +629,7 @@ int32_t tsDecompressTimestampImp(const char *const input, const int32_t nelement
     }
 
   } else {
-    assert(0);
+    ASSERT(0);
     return -1;
   }
 }
@@ -2146,7 +2146,7 @@ int32_t tsCompressTimestamp(void *pIn, int32_t nIn, int32_t nEle, void *pOut, in
     int32_t len = tsCompressTimestampImp(pIn, nEle, pBuf);
     return tsCompressStringImp(pBuf, len, pOut, nOut);
   } else {
-    assert(0);
+    ASSERTS(0, "compress algo not one or two stage");
     return -1;
   }
 }
@@ -2159,7 +2159,7 @@ int32_t tsDecompressTimestamp(void *pIn, int32_t nIn, int32_t nEle, void *pOut,
     if (tsDecompressStringImp(pIn, nIn, pBuf, nBuf) < 0) return -1;
     return tsDecompressTimestampImp(pBuf, nEle, pOut);
   } else {
-    assert(0);
+    ASSERTS(0, "compress algo invalid");
     return -1;
   }
 }
@@ -2180,7 +2180,7 @@ int32_t tsCompressFloat(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int32_
       int32_t len = tsCompressFloatImp(pIn, nEle, pBuf);
       return tsCompressStringImp(pBuf, len, pOut, nOut);
     } else {
-      assert(0);
+      ASSERTS(0, "compress algo invalid");
       return -1;
     }
 #ifdef TD_TSZ
@@ -2203,7 +2203,7 @@ int32_t tsDecompressFloat(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int3
       if (tsDecompressStringImp(pIn, nIn, pBuf, nBuf) < 0) return -1;
       return tsDecompressFloatImp(pBuf, nEle, pOut);
     } else {
-      assert(0);
+      ASSERTS(0, "compress algo invalid");
       return -1;
     }
 #ifdef TD_TSZ
@@ -2227,7 +2227,7 @@ int32_t tsCompressDouble(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int32
       int32_t len = tsCompressDoubleImp(pIn, nEle, pBuf);
       return tsCompressStringImp(pBuf, len, pOut, nOut);
     } else {
-      assert(0);
+      ASSERTS(0, "compress algo invalid");
       return -1;
     }
 #ifdef TD_TSZ
@@ -2250,7 +2250,7 @@ int32_t tsDecompressDouble(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int
       if (tsDecompressStringImp(pIn, nIn, pBuf, nBuf) < 0) return -1;
       return tsDecompressDoubleImp(pBuf, nEle, pOut);
     } else {
-      assert(0);
+      ASSERTS(0, "compress algo invalid");
       return -1;
     }
 #ifdef TD_TSZ
@@ -2281,7 +2281,7 @@ int32_t tsCompressBool(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int32_t
     }
     return tsCompressStringImp(pBuf, len, pOut, nOut);
   } else {
-    assert(0);
+    ASSERTS(0, "compress algo invalid");
     return -1;
   }
 }
@@ -2294,7 +2294,7 @@ int32_t tsDecompressBool(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int32
     if (tsDecompressStringImp(pIn, nIn, pBuf, nBuf) < 0) return -1;
     return tsDecompressBoolImp(pBuf, nEle, pOut);
   } else {
-    assert(0);
+    ASSERTS(0, "compress algo invalid");
     return -1;
   }
 }
@@ -2308,7 +2308,7 @@ int32_t tsCompressTinyint(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int3
     int32_t len = tsCompressINTImp(pIn, nEle, pBuf, TSDB_DATA_TYPE_TINYINT);
     return tsCompressStringImp(pBuf, len, pOut, nOut);
   } else {
-    assert(0);
+    ASSERTS(0, "compress algo invalid");
     return -1;
   }
 }
@@ -2321,7 +2321,7 @@ int32_t tsDecompressTinyint(void *pIn, int32_t nIn, int32_t nEle, void *pOut, in
     if (tsDecompressStringImp(pIn, nIn, pBuf, nBuf) < 0) return -1;
     return tsDecompressINTImp(pBuf, nEle, pOut, TSDB_DATA_TYPE_TINYINT);
   } else {
-    assert(0);
+    ASSERTS(0, "compress algo invalid");
     return -1;
   }
 }
@@ -2335,7 +2335,7 @@ int32_t tsCompressSmallint(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int
     int32_t len = tsCompressINTImp(pIn, nEle, pBuf, TSDB_DATA_TYPE_SMALLINT);
     return tsCompressStringImp(pBuf, len, pOut, nOut);
   } else {
-    assert(0);
+    ASSERTS(0, "compress algo invalid");
     return -1;
   }
 }
@@ -2348,7 +2348,7 @@ int32_t tsDecompressSmallint(void *pIn, int32_t nIn, int32_t nEle, void *pOut, i
     if (tsDecompressStringImp(pIn, nIn, pBuf, nBuf) < 0) return -1;
     return tsDecompressINTImp(pBuf, nEle, pOut, TSDB_DATA_TYPE_SMALLINT);
   } else {
-    assert(0);
+    ASSERTS(0, "compress algo invalid");
     return -1;
   }
 }
@@ -2362,7 +2362,7 @@ int32_t tsCompressInt(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int32_t
     int32_t len = tsCompressINTImp(pIn, nEle, pBuf, TSDB_DATA_TYPE_INT);
     return tsCompressStringImp(pBuf, len, pOut, nOut);
   } else {
-    assert(0);
+    ASSERTS(0, "compress algo invalid");
     return -1;
   }
 }
@@ -2375,7 +2375,7 @@ int32_t tsDecompressInt(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int32_
     if (tsDecompressStringImp(pIn, nIn, pBuf, nBuf) < 0) return -1;
     return tsDecompressINTImp(pBuf, nEle, pOut, TSDB_DATA_TYPE_INT);
   } else {
-    assert(0);
+    ASSERTS(0, "compress algo invalid");
     return -1;
   }
 }
@@ -2389,7 +2389,7 @@ int32_t tsCompressBigint(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int32
     int32_t len = tsCompressINTImp(pIn, nEle, pBuf, TSDB_DATA_TYPE_BIGINT);
     return tsCompressStringImp(pBuf, len, pOut, nOut);
   } else {
-    assert(0);
+    ASSERTS(0, "compress algo invalid");
     return -1;
   }
 }
@@ -2402,7 +2402,7 @@ int32_t tsDecompressBigint(void *pIn, int32_t nIn, int32_t nEle, void *pOut, int
     if (tsDecompressStringImp(pIn, nIn, pBuf, nBuf) < 0) return -1;
     return tsDecompressINTImp(pBuf, nEle, pOut, TSDB_DATA_TYPE_BIGINT);
   } else {
-    assert(0);
+    ASSERTS(0, "compress algo invalid");
     return -1;
   }
 }
diff --git a/source/util/src/tdigest.c b/source/util/src/tdigest.c
index 337ee803ffbf4fa3a715251daa1c8b850b06e17d..b46a50b2dc03bcf1242eded9028424327121b612 100644
--- a/source/util/src/tdigest.c
+++ b/source/util/src/tdigest.c
@@ -27,6 +27,7 @@
 #include "tdigest.h"
 #include "os.h"
 #include "osMath.h"
+#include "tlog.h"
 
 #define INTERPOLATE(x, x0, x1) (((x) - (x0)) / ((x1) - (x0)))
 //#define INTEGRATED_LOCATION(compression, q)   ((compression) * (asin(2 * (q) - 1) + M_PI / 2) / M_PI)
@@ -135,24 +136,24 @@ void tdigestCompress(TDigest *t) {
 
     if (a->mean <= b->mean) {
       mergeCentroid(&args, a);
-      assert(args.idx < t->size);
+      ASSERTS(args.idx < t->size, "idx over size");
       i++;
     } else {
       mergeCentroid(&args, b);
-      assert(args.idx < t->size);
+      ASSERTS(args.idx < t->size, "idx over size");
       j++;
     }
   }
 
   while (i < num_unmerged) {
     mergeCentroid(&args, &unmerged_centroids[i++]);
-    assert(args.idx < t->size);
+    ASSERTS(args.idx < t->size, "idx over size");
   }
   taosMemoryFree((void *)unmerged_centroids);
 
   while (j < t->num_centroids) {
     mergeCentroid(&args, &t->centroids[j++]);
-    assert(args.idx < t->size);
+    ASSERTS(args.idx < t->size, "idx over size");
   }
 
   if (t->total_weight > 0) {
diff --git a/source/util/src/texception.c b/source/util/src/texception.c
index 33befb694a0a0a71c01042d9c9b5b19f7da12912..4723e349903505923de5790cdbca223a0d5073b5 100644
--- a/source/util/src/texception.c
+++ b/source/util/src/texception.c
@@ -15,6 +15,7 @@
 
 #define _DEFAULT_SOURCE
 #include "texception.h"
+#include "tlog.h"
 
 static threadlocal SExceptionNode* expList;
 
@@ -71,7 +72,7 @@ static wrapper wrappers[] = {
 };
 
 void cleanupPush_void_ptr_ptr(bool failOnly, void* func, void* arg1, void* arg2) {
-  assert(expList->numCleanupAction < expList->maxCleanupAction);
+  ASSERTS(expList->numCleanupAction < expList->maxCleanupAction, "numCleanupAction over maxCleanupAction");
 
   SCleanupAction* ca = expList->cleanupActions + expList->numCleanupAction++;
   ca->wrapper = 0;
@@ -82,7 +83,7 @@ void cleanupPush_void_ptr_ptr(bool failOnly, void* func, void* arg1, void* arg2)
 }
 
 void cleanupPush_void_ptr_bool(bool failOnly, void* func, void* arg1, bool arg2) {
-  assert(expList->numCleanupAction < expList->maxCleanupAction);
+  ASSERTS(expList->numCleanupAction < expList->maxCleanupAction, "numCleanupAction over maxCleanupAction");
 
   SCleanupAction* ca = expList->cleanupActions + expList->numCleanupAction++;
   ca->wrapper = 1;
@@ -93,7 +94,7 @@ void cleanupPush_void_ptr_bool(bool failOnly, void* func, void* arg1, bool arg2)
 }
 
 void cleanupPush_void_ptr(bool failOnly, void* func, void* arg) {
-  assert(expList->numCleanupAction < expList->maxCleanupAction);
+  ASSERTS(expList->numCleanupAction < expList->maxCleanupAction, "numCleanupAction over maxCleanupAction");
 
   SCleanupAction* ca = expList->cleanupActions + expList->numCleanupAction++;
   ca->wrapper = 2;
@@ -103,7 +104,7 @@ void cleanupPush_void_ptr(bool failOnly, void* func, void* arg) {
 }
 
 void cleanupPush_int_int(bool failOnly, void* func, int32_t arg) {
-  assert(expList->numCleanupAction < expList->maxCleanupAction);
+  ASSERTS(expList->numCleanupAction < expList->maxCleanupAction, "numCleanupAction over maxCleanupAction");
 
   SCleanupAction* ca = expList->cleanupActions + expList->numCleanupAction++;
   ca->wrapper = 3;
@@ -113,7 +114,7 @@ void cleanupPush_int_int(bool failOnly, void* func, int32_t arg) {
 }
 
 void cleanupPush_void(bool failOnly, void* func) {
-  assert(expList->numCleanupAction < expList->maxCleanupAction);
+  ASSERTS(expList->numCleanupAction < expList->maxCleanupAction, "numCleanupAction over maxCleanupAction");
 
   SCleanupAction* ca = expList->cleanupActions + expList->numCleanupAction++;
   ca->wrapper = 4;
@@ -122,7 +123,7 @@ void cleanupPush_void(bool failOnly, void* func) {
 }
 
 void cleanupPush_int_ptr(bool failOnly, void* func, void* arg) {
-  assert(expList->numCleanupAction < expList->maxCleanupAction);
+  ASSERTS(expList->numCleanupAction < expList->maxCleanupAction, "numCleanupAction over maxCleanupAction");
 
   SCleanupAction* ca = expList->cleanupActions + expList->numCleanupAction++;
   ca->wrapper = 5;
diff --git a/source/util/src/tlosertree.c b/source/util/src/tlosertree.c
index aeb9ce310b3a8802120fa58e52a3fc88a57b7eec..bf99212b78d4e75d3cbe3eb9823881168e03c129 100644
--- a/source/util/src/tlosertree.c
+++ b/source/util/src/tlosertree.c
@@ -20,7 +20,7 @@
 
 // Set the initial value of the multiway merge tree.
 static void tMergeTreeInit(SMultiwayMergeTreeInfo* pTree) {
-  assert((pTree->totalSources & 0x01) == 0 && (pTree->numOfSources << 1 == pTree->totalSources));
+  ASSERT((pTree->totalSources & 0x01) == 0 && (pTree->numOfSources << 1 == pTree->totalSources));
 
   for (int32_t i = 0; i < pTree->totalSources; ++i) {
     if (i < pTree->numOfSources) {
@@ -80,7 +80,7 @@ void tMergeTreeDestroy(SMultiwayMergeTreeInfo* pTree) {
 }
 
 void tMergeTreeAdjust(SMultiwayMergeTreeInfo* pTree, int32_t idx) {
-  assert(idx <= pTree->totalSources - 1 && idx >= pTree->numOfSources && pTree->totalSources >= 2);
+  ASSERT(idx <= pTree->totalSources - 1 && idx >= pTree->numOfSources && pTree->totalSources >= 2);
 
   if (pTree->totalSources == 2) {
     pTree->pNode[0].index = 0;
@@ -115,7 +115,7 @@ void tMergeTreeAdjust(SMultiwayMergeTreeInfo* pTree, int32_t idx) {
 }
 
 void tMergeTreeRebuild(SMultiwayMergeTreeInfo* pTree) {
-  assert((pTree->totalSources & 0x1) == 0);
+  ASSERT((pTree->totalSources & 0x1) == 0);
 
   tMergeTreeInit(pTree);
   for (int32_t i = pTree->totalSources - 1; i >= pTree->numOfSources; i--) {
diff --git a/source/util/src/tpagedbuf.c b/source/util/src/tpagedbuf.c
index ced5b4f25e3f86e2a360cf60d964b7566b8b94a3..87b44b2d1337ab157e4499f5165abf0868069bc5 100644
--- a/source/util/src/tpagedbuf.c
+++ b/source/util/src/tpagedbuf.c
@@ -125,20 +125,20 @@ static FORCE_INLINE size_t getAllocPageSize(int32_t pageSize) { return pageSize
  * @return
  */
 static char* doFlushPageToDisk(SDiskbasedBuf* pBuf, SPageInfo* pg) {
-  assert(!pg->used && pg->pData != NULL);
+  ASSERT(!pg->used && pg->pData != NULL);
 
   int32_t size = pBuf->pageSize;
   char*   t = NULL;
   if (pg->offset == -1 || pg->dirty) {
     void* payload = GET_DATA_PAYLOAD(pg);
     t = doCompressData(payload, pBuf->pageSize, &size, pBuf);
-    assert(size >= 0);
+    ASSERTS(size >= 0, "size is negative");
   }
 
   // this page is flushed to disk for the first time
   if (pg->dirty) {
     if (pg->offset == -1) {
-      assert(pg->dirty == true);
+      ASSERTS(pg->dirty == true, "pg->dirty is false");
 
       pg->offset = allocatePositionInFile(pBuf, size);
       pBuf->nextPos += size;
@@ -210,7 +210,7 @@ static char* doFlushPageToDisk(SDiskbasedBuf* pBuf, SPageInfo* pg) {
 
 static char* flushPageToDisk(SDiskbasedBuf* pBuf, SPageInfo* pg) {
   int32_t ret = TSDB_CODE_SUCCESS;
-  assert(((int64_t)pBuf->numOfPages * pBuf->pageSize) == pBuf->totalBufSize && pBuf->numOfPages >= pBuf->inMemPages);
+  ASSERT(((int64_t)pBuf->numOfPages * pBuf->pageSize) == pBuf->totalBufSize && pBuf->numOfPages >= pBuf->inMemPages);
 
   if (pBuf->pFile == NULL) {
     if ((ret = createDiskFile(pBuf)) != TSDB_CODE_SUCCESS) {
@@ -272,7 +272,7 @@ static SListNode* getEldestUnrefedPage(SDiskbasedBuf* pBuf) {
   SListNode* pn = NULL;
   while ((pn = tdListNext(&iter)) != NULL) {
     SPageInfo* pageInfo = *(SPageInfo**)pn->data;
-    assert(pageInfo->pageId >= 0 && pageInfo->pn == pn);
+    ASSERT(pageInfo->pageId >= 0 && pageInfo->pn == pn);
 
     if (!pageInfo->used) {
       //      printf("%d is chosen\n", pageInfo->pageId);
@@ -303,7 +303,7 @@ static char* evacOneDataPage(SDiskbasedBuf* pBuf) {
     tdListPopNode(pBuf->lruList, pn);
 
     SPageInfo* d = *(SPageInfo**)pn->data;
-    assert(d->pn == pn);
+    ASSERTS(d->pn == pn, "d->pn not equal pn");
 
     d->pn = NULL;
     taosMemoryFreeClear(pn);
@@ -353,7 +353,7 @@ int32_t createDiskbasedBuf(SDiskbasedBuf** pBuf, int32_t pagesize, int32_t inMem
   pPBuf->freePgList = tdListNew(POINTER_BYTES);
 
   // at least more than 2 pages must be in memory
-  assert(inMemBufSize >= pagesize * 2);
+  ASSERT(inMemBufSize >= pagesize * 2);
 
   pPBuf->lruList = tdListNew(POINTER_BYTES);
 
@@ -402,7 +402,7 @@ void* getNewBufPage(SDiskbasedBuf* pBuf, int32_t* pageId) {
   }
 
   // add to LRU list
-  assert(listNEles(pBuf->lruList) < pBuf->inMemPages && pBuf->inMemPages > 0);
+  ASSERT(listNEles(pBuf->lruList) < pBuf->inMemPages && pBuf->inMemPages > 0);
   lruListPushFront(pBuf->lruList, pi);
 
   // allocate buf
@@ -421,11 +421,11 @@ void* getNewBufPage(SDiskbasedBuf* pBuf, int32_t* pageId) {
 }
 
 void* getBufPage(SDiskbasedBuf* pBuf, int32_t id) {
-  assert(pBuf != NULL && id >= 0);
+  ASSERT(pBuf != NULL && id >= 0);
   pBuf->statis.getPages += 1;
 
   SPageInfo** pi = taosHashGet(pBuf->all, &id, sizeof(int32_t));
-  assert(pi != NULL && *pi != NULL);
+  ASSERT(pi != NULL && *pi != NULL);
 
   if ((*pi)->pData != NULL) {  // it is in memory
     // no need to update the LRU list if only one page exists
@@ -435,7 +435,7 @@ void* getBufPage(SDiskbasedBuf* pBuf, int32_t id) {
     }
 
     SPageInfo** pInfo = (SPageInfo**)((*pi)->pn->data);
-    assert(*pInfo == *pi);
+    ASSERT(*pInfo == *pi);
 
     lruListMoveToFront(pBuf->lruList, (*pi));
     (*pi)->used = true;
@@ -444,7 +444,7 @@ void* getBufPage(SDiskbasedBuf* pBuf, int32_t id) {
 #endif
     return (void*)(GET_DATA_PAYLOAD(*pi));
   } else {  // not in memory
-    assert((*pi)->pData == NULL && (*pi)->pn == NULL &&
+    ASSERT((*pi)->pData == NULL && (*pi)->pn == NULL &&
            (((*pi)->length >= 0 && (*pi)->offset >= 0) || ((*pi)->length == -1 && (*pi)->offset == -1)));
 
     char* availablePage = NULL;
@@ -482,7 +482,9 @@ void* getBufPage(SDiskbasedBuf* pBuf, int32_t id) {
 }
 
 void releaseBufPage(SDiskbasedBuf* pBuf, void* page) {
-  assert(pBuf != NULL && page != NULL);
+  if (ASSERTS(pBuf != NULL && page != NULL, "pBuf or page is NULL")) {
+    return;
+  }
   SPageInfo* ppi = getPageInfoFromPayload(page);
   releaseBufPageInfo(pBuf, ppi);
 }
@@ -491,8 +493,10 @@ void releaseBufPageInfo(SDiskbasedBuf* pBuf, SPageInfo* pi) {
 #ifdef BUF_PAGE_DEBUG
   uDebug("page_releaseBufPageInfo pageId:%d, used:%d, offset:%" PRId64, pi->pageId, pi->used, pi->offset);
 #endif
-  // assert(pi->pData != NULL && pi->used == true);
-  assert(pi->pData != NULL);
+  if (ASSERTS(pi->pData != NULL, "pi->pData is NULL")) {
+    return;
+  }
+
   pi->used = false;
   pBuf->statis.releasePages += 1;
 }
diff --git a/source/util/src/trbtree.c b/source/util/src/trbtree.c
index c6aea874704a9508c7a75568fc976226a07402e1..ffae5441aa088f2cc71710b301d5243cb3975235 100644
--- a/source/util/src/trbtree.c
+++ b/source/util/src/trbtree.c
@@ -14,6 +14,7 @@
  */
 
 #include "trbtree.h"
+#include "tlog.h"
 
 static void tRBTreeRotateLeft(SRBTree *pTree, SRBTreeNode *x) {
   SRBTreeNode *y = x->right;
@@ -258,7 +259,7 @@ static void rbtree_delete_fixup(rbtree_t *rbtree, rbnode_t *child, rbnode_t *chi
     child_parent->color = BLACK;
     return;
   }
-  assert(sibling != RBTREE_NULL);
+  ASSERTS(sibling != RBTREE_NULL, "sibling is NULL");
 
   /* get a new sibling, by rotating at sibling. See which child
      of sibling is red */
@@ -288,11 +289,11 @@ static void rbtree_delete_fixup(rbtree_t *rbtree, rbnode_t *child, rbnode_t *chi
   sibling->color = child_parent->color;
   child_parent->color = BLACK;
   if (child_parent->right == child) {
-    assert(sibling->left->color == RED);
+    ASSERTS(sibling->left->color == RED, "slibing->left->color=%d not equal RED", sibling->left->color);
     sibling->left->color = BLACK;
     rbtree_rotate_right(rbtree, child_parent);
   } else {
-    assert(sibling->right->color == RED);
+    ASSERTS(sibling->right->color == RED, "slibing->right->color=%d not equal RED", sibling->right->color);
     sibling->right->color = BLACK;
     rbtree_rotate_left(rbtree, child_parent);
   }
@@ -315,18 +316,18 @@ static void swap_np(rbnode_t **x, rbnode_t **y) {
 /** Update parent pointers of child trees of 'parent' */
 static void change_parent_ptr(rbtree_t *rbtree, rbnode_t *parent, rbnode_t *old, rbnode_t *new) {
   if (parent == RBTREE_NULL) {
-    assert(rbtree->root == old);
+    ASSERTS(rbtree->root == old, "root not equal old");
     if (rbtree->root == old) rbtree->root = new;
     return;
   }
-  assert(parent->left == old || parent->right == old || parent->left == new || parent->right == new);
+  ASSERT(parent->left == old || parent->right == old || parent->left == new || parent->right == new);
   if (parent->left == old) parent->left = new;
   if (parent->right == old) parent->right = new;
 }
 /** Update parent pointer of a node 'child' */
 static void change_child_ptr(rbtree_t *rbtree, rbnode_t *child, rbnode_t *old, rbnode_t *new) {
   if (child == RBTREE_NULL) return;
-  assert(child->parent == old || child->parent == new);
+  ASSERT(child->parent == old || child->parent == new);
   if (child->parent == old) child->parent = new;
 }
 
@@ -371,7 +372,7 @@ rbnode_t *rbtree_delete(rbtree_t *rbtree, void *key) {
 
     /* now delete to_delete (which is at the location where the smright previously was) */
   }
-  assert(to_delete->left == RBTREE_NULL || to_delete->right == RBTREE_NULL);
+  ASSERT(to_delete->left == RBTREE_NULL || to_delete->right == RBTREE_NULL);
 
   if (to_delete->left != RBTREE_NULL)
     child = to_delete->left;
diff --git a/source/util/src/tref.c b/source/util/src/tref.c
index 75a16b0ad706668edc1ad2567aa9393a06fc685d..e70e12b37b4366d60bbb87c3eee33fc08bcced73 100644
--- a/source/util/src/tref.c
+++ b/source/util/src/tref.c
@@ -466,7 +466,7 @@ static void taosLockList(int64_t *lockedBy) {
 static void taosUnlockList(int64_t *lockedBy) {
   int64_t tid = taosGetSelfPthreadId();
   if (atomic_val_compare_exchange_64(lockedBy, tid, 0) != tid) {
-    assert(false);
+    ASSERTS(false, "atomic_val_compare_exchange_64 tid failed");
   }
 }
 
diff --git a/source/util/src/ttimer.c b/source/util/src/ttimer.c
index 51d0a59d001b12cd64775cf43b20f83ee0f1a638..7e99d6a35cf2eafeb8205e768152b5fb0deb0bd7 100644
--- a/source/util/src/ttimer.c
+++ b/source/util/src/ttimer.c
@@ -159,8 +159,7 @@ static void lockTimerList(timer_list_t* list) {
 static void unlockTimerList(timer_list_t* list) {
   int64_t tid = taosGetSelfPthreadId();
   if (atomic_val_compare_exchange_64(&(list->lockedBy), tid, 0) != tid) {
-    assert(false);
-    tmrError("%" PRId64 " trying to unlock a timer list not locked by current thread.", tid);
+    ASSERTS(false, "%" PRId64 " trying to unlock a timer list not locked by current thread.", tid);
   }
 }
 
@@ -506,7 +505,7 @@ bool taosTmrReset(TAOS_TMR_CALLBACK fp, int32_t mseconds, void* param, void* han
     }
   }
 
-  assert(timer->refCount == 1);
+  ASSERTS(timer->refCount == 1, "timer refCount=%d not expected 1", timer->refCount);
   memset(timer, 0, sizeof(*timer));
   *pTmrId = (tmr_h)doStartTimer(timer, fp, mseconds, param, ctrl);
 
diff --git a/source/util/src/tutil.c b/source/util/src/tutil.c
index cf1d3be3a6401e034bec50ed12efd82a75eadb9d..e94f94a00dcdd3b625b9bf705bf19a5febae43a9 100644
--- a/source/util/src/tutil.c
+++ b/source/util/src/tutil.c
@@ -15,6 +15,7 @@
 
 #define _DEFAULT_SOURCE
 #include "tutil.h"
+#include "tlog.h"
 
 void *tmemmem(const char *haystack, int32_t hlen, const char *needle, int32_t nlen) {
   const char *limit;
@@ -117,7 +118,7 @@ char **strsplit(char *z, const char *delim, int32_t *num) {
     if ((*num) >= size) {
       size = (size << 1);
       split = taosMemoryRealloc(split, POINTER_BYTES * size);
-      assert(NULL != split);
+      ASSERTS(NULL != split, "realloc memory failed. size=%d", POINTER_BYTES * size);
     }
   }
 
@@ -158,7 +159,9 @@ char *strtolower(char *dst, const char *src) {
   int32_t esc = 0;
   char    quote = 0, *p = dst, c;
 
-  assert(dst != NULL);
+  if (ASSERTS(dst != NULL, "dst is NULL")) {
+    return NULL;
+  }
 
   for (c = *src++; c; c = *src++) {
     if (esc) {
@@ -185,7 +188,10 @@ char *strntolower(char *dst, const char *src, int32_t n) {
   int32_t esc = 0;
   char    quote = 0, *p = dst, c;
 
-  assert(dst != NULL);
+  if (ASSERTS(dst != NULL, "dst is NULL")) {
+    return NULL;
+  }
+  
   if (n == 0) {
     *p = 0;
     return dst;
@@ -214,7 +220,10 @@ char *strntolower(char *dst, const char *src, int32_t n) {
 char *strntolower_s(char *dst, const char *src, int32_t n) {
   char *p = dst, c;
 
-  assert(dst != NULL);
+  if (ASSERTS(dst != NULL, "dst is NULL")) {
+    return NULL;
+  }
+
   if (n == 0) {
     return NULL;
   }