struct reader_client {
struct connection conn;
- struct stats_metrics *metrics;
};
static struct connection_list *reader_clients = NULL;
-void client_reader_create(int fd, struct stats_metrics *metrics)
+void client_reader_create(int fd)
{
struct reader_client *client;
client = i_new(struct reader_client, 1);
- client->metrics = metrics;
connection_init_server(reader_clients, &client->conn,
"stats-reader", fd, fd);
}
const struct metric *metric;
o_stream_cork(client->conn.output);
- iter = stats_metrics_iterate_init(client->metrics);
+ iter = stats_metrics_iterate_init(stats_metrics);
while ((metric = stats_metrics_iterate(iter)) != NULL) T_BEGIN {
string_t *str = t_str_new(128);
str_append_tabescaped(str, metric->name);
const char *const *args)
{
(void)reader_client_input_dump(client, args);
- stats_metrics_reset(client->metrics);
+ stats_metrics_reset(stats_metrics);
return 1;
}
struct stats_metrics;
-void client_reader_create(int fd, struct stats_metrics *metrics);
+void client_reader_create(int fd);
void client_readers_init(void);
void client_readers_deinit(void);
struct writer_client {
struct connection conn;
- struct stats_metrics *metrics;
struct stats_event *events;
HASH_TABLE(struct stats_event *, struct stats_event *) events_hash;
string_t *str = t_str_new(128);
str_append(str, "FILTER\t");
- event_filter_export(stats_metrics_get_event_filter(client->metrics), str);
+ event_filter_export(stats_metrics_get_event_filter(stats_metrics), str);
str_append_c(str, '\n');
o_stream_nsend(client->conn.output, str_data(str), str_len(str));
}
return event1->id == event2->id ? 0 : 1;
}
-void client_writer_create(int fd, struct stats_metrics *metrics)
+void client_writer_create(int fd)
{
struct writer_client *client;
client = i_new(struct writer_client, 1);
- client->metrics = metrics;
hash_table_create(&client->events_hash, default_pool, 0,
stats_event_hash, stats_event_cmp);
event_unref(&event);
return FALSE;
}
- stats_metrics_event(client->metrics, event, &ctx);
+ stats_metrics_event(stats_metrics, event, &ctx);
*event_r = event;
return TRUE;
}
struct stats_metrics;
-void client_writer_create(int fd, struct stats_metrics *metrics);
+void client_writer_create(int fd);
void client_writers_init(void);
void client_writers_deinit(void);
#include "client-reader.h"
const struct stats_settings *stats_settings;
-
-static struct stats_metrics *metrics;
+struct stats_metrics *stats_metrics;
static bool client_is_writer(const char *path)
{
static void client_connected(struct master_service_connection *conn)
{
if (client_is_writer(conn->name))
- client_writer_create(conn->fd, metrics);
+ client_writer_create(conn->fd);
else
- client_reader_create(conn->fd, metrics);
+ client_reader_create(conn->fd);
master_service_client_connection_accept(conn);
}
static void main_init(void)
{
void **sets = master_service_settings_get_others(master_service);
-
stats_settings = sets[0];
- metrics = stats_metrics_init(stats_settings);
+ stats_metrics = stats_metrics_init(stats_settings);
stats_event_categories_init();
client_readers_init();
client_writers_init();
client_readers_deinit();
client_writers_deinit();
stats_event_categories_deinit();
- stats_metrics_deinit(&metrics);
+ stats_metrics_deinit(&stats_metrics);
}
int main(int argc, char *argv[])
#include "stats-settings.h"
extern const struct stats_settings *stats_settings;
+extern struct stats_metrics *stats_metrics;
#endif
struct failure_context *ctx, const char *fmt ATTR_UNUSED,
va_list args ATTR_UNUSED)
{
- if (metrics != NULL) {
- stats_metrics_event(metrics, event, ctx);
- struct event_filter *filter = stats_metrics_get_event_filter(metrics);
+ if (stats_metrics != NULL) {
+ stats_metrics_event(stats_metrics, event, ctx);
+ struct event_filter *filter =
+ stats_metrics_get_event_filter(stats_metrics);
return !event_filter_match(filter, event, ctx);
}
return TRUE;
struct ioloop *loop = io_loop_create();
- client_reader_create(fds[1], metrics);
+ client_reader_create(fds[1]);
connection_init_client_fd(conn_list, conn, "stats", fds[0], fds[0]);
o_stream_nsend_str(conn->output, "DUMP\tcount\n");
struct ioloop *loop = io_loop_create();
- client_reader_create(fds[1], metrics);
+ client_reader_create(fds[1]);
connection_init_client_fd(conn_list, &conn->conn, "stats", fds[0], fds[0]);
o_stream_nsend_str(conn->conn.output, "DUMP\tcount\n");
struct ioloop *loop = io_loop_create();
- client_writer_create(fds[1], metrics);
+ client_writer_create(fds[1]);
connection_init_client_fd(conn_list, conn, "stats", fds[0], fds[0]);
last_sent_event = event;
return TRUE;
recurse_back = TRUE;
- if (metrics != NULL) {
+ if (stats_metrics != NULL) {
test_write_one(event);
}
recurse_back = FALSE;
};
pool_t test_pool;
-struct stats_metrics *metrics = NULL;
+struct stats_metrics *stats_metrics = NULL;
static bool callback_added = FALSE;
stats_event_category_register(child_test_category.name,
&test_category);
struct stats_settings *set = read_settings(settings_blob);
- metrics = stats_metrics_init(set);
+ stats_metrics = stats_metrics_init(set);
}
void test_deinit(void)
{
- stats_metrics_deinit(&metrics);
+ stats_metrics_deinit(&stats_metrics);
stats_event_categories_deinit();
pool_unref(&test_pool);
}
uint64_t get_stats_dist_field(const char *metric_name, enum stats_dist_field field)
{
- struct stats_metrics_iter *iter = stats_metrics_iterate_init(metrics);
+ struct stats_metrics_iter *iter =
+ stats_metrics_iterate_init(stats_metrics);
const struct metric *metric;
while((metric = stats_metrics_iterate(iter)) != NULL)
if (strcmp(metric->name, metric_name) == 0)
#ifndef TEST_STATS_COMMON
#define TEST_STATS_COMMON 1
-#include "lib.h"
+#include "stats-common.h"
#include "event-filter.h"
#include "istream.h"
#include "settings-parser.h"
extern struct event_category child_test_category;
extern pool_t test_pool;
-extern struct stats_metrics *metrics;
-
bool test_stats_callback(struct event *event,
enum event_callback_type type ATTR_UNUSED,
struct failure_context *ctx, const char *fmt ATTR_UNUSED,
struct failure_context *ctx, const char *fmt ATTR_UNUSED,
va_list args ATTR_UNUSED)
{
- if (metrics != NULL) {
- stats_metrics_event(metrics, event, ctx);
- struct event_filter *filter = stats_metrics_get_event_filter(metrics);
+ if (stats_metrics != NULL) {
+ stats_metrics_event(stats_metrics, event, ctx);
+ struct event_filter *filter =
+ stats_metrics_get_event_filter(stats_metrics);
return !event_filter_match(filter, event, ctx);
}
return TRUE;
test_init(settings_blob_2);
/* check filter */
- struct event_filter *filter = stats_metrics_get_event_filter(metrics);
+ struct event_filter *filter =
+ stats_metrics_get_event_filter(stats_metrics);
string_t *str_filter = t_str_new(64);
event_filter_export(filter, str_filter);
test_assert_strcmp("ntest ftest_field value ",
test_assert(get_stats_dist_field("test", STATS_DIST_COUNT) == test->num_values * test->num_values);
/* analyze the structure */
- struct stats_metrics_iter *iter = stats_metrics_iterate_init(metrics);
+ struct stats_metrics_iter *iter = stats_metrics_iterate_init(stats_metrics);
const struct metric *root_metric = stats_metrics_iterate(iter);
stats_metrics_iterate_deinit(&iter);
test_assert(get_stats_dist_field("test", STATS_DIST_COUNT) == test->num_inputs);
/* analyze the structure */
- struct stats_metrics_iter *iter = stats_metrics_iterate_init(metrics);
+ struct stats_metrics_iter *iter = stats_metrics_iterate_init(stats_metrics);
const struct metric *root_metric = stats_metrics_iterate(iter);
stats_metrics_iterate_deinit(&iter);