renames about tag

5 files changed, 146 insertions, 159 deletions

diff --git a/src/cells/hash_table.c b/src/cells/hash_table.c
index 60d2465..255a3ef 100644
--- a/src/cells/hash_table.c
+++ b/src/cells/hash_table.c
@@ -10,7 +10,7 @@
 #include "fieldstat.h"
 #include "exdata.h"
 
-struct tag_exdata_item {
+struct entry {
     char *key;
     size_t key_len;
     void *exdata;
@@ -19,7 +19,7 @@ struct tag_exdata_item {
 };
 
 struct hash_table {
-    struct tag_exdata_item *tag_id_map;
+    struct entry *key_exdata_map;
     int current_cell_num;
     int max_cell_num;
 
@@ -67,9 +67,9 @@ void hash_table_free(struct hash_table *pthis) {
     if (pthis == NULL) {
         return;
     }
-    struct tag_exdata_item *item, *tmp;
-    HASH_ITER(hh, pthis->tag_id_map, item, tmp) {
-        HASH_DEL(pthis->tag_id_map, item);
+    struct entry *item, *tmp;
+    HASH_ITER(hh, pthis->key_exdata_map, item, tmp) {
+        HASH_DEL(pthis->key_exdata_map, item);
         free(item->key);
         pthis->free_fn(item->exdata);
         free(item);
@@ -78,14 +78,14 @@ void hash_table_free(struct hash_table *pthis) {
 }
 
 void hash_table_reset(struct hash_table *pthis) {
-    struct tag_exdata_item *node, *tmp;
-    HASH_ITER(hh, pthis->tag_id_map, node, tmp) {
+    struct entry *node, *tmp;
+    HASH_ITER(hh, pthis->key_exdata_map, node, tmp) {
         if (!node->dying) {
             node->dying = true;
             pthis->reset_fn(node->exdata);
             continue;
         }
-        HASH_DEL(pthis->tag_id_map, node);
+        HASH_DEL(pthis->key_exdata_map, node);
         free(node->key);
         pthis->free_fn(node->exdata);
         free(node);
@@ -101,8 +101,8 @@ static char *my_keydup(const char *key, size_t key_len) {
 }
 
 int hash_table_add(struct hash_table *pthis, const char *key, size_t key_len, void *arg) {
-    struct tag_exdata_item *item;
-    HASH_FIND(hh, pthis->tag_id_map, key, key_len, item);
+    struct entry *item;
+    HASH_FIND(hh, pthis->key_exdata_map, key, key_len, item);
     if (item != NULL && !item->dying) {
         return 1;
     }
@@ -118,12 +118,12 @@ int hash_table_add(struct hash_table *pthis, const char *key, size_t key_len, vo
         return 1;
     }
 
-    item = calloc(1, sizeof(struct tag_exdata_item));
+    item = calloc(1, sizeof(struct entry));
     item->key = my_keydup(key, key_len);
     item->key_len = key_len;
     item->exdata = pthis->new_fn(arg);
     item->dying = false;
-    HASH_ADD_KEYPTR(hh, pthis->tag_id_map, item->key, key_len, item);
+    HASH_ADD_KEYPTR(hh, pthis->key_exdata_map, item->key, key_len, item);
 
     pthis->current_cell_num++;
     return 1;
@@ -138,8 +138,8 @@ void hash_table_set_exdata_schema(struct hash_table *pthis, exdata_new_cb new_fn
 }
 
 void *hash_table_get0_exdata(struct hash_table *pthis, const char *key, size_t key_len) {
-    struct tag_exdata_item *item;
-    HASH_FIND(hh, pthis->tag_id_map, key, key_len, item);
+    struct entry *item;
+    HASH_FIND(hh, pthis->key_exdata_map, key, key_len, item);
     if (item == NULL || item->dying) {
         return NULL;
     }
@@ -156,9 +156,9 @@ size_t hash_table_list(const struct hash_table *pthis, void **exdatas, size_t n_
         return 0;
     }
 
-    struct tag_exdata_item *item, *tmp;
+    struct entry *item, *tmp;
     size_t i = 0;
-    HASH_ITER(hh, pthis->tag_id_map, item, tmp) {
+    HASH_ITER(hh, pthis->key_exdata_map, item, tmp) {
         if (item->dying) {
             continue;
         }
@@ -172,14 +172,14 @@ size_t hash_table_list(const struct hash_table *pthis, void **exdatas, size_t n_
 }
 
 int hash_table_merge(struct hash_table *dest, struct hash_table *src) {
-    struct tag_exdata_item *item_src, *tmp;
-    struct tag_exdata_item *item_dst;
-    HASH_ITER(hh, src->tag_id_map, item_src, tmp) {
+    struct entry *item_src, *tmp;
+    struct entry *item_dst;
+    HASH_ITER(hh, src->key_exdata_map, item_src, tmp) {
         if (item_src->dying) {
             continue;
         }
 
-        HASH_FIND(hh, dest->tag_id_map, item_src->key, item_src->key_len, item_dst);
+        HASH_FIND(hh, dest->key_exdata_map, item_src->key, item_src->key_len, item_dst);
         if (item_dst != NULL && !item_dst->dying) {
             dest->merge_fn(item_dst->exdata, item_src->exdata);
             continue;
@@ -190,12 +190,12 @@ int hash_table_merge(struct hash_table *dest, struct hash_table *src) {
         }
 
         if (item_dst == NULL) {
-            item_dst = calloc(1, sizeof(struct tag_exdata_item));
+            item_dst = calloc(1, sizeof(struct entry));
             item_dst->key = my_keydup(item_src->key, item_src->key_len);
             item_dst->key_len = item_src->key_len;
             item_dst->dying = false;
             item_dst->exdata = dest->copy_fn(item_src->exdata);
-            HASH_ADD_KEYPTR(hh, dest->tag_id_map, item_dst->key, item_dst->key_len, item_dst);
+            HASH_ADD_KEYPTR(hh, dest->key_exdata_map, item_dst->key, item_dst->key_len, item_dst);
             dest->current_cell_num++;
         } else {
             assert(item_dst->dying);
@@ -217,17 +217,17 @@ struct hash_table *hash_table_copy(const struct hash_table *src) {
     pthis->reset_fn = src->reset_fn;
     pthis->copy_fn = src->copy_fn;
 
-    struct tag_exdata_item *item, *tmp;
-    HASH_ITER(hh, src->tag_id_map, item, tmp) {
+    struct entry *item, *tmp;
+    HASH_ITER(hh, src->key_exdata_map, item, tmp) {
         if (item->dying) {
             continue;
         }
-        struct tag_exdata_item *new_item = calloc(1, sizeof(struct tag_exdata_item));
+        struct entry *new_item = calloc(1, sizeof(struct entry));
         new_item->key = my_keydup(item->key, item->key_len);
         new_item->key_len = item->key_len;
         new_item->exdata = pthis->copy_fn(item->exdata);
         new_item->dying = false;
-        HASH_ADD_KEYPTR(hh, pthis->tag_id_map, new_item->key, new_item->key_len, new_item);
+        HASH_ADD_KEYPTR(hh, pthis->key_exdata_map, new_item->key, new_item->key_len, new_item);
     }
     return pthis;
 }
diff --git a/src/cube.c b/src/cube.c
index c5c21e6..bedf697 100644
--- a/src/cube.c
+++ b/src/cube.c
@@ -86,18 +86,6 @@ static struct field *field_array_duplicate(const struct field *fields_src, size_
     return ret;
 }
 
-static void fieldstat_free_tag_array(struct field *fields, size_t n_tags)
-{
-    for (size_t i = 0; i < n_tags; i++) {
-        struct field *field = &fields[i];
-        free((char *)field->key);
-        if (field->type == FIELD_VALUE_CSTRING) {
-            free((char *)field->value_str);
-        }
-    }
-    free(fields);
-}
-
 void add_cube_to_position(struct cube_manager *pthis, struct cube *cube, int id)
 {
     if (id >= pthis->slots_number) {
@@ -160,9 +148,9 @@ void print_field_array(const struct field *fields, size_t n_field)
     }
 }
 
-static void field_array_to_key(const struct field fields[], size_t n_tags, char **out_key, size_t *out_key_size)
+static void field_array_to_key(const struct field fields[], size_t n_fields, char **out_key, size_t *out_key_size)
 {
-    if (n_tags == 0) {
+    if (n_fields == 0) {
         // use a default dummy key
         *out_key = strdup("no fields");
         *out_key_size = strlen(*out_key);
@@ -181,7 +169,7 @@ static void field_array_to_key(const struct field fields[], size_t n_tags, char
     size_t key_len = 0;
     size_t val_len = 0;
 
-	for(i = 0; i < (int)n_tags; i++)
+	for(i = 0; i < (int)n_fields; i++)
 	{
 		field = (struct field *)&fields[i];
         key_len = strlen(field->key);
@@ -602,7 +590,15 @@ void cube_free(struct cube *cube) {
         break;
     }
 
-    fieldstat_free_tag_array(cube->cube_dimensions, cube->n_dimensions);
+    for (size_t i = 0; i < cube->n_dimensions; i++) {
+        struct field *field = &cube->cube_dimensions[i];
+        free((char *)field->key);
+        if (field->type == FIELD_VALUE_CSTRING) {
+            free((char *)field->value_str);
+        }
+    }
+    free(cube->cube_dimensions);
+
     free(cube->serialized_dimensions);
     metric_manifest_manager_free(cube->manifest_manager);
 
@@ -911,7 +907,7 @@ uint64_t field_array_to_hash(const struct field *field, size_t n_dimensions) {
     return XXH3_64bits_digest(&state);
 }
 
-int cube_hll_add_field(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, const struct field *tags_key, size_t n_tag_key) 
+int cube_hll_add_field(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, const struct field *item_fields, size_t n_item) 
 {
     if (cube->primary_metric_id == -1) {
         return FS_ERR_CUBE_SAMPLING_NOT_INITIALIZED;
@@ -931,7 +927,7 @@ int cube_hll_add_field(struct cube *cube, int metric_id, const struct field *dim
         struct exdata_new_args args;
         args.cell_dimensions = dimensions;
         args.n_dimensions = n_dimensions;
-        hash = field_array_to_hash(tags_key, n_tag_key);
+        hash = field_array_to_hash(item_fields, n_item);
 
         int tmp_ret = spread_sketch_add_hash(cube->spread_sketch, key, key_len, hash, (void *)&args, DUMMY_TIME_VAL);
         free(key);
@@ -959,7 +955,7 @@ int cube_hll_add_field(struct cube *cube, int metric_id, const struct field *dim
     struct metric *metric = add_or_find_metric_in_cell(manifest, cell_data);
     
     if (hash == 0) { // hash is not calculated yet.
-        hash = field_array_to_hash(tags_key, n_tag_key);
+        hash = field_array_to_hash(item_fields, n_item);
     }
     metric_hll_add_hash(metric, hash);
     return FS_OK;
@@ -1246,18 +1242,18 @@ void cube_get_cells(const struct cube *cube, struct field_list **cell_dimensions
         free(tmp_sorted_data);
     }
 
-    struct field_list *tag_list_ret = (struct field_list *)malloc(sizeof(struct field_list) * n_cell_tmp);
-    *cell_dimensions = tag_list_ret;
+    struct field_list *ret = (struct field_list *)malloc(sizeof(struct field_list) * n_cell_tmp);
+    *cell_dimensions = ret;
     *n_cell = n_cell_tmp;
     for (int i = 0; i < n_cell_tmp; i++) {
         struct cell *cell_data = cell_datas[i];
-        struct field_list *tag_list_tmp = &tag_list_ret[i];
-        tag_list_tmp->n_field = cell_data->cell_dimensions.n_field;
-        if (tag_list_tmp->n_field == 0) {
-            tag_list_tmp->field = NULL;
+        struct field_list *field_list_tmp = &ret[i];
+        field_list_tmp->n_field = cell_data->cell_dimensions.n_field;
+        if (field_list_tmp->n_field == 0) {
+            field_list_tmp->field = NULL;
             continue;
         }
-        tag_list_tmp->field = field_array_duplicate(cell_data->cell_dimensions.field, tag_list_tmp->n_field);
+        field_list_tmp->field = field_array_duplicate(cell_data->cell_dimensions.field, field_list_tmp->n_field);
     }
 
     free(cell_datas);
@@ -1266,36 +1262,36 @@ void cube_get_cells(const struct cube *cube, struct field_list **cell_dimensions
     free(spread_sketch_keys_lens);
 }
 
-const struct cell *get_cell_by_tag_list(const struct cube *cube, const struct field_list *fields)
+const struct cell *get_cell_by_dimension(const struct cube *cube, const struct field_list *fields)
 {
     const struct cell *ret = NULL;
-    char *tag_in_string;
-    size_t tag_len;
-    field_array_to_key(fields->field, fields->n_field, &tag_in_string, &tag_len);
+    char *compound_dimension;
+    size_t dimension_len;
+    field_array_to_key(fields->field, fields->n_field, &compound_dimension, &dimension_len);
 
     switch (cube->sampling_mode)
     {
     case SAMPLING_MODE_TOPK:
-        ret = heavy_keeper_get0_exdata(cube->heavykeeper, tag_in_string, tag_len);
+        ret = heavy_keeper_get0_exdata(cube->heavykeeper, compound_dimension, dimension_len);
         break;
     case SAMPLING_MODE_COMPREHENSIVE:
-        ret = hash_table_get0_exdata(cube->table, tag_in_string, tag_len);
+        ret = hash_table_get0_exdata(cube->table, compound_dimension, dimension_len);
         break;
     case SAMPLING_MODE_TOP_CARDINALITY:
-        ret = spread_sketch_get0_exdata(cube->spread_sketch, tag_in_string, tag_len);
+        ret = spread_sketch_get0_exdata(cube->spread_sketch, compound_dimension, dimension_len);
         break;
     default:
         assert(0);
         return NULL;
     }
-    free(tag_in_string);
+    free(compound_dimension);
 
     return ret;
 }
 
-const struct metric *get_metric_by_tag_list(const struct cube *cube, const struct field_list *fields, int metric_id,int *ret)
+const struct metric *cube_find_metric_in_cell(const struct cube *cube, const struct field_list *fields, int metric_id,int *ret)
 {
-    const struct cell *data = get_cell_by_tag_list(cube, fields);
+    const struct cell *data = get_cell_by_dimension(cube, fields);
     
     if (data == NULL) {
         *ret = FS_ERR_INVALID_DIMENSION;
@@ -1328,7 +1324,7 @@ int cube_counter_get(const struct cube *cube, int metric_id, const struct field_
     }
 
     int ret;
-    const struct metric *metric = get_metric_by_tag_list(cube, fields, metric_id, &ret);
+    const struct metric *metric = cube_find_metric_in_cell(cube, fields, metric_id, &ret);
     if (ret != FS_OK) {
         return ret;
     }
@@ -1358,7 +1354,7 @@ int cube_hll_get(const struct cube *cube, int metric_id, const struct field_list
     }
 
     int ret;
-    const struct metric *metric = get_metric_by_tag_list(cube, fields, metric_id, &ret);
+    const struct metric *metric = cube_find_metric_in_cell(cube, fields, metric_id, &ret);
     if (ret != FS_OK) {
         return ret;
     }
@@ -1373,7 +1369,7 @@ int cube_hll_get(const struct cube *cube, int metric_id, const struct field_list
 int cube_histogram_value_at_percentile(const struct cube *cube, int metric_id, const struct field_list *fields, double percentile, long long *value)
 {
     int ret;
-    const struct metric *metric = get_metric_by_tag_list(cube, fields, metric_id, &ret);
+    const struct metric *metric = cube_find_metric_in_cell(cube, fields, metric_id, &ret);
     if (ret != FS_OK) {
         return ret;
     }
@@ -1387,7 +1383,7 @@ int cube_histogram_value_at_percentile(const struct cube *cube, int metric_id, c
 
 int cube_histogram_count_le_value(const struct cube *cube, int metric_id, const struct field_list *fields, long long value, long long *count) {
     int ret;
-    const struct metric *metric = get_metric_by_tag_list(cube, fields, metric_id, &ret);
+    const struct metric *metric = cube_find_metric_in_cell(cube, fields, metric_id, &ret);
     if (ret != FS_OK) {
         return ret;
     }
@@ -1411,7 +1407,7 @@ int cube_get_serialization_as_base64(const struct cube *cube, int metric_id, con
     }
 
     int ret;
-    const struct metric *metric = get_metric_by_tag_list(cube, fields, metric_id, &ret);
+    const struct metric *metric = cube_find_metric_in_cell(cube, fields, metric_id, &ret);
     if (ret != FS_OK) {
         return ret;
     }
@@ -1438,7 +1434,7 @@ int cube_get_cell_count(const struct cube *cube) {
 }
 
 void cube_get_metrics_in_cell(const struct cube *cube, const struct field_list *fields, int **metric_id_out, size_t *n_metric_out) {
-    const struct cell *cell_data = get_cell_by_tag_list(cube, fields);
+    const struct cell *cell_data = get_cell_by_dimension(cube, fields);
     if (cell_data == NULL) {
         *metric_id_out = NULL;
         *n_metric_out = 0;
@@ -1462,19 +1458,19 @@ void cube_get_metrics_in_cell(const struct cube *cube, const struct field_list *
 }
 
 struct field_list *cube_get_identifier(const struct cube *cube) {
-    struct field_list *tag_list = (struct field_list *)malloc(sizeof(struct field_list));
+    struct field_list *ret = (struct field_list *)malloc(sizeof(struct field_list));
 
     if (cube->n_dimensions == 0) {
-        tag_list->field = NULL;
-        tag_list->n_field = 0;
-        return tag_list;
+        ret->field = NULL;
+        ret->n_field = 0;
+        return ret;
     }
 
-    tag_list->field = field_array_duplicate(cube->cube_dimensions, cube->n_dimensions);
-    tag_list->n_field = cube->n_dimensions;
+    ret->field = field_array_duplicate(cube->cube_dimensions, cube->n_dimensions);
+    ret->n_field = cube->n_dimensions;
     
 
-    return tag_list;
+    return ret;
 }
 
 const char *cube_get_metric_name(const struct cube *cube, int metric_id) {
diff --git a/src/cube.h b/src/cube.h
index c7a5893..f3c1d3c 100644
--- a/src/cube.h
+++ b/src/cube.h
@@ -27,7 +27,7 @@ int cube_register_hist(struct cube *cube,const char *metric_name, long long lowe
 
 int cube_histogram_record(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, long long value);
 int cube_hll_add(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, const char *key, size_t key_len);
-int cube_hll_add_field(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, const struct field *tags_key, size_t n_tag_key);
+int cube_hll_add_field(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, const struct field *item_fields, size_t n_item);
 int cube_counter_incrby(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, long long increment);
 int cube_counter_set(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, long long value);
 
@@ -40,7 +40,7 @@ int cube_get_serialization_as_base64(const struct cube *cube, int metric_id, con
 
 int cube_get_cell_count(const struct cube *cube);
 enum sampling_mode cube_get_sampling_mode(const struct cube *cube);
-void cube_get_cells(const struct cube *cube, struct field_list **tag_list, size_t *n_cell);
+void cube_get_cells(const struct cube *cube, struct field_list **cell_dimensions, size_t *n_cell);
 void cube_get_metrics(const struct cube *cube, int **metric_id_out, size_t *n_metric);
 void cube_get_metrics_in_cell(const struct cube *cube, const struct field_list *dimensions, int **metric_id_out, size_t *n_metric_out);
 struct field_list *cube_get_identifier(const struct cube *cube);
diff --git a/src/exporter/cjson_exporter.c b/src/exporter/cjson_exporter.c
index b2a909d..5954a1e 100644
--- a/src/exporter/cjson_exporter.c
+++ b/src/exporter/cjson_exporter.c
@@ -46,6 +46,7 @@
     ]
 */
 #define DEFAULT_EXPORTER_NAME "-"
+#define NIL_TAG_JSON "\anil"
 
 struct counter_history;
 struct export_kv_pair {
@@ -69,9 +70,9 @@ struct cell_iter {
     int *cube_ids;
     int n_cube;
     int curr_cube_idx;
-    struct field_list *shared_tag;
+    struct field_list *cube_dimension;
 
-    struct field_list *tag_list;
+    struct field_list *cell_dimension;
     size_t n_cell;
     size_t curr_cell_idx;
 
@@ -79,7 +80,7 @@ struct cell_iter {
 };
 
 struct cellwise_rec_for_export {
-    struct json_writer *cjson_tags;
+    struct json_writer *tag_json_obj;
     struct export_kv_pair **metric_pairs;
     size_t n_metric;
 };
@@ -123,7 +124,7 @@ void kv_pair_free(struct export_kv_pair *pair) {
     free(pair);
 }
 
-void kv_pair_fill_with_tags(struct export_kv_pair *dest, const struct field *src)
+void kv_pair_fill_with_fields(struct export_kv_pair *dest, const struct field *src)
 {
     dest->key = strdup(src->key);
     dest->type = src->type;
@@ -208,13 +209,13 @@ void counter_history_free(struct counter_history *history)
     free(history->exporter_name);
 
     if (history->global_tag_list != NULL) {
-        fieldstat_tag_list_arr_free(history->global_tag_list, 1);
+        fieldstat_field_list_arr_free(history->global_tag_list, 1);
     }
 
     free(history);
 }
 
-bool fieldstat_tag_list_cmp(const struct field_list *a, const struct field_list *b)
+bool field_list_cmp(const struct field_list *a, const struct field_list *b)
 {
     if (a->n_field != b->n_field) {
         return false;
@@ -252,7 +253,7 @@ bool fieldstat_tag_list_cmp(const struct field_list *a, const struct field_list
     return true;
 }
 
-struct field_list *my_copy_fs_tag_list(const struct field_list *src)
+struct field_list *field_list_dup(const struct field_list *src)
 {
     struct field_list *dest = malloc(sizeof(struct field_list));
     dest->n_field = src->n_field;
@@ -303,7 +304,7 @@ bool counter_history_check_if_need_to_update(const struct fieldstat_json_exporte
         return false;
     }
     // global field cant be deleted, so no need to check if cur_global_tag_list == NULL && history->global_tag_list != NULL
-    if (fieldstat_tag_list_cmp(cur_global_tag_list, history->global_tag_list) == false) {
+    if (field_list_cmp(cur_global_tag_list, history->global_tag_list) == false) {
         return true;
     }
 
@@ -318,7 +319,7 @@ void counter_history_fill_version_info(struct counter_history *history, struct f
     free(history->exporter_name);
     history->exporter_name = strdup(cur_exporter_name);
     if (cur_global_tag_list != NULL) {
-        history->global_tag_list = my_copy_fs_tag_list(cur_global_tag_list);
+        history->global_tag_list = field_list_dup(cur_global_tag_list);
     }
 }
 
@@ -337,9 +338,9 @@ void fieldstat_json_exporter_update_history(struct fieldstat_json_exporter *expo
 void write_delta_to_json(struct fieldstat_json_exporter *exporter, struct cellwise_rec_for_export *tag_field_pair, struct json_writer *field_json)
 {
     // for every tag_field_pair, get the field json string
-    const char *tag_json = json_writer_unwrap(tag_field_pair->cjson_tags);
+    const char *tag_json = json_writer_unwrap(tag_field_pair->tag_json_obj);
     if (tag_json == NULL) {
-        tag_json = "\a\t\a"; // just a dummy string
+        tag_json = NIL_TAG_JSON;
     }
     for (int j = 0; j < tag_field_pair->n_metric; j++) {
         if (tag_field_pair->metric_pairs[j]->type != FIELD_VALUE_INTEGER) { // only counter type need to write delta
@@ -407,14 +408,12 @@ void couple_export_table_free(struct couple_export_table *tbl)
     free(tbl);
 }
 
-#define NIL_TAG_JSON "\anil"
-
 // align delta fields to acc fields by matching field json string, return an array with length n_acc, each of whose element match the corresponding acc element by both field and index
 const struct cellwise_rec_for_export **rearrange_metric_delta(const struct cellwise_rec_for_export *acc, size_t n_acc, const struct cellwise_rec_for_export *delta, size_t n_delta)
 {
     struct couple_export_table *map = couple_export_table_new();
     for (int i = 0; i < n_delta; i++) {
-        const char *tag_json = json_writer_unwrap(delta[i].cjson_tags);
+        const char *tag_json = json_writer_unwrap(delta[i].tag_json_obj);
         if (tag_json == NULL) { // field might be empty, give it a dummy name
             tag_json = NIL_TAG_JSON;
         }
@@ -424,7 +423,7 @@ const struct cellwise_rec_for_export **rearrange_metric_delta(const struct cellw
     const struct cellwise_rec_for_export **ret = calloc(n_acc, sizeof(struct cellwise_rec_for_export *));
 
     for (int id_acc = 0; id_acc < n_acc; id_acc++) {
-        const char *tag_str_acc = json_writer_unwrap(acc[id_acc].cjson_tags);
+        const char *tag_str_acc = json_writer_unwrap(acc[id_acc].tag_json_obj);
         if (tag_str_acc == NULL) { // field might be empty, give it a dummy name
             tag_str_acc = NIL_TAG_JSON;
         }
@@ -454,8 +453,8 @@ struct cell_iter *cell_iter_new(const struct fieldstat *instance) {
 }
 
 void cell_iter_free_cell_records(struct cell_iter *iter) {
-    fieldstat_tag_list_arr_free(iter->tag_list, iter->n_cell);
-    iter->tag_list = NULL;
+    fieldstat_field_list_arr_free(iter->cell_dimension, iter->n_cell);
+    iter->cell_dimension = NULL;
     iter->n_cell = 0;
     iter->curr_cell_idx = 0;
 }
@@ -463,8 +462,8 @@ void cell_iter_free_cell_records(struct cell_iter *iter) {
 void cell_iter_free(struct cell_iter *iter) {
     cell_iter_free_cell_records(iter);
 
-    if (iter->shared_tag != NULL) {
-        fieldstat_tag_list_arr_free(iter->shared_tag, 1);
+    if (iter->cube_dimension != NULL) {
+        fieldstat_field_list_arr_free(iter->cube_dimension, 1);
     }
     free(iter->cube_ids);
 
@@ -476,12 +475,12 @@ int cell_iter_next_cube(struct cell_iter *iter) {
     while (iter->curr_cube_idx < iter->n_cube - 1) {
         int cube_id_next = iter->cube_ids[++iter->curr_cube_idx];
 
-        fieldstat_cube_get_cells(instance, cube_id_next, &iter->tag_list, &iter->n_cell);
+        fieldstat_cube_get_cells(instance, cube_id_next, &iter->cell_dimension, &iter->n_cell);
         if (iter->n_cell == 0) {
             continue;
         }
 
-        iter->shared_tag = fieldstat_cube_get_tags(iter->instance, iter->cube_ids[iter->curr_cube_idx]);
+        iter->cube_dimension = fieldstat_cube_get_dimensions(iter->instance, iter->cube_ids[iter->curr_cube_idx]);
         iter->curr_cell_idx = 0;
         return 1;
     }
@@ -510,8 +509,8 @@ int cell_iter_next(struct cell_iter *iter) {
     }
 
     cell_iter_free_cell_records(iter);
-    fieldstat_tag_list_arr_free(iter->shared_tag, 1);
-    iter->shared_tag = NULL;
+    fieldstat_field_list_arr_free(iter->cube_dimension, 1);
+    iter->cube_dimension = NULL;
 
     if (cell_iter_next_cube(iter)) {
         return 1;
@@ -529,7 +528,7 @@ struct export_kv_pair *cell_query_with_iter(const struct cell_iter *iter, int me
     struct export_kv_pair *ret = NULL;
     if (type == METRIC_TYPE_COUNTER) {
         long long value;
-        int tmp_ret = fieldstat_counter_get(iter->instance, cube_id, &iter->tag_list[iter->curr_cell_idx], metric_id, &value);
+        int tmp_ret = fieldstat_counter_get(iter->instance, cube_id, &iter->cell_dimension[iter->curr_cell_idx], metric_id, &value);
         if (tmp_ret < 0) {
             return NULL;
         }
@@ -542,7 +541,7 @@ struct export_kv_pair *cell_query_with_iter(const struct cell_iter *iter, int me
     if (type == METRIC_TYPE_HLL || type == METRIC_TYPE_HISTOGRAM) {
         char *value;
         size_t len;
-        fieldstat_metric_get_serialization_as_base64(iter->instance, cube_id, metric_id, &iter->tag_list[iter->curr_cell_idx], &value, &len);
+        fieldstat_metric_get_serialization_as_base64(iter->instance, cube_id, metric_id, &iter->cell_dimension[iter->curr_cell_idx], &value, &len);
         if (value == NULL) {
             return NULL;
         }
@@ -574,52 +573,51 @@ void kv_pair_write_to_json(const struct export_kv_pair *pairs, struct json_write
     }
 }
 
-void tag_list_append_to_tag_object(const struct field_list *tag_list, struct json_writer *cjson_tags)
+void field_list_write_to_json(const struct field_list *field_list, struct json_writer *json_obj)
 {
-    size_t tag_list_len = tag_list->n_field;
     struct export_kv_pair pairs = {0};
 
-    for (int i = 0; i < tag_list_len; i++) {
-        if (tag_list->n_field == 0) {
+    for (int i = 0; i < field_list->n_field; i++) {
+        if (field_list->n_field == 0) {
             continue;
         }
         memset(&pairs, 0, sizeof(struct export_kv_pair));
-        pairs.key = (char *)tag_list->field[i].key;
-        pairs.type = tag_list->field[i].type;
+        pairs.key = (char *)field_list->field[i].key;
+        pairs.type = field_list->field[i].type;
         switch (pairs.type)
         {
             case FIELD_VALUE_INTEGER:
-                pairs.value_longlong = tag_list->field[i].value_longlong;
+                pairs.value_longlong = field_list->field[i].value_longlong;
                 break;
             case FIELD_VALUE_DOUBLE:
-                pairs.value_double = tag_list->field[i].value_double;
+                pairs.value_double = field_list->field[i].value_double;
                 break;
             case FIELD_VALUE_CSTRING:
-                pairs.value_str = (char *)tag_list->field[i].value_str;
+                pairs.value_str = (char *)field_list->field[i].value_str;
                 break;
             default:
                 break;
         }
-        kv_pair_write_to_json(&pairs, cjson_tags);
+        kv_pair_write_to_json(&pairs, json_obj);
     }
 }
 
-void cell_iter_read_tag_list(const struct cell_iter *iter, struct export_kv_pair **exported_tags, size_t *len_out)
+void cell_iter_read_dimensions(const struct cell_iter *iter, struct export_kv_pair **exported_dimensions, size_t *n_dimension_out)
 {
-    struct field_list *tag_list_cell = &iter->tag_list[iter->curr_cell_idx];
-    struct field_list *tag_arr_shared = iter->shared_tag;
+    struct field_list *field_list_cell = &iter->cell_dimension[iter->curr_cell_idx];
+    struct field_list *field_list_cube = iter->cube_dimension;
 
-    size_t ret_tag_list_len = tag_list_cell->n_field + tag_arr_shared->n_field;
+    size_t ret_n_dimension = field_list_cell->n_field + field_list_cube->n_field;
 
-    struct export_kv_pair *tag_list = malloc(sizeof(struct export_kv_pair) * ret_tag_list_len);
-    *exported_tags = tag_list;
-    *len_out = ret_tag_list_len;
+    struct export_kv_pair *ret = malloc(sizeof(struct export_kv_pair) * ret_n_dimension);
+    *exported_dimensions = ret;
+    *n_dimension_out = ret_n_dimension;
 
-    for (int i = 0; i < tag_list_cell->n_field; i++) {
-        kv_pair_fill_with_tags(tag_list++, &tag_list_cell->field[i]);
+    for (int i = 0; i < field_list_cell->n_field; i++) {
+        kv_pair_fill_with_fields(ret++, &field_list_cell->field[i]);
     }
-    for (int i = 0; i < tag_arr_shared->n_field; i++) {
-        kv_pair_fill_with_tags(tag_list++, &tag_arr_shared->field[i]);
+    for (int i = 0; i < field_list_cube->n_field; i++) {
+        kv_pair_fill_with_fields(ret++, &field_list_cube->field[i]);
     }
 }
 
@@ -636,12 +634,12 @@ void kv_pair_free_list(struct export_kv_pair *pairs, size_t len)
 }
 
 // return 1 if added, 0 if not added
-int cjson_map_add(struct cellwise_rec_for_export *tag_field_pair, const struct cell_iter *iter)
+int json_obj_add(struct cellwise_rec_for_export *tag_field_pair, const struct cell_iter *iter)
 {
     struct export_kv_pair **fields = NULL;
     int *metric_ids = NULL;
     size_t n_metric = 0;
-    fieldstat_get_metric_in_cell(iter->instance, iter->cube_ids[iter->curr_cube_idx], &iter->tag_list[iter->curr_cell_idx], &metric_ids, &n_metric);
+    fieldstat_get_metric_in_cell(iter->instance, iter->cube_ids[iter->curr_cube_idx], &iter->cell_dimension[iter->curr_cell_idx], &metric_ids, &n_metric);
     if (n_metric == 0) {
         // printf("cannot get metric in cell\n");
         return 0;
@@ -665,15 +663,15 @@ int cjson_map_add(struct cellwise_rec_for_export *tag_field_pair, const struct c
     tag_field_pair->metric_pairs = fields;
     tag_field_pair->n_metric = n_nonempty_metrics;
 
-    struct export_kv_pair *tag_list;
-    size_t tag_list_len;
-    cell_iter_read_tag_list(iter, &tag_list, &tag_list_len);
+    struct export_kv_pair *dimensions;
+    size_t n_pair;
+    cell_iter_read_dimensions(iter, &dimensions, &n_pair);
     struct json_writer *writer_tag = json_writer_init();
-    for (int i = 0; i < tag_list_len; i++) {
-        kv_pair_write_to_json(&tag_list[i], writer_tag);
+    for (int i = 0; i < n_pair; i++) {
+        kv_pair_write_to_json(&dimensions[i], writer_tag);
     }
-    kv_pair_free_list(tag_list, tag_list_len);
-    tag_field_pair->cjson_tags = writer_tag;
+    kv_pair_free_list(dimensions, n_pair);
+    tag_field_pair->tag_json_obj = writer_tag;
 
     return 1;
 }
@@ -703,7 +701,7 @@ struct cellwise_rec_for_export *read_tag_and_field(const struct fieldstat *insta
     int i = 0;
     while (cell_iter_next(iter)) {
         // next_num++;
-        if (cjson_map_add(&tag_field_pair[i], iter) == 0) {
+        if (json_obj_add(&tag_field_pair[i], iter) == 0) {
             continue;
         }
         i++;
@@ -722,7 +720,7 @@ void fieldstat_json_exporter_write_global_tags(const struct fieldstat_json_expor
     }
     
     for (int i = 0; i < arr_len; i++) {
-        tag_list_append_to_tag_object(exporter->global_tag_list, tag_field_pair_arr[i].cjson_tags);
+        field_list_write_to_json(exporter->global_tag_list, tag_field_pair_arr[i].tag_json_obj);
     }
 }
 
@@ -832,7 +830,7 @@ void fieldstat_json_exporter_export_array(const struct fieldstat_json_exporter *
 
         json_writer_start_map(root);
         json_writer_str_field(root, "name", tmp_name, strlen(tmp_name));
-        json_writer_object_item(root, "tags", current->cjson_tags);
+        json_writer_object_item(root, "tags", current->tag_json_obj);
         json_writer_object_item(root, "fields", field_json);
         if (exporter->history != NULL) {
             json_writer_object_item(root, "fields_delta", field_json_delta);
@@ -927,7 +925,7 @@ char *fieldstat_json_exporter_export_with_delta(const struct fieldstat_json_expo
 
         json_writer_start_map(root);
         json_writer_str_field(root, "name", tmp_name, strlen(tmp_name));
-        json_writer_object_item(root, "tags", current->cjson_tags);
+        json_writer_object_item(root, "tags", current->tag_json_obj);
         json_writer_object_item(root, "fields", field_json);
         json_writer_object_item(root, "fields_delta", field_json_delta);
         json_writer_longlong_field(root, "timestamp_ms", cal_ms_time(timestamp));
@@ -956,7 +954,7 @@ char *fieldstat_json_exporter_export_with_delta(const struct fieldstat_json_expo
         free(expair_delta[i].metric_pairs);
         char *dummy_s;
         size_t dummy_len;
-        json_writer_finish(expair_delta[i].cjson_tags, &dummy_s, &dummy_len); // the field json is not added to the root json, so we need to free it manually
+        json_writer_finish(expair_delta[i].tag_json_obj, &dummy_s, &dummy_len); // the field json is not added to the root json, so we need to free it manually
         free(dummy_s);
     }
     free(expair_delta);
@@ -1022,7 +1020,7 @@ void fieldstat_json_exporter_free(struct fieldstat_json_exporter *exporter)
         free(exporter->name);
     }
     if (exporter->global_tag_list != NULL) {
-        fieldstat_tag_list_arr_free(exporter->global_tag_list, 1);
+        fieldstat_field_list_arr_free(exporter->global_tag_list, 1);
     }
 
     if (exporter->history != NULL) {
@@ -1057,7 +1055,7 @@ void fieldstat_json_exporter_export_flat_array(const struct fieldstat_json_expor
     char **cjson_str_arr = (char **)malloc(sizeof(char *) * n_pair);
     for (int i = 0; i < n_pair; i++) {
         struct cellwise_rec_for_export *current = &tag_field_pair[i];
-        struct json_writer *root = current->cjson_tags;
+        struct json_writer *root = current->tag_json_obj;
         for (int j = 0; j < tag_field_pair[i].n_metric; j++) {
             kv_pair_write_to_json(tag_field_pair[i].metric_pairs[j], root);
         }
diff --git a/src/fieldstat.c b/src/fieldstat.c
index 5c255ed..0896e0f 100644
--- a/src/fieldstat.c
+++ b/src/fieldstat.c
@@ -64,18 +64,6 @@ int fieldstat_cube_destroy(struct fieldstat *instance, int cube_id)
 /*                                    cube                                    */
 /* -------------------------------------------------------------------------- */
 
-void fieldstat_free_tag_array(struct field *fields, size_t n_tags)
-{
-    for (size_t i = 0; i < n_tags; i++) {
-        struct field *field = &fields[i];
-        free((char *)field->key);
-        if (field->type == FIELD_VALUE_CSTRING) {
-            free((char *)field->value_str);
-        }
-    }
-    free(fields);
-}
-
 // cppcheck-suppress [constParameterPointer, unmatchedSuppression]
 int fieldstat_cube_set_sampling(struct fieldstat *instance, int cube_id, enum sampling_mode mode, int max_n_cell, int primary_metric_id) {
     if (max_n_cell <= 0) {
@@ -230,8 +218,6 @@ struct fieldstat *fieldstat_fork(const struct fieldstat *instance)
 void fieldstat_calibrate(const struct fieldstat *master, struct fieldstat *replica)
 {
     cube_manager_calibrate(replica->cube_manager, master->cube_manager);
-
-    return FS_OK;
 }
 
 /* -------------------------------------------------------------------------- */
@@ -242,7 +228,7 @@ void fieldstat_get_cubes(const struct fieldstat *instance, int **cube_ids, int *
     cube_manager_list(instance->cube_manager, cube_ids, n_cube);
 }
 
-struct field_list *fieldstat_cube_get_tags(const struct fieldstat *instance, int cube_id)
+struct field_list *fieldstat_cube_get_dimensions(const struct fieldstat *instance, int cube_id)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
@@ -315,15 +301,22 @@ void fieldstat_metric_get_serialization_as_base64(const struct fieldstat *instan
     cube_get_serialization_as_base64(cube, metric_id, cell_dimensions, blob, blob_size);
 }
 
-void fieldstat_tag_list_arr_free(struct field_list *tag_list, size_t n_cell)
+void fieldstat_field_list_arr_free(struct field_list *field_lists, size_t n_field_list)
 {
-    if (tag_list == NULL) {
+    if (field_lists == NULL) {
         return;
     }
-    for (int i = 0; i < n_cell; i++) {
-        fieldstat_free_tag_array(tag_list[i].field, tag_list[i].n_field);
+    for (int i = 0; i < n_field_list; i++) {
+        for (size_t j = 0; j < field_lists[i].n_field; j++) {
+            struct field *field = &(field_lists[i].field[j]);
+            free((char *)field->key);
+            if (field->type == FIELD_VALUE_CSTRING) {
+                free((char *)field->value_str);
+            }
+        }
+        free(field_lists[i].field);
     }
-    free(tag_list);
+    free(field_lists);
 }
 
 const char *fieldstat_get_metric_name(const struct fieldstat *instance, int cube_id, int metric_id)