From 03491ea7e227c51d61e4e6a4b3810c727f0fbd19 Mon Sep 17 00:00:00 2001 From: yangwei Date: Fri, 2 Aug 2024 11:44:38 +0800 Subject: 🐞 fix(fieldstat.h): rename field_type to field_metric_type MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- inc/fieldstat.h | 22 +-- readme.md | 20 +-- src/fieldstat.cpp | 60 ++++---- src/fieldstat_dynamic.cpp | 26 ++-- src/fieldstat_internal.h | 8 +- src/file_output.cpp | 46 +++--- src/line_protocol_output.cpp | 16 +- src/prometheus_output.cpp | 16 +- test/fieldstat_test.cpp | 22 +-- test/src/gtest_dynamic_benchmark.cpp | 4 +- test/src/gtest_dynamic_fieldstat.cpp | 174 +++++++++++----------- test/src/gtest_dynamic_fieldstat_output.cpp | 18 +-- test/src/gtest_fieldstat_interface.cpp | 44 +++--- test/src/gtest_fieldstat_output.cpp | 22 +-- test/src/gtest_fieldstat_output_file_instance.cpp | 44 +++--- 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;ifield_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"); -- cgit v1.2.3