🐞 fix(fieldstat.h): rename field_type to field_metric_typev3.1.1

15 files changed, 271 insertions, 271 deletions

diff --git a/inc/fieldstat.h b/inc/fieldstat.h
index 3b37204..a3a3ca2 100644
--- a/inc/fieldstat.h
+++ b/inc/fieldstat.h
@@ -5,12 +5,12 @@ extern "C"
 {
 #endif
 
-enum field_type
+enum field_metric_type
 {
-	FIELD_TYPE_COUNTER,
-	FIELD_TYPE_GAUGE,
-	FILED_TYPE_HISTOGRAM,
-	FIELD_TYPE_SUMMARY
+	FIELD_METRIC_TYPE_COUNTER,
+	FIELD_METRIC_TYPE_GAUGE,
+	FILED_METRIC_TYPE_DISTRIBUTION,
+	FIELD_METRIC_TYPE_SUMMARY
 };
 
 
@@ -99,7 +99,7 @@ int fieldstat_set_output_interval(struct fieldstat_instance *instance, int milli
  * @param n_tag Size of tags[]
  * @return metric id. -1 is failed. >=0 is success.
  */
-int fieldstat_register(struct fieldstat_instance *instance, enum field_type type, const char *field_name, const struct field_tag tags[], size_t n_tag);
+int fieldstat_register(struct fieldstat_instance *instance, enum field_metric_type type, const char *field_name, const struct field_tag tags[], size_t n_tag);
 /**
  * Register table. Max table num is 64. Max table columns is 64.
  * @param instance The fieldstat instance.
@@ -109,7 +109,7 @@ int fieldstat_register(struct fieldstat_instance *instance, enum field_type type
  * @param n_column size of column_type[] and column_name[]
  * @return table id.  -1 is failed. >=0 is success.
  */
-int fieldstat_register_table(struct fieldstat_instance *instance, const char *table_name, const char *column_name[], enum field_type column_type[], size_t n_column);
+int fieldstat_register_table(struct fieldstat_instance *instance, const char *table_name, const char *column_name[], enum field_metric_type column_type[], size_t n_column);
 /**
  * Register table row
  * @param instance The fieldstat instance.
@@ -249,7 +249,7 @@ void fieldstat_dynamic_instance_start(struct fieldstat_dynamic_instance *instanc
  * @param out_column_ids output metric id in table row.
  * @return table id.  -1 is failed. >=0 is success.
  */
-int fieldstat_register_dynamic_table(struct fieldstat_dynamic_instance *instance, const char *table_name, const char *column_name[], enum field_type column_type[], size_t n_column, unsigned int out_column_ids[]);
+int fieldstat_register_dynamic_table(struct fieldstat_dynamic_instance *instance, const char *table_name, const char *column_name[], enum field_metric_type column_type[], size_t n_column, unsigned int out_column_ids[]);
 /**
  * fieldstat dynamic instance metric value increment operate. metirc type in[gauge, counter]
  * @param instance The fieldstat dynamic instance.
@@ -261,7 +261,7 @@ int fieldstat_register_dynamic_table(struct fieldstat_dynamic_instance *instance
  * @param thread_id The thread id of the call.
  * @return -1 is failed. 0 is success.
  */
-int fieldstat_dynamic_metric_value_incrby(struct fieldstat_dynamic_instance *instance, enum field_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id);
+int fieldstat_dynamic_metric_value_incrby(struct fieldstat_dynamic_instance *instance, enum field_metric_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id);
 /**
  * fieldstat dynamic instance metric value set operate. metirc type in[gauge, counter]
  * @param instance The fieldstat dynamic instance.
@@ -273,7 +273,7 @@ int fieldstat_dynamic_metric_value_incrby(struct fieldstat_dynamic_instance *ins
  * @param thread_id The thread id of the call.
  * @return -1 is failed. 0 is success.
  */
-int fieldstat_dynamic_metric_value_set(struct fieldstat_dynamic_instance *instance, enum field_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id);
+int fieldstat_dynamic_metric_value_set(struct fieldstat_dynamic_instance *instance, enum field_metric_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id);
 /**
  * fieldstat dynamic instance metric value decrment operate. metirc type in[gauge, counter]
  * @param instance The fieldstat dynamic instance.
@@ -285,7 +285,7 @@ int fieldstat_dynamic_metric_value_set(struct fieldstat_dynamic_instance *instan
  * @param thread_id The thread id of the call.
  * @return -1 is failed. 0 is success.
  */
-int fieldstat_dynamic_metric_value_decrby(struct fieldstat_dynamic_instance *instance, enum field_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id);
+int fieldstat_dynamic_metric_value_decrby(struct fieldstat_dynamic_instance *instance, enum field_metric_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id);
 /**
  * fieldstat dynamic instance table metric value incrment operate.
  * @param instance The fieldstat dynamic instance.
diff --git a/readme.md b/readme.md
index f18c92a..8cbc184 100644
--- a/readme.md
+++ b/readme.md
@@ -160,7 +160,7 @@ int ret = fieldstat_set_local_output(instance, "/tmp/fieldstat3.txt", "default")
 ```c
 int ret = -1;
 const char *columns[]          = {"column0", "column1", "column2", "column3"};
-enum field_type columns_type[] = {FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+enum field_type columns_type[] = {FIELD_METRIC_TYPE_COUNTER,FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 int table_id = fieldstat_register_table(instance, "table_name", columns, columns_type, sizeof(columns)/sizeof(column[0]));
 
 int output_metrics_id[4];
@@ -175,7 +175,7 @@ ret = fieldstat_value_set(instance, output_metric_ids[0], 1);
 #### Register and Operate Counter
 ```c
 int ret = 0;
-int mid = fieldstat_register(instance, FIELD_TYPE_COUNTER, "counter00", NULL, 0);
+int mid = fieldstat_register(instance, FIELD_METRIC_TYPE_COUNTER, "counter00", NULL, 0);
 //Incrby
 ret = fieldstat_value_incrby(instance, mid, 10);
 //Decrby
@@ -186,7 +186,7 @@ ret = fieldstat_value_set(instance, mid, 10);
 #### Register and Operate Gague
 ```c
 int ret = 0;
-int mid = fieldstat_register(instance, FIELD_TYPE_GAUGE,   "gauge00",   NULL, 0);
+int mid = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE,   "gauge00",   NULL, 0);
 //Incrby
 ret = fieldstat_value_incrby(instance, mid, 10);
 //Decrby
@@ -230,7 +230,7 @@ int thread_id = 0;
 int out_column_ids[4];
 
 const char *columns[]          = {"column0", "column1", "column2", "column3"};
-enum field_type columns_type[] = {FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+enum field_type columns_type[] = {FIELD_METRIC_TYPE_COUNTER,FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 int table_id = fieldstat_register_dynamic_table(instance, "table_name", columns, columns_type, sizeof(columns)/sizeof(columns[0]), out_column_ids);
 //Incrby
 ret = fieldstat_dynamic_table_metric_value_incrby(instance, table_id, out_column_ids[0], "table_name", 1, NULL, 0, thread_id);
@@ -244,22 +244,22 @@ ret = fieldstat_dynamic_table_metric_value_set(instance, table_id, out_column_id
 int ret = 0;
 int thread_id = 0;
 //Incrby
-ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_COUNTER, "counter00", 1, NULL, 0, thread_id);
+ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_COUNTER, "counter00", 1, NULL, 0, thread_id);
 //Decrby
-ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_TYPE_COUNTER, "counter00", 1, NULL, 0, thread_id);
+ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_METRIC_TYPE_COUNTER, "counter00", 1, NULL, 0, thread_id);
 //Set
-ret = fieldstat_dynamic_metric_value_set(instance,    FIELD_TYPE_COUNTER, "counter00", 1, NULL, 0, thread_id);
+ret = fieldstat_dynamic_metric_value_set(instance,    FIELD_METRIC_TYPE_COUNTER, "counter00", 1, NULL, 0, thread_id);
 ```
 #### Register and Operate Gauge
 ```c
 int ret = 0;
 int thread_id = 0;
 //Incrby
-ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, "counter00", 1, NULL, 0, thread_id);
+ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, "counter00", 1, NULL, 0, thread_id);
 //Decrby
-ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_TYPE_GAUGE, "counter00", 1, NULL, 0, thread_id);
+ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_METRIC_TYPE_GAUGE, "counter00", 1, NULL, 0, thread_id);
 //Set
-ret = fieldstat_dynamic_metric_value_set(instance,    FIELD_TYPE_GAUGE, "counter00", 1, NULL, 0, thread_id);
+ret = fieldstat_dynamic_metric_value_set(instance,    FIELD_METRIC_TYPE_GAUGE, "counter00", 1, NULL, 0, thread_id);
 ``` 
 
 #### Start Fieldstat Instance
diff --git a/src/fieldstat.cpp b/src/fieldstat.cpp
index 8e5cdf8..c26aa5b 100644
--- a/src/fieldstat.cpp
+++ b/src/fieldstat.cpp
@@ -205,7 +205,7 @@ void add_tags_to_metric(const struct field_tag tags[], size_t n_tag, char *tag_k
 	}
 }
 
-struct metric * metric_new(enum field_type type, const char *field_name, const struct field_tag tags[], size_t n_tag)
+struct metric * metric_new(enum field_metric_type type, const char *field_name, const struct field_tag tags[], size_t n_tag)
 {
 	struct metric *metric = (struct metric*)calloc(1, sizeof(struct metric));
 	metric->field_name = __str_dup(field_name);
@@ -242,8 +242,8 @@ void metric_free(struct metric *metric)
 	{
 		metric->table = NULL;
 	}
-	if(metric->field_type == FIELD_TYPE_SUMMARY || 
-	   metric->field_type == FILED_TYPE_HISTOGRAM)
+	if(metric->field_type == FIELD_METRIC_TYPE_SUMMARY || 
+	   metric->field_type == FILED_METRIC_TYPE_DISTRIBUTION)
 	{
 		h = &metric->histogram;
 		if(h->changing != NULL)
@@ -273,14 +273,14 @@ void metric_free(struct metric *metric)
 		{
 			switch(metric->field_type)
 			{
-				case FIELD_TYPE_COUNTER:
+				case FIELD_METRIC_TYPE_COUNTER:
 					if(metric->counter.changing != NULL)
 					{
 						free(metric->counter.changing);
 						metric->counter.changing = NULL;
 					}
 					break;
-				case FIELD_TYPE_GAUGE:
+				case FIELD_METRIC_TYPE_GAUGE:
 					if(metric->gauge.changing != NULL)
 					{
 						free(metric->gauge.changing);
@@ -507,7 +507,7 @@ int fieldstat_set_statsd_server(struct fieldstat_instance *instance, const char
 	return 0;
 }
 
-int fieldstat_register(struct fieldstat_instance *instance, enum field_type type, const char *field_name, const struct field_tag tags[], size_t n_tag)
+int fieldstat_register(struct fieldstat_instance *instance, enum field_metric_type type, const char *field_name, const struct field_tag tags[], size_t n_tag)
 {
 	int metric_id = 0;
 	struct metric *metric = NULL;
@@ -532,11 +532,11 @@ int fieldstat_register(struct fieldstat_instance *instance, enum field_type type
 	metric->is_atomic_counter = 0;
 	switch(type)
 	{
-		case FIELD_TYPE_COUNTER:
+		case FIELD_METRIC_TYPE_COUNTER:
 			memset(&(metric->counter), 0, sizeof(metric->counter));
 			metric->counter.changing = (struct threadsafe_counter *)calloc(1, sizeof(struct threadsafe_counter));
 			break;
-		case FIELD_TYPE_GAUGE:
+		case FIELD_METRIC_TYPE_GAUGE:
 			memset(&(metric->gauge), 0, sizeof(metric->gauge));
 			metric->gauge.changing   = (struct threadsafe_counter *)calloc(1, sizeof(struct threadsafe_counter));
 			break;
@@ -553,10 +553,10 @@ long long get_metric_unit_val(struct metric *metric,enum field_calc_algo calc_ty
 	long long value = 0;
 	switch(metric->field_type)
 	{
-		case FIELD_TYPE_COUNTER:
+		case FIELD_METRIC_TYPE_COUNTER:
 			target = &(metric->counter);
 			break;
-		case FIELD_TYPE_GAUGE:
+		case FIELD_METRIC_TYPE_GAUGE:
 			target = &(metric->gauge);
 			break;
 		default:
@@ -600,10 +600,10 @@ long long read_metric_current_value(struct metric *metric)
 	long long value = 0;
 	switch(metric->field_type)
 	{
-		case FIELD_TYPE_COUNTER:
+		case FIELD_METRIC_TYPE_COUNTER:
 			target = &(metric->counter);
 			break;
-		case FIELD_TYPE_GAUGE:
+		case FIELD_METRIC_TYPE_GAUGE:
 			target = &(metric->gauge);
 			break;
 		default:
@@ -615,7 +615,7 @@ long long read_metric_current_value(struct metric *metric)
 	else
 	 	value = atomic_read(&(target->atomic_changing));
 
-	if(metric->field_type == FIELD_TYPE_GAUGE)
+	if(metric->field_type == FIELD_METRIC_TYPE_GAUGE)
 	{
 		value += target->accumulated;
 	}
@@ -774,7 +774,7 @@ void fieldstat_instance_free(struct fieldstat_instance *instance)
 }
 
 
-struct table_metric* table_metric_new(const char *name, const char *column_name[], enum field_type column_type[], size_t n_column)
+struct table_metric* table_metric_new(const char *name, const char *column_name[], enum field_metric_type column_type[], size_t n_column)
 {
 	int i = 0;
 	struct table_metric *table_metric = (struct table_metric *)calloc(1, sizeof(struct table_metric));
@@ -837,7 +837,7 @@ void table_metric_free(struct table_metric *table)
 }
 
 
- int fieldstat_register_table(struct fieldstat_instance *instance, const char *table_name, const char *column_name[], enum field_type column_type[], size_t n_column)
+ int fieldstat_register_table(struct fieldstat_instance *instance, const char *table_name, const char *column_name[], enum field_metric_type column_type[], size_t n_column)
  {
 	int table_id = 0;
 
@@ -854,7 +854,7 @@ void table_metric_free(struct table_metric *table)
 		{
 			return -1;
 		}
-		if(column_type[i] != FIELD_TYPE_GAUGE && column_type[i] != FIELD_TYPE_COUNTER)
+		if(column_type[i] != FIELD_METRIC_TYPE_GAUGE && column_type[i] != FIELD_METRIC_TYPE_COUNTER)
 		{
 			return -1;
 		}
@@ -997,14 +997,14 @@ void metric_value_operate(struct metric *metric, enum field_op op, long long val
 	struct stat_unit_t *target = NULL;
 	switch(metric->field_type)
 	{
-		case FIELD_TYPE_COUNTER:
+		case FIELD_METRIC_TYPE_COUNTER:
 			target = &(metric->counter);
 			break;
-		case FIELD_TYPE_GAUGE:
+		case FIELD_METRIC_TYPE_GAUGE:
 			target = &(metric->gauge);
 			break;
-		case FIELD_TYPE_SUMMARY:
-		case FILED_TYPE_HISTOGRAM: 
+		case FIELD_METRIC_TYPE_SUMMARY:
+		case FILED_METRIC_TYPE_DISTRIBUTION: 
 			hdr_record_value(metric->histogram.changing, (int64_t) value);
 			return;
 		default:
@@ -1075,7 +1075,7 @@ int fieldstat_value_decrby(struct fieldstat_instance *instance, int metric_id, l
 	return ret;
 }
 
-static int parse_histogram_bin_format(const char* format, double **output_bins, enum field_type type)
+static int parse_histogram_bin_format(const char* format, double **output_bins, enum field_metric_type type)
 {
 	char *token=NULL,*sub_token=NULL,*saveptr;
 	size_t i=0;
@@ -1096,7 +1096,7 @@ static int parse_histogram_bin_format(const char* format, double **output_bins,
 		if (sub_token == NULL)
 			break;
 		ret=sscanf(sub_token,"%lf",bins+i);
-		if(type == FIELD_TYPE_SUMMARY)
+		if(type == FIELD_METRIC_TYPE_SUMMARY)
 		{
 			if(bins[i]>1.0)
 			{
@@ -1118,7 +1118,7 @@ error_out:
 }
 
 
-static int fieldstat_register_histogram(struct fieldstat_instance *instance, enum field_type type, const char *field_name, const struct field_tag tags[], size_t n_tag, 
+static int fieldstat_register_histogram(struct fieldstat_instance *instance, enum field_metric_type type, const char *field_name, const struct field_tag tags[], size_t n_tag, 
 		const char * bins, long long lowest_trackable_value, long long highest_trackable_value, int significant_figures, int output_window)
 {
 	struct metric *metric = NULL;
@@ -1167,10 +1167,10 @@ static int fieldstat_register_histogram(struct fieldstat_instance *instance, enu
 
 	switch(type)
 	{
-		case FIELD_TYPE_SUMMARY:
+		case FIELD_METRIC_TYPE_SUMMARY:
 			atomic_inc(&instance->summary_cnt);
 			break;
-		case FILED_TYPE_HISTOGRAM:
+		case FILED_METRIC_TYPE_DISTRIBUTION:
 			atomic_inc(&instance->histogram_cnt);
 			break;
 		default:
@@ -1184,14 +1184,14 @@ static int fieldstat_register_histogram(struct fieldstat_instance *instance, enu
 int fieldstat_register_distribution(struct fieldstat_instance *instance, const char *field_name,const struct field_tag tags[], size_t n_tag, 
 		const char * bins, long long lowest_trackable_value, long long highest_trackable_value, int significant_figures, int output_window)
 {
-	return fieldstat_register_histogram(instance, FILED_TYPE_HISTOGRAM, field_name, tags, n_tag, 
+	return fieldstat_register_histogram(instance, FILED_METRIC_TYPE_DISTRIBUTION, field_name, tags, n_tag, 
 		bins, lowest_trackable_value, highest_trackable_value, significant_figures, output_window);
 }
 
 int fieldstat_register_summary(struct fieldstat_instance *instance, const char *field_name, const struct field_tag tags[], size_t n_tag, 
 		const char * bins, long long lowest_trackable_value, long long highest_trackable_value, int significant_figures, int output_window)
 {
-	return fieldstat_register_histogram(instance, FIELD_TYPE_SUMMARY, field_name, tags, n_tag, 
+	return fieldstat_register_histogram(instance, FIELD_METRIC_TYPE_SUMMARY, field_name, tags, n_tag, 
 		bins, lowest_trackable_value, highest_trackable_value, significant_figures, output_window);
 }
 
@@ -1247,17 +1247,17 @@ int fieldstat_set_metric_ratio_para(struct fieldstat_instance *instance, int met
 	metric_n = get_metric(instance, numerator_metric_id);
 	metric_d = get_metric(instance, denominator_metric_id);
 
-	if(metric->field_type != FIELD_TYPE_GAUGE && metric->field_type != FIELD_TYPE_COUNTER)
+	if(metric->field_type != FIELD_METRIC_TYPE_GAUGE && metric->field_type != FIELD_METRIC_TYPE_COUNTER)
 	{
 		return -1;
 	}
 
-	if(metric_n->field_type != FIELD_TYPE_GAUGE && metric_n->field_type != FIELD_TYPE_COUNTER)
+	if(metric_n->field_type != FIELD_METRIC_TYPE_GAUGE && metric_n->field_type != FIELD_METRIC_TYPE_COUNTER)
 	{
 		return -1;
 	}
 
-	if(metric_d->field_type != FIELD_TYPE_GAUGE && metric_d->field_type != FIELD_TYPE_COUNTER)
+	if(metric_d->field_type != FIELD_METRIC_TYPE_GAUGE && metric_d->field_type != FIELD_METRIC_TYPE_COUNTER)
 	{
 		return -1;
 	}
diff --git a/src/fieldstat_dynamic.cpp b/src/fieldstat_dynamic.cpp
index 375de17..8861db0 100644
--- a/src/fieldstat_dynamic.cpp
+++ b/src/fieldstat_dynamic.cpp
@@ -251,7 +251,7 @@ void fieldstat_dynamic_instance_start(struct fieldstat_dynamic_instance *instanc
 	}
 }
 
-int fieldstat_register_dynamic_table(struct fieldstat_dynamic_instance *instance, const char *table_name, const char *column_name[], enum field_type column_type[], size_t n_column, unsigned int out_column_ids[])
+int fieldstat_register_dynamic_table(struct fieldstat_dynamic_instance *instance, const char *table_name, const char *column_name[], enum field_metric_type column_type[], size_t n_column, unsigned int out_column_ids[])
 {
 	int table_id = 0;
 	int i = 0;
@@ -269,7 +269,7 @@ int fieldstat_register_dynamic_table(struct fieldstat_dynamic_instance *instance
 		{
 			return -1;
 		}
-		if(column_type[i] != FIELD_TYPE_GAUGE && column_type[i] != FIELD_TYPE_COUNTER)
+		if(column_type[i] != FIELD_METRIC_TYPE_GAUGE && column_type[i] != FIELD_METRIC_TYPE_COUNTER)
 		{
 			return -1;
 		}
@@ -465,10 +465,10 @@ static struct metric * create_dynamic_table_metric(struct fieldstat_dynamic_inst
 		metric->is_atomic_counter = 1;
 		switch(table->column_type[i])
 		{
-			case FIELD_TYPE_COUNTER:
+			case FIELD_METRIC_TYPE_COUNTER:
 				memset(&(metric->counter), 0, sizeof(metric->counter));
 				break;
-			case FIELD_TYPE_GAUGE:
+			case FIELD_METRIC_TYPE_GAUGE:
 				memset(&(metric->gauge), 0, sizeof(metric->gauge));
 				break;
 			default:
@@ -513,7 +513,7 @@ static struct metric * create_dynamic_table_metric(struct fieldstat_dynamic_inst
 }
 
 
-static struct metric * create_dynamic_metric(struct fieldstat_dynamic_instance *instance, enum field_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id)
+static struct metric * create_dynamic_metric(struct fieldstat_dynamic_instance *instance, enum field_metric_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id)
 {
 	struct dynamic_metric **head = NULL;
 	struct dynamic_metric *insert = NULL;
@@ -544,10 +544,10 @@ static struct metric * create_dynamic_metric(struct fieldstat_dynamic_instance *
 	metric->is_atomic_counter = 1;
 	switch(metric->field_type)
 	{
-		case FIELD_TYPE_COUNTER:
+		case FIELD_METRIC_TYPE_COUNTER:
 			memset(&(metric->counter), 0, sizeof(metric->counter));
 			break;
-		case FIELD_TYPE_GAUGE:
+		case FIELD_METRIC_TYPE_GAUGE:
 			memset(&(metric->gauge), 0, sizeof(metric->gauge));
 			break;
 		default:
@@ -582,7 +582,7 @@ static struct metric * create_dynamic_metric(struct fieldstat_dynamic_instance *
 }
 
 
-static int fieldstat_dynamic_metric_value_operate(struct fieldstat_dynamic_instance *instance, enum field_op op, enum field_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id)
+static int fieldstat_dynamic_metric_value_operate(struct fieldstat_dynamic_instance *instance, enum field_op op, enum field_metric_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id)
 {
 	struct metric * metric = NULL;
 
@@ -602,17 +602,17 @@ static int fieldstat_dynamic_metric_value_operate(struct fieldstat_dynamic_insta
 }
 
 
-int fieldstat_dynamic_metric_value_incrby(struct fieldstat_dynamic_instance *instance, enum field_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id)
+int fieldstat_dynamic_metric_value_incrby(struct fieldstat_dynamic_instance *instance, enum field_metric_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id)
 {
 	return fieldstat_dynamic_metric_value_operate(instance, FS_OP_ADD, type, field_name, value, tags, n_tags, thread_id);
 }
 
-int fieldstat_dynamic_metric_value_set(struct fieldstat_dynamic_instance *instance, enum field_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id)
+int fieldstat_dynamic_metric_value_set(struct fieldstat_dynamic_instance *instance, enum field_metric_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id)
 {
 	return fieldstat_dynamic_metric_value_operate(instance, FS_OP_SET, type, field_name, value, tags, n_tags, thread_id);
 }
 
-int fieldstat_dynamic_metric_value_decrby(struct fieldstat_dynamic_instance *instance, enum field_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id)
+int fieldstat_dynamic_metric_value_decrby(struct fieldstat_dynamic_instance *instance, enum field_metric_type type, const char *field_name, long long value, const struct field_tag tags[], size_t n_tags, int thread_id)
 {
 	return fieldstat_dynamic_metric_value_operate(instance, FS_OP_SUB, type, field_name, value, tags, n_tags, thread_id);
 }
@@ -758,10 +758,10 @@ static struct metric **create_dynamic_table_row_metrics(
 		metric->is_atomic_counter = 1;
 		switch(table->column_type[i])
 		{
-			case FIELD_TYPE_COUNTER:
+			case FIELD_METRIC_TYPE_COUNTER:
 				memset(&(metric->counter), 0, sizeof(metric->counter));
 				break;
-			case FIELD_TYPE_GAUGE:
+			case FIELD_METRIC_TYPE_GAUGE:
 				memset(&(metric->gauge), 0, sizeof(metric->gauge));
 				break;
 			default:
diff --git a/src/fieldstat_internal.h b/src/fieldstat_internal.h
index ab1c083..2e595a2 100644
--- a/src/fieldstat_internal.h
+++ b/src/fieldstat_internal.h
@@ -123,7 +123,7 @@ struct table_metric
 {
 	char *name;
 	char *column_name[TABLE_COLUMN_SIZE];
-	enum field_type column_type[TABLE_COLUMN_SIZE];
+	enum field_metric_type column_type[TABLE_COLUMN_SIZE];
 	int column_invisible[TABLE_COLUMN_SIZE];
 	int column_cnt;
 
@@ -135,7 +135,7 @@ struct table_metric
 struct metric
 {
 	char *field_name;
-	enum field_type field_type;
+	enum field_metric_type field_type;
 	size_t n_tag;
 	char *tag_key[N_TAG_MAX];
 	char *tag_value[N_TAG_MAX];
@@ -289,7 +289,7 @@ long long read_metric_current_value(struct metric *metric);
 int is_valid_field_name(const char* name);
 int is_valid_tags(const struct field_tag *tags, size_t n_tags);
 struct metric ** read_metric_slot(struct fieldstat_instance *instance, int metric_id);
-struct metric * metric_new(enum field_type type, const char *field_name, const struct field_tag tags[], size_t n_tag);
+struct metric * metric_new(enum field_metric_type type, const char *field_name, const struct field_tag tags[], size_t n_tag);
 void metric_free(struct metric *metric);
 int file_output(struct fieldstat_instance *instance,long long interval_ms);
 struct table_line * read_table_line(struct table_metric *table, int line_id);
@@ -299,7 +299,7 @@ void get_current_table_line_cnt(struct fieldstat_instance *instance, int n_table
 int startup_udp();
 
 void metric_value_operate(struct metric *metric, enum field_op op, long long value);
-struct table_metric* table_metric_new(const char *name, const char *column_name[], enum field_type column_type[], size_t n_column);
+struct table_metric* table_metric_new(const char *name, const char *column_name[], enum field_metric_type column_type[], size_t n_column);
 void table_metric_free(struct table_metric *table);
 
 struct table_line *table_line_new(const char *name, const struct field_tag tags[],size_t n_tag);
diff --git a/src/file_output.cpp b/src/file_output.cpp
index cd66ec8..ebde407 100644
--- a/src/file_output.cpp
+++ b/src/file_output.cpp
@@ -75,7 +75,7 @@ static int output_file_format_default_type_gauge(struct fieldstat_instance *inst
 		{
 			continue;
 		}
-		if(metric->field_type != FIELD_TYPE_GAUGE)
+		if(metric->field_type != FIELD_METRIC_TYPE_GAUGE)
 		{
 			continue;
 		}
@@ -153,7 +153,7 @@ static int output_file_format_default_type_counter(struct fieldstat_instance *in
 		{
 			continue;
 		}
-		if(metric->field_type != FIELD_TYPE_COUNTER)
+		if(metric->field_type != FIELD_METRIC_TYPE_COUNTER)
 		{
 			continue;
 		}
@@ -311,7 +311,7 @@ static int build_table_metrics_point(struct fieldstat_instance *instance, struct
 	}
 	switch(metric->field_type)
 	{
-		case FIELD_TYPE_GAUGE:
+		case FIELD_METRIC_TYPE_GAUGE:
 			if(metric->is_ratio == 0)
 			{
 				value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
@@ -326,7 +326,7 @@ static int build_table_metrics_point(struct fieldstat_instance *instance, struct
 			}
 			break;
 
-		case FIELD_TYPE_COUNTER:
+		case FIELD_METRIC_TYPE_COUNTER:
 			if(metric->is_ratio == 0)
 			{
 				value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
@@ -413,30 +413,30 @@ static int output_file_print_hdr_head(struct metric *metric, char *print_buf, si
 	double * bins = metric->histogram.bins;
 	int bins_num  = metric->histogram.bins_num;
 
-	if(metric->field_type == FIELD_TYPE_SUMMARY)
+	if(metric->field_type == FIELD_METRIC_TYPE_SUMMARY)
 	{
 		snprintf(bin_format, sizeof(bin_format), "%%%d.2lf%%%%", HISTOGRAM_WIDTH-1);
 	}
-	if(metric->field_type == FILED_TYPE_HISTOGRAM)
+	if(metric->field_type == FILED_METRIC_TYPE_DISTRIBUTION)
 	{
 		snprintf(bin_format, sizeof(bin_format), "le=%%0.0f");
 	}
 	snprintf(str_format, sizeof(str_format), "%%%ds", HISTOGRAM_WIDTH);
-	if(metric->field_type == FIELD_TYPE_SUMMARY)
+	if(metric->field_type == FIELD_METRIC_TYPE_SUMMARY)
 	{
 		used_len += snprintf(print_buf + used_len, size - used_len, "%-8s\t", "summary");
 	}
-	if(metric->field_type == FILED_TYPE_HISTOGRAM)
+	if(metric->field_type == FILED_METRIC_TYPE_DISTRIBUTION)
 	{
 		used_len += snprintf(print_buf + used_len, size - used_len, "%-8s\t", "histogram");
 	}
 	for(i = 0;i < bins_num; i++)
 	{
-		if(metric->field_type == FIELD_TYPE_SUMMARY)
+		if(metric->field_type == FIELD_METRIC_TYPE_SUMMARY)
 		{
 			snprintf(buff, sizeof(buff), bin_format, bins[i]*100);
 		}
-		if(metric->field_type == FILED_TYPE_HISTOGRAM)
+		if(metric->field_type == FILED_METRIC_TYPE_DISTRIBUTION)
 		{
 			snprintf(buff, sizeof(buff), bin_format, bins[i]);
 		}
@@ -491,11 +491,11 @@ static int output_file_print_hdr_unit(struct metric *metric, char *print_buf, si
 
 	for(i = 0; i < bins_num; i++)
 	{
-		if(metric->field_type == FIELD_TYPE_SUMMARY)
+		if(metric->field_type == FIELD_METRIC_TYPE_SUMMARY)
 		{
 			value = (long long)hdr_value_at_percentile(h_out, bins[i]*100);
 		}
-		if(metric->field_type == FILED_TYPE_HISTOGRAM)
+		if(metric->field_type == FILED_METRIC_TYPE_DISTRIBUTION)
 		{
 			value = hdr_count_le_value(h_out, (long long)bins[i]);
 		}
@@ -544,8 +544,8 @@ static int output_file_format_default_type_histogram_and_summary(struct fieldsta
 		{
 			continue;
 		}
-		if(metric->field_type != FIELD_TYPE_SUMMARY 
-			&& metric->field_type != FILED_TYPE_HISTOGRAM)
+		if(metric->field_type != FIELD_METRIC_TYPE_SUMMARY 
+			&& metric->field_type != FILED_METRIC_TYPE_DISTRIBUTION)
 		{
 			continue;
 		}
@@ -637,8 +637,8 @@ int output_file_format_json(struct fieldstat_instance *instance, int n_cur_metri
 
 		switch(metric->field_type)
 		{
-			case FIELD_TYPE_COUNTER:
-			case FIELD_TYPE_GAUGE:
+			case FIELD_METRIC_TYPE_COUNTER:
+			case FIELD_METRIC_TYPE_GAUGE:
 				tmp_obj = cJSON_CreateObject();
 				cJSON_AddStringToObject(tmp_obj, "name", metric->field_name);
 				if(metric->table)
@@ -646,7 +646,7 @@ int output_file_format_json(struct fieldstat_instance *instance, int n_cur_metri
 					cJSON_AddStringToObject(tmp_obj, "table_name", metric->table->name);
 					cJSON_AddStringToObject(tmp_obj, "column_name", metric->table->column_name[metric->table_column_id]);	
 				}
-				metric->field_type ==  FIELD_TYPE_COUNTER 
+				metric->field_type ==  FIELD_METRIC_TYPE_COUNTER 
 					?cJSON_AddStringToObject(tmp_obj, "type", "counter")
 					:cJSON_AddStringToObject(tmp_obj, "type", "gauge");
 				value = get_metric_unit_val(metric, FS_CALC_CURRENT, 1);
@@ -655,19 +655,19 @@ int output_file_format_json(struct fieldstat_instance *instance, int n_cur_metri
 				cJSON_AddNumberToObject(tmp_obj, "diff", value);
 				cJSON_AddItemToArray(metrics_array_obj, tmp_obj);
 				break;
-			case FIELD_TYPE_SUMMARY:
-			case FILED_TYPE_HISTOGRAM:
+			case FIELD_METRIC_TYPE_SUMMARY:
+			case FILED_METRIC_TYPE_DISTRIBUTION:
 				struct hdr_histogram *h_out = read_hdr_unit_output(metric);
 				for(int j = 0; j < metric->histogram.bins_num; j++)
 				{
 					tmp_obj = cJSON_CreateObject();
-					if(metric->field_type == FIELD_TYPE_SUMMARY)
+					if(metric->field_type == FIELD_METRIC_TYPE_SUMMARY)
 					{
 						value = (long long)hdr_value_at_percentile(h_out, metric->histogram.bins[j]);
 						cJSON_AddStringToObject(tmp_obj, "type", "summary");
 						snprintf(tmp_output_name, sizeof(tmp_output_name), "%s.p%.2f", metric->field_name, metric->histogram.bins[j]);
 					}
-					if(metric->field_type == FILED_TYPE_HISTOGRAM)
+					if(metric->field_type == FILED_METRIC_TYPE_DISTRIBUTION)
 					{
 						value = hdr_count_le_value(h_out, (long long)metric->histogram.bins[j]);
 						cJSON_AddStringToObject(tmp_obj, "type", "histogram");
@@ -689,11 +689,11 @@ int output_file_format_json(struct fieldstat_instance *instance, int n_cur_metri
 					tmp_obj = cJSON_CreateObject();
 					snprintf(tmp_output_name, sizeof(tmp_output_name), "%s.%s", metric->field_name, extra[j]);
 					cJSON_AddStringToObject(tmp_obj, "name", tmp_output_name);
-					if(metric->field_type == FIELD_TYPE_SUMMARY)
+					if(metric->field_type == FIELD_METRIC_TYPE_SUMMARY)
 					{
 						cJSON_AddStringToObject(tmp_obj, "type", "summary");	
 					}
-					if(metric->field_type == FILED_TYPE_HISTOGRAM)
+					if(metric->field_type == FILED_METRIC_TYPE_DISTRIBUTION)
 					{
 						cJSON_AddStringToObject(tmp_obj, "type", "histogram");
 					}
diff --git a/src/line_protocol_output.cpp b/src/line_protocol_output.cpp
index 5c01512..36e313b 100644
--- a/src/line_protocol_output.cpp
+++ b/src/line_protocol_output.cpp
@@ -103,10 +103,10 @@ static long long read_single_metric_value(struct metric *metric, int output_type
 		:is_refer = 1;
 	switch(metric->field_type)
 	{
-		case FIELD_TYPE_GAUGE:
+		case FIELD_METRIC_TYPE_GAUGE:
 			value = get_metric_unit_val(metric, FS_CALC_CURRENT, is_refer);
 			break;
-		case FIELD_TYPE_COUNTER:
+		case FIELD_METRIC_TYPE_COUNTER:
 			value = get_metric_unit_val(metric, FS_CALC_SPEED, is_refer);
 			break;
 		default:
@@ -155,12 +155,12 @@ static int add_hdr_field_set(struct metric *metric, struct hdr_histogram *h_out,
 	{
 		switch(metric->field_type)
 		{
-			case FIELD_TYPE_SUMMARY:
+			case FIELD_METRIC_TYPE_SUMMARY:
 				value = (long long)hdr_value_at_percentile(h_out, bins[i]*100);
 				used_len += snprintf(line_buf + used_len, line_buf_size - used_len, 
 									 "P%d=%lld,", (int)(bins[i]*100), value);
 				break;
-			case FILED_TYPE_HISTOGRAM:
+			case FILED_METRIC_TYPE_DISTRIBUTION:
 				value = hdr_count_le_value(h_out, (long long)bins[i]);
 				used_len += snprintf(line_buf + used_len, line_buf_size - used_len, 
 									 "le%d=%lld,", (int)bins[i], value);
@@ -391,13 +391,13 @@ static void output_line_protocol_single_metric(struct fieldstat_instance *instan
 
 		switch(metric->field_type)
 		{
-			case FIELD_TYPE_GAUGE:
-			case FIELD_TYPE_COUNTER:
+			case FIELD_METRIC_TYPE_GAUGE:
+			case FIELD_METRIC_TYPE_COUNTER:
 				used_len = build_single_metric_line_buf(instance->name, instance->output_type, 
 														metric, line_buf, sizeof(line_buf));
 				break;
-			case FIELD_TYPE_SUMMARY:
-			case FILED_TYPE_HISTOGRAM:
+			case FIELD_METRIC_TYPE_SUMMARY:
+			case FILED_METRIC_TYPE_DISTRIBUTION:
 				used_len = build_hdr_metric_line_buf(instance->name, instance->output_type, 
 													 metric, line_buf, sizeof(line_buf));
 				break;
diff --git a/src/prometheus_output.cpp b/src/prometheus_output.cpp
index 1e556d9..6762304 100644
--- a/src/prometheus_output.cpp
+++ b/src/prometheus_output.cpp
@@ -182,12 +182,12 @@ static int prometheus_output_histogram_and_summary(struct metric *metric, char *
 	int bin_num = metric->histogram.bins_num;
 	double *bins = metric->histogram.bins;
 
-	if(metric->field_type == FILED_TYPE_HISTOGRAM)
+	if(metric->field_type == FILED_METRIC_TYPE_DISTRIBUTION)
 	{
 		output_format = (char *)"%s_bucket{%s,le=\"%0.2f\"} %lld\n";
 	}
 
-	if(metric->field_type == FIELD_TYPE_SUMMARY)
+	if(metric->field_type == FIELD_METRIC_TYPE_SUMMARY)
 	{
 		output_format = (char *)"%s{%s,quantile=\"%0.2f\"} %lld\n";
 	}
@@ -200,11 +200,11 @@ static int prometheus_output_histogram_and_summary(struct metric *metric, char *
 
 	for(i=0;i<bin_num;i++)
 	{
-		if(metric->field_type == FILED_TYPE_HISTOGRAM)
+		if(metric->field_type == FILED_METRIC_TYPE_DISTRIBUTION)
 		{
 			value = (long long)hdr_count_le_value(h_out, (long long)bins[i]);
 		}
-		if(metric->field_type == FIELD_TYPE_SUMMARY)
+		if(metric->field_type == FIELD_METRIC_TYPE_SUMMARY)
 		{
 			value=(long long)hdr_value_at_percentile(h_out, bins[i]*100);
 		}
@@ -320,8 +320,8 @@ static int prometheus_get_instance_metric_playload(struct fieldstat_instance *in
 
 		switch(metric->field_type)
 		{
-			case FIELD_TYPE_COUNTER:
-			case FIELD_TYPE_GAUGE:
+			case FIELD_METRIC_TYPE_COUNTER:
+			case FIELD_METRIC_TYPE_GAUGE:
 				instance->output_type == 1
 					?value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0)
 					:value = get_metric_unit_val(metric, FS_CALC_CURRENT, 1);
@@ -333,8 +333,8 @@ static int prometheus_get_instance_metric_playload(struct fieldstat_instance *in
 											value
 										);
 				break;
-			case FIELD_TYPE_SUMMARY:
-			case FILED_TYPE_HISTOGRAM:
+			case FIELD_METRIC_TYPE_SUMMARY:
+			case FILED_METRIC_TYPE_DISTRIBUTION:
 				append_offset += prometheus_output_histogram_and_summary(metric,new_payload + append_offset,
 								new_payload_size - append_offset, instance_name, metric_name, metric_tags);
 				break;
diff --git a/test/fieldstat_test.cpp b/test/fieldstat_test.cpp
index 4dfec7e..fce2dfc 100644
--- a/test/fieldstat_test.cpp
+++ b/test/fieldstat_test.cpp
@@ -90,11 +90,11 @@ static void* dynamic_register(void* arg)
 		loops--;
 		//fieldstat_value_incrby(instance,g_counter_id[i], i + 1);
 		snprintf(name, sizeof(name), "counter_%d_%d", loops, rand()%10000);
-		fieldstat_register(instance, FIELD_TYPE_COUNTER, name, tags, 1);
+		fieldstat_register(instance, FIELD_METRIC_TYPE_COUNTER, name, tags, 1);
 
 		memset(name, 0, sizeof(name));
 		snprintf(name, sizeof(name), "gauge_%d_%d", loops, rand()%10000);
-		fieldstat_register(instance,FIELD_TYPE_GAUGE, name, tags, 1);
+		fieldstat_register(instance,FIELD_METRIC_TYPE_GAUGE, name, tags, 1);
 
 		memset(name, 0, sizeof(name));
 		snprintf(name, sizeof(name), "summary_%d_%d", loops, rand()%10000);
@@ -175,7 +175,7 @@ int test_register_by_fieldstat_type(struct fieldstat_instance *instance)
 {
 	int ret = 0;
 //Register counter start
-	ret = fieldstat_register(instance, FIELD_TYPE_COUNTER, "counter_no_tags",NULL,0);
+	ret = fieldstat_register(instance, FIELD_METRIC_TYPE_COUNTER, "counter_no_tags",NULL,0);
 	if(ret == -1)
 	{
 		printf("Failed ot register counter_no_tags, type = counter\n");
@@ -188,7 +188,7 @@ int test_register_by_fieldstat_type(struct fieldstat_instance *instance)
 	tag_counter.value_str = "C_one_tag";
 	tag_counter.key = "C_one_tag_yes";
 
-	ret = fieldstat_register(instance, FIELD_TYPE_COUNTER,"counter_with_one_tag", &tag_counter, 1);
+	ret = fieldstat_register(instance, FIELD_METRIC_TYPE_COUNTER,"counter_with_one_tag", &tag_counter, 1);
 	if(ret == -1)
 	{
 		printf("Failed ot register counter_with_one_tag, type = counter\n");
@@ -210,7 +210,7 @@ int test_register_by_fieldstat_type(struct fieldstat_instance *instance)
 	tags_counter[2].key = "C_tags_2_yes";
 
 
-	ret = fieldstat_register(instance, FIELD_TYPE_COUNTER,"counter_with_tags", tags_counter, sizeof(tags_counter)/sizeof(tags_counter[0]));
+	ret = fieldstat_register(instance, FIELD_METRIC_TYPE_COUNTER,"counter_with_tags", tags_counter, sizeof(tags_counter)/sizeof(tags_counter[0]));
 	if(ret == -1)
 	{
 		printf("Failed ot register counter_with_tags, type = counter\n");
@@ -221,7 +221,7 @@ int test_register_by_fieldstat_type(struct fieldstat_instance *instance)
 
 //Register gauge start 
 
-	ret = fieldstat_register(instance, FIELD_TYPE_GAUGE, "gauge_no_tags",NULL,0);
+	ret = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "gauge_no_tags",NULL,0);
 	if(ret == -1)
 	{
 		printf("Failed ot register gauge_no_tags, type = gauge\n");
@@ -234,7 +234,7 @@ int test_register_by_fieldstat_type(struct fieldstat_instance *instance)
 	tag_gauge.value_str = "G_one_tag";
 	tag_gauge.key = "G_one_tag_yes";
 
-	ret = fieldstat_register(instance, FIELD_TYPE_GAUGE,"gauge_with_one_tag", &tag_gauge, 1);
+	ret = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE,"gauge_with_one_tag", &tag_gauge, 1);
 	if(ret == -1)
 	{
 		printf("Failed ot register gauge_with_one_tag, type = gauge\n");
@@ -255,7 +255,7 @@ int test_register_by_fieldstat_type(struct fieldstat_instance *instance)
 	tags_gauge[2].value_str = "G_tags_2";
 	tags_gauge[2].key = "G_tags_2_yes";
 
-	ret = fieldstat_register(instance, FIELD_TYPE_GAUGE, "gauge_with_tags", tags_gauge, sizeof(tags_gauge)/sizeof(tags_gauge[0]));
+	ret = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "gauge_with_tags", tags_gauge, sizeof(tags_gauge)/sizeof(tags_gauge[0]));
 	if(ret == -1)
 	{
 		printf("Failed ot register gauge_with_tags, type = gauge\n");
@@ -286,7 +286,7 @@ int test_register_by_fieldstat_type(struct fieldstat_instance *instance)
 //Register table start
 	int table_id = -1;
 	const char *column[] = {"T_success_log","T_fail_log"};
-	enum field_type table_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_GAUGE};
+	enum field_metric_type table_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_GAUGE};
 	table_id = fieldstat_register_table(instance, "table_test", column, table_type, sizeof(column)/sizeof(column[0]));
 	if(table_id == -1)
 	{
@@ -343,10 +343,10 @@ int main(int argc, char *argv[])
 
 	struct thread_para para;
 	const char *shaping_column[] = {"in_rx_pkts","in_tx_pkts"};
-	enum field_type shaping_type[] = {FIELD_TYPE_COUNTER,FIELD_TYPE_GAUGE};
+	enum field_metric_type shaping_type[] = {FIELD_METRIC_TYPE_COUNTER,FIELD_METRIC_TYPE_GAUGE};
 	para.shaping_table_id = fieldstat_register_table(test_instance,"shaping",shaping_column,shaping_type,sizeof(shaping_column)/sizeof(shaping_column[0]));
 	const char *sce_column[] = {"sent_bytes","recv_pkts"};
-	enum field_type sce_type[] = {FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER};
+	enum field_metric_type sce_type[] = {FIELD_METRIC_TYPE_COUNTER,FIELD_METRIC_TYPE_COUNTER};
 	para.sce_table_id = fieldstat_register_table(test_instance, "sce", sce_column,sce_type, sizeof(sce_column)/sizeof(sce_column[0]));
 	para.loops=10;
 	para.instance= test_instance;
diff --git a/test/src/gtest_dynamic_benchmark.cpp b/test/src/gtest_dynamic_benchmark.cpp
index dc0379d..e01222e 100644
--- a/test/src/gtest_dynamic_benchmark.cpp
+++ b/test/src/gtest_dynamic_benchmark.cpp
@@ -255,7 +255,7 @@ void _worker_thread_one_metric(void *arg)
 	{
 		//memset(metric_name, 0, sizeof(metric_name));
 		//snprintf(metric_name, sizeof(metric_name), "Active_sessions_%d", i);
-		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE,
+		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE,
 													"Active_sessions", 10, 
 													NULL, 0, thread_id); 
 		EXPECT_EQ(0, ret);
@@ -364,7 +364,7 @@ void build_Memory_benchmark(int n_thread, int n_metrics)
 			memset(metric_name, 0, sizeof(metric_name));
 			snprintf(metric_name, sizeof(metric_name), "Active_sessions_%d", j);
 
-			ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, 
+			ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, 
 														metric_name, j, NULL, 0, i); 
 			EXPECT_EQ(0, ret);
 		}
diff --git a/test/src/gtest_dynamic_fieldstat.cpp b/test/src/gtest_dynamic_fieldstat.cpp
index 7de7473..1582dc7 100644
--- a/test/src/gtest_dynamic_fieldstat.cpp
+++ b/test/src/gtest_dynamic_fieldstat.cpp
@@ -144,7 +144,7 @@ TEST(FeildStatDynamicAPI, FieldStatRegisterDynamicTable)
 {
 	int ret = 0;
 	const char *column_name[] = {"in_pkts", "in_bytes", "out_pkts", "out_bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_GAUGE, FIELD_TYPE_COUNTER, FIELD_TYPE_GAUGE, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_GAUGE, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_GAUGE, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[4];
 	char table_name[32];
 
@@ -215,9 +215,9 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicMetricValueIncrby)
 
 	for(int i = 0; i < n_thread; i++)
 	{
-		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, "Active_sessions", 100 + i, tags, sizeof(tags)/sizeof(tags[0]), i); 
+		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 100 + i, tags, sizeof(tags)/sizeof(tags[0]), i); 
 		EXPECT_EQ(0, ret);
-		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_COUNTER, "Traffic_bytes", 10 + i, tags, sizeof(tags)/sizeof(tags[0]), i); 
+		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_COUNTER, "Traffic_bytes", 10 + i, tags, sizeof(tags)/sizeof(tags[0]), i); 
 		EXPECT_EQ(0, ret);
 	}
 	
@@ -230,11 +230,11 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicMetricValueIncrby)
 			metric  = metrics[0];
 			switch(metric->field_type)
 			{
-				case FIELD_TYPE_COUNTER:
+				case FIELD_METRIC_TYPE_COUNTER:
 					value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
 					EXPECT_EQ(value, 10 + i);
 					break;
-				case FIELD_TYPE_GAUGE:
+				case FIELD_METRIC_TYPE_GAUGE:
 					value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
 					EXPECT_EQ(value, 100 + i);
 					break;
@@ -277,9 +277,9 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicMetricValueSet)
 
 	for(int i = 0; i < n_thread; i++)
 	{
-		ret = fieldstat_dynamic_metric_value_set(instance, FIELD_TYPE_GAUGE, "Active_sessions", 100 + i, tags, sizeof(tags)/sizeof(tags[0]), i); 
+		ret = fieldstat_dynamic_metric_value_set(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 100 + i, tags, sizeof(tags)/sizeof(tags[0]), i); 
 		EXPECT_EQ(0, ret);
-		ret = fieldstat_dynamic_metric_value_set(instance, FIELD_TYPE_COUNTER, "Traffic_bytes", 10 + i, tags, sizeof(tags)/sizeof(tags[0]), i); 
+		ret = fieldstat_dynamic_metric_value_set(instance, FIELD_METRIC_TYPE_COUNTER, "Traffic_bytes", 10 + i, tags, sizeof(tags)/sizeof(tags[0]), i); 
 		EXPECT_EQ(0, ret);
 	}
 	
@@ -292,11 +292,11 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicMetricValueSet)
 			metric  = metrics[0];
 			switch(metric->field_type)
 			{
-				case FIELD_TYPE_COUNTER:
+				case FIELD_METRIC_TYPE_COUNTER:
 					value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
 					EXPECT_EQ(value, 10 + i);
 					break;
-				case FIELD_TYPE_GAUGE:
+				case FIELD_METRIC_TYPE_GAUGE:
 					value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
 					EXPECT_EQ(value, 100 + i);
 					break;
@@ -337,9 +337,9 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicMetricValueDecrby)
 
 	for(int i = 0; i < n_thread; i++)
 	{
-		ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_TYPE_GAUGE, "Active_sessions", 100 + i, tags, sizeof(tags)/sizeof(tags[0]), i); 
+		ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 100 + i, tags, sizeof(tags)/sizeof(tags[0]), i); 
 		EXPECT_EQ(0, ret);
-		ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_TYPE_COUNTER, "Traffic_bytes", 10 + i, tags, sizeof(tags)/sizeof(tags[0]), i); 
+		ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_METRIC_TYPE_COUNTER, "Traffic_bytes", 10 + i, tags, sizeof(tags)/sizeof(tags[0]), i); 
 		EXPECT_EQ(0, ret);
 	}
 	
@@ -352,11 +352,11 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicMetricValueDecrby)
 			metric  = metrics[0];
 			switch(metric->field_type)
 			{
-				case FIELD_TYPE_COUNTER:
+				case FIELD_METRIC_TYPE_COUNTER:
 					value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
 					EXPECT_EQ(value, -(10 + i));
 					break;
-				case FIELD_TYPE_GAUGE:
+				case FIELD_METRIC_TYPE_GAUGE:
 					value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
 					EXPECT_EQ(value, -(100 + i));
 					break;
@@ -394,7 +394,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicTableMetricValueIncrby)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -465,7 +465,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicTableMetricValueSet)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -536,7 +536,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicTableMetricValueDecrby)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -643,7 +643,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolNoTag)
 	ret = fieldstat_dynamic_set_line_protocol_server(instance, "127.0.0.1", 8700);
 	EXPECT_EQ(0, ret);
 
-	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, "Active_sessions", 10, NULL, 0, 0);
+	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 10, NULL, 0, 0);
 	ret = line_protocol_dynamic_metric_output(instance);
 	EXPECT_EQ(0, ret);
 	sleep(1);
@@ -669,7 +669,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolOneTag)
 
 	ret = fieldstat_dynamic_set_line_protocol_server(instance, "127.0.0.1", 8700);
 	EXPECT_EQ(0, ret);
-	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, "Active_sessions", 11, tags, 1, 0);
+	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 11, tags, 1, 0);
 	ret = line_protocol_dynamic_metric_output(instance);
 	EXPECT_EQ(0, ret);
 	sleep(1);
@@ -701,7 +701,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolTwoTags)
 	ret = fieldstat_dynamic_set_line_protocol_server(instance, "127.0.0.1", 8700);
 	EXPECT_EQ(0, ret);
 
-	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, "Active_sessions", 12, tags, 2, 0);
+	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 12, tags, 2, 0);
 	ret = line_protocol_dynamic_metric_output(instance);
 	EXPECT_EQ(0, ret);
 	sleep(1);
@@ -715,7 +715,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolTableMetricNoTag)
 	int ret = 0;
 	struct fieldstat_dynamic_instance *instance = NULL;
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 	const char *compare_zero_tag = "{\"fields\":{\"bytes\":30,\"packages\":30},\"name\":\"security_rule_hits\",\"tags\":{\"app_name\":\"firewall\",\"table_name\":\"shaping\"}}";
@@ -749,7 +749,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolTableMetricOneTag)
 	int ret = 0;
 	struct fieldstat_dynamic_instance *instance = NULL;
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 	struct field_tag tags[1];
@@ -788,7 +788,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolTableMetricTowTags)
 	int ret = 0;
 	struct fieldstat_dynamic_instance *instance = NULL;
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 	struct field_tag tags[2];
@@ -839,14 +839,14 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolTypeGauge)
 	ret = fieldstat_dynamic_set_line_protocol_server(instance, "127.0.0.1", 8700);
 	EXPECT_EQ(0, ret);
 
-	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, "Active_sessions", 12, NULL, 0, 0);
+	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 12, NULL, 0, 0);
 	EXPECT_EQ(0, ret);
 	ret = line_protocol_dynamic_metric_output(instance);
 	EXPECT_EQ(0, ret);
 	sleep(1);
 	parse_telegraf_cjson_output(compare_first_output);
 
-	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, "Active_sessions", 12, NULL, 0, 0);
+	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 12, NULL, 0, 0);
 	EXPECT_EQ(0, ret);
 	ret = line_protocol_dynamic_metric_output(instance);
 	EXPECT_EQ(0, ret);
@@ -872,14 +872,14 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolTypeCounter)
 	ret = fieldstat_dynamic_set_line_protocol_server(instance, "127.0.0.1", 8700);
 	EXPECT_EQ(0, ret);
 
-	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_COUNTER, "Active_sessions", 12, NULL, 0, 0);
+	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_COUNTER, "Active_sessions", 12, NULL, 0, 0);
 	EXPECT_EQ(0, ret);
 	ret = line_protocol_dynamic_metric_output(instance);
 	EXPECT_EQ(0, ret);
 	sleep(1);
 	parse_telegraf_cjson_output(compare_first_output);
 
-	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_COUNTER, "Active_sessions", 12, NULL, 0, 0);
+	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_COUNTER, "Active_sessions", 12, NULL, 0, 0);
 	EXPECT_EQ(0, ret);
 	ret = line_protocol_dynamic_metric_output(instance);
 	EXPECT_EQ(0, ret);
@@ -894,7 +894,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolTableMetricTypeAllCo
 	int ret = 0;
 	struct fieldstat_dynamic_instance *instance = NULL;
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 	const char *compare_update_column_0 = "{\"fields\":{\"bytes\":0,\"packages\":30},\"name\":\"security_rule_hits\",\"tags\":{\"app_name\":\"firewall\",\"table_name\":\"shaping\"}}";
@@ -941,7 +941,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolTableMetricTypeAllGa
 	int ret = 0;
 	struct fieldstat_dynamic_instance *instance = NULL;
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_GAUGE, FIELD_TYPE_GAUGE};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_GAUGE, FIELD_METRIC_TYPE_GAUGE};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 	const char *compare_update_column_0 = "{\"fields\":{\"bytes\":0,\"packages\":30},\"name\":\"security_rule_hits\",\"tags\":{\"app_name\":\"firewall\",\"table_name\":\"shaping\"}}";
@@ -987,7 +987,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolTableMetricTypeOneCo
 	int ret = 0;
 	struct fieldstat_dynamic_instance *instance = NULL;
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_GAUGE};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_GAUGE};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 	const char *compare_update_column_0 = "{\"fields\":{\"bytes\":0,\"packages\":30},\"name\":\"security_rule_hits\",\"tags\":{\"app_name\":\"firewall\",\"table_name\":\"shaping\"}}";
@@ -1086,7 +1086,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolValueZero)
 	ret = fieldstat_dynamic_set_line_protocol_server(instance, "127.0.0.1", 8700);
 	EXPECT_EQ(0, ret);
 
-	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, "Active_sessions", 0, NULL, 0, 0);
+	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 0, NULL, 0, 0);
 	EXPECT_EQ(0, ret);
 	ret = line_protocol_dynamic_metric_output(instance);
 	EXPECT_EQ(0, ret);
@@ -1102,7 +1102,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolTableMetricValueZero
 	int ret = 0;
 	struct fieldstat_dynamic_instance *instance = NULL;
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 	const char *compare_column = "{\"fields\":{\"bytes\":0,\"packages\":0},\"name\":\"security_rule_hits\",\"tags\":{\"app_name\":\"firewall\",\"table_name\":\"shaping\"}}";
@@ -1165,7 +1165,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolMultiMetric)
 	{
 		memset(field_name, 0, sizeof(field_name));
 		snprintf(field_name, sizeof(field_name), "Active_sessions_%d", i);
-		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, (const char *)field_name, 12, NULL, 0, 0);
+		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, (const char *)field_name, 12, NULL, 0, 0);
 		EXPECT_EQ(0, ret);
 	}
 	ret = system("cat /dev/null > /tmp/metrics.out");
@@ -1226,7 +1226,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicOutputLineProtocolMultiTableRow)
 
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -1326,9 +1326,9 @@ void _worker_thread_multi_incrby(void *arg)
 
 	for(i = 0; i < loops; i++)
 	{
-		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, "Active_sessions", 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
-		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_COUNTER, "Traffic_bytes", 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_COUNTER, "Traffic_bytes", 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
 	
 		ret = fieldstat_dynamic_table_metric_value_incrby(instance, table_id, out_column_ids[0], "security_rule_hits", 30, tags, sizeof(tags)/sizeof(tags[0]), thread_id);
@@ -1358,7 +1358,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiIncrby)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -1414,11 +1414,11 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiIncrby)
 			{
 				switch(metric->field_type)
 				{
-					case FIELD_TYPE_GAUGE:
+					case FIELD_METRIC_TYPE_GAUGE:
 						value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
 						EXPECT_EQ((10 * n_loops), value);
 						break;
-					case FIELD_TYPE_COUNTER:
+					case FIELD_METRIC_TYPE_COUNTER:
 						value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
 						EXPECT_EQ((20 * n_loops), value);
 						break;
@@ -1463,9 +1463,9 @@ void _worker_thread_multi_decrby(void *arg)
 
 	for(i = 0; i < loops; i++)
 	{
-		ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_TYPE_GAUGE, "Active_sessions", 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
-		ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_TYPE_COUNTER, "Traffic_bytes", 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_METRIC_TYPE_COUNTER, "Traffic_bytes", 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
 	
 		ret = fieldstat_dynamic_table_metric_value_decrby(instance, table_id, out_column_ids[0], "security_rule_hits", 30, tags, sizeof(tags)/sizeof(tags[0]), thread_id);
@@ -1495,7 +1495,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiDecrby)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -1551,11 +1551,11 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiDecrby)
 			{
 				switch(metric->field_type)
 				{
-					case FIELD_TYPE_GAUGE:
+					case FIELD_METRIC_TYPE_GAUGE:
 						value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
 						EXPECT_EQ((-10 * n_loops), value);
 						break;
-					case FIELD_TYPE_COUNTER:
+					case FIELD_METRIC_TYPE_COUNTER:
 						value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
 						EXPECT_EQ((-20 * n_loops), value);
 						break;
@@ -1600,9 +1600,9 @@ void _worker_thread_multi_set(void *arg)
 
 	for(i = 0; i < loops; i++)
 	{
-		ret = fieldstat_dynamic_metric_value_set(instance, FIELD_TYPE_GAUGE, "Active_sessions", 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_set(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
-		ret = fieldstat_dynamic_metric_value_set(instance, FIELD_TYPE_COUNTER, "Traffic_bytes", 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_set(instance, FIELD_METRIC_TYPE_COUNTER, "Traffic_bytes", 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
 	
 		ret = fieldstat_dynamic_table_metric_value_set(instance, table_id, out_column_ids[0], "security_rule_hits", 30, tags, sizeof(tags)/sizeof(tags[0]), thread_id);
@@ -1632,7 +1632,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiSet)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -1688,11 +1688,11 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiSet)
 			{
 				switch(metric->field_type)
 				{
-					case FIELD_TYPE_GAUGE:
+					case FIELD_METRIC_TYPE_GAUGE:
 						value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
 						EXPECT_EQ(10, value);
 						break;
-					case FIELD_TYPE_COUNTER:
+					case FIELD_METRIC_TYPE_COUNTER:
 						value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
 						EXPECT_EQ(20, value);
 						break;
@@ -1743,9 +1743,9 @@ void _worker_thread_incrby_multi_metric(void *arg)
 		snprintf(gauge_name, sizeof(gauge_name), "Active_sessions_%d", i);
 		snprintf(counter_name, sizeof(gauge_name), "Traffic_bytes_%d", i);
 		snprintf(table_column_name, sizeof(gauge_name), "security_rule_hits_%d", i);
-		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, gauge_name, 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, gauge_name, 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
-		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_COUNTER, counter_name, 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_COUNTER, counter_name, 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
 	
 		ret = fieldstat_dynamic_table_metric_value_incrby(instance, table_id, out_column_ids[0], table_column_name, 30, tags, sizeof(tags)/sizeof(tags[0]), thread_id);
@@ -1774,7 +1774,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceIncrbyMultiMetric)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -1830,11 +1830,11 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceIncrbyMultiMetric)
 			{
 				switch(metric->field_type)
 				{
-					case FIELD_TYPE_GAUGE:
+					case FIELD_METRIC_TYPE_GAUGE:
 						value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
 						EXPECT_EQ(10, value);
 						break;
-					case FIELD_TYPE_COUNTER:
+					case FIELD_METRIC_TYPE_COUNTER:
 						value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
 						EXPECT_EQ(20, value);
 						break;
@@ -1885,9 +1885,9 @@ void _worker_thread_decrby_multi_metric(void *arg)
 		snprintf(gauge_name, sizeof(gauge_name), "Active_sessions_%d", i);
 		snprintf(counter_name, sizeof(gauge_name), "Traffic_bytes_%d", i);
 		snprintf(table_column_name, sizeof(gauge_name), "security_rule_hits_%d", i);
-		ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_TYPE_GAUGE, gauge_name, 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_METRIC_TYPE_GAUGE, gauge_name, 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
-		ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_TYPE_COUNTER, counter_name, 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_METRIC_TYPE_COUNTER, counter_name, 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
 	
 		ret = fieldstat_dynamic_table_metric_value_decrby(instance, table_id, out_column_ids[0], table_column_name, 30, tags, sizeof(tags)/sizeof(tags[0]), thread_id);
@@ -1917,7 +1917,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceDecrbyMultiMetric)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -1973,11 +1973,11 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceDecrbyMultiMetric)
 			{
 				switch(metric->field_type)
 				{
-					case FIELD_TYPE_GAUGE:
+					case FIELD_METRIC_TYPE_GAUGE:
 						value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
 						EXPECT_EQ(-10, value);
 						break;
-					case FIELD_TYPE_COUNTER:
+					case FIELD_METRIC_TYPE_COUNTER:
 						value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
 						EXPECT_EQ(-20, value);
 						break;
@@ -2029,9 +2029,9 @@ void _worker_thread_set_multi_metric(void *arg)
 		snprintf(gauge_name, sizeof(gauge_name), "Active_sessions_%d", i);
 		snprintf(counter_name, sizeof(gauge_name), "Traffic_bytes_%d", i);
 		snprintf(table_column_name, sizeof(gauge_name), "security_rule_hits_%d", i);
-		ret = fieldstat_dynamic_metric_value_set(instance, FIELD_TYPE_GAUGE, gauge_name, 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_set(instance, FIELD_METRIC_TYPE_GAUGE, gauge_name, 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
-		ret = fieldstat_dynamic_metric_value_set(instance, FIELD_TYPE_COUNTER, counter_name, 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_set(instance, FIELD_METRIC_TYPE_COUNTER, counter_name, 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
 	
 		ret = fieldstat_dynamic_table_metric_value_set(instance, table_id, out_column_ids[0], table_column_name, 30, tags, sizeof(tags)/sizeof(tags[0]), thread_id);
@@ -2061,7 +2061,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceSetMultiMetric)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -2117,11 +2117,11 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceSetMultiMetric)
 			{
 				switch(metric->field_type)
 				{
-					case FIELD_TYPE_GAUGE:
+					case FIELD_METRIC_TYPE_GAUGE:
 						value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
 						EXPECT_EQ(10, value);
 						break;
-					case FIELD_TYPE_COUNTER:
+					case FIELD_METRIC_TYPE_COUNTER:
 						value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
 						EXPECT_EQ(20, value);
 						break;
@@ -2177,9 +2177,9 @@ void _worker_thread_multi_incrby_multi_metric(void *arg)
 
 		for(int j = 0; j < loops; j++)
 		{
-			ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, (const char *)gauge_name, 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+			ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, (const char *)gauge_name, 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 			EXPECT_EQ(0, ret);
-			ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_COUNTER, (const char *)counter_name, 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+			ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_COUNTER, (const char *)counter_name, 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 			EXPECT_EQ(0, ret);
 		
 			ret = fieldstat_dynamic_table_metric_value_incrby(instance, table_id, out_column_ids[0], (const char *)table_column_name, 30, tags, sizeof(tags)/sizeof(tags[0]), thread_id);
@@ -2210,7 +2210,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiIncrbyMultiMetric)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -2266,11 +2266,11 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiIncrbyMultiMetric)
 			{
 				switch(metric->field_type)
 				{
-					case FIELD_TYPE_GAUGE:
+					case FIELD_METRIC_TYPE_GAUGE:
 						value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
 						EXPECT_EQ((10 * n_loops), value);
 						break;
-					case FIELD_TYPE_COUNTER:
+					case FIELD_METRIC_TYPE_COUNTER:
 						value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
 						EXPECT_EQ((20 * n_loops), value);
 						break;
@@ -2323,9 +2323,9 @@ void _worker_thread_multi_decrby_multi_metric(void *arg)
 
 		for(int j = 0; j < loops; j++)
 		{
-			ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_TYPE_GAUGE, (const char *)gauge_name, 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+			ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_METRIC_TYPE_GAUGE, (const char *)gauge_name, 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 			EXPECT_EQ(0, ret);
-			ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_TYPE_COUNTER, (const char *)counter_name, 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+			ret = fieldstat_dynamic_metric_value_decrby(instance, FIELD_METRIC_TYPE_COUNTER, (const char *)counter_name, 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 			EXPECT_EQ(0, ret);
 		
 			ret = fieldstat_dynamic_table_metric_value_decrby(instance, table_id, out_column_ids[0], (const char *)table_column_name, 30, tags, sizeof(tags)/sizeof(tags[0]), thread_id);
@@ -2356,7 +2356,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiDecrbyMultiMetric)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -2412,11 +2412,11 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiDecrbyMultiMetric)
 			{
 				switch(metric->field_type)
 				{
-					case FIELD_TYPE_GAUGE:
+					case FIELD_METRIC_TYPE_GAUGE:
 						value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
 						EXPECT_EQ((-1 * 10 * n_loops), value);
 						break;
-					case FIELD_TYPE_COUNTER:
+					case FIELD_METRIC_TYPE_COUNTER:
 						value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
 						EXPECT_EQ((-1 * 20 * n_loops), value);
 						break;
@@ -2468,9 +2468,9 @@ void _worker_thread_multi_set_multi_metric(void *arg)
 
 		for(int j = 0; j < loops; j++)
 		{
-			ret = fieldstat_dynamic_metric_value_set(instance, FIELD_TYPE_GAUGE, (const char *)gauge_name, 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+			ret = fieldstat_dynamic_metric_value_set(instance, FIELD_METRIC_TYPE_GAUGE, (const char *)gauge_name, 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 			EXPECT_EQ(0, ret);
-			ret = fieldstat_dynamic_metric_value_set(instance, FIELD_TYPE_COUNTER, (const char *)counter_name, 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+			ret = fieldstat_dynamic_metric_value_set(instance, FIELD_METRIC_TYPE_COUNTER, (const char *)counter_name, 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 			EXPECT_EQ(0, ret);
 		
 			ret = fieldstat_dynamic_table_metric_value_set(instance, table_id, out_column_ids[0], (const char *)table_column_name, 30, tags, sizeof(tags)/sizeof(tags[0]), thread_id);
@@ -2501,7 +2501,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiSetMultiMetric)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -2557,11 +2557,11 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiSetMultiMetric)
 			{
 				switch(metric->field_type)
 				{
-					case FIELD_TYPE_GAUGE:
+					case FIELD_METRIC_TYPE_GAUGE:
 						value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
 						EXPECT_EQ(10, value);
 						break;
-					case FIELD_TYPE_COUNTER:
+					case FIELD_METRIC_TYPE_COUNTER:
 						value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
 						EXPECT_EQ(20, value);
 						break;
@@ -2592,7 +2592,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicMetricValueGet)
 
 	fieldstat_dynamic_instance_start(instance);
 
-	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, "Active_sessions", 1000, NULL, 0, 0);
+	ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 1000, NULL, 0, 0);
 	EXPECT_EQ(0, ret);
 	value = fieldstat_dynamic_metric_value_get(instance, "Active_sessions", NULL, 0, 0);
 	EXPECT_EQ(1000, value);
@@ -2611,7 +2611,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicTableMetricValueGet)
 	long long value = 0;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 
 	struct fieldstat_dynamic_instance *instance = NULL;
@@ -2658,7 +2658,7 @@ TEST(FeildStatDynamicAPI, TableRowMetricValueIncrby)
 	long long values[2] = {0, 0};
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 
 	struct fieldstat_dynamic_instance *instance = NULL;
@@ -2693,7 +2693,7 @@ TEST(FeildStatDynamicAPI, TableRowMetricValueDecrby)
 	long long values[2] = {0, 0};
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 
 	struct fieldstat_dynamic_instance *instance = NULL;
@@ -2729,7 +2729,7 @@ TEST(FeildStatDynamicAPI, TableRowMetricValueSet)
 	long long values[2] = {0, 0};
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 
 	struct fieldstat_dynamic_instance *instance = NULL;
@@ -2772,7 +2772,7 @@ TEST(FeildStatDynamicAPI, SendLenEqualUDPPayload)
 								 "\"thread_id\":\"1\"}}";
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 
 	struct field_tag tags[4];
@@ -2834,7 +2834,7 @@ TEST(FeildStatDynamicAPI, ReadPerThreadHtableInfo)
 
 	instance = fieldstat_dynamic_instance_new("firewall", n_thread);
 
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	const char *column_name[]     = {"packages", "bytes"};
 	
 	unsigned int column_ids[2];
@@ -2852,11 +2852,11 @@ TEST(FeildStatDynamicAPI, ReadPerThreadHtableInfo)
 
 	for(int i = 0; i < n_thread; i++)
 	{
-		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, 
+		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, 
 													"Active_sessions", 100, 
 													NULL, 0, i); 
 		EXPECT_EQ(0, ret);
-		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_COUNTER, 
+		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_COUNTER, 
 													"Traffic_bytes",   100, 
 													NULL, 0, i); 
 		EXPECT_EQ(0, ret);
diff --git a/test/src/gtest_dynamic_fieldstat_output.cpp b/test/src/gtest_dynamic_fieldstat_output.cpp
index 4e88de3..0e02d98 100644
--- a/test/src/gtest_dynamic_fieldstat_output.cpp
+++ b/test/src/gtest_dynamic_fieldstat_output.cpp
@@ -48,9 +48,9 @@ void _worker_thread_multi_incrby(void *arg)
 
 	for(i = 0; i < loops; i++)
 	{
-		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_GAUGE, "Active_sessions", 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", 10, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
-		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_TYPE_COUNTER, "Traffic_bytes", 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
+		ret = fieldstat_dynamic_metric_value_incrby(instance, FIELD_METRIC_TYPE_COUNTER, "Traffic_bytes", 20, tags, sizeof(tags)/sizeof(tags[0]), thread_id); 
 		EXPECT_EQ(0, ret);
 	
 		ret = fieldstat_dynamic_table_metric_value_incrby(instance, table_id, out_column_ids[0], "security_rule_hits", 30, tags, sizeof(tags)/sizeof(tags[0]), thread_id);
@@ -76,7 +76,7 @@ TEST(FeildStatDynamicAPI, FieldStatDynamicInstanceMultiIncrby)
 	int n_loops = 10000;
 
 	const char *column_name[] = {"packages", "bytes"};
-	enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 	unsigned int out_column_ids[2];
 	int table_id = -1;
 
@@ -254,12 +254,12 @@ TEST(DynamicOutput, HashKeyOutOfSize)
 		"packages11", "packages12", "packages13", "packages14", "packages15",
 		"packages16", "packages17", "packages18", "packages19", "packages20"};
 
-	enum field_type column_type[] = {
-		FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-		FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-		FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-		FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-		FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type column_type[] = {
+		FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+		FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+		FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+		FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+		FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 
 
 	struct thread_para para[n_thread];
diff --git a/test/src/gtest_fieldstat_interface.cpp b/test/src/gtest_fieldstat_interface.cpp
index d2d8eaf..b925ef4 100644
--- a/test/src/gtest_fieldstat_interface.cpp
+++ b/test/src/gtest_fieldstat_interface.cpp
@@ -184,19 +184,19 @@ TEST(FeildStatAPI, FieldStatRegister)
 	instance = fieldstat_instance_new("test");
 	EXPECT_STREQ("test", instance->name);
 
-	metric_id = fieldstat_register(instance, FIELD_TYPE_COUNTER, "Traffic_bytes",NULL,0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_COUNTER, "Traffic_bytes",NULL,0);
 	EXPECT_EQ(0, metric_id);
 	EXPECT_EQ(1, instance->metric_cnt);
 	EXPECT_NE(nullptr, instance->metric_block_list[0]);
 	in_block_metric = instance->metric_block_list[0];
 	EXPECT_NE(nullptr, in_block_metric[0]);
 
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "Active_sessions", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "Active_sessions", NULL, 0);
 	EXPECT_EQ(1, metric_id);
 	EXPECT_EQ(2, instance->metric_cnt);
 	EXPECT_NE(nullptr, in_block_metric[1]);
 
-	metric_id = fieldstat_register(instance, FIELD_TYPE_COUNTER, "New_sessions", tags, sizeof(tags)/sizeof(tags[0]));
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_COUNTER, "New_sessions", tags, sizeof(tags)/sizeof(tags[0]));
 	EXPECT_EQ(2, metric_id);
 	EXPECT_EQ(3, instance->metric_cnt);
 	EXPECT_NE(nullptr, in_block_metric[2]);
@@ -211,10 +211,10 @@ TEST(FieldStatAPI, FieldStatRegisterTable)
 
 	const char *shaping_column_name[] = {"packets","bytes"};
 	const char *shaping_table_name = "shaping";
-	enum field_type shaping_column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	enum field_metric_type shaping_column_type[] = {FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER};
 
 	const char *sc_column_name[] = {"sent_pkts", "send_bytes", "recv_pkts", "recv_bytes"};
-	enum field_type sc_column_type[] = {FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER};
+	enum field_metric_type sc_column_type[] = {FIELD_METRIC_TYPE_COUNTER,FIELD_METRIC_TYPE_COUNTER,FIELD_METRIC_TYPE_COUNTER,FIELD_METRIC_TYPE_COUNTER};
 	const char *sc_table_name = "service_chaining";
 
 	instance = fieldstat_instance_new("test");
@@ -248,7 +248,7 @@ TEST(FieldStatAPI, FieldStatRegisterTableMetrics)
 	int table_id = -1;
 
 	const char *sc_column_name[] = {"sent_pkts", "send_bytes", "recv_pkts", "recv_bytes"};
-	enum field_type sc_column_type[] = {FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER,FIELD_TYPE_COUNTER};
+	enum field_metric_type sc_column_type[] = {FIELD_METRIC_TYPE_COUNTER,FIELD_METRIC_TYPE_COUNTER,FIELD_METRIC_TYPE_COUNTER,FIELD_METRIC_TYPE_COUNTER};
 	const char *sc_table_name = "service_chaining";
 
 
@@ -270,7 +270,7 @@ TEST(FeildStatAPI, FieldStatLocalOutputFormatJson)
 	instance = fieldstat_instance_new("test");
 	EXPECT_STREQ("test", instance->name);
 
-	metric_id = fieldstat_register(instance, FIELD_TYPE_COUNTER, "Traffic_bytes",NULL,0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_COUNTER, "Traffic_bytes",NULL,0);
 	EXPECT_EQ(0, metric_id);
 
 	ret_set_local_output = fieldstat_set_local_output(instance,"test.json","json");
@@ -323,7 +323,7 @@ TEST(FeildStatAPI, FieldStatLineProtocolOutputTableMetric)
 	"ipv4_out_bytes", "ipv6_in_packets", "ipv6_in_bytes", "ipv6_out_packets", "ipv6_out_bytes", "tcp_conn_num", "tcp_in_packets", "tcp_in_bytes",
 	"tcp_out_packets", "tcp_out_bytes", "udp_conn_num", "udp_in_packets", "udp_in_bytes", "udp_out_packets", "udp_out_bytes", "alert_bytes", "block_bytes",
 	"pinning_num", "maybe_pinning_num", "not_pinning_num"};
-	enum field_type table_column_type[54] = {FIELD_TYPE_COUNTER};
+	enum field_metric_type table_column_type[54] = {FIELD_METRIC_TYPE_COUNTER};
 
 	instance = fieldstat_instance_new("tsg_statistic");
 	EXPECT_STREQ("tsg_statistic", instance->name);
@@ -408,9 +408,9 @@ TEST(FeildStatAPI, SetMetricRatioPara)
 						  "\"name\":\"Sum\",\"tags\":{\"app_name\":\"maat\",\"table_name\":\"maat_info\"}}";
 
 
-	enum field_type table_column_type[10] = {
-		FIELD_TYPE_GAUGE,   FIELD_TYPE_GAUGE,   FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, 
-		FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER
+	enum field_metric_type table_column_type[10] = {
+		FIELD_METRIC_TYPE_GAUGE,   FIELD_METRIC_TYPE_GAUGE,   FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, 
+		FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER
 	};
 
 	instance = fieldstat_instance_new("maat");
@@ -507,17 +507,17 @@ TEST(FeildStatAPI, SetMetricInvisible)
 		"rule", "reg/v6", "stream", "IN_Bps", "cpu_us",
 		"PROC_Bps", "IN_Tps", "PROC_Tps","hit_cnt", "hit_rate"
 	};
-	enum field_type table_column_type[10] = {
-		FIELD_TYPE_GAUGE,
-		FIELD_TYPE_GAUGE,
-		FIELD_TYPE_COUNTER,
-		FIELD_TYPE_COUNTER,
-		FIELD_TYPE_COUNTER,
-		FIELD_TYPE_COUNTER,
-		FIELD_TYPE_COUNTER,
-		FIELD_TYPE_COUNTER,
-		FIELD_TYPE_COUNTER,
-		FIELD_TYPE_COUNTER
+	enum field_metric_type table_column_type[10] = {
+		FIELD_METRIC_TYPE_GAUGE,
+		FIELD_METRIC_TYPE_GAUGE,
+		FIELD_METRIC_TYPE_COUNTER,
+		FIELD_METRIC_TYPE_COUNTER,
+		FIELD_METRIC_TYPE_COUNTER,
+		FIELD_METRIC_TYPE_COUNTER,
+		FIELD_METRIC_TYPE_COUNTER,
+		FIELD_METRIC_TYPE_COUNTER,
+		FIELD_METRIC_TYPE_COUNTER,
+		FIELD_METRIC_TYPE_COUNTER
 	};
 	const char *compared_file_data_line = "Sum                   0"
 		"                   0            0.00e+00            5.00e+02"
diff --git a/test/src/gtest_fieldstat_output.cpp b/test/src/gtest_fieldstat_output.cpp
index 4faa5e5..3281c2b 100644
--- a/test/src/gtest_fieldstat_output.cpp
+++ b/test/src/gtest_fieldstat_output.cpp
@@ -21,17 +21,17 @@ const char *table_column_name[] = {
 	"maybe_pinning_num", "not_pinning_num"
 };
 
-enum field_type table_column_type[] = {
-	FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-	FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-	FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-	FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-	FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-	FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-	FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-	FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-	FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER,
-	FIELD_TYPE_COUNTER
+enum field_metric_type table_column_type[] = {
+	FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+	FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+	FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+	FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+	FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+	FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+	FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+	FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+	FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER, FIELD_METRIC_TYPE_COUNTER,
+	FIELD_METRIC_TYPE_COUNTER
 };
 
 const char *file_output_path = "/tmp/fieldstat.txt";
diff --git a/test/src/gtest_fieldstat_output_file_instance.cpp b/test/src/gtest_fieldstat_output_file_instance.cpp
index 2556223..b15c807 100644
--- a/test/src/gtest_fieldstat_output_file_instance.cpp
+++ b/test/src/gtest_fieldstat_output_file_instance.cpp
@@ -27,9 +27,9 @@ TEST(FeildStatOutput, OutputMaatTable)
 									 "                   0                   0                   0"
 									 "                   0\n";
 
-	enum field_type table_column_type[8] = {
-		FIELD_TYPE_GAUGE, FIELD_TYPE_GAUGE, FIELD_TYPE_GAUGE, FIELD_TYPE_GAUGE, 
-		FIELD_TYPE_GAUGE, FIELD_TYPE_GAUGE, FIELD_TYPE_GAUGE, FIELD_TYPE_GAUGE
+	enum field_metric_type table_column_type[8] = {
+		FIELD_METRIC_TYPE_GAUGE, FIELD_METRIC_TYPE_GAUGE, FIELD_METRIC_TYPE_GAUGE, FIELD_METRIC_TYPE_GAUGE, 
+		FIELD_METRIC_TYPE_GAUGE, FIELD_METRIC_TYPE_GAUGE, FIELD_METRIC_TYPE_GAUGE, FIELD_METRIC_TYPE_GAUGE
 	};
 
 	instance = fieldstat_instance_new("maat");
@@ -171,43 +171,43 @@ TEST(FeildStatOutput, OutputMaatGaugeType)
 	instance = fieldstat_instance_new("maat");
 	EXPECT_STREQ("maat", instance->name);
 
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "version", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "version", NULL, 0);
 	EXPECT_EQ(0, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "threads", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "threads", NULL, 0);
 	EXPECT_EQ(1, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "tables", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "tables", NULL, 0);
 	EXPECT_EQ(2, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "plug_cached", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "plug_cached", NULL, 0);
 	EXPECT_EQ(3, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "plug_acc", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "plug_acc", NULL, 0);
 	EXPECT_EQ(4, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "group", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "group", NULL, 0);
 	EXPECT_EQ(5, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "not_grp", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "not_grp", NULL, 0);
 	EXPECT_EQ(6, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "compile", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "compile", NULL, 0);
 	EXPECT_EQ(7, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "garbage_num", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "garbage_num", NULL, 0);
 	EXPECT_EQ(8, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "outer_mid", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "outer_mid", NULL, 0);
 	EXPECT_EQ(9, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "z_stream", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "z_stream", NULL, 0);
 	EXPECT_EQ(10, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "nt_grp_hit", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "nt_grp_hit", NULL, 0);
 	EXPECT_EQ(11, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "scan_bytes", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "scan_bytes", NULL, 0);
 	EXPECT_EQ(12, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "scan_times", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "scan_times", NULL, 0);
 	EXPECT_EQ(13, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "update_err", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "update_err", NULL, 0);
 	EXPECT_EQ(14, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "scan_error", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "scan_error", NULL, 0);
 	EXPECT_EQ(15, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "cmd_commit", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "cmd_commit", NULL, 0);
 	EXPECT_EQ(16, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "cmd_in_q", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "cmd_in_q", NULL, 0);
 	EXPECT_EQ(17, metric_id);
-	metric_id = fieldstat_register(instance, FIELD_TYPE_GAUGE, "line_cmd/s", NULL, 0);
+	metric_id = fieldstat_register(instance, FIELD_METRIC_TYPE_GAUGE, "line_cmd/s", NULL, 0);
 	EXPECT_EQ(18, metric_id);
 
 	ret = fieldstat_set_local_output(instance, output_file_path, "default");