Hello everyone. I am writing code to remove metrics from a remote server and output them to localhost:9091. My problem is that I can't understand why the metrics are not displayed on localhost:9091 despite the fact that there is a connection to the server and the removed metrics are selected in the console. Who is not difficult to help or tell me how to solve my problem. my code:

include <libssh/libssh.h>

include <prometheus/registry.h>

include <prometheus/exposer.h>

include <prometheus/counter.h>

include <prometheus/gauge.h>

include

include "string.h"

// Function to execute a command on an SSH channel and return the output std::string execute_ssh_command(ssh_session session, const std::string& command) { ssh_channel channel = ssh_channel_new(session); if (channel == NULL) { throw std::runtime_error("Error creating SSH channel"); } if (ssh_channel_open_session(channel) != SSH_OK) { throw std::runtime_error("Error opening SSH channel"); } if (ssh_channel_request_exec(channel, command.c_str()) != SSH_OK) { throw std::runtime_error("Error executing SSH command"); } char buffer[256]; std::stringstream output; while (ssh_channel_read(channel, buffer, sizeof(buffer), 0) > 0) { output << buffer; } ssh_channel_send_eof(channel); ssh_channel_close(channel); ssh_channel_free(channel); return output.str(); }

int verify_knownhost(ssh_session session) { enum ssh_known_hosts_e state; unsigned char hash = NULL; ssh_key srv_pubkey = NULL; size_t hlen; char buf[10]; char hexa; char *p; int cmp; int rc;

rc = ssh_get_server_publickey(session, &srv_pubkey);
if (rc < 0) {
    return -1;
}

rc = ssh_get_publickey_hash(srv_pubkey,
                            SSH_PUBLICKEY_HASH_SHA1,
                            &hash,
                            &hlen);
ssh_key_free(srv_pubkey);
if (rc < 0) {
    return -1;
}

state = ssh_session_is_known_server(session);
switch (state) {
    case SSH_KNOWN_HOSTS_OK:
        /* OK */

        break;
    case SSH_KNOWN_HOSTS_CHANGED:
        fprintf(stderr, "Host key for server changed: it is now:\n");
        ssh_print_hexa("Public key hash", hash, hlen);
        fprintf(stderr, "For security reasons, connection will be stopped\n");
        ssh_clean_pubkey_hash(&hash);

        return -1;
    case SSH_KNOWN_HOSTS_OTHER:
        fprintf(stderr, "The host key for this server was not found but an other"
                "type of key exists.\n");
        fprintf(stderr, "An attacker might change the default server key to"
                "confuse your client into thinking the key does not exist\n");
        ssh_clean_pubkey_hash(&hash);

        return -1;
    case SSH_KNOWN_HOSTS_NOT_FOUND:
        fprintf(stderr, "Could not find known host file.\n");
        fprintf(stderr, "If you accept the host key here, the file will be"
                "automatically created.\n");

        /* FALL THROUGH to SSH_SERVER_NOT_KNOWN behavior */

    case SSH_KNOWN_HOSTS_UNKNOWN:
        hexa = ssh_get_hexa(hash, hlen);
        fprintf(stderr,"The server is unknown. Do you trust the host key?\n");
        fprintf(stderr, "Public key hash: %s\n", hexa);
        ssh_string_free_char(hexa);
        ssh_clean_pubkey_hash(&hash);
        p = fgets(buf, sizeof(buf), stdin);
        if (p == NULL) {
            return -1;
        }

        cmp = strncasecmp(buf, "yes", 3);
        if (cmp != 0) {
            return -1;
        }

        rc = ssh_session_update_known_hosts(session);
        if (rc < 0) {
            fprintf(stderr, "Error %s\n", strerror(errno));
            return -1;
        }

        break;
    case SSH_KNOWN_HOSTS_ERROR:
        fprintf(stderr, "Error %s", ssh_get_error(session));
        ssh_clean_pubkey_hash(&hash);
        return -1;
}

ssh_clean_pubkey_hash(&hash);
return 0;

}

int main() {

int port[]={22};
char *password;
char pswrd[]={"password"};
char ip[]={"id"};
char login[]={"name"};
int rc;
ssh_session session;
session = ssh_new();
if(session == NULL) 
    {
        std::cout << "Session cannot be created. Exiting.." << std::endl;
        exit(EXIT_FAILURE);
    }

ssh_options_set(session, SSH_OPTIONS_HOST, ip);
ssh_options_set(session, SSH_OPTIONS_USER, login);

rc = ssh_connect(session);

if (rc != SSH_OK)
    {
        fprintf(stderr, "Error connecting to localhost: %s\n",
        ssh_get_error(session));
        ssh_free(session);
        exit(-1);
    }

if (verify_knownhost(session) < 0) { ssh_disconnect(session); ssh_free(session); exit(-1); }

password=pswrd;
rc = ssh_userauth_password(session, NULL, password);
if (rc != SSH_AUTH_SUCCESS)
    {
        fprintf(stderr, "Error authenticating with password: %s\n",
        ssh_get_error(session));
        ssh_disconnect(session);
        ssh_free(session);
        exit(-1);
    }

//creating the prometheus registry

auto registry = std::make_shared<prometheus::Registry>();

auto& ram_usage_gauge = prometheus::BuildGauge()
                           .Name("node_memory_usage_bytes")
                           .Help("RAM usage")
                           .Register(*registry);

prometheus::Exposer exposer{"localhost:9091"};
// collecting indicators every 1 seconds
while (true) {
try {
    // getting data about RAM on the server
    std::string output = execute_ssh_command(session, "free | grep Mem | awk '{print $3}'");
    int node_memory_usage_bytes = std::stoi(output);
    std::cout<< node_memory_usage_bytes<< std::endl;
    ram_usage_gauge.Add({{"name","id"}})
        .Set(node_memory_usage_bytes);
} catch (std::exception& e) {
    std::cerr << "Error getting RAM usage: " << e.what() << std::endl;
}
// transferring metrics to port 9091

exposer.RegisterCollectable(registry);

std::this_thread::sleep_for(std::chrono::seconds(1));

}

// completion of work
ssh_disconnect(session);
ssh_free(session);

}

jupp0r / prometheus-cpp

metrics are not displayed on localhost:9091 #642

include <libssh/libssh.h>

include <prometheus/registry.h>

include <prometheus/exposer.h>

include <prometheus/counter.h>

include <prometheus/gauge.h>

include

include

include

include

include

include "string.h"