libosmocore/src/vty/stats_vty.c

/*
 * (C) 2009-2022 by Harald Welte <laforge@gnumonks.org>
 * (C) 2009-2014 by Holger Hans Peter Freyther
 * (C) 2015      by sysmocom - s.f.m.c. GmbH
 * All Rights Reserved
 *
 * SPDX-License-Identifier: GPL-2.0+
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#include <stdlib.h>
#include <string.h>

#include "config.h"

#include <osmocom/vty/command.h>
#include <osmocom/vty/buffer.h>
#include <osmocom/vty/vty.h>
#include <osmocom/vty/telnet_interface.h>
#include <osmocom/vty/telnet_interface.h>
#include <osmocom/vty/misc.h>

#include <osmocom/core/stats.h>
#include <osmocom/core/counter.h>
#include <osmocom/core/rate_ctr.h>
#include <osmocom/core/stats_tcp.h>

#define CFG_STATS_STR "Configure stats sub-system\n"
#define CFG_REPORTER_STR "Configure a stats reporter\n"

#define SHOW_STATS_STR "Show statistical values\n"
#define SKIP_ZERO_STR "Skip items with total count zero\n"

#define STATS_STR "Stats related commands\n"

/*! \file stats_vty.c
 *  VTY interface for statsd / statistic items
 *
 *  This code allows you to register a couple of VTY commands that
 *  permit configuration of the \ref stats functionality from the VTY.
 *
 *  Use \ref osmo_stats_vty_add_cmds once at application start-up to
 *  enable related commands.
 */

/* containing version info */
extern struct host host;

struct cmd_node cfg_stats_node = {
	CFG_STATS_NODE,
	"%s(config-stats)# ",
	1
};

static const struct value_string stats_class_strs[] = {
	{ OSMO_STATS_CLASS_GLOBAL,     "global" },
	{ OSMO_STATS_CLASS_PEER,       "peer" },
	{ OSMO_STATS_CLASS_SUBSCRIBER, "subscriber" },
	{ 0, NULL }
};

static struct osmo_stats_reporter *osmo_stats_vty2srep(struct vty *vty)
{
	if (vty->node == CFG_STATS_NODE)
		return vty->index;

	return NULL;
}

static int set_srep_parameter_str(struct vty *vty,
	int (*fun)(struct osmo_stats_reporter *, const char *),
	const char *val, const char *param_name)
{
	int rc;
	struct osmo_stats_reporter *srep = osmo_stats_vty2srep(vty);
	OSMO_ASSERT(srep);

	rc = fun(srep, val);
	if (rc < 0) {
		vty_out(vty, "%% Unable to set %s: %s%s",
			param_name, strerror(-rc), VTY_NEWLINE);
		return CMD_WARNING;
	}

	return CMD_SUCCESS;
}

static int set_srep_parameter_int(struct vty *vty,
	int (*fun)(struct osmo_stats_reporter *, int),
	const char *val, const char *param_name)
{
	int rc;
	int int_val;
	struct osmo_stats_reporter *srep = osmo_stats_vty2srep(vty);
	OSMO_ASSERT(srep);

	int_val = atoi(val);

	rc = fun(srep, int_val);
	if (rc < 0) {
		vty_out(vty, "%% Unable to set %s: %s%s",
			param_name, strerror(-rc), VTY_NEWLINE);
		return CMD_WARNING;
	}

	return CMD_SUCCESS;
}

DEFUN(cfg_stats_reporter_local_ip, cfg_stats_reporter_local_ip_cmd,
	"local-ip ADDR",
	"Set the IP address to which we bind locally\n"
	"IP Address\n")
{
	return set_srep_parameter_str(vty, osmo_stats_reporter_set_local_addr,
		argv[0], "local address");
}

DEFUN(cfg_no_stats_reporter_local_ip, cfg_no_stats_reporter_local_ip_cmd,
	"no local-ip",
	NO_STR
	"Set the IP address to which we bind locally\n")
{
	return set_srep_parameter_str(vty, osmo_stats_reporter_set_local_addr,
		NULL, "local address");
}

DEFUN(cfg_stats_reporter_remote_ip, cfg_stats_reporter_remote_ip_cmd,
	"remote-ip ADDR",
	"Set the remote IP address to which we connect\n"
	"IP Address\n")
{
	return set_srep_parameter_str(vty, osmo_stats_reporter_set_remote_addr,
		argv[0], "remote address");
}

DEFUN(cfg_stats_reporter_remote_port, cfg_stats_reporter_remote_port_cmd,
	"remote-port <1-65535>",
	"Set the remote port to which we connect\n"
	"Remote port number\n")
{
	return set_srep_parameter_int(vty, osmo_stats_reporter_set_remote_port,
		argv[0], "remote port");
}

DEFUN(cfg_stats_reporter_mtu, cfg_stats_reporter_mtu_cmd,
	"mtu <100-65535>",
	"Set the maximum packet size\n"
	"Size in byte\n")
{
	return set_srep_parameter_int(vty, osmo_stats_reporter_set_mtu,
		argv[0], "mtu");
}

DEFUN(cfg_no_stats_reporter_mtu, cfg_no_stats_reporter_mtu_cmd,
	"no mtu",
	NO_STR "Set the maximum packet size\n")
{
	return set_srep_parameter_int(vty, osmo_stats_reporter_set_mtu,
		"0", "mtu");
}

DEFUN(cfg_stats_reporter_prefix, cfg_stats_reporter_prefix_cmd,
	"prefix PREFIX",
	"Set the item name prefix\n"
	"The prefix string\n")
{
	return set_srep_parameter_str(vty, osmo_stats_reporter_set_name_prefix,
		argv[0], "prefix string");
}

DEFUN(cfg_no_stats_reporter_prefix, cfg_no_stats_reporter_prefix_cmd,
	"no prefix",
	NO_STR
	"Set the item name prefix\n")
{
	return set_srep_parameter_str(vty, osmo_stats_reporter_set_name_prefix,
		"", "prefix string");
}

DEFUN(cfg_stats_reporter_level, cfg_stats_reporter_level_cmd,
	"level (global|peer|subscriber)",
	"Set the maximum group level\n"
	"Report global groups only\n"
	"Report global and network peer related groups\n"
	"Report global, peer, and subscriber groups\n")
{
	int level = get_string_value(stats_class_strs, argv[0]);
	int rc;
	struct osmo_stats_reporter *srep = osmo_stats_vty2srep(vty);

	OSMO_ASSERT(srep);
	rc = osmo_stats_reporter_set_max_class(srep, level);
	if (rc < 0) {
		vty_out(vty, "%% Unable to set level: %s%s",
			strerror(-rc), VTY_NEWLINE);
		return CMD_WARNING;
	}

	return 0;
}

DEFUN(cfg_stats_reporter_enable, cfg_stats_reporter_enable_cmd,
	"enable",
	"Enable the reporter\n")
{
	int rc;
	struct osmo_stats_reporter *srep = osmo_stats_vty2srep(vty);
	OSMO_ASSERT(srep);

	rc = osmo_stats_reporter_enable(srep);
	if (rc < 0) {
		vty_out(vty, "%% Unable to enable the reporter: %s%s",
			strerror(-rc), VTY_NEWLINE);
		return CMD_WARNING;
	}

	return CMD_SUCCESS;
}

DEFUN(cfg_stats_reporter_disable, cfg_stats_reporter_disable_cmd,
	"disable",
	"Disable the reporter\n")
{
	int rc;
	struct osmo_stats_reporter *srep = osmo_stats_vty2srep(vty);
	OSMO_ASSERT(srep);

	rc = osmo_stats_reporter_disable(srep);
	if (rc < 0) {
		vty_out(vty, "%% Unable to disable the reporter: %s%s",
			strerror(-rc), VTY_NEWLINE);
		return CMD_WARNING;
	}

	return CMD_SUCCESS;
}

DEFUN(cfg_stats_reporter_flush_period, cfg_stats_reporter_flush_period_cmd,
	"flush-period <0-65535>",
	CFG_STATS_STR "Send all stats even if they have not changed (i.e. force the flush)"
	              "every N-th reporting interval. Set to 0 to disable regular flush (default).\n"
	"0 to disable regular flush (default), 1 to flush every time, 2 to flush every 2nd time, etc\n")
{
	int rc;
	unsigned int period = atoi(argv[0]);
	struct osmo_stats_reporter *srep = osmo_stats_vty2srep(vty);
	OSMO_ASSERT(srep);

	rc = osmo_stats_reporter_set_flush_period(srep, period);
	if (rc < 0) {
		vty_out(vty, "%% Unable to set force flush period: %s%s",
			strerror(-rc), VTY_NEWLINE);
		return CMD_WARNING;
	}

	return CMD_SUCCESS;
}

DEFUN(cfg_stats_reporter_statsd, cfg_stats_reporter_statsd_cmd,
	"stats reporter statsd [NAME]",
	CFG_STATS_STR CFG_REPORTER_STR
	"Report to a STATSD server\n"
	"Name of the reporter\n")
{
	struct osmo_stats_reporter *srep;
	const char *name = NULL;

	if (argc > 0)
		name = argv[0];

	srep = osmo_stats_reporter_find(OSMO_STATS_REPORTER_STATSD, name);
	if (!srep) {
		srep = osmo_stats_reporter_create_statsd(name);
		if (!srep) {
			vty_out(vty, "%% Unable to create statsd reporter%s",
				VTY_NEWLINE);
			return CMD_WARNING;
		}
		srep->max_class = OSMO_STATS_CLASS_GLOBAL;
		/* TODO: if needed, add osmo_stats_add_reporter(srep); */
	}

	vty->index = srep;
	vty->node = CFG_STATS_NODE;

	return CMD_SUCCESS;
}

DEFUN(cfg_no_stats_reporter_statsd, cfg_no_stats_reporter_statsd_cmd,
	"no stats reporter statsd [NAME]",
	NO_STR CFG_STATS_STR CFG_REPORTER_STR
	"Report to a STATSD server\n"
	"Name of the reporter\n")
{
	struct osmo_stats_reporter *srep;
	const char *name = NULL;

	if (argc > 0)
		name = argv[0];

	srep = osmo_stats_reporter_find(OSMO_STATS_REPORTER_STATSD, name);
	if (!srep) {
		vty_out(vty, "%% There is no such statsd reporter with name '%s'%s",
			name ? name : "", VTY_NEWLINE);
		return CMD_WARNING;
	}

	osmo_stats_reporter_free(srep);

	return CMD_SUCCESS;
}

DEFUN(cfg_stats_reporter_log, cfg_stats_reporter_log_cmd,
	"stats reporter log [NAME]",
	CFG_STATS_STR CFG_REPORTER_STR
	"Report to the logger\n"
	"Name of the reporter\n")
{
	struct osmo_stats_reporter *srep;
	const char *name = NULL;

	if (argc > 0)
		name = argv[0];

	srep = osmo_stats_reporter_find(OSMO_STATS_REPORTER_LOG, name);
	if (!srep) {
		srep = osmo_stats_reporter_create_log(name);
		if (!srep) {
			vty_out(vty, "%% Unable to create log reporter%s",
				VTY_NEWLINE);
			return CMD_WARNING;
		}
		srep->max_class = OSMO_STATS_CLASS_GLOBAL;
		/* TODO: if needed, add osmo_stats_add_reporter(srep); */
	}

	vty->index = srep;
	vty->node = CFG_STATS_NODE;

	return CMD_SUCCESS;
}

DEFUN(cfg_no_stats_reporter_log, cfg_no_stats_reporter_log_cmd,
	"no stats reporter log [NAME]",
	NO_STR CFG_STATS_STR CFG_REPORTER_STR
	"Report to the logger\n"
	"Name of the reporter\n")
{
	struct osmo_stats_reporter *srep;
	const char *name = NULL;

	if (argc > 0)
		name = argv[0];

	srep = osmo_stats_reporter_find(OSMO_STATS_REPORTER_LOG, name);
	if (!srep) {
		vty_out(vty, "%% There is no such log reporter with name '%s'%s",
			name ? name : "", VTY_NEWLINE);
		return CMD_WARNING;
	}

	osmo_stats_reporter_free(srep);

	return CMD_SUCCESS;
}

DEFUN(cfg_stats_interval, cfg_stats_interval_cmd,
	"stats interval <0-65535>",
	CFG_STATS_STR "Set the reporting interval\n"
	"Interval in seconds (0 disables the reporting interval)\n")
{
	int rc;
	int interval = atoi(argv[0]);
	rc = osmo_stats_set_interval(interval);
	if (rc < 0) {
		vty_out(vty, "%% Unable to set interval: %s%s",
			strerror(-rc), VTY_NEWLINE);
		return CMD_WARNING;
	}

	return CMD_SUCCESS;
}

DEFUN(cfg_tcp_stats_interval, cfg_tcp_stats_interval_cmd,
	"stats-tcp interval <0-65535>",
	CFG_STATS_STR "Set the tcp socket stats polling interval\n"
	"Interval in seconds (0 disables the polling interval)\n")
{
	int rc;
	int interval = atoi(argv[0]);
	rc = osmo_stats_tcp_set_interval(interval);
	if (rc < 0) {
		vty_out(vty, "%% Unable to set interval: %s%s",
			strerror(-rc), VTY_NEWLINE);
		return CMD_WARNING;
	}

	return CMD_SUCCESS;
}

DEFUN(cfg_tcp_stats_batch_size, cfg_tcp_stats_batch_size_cmd,
	"stats-tcp batch-size <1-65535>",
	CFG_STATS_STR "Set the number of tcp sockets that are processed per stats polling interval\n"
	"Number of sockets per interval\n")
{
	osmo_tcp_stats_config->batch_size = atoi(argv[0]);
	return CMD_SUCCESS;
}

DEFUN(show_stats,
      show_stats_cmd,
      "show stats [skip-zero]",
      SHOW_STR SHOW_STATS_STR SKIP_ZERO_STR)
{
	bool skip_zero = false;
	if (argc > 0)
		skip_zero = true;

	vty_out_statistics_full2(vty, "", skip_zero);

	return CMD_SUCCESS;
}

DEFUN(show_stats_level,
      show_stats_level_cmd,
      "show stats level (global|peer|subscriber) [skip-zero]",
      SHOW_STR SHOW_STATS_STR
      "Set the maximum group level\n"
      "Show global groups only\n"
      "Show global and network peer related groups\n"
      "Show global, peer, and subscriber groups\n" SKIP_ZERO_STR)
{
	int level = get_string_value(stats_class_strs, argv[0]);
	bool skip_zero = false;
	if (argc > 1)
		skip_zero = true;
	vty_out_statistics_partial2(vty, "", level, skip_zero);

	return CMD_SUCCESS;
}

static int asciidoc_handle_counter(struct osmo_counter *counter, void *sctx_)
{
	struct vty *vty = sctx_;
	char *name = osmo_asciidoc_escape(counter->name);
	char *description = osmo_asciidoc_escape(counter->description);

	/* | name | This document & | description | */
	vty_out(vty, "| %s | <<ungroup_counter_%s>> | %s%s",
		name,
		name,
		description ? description : "",
		VTY_NEWLINE);

	talloc_free(name);
	talloc_free(description);

	return 0;
}

static void asciidoc_counter_generate(struct vty *vty)
{
	vty_out(vty, "// ungrouped osmo_counters%s", VTY_NEWLINE);
	vty_out(vty, ".ungrouped osmo counters%s", VTY_NEWLINE);
	vty_out(vty, "[options=\"header\"]%s", VTY_NEWLINE);
	vty_out(vty, "|===%s", VTY_NEWLINE);
	vty_out(vty, "| Name | Reference | Description%s", VTY_NEWLINE);
	osmo_counters_for_each(asciidoc_handle_counter, vty);
	vty_out(vty, "|===%s", VTY_NEWLINE);
}

static int asciidoc_rate_ctr_handler(
	struct rate_ctr_group *ctrg, struct rate_ctr *ctr,
	const struct rate_ctr_desc *desc, void *sctx_)
{
	struct vty *vty = sctx_;
	char *name = osmo_asciidoc_escape(desc->name);
	char *description = osmo_asciidoc_escape(desc->description);
	char *group_name_prefix = osmo_asciidoc_escape(ctrg->desc->group_name_prefix);

	/* | Name | This document & | Description | */
	vty_out(vty, "| %s | <<%s_%s>> | %s%s",
		name,
		group_name_prefix,
		name,
		description ? description : NULL,
		VTY_NEWLINE);

	/* description seems to be optional */
	talloc_free(name);
	talloc_free(group_name_prefix);
	talloc_free(description);

	return 0;
}

static int asciidoc_rate_ctr_group_handler(struct rate_ctr_group *ctrg, void *sctx_)
{
	struct vty *vty = sctx_;

	char *group_description = osmo_asciidoc_escape(ctrg->desc->group_description);
	char *group_name_prefix = osmo_asciidoc_escape(ctrg->desc->group_name_prefix);

	vty_out(vty, "// rate_ctr_group table %s%s", group_description, VTY_NEWLINE);
	vty_out(vty, ".%s - %s%s", group_name_prefix, group_description, VTY_NEWLINE);
	vty_out(vty, "[options=\"header\"]%s", VTY_NEWLINE);
	vty_out(vty, "|===%s", VTY_NEWLINE);
	vty_out(vty, "| Name | Reference | Description%s", VTY_NEWLINE);
	rate_ctr_for_each_counter(ctrg, asciidoc_rate_ctr_handler, sctx_);
	vty_out(vty, "|===%s", VTY_NEWLINE);

	talloc_free(group_name_prefix);
	talloc_free(group_description);

	return 0;
}

static int asciidoc_osmo_stat_item_handler(
	struct osmo_stat_item_group *statg, struct osmo_stat_item *item, void *sctx_)
{
	struct vty *vty = sctx_;

	const struct osmo_stat_item_desc *desc = osmo_stat_item_get_desc(item);
	char *name = osmo_asciidoc_escape(desc->name);
	char *description = osmo_asciidoc_escape(desc->description);
	char *group_name_prefix = osmo_asciidoc_escape(statg->desc->group_name_prefix);
	char *unit = osmo_asciidoc_escape(desc->unit);

	/* | Name | Reference | Description | Unit | */
	vty_out(vty, "| %s | <<%s_%s>> | %s | %s%s",
		name,
		group_name_prefix,
		name,
		description ? description : "",
		unit ? unit : "",
		VTY_NEWLINE);

	talloc_free(name);
	talloc_free(group_name_prefix);
	talloc_free(description);
	talloc_free(unit);

	return 0;
}

static int asciidoc_osmo_stat_item_group_handler(struct osmo_stat_item_group *statg, void *sctx_)
{
	char *group_name_prefix = osmo_asciidoc_escape(statg->desc->group_name_prefix);
	char *group_description = osmo_asciidoc_escape(statg->desc->group_description);

	struct vty *vty = sctx_;
	vty_out(vty, "%s%s", group_description ? group_description : "" , VTY_NEWLINE);

	vty_out(vty, "// osmo_stat_item_group table %s%s", group_description ? group_description : "", VTY_NEWLINE);
	vty_out(vty, ".%s - %s%s", group_name_prefix, group_description ? group_description : "", VTY_NEWLINE);
	vty_out(vty, "[options=\"header\"]%s", VTY_NEWLINE);
	vty_out(vty, "|===%s", VTY_NEWLINE);
	vty_out(vty, "| Name | Reference | Description | Unit%s", VTY_NEWLINE);
	osmo_stat_item_for_each_item(statg, asciidoc_osmo_stat_item_handler, sctx_);
	vty_out(vty, "|===%s", VTY_NEWLINE);

	talloc_free(group_name_prefix);
	talloc_free(group_description);

	return 0;
}

DEFUN(show_stats_asciidoc_table,
      show_stats_asciidoc_table_cmd,
      "show asciidoc counters",
      SHOW_STR "Asciidoc generation\n" "Generate table of all registered counters\n")
{
	vty_out(vty, "// autogenerated by show asciidoc counters%s", VTY_NEWLINE);
	vty_out(vty, "These counters and their description are based on %s %s (%s).%s%s",
		host.app_info->name,
		host.app_info->version,
		host.app_info->name ? host.app_info->name : "", VTY_NEWLINE, VTY_NEWLINE);
	/* 2x VTY_NEWLINE are intentional otherwise it would interpret the first table header
	 * as usual text*/
	vty_out(vty, "=== Rate Counters%s%s", VTY_NEWLINE, VTY_NEWLINE);
	vty_out(vty, "// generating tables for rate_ctr_group%s", VTY_NEWLINE);
	rate_ctr_for_each_group(asciidoc_rate_ctr_group_handler, vty);

	vty_out(vty, "=== Osmo Stat Items%s%s", VTY_NEWLINE, VTY_NEWLINE);
	vty_out(vty, "// generating tables for osmo_stat_items%s", VTY_NEWLINE);
	osmo_stat_item_for_each_group(asciidoc_osmo_stat_item_group_handler, vty);

	if (osmo_counters_count() == 0)
	{
		vty_out(vty, "// there are no ungrouped osmo_counters%s",
			VTY_NEWLINE);
	} else {
		vty_out(vty, "=== Osmo Counters%s%s", VTY_NEWLINE, VTY_NEWLINE);
		vty_out(vty, "// generating tables for osmo_counters%s", VTY_NEWLINE);
		asciidoc_counter_generate(vty);
	}
	return CMD_SUCCESS;
}

struct rctr_vty_ctx {
	struct vty *vty;
	bool skip_zero;
};

static int rate_ctr_group_handler(struct rate_ctr_group *ctrg, void *sctx_)
{
	struct rctr_vty_ctx *sctx = sctx_;
	struct vty *vty = sctx->vty;
	vty_out(vty, "%s %u", ctrg->desc->group_description, ctrg->idx);
	if (ctrg->name != NULL)
		vty_out(vty, " (%s)", ctrg->name);
	vty_out(vty, ":%s", VTY_NEWLINE);
	vty_out_rate_ctr_group_fmt2(vty, "%25n: %10c (%S/s %M/m %H/h %D/d) %d", ctrg, sctx->skip_zero);
	return 0;
}

DEFUN(show_rate_counters,
      show_rate_counters_cmd,
      "show rate-counters [skip-zero]",
      SHOW_STR "Show all rate counters\n" SKIP_ZERO_STR)
{
	struct rctr_vty_ctx rctx = { .vty = vty, .skip_zero = false };
	if (argc > 0)
		rctx.skip_zero = true;
	rate_ctr_for_each_group(rate_ctr_group_handler, &rctx);
	return CMD_SUCCESS;
}

DEFUN(stats_report,
      stats_report_cmd,
      "stats report",
      STATS_STR "Manurally trigger reporting of stats\n")
{
        osmo_stats_report();
	return CMD_SUCCESS;
}

static int reset_rate_ctr_group_handler(struct rate_ctr_group *ctrg, void *sctx_)
{
        rate_ctr_group_reset(ctrg);
        return 0;
}

DEFUN(stats_reset,
      stats_reset_cmd,
      "stats reset",
      STATS_STR "Reset all rate counter stats\n")
{
        rate_ctr_for_each_group(reset_rate_ctr_group_handler, NULL);
	return CMD_SUCCESS;
}

static int config_write_stats_reporter(struct vty *vty, struct osmo_stats_reporter *srep)
{
	const char *type = NULL;

	switch (srep->type) {
	case OSMO_STATS_REPORTER_STATSD:
		type = "statsd";
		break;
	case OSMO_STATS_REPORTER_LOG:
		type = "log";
		break;
	default:
		/* don't try to save unknown stats reporters to the VTY.  Imagine some
		 * application registering a new application specific stats reporter that
		 * this VTY code knows nothing about! */
		return 0;
	}

	vty_out(vty, "stats reporter %s", type);
	if (srep->name != NULL)
		vty_out(vty, " %s", srep->name);
	vty_out(vty, "%s", VTY_NEWLINE);

	if (srep->have_net_config) {
		if (srep->dest_addr_str)
			vty_out(vty, "  remote-ip %s%s",
				srep->dest_addr_str, VTY_NEWLINE);
		if (srep->dest_port)
			vty_out(vty, "  remote-port %d%s",
				srep->dest_port, VTY_NEWLINE);
		if (srep->bind_addr_str)
			vty_out(vty, "  local-ip %s%s",
				srep->bind_addr_str, VTY_NEWLINE);
		if (srep->mtu)
			vty_out(vty, "  mtu %d%s",
				srep->mtu, VTY_NEWLINE);
	}

	if (srep->max_class)
		vty_out(vty, "  level %s%s",
			get_value_string(stats_class_strs, srep->max_class),
			VTY_NEWLINE);

	if (srep->name_prefix && *srep->name_prefix)
		vty_out(vty, "  prefix %s%s",
			srep->name_prefix, VTY_NEWLINE);
	else
		vty_out(vty, "  no prefix%s", VTY_NEWLINE);

	if (srep->flush_period > 0)
		vty_out(vty, "  flush-period %d%s",
			srep->flush_period, VTY_NEWLINE);

	if (srep->enabled)
		vty_out(vty, "  enable%s", VTY_NEWLINE);
	else
		vty_out(vty, "  disable%s", VTY_NEWLINE);

	return 1;
}

static int config_write_stats(struct vty *vty)
{
	struct osmo_stats_reporter *srep;

	vty_out(vty, "stats interval %d%s", osmo_stats_config->interval, VTY_NEWLINE);
	if (osmo_tcp_stats_config->interval != TCP_STATS_DEFAULT_INTERVAL)
		vty_out(vty, "stats-tcp interval %d%s", osmo_tcp_stats_config->interval, VTY_NEWLINE);
	if (osmo_tcp_stats_config->batch_size != TCP_STATS_DEFAULT_BATCH_SIZE)
		vty_out(vty, "stats-tcp batch-size %d%s", osmo_tcp_stats_config->batch_size, VTY_NEWLINE);

	/* Loop through all reporters */
	llist_for_each_entry(srep, &osmo_stats_reporter_list, list)
		config_write_stats_reporter(vty, srep);

	return 1;
}

/*! Add stats related commands to the VTY
 *  Call this once during your application initialization if you would
 *  like to have stats VTY commands enabled.
 */
void osmo_stats_vty_add_cmds(void)
{
	install_lib_element_ve(&show_stats_cmd);
	install_lib_element_ve(&show_stats_level_cmd);

	install_lib_element(CONFIG_NODE, &cfg_stats_reporter_statsd_cmd);
	install_lib_element(CONFIG_NODE, &cfg_no_stats_reporter_statsd_cmd);
	install_lib_element(CONFIG_NODE, &cfg_stats_reporter_log_cmd);
	install_lib_element(CONFIG_NODE, &cfg_no_stats_reporter_log_cmd);
	install_lib_element(CONFIG_NODE, &cfg_stats_interval_cmd);
	install_lib_element(CONFIG_NODE, &cfg_tcp_stats_interval_cmd);
	install_lib_element(CONFIG_NODE, &cfg_tcp_stats_batch_size_cmd);

	install_node(&cfg_stats_node, config_write_stats);

	install_lib_element(CFG_STATS_NODE, &cfg_stats_reporter_local_ip_cmd);
	install_lib_element(CFG_STATS_NODE, &cfg_no_stats_reporter_local_ip_cmd);
	install_lib_element(CFG_STATS_NODE, &cfg_stats_reporter_remote_ip_cmd);
	install_lib_element(CFG_STATS_NODE, &cfg_stats_reporter_remote_port_cmd);
	install_lib_element(CFG_STATS_NODE, &cfg_stats_reporter_mtu_cmd);
	install_lib_element(CFG_STATS_NODE, &cfg_no_stats_reporter_mtu_cmd);
	install_lib_element(CFG_STATS_NODE, &cfg_stats_reporter_prefix_cmd);
	install_lib_element(CFG_STATS_NODE, &cfg_no_stats_reporter_prefix_cmd);
	install_lib_element(CFG_STATS_NODE, &cfg_stats_reporter_level_cmd);
	install_lib_element(CFG_STATS_NODE, &cfg_stats_reporter_enable_cmd);
	install_lib_element(CFG_STATS_NODE, &cfg_stats_reporter_disable_cmd);
	install_lib_element(CFG_STATS_NODE, &cfg_stats_reporter_flush_period_cmd);

	install_lib_element_ve(&show_stats_asciidoc_table_cmd);
	install_lib_element_ve(&show_rate_counters_cmd);

        install_lib_element(ENABLE_NODE, &stats_report_cmd);
        install_lib_element(ENABLE_NODE, &stats_reset_cmd);
}