rename tag->field; tag2key on stack

15 files changed, 407 insertions, 428 deletions

diff --git a/test/profiling/main.c b/test/profiling/main.c
index 3e498af..5838f20 100644
--- a/test/profiling/main.c
+++ b/test/profiling/main.c
@@ -4,26 +4,26 @@
 #include <string.h>
 
 #include "fieldstat.h"
-#include "tags/my_ut_hash.h"
-#include "tags/my_ut_hash_inner.h"
+#include "fields/my_ut_hash.h"
+#include "fields/my_ut_hash_inner.h"
 
 #define ADD_OPER_NUM 5000000ULL
 // #define ADD_OPER_NUM 1
 #define MAX_STRING_KEY_LEN 10
 
-const struct fieldstat_tag TEST_TAG_INT = {"INT key_", TAG_INTEGER, {.value_longlong = 100}};
+const struct field TEST_TAG_INT = {"INT key_", TAG_INTEGER, {.value_longlong = 100}};
 
 
 int main () {
     printf("Start profiling...\n");
     clock_t start, end;
-    // struct fieldstat_tag TAG[4] = {
+    // struct field TAG[4] = {
     //     {"INT key_", TAG_INTEGER, {.value_longlong = 100}},
     //     {"STRING key_", TAG_CSTRING, {.value_str = "10012312312312"}},
     //     {"STRING key_", TAG_CSTRING, {.value_str = "100adsffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"}},
     //     {"FLOAT key_", TAG_INTEGER, {.value_double = 100.0}},
     // };
-    struct fieldstat_tag TAG[4] = {
+    struct field TAG[4] = {
         {"object_id", TAG_INTEGER, {.value_longlong = 20}},
         {"item_id", TAG_INTEGER, {.value_longlong = 16916397}},
         {"chart_id", TAG_INTEGER, {.value_longlong = 1}},
diff --git a/test/test_easy_fs.cpp b/test/test_easy_fs.cpp
index d3f45b7..9512aa0 100644
--- a/test/test_easy_fs.cpp
+++ b/test/test_easy_fs.cpp
@@ -28,12 +28,12 @@ TEST(test_easy_fieldstat, output_to_buff)
     fieldstat_easy_output(fse, &buff, &buff_len);
     cJSON *root = cJSON_Parse(buff);
     cJSON *cell = cJSON_GetArrayItem(root, 0);
-    cJSON *metric = cJSON_GetObjectItem(cell, "fields");
+    cJSON *metric = cJSON_GetObjectItem(cell, "tags");
     long long value = cJSON_GetObjectItem(metric, "metric counter")->valueint;
     EXPECT_EQ(value, 1);
-    cJSON *tags = cJSON_GetObjectItem(cell, "tags");
-    EXPECT_EQ(cJSON_GetObjectItem(tags, TEST_TAG_INT.key)->valueint, TEST_TAG_INT.value_longlong);
-    EXPECT_STREQ(cJSON_GetObjectItem(tags, TEST_TAG_STRING.key)->valuestring, TEST_TAG_STRING.value_str);
+    cJSON *fields = cJSON_GetObjectItem(cell, "tags");
+    EXPECT_EQ(cJSON_GetObjectItem(fields, TEST_TAG_INT.key)->valueint, TEST_TAG_INT.value_longlong);
+    EXPECT_STREQ(cJSON_GetObjectItem(fields, TEST_TAG_STRING.key)->valuestring, TEST_TAG_STRING.value_str);
 
     cJSON_Delete(root);
     free(buff);
@@ -55,7 +55,7 @@ TEST(test_easy_fieldstat, output_to_buff_with_delta)
 
     cJSON *root = cJSON_Parse(buff);
     cJSON *cell = cJSON_GetArrayItem(root, 0);
-    cJSON *metric = cJSON_GetObjectItem(cell, "fields");
+    cJSON *metric = cJSON_GetObjectItem(cell, "tags");
     long long value = cJSON_GetObjectItem(metric, "metric counter")->valueint;
     EXPECT_EQ(value, 2);
     cJSON *metric_delta = cJSON_GetObjectItem(cell, "fields_delta");
@@ -104,7 +104,7 @@ TEST(test_easy_fieldstat, output_to_file)
     EXPECT_EQ(cJSON_GetArraySize(root), 1);
 
     cJSON *tagged_by_int = cJSON_GetArrayItem(root, 0);
-    cJSON *metric = cJSON_GetObjectItem(tagged_by_int, "fields");
+    cJSON *metric = cJSON_GetObjectItem(tagged_by_int, "tags");
     EXPECT_TRUE(metric != NULL);
 
     long long value = cJSON_GetObjectItem(metric, "metric counter")->valueint;
@@ -117,7 +117,7 @@ TEST(test_easy_fieldstat, output_to_file)
     root = read_file();
     EXPECT_EQ(cJSON_GetArraySize(root), 1);
     tagged_by_int = cJSON_GetArrayItem(root, 0);
-    metric = cJSON_GetObjectItem(tagged_by_int, "fields");
+    metric = cJSON_GetObjectItem(tagged_by_int, "tags");
     value = cJSON_GetObjectItem(metric, "metric counter")->valueint;
     EXPECT_EQ(value, 111); // should not change
     cJSON_Delete(root);
@@ -128,7 +128,7 @@ TEST(test_easy_fieldstat, output_to_file)
     printf("4th interval\n");
     root = read_file();
     cJSON *tagged_by_double = cJSON_GetArrayItem(root, 1);
-    metric = cJSON_GetObjectItem(tagged_by_double, "fields");
+    metric = cJSON_GetObjectItem(tagged_by_double, "tags");
     value = cJSON_GetObjectItem(metric, "metric counter")->valueint;
     EXPECT_EQ(value, 10086);
     cJSON_Delete(root);
@@ -150,7 +150,7 @@ TEST(test_easy_fieldstat, empty_tag)
     EXPECT_EQ(cJSON_GetArraySize(root), 1);
 
     cJSON *tagged_by_int = cJSON_GetArrayItem(root, 0);
-    cJSON *metric = cJSON_GetObjectItem(tagged_by_int, "fields");
+    cJSON *metric = cJSON_GetObjectItem(tagged_by_int, "tags");
     EXPECT_TRUE(metric != NULL);
     cJSON *metric_delta = cJSON_GetObjectItem(tagged_by_int, "fields_delta");
     EXPECT_TRUE(metric_delta != NULL);
@@ -197,8 +197,8 @@ TEST(test_easy_fieldstat, output_interval_ok)
 TEST(test_easy_fieldstat, ensure_data_racing_of_two_output_and_of_incyby)
 {
     const int N_THREADS = 3;
-    struct fieldstat_tag global_tags[1];
-    struct fieldstat_tag tmptag;
+    struct field global_tags[1];
+    struct field tmptag;
     tmptag.key = "app id";
     tmptag.type = TAG_INTEGER;
     tmptag.value_longlong = 1;
@@ -250,7 +250,7 @@ TEST(test_easy_fieldstat, reset)
 
 long long get_value(const char *input, const char *key) {
     cJSON *root = cJSON_Parse(input);
-    cJSON *metric = cJSON_GetObjectItem(root, "fields");
+    cJSON *metric = cJSON_GetObjectItem(root, "tags");
     long long value = cJSON_GetObjectItem(metric, key)->valueint;
     cJSON_Delete(root);
     return value;
diff --git a/test/test_empty_tags.cpp b/test/test_empty_tags.cpp
index 7e17489..5c39f26 100644
--- a/test/test_empty_tags.cpp
+++ b/test/test_empty_tags.cpp
@@ -8,12 +8,12 @@
 
 void assert_cell_null(const struct fieldstat *instance, int cube_id, long long expected_count)
 {
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance, cube_id, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
-    EXPECT_EQ(tag_list[0].n_tag, 0);
-    EXPECT_TRUE(tag_list[0].tag == NULL);
+    EXPECT_EQ(tag_list[0].n_field, 0);
+    EXPECT_TRUE(tag_list[0].field == NULL);
     long long value;
     fieldstat_counter_get(instance, cube_id, &tag_list[0], 0, &value);
     EXPECT_EQ(value, expected_count);
@@ -57,9 +57,9 @@ TEST(test_empty_tag, merge)
     int n_cube = 0;
     fieldstat_get_cubes(instance_dst, &ret_cube_id_arr, &n_cube);
     int ret_cell_id = ret_cube_id_arr[0];
-    struct fieldstat_tag_list *shared_tag = fieldstat_cube_get_tags(instance_dst, ret_cell_id);
-    EXPECT_EQ(shared_tag->n_tag, 0);
-    EXPECT_TRUE(shared_tag->tag == NULL);
+    struct field_list *shared_tag = fieldstat_cube_get_tags(instance_dst, ret_cell_id);
+    EXPECT_EQ(shared_tag->n_field, 0);
+    EXPECT_TRUE(shared_tag->field == NULL);
     fieldstat_tag_list_arr_free(shared_tag, 1);
     free(ret_cube_id_arr);
 
@@ -81,9 +81,9 @@ TEST(test_empty_tag, merge_topk)
     int n_cube = 0;
     fieldstat_get_cubes(instance_dst, &ret_cube_id_arr, &n_cube);
     int ret_cell_id = ret_cube_id_arr[0];
-    struct fieldstat_tag_list *shared_tag = fieldstat_cube_get_tags(instance_dst, ret_cell_id);
-    EXPECT_EQ(shared_tag->n_tag, 0);
-    EXPECT_TRUE(shared_tag->tag == NULL);
+    struct field_list *shared_tag = fieldstat_cube_get_tags(instance_dst, ret_cell_id);
+    EXPECT_EQ(shared_tag->n_field, 0);
+    EXPECT_TRUE(shared_tag->field == NULL);
     fieldstat_tag_list_arr_free(shared_tag, 1);
     free(ret_cube_id_arr);
 
@@ -107,11 +107,11 @@ TEST(test_empty_tag, export)
     fieldstat_free(instance);
 
     cJSON *root = cJSON_GetArrayItem(root_arr, 0);
-    // check tag
-    cJSON *tag = cJSON_GetObjectItem(root, "tags");
-    EXPECT_EQ(cJSON_GetArraySize(tag), 0);
+    // check field
+    cJSON *field = cJSON_GetObjectItem(root, "tags");
+    EXPECT_EQ(cJSON_GetArraySize(field), 0);
 
-    cJSON *metrics = cJSON_GetObjectItem(root, "fields");
+    cJSON *metrics = cJSON_GetObjectItem(root, "tags");
     EXPECT_NE(metrics, nullptr);
     cJSON *counter = cJSON_GetObjectItem(metrics, "metric");
     EXPECT_EQ(counter->valueint, 1);
diff --git a/test/test_exporter_json.cpp b/test/test_exporter_json.cpp
index aac8ac7..259091b 100644
--- a/test/test_exporter_json.cpp
+++ b/test/test_exporter_json.cpp
@@ -23,23 +23,23 @@ struct hdr_histogram *g_histogram_standard;
 #define TEST_TOPK_STANDARD_K 5
 #define TEST_METRIC_NUM 2
 
-const struct fieldstat_tag TEST_TAG_GLOBAL1 = {"test_tag_global 1", .type = TAG_INTEGER, {.value_longlong = 1}};
-const struct fieldstat_tag TEST_TAG_GLOBAL2 = {"test_tag_global 2", .type = TAG_DOUBLE, {.value_double = 2.2}};
-const struct fieldstat_tag TEST_TAG_GLOBAL3 = {"test_tag_global 3", .type = TAG_CSTRING, {.value_str = "string3"}};
-const struct fieldstat_tag TEST_TAG_GLOBAL[3] = {TEST_TAG_GLOBAL1, TEST_TAG_GLOBAL2, TEST_TAG_GLOBAL3};
+const struct field TEST_TAG_GLOBAL1 = {"test_tag_global 1", .type = TAG_INTEGER, {.value_longlong = 1}};
+const struct field TEST_TAG_GLOBAL2 = {"test_tag_global 2", .type = TAG_DOUBLE, {.value_double = 2.2}};
+const struct field TEST_TAG_GLOBAL3 = {"test_tag_global 3", .type = TAG_CSTRING, {.value_str = "string3"}};
+const struct field TEST_TAG_GLOBAL[3] = {TEST_TAG_GLOBAL1, TEST_TAG_GLOBAL2, TEST_TAG_GLOBAL3};
 
-const struct fieldstat_tag TEST_TAG_SHARED1_1 = {"test_tag_shared 1", .type = TAG_INTEGER, {.value_longlong = 3}};
-const struct fieldstat_tag TEST_TAG_SHARED1_2 = {"test_tag_shared 2", .type = TAG_DOUBLE, {.value_double = 0.2}};
-const struct fieldstat_tag TEST_TAG_SHARED1_3 = {"test_tag_shared 3", .type = TAG_CSTRING, {.value_str = "1string"}};
-const struct fieldstat_tag TEST_TAG_SHARED1[3] = {TEST_TAG_SHARED1_1, TEST_TAG_SHARED1_2, TEST_TAG_SHARED1_3};
+const struct field TEST_TAG_SHARED1_1 = {"test_tag_shared 1", .type = TAG_INTEGER, {.value_longlong = 3}};
+const struct field TEST_TAG_SHARED1_2 = {"test_tag_shared 2", .type = TAG_DOUBLE, {.value_double = 0.2}};
+const struct field TEST_TAG_SHARED1_3 = {"test_tag_shared 3", .type = TAG_CSTRING, {.value_str = "1string"}};
+const struct field TEST_TAG_SHARED1[3] = {TEST_TAG_SHARED1_1, TEST_TAG_SHARED1_2, TEST_TAG_SHARED1_3};
 
-const struct fieldstat_tag TEST_TAG_SHARED2_1 = {"test_tag_shared 11", .type = TAG_INTEGER, {.value_longlong = 4}};
-const struct fieldstat_tag TEST_TAG_SHARED2_2 = {"test_tag_shared 22", .type = TAG_DOUBLE, {.value_double = 0.3}};
-const struct fieldstat_tag TEST_TAG_SHARED2_3 = {"test_tag_shared 33", .type = TAG_CSTRING, {.value_str = "2string"}};
-const struct fieldstat_tag TEST_TAG_SHARED2[3] = {TEST_TAG_SHARED2_1, TEST_TAG_SHARED2_2, TEST_TAG_SHARED2_3};
+const struct field TEST_TAG_SHARED2_1 = {"test_tag_shared 11", .type = TAG_INTEGER, {.value_longlong = 4}};
+const struct field TEST_TAG_SHARED2_2 = {"test_tag_shared 22", .type = TAG_DOUBLE, {.value_double = 0.3}};
+const struct field TEST_TAG_SHARED2_3 = {"test_tag_shared 33", .type = TAG_CSTRING, {.value_str = "2string"}};
+const struct field TEST_TAG_SHARED2[3] = {TEST_TAG_SHARED2_1, TEST_TAG_SHARED2_2, TEST_TAG_SHARED2_3};
 
-const struct fieldstat_tag TEST_TAG_SHARED3_1 = {"test_tag_shared 3", .type = TAG_INTEGER, {.value_longlong = 5}};
-const struct fieldstat_tag TEST_TAG_SHARED3[1] = {TEST_TAG_SHARED3_1};
+const struct field TEST_TAG_SHARED3_1 = {"test_tag_shared 3", .type = TAG_INTEGER, {.value_longlong = 5}};
+const struct field TEST_TAG_SHARED3[1] = {TEST_TAG_SHARED3_1};
 
 void test_check_if_tag_list_is_in_json(cJSON *tag_obj, const Fieldstat_tag_list_wrapper *benchmark)
 {
@@ -60,7 +60,7 @@ void test_check_if_tag_list_is_in_json(cJSON *tag_obj, const Fieldstat_tag_list_
 
 void test_check_if_global_tag_is_in_json(cJSON *tag_obj)
 {
-    struct fieldstat_tag_list tag_list = {.tag = (struct fieldstat_tag *)TEST_TAG_GLOBAL, .n_tag = 3};
+    struct field_list tag_list = {.field = (struct field *)TEST_TAG_GLOBAL, .n_field = 3};
     const Fieldstat_tag_list_wrapper benchmark(&tag_list);
     test_check_if_tag_list_is_in_json(tag_obj, &benchmark);
 }
@@ -105,7 +105,7 @@ void test_check_if_metric_topk_correct(cJSON *metric_obj, const char **name, uns
     }
 }
 
-void fill_random_tag(Fieldstat_tag_list_wrapper *tags[], int tag_list_num)
+void fill_random_tag(Fieldstat_tag_list_wrapper *fields[], int tag_list_num)
 {
     std::uniform_int_distribution<int> dist(1,100);
     std::mt19937 rng();
@@ -113,7 +113,7 @@ void fill_random_tag(Fieldstat_tag_list_wrapper *tags[], int tag_list_num)
     for (int i = 0; i < tag_list_num; i++)
     {
         Fieldstat_tag_list_wrapper *tmp = new Fieldstat_tag_list_wrapper(dist, i + 1);
-        tags[i] = tmp;
+        fields[i] = tmp;
     }
 }
 
@@ -192,12 +192,12 @@ TEST(export_test, cjson_export_with_fixed_tag_and_many_metrics_on_one_cube_of_co
     int id_histogram = fieldstat_register_hist(instance, "histogram",
         g_histogram_standard->lowest_discernible_value, g_histogram_standard->highest_trackable_value, g_histogram_standard->significant_figures);
 
-    Fieldstat_tag_list_wrapper *tags[tag_list_num];
-    fill_random_tag(tags, tag_list_num);
+    Fieldstat_tag_list_wrapper *fields[tag_list_num];
+    fill_random_tag(fields, tag_list_num);
 
     for (int j = 0; j < tag_list_num; j++) {
-        const struct fieldstat_tag *tag_tmp = tags[j]->get_tag();
-        size_t tag_count = tags[j]->get_tag_count();
+        const struct field *tag_tmp = fields[j]->get_tag();
+        size_t tag_count = fields[j]->get_tag_count();
 
         fieldstat_counter_incrby(instance, cube_id, id_counter, tag_tmp, tag_count, 1);
         for (size_t i = 0; i < OPER_NUM; i++){
@@ -215,10 +215,10 @@ TEST(export_test, cjson_export_with_fixed_tag_and_many_metrics_on_one_cube_of_co
     {
         cJSON *root = cJSON_GetArrayItem(root_arr, i);
 
-        // check tag
-        cJSON *tag = cJSON_GetObjectItem(root, "tags");
-        EXPECT_NE(tag, nullptr);
-        test_check_if_tag_list_is_in_json(tag, tags[i]);
+        // check field
+        cJSON *field = cJSON_GetObjectItem(root, "tags");
+        EXPECT_NE(field, nullptr);
+        test_check_if_tag_list_is_in_json(field, fields[i]);
 
         // check metrics
         cJSON *metrics = cJSON_GetObjectItem(root, "fields");
@@ -230,7 +230,7 @@ TEST(export_test, cjson_export_with_fixed_tag_and_many_metrics_on_one_cube_of_co
     }
 
     for (int i = 0; i < 3; i++) {
-        delete tags[i];
+        delete fields[i];
     }
 
     fieldstat_free(instance);
@@ -262,7 +262,7 @@ TEST(export_test, cjson_export_on_one_cube_of_topk_sampling)
         EXPECT_EQ(tag_val->type, cJSON_Number);
         topk_tag_value_set.insert(tag_val->valueint);
 
-        struct fieldstat_tag_list tmp_tag = {(struct fieldstat_tag *)&TEST_TAG_SHARED1, 3};
+        struct field_list tmp_tag = {(struct field *)&TEST_TAG_SHARED1, 3};
         Fieldstat_tag_list_wrapper shared_wrapper = Fieldstat_tag_list_wrapper(&tmp_tag);
         test_check_if_tag_list_is_in_json(tag, &shared_wrapper);
 
@@ -300,7 +300,7 @@ TEST(export_test, only_registered_but_not_added_export_null_with_global_tag)
     fieldstat_register_hist(instance, "histogram",
         g_histogram_standard->lowest_discernible_value, g_histogram_standard->highest_trackable_value, g_histogram_standard->significant_figures);
 
-    // add global tag
+    // add global field
     cJSON *root_arr = test_exporter_extract_results_with_standard_global(instance);
     EXPECT_EQ(root_arr, nullptr);
 
@@ -319,9 +319,9 @@ TEST(export_test, skip_two_empty_cube_and_export_last_one_with_global_tag)
         g_histogram_standard->lowest_discernible_value, g_histogram_standard->highest_trackable_value, g_histogram_standard->significant_figures);
 
     const int tag_num = 1;
-    Fieldstat_tag_list_wrapper *tags[tag_num];
-    fill_random_tag(tags, tag_num);
-    const Fieldstat_tag_list_wrapper *the_tag = tags[0];
+    Fieldstat_tag_list_wrapper *fields[tag_num];
+    fill_random_tag(fields, tag_num);
+    const Fieldstat_tag_list_wrapper *the_tag = fields[0];
     for (size_t i = 0; i < OPER_NUM; i++){
         fieldstat_hist_record(instance, cube_id_3, id_histogram, the_tag->get_tag(), the_tag->get_tag_count(), g_histogram_standard_oper[i]);
     }
@@ -337,7 +337,7 @@ TEST(export_test, skip_two_empty_cube_and_export_last_one_with_global_tag)
 
         // check tag
         cJSON *tag = cJSON_GetObjectItem(root, "tags");
-        test_check_if_tag_list_is_in_json(tag, tags[0]);
+        test_check_if_tag_list_is_in_json(tag, fields[0]);
         test_check_if_global_tag_is_in_json(tag);
 
         cJSON *metrics = cJSON_GetObjectItem(root, "fields");
@@ -350,7 +350,7 @@ TEST(export_test, skip_two_empty_cube_and_export_last_one_with_global_tag)
         FAIL();
     }
 
-    delete tags[0];
+    delete fields[0];
 
     fieldstat_free(instance);
     cJSON_Delete(root_arr);
@@ -367,9 +367,9 @@ TEST(export_test, skip_empty_metrics_given_cube_deleted) {
     (void)fieldstat_register_counter(instance, "counter4");
 
     const int tag_num = 1;
-    Fieldstat_tag_list_wrapper *tags[tag_num];
-    fill_random_tag(tags, tag_num);
-    const Fieldstat_tag_list_wrapper *the_tag = tags[0];
+    Fieldstat_tag_list_wrapper *fields[tag_num];
+    fill_random_tag(fields, tag_num);
+    const Fieldstat_tag_list_wrapper *the_tag = fields[0];
 
     fieldstat_counter_incrby(instance, cube_id, metric_id, the_tag->get_tag(), the_tag->get_tag_count(), 1234);
 
@@ -380,13 +380,13 @@ TEST(export_test, skip_empty_metrics_given_cube_deleted) {
     for (int i = 0; i < arr_num; i++) {
         cJSON *root = cJSON_GetArrayItem(root_arr, i);
 
-        // check tag
-        cJSON *tag = cJSON_GetObjectItem(root, "tags");
-        test_check_if_tag_list_is_in_json(tag, tags[0]);
-        test_check_if_global_tag_is_in_json(tag);
-        struct fieldstat_tag_list tmp_tag = {(struct fieldstat_tag *)&TEST_TAG_SHARED2, 3};
+        // check field
+        cJSON *field = cJSON_GetObjectItem(root, "tags");
+        test_check_if_tag_list_is_in_json(field, fields[0]);
+        test_check_if_global_tag_is_in_json(field);
+        struct field_list tmp_tag = {(struct field *)&TEST_TAG_SHARED2, 3};
         Fieldstat_tag_list_wrapper shared_wrapper = Fieldstat_tag_list_wrapper(&tmp_tag);
-        test_check_if_tag_list_is_in_json(tag, &shared_wrapper);
+        test_check_if_tag_list_is_in_json(field, &shared_wrapper);
 
         cJSON *metrics = cJSON_GetObjectItem(root, "fields");
         EXPECT_NE(metrics, nullptr);
@@ -399,7 +399,7 @@ TEST(export_test, skip_empty_metrics_given_cube_deleted) {
         FAIL();
     }
 
-    delete tags[0];
+    delete fields[0];
     fieldstat_free(instance);
     cJSON_Delete(root_arr);
 }
@@ -645,15 +645,15 @@ TEST(export_test, enable_delta_and_export_three_times_skipping_cube_with_no_coun
     fieldstat_free(instance);
 }
 
-void test_check_delta_for_one_json(const struct fieldstat_tag_list *expect_cell_tag, const struct fieldstat_tag_list *expect_shared_tag, long long expect_value, long long expect_delta, cJSON *root)
+void test_check_delta_for_one_json(const struct field_list *expect_cell_tag, const struct field_list *expect_shared_tag, long long expect_value, long long expect_delta, cJSON *root)
 {
-    // check tag
-    cJSON *tag = cJSON_GetObjectItem(root, "tags");
+    // check field
+    cJSON *field = cJSON_GetObjectItem(root, "tags");
     Fieldstat_tag_list_wrapper cell_wrapper = Fieldstat_tag_list_wrapper(expect_cell_tag);
-    test_check_if_tag_list_is_in_json(tag, &cell_wrapper);
+    test_check_if_tag_list_is_in_json(field, &cell_wrapper);
     Fieldstat_tag_list_wrapper shared_wrapper = Fieldstat_tag_list_wrapper(expect_shared_tag);
-    test_check_if_tag_list_is_in_json(tag, &shared_wrapper);
-    test_check_if_global_tag_is_in_json(tag);
+    test_check_if_tag_list_is_in_json(field, &shared_wrapper);
+    test_check_if_global_tag_is_in_json(field);
 
     // check metrics
     cJSON *metrics = cJSON_GetObjectItem(root, "fields");
@@ -690,21 +690,21 @@ TEST(export_test, enable_delta_and_export_instance_with_many_cells_with_global_t
 
     /* ------------------------------ cube 0 cell 0 ----------------------------- */
     cJSON *root = cJSON_GetArrayItem(root_arr, 0);
-    struct fieldstat_tag_list tmp_tag_cell = {(struct fieldstat_tag *)&TEST_TAG_INT, 1};
-    struct fieldstat_tag_list tmp_tag_shared = {(struct fieldstat_tag *)&TEST_TAG_SHARED1, 3};
+    struct field_list tmp_tag_cell = {(struct field *)&TEST_TAG_INT, 1};
+    struct field_list tmp_tag_shared = {(struct field *)&TEST_TAG_SHARED1, 3};
     test_check_delta_for_one_json(&tmp_tag_cell, &tmp_tag_shared, 11, 11, root);
     /* ------------------------------ cube 0 cell 1 ----------------------------- */
     root = cJSON_GetArrayItem(root_arr, 1);
-    tmp_tag_cell = (struct fieldstat_tag_list){(struct fieldstat_tag *)&TEST_TAG_STRING, 1};
+    tmp_tag_cell = (struct field_list){(struct field *)&TEST_TAG_STRING, 1};
     test_check_delta_for_one_json(&tmp_tag_cell, &tmp_tag_shared, 12, 12, root);
     /* ------------------------------ cube 1 cell 0 ----------------------------- */
     root = cJSON_GetArrayItem(root_arr, 2);
-    tmp_tag_cell = (struct fieldstat_tag_list){(struct fieldstat_tag *)&TEST_TAG_INT, 1};
-    tmp_tag_shared = (struct fieldstat_tag_list){(struct fieldstat_tag *)&TEST_TAG_SHARED3, 1};
+    tmp_tag_cell = (struct field_list){(struct field *)&TEST_TAG_INT, 1};
+    tmp_tag_shared = (struct field_list){(struct field *)&TEST_TAG_SHARED3, 1};
     test_check_delta_for_one_json(&tmp_tag_cell, &tmp_tag_shared, 21, 21, root);
     /* ------------------------------ cube 1 cell 1 ----------------------------- */
     root = cJSON_GetArrayItem(root_arr, 3);
-    tmp_tag_cell = (struct fieldstat_tag_list){(struct fieldstat_tag *)&TEST_TAG_DOUBLE, 1};
+    tmp_tag_cell = (struct field_list){(struct field *)&TEST_TAG_DOUBLE, 1};
     test_check_delta_for_one_json(&tmp_tag_cell, &tmp_tag_shared, 22, 22, root);
 
     // new turn 
@@ -726,21 +726,21 @@ TEST(export_test, enable_delta_and_export_instance_with_many_cells_with_global_t
 
     /* ------------------------------ cube 0 cell 0 ----------------------------- */
     root = cJSON_GetArrayItem(root_arr, 0);
-    tmp_tag_cell = (struct fieldstat_tag_list){(struct fieldstat_tag *)&TEST_TAG_INT, 1};
-    tmp_tag_shared = (struct fieldstat_tag_list){(struct fieldstat_tag *)&TEST_TAG_SHARED1, 3};
+    tmp_tag_cell = (struct field_list){(struct field *)&TEST_TAG_INT, 1};
+    tmp_tag_shared = (struct field_list){(struct field *)&TEST_TAG_SHARED1, 3};
     test_check_delta_for_one_json(&tmp_tag_cell, &tmp_tag_shared, 111, 100, root);
     /* ------------------------------ cube 0 cell 1 ----------------------------- */
     root = cJSON_GetArrayItem(root_arr, 1);
-    tmp_tag_cell = (struct fieldstat_tag_list){(struct fieldstat_tag *)&TEST_TAG_STRING, 1};
+    tmp_tag_cell = (struct field_list){(struct field *)&TEST_TAG_STRING, 1};
     test_check_delta_for_one_json(&tmp_tag_cell, &tmp_tag_shared, 212, 200, root);
     /* ------------------------------ cube 1 cell 0 ----------------------------- */
     root = cJSON_GetArrayItem(root_arr, 2);
-    tmp_tag_cell = (struct fieldstat_tag_list){(struct fieldstat_tag *)&TEST_TAG_INT, 1};
-    tmp_tag_shared = (struct fieldstat_tag_list){(struct fieldstat_tag *)&TEST_TAG_SHARED3, 1};
+    tmp_tag_cell = (struct field_list){(struct field *)&TEST_TAG_INT, 1};
+    tmp_tag_shared = (struct field_list){(struct field *)&TEST_TAG_SHARED3, 1};
     test_check_delta_for_one_json(&tmp_tag_cell, &tmp_tag_shared, 321, 300, root);
     /* ------------------------------ cube 1 cell 1 ----------------------------- */
     root = cJSON_GetArrayItem(root_arr, 3);
-    tmp_tag_cell = (struct fieldstat_tag_list){(struct fieldstat_tag *)&TEST_TAG_DOUBLE, 1};
+    tmp_tag_cell = (struct field_list){(struct field *)&TEST_TAG_DOUBLE, 1};
     test_check_delta_for_one_json(&tmp_tag_cell, &tmp_tag_shared, 422, 400, root);
 
     cJSON_Delete(root_arr);
@@ -950,28 +950,6 @@ TEST(export_test, delta_with_two_instance_different_cell)
     fieldstat_free(delta);
 }
 
-// TEST(export_test, sort_tag) {
-//     const struct fieldstat_tag tag1[3] = {TEST_TAG_INT, TEST_TAG_STRING, TEST_TAG_DOUBLE};
-//     const struct fieldstat_tag tag2[3] = {TEST_TAG_STRING, TEST_TAG_DOUBLE, TEST_TAG_INT};
-
-//     struct fieldstat *instance = fieldstat_new();
-//     fieldstat_create_cube(instance, NULL, 0, SAMPLING_MODE_COMPREHENSIVE, 0);
-//     int id_counter = fieldstat_register_counter(instance, "counter");
-//     fieldstat_counter_incrby(instance, 0, id_counter, tag1, 3, 1);
-//     fieldstat_counter_incrby(instance, 0, id_counter, tag2, 3, 10);
-
-//     // export test
-//     cJSON *root_arr = test_exporter_extract_results(instance);
-//     EXPECT_EQ(cJSON_GetArraySize(root_arr), 1);
-//     cJSON *root = cJSON_GetArrayItem(root_arr, 0);
-//     cJSON *metrics = cJSON_GetObjectItem(root, "fields");
-//     cJSON *counter = cJSON_GetObjectItem(metrics, "counter");
-//     EXPECT_EQ(counter->valueint, 11);
-
-//     cJSON_Delete(root_arr);
-//     fieldstat_free(instance);
-// }
-
 extern "C" {
 extern int add_object_to_json_array_start(char *buf, int buf_len);
 extern int add_object_to_json_array_end(char **buf, int buf_len, int start);
diff --git a/test/test_fieldstat_exporter.py b/test/test_fieldstat_exporter.py
index 232f4b5..6f65cb2 100644
--- a/test/test_fieldstat_exporter.py
+++ b/test/test_fieldstat_exporter.py
@@ -52,33 +52,33 @@ class TestPrometheusExporter(unittest.TestCase):
 
     def test__escape_metric_tags(self):
         json_obj = {'name': '-',
-                    'tags': {
+                    'fields': {
                         'send(){}/\\%*$-,;': 'sum', 
                         'policy_id': 1, 
                         'quanlity': 0.5
                     },
                     'fields': {'T_success_log': 1},
                     'timestamp': 1694657637836}
-        tags = self.prom._PrometheusExporter__escape_metric_tags(json_obj)
+        fields = self.prom._PrometheusExporter__escape_metric_tags(json_obj)
 
-        self.assertEqual(tags, "send____________=\"sum\",policy_id=\"1\",quanlity=\"0.5\",app_name=\"-\"")
+        self.assertEqual(fields, "send____________=\"sum\",policy_id=\"1\",quanlity=\"0.5\",app_name=\"-\"")
 
     def test__build_type_counter(self):
         name  = "tsg_master_log"
-        tags  = "send_log=\"sum\",policy_id=\"1\",app_name=\"-\""
+        fields  = "send_log=\"sum\",policy_id=\"1\",app_name=\"-\""
         value = 100 
 
-        metric = self.prom._PrometheusExporter__build_type_counter(name, tags, value)
+        metric = self.prom._PrometheusExporter__build_type_counter(name, fields, value)
         self.assertEqual(metric, "tsg_master_log{send_log=\"sum\",policy_id=\"1\",app_name=\"-\"} 100\n")
 
 
     def test__build_histogram_format(self):
         c_hist = FieldstatAPI.libfieldstat.fieldstat_histogram_base64_decode(self.hist_val.encode('utf-8'))
         name   = "tsg_master_log"
-        tags   = "policy_id=\"1\",app_name=\"-\""
+        fields   = "policy_id=\"1\",app_name=\"-\""
         self.prom.hist_bins = [10,20,50,80,90,95,99]
 
-        metrics = self.prom._PrometheusExporter__build_histogram_format(name, tags, c_hist)
+        metrics = self.prom._PrometheusExporter__build_histogram_format(name, fields, c_hist)
 
         desired = "tsg_master_log_bucket{policy_id=\"1\",app_name=\"-\",le=\"10.00\"} 10\n"\
                   "tsg_master_log_bucket{policy_id=\"1\",app_name=\"-\",le=\"20.00\"} 20\n"\
@@ -94,10 +94,10 @@ class TestPrometheusExporter(unittest.TestCase):
     def test__build_summary_format(self):
         c_hist = FieldstatAPI.libfieldstat.fieldstat_histogram_base64_decode(self.hist_val.encode('utf-8'))
         name   = "tsg_master_log"
-        tags   = "policy_id=\"1\",app_name=\"-\""
+        fields   = "policy_id=\"1\",app_name=\"-\""
         self.prom.hist_bins = [0.1,0.2,0.5,0.8,0.9,0.95,0.99]
 
-        metrics = self.prom._PrometheusExporter__build_summary_format(name, tags, c_hist)
+        metrics = self.prom._PrometheusExporter__build_summary_format(name, fields, c_hist)
 
         desired = "tsg_master_log{policy_id=\"1\",app_name=\"-\",quantile=\"10.00%\"} 9\n" \
                   "tsg_master_log{policy_id=\"1\",app_name=\"-\",quantile=\"20.00%\"} 19\n"\
@@ -111,13 +111,13 @@ class TestPrometheusExporter(unittest.TestCase):
 
     def test__build_type_histogram(self):
         name  = "tsg_master_log"
-        tags  = "policy_id=\"1\",app_name=\"-\""
+        fields  = "policy_id=\"1\",app_name=\"-\""
         value = self.hist_val
 
         self.prom.hist_bins   = [0.1,0.2,0.5,0.8,0.9,0.95,0.99]
         self.prom.hist_format = "summary"
         
-        metrics = self.prom._PrometheusExporter__build_type_histogram(name, tags, value)
+        metrics = self.prom._PrometheusExporter__build_type_histogram(name, fields, value)
         
         desired = "tsg_master_log{policy_id=\"1\",app_name=\"-\",quantile=\"10.00%\"} 9\n" \
                   "tsg_master_log{policy_id=\"1\",app_name=\"-\",quantile=\"20.00%\"} 19\n"\
@@ -133,7 +133,7 @@ class TestPrometheusExporter(unittest.TestCase):
         self.prom.hist_bins   = [10,20,50,80,90,95,99]
         self.prom.hist_format = "histogram"
         
-        metrics = self.prom._PrometheusExporter__build_type_histogram(name, tags, value)
+        metrics = self.prom._PrometheusExporter__build_type_histogram(name, fields, value)
 
         desired = "tsg_master_log_bucket{policy_id=\"1\",app_name=\"-\",le=\"10.00\"} 10\n"\
                   "tsg_master_log_bucket{policy_id=\"1\",app_name=\"-\",le=\"20.00\"} 20\n"\
@@ -149,10 +149,10 @@ class TestPrometheusExporter(unittest.TestCase):
 
     def test__build_type_hll(self):
         name  = "tsg_master_log"
-        tags  = "policy_id=\"1\",app_name=\"-\""
+        fields  = "policy_id=\"1\",app_name=\"-\""
         value = "AQUBDECDAQxAQQUIIEEJCDCFARgQRAUIMIMAAAECAAAAAAAAAA=="
         
-        metric = self.prom._PrometheusExporter__build_type_hll(name, tags, value)
+        metric = self.prom._PrometheusExporter__build_type_hll(name, fields, value)
 
         self.assertEqual(metric, "tsg_master_log{policy_id=\"1\",app_name=\"-\"} 93.61\n")
 
@@ -164,7 +164,7 @@ class TestPrometheusExporter(unittest.TestCase):
                             "policy_id": 1,
                             "quanlity": 0.50
                         },
-                        "fields": {
+                        "tags": {
                             "T_success_log": 1
                         },
                         "fields_delta": {
@@ -180,7 +180,7 @@ class TestPrometheusExporter(unittest.TestCase):
                     "tags": {
                         "rule_id": 1
                     },
-                    "fields": {
+                    "tags": {
                         "external_ip": "AQUBDECDAQxAQQUIIEEJCDCFARgQRAUIMIMAAAECAAAAAAAAAA==",
                     },
                     "timestamp_ms": 100010,
@@ -196,7 +196,7 @@ class TestPrometheusExporter(unittest.TestCase):
                          "rule_id": 1,
                          "action": "deny"
                      },
-                     "fields": {
+                     "tags": {
                          "list_num": "HISTEwAAAGQAAAAAAAAAAwAAAAAAAAABAAAAAAAJJ8A/8AAAAAAAAAEEAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAAAAAAAAA"
                      },
                      "timestamp_ms": 100010,
@@ -273,26 +273,26 @@ class TestCounterTable(unittest.TestCase):
     #     self.c_table.field_names = []
 
     #     table = self.c_table.create_row_table({"column0": 0, "column1": 1})
-    #     tags  = {"row": "0"}
+    #     fields  = {"row": "0"}
     #     field = {"column0": 0, "column1":1}
-    #     self.c_table.add_row_table_row(None,  tags, field)
+    #     self.c_table.add_row_table_row(None,  fields, field)
 
     #     table_str = table.get_string()
     #     row_count = len(table_str.split("\n")) - 1
     #     self.assertEqual(row_count, 0)
         
-    #     self.c_table.add_row_table_row(table, tags, field)
+    #     self.c_table.add_row_table_row(table, fields, field)
     #     row_count = len(table_str.split("\n")) - 1
     #     self.assertEqual(row_count, 0)
 
     def test_add_table_column(self):
         head    = "policy_hit"
-        tags    = "{\"thread_id\": 1,\"action\": \"deny\"}"
+        fields    = "{\"thread_id\": 1,\"action\": \"deny\"}"
         value   = 100
         speed_s = 1.1
         
         self.c_table.columns = []
-        self.c_table.add_table_column(tags, head, value, speed_s)
+        self.c_table.add_table_column(fields, head, value, speed_s)
 
         self.assertEqual(len(self.c_table.columns), 1)
         self.assertEqual(self.c_table.read_columns_num(), 1)
@@ -408,16 +408,16 @@ class TestHistogramTable(unittest.TestCase):
 
 
     def test_build_table(self):
-        tags = "{\"thread_id\": 1}"
+        fields = "{\"thread_id\": 1}"
         key  = "hit_policy"
-        self.h_table.build_table(tags, key, self.hist_val, self.hist_val, 1000)
+        self.h_table.build_table(fields, key, self.hist_val, self.hist_val, 1000)
         table_str = self.h_table.tables[-1].get_string()
         row_count = len(table_str.split("\n"))
         self.assertEqual(row_count, 7)
 
 
     def test_build_table(self):
-        tags  = "{\"thread_id\": 1,\"action\": \"deny\"}"
+        fields  = "{\"thread_id\": 1,\"action\": \"deny\"}"
         key   = "policy_hit"
         self.h_table.format = "summary"
 
@@ -426,7 +426,7 @@ class TestHistogramTable(unittest.TestCase):
             self.h_table.bins = []
             for i in range(1, n_bins + 1):
                 self.h_table.bins.append(i * 0.01)
-            self.h_table.build_table(tags, key, self.hist_val, self.hist_val, 1000)
+            self.h_table.build_table(fields, key, self.hist_val, self.hist_val, 1000)
             table = self.h_table.tables[-1]
             self.assertEqual(len(table.field_names), n_bins + 6)
             table_str = self.h_table.tables[-1].get_string()
@@ -435,7 +435,7 @@ class TestHistogramTable(unittest.TestCase):
 
 
     def test_print_tables(self):
-        tags  = "{\"thread_id\": 1,\"action\": \"deny\"}"
+        fields  = "{\"thread_id\": 1,\"action\": \"deny\"}"
         key   = "policy_hit"
         value = self.hist_val
 
@@ -443,7 +443,7 @@ class TestHistogramTable(unittest.TestCase):
             n_operate = random.randint(1, 100)
             self.h_table.tables = []
             for _ in range (n_operate):
-                self.h_table.build_table(tags, key, self.hist_val, None, 1000)
+                self.h_table.build_table(fields, key, self.hist_val, None, 1000)
             
             output     = StringIO()
             sys.stdout = output
@@ -463,7 +463,7 @@ class TestHistogramTable(unittest.TestCase):
 class TestLocalExporter(unittest.TestCase):
     def setUp(self):
         self.local    = LocalExporter()
-        self.tags     = "{\"thread_id\": 1,\"action\": \"deny\"}"
+        self.fields     = "{\"thread_id\": 1,\"action\": \"deny\"}"
         self.key      = "policy_hit"
 
 
@@ -471,7 +471,7 @@ class TestLocalExporter(unittest.TestCase):
                                      "tags": {
                                          "send_log": "sum"
                                      },
-                                     "fields": {
+                                     "tags": {
                                          "T_fail_log": 2
                                      },
                                      "fields_delta": {
@@ -485,7 +485,7 @@ class TestLocalExporter(unittest.TestCase):
                                      "tags": {
                                          "rule_id": 1
                                      },
-                                     "fields": {
+                                     "tags": {
                                          "acc_ip": "AQUFEGDCAhAwhAMMIQQBBBCDBRBggQMEMIcAAADCAAAAAAAAAA=="
                                      },
                                      "timestamp_ms": 100010,
@@ -497,7 +497,7 @@ class TestLocalExporter(unittest.TestCase):
                                      "tags": {
                                          "action": "deny"
                                      },
-                                     "fields": {
+                                     "tags": {
                                          "list_num": "HISTEwAAAGQAAAAAAAAAAwAAAAAAAAABAAAAAAAJJ8A/8AAAAAAA"\
                                                      "AAEEAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC"\
                                                      "AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC"\
@@ -532,7 +532,7 @@ class TestLocalExporter(unittest.TestCase):
             val_delta  = random.randint(10, 20)
             tsms_delta = random.randint(1, 10) * 1000
             self.local.ctable = CounterTable()
-            self.local._LocalExporter__build_counter_type_exporter(self.tags, self.key, val, val_delta, tsms_delta)
+            self.local._LocalExporter__build_counter_type_exporter(self.fields, self.key, val, val_delta, tsms_delta)
             self.assertEqual(self.local.ctable.columns[-1][1][1], str(val))
             self.assertEqual(self.local.ctable.columns[-1][1][2],  "{:.2f}".format(val_delta*1000/tsms_delta))
 
@@ -544,7 +544,7 @@ class TestLocalExporter(unittest.TestCase):
                    "CAgICAgICAgICAgICAgICAgICAgIAAAAAAAAA"
         self.local.htable = HistogramTable()
         peradd   = len(self.local.htable.tables)
-        self.local._LocalExporter__build_histogram_type_exporter(self.tags, self.key, hist_val, None, 0)
+        self.local._LocalExporter__build_histogram_type_exporter(self.fields, self.key, hist_val, None, 0)
         postadd  = len(self.local.htable.tables)
         self.assertEqual(postadd - peradd, 1)
 
@@ -553,36 +553,36 @@ class TestLocalExporter(unittest.TestCase):
         value   = "AQUBDECDAQxAQQUIIEEJCDCFARgQRAUIMIMAAAECAAAAAAAAAA=="
         self.local.hlltable = CounterTable()
         peradd  = len(self.local.hlltable.columns)
-        self.local._LocalExporter__build_hll_type_exporter(self.tags, self.key, value)
+        self.local._LocalExporter__build_hll_type_exporter(self.fields, self.key, value)
         postadd = len(self.local.hlltable.columns)
         
         self.assertEqual(postadd - peradd, 1)
 
 
     def test__append_app_name_to_tags(self):
-        tags = self.local._LocalExporter__append_app_name_to_tags(self.counter_json_object)       
-        self.assertEqual(tags, "{\"send_log\": \"sum\", \"app_name\": \"-\"}")
+        fields = self.local._LocalExporter__append_app_name_to_tags(self.counter_json_object)       
+        self.assertEqual(fields, "{\"send_log\": \"sum\", \"app_name\": \"-\"}")
 
 
     def test__is_tags_matched(self):
         self.local.match_tags = {}
-        tags = {"action": "deny", "policy_id": 0, "hit_rate": 1.1}
-        ret = self.local._LocalExporter__is_tags_matched(tags)
+        fields = {"action": "deny", "policy_id": 0, "hit_rate": 1.1}
+        ret = self.local._LocalExporter__is_tags_matched(fields)
         self.assertEqual(ret, True)
 
         self.local.match_tags = {"action": "deny"}
-        tags = {}
-        ret = self.local._LocalExporter__is_tags_matched(tags)
+        fields = {}
+        ret = self.local._LocalExporter__is_tags_matched(fields)
         self.assertEqual(ret, False)
 
         self.local.match_tags = {"action": "deny", "policy_id": 0, "hit_rate": 1.1}
-        tags = {"action": "deny"}
-        ret = self.local._LocalExporter__is_tags_matched(tags)
+        fields = {"action": "deny"}
+        ret = self.local._LocalExporter__is_tags_matched(fields)
         self.assertEqual(ret, False)
 
         self.local.match_tags = {"action": "deny", "policy_id": 0, "hit_rate": 1.10}
-        tags = {"action": "deny", "policy_id": 0, "hit_rate": 1.1}
-        ret = self.local._LocalExporter__is_tags_matched(tags)
+        fields = {"action": "deny", "policy_id": 0, "hit_rate": 1.1}
+        ret = self.local._LocalExporter__is_tags_matched(fields)
         self.assertEqual(ret, True)
 
 
@@ -591,7 +591,7 @@ class TestLocalExporter(unittest.TestCase):
                         "tags": {
                             "send_log": "sum"
                         },
-                        "fields": {
+                        "tags": {
                             "T_fail_log": 2
                         },
                         "fields_delta": {
@@ -604,7 +604,7 @@ class TestLocalExporter(unittest.TestCase):
                         "tags": {
                             "send_log": "firewall"
                         },
-                        "fields": {
+                        "tags": {
                             "T_fail_log": 2
                         },
                         "fields_delta": {
@@ -684,7 +684,7 @@ class TestFieldstatExporter(unittest.TestCase):
         self.assertEqual(args.loop,         False)
         self.assertEqual(args.clear_screen, False)
 
-        args = parser.parse_args(["local", "--loop", "--clear-screen", "-i", "1000", "--display-hist", "--display-hll", "--display-counter", "--match-tags", "policy:1,rule:1"])
+        args = parser.parse_args(["local", "--loop", "--clear-screen", "-i", "1000", "--display-hist", "--display-hll", "--display-counter", "--match-fields", "policy:1,rule:1"])
         self.assertEqual(args.interval,        1000)
         self.assertEqual(args.loop,            True)
         self.assertEqual(args.clear_screen,    True)
@@ -701,8 +701,8 @@ class TestFieldstatExporter(unittest.TestCase):
         
     def test_parse_tags_str(self):
         tags_str = "policy:1,rule:intercept"
-        tags     = self.exporter._FieldstatExporter__parse_tags_str(tags_str)
-        self.assertEqual(tags, {'policy': 1, 'rule': 'intercept'})
+        fields     = self.exporter._FieldstatExporter__parse_tags_str(tags_str)
+        self.assertEqual(fields, {'policy': 1, 'rule': 'intercept'})
 
     def test_read_shared_args_value(self):
         parser = self.exporter._FieldstatExporter__build_shared_args_parser()
diff --git a/test/test_fuzz_test.cpp b/test/test_fuzz_test.cpp
index bcf0d20..38f68bc 100644
--- a/test/test_fuzz_test.cpp
+++ b/test/test_fuzz_test.cpp
@@ -10,7 +10,7 @@
 
 using namespace std;
 
-void fill_random_tag_of_length_1_to_3(Fieldstat_tag_list_wrapper *tags[], int tag_list_num)
+void fill_random_tag_of_length_1_to_3(Fieldstat_tag_list_wrapper *fields[], int tag_list_num)
 {
     std::uniform_int_distribution<int> dist(1,100);
     std::mt19937 rng();
@@ -19,11 +19,11 @@ void fill_random_tag_of_length_1_to_3(Fieldstat_tag_list_wrapper *tags[], int ta
     {
         Fieldstat_tag_list_wrapper *tmp = new Fieldstat_tag_list_wrapper(dist, rand() % 3 + 1);
         tmp->sort_tag_list();
-        tags[i] = tmp;
+        fields[i] = tmp;
     }
 }
 
-void fill_with_elephant_flows(Fieldstat_tag_list_wrapper *tags[], int tag_list_num)
+void fill_with_elephant_flows(Fieldstat_tag_list_wrapper *fields[], int tag_list_num)
 {
     for (int i = 0; i < tag_list_num; i++)
     {
@@ -36,11 +36,11 @@ void fill_with_elephant_flows(Fieldstat_tag_list_wrapper *tags[], int tag_list_n
         } else {
             tmp = new Fieldstat_tag_list_wrapper("mouse", rand() % 10000);
         }
-        tags[i] = tmp;
+        fields[i] = tmp;
     }
 }
 
-long long fuzz_fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tag_list)
+long long fuzz_fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct field_list *tag_list)
 {
     long long value = 0;
     int ret = fieldstat_counter_get(instance, cube_id, tag_list, metric_id, &value);
@@ -48,7 +48,7 @@ long long fuzz_fieldstat_counter_get(const struct fieldstat *instance, int cube_
     return value;
 }
 
-double fuzz_fieldstat_hll_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tag_list)
+double fuzz_fieldstat_hll_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct field_list *tag_list)
 {
     double value = 0;
     int ret = fieldstat_hll_get(instance, cube_id, tag_list, metric_id, &value);
@@ -83,7 +83,7 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
     // init metric
     fieldstat_register_counter(master, metric_name[METRIC_ID_COUNTER]);
     fieldstat_register_hll(master, metric_name[METRIC_ID_HLL], 6);
-    // all the possible tags
+    // all the possible fields
     Fieldstat_tag_list_wrapper *tag_list_wrapper[FLOW_NUM];
     fill_random_tag_of_length_1_to_3(tag_list_wrapper, FLOW_NUM);
     //all the possible operations
@@ -133,19 +133,19 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
             }
         }
         struct fieldstat *instance = replica[rand() % INSTANCE_NUM]; // the flow randomly goes to one of the instance
-        const Fieldstat_tag_list_wrapper * tag = tag_list_wrapper[rand() % FLOW_NUM];
+        const Fieldstat_tag_list_wrapper * field = tag_list_wrapper[rand() % FLOW_NUM];
         int cube_id = rand() % CUBE_NUM;
         const Fieldstat_tag_list_wrapper *shared_tag = shared_tags[cube_id];
 
-        int ret_add = fieldstat_counter_incrby(instance, cube_id, METRIC_ID_COUNTER, tag->get_tag(), tag->get_tag_count(), rand_nums[i]);
+        int ret_add = fieldstat_counter_incrby(instance, cube_id, METRIC_ID_COUNTER, field->get_tag(), field->get_tag_count(), rand_nums[i]);
         if (ret_add == FS_ERR_TOO_MANY_CELLS) {
             continue;
         }
         EXPECT_EQ(ret_add, FS_OK);
         string *val = rand_strs[i];
-        ret_add = fieldstat_hll_add(instance, cube_id, METRIC_ID_HLL, tag->get_tag(), tag->get_tag_count(), val->c_str(), val->size());
+        ret_add = fieldstat_hll_add(instance, cube_id, METRIC_ID_HLL, field->get_tag(), field->get_tag_count(), val->c_str(), val->size());
         EXPECT_EQ(ret_add, FS_OK);
-        string cell_key = shared_tag->to_string() + tag->to_string();
+        string cell_key = shared_tag->to_string() + field->to_string();
         comp_count[cell_key] += rand_nums[i];
         comp_hll[cell_key].insert(*val);
     }
@@ -170,10 +170,10 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
     struct fieldstat *instance_in_focus = dest;
     fieldstat_get_cubes(instance_in_focus, &cube_ids, &cube_num);
     for (int i = 0; i < cube_num; i++) {
-        struct fieldstat_tag_list *shared_tag_out = fieldstat_cube_get_tags(instance_in_focus, cube_ids[i]);
+        struct field_list *shared_tag_out = fieldstat_cube_get_tags(instance_in_focus, cube_ids[i]);
 
         size_t cell_num0;
-        struct fieldstat_tag_list *tags0;
+        struct field_list *tags0;
         fieldstat_cube_get_cells(instance_in_focus, cube_ids[i], &tags0, &cell_num0);
 
         for (size_t j = 0; j < cell_num0; j++) {
@@ -222,7 +222,7 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
     }
     // init metric
     fieldstat_register_counter(master, "topk");
-    // all the possible tags
+    // all the possible fields
     Fieldstat_tag_list_wrapper *tag_list_wrapper[FLOW_NUM];
     fill_with_elephant_flows(tag_list_wrapper, FLOW_NUM);
     //all the possible operations
@@ -235,7 +235,7 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
         replica[i] = fieldstat_fork(master);
     }
     // for benchmark
-    unordered_map<string, unordered_map<string, int>> count_map; // hte first key is shared tag, second key is tag
+    unordered_map<string, unordered_map<string, int>> count_map; // hte first key is shared field, second key is field
 
     clock_t start = clock();
     int next_shared_tag_value = CUBE_NUM;
@@ -269,16 +269,16 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
             }
         }
         struct fieldstat *instance = replica[rand() % INSTANCE_NUM]; // the flow randomly goes to one of the instance
-        const Fieldstat_tag_list_wrapper * tag = tag_list_wrapper[rand() % FLOW_NUM];
+        const Fieldstat_tag_list_wrapper * field = tag_list_wrapper[rand() % FLOW_NUM];
         int cube_id = rand() % CUBE_NUM;
         const Fieldstat_tag_list_wrapper *shared_tag = shared_tags[cube_id];
 
-        int ret_add = fieldstat_counter_incrby(instance, cube_id, 0, tag->get_tag(), tag->get_tag_count(), rand_nums[i]);
+        int ret_add = fieldstat_counter_incrby(instance, cube_id, 0, field->get_tag(), field->get_tag_count(), rand_nums[i]);
         if (ret_add == FS_ERR_TOO_MANY_CELLS) {
             continue;
         }
         EXPECT_EQ(ret_add, FS_OK);
-        count_map[shared_tag->to_string()][tag->to_string()] += rand_nums[i];
+        count_map[shared_tag->to_string()][field->to_string()] += rand_nums[i];
     }
 
     clock_t end = clock();
@@ -296,15 +296,15 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
     struct fieldstat *instance_in_focus = dest;
     fieldstat_get_cubes(instance_in_focus, &cube_ids, &cube_num);
     for (int i = 0; i < cube_num; i++) {
-        struct fieldstat_tag_list *shared_tag_out = fieldstat_cube_get_tags(instance_in_focus, cube_ids[i]);
+        struct field_list *shared_tag_out = fieldstat_cube_get_tags(instance_in_focus, cube_ids[i]);
 
         size_t cell_num;
-        struct fieldstat_tag_list *tags;
-        fieldstat_cube_get_cells(instance_in_focus, cube_ids[i], &tags, &cell_num);
+        struct field_list *fields;
+        fieldstat_cube_get_cells(instance_in_focus, cube_ids[i], &fields, &cell_num);
 
         std::vector<struct Fieldstat_tag_list_wrapper *> test_result;
         for (size_t j = 0; j < cell_num; j++) {
-            test_result.push_back(new Fieldstat_tag_list_wrapper(&tags[j]));
+            test_result.push_back(new Fieldstat_tag_list_wrapper(&fields[j]));
         }
 
         double accuracy = test_cal_topk_accuracy(test_result, count_map[Fieldstat_tag_list_wrapper(shared_tag_out).to_string()]);
@@ -315,7 +315,7 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
             delete test_result[j];
         }
 
-        fieldstat_tag_list_arr_free(tags, cell_num);
+        fieldstat_tag_list_arr_free(fields, cell_num);
         fieldstat_tag_list_arr_free(shared_tag_out, 1);
     }
     free(cube_ids);
@@ -341,23 +341,23 @@ TEST(Fuzz_test, add_and_reset_with_randomly_generated_flows_and_randomly_chosen_
     fieldstat_counter_incrby(instance, cube_id, primary_metric_id, tag_list_wrapper[0]->get_tag(), tag_list_wrapper[0]->get_tag_count(), 1);
     fieldstat_counter_incrby(instance, cube_id, counter2_id, tag_list_wrapper[0]->get_tag(), tag_list_wrapper[0]->get_tag_count(), 1);
 
-    struct fieldstat_tag_list tag_list_tmp = {NULL, 0};
+    struct field_list tag_list_tmp = {NULL, 0};
 
     for(int i = 0; i < FLOW_NUM; i++) {
         int using_id = rand() % 2 == 0 ? primary_metric_id : counter2_id;
 
         int ret = fieldstat_counter_incrby(instance, cube_id, using_id, tag_list_wrapper[i]->get_tag(), tag_list_wrapper[i]->get_tag_count(), 1);
         if (ret == FS_ERR_TOO_MANY_CELLS) {
-            struct fieldstat_tag_list *tag_list = NULL;
+            struct field_list *tag_list = NULL;
             size_t n_cell = 0;
             fieldstat_cube_get_cells(instance, cube_id, &tag_list, &n_cell);
             ASSERT_EQ(n_cell, 1);
 
             long long value;
-            tag_list_tmp.tag = (struct fieldstat_tag *)tag_list_wrapper[i]->get_tag();
-            tag_list_tmp.n_tag = tag_list_wrapper[i]->get_tag_count();
+            tag_list_tmp.field = (struct field *)tag_list_wrapper[i]->get_tag();
+            tag_list_tmp.n_field = tag_list_wrapper[i]->get_tag_count();
             int counter_exist = fieldstat_counter_get(instance, cube_id, &tag_list_tmp, using_id,  &value);
-            ASSERT_EQ(counter_exist, FS_ERR_INVALID_TAG); // the tag is not added to the cube
+            ASSERT_EQ(counter_exist, FS_ERR_INVALID_TAG); // the field is not added to the cube
             fieldstat_tag_list_arr_free(tag_list, n_cell);
         }
 
@@ -391,7 +391,7 @@ TEST(Fuzz_test, simple_one_for_perf)
     }
     // init metric
     fieldstat_register_counter(master, "topk");
-    // all the possible tags
+    // all the possible fields
     Fieldstat_tag_list_wrapper *tag_list_wrapper[FLOW_NUM];
     fill_with_elephant_flows(tag_list_wrapper, FLOW_NUM);
     //all the possible operations
@@ -408,10 +408,10 @@ TEST(Fuzz_test, simple_one_for_perf)
 
     for (int i = 0; i < TEST_ROUND; i++) {
         
-        const Fieldstat_tag_list_wrapper * tag = tag_list_wrapper[rand() % FLOW_NUM];
+        const Fieldstat_tag_list_wrapper * field = tag_list_wrapper[rand() % FLOW_NUM];
         int cube_id = rand() % CUBE_NUM;
 
-        (void)fieldstat_counter_incrby(instance, cube_id, 0, tag->get_tag(), tag->get_tag_count(), rand_nums[i]);
+        (void)fieldstat_counter_incrby(instance, cube_id, 0, field->get_tag(), field->get_tag_count(), rand_nums[i]);
     }
 
     clock_t end = clock();
diff --git a/test/test_merge.cpp b/test/test_merge.cpp
index cf37bc7..e51b90d 100644
--- a/test/test_merge.cpp
+++ b/test/test_merge.cpp
@@ -31,7 +31,7 @@ double test_cal_accuracy_given_expected_key(vector<struct Fieldstat_tag_list_wra
     return test_cal_topk_accuracy(test_result, countMap);
 }
 
-long long merge_test_fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tag_list = &TEST_TAG_LIST_STRING)
+long long merge_test_fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct field_list *tag_list = &TEST_TAG_LIST_STRING)
 {
     long long ret = 0;
     fieldstat_counter_get(instance, cube_id, tag_list, metric_id, &ret);
@@ -156,12 +156,12 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_comprehensive)
     long long measure = merge_test_fieldstat_counter_get(instance, cube_id, metric_id);
     EXPECT_EQ(measure, 10086);
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance, cube_id, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
-    EXPECT_EQ(tag_list->n_tag, 1);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_STRING.key);
+    EXPECT_EQ(tag_list->n_field, 1);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_TAG_STRING.key);
 
     fieldstat_free(instance);
     fieldstat_free(instance_dest);
@@ -203,7 +203,7 @@ TEST(unit_test_merge, new_too_many_cells_on_one_metric_given_source_cube_reset_a
 
     fieldstat_merge(instance_dest, instance);
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance_dest, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 2);
@@ -291,12 +291,12 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_topk)
     long long measure = merge_test_fieldstat_counter_get(instance, cube_id, metric_id);
     EXPECT_EQ(measure, 10086);
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance, cube_id, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
-    EXPECT_EQ(tag_list->n_tag, 1);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_STRING.key);
+    EXPECT_EQ(tag_list->n_field, 1);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_TAG_STRING.key);
 
     fieldstat_free(instance);
     fieldstat_free(instance_dest);
@@ -322,7 +322,7 @@ TEST(unit_test_merge, merge_existing_cell_on_existing_cube_and_metric_topk)
     free(cube_id_dest);
     EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, 0), "metric_name");
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance_dest, ret_cube_id, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
@@ -350,7 +350,7 @@ TEST(unit_test_merge, new_too_many_cells_on_one_metric_given_source_cube_reset_a
 
     fieldstat_merge(instance_dest, instance);
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance_dest, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 2);
@@ -382,7 +382,7 @@ TEST(unit_test_merge, merge_accuracy_test_with_K_large_enough_topk)
     struct fieldstat *instance_dest = test_push_flows(flows_in_dest, K);
     fieldstat_merge(instance_dest, instance_src);
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance_dest, 0, &tag_list, &n_cell);
 
@@ -420,7 +420,7 @@ TEST(unit_test_merge, merge_accuracy_test_gen_dest_full_all_inserted_given_src_f
 
     fieldstat_merge(instance_dest, instance_src);
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance_dest, 0, &tag_list, &n_cell);
     vector<Fieldstat_tag_list_wrapper *> flows_in_merged;
@@ -453,7 +453,7 @@ TEST(unit_test_merge, merge_accuracy_test_gen_dest_full_some_inserted_and_some_m
     struct fieldstat *instance_dest = test_push_flows(flows_in_dest, K);
     fieldstat_merge(instance_dest, instance_src);
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance_dest, 0, &tag_list, &n_cell);
     vector<Fieldstat_tag_list_wrapper *> flows_in_merged;
@@ -488,11 +488,11 @@ TEST(unit_test_merge, primary_metric_has_no_value)
     fieldstat_merge(instance_dest, instance);
     fieldstat_merge(instance_dest, instance);
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance_dest, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
-    EXPECT_STREQ(tag_list[0].tag[0].key, TEST_TAG_STRING.key);
+    EXPECT_STREQ(tag_list[0].field[0].key, TEST_TAG_STRING.key);
 
     EXPECT_EQ(merge_test_fieldstat_counter_get(instance_dest, 0, metric_operated, &tag_list[0]), 2);
     EXPECT_EQ(merge_test_fieldstat_counter_get(instance_dest, 0, metric_primary, &tag_list[0]), 0);
diff --git a/test/test_metric_counter.cpp b/test/test_metric_counter.cpp
index d5d2d5c..675c42f 100644
--- a/test/test_metric_counter.cpp
+++ b/test/test_metric_counter.cpp
@@ -19,7 +19,7 @@ struct fieldstat *test_init_standard_instance()
     return instance;
 }
 
-long long my_fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag_list *tag_list = &TEST_TAG_LIST_INT)
+long long my_fieldstat_counter_get(const struct fieldstat *instance, int cube_id, int metric_id, const struct field_list *tag_list = &TEST_TAG_LIST_INT)
 {
     long long ret = 0;
     fieldstat_counter_get(instance, cube_id, tag_list, metric_id,  &ret);
@@ -38,12 +38,12 @@ void test_assert_standard_instance(const struct fieldstat *instance)
     const char *name = fieldstat_get_metric_name(instance, 0);
     EXPECT_STREQ(name, "czz_test counter metric");
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
-    EXPECT_EQ(tag_list->n_tag, 1);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_INT.key);
+    EXPECT_EQ(tag_list->n_field, 1);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_TAG_INT.key);
 
     int *metric_id = NULL;
     size_t n_metric = 0;
@@ -114,7 +114,7 @@ TEST(metric_test_counter, topk_add_and_test_accuracy)
     fieldstat_register_counter(instance, "test");
 
     int tag_list_num = 10000;
-    Fieldstat_tag_list_wrapper *tags[tag_list_num];
+    Fieldstat_tag_list_wrapper *fields[tag_list_num];
     map<string, int> flow_cnt;
     for (int i = 0; i < tag_list_num; i++)
     {   
@@ -127,16 +127,16 @@ TEST(metric_test_counter, topk_add_and_test_accuracy)
             flow_k = "mouse";
             flow_v = std::to_string(rand() % 1000);
         }
-        tags[i] = new Fieldstat_tag_list_wrapper(flow_k, flow_v.c_str());
+        fields[i] = new Fieldstat_tag_list_wrapper(flow_k, flow_v.c_str());
 
         flow_cnt[flow_k + flow_v]++;
     }
 
     for (int i = 0; i < tag_list_num; i++) {
-        fieldstat_counter_incrby(instance, 0, 0, tags[i]->get_tag(), tags[i]->get_tag_count(), 1);
+        fieldstat_counter_incrby(instance, 0, 0, fields[i]->get_tag(), fields[i]->get_tag_count(), 1);
     }
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 10);
@@ -159,7 +159,7 @@ TEST(metric_test_counter, topk_add_and_test_accuracy)
     fieldstat_free(instance);
 
     for (int i = 0; i < tag_list_num; i++)
-        delete tags[i];
+        delete fields[i];
 }
 
 TEST(metric_test_counter, add_with_wrong_cube_id_expecting_fail)
@@ -230,15 +230,15 @@ TEST(metric_test_counter, primary_counter_add_after_first)
     EXPECT_EQ(my_fieldstat_counter_get(instance, cube_id, metric_id2), 10);
 
     // TOPK functions well
-    struct fieldstat_tag tag = TEST_TAG_INT;
+    struct field field = TEST_TAG_INT;
     for (int i = 0; i < 9; i++) {
-        tag.value_longlong = i + 123;
-        ret = fieldstat_counter_incrby(instance, cube_id, metric_id_primary, &tag, 1, 1 + i);
+        field.value_longlong = i + 123;
+        ret = fieldstat_counter_incrby(instance, cube_id, metric_id_primary, &field, 1, 1 + i);
         EXPECT_EQ(ret, FS_OK);
     }
     // now the TOPK is full, add a new one
-    tag.value_longlong = 321;
-    ret = fieldstat_counter_incrby(instance, cube_id, metric_id_primary, &tag, 1, 1);
+    field.value_longlong = 321;
+    ret = fieldstat_counter_incrby(instance, cube_id, metric_id_primary, &field, 1, 1);
     EXPECT_EQ(ret, FS_ERR_TOO_MANY_CELLS);
 
     fieldstat_free(instance);
diff --git a/test/test_metric_histogram.cpp b/test/test_metric_histogram.cpp
index 4faf9fc..06fdd17 100644
--- a/test/test_metric_histogram.cpp
+++ b/test/test_metric_histogram.cpp
@@ -31,12 +31,12 @@ void test_assert_standard_instance(const struct fieldstat *instance)
     EXPECT_STREQ(name, "czz_test hdr metric");
 
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
-    EXPECT_EQ(tag_list->n_tag, 1);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_STRING.key);
+    EXPECT_EQ(tag_list->n_field, 1);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_TAG_STRING.key);
 
     int *metric_id = NULL;
     size_t n_metric = 0;
diff --git a/test/test_metric_hll.cpp b/test/test_metric_hll.cpp
index 3a4cbe1..8e96266 100644
--- a/test/test_metric_hll.cpp
+++ b/test/test_metric_hll.cpp
@@ -26,12 +26,12 @@ void test_assert_standard_instance(const struct fieldstat *instance)
     const char *name = fieldstat_get_metric_name(instance, 0);
     EXPECT_STREQ(name, "czz_test hll metric");
 
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     size_t n_cell = 0;
     fieldstat_cube_get_cells(instance, 0, &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 1);
-    EXPECT_EQ(tag_list->n_tag, 1);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_INT.key);
+    EXPECT_EQ(tag_list->n_field, 1);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_TAG_INT.key);
     
     int *metric_id = NULL;
     size_t n_metric = 0;
@@ -67,9 +67,9 @@ TEST(metric_test_hll, simple_register_and_query)
 TEST(metric_test_hll, add_with_tags) {
     struct fieldstat *instance = test_init_standard_instance_one_cube_one_metric_one_cell_hll();
 
-    fieldstat_hll_add_tag(instance, 0, 0, &TEST_TAG_INT, 1, &TEST_TAG_INT, 1);
-    fieldstat_hll_add_tag(instance, 0, 0, &TEST_TAG_INT, 1, &TEST_TAG_DOUBLE, 1);
-    fieldstat_hll_add_tag(instance, 0, 0, &TEST_TAG_INT, 1, &TEST_TAG_STRING, 1);
+    fieldstat_hll_add_field(instance, 0, 0, &TEST_TAG_INT, 1, &TEST_TAG_INT, 1);
+    fieldstat_hll_add_field(instance, 0, 0, &TEST_TAG_INT, 1, &TEST_TAG_DOUBLE, 1);
+    fieldstat_hll_add_field(instance, 0, 0, &TEST_TAG_INT, 1, &TEST_TAG_STRING, 1);
     
     test_assert_standard_instance(instance);
     EXPECT_NEAR(my_fieldstat_hll_get(instance, 0, 0), 3, 0.5);
diff --git a/test/test_performance.cpp b/test/test_performance.cpp
index 11c05ce..5931a81 100644
--- a/test/test_performance.cpp
+++ b/test/test_performance.cpp
@@ -9,19 +9,19 @@
 // /* -------------------------------------------------------------------------- */
 // /*                                    merge                                   */
 // /* -------------------------------------------------------------------------- */
-double perform_merge_test(std::function<void (struct fieldstat*, int, int, const struct fieldstat_tag *, int)> metric_add_func, 
+double perform_merge_test(std::function<void (struct fieldstat*, int, int, const struct field *, int)> metric_add_func, 
     std::function<int(struct fieldstat*)> metric_register_func, enum sampling_mode mode, bool merge_empty_dest)
 {
     const int MAX_CELL_NUM = 1000;
-    Fieldstat_tag_list_wrapper *tags[MAX_CELL_NUM];
+    Fieldstat_tag_list_wrapper *fields[MAX_CELL_NUM];
     for (int i = 0; i < MAX_CELL_NUM; i++) {
-        tags[i] = new Fieldstat_tag_list_wrapper("my key", i);
+        fields[i] = new Fieldstat_tag_list_wrapper("my key", i);
     }
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, mode, MAX_CELL_NUM);
     int metric_id = metric_register_func(instance);
     for (int j = 0; j < MAX_CELL_NUM; j++) {
-        metric_add_func(instance, cube_id, metric_id, tags[j]->get_tag(), 1);
+        metric_add_func(instance, cube_id, metric_id, fields[j]->get_tag(), 1);
     }
 
     struct fieldstat *instance_dest = fieldstat_new();
@@ -36,7 +36,7 @@ double perform_merge_test(std::function<void (struct fieldstat*, int, int, const
     fieldstat_free(instance_dest);
     fieldstat_free(instance);
     for (int i = 0; i < MAX_CELL_NUM; i++) {
-        delete tags[i];
+        delete fields[i];
     }
 
     return (end - start) / 1000.0;
@@ -44,8 +44,8 @@ double perform_merge_test(std::function<void (struct fieldstat*, int, int, const
 
 TEST(test_performance, merge_performance_one_instance_comprehensive_counter_empty_dest)
 {   
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_counter_incrby(instance, cube_id, metric_id, tags, n_tag, 1);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_counter_incrby(instance, cube_id, metric_id, fields, n_field, 1);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
         return fieldstat_register_counter(instance, "metric name");
@@ -61,8 +61,8 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_hll_empty_de
     //     int metric_id = fieldstat_register_hll(instance, cube_id, "czz_test hll metric", 10);
     // int ret = fieldstat_hll_add(instance, cube_id, metric_id, cell_id, "hello", 5);
 
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_hll_add(instance, cube_id, metric_id, tags, n_tag, "hello", 5);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_hll_add(instance, cube_id, metric_id, fields, n_field, "hello", 5);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
         return fieldstat_register_hll(instance, "hll metric", 6);
@@ -78,8 +78,8 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_histogram_em
     // int metric_id = fieldstat_register_hist(instance, cube_id, "czz_test", 1, 100000, 1);
     // int ret = fieldstat_hist_record(instance, cube_id, metric_id, cell_id, 1234);
 
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_hist_record(instance, cube_id, metric_id, tags, n_tag, 1234);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_hist_record(instance, cube_id, metric_id, fields, n_field, 1234);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
         return fieldstat_register_hist(instance, "histogram metric", 1, 100000, 1);
@@ -92,8 +92,8 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_histogram_em
 
 TEST(test_performance, merge_performance_one_instance_topk_counter_empty_dest)
 {   
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_counter_incrby(instance, cube_id, metric_id, tags, n_tag, rand() % 1000);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_counter_incrby(instance, cube_id, metric_id, fields, n_field, rand() % 1000);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
         return fieldstat_register_counter(instance, "metric name");
@@ -106,8 +106,8 @@ TEST(test_performance, merge_performance_one_instance_topk_counter_empty_dest)
 
 TEST(test_performance, merge_performance_one_instance_comprehensive_counter_full_dest)
 {   
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_counter_incrby(instance, cube_id, metric_id, tags, n_tag, 1);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_counter_incrby(instance, cube_id, metric_id, fields, n_field, 1);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
         return fieldstat_register_counter(instance, "metric name");
@@ -120,8 +120,8 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_counter_full
 
 TEST(test_performance, merge_performance_one_instance_comprehensive_hll_full_dest)
 {   
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_hll_add(instance, cube_id, metric_id, tags, n_tag, "hello", 5);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_hll_add(instance, cube_id, metric_id, fields, n_field, "hello", 5);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
         return fieldstat_register_hll(instance, "hll metric", 6);
@@ -134,8 +134,8 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_hll_full_des
 
 TEST(test_performance, merge_performance_one_instance_comprehensive_histogram_full_dest)
 {   
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_hist_record(instance, cube_id, metric_id, tags, n_tag, 1234);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_hist_record(instance, cube_id, metric_id, fields, n_field, 1234);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
         return fieldstat_register_hist(instance, "histogram metric", 1, 100000, 1);
@@ -148,8 +148,8 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_histogram_fu
 
 TEST(test_performance, merge_performance_one_instance_topk_counter_full_dest)
 {   
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_counter_incrby(instance, cube_id, metric_id, tags, n_tag, rand() % 1000);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_counter_incrby(instance, cube_id, metric_id, fields, n_field, rand() % 1000);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
         return fieldstat_register_counter(instance, "metric name");
@@ -163,7 +163,7 @@ TEST(test_performance, merge_performance_one_instance_topk_counter_full_dest)
 struct fieldstat *construct_fs_with_many_empty_cubes(int cube_num, int metric_num, enum sampling_mode mode)
 {
     struct fieldstat *instance = fieldstat_new();
-    struct fieldstat_tag tmp_tag = TEST_TAG_INT;
+    struct field tmp_tag = TEST_TAG_INT;
     for (int i = 0; i < cube_num; i++) {
         tmp_tag.value_longlong = i;
         fieldstat_create_cube(instance, &tmp_tag, 1, mode, 1000);
@@ -215,10 +215,10 @@ TEST(test_performance, merge_empty_cubes_topk)
 TEST(test_performance, performance_test_add_cells_comprehensive)
 {
     size_t cell_count = 100000;
-    struct fieldstat_tag tags[cell_count];
+    struct field fields[cell_count];
     for (size_t i = 0; i < cell_count; i++) {
-        tags[i] = TEST_TAG_INT;
-        tags[i].value_longlong = i;
+        fields[i] = TEST_TAG_INT;
+        fields[i].value_longlong = i;
     }
     // getchar();
     struct fieldstat *instance = fieldstat_new();
@@ -227,7 +227,7 @@ TEST(test_performance, performance_test_add_cells_comprehensive)
 
     clock_t start = clock();
     for (size_t i = 0; i < cell_count; i++) {
-        fieldstat_counter_incrby(instance, 0, 0, &tags[i % cell_count], 1, 1);
+        fieldstat_counter_incrby(instance, 0, 0, &fields[i % cell_count], 1, 1);
     }
     clock_t end = clock();
     double seconds = (double)(end - start) / cell_count;
@@ -239,14 +239,14 @@ TEST(test_performance, performance_test_add_cells_comprehensive)
 TEST(test_performance, performance_test_add_cells_topk)
 {
     size_t cell_count = 100000;
-    struct fieldstat_tag tags[cell_count];
+    struct field fields[cell_count];
     for (size_t i = 0; i < cell_count; i++) {
-        tags[i] = TEST_TAG_INT;
-        // tags[i].value_longlong = rand() % 10000;
+        fields[i] = TEST_TAG_INT;
+        // fields[i].value_longlong = rand() % 10000;
         if (rand()%2)
-            tags[i].value_longlong = i;
+            fields[i].value_longlong = i;
         else
-            tags[i].value_longlong = rand() % 1000;
+            fields[i].value_longlong = rand() % 1000;
     }
     struct fieldstat *instance = fieldstat_new();
     fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 1000);
@@ -255,7 +255,7 @@ TEST(test_performance, performance_test_add_cells_topk)
     // getchar();
     clock_t start = clock();
     for (size_t i = 0; i < cell_count; i++) {
-        fieldstat_counter_incrby(instance, 0, 0, &tags[i % cell_count], 1, 1);
+        fieldstat_counter_incrby(instance, 0, 0, &fields[i % cell_count], 1, 1);
     }
     clock_t end = clock();
     double seconds = (double)(end - start) / cell_count;
@@ -313,18 +313,18 @@ TEST(test_performance, performance_test_add_cells_hll_add)
 TEST(test_performance, performance_test_add_cells_comprehensive_5_tags)
 {
     size_t cell_count = 100000;
-    struct fieldstat_tag *tag_v[cell_count];
+    struct field *tag_v[cell_count];
     for (size_t i = 0; i < cell_count; i++) {
-        struct fieldstat_tag *tags = (struct fieldstat_tag *)malloc(sizeof(struct fieldstat_tag) * 5);
+        struct field *fields = (struct field *)malloc(sizeof(struct field) * 5);
 
-        tags[0] = TEST_TAG_INT;
-        tags[1] = TEST_TAG_INT;
-        tags[2] = TEST_TAG_INT;
-        tags[3] = TEST_TAG_INT;
-        tags[4] = TEST_TAG_INT;
-        tags[0].value_longlong = i;
+        fields[0] = TEST_TAG_INT;
+        fields[1] = TEST_TAG_INT;
+        fields[2] = TEST_TAG_INT;
+        fields[3] = TEST_TAG_INT;
+        fields[4] = TEST_TAG_INT;
+        fields[0].value_longlong = i;
 
-        tag_v[i] = tags;
+        tag_v[i] = fields;
     }
     // getchar();
     struct fieldstat *instance = fieldstat_new();
@@ -337,7 +337,7 @@ TEST(test_performance, performance_test_add_cells_comprehensive_5_tags)
     }
     clock_t end = clock();
     double seconds = (double)(end - start) / cell_count;
-    printf("performance_test_add_cells_comprehensive time 5 tags cost: %f\n", seconds);
+    printf("performance_test_add_cells_comprehensive time 5 fields cost: %f\n", seconds);
     EXPECT_TRUE(seconds < 2);
     fieldstat_free(instance);
 
@@ -357,19 +357,19 @@ TEST(test_performance, performance_test_add_cells_histogram_record_5tags)
         vals[i] = rand() % 100000 + 1;
     }
 
-    struct fieldstat_tag tags[5];
-    tags[0] = TEST_TAG_INT;
-    tags[1] = TEST_TAG_STRING;
-    tags[2] = TEST_TAG_DOUBLE;
-    tags[3] = TEST_TAG_INT;
-    tags[4] = TEST_TAG_INT;
+    struct field fields[5];
+    fields[0] = TEST_TAG_INT;
+    fields[1] = TEST_TAG_STRING;
+    fields[2] = TEST_TAG_DOUBLE;
+    fields[3] = TEST_TAG_INT;
+    fields[4] = TEST_TAG_INT;
     clock_t start = clock();
     for (size_t i = 0; i < test_num; i++) {
-        fieldstat_hist_record(instance, 0, 0, tags, 5, vals[i]);
+        fieldstat_hist_record(instance, 0, 0, fields, 5, vals[i]);
     }
     clock_t end = clock();
     double seconds = (double)(end - start) / test_num;
-    printf("performance_test_add_cells_histogram_record time 5 tags cost: %f\n", seconds);
+    printf("performance_test_add_cells_histogram_record time 5 fields cost: %f\n", seconds);
     EXPECT_TRUE(seconds < 1);
     fieldstat_free(instance);
 }
@@ -385,19 +385,19 @@ TEST(test_performance, performance_test_add_cells_hll_add_5tags)
         vals[i] = std::to_string(rand() % 1000000 + 1);
     }
 
-    struct fieldstat_tag tags[5];
-    tags[0] = TEST_TAG_INT;
-    tags[1] = TEST_TAG_STRING;
-    tags[2] = TEST_TAG_DOUBLE;
-    tags[3] = TEST_TAG_INT;
-    tags[4] = TEST_TAG_INT;
+    struct field fields[5];
+    fields[0] = TEST_TAG_INT;
+    fields[1] = TEST_TAG_STRING;
+    fields[2] = TEST_TAG_DOUBLE;
+    fields[3] = TEST_TAG_INT;
+    fields[4] = TEST_TAG_INT;
     clock_t start = clock();
     for (size_t i = 0; i < test_num; i++) {
-        fieldstat_hll_add(instance, 0, 0, tags, 5, vals[i].c_str(), vals[i].length());
+        fieldstat_hll_add(instance, 0, 0, fields, 5, vals[i].c_str(), vals[i].length());
     }
     clock_t end = clock();
     double seconds = (double)(end - start) / test_num;
-    printf("performance_test_add_cells_hll_add time 5 tags cost: %f\n", seconds);
+    printf("performance_test_add_cells_hll_add time 5 fields cost: %f\n", seconds);
     EXPECT_TRUE(seconds < 1);
     fieldstat_free(instance);
 }
@@ -414,9 +414,9 @@ TEST(test_performance, export_many_cells)
     const int CUBE_NUM = 10;
     const int METRIC_NUM = 10;
 
-    Fieldstat_tag_list_wrapper *tags[TAG_NUM];
+    Fieldstat_tag_list_wrapper *fields[TAG_NUM];
     for (int i = 0; i < TAG_NUM; i++) {
-        tags[i] = new Fieldstat_tag_list_wrapper("my key", i);
+        fields[i] = new Fieldstat_tag_list_wrapper("my key", i);
     }
 
     struct fieldstat *instance = fieldstat_new();
@@ -429,7 +429,7 @@ TEST(test_performance, export_many_cells)
             int metric_id = fieldstat_register_counter(instance, metric_name.c_str());
 
             for (int k = 0; k < MAX_CELL_NUM; k++) {
-                fieldstat_counter_incrby(instance, cube_id, metric_id, tags[rand() % TAG_NUM]->get_tag(), 1, 1);
+                fieldstat_counter_incrby(instance, cube_id, metric_id, fields[rand() % TAG_NUM]->get_tag(), 1, 1);
             }
         }
     }
@@ -447,7 +447,7 @@ TEST(test_performance, export_many_cells)
     fieldstat_free(instance);
 
     for (int i = 0; i < TAG_NUM; i++) {
-        delete tags[i];
+        delete fields[i];
     }
 }
 
@@ -501,7 +501,7 @@ struct fieldstat *construct_fs_with_many_cells(int cell_num, enum sampling_mode
     struct fieldstat *instance = fieldstat_new();
     fieldstat_create_cube(instance, &TEST_TAG_INT, 1, mode, cell_num);
     fieldstat_register_counter(instance, "test");
-    struct fieldstat_tag tmp_tag = TEST_TAG_INT;
+    struct field tmp_tag = TEST_TAG_INT;
     for (int i = 0; i < cell_num; i++) {
         tmp_tag.value_longlong = i;
         fieldstat_counter_incrby(instance, 0, 0, &tmp_tag, 1, 1);
diff --git a/test/test_register_and_reset.cpp b/test/test_register_and_reset.cpp
index 25bdfb0..2e295e8 100644
--- a/test/test_register_and_reset.cpp
+++ b/test/test_register_and_reset.cpp
@@ -82,7 +82,7 @@ TEST(test_register, register_many_cubes)
 {
     struct fieldstat *instance = fieldstat_new();
     int registered_cube = 10000; // will trigger realloc many times
-    struct fieldstat_tag shared_tag = TEST_SHARED_TAG;
+    struct field shared_tag = TEST_SHARED_TAG;
     for (int i = 0; i < registered_cube; i++) {
         shared_tag.value_longlong = i;
         int cube_id = fieldstat_create_cube(instance, &shared_tag, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
@@ -107,16 +107,17 @@ TEST(test_register, add_many_tagged_cells)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    struct fieldstat_tag test_tag_long[100];
-    for (int i = 0; i < 100; i++) {
+    size_t n_field = 1000;
+    struct field test_tag_long[n_field];
+    for (int i = 0; i < n_field; i++) {
         test_tag_long[i] = TEST_TAG_INT; // will trigger realloc 
     }
 
     int metric_id = fieldstat_register_counter(instance, "counter");
-    fieldstat_counter_incrby(instance, cube_id, metric_id, test_tag_long, 100, 10086);
+    fieldstat_counter_incrby(instance, cube_id, metric_id, test_tag_long, n_field, 10086);
 
     long long result;
-    struct fieldstat_tag_list tag_list = {test_tag_long, 100};
+    struct field_list tag_list = {test_tag_long, n_field};
     fieldstat_counter_get(instance, cube_id, &tag_list, metric_id,  &result);
     EXPECT_EQ(result, 10086);
 
@@ -127,7 +128,7 @@ TEST(test_register, add_long_tagged_cells)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    struct fieldstat_tag test_tag_long = TEST_TAG_STRING;
+    struct field test_tag_long = TEST_TAG_STRING;
     char *long_string = (char *)malloc(5001);
     memset(long_string, 'a', 5001);
     long_string[5000] = '\0';
@@ -137,7 +138,7 @@ TEST(test_register, add_long_tagged_cells)
     fieldstat_counter_incrby(instance, cube_id, metric_id, &test_tag_long, 1, 10086);
 
     long long result;
-    struct fieldstat_tag_list tag_list = {&test_tag_long, 1};
+    struct field_list tag_list = {&test_tag_long, 1};
     fieldstat_counter_get(instance, cube_id, &tag_list, metric_id, &result);
     EXPECT_EQ(result, 10086);
 
@@ -194,17 +195,17 @@ TEST(test_register, fork_registered_info_with_cube_and_metric)
     int cube_num;
     fieldstat_get_cubes(dup, &cube_ids, &cube_num);
     EXPECT_EQ(cube_num, 2);
-    struct fieldstat_tag_list *tag_list = NULL;
+    struct field_list *tag_list = NULL;
     
     tag_list = fieldstat_cube_get_tags(dup, cube_ids[0]);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_SHARED_TAG.key);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_SHARED_TAG.key);
     fieldstat_tag_list_arr_free(tag_list, 1);
     size_t n_cell = 0;
     fieldstat_cube_get_cells(dup, cube_ids[0], &tag_list, &n_cell);
     EXPECT_EQ(n_cell, 0);
 
     tag_list = fieldstat_cube_get_tags(dup, cube_ids[1]);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_DOUBLE.key);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_TAG_DOUBLE.key);
     free(cube_ids);
     fieldstat_tag_list_arr_free(tag_list, 1);
 
@@ -256,7 +257,7 @@ TEST(test_register, register_many_cells_on_unlimited_sized_cube)
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 0);
     int metric_id = fieldstat_register_counter(instance, "counter");
-    struct fieldstat_tag test_tag = {"abc", TAG_INTEGER, {.value_longlong = 0}};
+    struct field test_tag = {"abc", TAG_INTEGER, {.value_longlong = 0}};
     for (int i = 0; i < 10000; i++) {
         test_tag.value_longlong = i;
         fieldstat_counter_incrby(instance, cube_id, metric_id, &test_tag, 1, 1);
@@ -264,7 +265,7 @@ TEST(test_register, register_many_cells_on_unlimited_sized_cube)
 
     for (int i = 0; i < 10000; i++) {
         test_tag.value_longlong = i;
-        struct fieldstat_tag_list tag_list = {&test_tag, 1};
+        struct field_list tag_list = {&test_tag, 1};
         long long value;
         fieldstat_counter_get(instance, cube_id, &tag_list, metric_id, &value);
         EXPECT_EQ(value, 1);
@@ -313,8 +314,8 @@ TEST(calibrate, target_one_more_metric)
 
     EXPECT_EQ(test_get_max_metric_id(target), 0);
     EXPECT_STREQ(fieldstat_get_metric_name(target, 0), "counter");
-    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_SHARED_TAG.key);
+    struct field_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_SHARED_TAG.key);
 
     fieldstat_free(master);
     fieldstat_free(target);
@@ -334,8 +335,8 @@ TEST(calibrate, master_one_more_metric)
     EXPECT_EQ(test_get_max_metric_id(target), 1);
     EXPECT_STREQ(fieldstat_get_metric_name(target, 0), "counter");
     EXPECT_STREQ(fieldstat_get_metric_name(target, 1), "counter2");
-    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_SHARED_TAG.key);
+    struct field_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_SHARED_TAG.key);
 
     fieldstat_free(master);
     fieldstat_free(target);
@@ -357,8 +358,8 @@ TEST(calibrate, different_metric)
     EXPECT_EQ(test_get_max_metric_id(target), 1);
     EXPECT_STREQ(fieldstat_get_metric_name(target, 0), "counter");
     EXPECT_STREQ(fieldstat_get_metric_name(target, 1), "hi i am master new");
-    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_SHARED_TAG.key);
+    struct field_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_SHARED_TAG.key);
 
     fieldstat_free(master);
     fieldstat_free(target);
@@ -386,8 +387,8 @@ TEST(calibrate, target_more_cube)
 
     EXPECT_EQ(test_get_max_metric_id(target), 0);
     EXPECT_STREQ(fieldstat_get_metric_name(target, 0), "counter");
-    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_SHARED_TAG.key);
+    struct field_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_SHARED_TAG.key);
 
     EXPECT_EQ(fieldstat_find_cube(target, &TEST_SHARED_TAG, 1), 0);
     EXPECT_EQ(fieldstat_find_cube(target, &TEST_TAG_STRING, 1), FS_ERR_INVALID_KEY);
@@ -414,10 +415,10 @@ TEST(calibrate, master_more_cube)
     EXPECT_EQ(cube_ids[1], cube_id2);
     free(cube_ids);
 
-    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_SHARED_TAG.key);
-    struct fieldstat_tag_list *tag_list2 = fieldstat_cube_get_tags(target, cube_id2);
-    EXPECT_STREQ(tag_list2->tag[0].key, TEST_TAG_STRING.key);
+    struct field_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_SHARED_TAG.key);
+    struct field_list *tag_list2 = fieldstat_cube_get_tags(target, cube_id2);
+    EXPECT_STREQ(tag_list2->field[0].key, TEST_TAG_STRING.key);
 
     EXPECT_EQ(fieldstat_find_cube(target, &TEST_TAG_STRING, 1), 1);
     EXPECT_EQ(fieldstat_find_cube(target, &TEST_SHARED_TAG, 1), 0);
@@ -439,8 +440,8 @@ TEST(calibrate, master_change_cube)
 
     fieldstat_calibrate(master, target);
 
-    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
-    EXPECT_STREQ(tag_list->tag[0].key, TEST_TAG_STRING.key);
+    struct field_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
+    EXPECT_STREQ(tag_list->field[0].key, TEST_TAG_STRING.key);
 
     EXPECT_EQ(fieldstat_find_cube(target, &TEST_TAG_STRING, 1), 0);
 
@@ -453,7 +454,7 @@ TEST(calibrate, master_many_cube)
 {
     struct fieldstat *master = fieldstat_new();
     int registered_cube = 3000; // will trigger realloc 1 times
-    struct fieldstat_tag shared_tag = TEST_SHARED_TAG;
+    struct field shared_tag = TEST_SHARED_TAG;
     for (int i = 0; i < registered_cube; i++) {
         shared_tag.value_longlong = i;
         int cube_id = fieldstat_create_cube(master, &shared_tag, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
@@ -493,7 +494,7 @@ TEST(calibrate, master_many_cube)
 // calibrate调用时，依次比较每个cube id，id:0时，将master[0] 同步,同步时，会先删除A,然后添加B'
     // replica:B' B        (B' B)
 
-// calibrate 继续，同步master[1]，replica[1]不存在，创建新的cube。此时，不仅从id->cube 的数组中删除掉B，且从cube tag->id 的字典中删除掉B。可能会错误的删除掉B'，导致两个map的对应不一致。
+// calibrate 继续，同步master[1]，replica[1]不存在，创建新的cube。此时，不仅从id->cube 的数组中删除掉B，且从cube field->id 的字典中删除掉B。可能会错误的删除掉B'，导致两个map的对应不一致。
     // replica:B' /        (B )
 
 // 例如：find_cube(B)-> 返回1。
@@ -501,8 +502,8 @@ TEST(calibrate, master_many_cube)
 TEST(calibrate, issue_calibrate_wrong)
 {
     struct fieldstat *master = fieldstat_new();
-    const struct fieldstat_tag *tag_A = &TEST_SHARED_TAG;
-    const struct fieldstat_tag *tag_B = &TEST_TAG_INT;
+    const struct field *tag_A = &TEST_SHARED_TAG;
+    const struct field *tag_B = &TEST_TAG_INT;
     int cube_idA = fieldstat_create_cube(master, tag_A, 1, SAMPLING_MODE_COMPREHENSIVE, 1);
     int cube_idB = fieldstat_create_cube(master, tag_B, 1, SAMPLING_MODE_COMPREHENSIVE, 1);
     struct fieldstat *target = fieldstat_fork(master);
@@ -521,8 +522,8 @@ TEST(calibrate, issue_calibrate_wrong)
     EXPECT_EQ(fieldstat_find_cube(target, tag_A, 1), FS_ERR_INVALID_KEY);
     EXPECT_EQ(fieldstat_find_cube(target, tag_B, 1), cubes_id_ret[0]);
 
-    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, cubes_id_ret[0]);
-    EXPECT_STREQ(tag_list->tag[0].key, tag_B->key);
+    struct field_list *tag_list = fieldstat_cube_get_tags(target, cubes_id_ret[0]);
+    EXPECT_STREQ(tag_list->field[0].key, tag_B->key);
     fieldstat_tag_list_arr_free(tag_list, 1);
 
     fieldstat_free(master);
@@ -533,8 +534,8 @@ TEST(calibrate, issue_calibrate_wrong)
 TEST(calibrate, delete_first_cube)
 {
     struct fieldstat *master = fieldstat_new();
-    const struct fieldstat_tag *tag_A = &TEST_SHARED_TAG;
-    const struct fieldstat_tag *tag_B = &TEST_TAG_INT;
+    const struct field *tag_A = &TEST_SHARED_TAG;
+    const struct field *tag_B = &TEST_TAG_INT;
     int cube_idA = fieldstat_create_cube(master, tag_A, 1, SAMPLING_MODE_COMPREHENSIVE, 1);
     int cube_idB = fieldstat_create_cube(master, tag_B, 1, SAMPLING_MODE_COMPREHENSIVE, 1);
     struct fieldstat *target = fieldstat_fork(master);
@@ -553,8 +554,8 @@ TEST(calibrate, delete_first_cube)
     EXPECT_EQ(fieldstat_find_cube(target, tag_A, 1), FS_ERR_INVALID_KEY);
     EXPECT_EQ(fieldstat_find_cube(target, tag_B, 1), 1);
 
-    struct fieldstat_tag_list *tag_list = fieldstat_cube_get_tags(target, 1);
-    EXPECT_STREQ(tag_list->tag[0].key, tag_B->key);
+    struct field_list *tag_list = fieldstat_cube_get_tags(target, 1);
+    EXPECT_STREQ(tag_list->field[0].key, tag_B->key);
     fieldstat_tag_list_arr_free(tag_list, 1);
 
     fieldstat_free(master);
diff --git a/test/test_write_json_file.cpp b/test/test_write_json_file.cpp
index f4dd7f8..1b5fd5f 100644
--- a/test/test_write_json_file.cpp
+++ b/test/test_write_json_file.cpp
@@ -24,8 +24,8 @@ extern "C" {
 
 [[gnu::unused]] static struct fieldstat_easy *get_hist_fieldstat_easy()
 {
-    struct fieldstat_tag global_tags[2];
-    struct fieldstat_tag cell_tags[2];
+    struct field global_tags[2];
+    struct field cell_tags[2];
 
     global_tags[0].key  = "rule_id";
     global_tags[0].type = TAG_INTEGER;
@@ -59,7 +59,7 @@ extern "C" {
 }
 
 static void write_hll(struct fieldstat *instance) {
-    struct fieldstat_tag shared_tags[1];
+    struct field shared_tags[1];
 
     shared_tags[0].key  = "rule_id";
     shared_tags[0].type = TAG_INTEGER;
@@ -85,8 +85,8 @@ static void write_hll(struct fieldstat *instance) {
 }
 
 void write_histogram(struct fieldstat *instance) {
-    struct fieldstat_tag shared_tags[2];
-    struct fieldstat_tag cell_tags[2];
+    struct field shared_tags[2];
+    struct field cell_tags[2];
 
     shared_tags[0].key  = "rule_id";
     shared_tags[0].type = TAG_INTEGER;
@@ -123,8 +123,8 @@ void write_histogram(struct fieldstat *instance) {
 
 // static struct fieldstat_easy *get_table_fieldstat_easy()
 // {
-//     struct fieldstat_tag global_tags[2];
-//     struct fieldstat_tag cell_tags;
+//     struct field global_tags[2];
+//     struct field cell_tags;
 
 //     global_tags[0].key  = "policy_id";
 //     global_tags[0].type = TAG_INTEGER;
@@ -166,7 +166,7 @@ void fieldstat_easy_to_file(struct fieldstat_easy *fse, const char *file_path)
 }
 
 void write_table(struct fieldstat *instance) {
-    struct fieldstat_tag shared_tags[2];   
+    struct field shared_tags[2];   
     shared_tags[0].key  = "policy_id";
     shared_tags[0].type = TAG_INTEGER;
     shared_tags[0].value_longlong = 1;
@@ -180,7 +180,7 @@ void write_table(struct fieldstat *instance) {
         "GTPC-RECORD", "BGP-RECORD", "PROXY-EVENT", "DOS-SKETCH-RECORD",
         "STATISTICS-RULE-METRIC", "OBJECT-STATISTICS-METRIC"};
 
-    struct fieldstat_tag cell_tags;
+    struct field cell_tags;
     cell_tags.key = "send_log";
     cell_tags.type = TAG_CSTRING;
     cell_tags.value_str = "true";
diff --git a/test/utils.cpp b/test/utils.cpp
index b53e4e4..7fa9825 100644
--- a/test/utils.cpp
+++ b/test/utils.cpp
@@ -32,24 +32,24 @@ string gen_rand_string(int len)
 /*                               taglist wrapper                              */
 /* -------------------------------------------------------------------------- */
 
-Fieldstat_tag_list_wrapper::Fieldstat_tag_list_wrapper(const struct fieldstat_tag_list *tag_list) {
-    tag_list_c.tag = (struct fieldstat_tag *)malloc(sizeof(struct fieldstat_tag) * tag_list->n_tag);
-    tag_list_c.n_tag = tag_list->n_tag;
-    for (size_t i = 0; i < tag_list->n_tag; i++)
+Fieldstat_tag_list_wrapper::Fieldstat_tag_list_wrapper(const struct field_list *tag_list) {
+    tag_list_c.field = (struct field *)malloc(sizeof(struct field) * tag_list->n_field);
+    tag_list_c.n_field = tag_list->n_field;
+    for (size_t i = 0; i < tag_list->n_field; i++)
     {
         // copy the tag_list
-        tag_list_c.tag[i].key = strdup(tag_list->tag[i].key);
-        tag_list_c.tag[i].type = tag_list->tag[i].type;
-        switch (tag_list->tag[i].type)
+        tag_list_c.field[i].key = strdup(tag_list->field[i].key);
+        tag_list_c.field[i].type = tag_list->field[i].type;
+        switch (tag_list->field[i].type)
         {
             case TAG_INTEGER:
-                tag_list_c.tag[i].value_longlong = tag_list->tag[i].value_longlong;
+                tag_list_c.field[i].value_longlong = tag_list->field[i].value_longlong;
                 break;
             case TAG_DOUBLE:
-                tag_list_c.tag[i].value_double = tag_list->tag[i].value_double;
+                tag_list_c.field[i].value_double = tag_list->field[i].value_double;
                 break;
             case TAG_CSTRING:
-                tag_list_c.tag[i].value_str = strdup(tag_list->tag[i].value_str);
+                tag_list_c.field[i].value_str = strdup(tag_list->field[i].value_str);
                 break;
             default:
                 break;
@@ -59,84 +59,84 @@ Fieldstat_tag_list_wrapper::Fieldstat_tag_list_wrapper(const struct fieldstat_ta
 
 Fieldstat_tag_list_wrapper::Fieldstat_tag_list_wrapper(const char * key, int value)
 {
-    tag_list_c.tag = (struct fieldstat_tag *)malloc(sizeof(struct fieldstat_tag));
-    tag_list_c.n_tag = 1;
-    tag_list_c.tag[0].key = strdup(key);
-    tag_list_c.tag[0].type = TAG_INTEGER;
-    tag_list_c.tag[0].value_longlong = value;
+    tag_list_c.field = (struct field *)malloc(sizeof(struct field));
+    tag_list_c.n_field = 1;
+    tag_list_c.field[0].key = strdup(key);
+    tag_list_c.field[0].type = TAG_INTEGER;
+    tag_list_c.field[0].value_longlong = value;
 }
 
 Fieldstat_tag_list_wrapper::Fieldstat_tag_list_wrapper(const char * key, const char *value)
 {
-    tag_list_c.tag = (struct fieldstat_tag *)malloc(sizeof(struct fieldstat_tag));
-    tag_list_c.n_tag = 1;
-    tag_list_c.tag[0].key = strdup(key);
-    tag_list_c.tag[0].type = TAG_CSTRING;
-    tag_list_c.tag[0].value_str = strdup(value);
+    tag_list_c.field = (struct field *)malloc(sizeof(struct field));
+    tag_list_c.n_field = 1;
+    tag_list_c.field[0].key = strdup(key);
+    tag_list_c.field[0].type = TAG_CSTRING;
+    tag_list_c.field[0].value_str = strdup(value);
 }
 
 
 Fieldstat_tag_list_wrapper::~Fieldstat_tag_list_wrapper() {
-    for (size_t i = 0; i < tag_list_c.n_tag; i++) {
-        free((char *)tag_list_c.tag[i].key);
-        if (tag_list_c.tag[i].type == TAG_CSTRING) {
-            free((char *)tag_list_c.tag[i].value_str);
+    for (size_t i = 0; i < tag_list_c.n_field; i++) {
+        free((char *)tag_list_c.field[i].key);
+        if (tag_list_c.field[i].type == TAG_CSTRING) {
+            free((char *)tag_list_c.field[i].value_str);
         }
     }
-    free(tag_list_c.tag);
+    free(tag_list_c.field);
 }
 
 Fieldstat_tag_list_wrapper::Fieldstat_tag_list_wrapper(std::uniform_int_distribution<int> &dist, int tag_count)
 {
-    tag_list_c.tag = (struct fieldstat_tag *)malloc(sizeof(struct fieldstat_tag) * tag_count);
-    tag_list_c.n_tag = tag_count;
+    tag_list_c.field = (struct field *)malloc(sizeof(struct field) * tag_count);
+    tag_list_c.n_field = tag_count;
     std::mt19937 rng(1);
     for (int i = 0; i < tag_count; i++)
     {
-        tag_list_c.tag[i].key = strdup(gen_rand_string(10).c_str());
+        tag_list_c.field[i].key = strdup(gen_rand_string(10).c_str());
         int rand_ret = rand() % 3;
         if (rand_ret == 0)
         {
-            tag_list_c.tag[i].type = TAG_INTEGER;
-            tag_list_c.tag[i].value_longlong = static_cast<long long>(dist(rng));
+            tag_list_c.field[i].type = TAG_INTEGER;
+            tag_list_c.field[i].value_longlong = static_cast<long long>(dist(rng));
         }
         else if (rand_ret == 1)
         {
-            tag_list_c.tag[i].type = TAG_DOUBLE;
-            tag_list_c.tag[i].value_double = static_cast<double>(dist(rng)) + 0.5;
+            tag_list_c.field[i].type = TAG_DOUBLE;
+            tag_list_c.field[i].value_double = static_cast<double>(dist(rng)) + 0.5;
         }
         else
         {
-            tag_list_c.tag[i].type = TAG_CSTRING;
-            tag_list_c.tag[i].value_str = strdup(gen_rand_string(10).c_str());
+            tag_list_c.field[i].type = TAG_CSTRING;
+            tag_list_c.field[i].value_str = strdup(gen_rand_string(10).c_str());
         }
     }
 }
 
 Fieldstat_tag_list_wrapper::Fieldstat_tag_list_wrapper() {
-    tag_list_c.tag = NULL;
-    tag_list_c.n_tag = 0;
+    tag_list_c.field = NULL;
+    tag_list_c.n_field = 0;
 }
 
 Fieldstat_tag_list_wrapper::Fieldstat_tag_list_wrapper(const Fieldstat_tag_list_wrapper &tag_list_wrapper){
-    const struct fieldstat_tag_list *tag_list = tag_list_wrapper.get_c_struct();
-    tag_list_c.tag = (struct fieldstat_tag *)malloc(sizeof(struct fieldstat_tag) * tag_list->n_tag);
-    tag_list_c.n_tag = tag_list->n_tag;
-    for (size_t i = 0; i < tag_list->n_tag; i++)
+    const struct field_list *tag_list = tag_list_wrapper.get_c_struct();
+    tag_list_c.field = (struct field *)malloc(sizeof(struct field) * tag_list->n_field);
+    tag_list_c.n_field = tag_list->n_field;
+    for (size_t i = 0; i < tag_list->n_field; i++)
     {
         // copy the tag_list
-        tag_list_c.tag[i].key = strdup(tag_list->tag[i].key);
-        tag_list_c.tag[i].type = tag_list->tag[i].type;
-        switch (tag_list->tag[i].type)
+        tag_list_c.field[i].key = strdup(tag_list->field[i].key);
+        tag_list_c.field[i].type = tag_list->field[i].type;
+        switch (tag_list->field[i].type)
         {
             case TAG_INTEGER:
-                tag_list_c.tag[i].value_longlong = tag_list->tag[i].value_longlong;
+                tag_list_c.field[i].value_longlong = tag_list->field[i].value_longlong;
                 break;
             case TAG_DOUBLE:
-                tag_list_c.tag[i].value_double = tag_list->tag[i].value_double;
+                tag_list_c.field[i].value_double = tag_list->field[i].value_double;
                 break;
             case TAG_CSTRING:
-                tag_list_c.tag[i].value_str = strdup(tag_list->tag[i].value_str);
+                tag_list_c.field[i].value_str = strdup(tag_list->field[i].value_str);
                 break;
             default:
                 break;
@@ -144,38 +144,38 @@ Fieldstat_tag_list_wrapper::Fieldstat_tag_list_wrapper(const Fieldstat_tag_list_
     }
 }
 
-const struct fieldstat_tag *Fieldstat_tag_list_wrapper::get_tag() const
+const struct field *Fieldstat_tag_list_wrapper::get_tag() const
 {
-    return tag_list_c.tag;
+    return tag_list_c.field;
 }
 
 size_t Fieldstat_tag_list_wrapper::get_tag_count() const
 {
-    return tag_list_c.n_tag;
+    return tag_list_c.n_field;
 }
 
-const struct fieldstat_tag_list *Fieldstat_tag_list_wrapper::get_c_struct() const
+const struct field_list *Fieldstat_tag_list_wrapper::get_c_struct() const
 {
     return &tag_list_c;
 }
 
 void Fieldstat_tag_list_wrapper::print_tag_list() const
 {
-    printf("tag_list_c.n_tag: %zu\n", tag_list_c.n_tag);
-    for (size_t i = 0; i < tag_list_c.n_tag; i++)
+    printf("tag_list_c.n_field: %zu\n", tag_list_c.n_field);
+    for (size_t i = 0; i < tag_list_c.n_field; i++)
     {
-        printf("tag_list_c.tag[%zu].key: %s\n", i, tag_list_c.tag[i].key);
-        printf("tag_list_c.tag[%zu].type: %d\n", i, (int)tag_list_c.tag[i].type);
-        switch (tag_list_c.tag[i].type)
+        printf("tag_list_c.field[%zu].key: %s\n", i, tag_list_c.field[i].key);
+        printf("tag_list_c.field[%zu].type: %d\n", i, (int)tag_list_c.field[i].type);
+        switch (tag_list_c.field[i].type)
         {
             case TAG_INTEGER:
-                printf("tag_list_c.tag[%zu].value_longlong: %lld\n", i, tag_list_c.tag[i].value_longlong);
+                printf("tag_list_c.field[%zu].value_longlong: %lld\n", i, tag_list_c.field[i].value_longlong);
                 break;
             case TAG_DOUBLE:
-                printf("tag_list_c.tag[%zu].value_double: %lf\n", i, tag_list_c.tag[i].value_double);
+                printf("tag_list_c.field[%zu].value_double: %lf\n", i, tag_list_c.field[i].value_double);
                 break;
             case TAG_CSTRING:
-                printf("tag_list_c.tag[%zu].value_str: %s\n", i, tag_list_c.tag[i].value_str);
+                printf("tag_list_c.field[%zu].value_str: %s\n", i, tag_list_c.field[i].value_str);
                 break;
             default:
                 break;
@@ -187,20 +187,20 @@ void Fieldstat_tag_list_wrapper::print_tag_list() const
 string Fieldstat_tag_list_wrapper::to_string() const
 {
     string str = "";
-    for (size_t i = 0; i < tag_list_c.n_tag; i++)
+    for (size_t i = 0; i < tag_list_c.n_field; i++)
     {
-        str += tag_list_c.tag[i].key;
+        str += tag_list_c.field[i].key;
         str += ":";
-        switch (tag_list_c.tag[i].type)
+        switch (tag_list_c.field[i].type)
         {
             case TAG_INTEGER:
-                str += std::to_string(tag_list_c.tag[i].value_longlong);
+                str += std::to_string(tag_list_c.field[i].value_longlong);
                 break;
             case TAG_DOUBLE:
-                str += std::to_string(tag_list_c.tag[i].value_double);
+                str += std::to_string(tag_list_c.field[i].value_double);
                 break;
             case TAG_CSTRING:
-                str += tag_list_c.tag[i].value_str;
+                str += tag_list_c.field[i].value_str;
                 break;
             default:
                 break;
@@ -212,30 +212,30 @@ string Fieldstat_tag_list_wrapper::to_string() const
 
 bool Fieldstat_tag_list_wrapper::operator==(const Fieldstat_tag_list_wrapper &tag_list_wrapper) const
 {
-    const struct fieldstat_tag_list *tag_list = tag_list_wrapper.get_c_struct();
-    if (tag_list_c.n_tag != tag_list->n_tag) {
+    const struct field_list *tag_list = tag_list_wrapper.get_c_struct();
+    if (tag_list_c.n_field != tag_list->n_field) {
         return false;
     }
-    for (size_t i = 0; i < tag_list_c.n_tag; i++) {
-        if (strcmp((char *)tag_list_c.tag[i].key, (char *)tag_list->tag[i].key) != 0) {
+    for (size_t i = 0; i < tag_list_c.n_field; i++) {
+        if (strcmp((char *)tag_list_c.field[i].key, (char *)tag_list->field[i].key) != 0) {
             return false;
         }
-        if (tag_list_c.tag[i].type != tag_list->tag[i].type) {
+        if (tag_list_c.field[i].type != tag_list->field[i].type) {
             return false;
         }
-        switch (tag_list_c.tag[i].type) {
+        switch (tag_list_c.field[i].type) {
             case TAG_INTEGER:
-                if (tag_list_c.tag[i].value_longlong != tag_list->tag[i].value_longlong) {
+                if (tag_list_c.field[i].value_longlong != tag_list->field[i].value_longlong) {
                     return false;
                 }
                 break;
             case TAG_DOUBLE:
-                if (tag_list_c.tag[i].value_double != tag_list->tag[i].value_double) {
+                if (tag_list_c.field[i].value_double != tag_list->field[i].value_double) {
                     return false;
                 }
                 break;
             case TAG_CSTRING:
-                if (strcmp((char *)tag_list_c.tag[i].value_str, (char *)tag_list->tag[i].value_str) != 0) {
+                if (strcmp((char *)tag_list_c.field[i].value_str, (char *)tag_list->field[i].value_str) != 0) {
                     return false;
                 }
                 break;
@@ -248,7 +248,7 @@ bool Fieldstat_tag_list_wrapper::operator==(const Fieldstat_tag_list_wrapper &ta
 
 Fieldstat_tag_list_wrapper& Fieldstat_tag_list_wrapper::sort_tag_list()
 {
-    std::sort(tag_list_c.tag, tag_list_c.tag + tag_list_c.n_tag, [](const struct fieldstat_tag &a, const struct fieldstat_tag &b) {
+    std::sort(tag_list_c.field, tag_list_c.field + tag_list_c.n_field, [](const struct field &a, const struct field &b) {
         return strcmp((char *)a.key, (char *)b.key) < 0;
     });
     return *this;
diff --git a/test/utils.hpp b/test/utils.hpp
index 28dea2b..f414de9 100644
--- a/test/utils.hpp
+++ b/test/utils.hpp
@@ -3,16 +3,16 @@
 #include <unordered_map>
 #include "fieldstat.h"
 
-const struct fieldstat_tag TEST_TAG_STRING = {"STRING KEY_", TAG_CSTRING, {.value_str = "100.1"}};
-const struct fieldstat_tag_list TEST_TAG_LIST_STRING = {(struct fieldstat_tag *)&TEST_TAG_STRING, 1};
-const struct fieldstat_tag TEST_TAG_STRING_collided = {"collided", TAG_CSTRING, {.value_str = "2"}};
-const struct fieldstat_tag TEST_TAG_INT = {"INT key_", TAG_INTEGER, {.value_longlong = 100}};
-const struct fieldstat_tag_list TEST_TAG_LIST_INT = {(struct fieldstat_tag *)&TEST_TAG_INT, 1};
-const struct fieldstat_tag TEST_TAG_INT_collided = {"collided", TAG_INTEGER, {.value_longlong = 2}};
-const struct fieldstat_tag TEST_TAG_DOUBLE = {"DOUBLE key_", TAG_DOUBLE, {.value_double = 100.1}};
-const struct fieldstat_tag_list TEST_TAG_LIST_DOUBLE = {(struct fieldstat_tag *)&TEST_TAG_DOUBLE, 1};
-const struct fieldstat_tag TEST_TAG_DOUBLE_collided = {"collided", TAG_DOUBLE, {.value_double = 2.0}};
-const struct fieldstat_tag TEST_SHARED_TAG = {"shared", TAG_INTEGER, {.value_longlong = 1}};
+const struct field TEST_TAG_STRING = {"STRING KEY_", TAG_CSTRING, {.value_str = "100.1"}};
+const struct field_list TEST_TAG_LIST_STRING = {(struct field *)&TEST_TAG_STRING, 1};
+const struct field TEST_TAG_STRING_collided = {"collided", TAG_CSTRING, {.value_str = "2"}};
+const struct field TEST_TAG_INT = {"INT key_", TAG_INTEGER, {.value_longlong = 100}};
+const struct field_list TEST_TAG_LIST_INT = {(struct field *)&TEST_TAG_INT, 1};
+const struct field TEST_TAG_INT_collided = {"collided", TAG_INTEGER, {.value_longlong = 2}};
+const struct field TEST_TAG_DOUBLE = {"DOUBLE key_", TAG_DOUBLE, {.value_double = 100.1}};
+const struct field_list TEST_TAG_LIST_DOUBLE = {(struct field *)&TEST_TAG_DOUBLE, 1};
+const struct field TEST_TAG_DOUBLE_collided = {"collided", TAG_DOUBLE, {.value_double = 2.0}};
+const struct field TEST_SHARED_TAG = {"shared", TAG_INTEGER, {.value_longlong = 1}};
 const struct timeval TEST_TIMEVAL = {100, 10000};
 const long long TEST_TIMEVAL_LONG = 100010; // 100s * 1000 + 10000us / 1000 = 100010ms
 
@@ -20,7 +20,7 @@ std::string gen_rand_string(int len);
 
 class Fieldstat_tag_list_wrapper {
 public:
-    explicit Fieldstat_tag_list_wrapper(const struct fieldstat_tag_list *tag_list_c);
+    explicit Fieldstat_tag_list_wrapper(const struct field_list *tag_list_c);
     explicit Fieldstat_tag_list_wrapper(const char * key, int value);
     explicit Fieldstat_tag_list_wrapper(const char * key, const char *value);
     explicit Fieldstat_tag_list_wrapper(std::uniform_int_distribution<int> &dist, int tag_count);
@@ -31,13 +31,13 @@ public:
     ~Fieldstat_tag_list_wrapper();
     bool operator==(const Fieldstat_tag_list_wrapper &tag_list_wrapper) const;
 
-    const struct fieldstat_tag *get_tag() const;
+    const struct field *get_tag() const;
     size_t get_tag_count() const;
-    const struct fieldstat_tag_list *get_c_struct() const;
+    const struct field_list *get_c_struct() const;
     void print_tag_list() const;
     Fieldstat_tag_list_wrapper& sort_tag_list();
 private:
-    struct fieldstat_tag_list tag_list_c;
+    struct field_list tag_list_c;
 };