Merge branch 'check_return_value' into 'master'

Check return value

See merge request tsg/dp_telemetry_app!14

10 files changed, 184 insertions, 139 deletions

diff --git a/etc/dp_trace_dy.conf b/etc/dp_trace_dy.conf
index 2989f1a..9e9240d 100644
--- a/etc/dp_trace_dy.conf
+++ b/etc/dp_trace_dy.conf
@@ -1,6 +1,6 @@
 [dp_trace_rule]
-dp_trace_file_max_size_in_KB=10
-dp_trace_merge_timeout=2
+dp_trace_file_max_size_in_KB=20
+dp_trace_merge_timeout=30
 
 [dp_trace_rule:0]
 enable=1
diff --git a/include/common.h b/include/common.h
index 93e0366..68c9989 100644
--- a/include/common.h
+++ b/include/common.h
@@ -24,12 +24,20 @@
 
 #define TELEMETRY_DIM(a) (sizeof(a) / sizeof((a)[0]))
 
+extern unsigned int zlog_env_is_init;
 #define DP_TRACE_VERIFY(condition, fmt, ...)                                                                           \
     do                                                                                                                 \
     {                                                                                                                  \
         if (!(condition))                                                                                              \
         {                                                                                                              \
-            dzlog_error(fmt, ##__VA_ARGS__);                                                                           \
+            if (zlog_env_is_init == 1)                                                                                 \
+            {                                                                                                          \
+                dzlog_error(fmt, ##__VA_ARGS__);                                                                       \
+            }                                                                                                          \
+            else                                                                                                       \
+            {                                                                                                          \
+                printf(fmt, ##__VA_ARGS__);                                                                            \
+            }                                                                                                          \
             exit(EXIT_FAILURE);                                                                                        \
         }                                                                                                              \
     } while (0)
@@ -40,7 +48,7 @@
 
 extern struct mr_instance * mr_instance;
 
-static bool is_directory_exists(const char * path)
+static inline bool is_directory_exists(const char * path)
 {
     struct stat info;
     if (stat(path, &info) != 0)
@@ -48,7 +56,42 @@ static bool is_directory_exists(const char * path)
     return S_ISDIR(info.st_mode) == 1;
 }
 
-static bool is_file_exists(const char * path)
+static inline bool is_file_exists(const char * path)
 {
     return access(path, F_OK) == 0;
+}
+
+// Combine relative paths and absolute paths into a new absolute path
+static inline char * paths_combine(const char * restrict prog_absolute_path, const char * restrict file_relative_path,
+                                   char * restrict resolve_path, size_t resolve_path_size)
+{
+    int prog_len = strlen(prog_absolute_path);
+    int file_len = strlen(file_relative_path);
+    if (prog_len + file_len + 1 > resolve_path_size)
+    {
+        return NULL;
+    }
+
+    if (file_relative_path[0] == '/')
+    {
+        strcpy(resolve_path, file_relative_path);
+        return resolve_path;
+    }
+
+    char combine_path[PATH_MAX];
+    strcpy(combine_path, prog_absolute_path);
+
+    char * last_slash = strrchr(combine_path, '/');
+    if (last_slash == NULL)
+    {
+        return NULL;
+    }
+    *last_slash = '\0';
+
+    strcat(combine_path, "/");
+    strcat(combine_path, file_relative_path);
+
+    realpath(combine_path, resolve_path);
+
+    return resolve_path;
 }
\ No newline at end of file
diff --git a/include/config.h b/include/config.h
index de8778d..594832a 100644
--- a/include/config.h
+++ b/include/config.h
@@ -42,6 +42,8 @@ struct config
     char dp_trace_dir[PATH_MAX];
     unsigned int dp_trace_file_max_size_in_KB;
     unsigned int dp_trace_merge_timeout;
+
+    unsigned int nr_desc;
     struct dp_trace_job_desc desc[DP_TRACE_JOB_NUM_MAX];
 };
 
diff --git a/src/config.c b/src/config.c
index b42335e..14f474f 100644
--- a/src/config.c
+++ b/src/config.c
@@ -14,9 +14,7 @@
 extern struct mr_instance * mr_instance;
 static struct config * g_conf = NULL;
 
-static void main_process_realpath_get(char * absolute_path, size_t size);
-static char * paths_combine(const char * restrict absolute_path, const char * restrict relative_path,
-                            char * restrict resolve_path);
+static void main_program_realpath_get(char * absolute_path, size_t size);
 
 const struct config * config_create(const char * config_path, const char * dy_config_path)
 {
@@ -25,7 +23,7 @@ const struct config * config_create(const char * config_path, const char * dy_co
 
     snprintf(conf->config_path, sizeof(conf->config_path), "%s", config_path);
     snprintf(conf->dy_config_path, sizeof(conf->dy_config_path), "%s", dy_config_path);
-    main_process_realpath_get(conf->absolute_path, sizeof(conf->absolute_path));
+    main_program_realpath_get(conf->absolute_path, sizeof(conf->absolute_path));
     printf("process absolute path %s\n", conf->absolute_path);
 
     g_conf = conf;
@@ -34,7 +32,7 @@ const struct config * config_create(const char * config_path, const char * dy_co
 
 const struct config * global_config_get()
 {
-    DP_TRACE_VERIFY(g_conf, "global config is null.");
+    assert(g_conf != NULL);
     return g_conf;
 }
 
@@ -65,7 +63,7 @@ void config_load()
     }
 
     MESA_load_profile_string_nodef(config_path, "global", "zlog_config_path", tmp_path, sizeof(tmp_path));
-    paths_combine(g_conf->absolute_path, tmp_path, g_conf->zlog_config_path);
+    paths_combine(g_conf->absolute_path, tmp_path, g_conf->zlog_config_path, sizeof(g_conf->zlog_config_path));
     printf("zlog config path: %s\n", g_conf->zlog_config_path);
 
     MESA_load_profile_string_def(config_path, "global", "dp_trace_dir", tmp_path, sizeof(tmp_path), "/tmp");
@@ -97,11 +95,11 @@ void config_load()
     MESA_load_profile_int_def(config_path, "maat", "maat_input_mode", &(g_conf->maat_input_mode), 0);
 
     MESA_load_profile_string_def(config_path, "maat", "table_schema", tmp_path, sizeof(tmp_path), "");
-    paths_combine(g_conf->absolute_path, tmp_path, g_conf->table_schema);
+    paths_combine(g_conf->absolute_path, tmp_path, g_conf->table_schema, sizeof(g_conf->table_schema));
     printf("maat table_schema path: %s\n", g_conf->table_schema);
 
     MESA_load_profile_string_def(config_path, "maat", "json_cfg_file", tmp_path, sizeof(tmp_path), "");
-    paths_combine(g_conf->absolute_path, tmp_path, g_conf->json_cfg_file);
+    paths_combine(g_conf->absolute_path, tmp_path, g_conf->json_cfg_file, sizeof(g_conf->json_cfg_file));
     printf("maat json config file path: %s\n", g_conf->json_cfg_file);
 
     MESA_load_profile_string_def(config_path, "maat", "maat_redis_server", g_conf->redis_server,
@@ -134,6 +132,7 @@ void dynamic_config_load()
                                  &dp_trace_merge_timeout);
     g_conf->dp_trace_merge_timeout = dp_trace_merge_timeout;
 
+    g_conf->nr_desc = 0;
     memset(g_conf->desc, 0, sizeof(g_conf->desc));
     for (int rule_index = 0; rule_index < DP_TRACE_JOB_NUM_MAX; rule_index++)
     {
@@ -160,7 +159,7 @@ void dynamic_config_load()
         MESA_load_profile_uint_nodef(g_conf->dy_config_path, dp_trace_section, "snaplen", &snaplen);
 
         struct dp_trace_job_desc * desc = (struct dp_trace_job_desc *)&g_conf->desc;
-        struct dp_trace_job_desc * desc_i = &desc[rule_index];
+        struct dp_trace_job_desc * desc_i = &desc[g_conf->nr_desc++];
         desc_i->enable = (enable == 0) ? false : true;
         desc_i->rule_index = rule_index;
 
@@ -177,11 +176,11 @@ void dynamic_config_load()
 void dynamic_config_load_and_apply()
 {
     dynamic_config_load();
-    job_rule_apply(g_conf->desc, TELEMETRY_DIM(g_conf->desc), DP_TRACE_ROLE);
+    job_rule_apply(g_conf->desc, g_conf->nr_desc, DP_TRACE_ROLE);
 }
 
 //////////////////////// helper function /////////////////////////
-static void main_process_realpath_get(char * absolute_path, size_t size)
+static void main_program_realpath_get(char * absolute_path, size_t size)
 {
     // readlink requires "/proc/self/exe" on Linux and "/proc/curproc/file" on FreeBSD
     // https://stackoverflow.com/questions/933850/how-do-i-find-the-location-of-the-executable-in-c
@@ -189,29 +188,4 @@ static void main_process_realpath_get(char * absolute_path, size_t size)
     ssize_t len = readlink("/proc/self/exe", absolute_path, size - 1);
     DP_TRACE_VERIFY(len != -1, "get main process realpath failed:%s", strerror(errno));
     absolute_path[len] = '\0';
-}
-
-// Combine relative paths and absolute paths into a new absolute path
-static char * paths_combine(const char * restrict absolute_path, const char * restrict relative_path,
-                            char * restrict resolve_path)
-{
-    if (relative_path[0] == '/')
-    {
-        strcpy(resolve_path, relative_path);
-        return resolve_path;
-    }
-
-    char combine_path[PATH_MAX];
-    strcpy(combine_path, absolute_path);
-
-    char * last_slash = strrchr(combine_path, '/');
-    DP_TRACE_VERIFY(last_slash != NULL, "Invalid absolute path.");
-    *last_slash = '\0';
-
-    strcat(combine_path, "/");
-    strcat(combine_path, relative_path);
-
-    realpath(combine_path, resolve_path);
-
-    return resolve_path;
 }
\ No newline at end of file
diff --git a/src/job_ctx.c b/src/job_ctx.c
index 65d9cdd..1bb1d2b 100644
--- a/src/job_ctx.c
+++ b/src/job_ctx.c
@@ -20,40 +20,49 @@ static int telemetry_unused_job_index_get();
 
 void job_rule_apply(struct dp_trace_job_desc desc[], unsigned int nr_desc, uint8_t role)
 {
-    job_bitmap_t jobs_id_used;
-    int ret = marsio_dp_trace_job_id_uesd_get(mr_instance, &jobs_id_used);
-    if (ret < 0)
-    {
-        dzlog_error("marsio_dp_trace_job_id_uesd_get faild");
-        return;
-    }
-
+    int ret = 0;
     for (unsigned int i = 0; i < nr_desc; i++)
     {
         uint8_t rule_index = desc[i].rule_index;
         job_bitmap_t cur_job_id = index_to_job_id(rule_index);
-        unsigned int cur_job_uesd = cur_job_id & jobs_id_used;
+        uint8_t cur_job_uesd = is_job_id_used(cur_job_id);
 
         // The job that was not originally in the system is now included in the configuration.
         if (cur_job_uesd == 0 && desc[i].enable && strlen(desc[i].bpf_expr) != 0)
         {
-            marsio_dp_trace_job_add(mr_instance, &desc[i]);
-            dp_trace_job_occupy[rule_index].uesd = 1;
-            dp_trace_job_occupy[rule_index].role = role;
+            ret = marsio_dp_trace_job_add(mr_instance, &desc[i]);
+            if (ret == 0)
+            {
+                dzlog_error("add rule %u failed. bpf_expr is: %s", rule_index, desc[i].bpf_expr);
+            }
+            else
+            {
+                dp_trace_job_occupy[rule_index].uesd = 1;
+                dp_trace_job_occupy[rule_index].role = role;
+                dzlog_info("add rule %u successfully. bpf_expr is: %s", rule_index, desc[i].bpf_expr);
+            }
             continue;
         }
 
         // The job that originally existed in the system is not in the configuration now.
         if (cur_job_uesd == 1 && (desc[i].enable == false || strlen(desc[i].bpf_expr) == 0))
         {
-            marsio_dp_trace_job_del(mr_instance, cur_job_id);
-            uint8_t tmp_role = dp_trace_job_occupy[rule_index].role;
-            dp_trace_job_occupy[rule_index].uesd = 0;
-            dp_trace_job_occupy[rule_index].role = DP_TRACE_NO_ROLE;
-
-            if (dp_trace_job_occupy[rule_index].role == tmp_role)
+            ret = marsio_dp_trace_job_del(mr_instance, cur_job_id);
+            if (ret < 0)
             {
-                dp_trace_pcapng_merger(cur_job_id);
+                dzlog_error("del rule %u failed. bpf_expr is: %s", rule_index, desc[i].bpf_expr);
+            }
+            else
+            {
+                uint8_t tmp_role = dp_trace_job_occupy[rule_index].role;
+                dp_trace_job_occupy[rule_index].uesd = 0;
+                dp_trace_job_occupy[rule_index].role = DP_TRACE_NO_ROLE;
+
+                if (tmp_role == DP_TRACE_ROLE)
+                {
+                    dp_trace_pcapng_merger(cur_job_id);
+                }
+                dzlog_info("del rule %u successfully. bpf_expr is: %s", rule_index, desc[i].bpf_expr);
             }
             continue;
         }
@@ -119,7 +128,7 @@ void telemetry_job_add_cb(const char * table_name, int table_id, const char * ke
     *ad = &telemetry_descs[index];
 
 out:
-    if (json_str)
+    if (json)
         cJSON_Delete(json);
     if (json_str)
         free(json_str);
diff --git a/src/kafka.c b/src/kafka.c
index 69d8dc7..7854cca 100644
--- a/src/kafka.c
+++ b/src/kafka.c
@@ -1,5 +1,6 @@
 #include "kafka.h"
 #include "common.h"
+#include <errno.h>
 
 rd_kafka_t * kafka_handle_create(const char * brokerlist, const char * sasl_username, const char * sasl_passwd)
 {
@@ -86,15 +87,30 @@ error:
     {
         rd_kafka_destroy(handle);
     }
-    return NULL;
+    exit(EXIT_FAILURE);
 }
 
 rd_kafka_topic_t * kafka_topic_new(rd_kafka_t * rk, const char * topic, rd_kafka_topic_conf_t * conf)
 {
-    return rd_kafka_topic_new(rk, topic, conf);
+    rd_kafka_topic_t * ret = rd_kafka_topic_new(rk, topic, conf);
+    if (ret == NULL)
+    {
+        rd_kafka_resp_err_t err = rd_kafka_last_error();
+        dzlog_error("rd_kafka_topic_new failed:%s", rd_kafka_err2str(err));
+        exit(EXIT_FAILURE);
+    }
+    return ret;
 }
 
 int kafka_produce(rd_kafka_topic_t * rkt, void * payload, size_t len)
 {
-    return rd_kafka_produce(rkt, RD_KAFKA_PARTITION_UA, RD_KAFKA_MSG_F_FREE, (void *)payload, len, NULL, 0, NULL);
+    // Automatically release payload
+    // Even if the function fails to execute and returns -1, the payload will be released.
+    int ret = rd_kafka_produce(rkt, RD_KAFKA_PARTITION_UA, RD_KAFKA_MSG_F_FREE, (void *)payload, len, NULL, 0, NULL);
+    if (ret != 0)
+    {
+        rd_kafka_resp_err_t err = rd_kafka_last_error();
+        dzlog_error("rd_kafka_topic_new failed:%s", rd_kafka_err2str(err));
+    }
+    return ret;
 }
\ No newline at end of file
diff --git a/src/maat.c b/src/maat.c
index fcd1e7c..611908e 100644
--- a/src/maat.c
+++ b/src/maat.c
@@ -18,7 +18,6 @@ static struct maat * dp_trace_maat_instance_create()
     maat_options_set_logger(opts, "log/maat.log", (enum log_level)conf->maat_log_level);
     maat_options_set_instance_name(opts, "dp_trace_telemetry");
     maat_options_set_caller_thread_number(opts, 0);
-
     switch (conf->maat_input_mode)
     {
     case MAAT_INPUT_JSON:
@@ -26,7 +25,7 @@ static struct maat * dp_trace_maat_instance_create()
         if (ret != 0)
         {
             dzlog_error("maat_options_set_json_file function execution failed.");
-            goto error_out;
+            goto end;
         }
         break;
     case MAAT_INPUT_REDIS:
@@ -43,13 +42,13 @@ static struct maat * dp_trace_maat_instance_create()
         else
         {
             dzlog_error("Invalid redis port range %s, MAAT init failed.", conf->redis_port_range);
-            goto error_out;
+            goto end;
         }
         maat_options_set_redis(opts, conf->redis_server, redis_port_select, conf->redis_db_idx);
         break;
     default:
         dzlog_error("Invalid MAAT Input Mode: %d.", conf->maat_input_mode);
-        goto error_out;
+        goto end;
         break;
     }
 
@@ -57,15 +56,15 @@ static struct maat * dp_trace_maat_instance_create()
     if (!target)
     {
         dzlog_error("maat_new function execution failed.");
-        goto error_out;
+        goto end;
     }
 
-    maat_options_free(opts);
+end:
+    if (opts != NULL)
+    {
+        maat_options_free(opts);
+    }
     return target;
-
-error_out:
-    maat_options_free(opts);
-    return NULL;
 }
 
 void dp_trace_maat_init()
diff --git a/src/main.c b/src/main.c
index 2f20972..4fae839 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,6 +1,5 @@
 #include "common.h"
 #include "config.h"
-#include "job_ctx.h"
 #include "maat.h"
 #include "trace_output.h"
 
@@ -12,13 +11,13 @@
 #include <stdlib.h>
 #include <sys/signalfd.h>
 
-static char appsym[64] = "dp_trace_telemetry";
+static const char appsym[64] = "dp_trace_telemetry";
 
 struct mr_instance * mr_instance = NULL;
+unsigned int zlog_env_is_init = 0;
 
 static void signal_handler(evutil_socket_t fd, short what, void * arg)
 {
-
     switch (fd)
     {
     case SIGHUP:
@@ -43,7 +42,7 @@ void signal_event_init()
 
     evbase = event_base_new();
 
-    DP_TRACE_VERIFY(evbase, "event_base_new failed");
+    DP_TRACE_VERIFY(evbase != NULL, "event_base_new failed");
 
     for (unsigned int i = 0; i < TELEMETRY_DIM(signals); i++)
     {
@@ -53,32 +52,33 @@ void signal_event_init()
     }
 
     pthread_t tid;
-    if (pthread_create(&tid, NULL, signal_event_thread_dispatch, evbase) != 0)
-    {
-        dzlog_error("failed to create thread for event_base dispatch");
-        exit(EXIT_FAILURE);
-    }
+    int ret = pthread_create(&tid, NULL, signal_event_thread_dispatch, evbase);
+    DP_TRACE_VERIFY(ret == 0, "failed to create thread for event_base dispatch.return value:%d", ret);
 }
 
-void usage()
+void usage(const char * program_name)
 {
-    fprintf(stdout, "Usage:\n"
-                    "\n"
-                    "   dp_trace_telemetry [option]\n"
-                    "\n"
-                    "Options:\n"
-                    "\n"
-                    "   -c config file path\n"
-                    "   -d dynamic config file path\n"
-                    "   -v show current version\n"
-                    "   -h \n"
-                    "\n");
+    fprintf(stdout,
+            "Usage:\n"
+            "\n"
+            "   %s [option]\n"
+            "\n"
+            "Options:\n"
+            "\n"
+            "   -c config file path\n"
+            "   -d dynamic config file path\n"
+            "   -v show current version\n"
+            "   -h \n"
+            "\n",
+            program_name);
     exit(0);
 }
 
 int main(int argc, char * argv[])
 {
     int ret = 0;
+    char * arg0_dup = strdup(argv[0]);
+    const char * program_name = basename(arg0_dup);
 
     char config_path[PATH_MAX];
     char dy_config_path[PATH_MAX];
@@ -89,7 +89,7 @@ int main(int argc, char * argv[])
         switch (opt)
         {
         case 'h': {
-            usage();
+            usage(program_name);
             break;
         }
         case 'c': {
@@ -105,7 +105,7 @@ int main(int argc, char * argv[])
             exit(0);
         }
         default:
-            usage();
+            usage(program_name);
             break;
         }
     }
@@ -124,19 +124,22 @@ int main(int argc, char * argv[])
         printf("fail in dzlog_int.\n");
         if (zlog_profile_error != NULL)
         {
-            printf("The zlog error log is recorded in:%s\n", zlog_profile_error);
+            printf("The dzlog_init function error infomation is recorded in:%s\n", zlog_profile_error);
         }
-        return 0;
+        exit(EXIT_FAILURE);
     }
+    zlog_env_is_init = 1;
 
     dp_trace_output_init();
 
     mr_instance = marsio_create();
 
     cpu_set_t cpu_set_io = conf->cpu_set_io;
-    marsio_option_set(mr_instance, MARSIO_OPT_THREAD_MASK_IN_CPUSET, &cpu_set_io, sizeof(cpu_set_io));
+    ret = marsio_option_set(mr_instance, MARSIO_OPT_THREAD_MASK_IN_CPUSET, &cpu_set_io, sizeof(cpu_set_io));
+    DP_TRACE_VERIFY(ret >= 0, "marsio_option_set failed.");
 
-    marsio_init(mr_instance, appsym);
+    ret = marsio_init(mr_instance, appsym);
+    DP_TRACE_VERIFY(ret >= 0, "marsio init failed.");
 
     dynamic_config_load_and_apply();
 
@@ -167,5 +170,6 @@ int main(int argc, char * argv[])
     }
 
     marsio_destory(mr_instance);
-    fprintf(stdout, "L2FWD is terminated. ");
+    free(arg0_dup);
+    dzlog_info("%s is terminated.", program_name);
 }
\ No newline at end of file
diff --git a/src/trace_output.c b/src/trace_output.c
index cf7c2e6..ac0a63b 100644
--- a/src/trace_output.c
+++ b/src/trace_output.c
@@ -47,18 +47,7 @@ void dp_trace_output_init()
     // pcapng file path init
     const char * dp_trace_dir = conf->dp_trace_dir;
     int ret = mkdir(dp_trace_dir, 0755);
-    if (ret != 0 && errno != EEXIST)
-    {
-        dzlog_error("Failed to create directory:%s.%s", dp_trace_dir, strerror(errno));
-        exit(EXIT_FAILURE);
-    }
-
-    for (unsigned int i = 0; i < TELEMETRY_DIM(dp_trace_output); i++)
-    {
-        asprintf(&dp_trace_output[i].file_path, "%s/dp_trace_%u.pcapng", dp_trace_dir, i);
-        asprintf(&dp_trace_output[i].file_bak_path, "%s/dp_trace_%u.pcapng.1", dp_trace_dir, i);
-        asprintf(&dp_trace_output[i].file_middle_path, "%s/dp_trace_%u.pcapng.2", dp_trace_dir, i);
-    }
+    DP_TRACE_VERIFY(ret == 0 || errno == EEXIST, "Failed to create directory:%s.%s", dp_trace_dir, strerror(errno));
 
     pthread_mutexattr_t attr;
     pthread_mutexattr_init(&attr);
@@ -66,12 +55,12 @@ void dp_trace_output_init()
     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
     for (unsigned int i = 0; i < TELEMETRY_DIM(dp_trace_output); i++)
     {
+        asprintf(&dp_trace_output[i].file_path, "%s/dp_trace_%u.pcapng", dp_trace_dir, i);
+        asprintf(&dp_trace_output[i].file_bak_path, "%s/dp_trace_%u.pcapng.1", dp_trace_dir, i);
+        asprintf(&dp_trace_output[i].file_middle_path, "%s/dp_trace_%u.pcapng.2", dp_trace_dir, i);
+
         ret = pthread_mutex_init(&dp_trace_output[i].file_mutex, &attr);
-        if (ret != 0)
-        {
-            dzlog_error("pthread_mutex_init failed(ret=%d)", ret);
-            exit(EXIT_FAILURE);
-        }
+        DP_TRACE_VERIFY(ret == 0, "pthread_mutex_init failed(ret = % d)", ret);
     }
 
     kafka_handle = kafka_handle_create(conf->broker_list, conf->sasl_password, conf->sasl_username);
@@ -105,7 +94,7 @@ void * dp_trace_process_thread(void * arg)
 
         for (unsigned int i = 0; i < DP_TRACE_JOB_NUM_MAX; i++)
         {
-            unsigned int nr_mbufs = nr_jobs_mbufs[i];
+            const unsigned int nr_mbufs = nr_jobs_mbufs[i];
             if (nr_mbufs == 0)
             {
                 continue;
@@ -135,8 +124,9 @@ void * dp_trace_process_thread(void * arg)
             else
             {
                 dzlog_info("The job has been deleted. The trace content corresponding to the job has been discarded.");
-                marsio_dp_trace_free(mr_instance, class_mbufs[i], nr_mbufs);
             }
+
+            marsio_dp_trace_free(mr_instance, class_mbufs[i], nr_mbufs);
         }
     }
 }
@@ -248,7 +238,6 @@ unlock:
     dp_trace_file_mutex_unlock(job_id);
 
 end:
-    marsio_dp_trace_free(mr_instance, mbufs, nr_mbufs);
     free(comment);
     return;
 }
@@ -513,6 +502,7 @@ static int dp_trace_record_decode_to_str(marsio_buff_t * mr_mbuf, char * data, u
 
 #ifndef NDEBUG
     unsigned int comment_cnt = 0;
+    unsigned int trace_comment_cnt = 0;
 #endif
 
     while (position < trace_buff_info.buffer_used)
@@ -523,22 +513,28 @@ static int dp_trace_record_decode_to_str(marsio_buff_t * mr_mbuf, char * data, u
         const char * str = cur + sizeof(struct dp_trace_record_header);
         const unsigned int str_len = record_header->recode_len;
 
-        int n = snprintf(data, size, "[%s:%s:] %ld.%ld ", record_header->appsym, record_header->module,
-                         record_header->ts.tv_sec, record_header->ts.tv_nsec);
-        if (unlikely(n < 0 || n >= size))
-            return -1;
-        size -= n;
-        data += n;
-
-        if (unlikely(size - 2 < str_len))
-            return -1;
-        memcpy(data, str, str_len);
-        size -= str_len;
-        data += str_len;
-
-        *data = '\n';
-        size--;
-        data++;
+        if (record_header->tag == DP_TRACE_RECORD_TYPE_TRACE)
+        {
+            int n = snprintf(data, size, "[%s:%s:] %ld.%ld ", record_header->appsym, record_header->module,
+                             record_header->ts.tv_sec, record_header->ts.tv_nsec);
+            if (unlikely(n < 0 || n >= size))
+                return -1;
+            size -= n;
+            data += n;
+
+            if (unlikely(size - 2 < str_len))
+                return -1;
+            memcpy(data, str, str_len);
+            size -= str_len;
+            data += str_len;
+
+            *data = '\n';
+            size--;
+            data++;
+#ifndef NDEBUG
+            trace_comment_cnt++;
+#endif
+        }
 
         position += sizeof(struct dp_trace_record_header) + str_len;
 #ifndef NDEBUG
@@ -551,7 +547,8 @@ static int dp_trace_record_decode_to_str(marsio_buff_t * mr_mbuf, char * data, u
 
 #ifndef NDEBUG
     uint16_t avali = trace_buff_info.buffer_len - trace_buff_info.buffer_used;
-    snprintf(data, size, "used: %u, avali: %u, comment: %u", trace_buff_info.buffer_used, avali, comment_cnt);
+    snprintf(data, size, "used: %u, avali: %u, all comment: %u, trace comment %u", trace_buff_info.buffer_used, avali,
+             comment_cnt, trace_comment_cnt);
 #else
     *data = '\0';
 #endif
diff --git a/test/cmocka_test.c b/test/cmocka_test.c
index 64681b3..b96a368 100644
--- a/test/cmocka_test.c
+++ b/test/cmocka_test.c
@@ -10,6 +10,7 @@
 #include <cmocka.h>
 
 struct mr_instance * mr_instance = NULL;
+unsigned int zlog_env_is_init = 0;
 
 int setup(void ** state)
 {