feature:新增table注册和table输出file功能，现在支出多table注册

4 files changed, 289 insertions, 14 deletions

diff --git a/inc/fieldstat.h b/inc/fieldstat.h
index 8746645..a5a1195 100644
--- a/inc/fieldstat.h
+++ b/inc/fieldstat.h
@@ -13,7 +13,8 @@
 #define LEN_APP_NAME   32
 #define LEN_FORMAT_MAX 32
 #define LEN_PATH_MAX   256
-
+#define	NUM_MAX_TABLE	64
+#define TABLE_COLUMN_SIZE 32
 
 struct fieldstat_global_prometheus
 {
@@ -46,6 +47,13 @@ struct fieldstat_instance
 	int metric_cnt;
 	int metric_size;
 	struct metric_t **metric;
+	struct{
+		struct metric_t **column;
+		size_t column_size;
+	} table_metrics[NUM_MAX_TABLE];
+
+	int table_num;
+	int line_seq;
 
 	int prometheus_output_enable;
 
@@ -69,6 +77,12 @@ enum field_type
 	FIELD_TYPE_SUMMARY
 };
 
+struct metric_id_list
+{
+	int num;
+	int id[TABLE_COLUMN_SIZE];
+};
+
 /*
  * @param listen_port 
  * @param url if NULL use "/metrics" default
@@ -88,6 +102,7 @@ int fieldstat_set_app_name(struct fieldstat_instance *instance, const char *app_
  * @param field_name the name of the field
  * @type counter, gauge summary and histogram
  * @n_tag size of tag_key[] and tag_value[]
+ * 
  * return field_id to be used in fieldstat_value_xxx(),
  * 	 -1 if an error occured.
  * example field_name=packets, tag=[{"policy_id", "101"},{"profile_id", "a"}]
@@ -95,8 +110,10 @@ int fieldstat_set_app_name(struct fieldstat_instance *instance, const char *app_
  * counter or histogram
  * */
 int fieldstat_register(struct fieldstat_instance *instance, enum field_type type, const char *field_name, const char *tag_key[], const char *tag_value[], size_t n_tag);
-//int fieldstat_register_table(struct fieldstat_instance *instance, enum file_type table_type[], consul char *field_list[], size_t n_field);
-//int fieldstat_register_table_metrics(struct fieldstat_instance * instance, const char *tag_key[], const char *tag_value[]);
+int fieldstat_register_table(struct fieldstat_instance *instance, enum field_type table_type[], const char *field_list[], size_t n_field);
+//int fieldstat_register_table_metrics(struct fieldstat_instance * instance, const char *field_name, const char *tag_key[], const char *tag_value[]);
+struct metric_id_list fieldstat_register_table_metrics(struct fieldstat_instance * instance, int table_id, const char *field_name, const char *tag_key[], const char *tag_value[],size_t n_tag);
+
 
 int fieldstat_value_incrby(struct fieldstat_instance *instance, int field_id, long long increment);
 int fieldstat_value_set(struct fieldstat_instance *instance, int field_id, long long increment);
@@ -106,3 +123,4 @@ void fieldstat_instance_start(struct fieldstat_instance *instance);
 void fieldstat_passive_output(struct fieldstat_instance *instance);
 
 #endif
+
diff --git a/src/fieldstat.cpp b/src/fieldstat.cpp
index a277559..081126e 100644
--- a/src/fieldstat.cpp
+++ b/src/fieldstat.cpp
@@ -328,7 +328,7 @@ static int print_buf_tag_append_position(metric_t *metric, char *print_buf_tags,
 	char *print_buf_tags_append_position = print_buf_tags;
 
 	print_buf_tags_append_position += snprintf(print_buf_tags_append_position, size - (print_buf_tags_append_position - print_buf_tags),"{");
-	for(; i < metric->n_tag; i++)
+	for(; i < (int)metric->n_tag; i++)
 	{
 		if(i == 0)
 		{
@@ -363,6 +363,10 @@ static int output_file_format_default_type_gauge(struct fieldstat_instance *inst
 		{
 			continue;
 		}
+		if(metric->belong_to_table == 1)
+		{
+			continue;
+		}
 		if(metric->is_invisible == 1)
 		{
 			value = get_metric_unit_val(metric, FS_CALC_SPEED, 0);
@@ -421,6 +425,10 @@ static int output_file_format_default_type_counter(struct fieldstat_instance *in
 		{
 			continue;
 		}
+		if(metric->belong_to_table == 1)
+		{
+			continue;
+		}
 		if(metric->is_invisible == 1)
 		{
 			get_metric_unit_val(metric,FS_CALC_CURRENT,0);
@@ -474,6 +482,84 @@ static int output_file_format_default_type_counter(struct fieldstat_instance *in
 }
 
 
+static int output_file_format_default_table(struct fieldstat_instance *instance,long long interval_ms,char*print_buf, unsigned int size)
+{
+	int i = 0, j = 0, k = 0;
+	metric_t *metric = NULL;
+	long long value = 0;
+	//double ratio = 0.0;
+	struct metric_t **table_column = NULL;
+	size_t table_column_size = 0;
+
+	char* print_buf_append_position = print_buf;
+
+	int index_table[NUM_MAX_TABLE][1024];
+	int table_metric_number[NUM_MAX_TABLE];
+	memset(table_metric_number,0, sizeof(table_metric_number));
+	char *line_name = NULL;
+	int table_id = 0;
+	int per_table_counter = 0;
+	int metric_id = 0;
+	char print_buf_tags[1024] = {0};
+
+	for(i = 0; i < instance->metric_cnt; i++)
+	{
+		metric = instance->metric[i];
+		if(metric->belong_to_table != 1)
+		{
+			continue;
+		}
+		table_id = metric->table_id;
+		per_table_counter = table_metric_number[table_id]++;
+		index_table[table_id][per_table_counter] = i;
+	}
+
+	for(i = 0; i < instance->table_num; i++)
+	{
+		if(table_metric_number[i] == 0)
+		{
+			continue;
+		}
+
+		table_column = instance->table_metrics[i].column;
+		table_column_size = instance->table_metrics[i].column_size;
+
+		print_buf_append_position += snprintf(print_buf_append_position, size - (print_buf - print_buf),"\t\t\t");
+		for(k = 0; k < (int)table_column_size; k++)
+		{
+			print_buf_append_position += snprintf(print_buf_append_position ,size - (print_buf_append_position - print_buf), "\t%10s", table_column[k]->field_name);			
+		}
+		for(j = 0; j < table_metric_number[i]; j++)
+		{
+			metric_id = index_table[i][j];
+			metric = instance->metric[metric_id];
+			if(line_name == NULL || strcmp(line_name, metric->field_name))
+			{
+				print_buf_tag_append_position(metric, print_buf_tags, sizeof(print_buf_tags));
+				print_buf_append_position += snprintf(print_buf_append_position, size - (print_buf_append_position - print_buf), "\n%s %-20s\t", metric->field_name,print_buf_tags);
+
+				line_name = metric->field_name;	
+			}
+			value = get_metric_unit_val(metric, FS_CALC_CURRENT, 0);
+			print_buf_append_position += snprintf(print_buf_append_position, size - (print_buf_append_position - print_buf), "%10lld\t", value);
+		}
+		print_buf_append_position += snprintf(print_buf_append_position,size - (print_buf_append_position - print_buf), "\n");
+		line_name = NULL;
+
+		if(print_buf_append_position - print_buf > 0)
+		{
+			if(*(print_buf_append_position - 1) == '\n')
+			{
+				print_buf_append_position--;
+			}
+			print_buf_append_position += snprintf(print_buf_append_position, size - (print_buf_append_position - print_buf), "\n%s\n", draw_line);
+		}
+	}
+
+	return print_buf_append_position - print_buf;
+}
+
+
 int fieldstat_output_file(struct fieldstat_instance *instance,long long interval_ms)
 {
 	size_t print_buf_sz = instance->metric_cnt*1024;
@@ -506,6 +592,7 @@ int fieldstat_output_file(struct fieldstat_instance *instance,long long interval
 		//pthread_mutex_lock(&(_handle->reg_lock)); //TODO
 		print_buf_append_position += output_file_format_default_type_gauge(instance, interval_ms, print_buf_append_position, print_buf_sz - (print_buf_append_position - print_buf));
 		print_buf_append_position += output_file_format_default_type_counter(instance, interval_ms, print_buf_append_position, print_buf_sz - (print_buf_append_position - print_buf));
+		print_buf_append_position += output_file_format_default_table(instance, interval_ms, print_buf_append_position, print_buf_sz - (print_buf_append_position - print_buf));
 		//TODO  output table,output histogram,output summary 
 		//pthread_mutex_unlock(&(_handle->reg_lock));//TODO
 	}
@@ -591,6 +678,119 @@ struct fieldstat_instance * fieldstat_instance_create(void)
 	instance->output_interval_s = 2;		//default 2s
 	instance->background_thread_disable = 0;
 	instance->metric_size = NUM_INIT_METRICS;
-	instance->metric =(struct metric_t **)calloc(sizeof(struct metric *), instance->metric_size);
+	instance->metric = (struct metric_t **)calloc(sizeof(struct metric *), instance->metric_size);
+	//instance->table_num = NUM_INIT_TABLES;
+	//instance->metric_table = (struct metric_t **)calloc(sizeof(struct metric *), instance->table_num); 
 	return instance;
 }
+
+
+ int fieldstat_register_table(struct fieldstat_instance *instance, enum field_type table_type[], const char *field_list[], size_t n_field)
+ {
+	int table_id = 0;
+	int i = 0;
+	metric_t **table_column = NULL;
+
+	if(n_field <= 0)
+	{
+		return -1;
+	}
+	if(instance->table_num > NUM_MAX_TABLE)
+	{
+		return -1;
+	}
+	if(n_field > TABLE_COLUMN_SIZE)
+	{
+		return -1;
+	}
+
+	table_id = instance->table_num++;
+	//instance->metric_table[table_id];
+	table_column = instance->table_metrics[table_id].column = (struct metric_t **)calloc(sizeof(struct metric *), n_field);
+	instance->table_metrics[table_id].column_size = n_field;
+	for(; i < (int)n_field; i ++)
+	{
+		table_column[i] = metric_new(table_type[i],field_list[i],NULL,NULL,0);
+	}
+	return table_id;
+ }
+
+
+struct metric_id_list fieldstat_register_table_metrics(struct fieldstat_instance * instance, int table_id, const char *field_name, const char *tag_key[], const char *tag_value[],size_t n_tag)
+
+//int fieldstat_register(struct fieldstat_instance *instance, enum field_type type, const char *field_name, const char *tag_key[], const char *tag_value[], size_t n_tag)
+{
+	
+	int metric_id = 0;
+	int i = 0;
+	struct metric_t * metric_choosen = NULL;
+	metric_t **table_column = instance->table_metrics[table_id].column;
+	int table_column_size = instance->table_metrics[table_id].column_size;
+	struct metric_id_list metric_id_list;
+	memset(&(metric_id_list),0,sizeof(struct metric_id_list));
+
+	if(table_id < 0 || table_id >= NUM_MAX_TABLE)
+	{
+		return metric_id_list;
+	}
+
+	if(!is_valid_field_name(field_name))
+	{
+		return metric_id_list;
+	}
+	if(n_tag > N_TAG_MAX)
+	{
+		return metric_id_list;
+	}
+
+	if(table_column_size < 1)
+	{
+		return metric_id_list;
+	}
+
+	//TODO not block
+	table_column = instance->table_metrics[table_id].column;
+
+	for(; i < table_column_size; i ++)
+	{	
+		metric_id = instance->metric_cnt++;
+		assert(instance->metric_cnt < instance->metric_size);
+		metric_choosen = instance->metric[metric_id] = metric_new(table_column[i]->field_type,field_name,tag_key,tag_value,n_tag);
+
+		metric_choosen->table_id = table_id;
+		metric_choosen->belong_to_table = 1;
+		metric_choosen->table_column_id = i;
+		metric_choosen->line_seq ++;
+		metric_choosen->table_column_name = strdup(table_column[i]->field_name); 
+
+		switch(metric_choosen->field_type)
+		{
+			case FIELD_TYPE_COUNTER:
+				instance->counter_cnt++;
+				memset(&(metric_choosen->counter), 0, sizeof(metric_choosen->counter));
+				break;
+			case FIELD_TYPE_GAUGE:
+				instance->gauge_cnt++;
+				memset(&(metric_choosen->gauge), 0, sizeof(metric_choosen->gauge));
+				break;
+			case FILED_TYPE_HISTOGRAM:
+				//instance->histogram_cnt++;
+				// TODO  what?
+				break;
+			case FIELD_TYPE_SUMMARY:
+				//instance->summary_cnt++;
+				//TODO what ?
+				break;
+			default:
+				assert(0);
+				break;
+		}
+		if(table_column_size < TABLE_COLUMN_SIZE)
+		{
+			metric_id_list.id[metric_id_list.num ++] = metric_id;
+		}
+
+	}
+
+	return metric_id_list;
+}
diff --git a/src/fieldstat_internal.h b/src/fieldstat_internal.h
index c9baf1d..d8c83b7 100644
--- a/src/fieldstat_internal.h
+++ b/src/fieldstat_internal.h
@@ -63,7 +63,13 @@ struct metric_t
 	int not_send_to_server;
 	int numerator_id;
 	int denominator_id;
-	
+
+	int belong_to_table;
+	int table_id;
+	size_t line_seq;
+	int table_column_id;
+	char *table_column_name;
+
 	union
 	{
 		struct stat_unit_t counter;
diff --git a/test/fs2_test.cpp b/test/fs2_test.cpp
index b049059..e712f5d 100644
--- a/test/fs2_test.cpp
+++ b/test/fs2_test.cpp
@@ -20,11 +20,16 @@
 int main(int argc, char *argv[])
 {
 	int ret = 0;
+	int i = 0;
 	struct fieldstat_instance * test_instance = NULL;
 	const char *tag_key[] = {"A","B","C"};
-	const char *tag_value[] = {"a1","b1","c1"};
+	const char *tag_value[] = {"a1","b1","c1","b1","f1"};
+	enum field_type table_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	const char *field_list[] = {"column_0", "colunm_1", "column_2"};
+	const char *field_list_0[] = {"c0", "c1", "c2"};
+	struct metric_id_list id_list; 
 
-       	test_instance = fieldstat_instance_create();
+	test_instance = fieldstat_instance_create();
 	ret = fieldstat_set_app_name(test_instance, "test");
 	if(ret == -1)
 	{
@@ -73,14 +78,60 @@ int main(int argc, char *argv[])
 		printf("Failed to register metric!\n");
 	}
 
-
-        ret = fieldstat_register(test_instance, FIELD_TYPE_COUNTER, "metric_1", tag_key, tag_value, sizeof(tag_key)/sizeof(tag_key[0]));
-        if(ret == -1)
-        {
-                printf("Failed to register metric!\n");
-        }
+	ret = fieldstat_register(test_instance, FIELD_TYPE_COUNTER, "metric_1", tag_key, tag_value, sizeof(tag_key)/sizeof(tag_key[0]));
+	if(ret == -1)
+	{
+		printf("Failed to register metric!\n");
+	}
 	
 	ret = fieldstat_register(test_instance, FIELD_TYPE_GAUGE, "gauge_0",tag_key, tag_value, sizeof(tag_key)/sizeof(tag_key[0]));
+	if(ret == -1)
+	{
+		printf("Failed to register metric gauge_0\n");
+	}
+
+	ret = fieldstat_register(test_instance, FIELD_TYPE_GAUGE, "gauge_0_tag", NULL, NULL, 0);
+	if(ret == -1)
+	{
+		printf("Failed to register metric gauge_0_tag\n");
+	}
+/*
+	enum field_type table_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER};
+	const char *field_list[] = {"column_0", "colunm_1", "column_2"};
+*/
+	int table_id = -1;
+	table_id = fieldstat_register_table(test_instance, table_type, field_list, sizeof(field_list)/sizeof(field_list[0]));
+	if(table_id == -1)
+	{
+		printf("Failed to register metric table\n");
+	}
+
+	id_list = fieldstat_register_table_metrics(test_instance, table_id, "line_0", tag_key, tag_value, sizeof(tag_key)/sizeof(tag_key[0]));
+	for(i = 0; i < id_list.num; i++)
+	{
+		printf("%d\n", id_list.id[i]);
+	}
+
+	id_list = fieldstat_register_table_metrics(test_instance, table_id, "line_2", tag_key, tag_value, sizeof(tag_key)/sizeof(tag_key[0]));
+	for(i = 0; i < id_list.num; i++)
+	{
+		printf("%d\n", id_list.id[i]);
+	}
+
+	table_id = fieldstat_register_table(test_instance, table_type, field_list_0, sizeof(field_list_0)/sizeof(field_list_0[0]));
+	printf("%d\n",table_id);
+	if(table_id == -1)
+	{
+		printf("Failed to register metric table list_0\n");
+	}
+
+	id_list = fieldstat_register_table_metrics(test_instance, table_id, "line_0", tag_key, tag_value, sizeof(tag_key)/sizeof(tag_key[0]));
+	printf("id_list.num:%d\n",id_list.num);
+	for(i = 0; i < id_list.num; i++)
+	{
+		printf("%d\n", id_list.id[i]);
+	}
+
 
 	fieldstat_instance_start(test_instance);
 	sleep(1);