[metrics] Add a basic CLI

systemd-report will list all the metrics.

Author: YapingLi04

src/report/meson.build

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+
+executables += [
+        executable_template + {
+                'name' : 'systemd-report',
+                'public' : true,
+                'sources' : files('report.c'),
+        },
+]

src/report/report.c

@@ -0,0 +1,227 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+
+#include <getopt.h>
+
+#include "alloc-util.h"
+#include "build.h"
+#include "dirent-util.h"
+#include "fd-util.h"
+#include "log.h"
+#include "main-func.h"
+#include "sd-varlink.h"
+#include "string-util.h"
+#include "sd-event.h"
+#include "time-util.h"
+
+#define RUN_SYSTEMD_METRICS_PATH "/run/systemd/metrics/"
+#define MAX_CONCURRENT_METRICS_SOCKETS 20
+#define TIMEOUT_USEC (30*USEC_PER_SEC) /* 30 seconds */
+
+typedef struct Context {
+        int n_ref;
+} Context;
+
+static int metrics_on_query_reply(
+                sd_varlink *link,
+                sd_json_variant *parameters,
+                const char *error_id,
+                sd_varlink_reply_flags_t flags,
+                void *userdata) {
+        assert(link);
+
+        Context* context = ASSERT_PTR(userdata);
+
+        if (error_id) {
+                bool disconnect = streq(error_id, SD_VARLINK_ERROR_DISCONNECTED);
+                if (disconnect)
+                        log_info("Disconnected.");
+                else
+                        log_error("Varlink error: %s", error_id);
+
+                (void) sd_event_exit(ASSERT_PTR(sd_varlink_get_event(link)), disconnect ? EXIT_SUCCESS : EXIT_FAILURE);
+                return 0;
+        }
+
+        sd_json_variant_dump(parameters, SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO, stdout, NULL);
+
+        fflush(stdout);
+
+        if (FLAGS_SET(flags, SD_VARLINK_REPLY_ERROR)) {
+                (void) sd_event_exit(ASSERT_PTR(sd_varlink_get_event(link)), EXIT_FAILURE);
+                return 0;
+        }
+
+        if ((flags == 0) && (--context->n_ref <= 0))
+                (void) sd_event_exit(ASSERT_PTR(sd_varlink_get_event(link)), EXIT_SUCCESS);
+
+        return 0;
+}
+
+static int metrics_call(const char *path, sd_event *event, sd_varlink *vl, Context *context) {
+        int r;
+
+        assert(path);
+        assert(event);
+        assert(context);
+
+        r = sd_varlink_connect_address(&vl, path);
+        if (r < 0)
+                return log_debug_errno(r, "Unable to connect to %s: %m", path);
+
+        (void) sd_varlink_set_userdata(vl, context);
+
+        r = sd_varlink_attach_event(vl, event, SD_EVENT_PRIORITY_NORMAL);
+        if (r < 0)
+                return log_debug_errno(r, "Failed to attach varlink connection to event loop: %m");
+
+        r = sd_varlink_bind_reply(vl, metrics_on_query_reply);
+        if (r < 0)
+                return log_debug_errno(r, "Failed to bind reply callback: %m");
+
+        r = sd_varlink_observe(vl, "io.systemd.Metrics.List", /* parameter */ NULL);
+        if (r < 0)
+                return log_debug_errno(r, "Failed to issue io.systemd.Metrics.List call: %m");
+
+        return 0;
+}
+
+static void sd_varlink_unref_many(sd_varlink **array, size_t n) {
+        FOREACH_ARRAY(v, array, n)
+                sd_varlink_unref(*v);
+
+
+        free(array);
+}
+
+static int timeout_callback(sd_event_source *es, uint64_t usec, void *userdata) {
+        return sd_event_exit(ASSERT_PTR(sd_event_source_get_event(es)), EXIT_FAILURE);
+}
+
+static int metrics_start_query(void) {
+        _cleanup_closedir_ DIR *d = NULL;
+        _cleanup_(sd_event_unrefp) sd_event *event = NULL;
+        int r, c;
+
+        d = opendir(RUN_SYSTEMD_METRICS_PATH);
+        if (!d) {
+                if (errno == ENOENT)
+                        return -ESRCH;
+
+                return -errno;
+        }
+
+        r = sd_event_default(&event);
+        if (r < 0)
+                return log_error_errno(r, "Failed to get event loop: %m");
+
+        r = sd_event_set_signal_exit(event, true);
+        if (r < 0)
+                return log_error_errno(r, "Failed to enable exit on SIGINT/SIGTERM: %m");
+
+        sd_varlink *varlinks[MAX_CONCURRENT_METRICS_SOCKETS] = {};
+        size_t n_varlinks = MAX_CONCURRENT_METRICS_SOCKETS;
+        Context context = {};
+        int i = 0;
+
+        CLEANUP_ARRAY(varlinks, n_varlinks, sd_varlink_unref_many);
+
+        FOREACH_DIRENT(de, d, return -errno) {
+                _cleanup_free_ char *p = NULL;
+
+                if (de->d_type != DT_SOCK && de->d_type != DT_UNKNOWN)
+                        continue;
+
+                p = path_join(RUN_SYSTEMD_METRICS_PATH, de->d_name);
+                if (!p)
+                        return -ENOMEM;
+
+                context.n_ref++;
+
+                r = metrics_call(p, event, varlinks[i], &context);
+                if (r < 0) {
+                        context.n_ref--;
+                        continue;
+                }
+
+                if (++i >= MAX_CONCURRENT_METRICS_SOCKETS)
+                        break;
+        }
+
+        r = sd_event_add_time_relative(event, NULL, CLOCK_MONOTONIC, 100, 0, timeout_callback, NULL);
+        if (r < 0)
+                return log_error_errno(r, "Failed to add timer event: %m");
+
+        r = sd_event_loop(event);
+        if (r < 0)
+                r = log_error_errno(r, "Failed to run event loop: %m");
+
+        r = sd_event_get_exit_code(event, &c);
+        if (r < 0)
+                r = log_error_errno(r, "Failed to get exit code: %m");
+
+        return c;
+}
+
+static int help(void) {
+        printf("%s [OPTIONS...]\n\n"
+                "Print metrics for all systemd components.\n\n"
+                "  -h --help             Show this help\n"
+                "     --version          Show package version\n",
+                program_invocation_short_name);
+
+        return 0;
+}
+
+static int parse_argv(int argc, char *argv[]) {
+        enum {
+                ARG_VERSION = 0x100
+        };
+
+        static const struct option options[] = {
+                { "help",          no_argument,       NULL, 'h'               },
+                { "version",       no_argument,       NULL, ARG_VERSION       },
+                {}
+        };
+
+        int c;
+
+        assert(argc >= 0);
+        assert(argv);
+
+        while ((c = getopt_long(argc, argv, "hp", options, NULL)) >= 0)
+                switch (c) {
+                case 'h':
+                        return help();
+                case ARG_VERSION:
+                        return version();
+                case '?':
+                        return -EINVAL;
+                default:
+                        assert_not_reached();
+                }
+
+        if (optind < argc)
+                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
+                                        "%s takes no arguments.",
+                                        program_invocation_short_name);
+
+        return 1;
+}
+
+static int run(int argc, char *argv[]) {
+        int r;
+
+        log_setup();
+
+        r = parse_argv(argc, argv);
+        if (r <= 0)
+                return r;
+
+        r = metrics_start_query();
+        if (r < 0)
+                return r;
+
+        return 0;
+}
+
+DEFINE_MAIN_FUNCTION_WITH_POSITIVE_FAILURE(run);

test/units/TEST-74-AUX-UTILS.varlinkctl.sh

@@ -219,3 +219,6 @@ systemd-run --wait --pipe --user --machine testuser@ \
 # test io.systemd.Unit in user manager
 systemd-run --wait --pipe --user --machine testuser@ \
         varlinkctl --more call "/run/user/$testuser_uid/systemd/io.systemd.Manager" io.systemd.Unit.List '{}'
+
+# test report
+systemd-report