Merge pull request #2173 from RincewindsHat/modern_output/check_pgsqlHEADmaster

Modern output/check pgsql

1 files changed, 203 insertions, 89 deletions

diff --git a/plugins/check_pgsql.c b/plugins/check_pgsql.c
index 793a686f..0ce75e0a 100644
--- a/plugins/check_pgsql.c
+++ b/plugins/check_pgsql.c
@@ -28,27 +28,29 @@
  *
  *****************************************************************************/
 
+#include "output.h"
+#include "perfdata.h"
 #include "states.h"
-const char *progname = "check_pgsql";
-const char *copyright = "1999-2024";
-const char *email = "devel@monitoring-plugins.org";
-
 #include "common.h"
 #include "utils.h"
 #include "utils_cmd.h"
 #include "check_pgsql.d/config.h"
 #include "thresholds.h"
-
 #include "netutils.h"
 #include <libpq-fe.h>
 #include <pg_config_manual.h>
 
+const char *progname = "check_pgsql";
+const char *copyright = "1999-2024";
+const char *email = "devel@monitoring-plugins.org";
+
 #define DEFAULT_HOST "127.0.0.1"
 
 /* return the PSQL server version as a 3-tuple */
 #define PSQL_SERVER_VERSION3(server_version)                                                       \
-        (server_version) / 10000, (server_version) / 100 - (int)((server_version) / 10000) * 100,      \
-                (server_version) - (int)((server_version) / 100) * 100
+        ((server_version) / 10000),                                                                    \
+                (((server_version) / 100) - (int)(((server_version) / 10000) * 100)),                      \
+                (server_version) - (int)(((server_version) / 100) * 100)
 /* return true if the given host is a UNIX domain socket */
 #define PSQL_IS_UNIX_DOMAIN_SOCKET(host) ((NULL == (host)) || ('\0' == *(host)) || ('/' == *(host)))
 /* return a 3-tuple identifying a host/port independent of the socket type */
@@ -64,15 +66,25 @@ static check_pgsql_config_wrapper process_arguments(int /*argc*/, char ** /*argv
 
 static void print_help(void);
 static bool is_pg_logname(char * /*username*/);
-static mp_state_enum do_query(PGconn * /*conn*/, char * /*query*/, const char /*pgqueryname*/[],
-                                                          thresholds * /*qthresholds*/, char * /*query_warning*/,
-                                                          char * /*query_critical*/);
+
+typedef enum {
+        QUERY_OK,
+        ERROR_WITH_QUERY,     // critical
+        NO_ROWS_RETURNED,     // warning
+        NO_COLUMNS_RETURNED,  // warning
+        NO_DATA_RETURNED,     // critica/
+        RESULT_IS_NOT_NUMERIC // critical
+} do_query_errorcode;
+
+typedef struct {
+        do_query_errorcode error_code;
+        double numerical_result;
+} do_query_wrapper;
+static do_query_wrapper do_query(PGconn * /*conn*/, char * /*query*/);
 void print_usage(void);
 
 static int verbose = 0;
 
-#define OPTID_QUERYNAME -1000
-
 /******************************************************************************
 
 The (pseudo?)literate programming XML is contained within \@\@\- <XML> \-\@\@
@@ -138,8 +150,8 @@ int main(int argc, char **argv) {
 
         const check_pgsql_config config = tmp_config.config;
 
-        if (verbose > 2) {
-                printf("Arguments initialized\n");
+        if (config.output_format_is_set) {
+                mp_set_format(config.output_format);
         }
 
         /* Set signal handling and alarm */
@@ -199,21 +211,41 @@ int main(int argc, char **argv) {
         if (verbose) {
                 printf("Verifying connection\n");
         }
+
+        mp_check overall = mp_check_init();
+
+        mp_subcheck sc_connection = mp_subcheck_init();
+
         if (PQstatus(conn) == CONNECTION_BAD) {
-                printf(_("CRITICAL - no connection to '%s' (%s).\n"), config.dbName, PQerrorMessage(conn));
+                sc_connection = mp_set_subcheck_state(sc_connection, STATE_CRITICAL);
+                xasprintf(&sc_connection.output, "no connection to '%s' (%s)", config.dbName,
+                                  PQerrorMessage(conn));
                 PQfinish(conn);
-                return STATE_CRITICAL;
-        }
-
-        mp_state_enum status = STATE_UNKNOWN;
-        if (elapsed_time > config.tcrit) {
-                status = STATE_CRITICAL;
-        } else if (elapsed_time > config.twarn) {
-                status = STATE_WARNING;
+                mp_add_subcheck_to_check(&overall, sc_connection);
+                mp_exit(overall);
         } else {
-                status = STATE_OK;
+                sc_connection = mp_set_subcheck_state(sc_connection, STATE_OK);
+                xasprintf(&sc_connection.output, "connected to '%s'", config.dbName);
+                mp_add_subcheck_to_check(&overall, sc_connection);
         }
 
+        mp_subcheck sc_connection_time = mp_subcheck_init();
+        sc_connection_time = mp_set_subcheck_default_state(sc_connection_time, STATE_UNKNOWN);
+
+        xasprintf(&sc_connection_time.output, "connection time: %.10g", elapsed_time);
+
+        mp_perfdata pd_connection_time = perfdata_init();
+        pd_connection_time.label = "time";
+        pd_connection_time.uom = "s";
+        pd_connection_time = mp_set_pd_value(pd_connection_time, elapsed_time);
+        pd_connection_time = mp_pd_set_thresholds(pd_connection_time, config.time_thresholds);
+
+        mp_add_perfdata_to_subcheck(&sc_connection_time, pd_connection_time);
+        sc_connection_time =
+                mp_set_subcheck_state(sc_connection_time, mp_get_pd_status(pd_connection_time));
+
+        mp_add_subcheck_to_check(&overall, sc_connection_time);
+
         if (verbose) {
                 char *server_host = PQhost(conn);
                 int server_version = PQserverVersion(conn);
@@ -225,25 +257,87 @@ int main(int argc, char **argv) {
                            PSQL_SERVER_VERSION3(server_version), PQprotocolVersion(conn), PQbackendPID(conn));
         }
 
-        printf(_(" %s - database %s (%f sec.)|%s\n"), state_text(status), config.dbName, elapsed_time,
-                   fperfdata("time", elapsed_time, "s", (config.twarn > 0.0), config.twarn,
-                                         (config.tcrit > 0.0), config.tcrit, true, 0, false, 0));
-
-        mp_state_enum query_status = STATE_UNKNOWN;
         if (config.pgquery) {
-                query_status = do_query(conn, config.pgquery, config.pgqueryname, config.qthresholds,
-                                                                config.query_warning, config.query_critical);
+                mp_subcheck sc_query = mp_subcheck_init();
+                sc_query = mp_set_subcheck_default_state(sc_query, STATE_UNKNOWN);
+                if (config.pgqueryname) {
+                        xasprintf(&sc_query.output, "query '%s'", config.pgqueryname);
+                } else {
+                        xasprintf(&sc_query.output, "query '%s'", config.pgquery);
+                }
+
+                do_query_wrapper query_result = do_query(conn, config.pgquery);
+
+                switch (query_result.error_code) {
+                case QUERY_OK: {
+                        // Query was successful and there is a numerical result
+                        sc_query = mp_set_subcheck_state(sc_query, STATE_OK);
+                        xasprintf(&sc_query.output, "%s succeeded", sc_query.output);
+
+                        mp_perfdata pd_query = perfdata_init();
+                        pd_query = mp_set_pd_value(pd_query, query_result.numerical_result);
+                        pd_query = mp_pd_set_thresholds(pd_query, config.qthresholds);
+                        pd_query.label = "query";
+
+                        mp_subcheck sc_query_compare = mp_subcheck_init();
+                        mp_state_enum query_compare_state = mp_get_pd_status(pd_query);
+
+                        sc_query_compare = mp_set_subcheck_state(sc_query_compare, query_compare_state);
+                        mp_add_perfdata_to_subcheck(&sc_query_compare, pd_query);
+
+                        if (query_compare_state == STATE_OK) {
+                                xasprintf(&sc_query_compare.output, "query result '%f' is within thresholds",
+                                                  query_result.numerical_result);
+                        } else {
+                                xasprintf(&sc_query_compare.output, "query result '%f' is violating thresholds",
+                                                  query_result.numerical_result);
+                        }
+                        mp_add_subcheck_to_check(&overall, sc_query_compare);
+
+                } break;
+                case ERROR_WITH_QUERY:
+                        xasprintf(&sc_query.output, "%s - Error with query: %s", sc_query.output,
+                                          PQerrorMessage(conn));
+                        sc_query = mp_set_subcheck_state(sc_query, STATE_CRITICAL);
+                        break;
+                case NO_ROWS_RETURNED:
+                        xasprintf(&sc_query.output, "%s - no rows were returned by the query", sc_query.output);
+                        sc_query = mp_set_subcheck_state(sc_query, STATE_WARNING);
+                        break;
+                case NO_COLUMNS_RETURNED:
+                        xasprintf(&sc_query.output, "%s - no columns were returned by the query",
+                                          sc_query.output);
+                        sc_query = mp_set_subcheck_state(sc_query, STATE_WARNING);
+                        break;
+                case NO_DATA_RETURNED:
+                        xasprintf(&sc_query.output, "%s - no data was returned by the query", sc_query.output);
+                        sc_query = mp_set_subcheck_state(sc_query, STATE_WARNING);
+                        break;
+                case RESULT_IS_NOT_NUMERIC:
+                        xasprintf(&sc_query.output, "%s - result of the query is not numeric", sc_query.output);
+                        sc_query = mp_set_subcheck_state(sc_query, STATE_CRITICAL);
+                        break;
+                };
+
+                mp_add_subcheck_to_check(&overall, sc_query);
         }
 
         if (verbose) {
                 printf("Closing connection\n");
         }
         PQfinish(conn);
-        return (config.pgquery && query_status > status) ? query_status : status;
+
+        mp_exit(overall);
 }
 
 /* process command-line arguments */
-check_pgsql_config_wrapper process_arguments(int argc, char **argv) {
+static check_pgsql_config_wrapper process_arguments(int argc, char **argv) {
+
+        enum {
+                OPTID_QUERYNAME = CHAR_MAX + 1,
+                output_format_index,
+        };
+
         static struct option longopts[] = {{"help", no_argument, 0, 'h'},
                                                                            {"version", no_argument, 0, 'V'},
                                                                            {"timeout", required_argument, 0, 't'},
@@ -261,6 +355,7 @@ check_pgsql_config_wrapper process_arguments(int argc, char **argv) {
                                                                            {"query_critical", required_argument, 0, 'C'},
                                                                            {"query_warning", required_argument, 0, 'W'},
                                                                            {"verbose", no_argument, 0, 'v'},
+                                                                           {"output-format", required_argument, 0, output_format_index},
                                                                            {0, 0, 0, 0}};
 
         check_pgsql_config_wrapper result = {
@@ -278,6 +373,17 @@ check_pgsql_config_wrapper process_arguments(int argc, char **argv) {
                 }
 
                 switch (option_char) {
+                case output_format_index: {
+                        parsed_output_format parser = mp_parse_output_format(optarg);
+                        if (!parser.parsing_success) {
+                                printf("Invalid output format: %s\n", optarg);
+                                exit(STATE_UNKNOWN);
+                        }
+
+                        result.config.output_format_is_set = true;
+                        result.config.output_format = parser.output_format;
+                        break;
+                }
                 case '?': /* usage */
                         usage5();
                 case 'h': /* help */
@@ -293,26 +399,40 @@ check_pgsql_config_wrapper process_arguments(int argc, char **argv) {
                                 timeout_interval = atoi(optarg);
                         }
                         break;
-                case 'c': /* critical time threshold */
-                        if (!is_nonnegative(optarg)) {
-                                usage2(_("Critical threshold must be a positive integer"), optarg);
-                        } else {
-                                result.config.tcrit = strtod(optarg, NULL);
+                case 'c': /* critical time threshold */ {
+                        mp_range_parsed tmp = mp_parse_range_string(optarg);
+                        if (tmp.error != MP_PARSING_SUCCES) {
+                                die(STATE_UNKNOWN, "failed to parse critical time threshold");
                         }
-                        break;
-                case 'w': /* warning time threshold */
-                        if (!is_nonnegative(optarg)) {
-                                usage2(_("Warning threshold must be a positive integer"), optarg);
-                        } else {
-                                result.config.twarn = strtod(optarg, NULL);
+                        result.config.time_thresholds =
+                                mp_thresholds_set_crit(result.config.time_thresholds, tmp.range);
+                } break;
+                case 'w': /* warning time threshold */ {
+                        mp_range_parsed tmp = mp_parse_range_string(optarg);
+                        if (tmp.error != MP_PARSING_SUCCES) {
+                                die(STATE_UNKNOWN, "failed to parse warning time threshold");
                         }
-                        break;
-                case 'C': /* critical query threshold */
-                        result.config.query_critical = optarg;
-                        break;
-                case 'W': /* warning query threshold */
-                        result.config.query_warning = optarg;
-                        break;
+                        result.config.time_thresholds =
+                                mp_thresholds_set_warn(result.config.time_thresholds, tmp.range);
+                } break;
+                case 'C': /* critical query threshold */ {
+                        mp_range_parsed tmp = mp_parse_range_string(optarg);
+                        if (tmp.error != MP_PARSING_SUCCES) {
+                                die(STATE_UNKNOWN, "failed to parse critical query threshold");
+                        }
+
+                        result.config.qthresholds =
+                                mp_thresholds_set_crit(result.config.qthresholds, tmp.range);
+
+                } break;
+                case 'W': /* warning query threshold */ {
+                        mp_range_parsed tmp = mp_parse_range_string(optarg);
+                        if (tmp.error != MP_PARSING_SUCCES) {
+                                die(STATE_UNKNOWN, "failed to parse warning query threshold");
+                        }
+                        result.config.qthresholds =
+                                mp_thresholds_set_warn(result.config.qthresholds, tmp.range);
+                } break;
                 case 'H': /* host */
                         if ((*optarg != '/') && (!is_host(optarg))) {
                                 usage2(_("Invalid hostname/address"), optarg);
@@ -363,9 +483,6 @@ check_pgsql_config_wrapper process_arguments(int argc, char **argv) {
                 }
         }
 
-        set_thresholds(&result.config.qthresholds, result.config.query_warning,
-                                   result.config.query_critical);
-
         return result;
 }
 
@@ -393,7 +510,7 @@ should be added.</para>
 -@@
 ******************************************************************************/
 
-bool is_pg_logname(char *username) {
+static bool is_pg_logname(char *username) {
         if (strlen(username) > NAMEDATALEN - 1) {
                 return (false);
         }
@@ -447,12 +564,13 @@ void print_help(void) {
         printf(" %s\n", "--queryname=STRING");
         printf("    %s\n", _("A name for the query, this string is used instead of the query"));
         printf("    %s\n", _("in the long output of the plugin"));
-        printf(" %s\n", "-W, --query-warning=RANGE");
+        printf(" %s\n", "-W, --query_warning=RANGE");
         printf("    %s\n", _("SQL query value to result in warning status (double)"));
-        printf(" %s\n", "-C, --query-critical=RANGE");
+        printf(" %s\n", "-C, --query_critical=RANGE");
         printf("    %s\n", _("SQL query value to result in critical status (double)"));
 
         printf(UT_VERBOSE);
+        printf(UT_OUTPUT_FORMAT);
 
         printf("\n");
         printf(" %s\n", _("All parameters are optional."));
@@ -509,33 +627,44 @@ void print_usage(void) {
                    "[-q <query>] [-C <critical query range>] [-W <warning query range>]\n");
 }
 
-mp_state_enum do_query(PGconn *conn, char *query, const char pgqueryname[], thresholds *qthresholds,
-                                           char *query_warning, char *query_critical) {
+static do_query_wrapper do_query(PGconn *conn, char *query) {
         if (verbose) {
                 printf("Executing SQL query \"%s\".\n", query);
         }
         PGresult *res = PQexec(conn, query);
 
+        do_query_wrapper result = {
+                .error_code = QUERY_OK,
+        };
+
         if (PGRES_TUPLES_OK != PQresultStatus(res)) {
-                printf(_("QUERY %s - %s: %s.\n"), _("CRITICAL"), _("Error with query"),
-                           PQerrorMessage(conn));
-                return STATE_CRITICAL;
+                // TODO
+                // printf(_("QUERY %s - %s: %s.\n"), _("CRITICAL"), _("Error with query"),
+                // PQerrorMessage(conn));
+                result.error_code = ERROR_WITH_QUERY;
+                return result;
         }
 
         if (PQntuples(res) < 1) {
-                printf("QUERY %s - %s.\n", _("WARNING"), _("No rows returned"));
-                return STATE_WARNING;
+                // TODO
+                // printf("QUERY %s - %s.\n", _("WARNING"), _("No rows returned"));
+                result.error_code = NO_ROWS_RETURNED;
+                return result;
         }
 
         if (PQnfields(res) < 1) {
-                printf("QUERY %s - %s.\n", _("WARNING"), _("No columns returned"));
-                return STATE_WARNING;
+                // TODO
+                // printf("QUERY %s - %s.\n", _("WARNING"), _("No columns returned"));
+                result.error_code = NO_COLUMNS_RETURNED;
+                return result;
         }
 
         char *val_str = PQgetvalue(res, 0, 0);
         if (!val_str) {
-                printf("QUERY %s - %s.\n", _("CRITICAL"), _("No data returned"));
-                return STATE_CRITICAL;
+                // TODO
+                // printf("QUERY %s - %s.\n", _("CRITICAL"), _("No data returned"));
+                result.error_code = NO_DATA_RETURNED;
+                return result;
         }
 
         char *endptr = NULL;
@@ -545,8 +674,10 @@ mp_state_enum do_query(PGconn *conn, char *query, const char pgqueryname[], thre
         }
 
         if (endptr == val_str) {
-                printf("QUERY %s - %s: %s\n", _("CRITICAL"), _("Is not a numeric"), val_str);
-                return STATE_CRITICAL;
+                // TODO
+                // printf("QUERY %s - %s: %s\n", _("CRITICAL"), _("Is not a numeric"), val_str);
+                result.error_code = RESULT_IS_NOT_NUMERIC;
+                return result;
         }
 
         if ((endptr != NULL) && (*endptr != '\0')) {
@@ -555,24 +686,7 @@ mp_state_enum do_query(PGconn *conn, char *query, const char pgqueryname[], thre
                 }
         }
 
-        mp_state_enum my_status = get_status(value, qthresholds);
-        printf("QUERY %s - ", (my_status == STATE_OK)         ? _("OK")
-                                                  : (my_status == STATE_WARNING)  ? _("WARNING")
-                                                  : (my_status == STATE_CRITICAL) ? _("CRITICAL")
-                                                                                                                  : _("UNKNOWN"));
-        if (pgqueryname) {
-                printf(_("%s returned %f"), pgqueryname, value);
-        } else {
-                printf(_("'%s' returned %f"), query, value);
-        }
+        result.numerical_result = value;
 
-        printf("|query=%f;%s;%s;;\n", value, query_warning ? query_warning : "",
-                   query_critical ? query_critical : "");
-        if (PQnfields(res) > 1) {
-                char *extra_info = PQgetvalue(res, 0, 1);
-                if (extra_info != NULL) {
-                        printf("Extra Info: %s\n", extra_info);
-                }
-        }
-        return my_status;
+        return result;
 }