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

7 files changed, 164 insertions, 164 deletions

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");