MXS-1220: Implement JSON diagnostics in binlogrouter
The binlogrouter now implements the JSON diagnistics entry point.
This commit is contained in:
Markus Mäkelä
Markus Mäkelä
parent
52e0cc8e16
commit
ec6f3d566b
@ -1289,33 +1289,20 @@ spin_reporter(void *dcb, char *desc, int value)
|
||||
*/
|
||||
static json_t* diagnostics(MXS_ROUTER *router)
|
||||
{
|
||||
// TODO: Fix this
|
||||
return NULL;
|
||||
|
||||
DCB *dcb = NULL;
|
||||
ROUTER_INSTANCE *router_inst = (ROUTER_INSTANCE *)router;
|
||||
ROUTER_SLAVE *session;
|
||||
int i = 0, j;
|
||||
int minno = 0;
|
||||
double min5, min10, min15, min30;
|
||||
char buf[40];
|
||||
struct tm tm;
|
||||
|
||||
spinlock_acquire(&router_inst->lock);
|
||||
session = router_inst->slaves;
|
||||
while (session)
|
||||
{
|
||||
i++;
|
||||
session = session->next;
|
||||
}
|
||||
spinlock_release(&router_inst->lock);
|
||||
json_t* rval = json_object();
|
||||
|
||||
minno = router_inst->stats.minno;
|
||||
min30 = 0.0;
|
||||
min15 = 0.0;
|
||||
min10 = 0.0;
|
||||
min5 = 0.0;
|
||||
for (j = 0; j < BLR_NSTATS_MINUTES; j++)
|
||||
for (int j = 0; j < BLR_NSTATS_MINUTES; j++)
|
||||
{
|
||||
minno--;
|
||||
if (minno < 0)
|
||||
@ -1341,105 +1328,86 @@ static json_t* diagnostics(MXS_ROUTER *router)
|
||||
min10 /= 10.0;
|
||||
min5 /= 5.0;
|
||||
|
||||
if (router_inst->master)
|
||||
{
|
||||
dcb_printf(dcb, "\tMaster connection DCB: %p\n",
|
||||
router_inst->master);
|
||||
}
|
||||
else
|
||||
{
|
||||
dcb_printf(dcb, "\tMaster connection DCB: 0x0\n");
|
||||
}
|
||||
|
||||
/* SSL options */
|
||||
if (router_inst->ssl_enabled)
|
||||
{
|
||||
dcb_printf(dcb, "\tMaster SSL is ON:\n");
|
||||
if (router_inst->service->dbref->server && router_inst->service->dbref->server->server_ssl)
|
||||
{
|
||||
dcb_printf(dcb, "\t\tMaster SSL CA cert: %s\n",
|
||||
router_inst->service->dbref->server->server_ssl->ssl_ca_cert);
|
||||
dcb_printf(dcb, "\t\tMaster SSL Cert: %s\n",
|
||||
router_inst->service->dbref->server->server_ssl->ssl_cert);
|
||||
dcb_printf(dcb, "\t\tMaster SSL Key: %s\n",
|
||||
router_inst->service->dbref->server->server_ssl->ssl_key);
|
||||
dcb_printf(dcb, "\t\tMaster SSL tls_ver: %s\n",
|
||||
router_inst->ssl_version ? router_inst->ssl_version : "MAX");
|
||||
}
|
||||
json_t* obj = json_object();
|
||||
|
||||
json_object_set_new(obj, "ssl_ca_cert", json_string(router_inst->service->dbref->server->server_ssl->ssl_ca_cert));
|
||||
json_object_set_new(obj, "ssl_cert", json_string(router_inst->service->dbref->server->server_ssl->ssl_cert));
|
||||
json_object_set_new(obj, "ssl_key", json_string(router_inst->service->dbref->server->server_ssl->ssl_key));
|
||||
json_object_set_new(obj, "ssl_version", json_string(router_inst->ssl_version ? router_inst->ssl_version : "MAX"));
|
||||
|
||||
json_object_set_new(rval, "master_ssl", obj);
|
||||
}
|
||||
|
||||
/* Binlog Encryption options */
|
||||
if (router_inst->encryption.enabled)
|
||||
{
|
||||
dcb_printf(dcb, "\tBinlog Encryption is ON:\n");
|
||||
dcb_printf(dcb, "\t\tEncryption Key File: %s\n",
|
||||
router_inst->encryption.key_management_filename);
|
||||
dcb_printf(dcb, "\t\tEncryption Key Algorithm: %s\n",
|
||||
blr_get_encryption_algorithm(router_inst->encryption.encryption_algorithm));
|
||||
dcb_printf(dcb, "\t\tEncryption Key length: %lu bits\n",
|
||||
8 * router_inst->encryption.key_len);
|
||||
json_t* obj = json_object();
|
||||
|
||||
json_object_set_new(obj, "key", json_string(
|
||||
router_inst->encryption.key_management_filename));
|
||||
json_object_set_new(obj, "algorithm", json_string(
|
||||
blr_get_encryption_algorithm(router_inst->encryption.encryption_algorithm)));
|
||||
json_object_set_new(obj, "key_length",
|
||||
json_integer(8 * router_inst->encryption.key_len));
|
||||
|
||||
json_object_set_new(rval, "master_encryption", obj);
|
||||
}
|
||||
|
||||
dcb_printf(dcb, "\tMaster connection state: %s\n",
|
||||
blrm_states[router_inst->master_state]);
|
||||
json_object_set_new(rval, "master_state", json_string(blrm_states[router_inst->master_state]));
|
||||
|
||||
localtime_r(&router_inst->stats.lastReply, &tm);
|
||||
asctime_r(&tm, buf);
|
||||
|
||||
dcb_printf(dcb, "\tBinlog directory: %s\n",
|
||||
router_inst->binlogdir);
|
||||
dcb_printf(dcb, "\tHeartbeat period (seconds): %lu\n",
|
||||
router_inst->heartbeat);
|
||||
dcb_printf(dcb, "\tNumber of master connects: %d\n",
|
||||
router_inst->stats.n_masterstarts);
|
||||
dcb_printf(dcb, "\tNumber of delayed reconnects: %d\n",
|
||||
router_inst->stats.n_delayedreconnects);
|
||||
dcb_printf(dcb, "\tCurrent binlog file: %s\n",
|
||||
router_inst->binlog_name);
|
||||
dcb_printf(dcb, "\tCurrent binlog position: %lu\n",
|
||||
router_inst->current_pos);
|
||||
|
||||
json_object_set_new(rval, "binlogdir", json_string(router_inst->binlogdir));
|
||||
json_object_set_new(rval, "heartbeat", json_integer(router_inst->heartbeat));
|
||||
json_object_set_new(rval, "master_starts", json_integer(router_inst->stats.n_masterstarts));
|
||||
json_object_set_new(rval, "master_reconnects", json_integer(router_inst->stats.n_delayedreconnects));
|
||||
json_object_set_new(rval, "binlog_name", json_string(router_inst->binlog_name));
|
||||
json_object_set_new(rval, "binlog_position", json_integer(router_inst->current_pos));
|
||||
|
||||
if (router_inst->trx_safe)
|
||||
{
|
||||
if (router_inst->pending_transaction.state != BLRM_NO_TRANSACTION)
|
||||
{
|
||||
dcb_printf(dcb, "\tCurrent open transaction pos: %lu\n",
|
||||
router_inst->binlog_position);
|
||||
json_object_set_new(rval, "current_trx_position", json_integer(router_inst->binlog_position));
|
||||
}
|
||||
}
|
||||
dcb_printf(dcb, "\tNumber of slave servers: %u\n",
|
||||
router_inst->stats.n_slaves);
|
||||
dcb_printf(dcb, "\tNo. of binlog events received this session: %lu\n",
|
||||
router_inst->stats.n_binlogs_ses);
|
||||
dcb_printf(dcb, "\tTotal no. of binlog events received: %lu\n",
|
||||
router_inst->stats.n_binlogs);
|
||||
dcb_printf(dcb, "\tNo. of bad CRC received from master: %u\n",
|
||||
router_inst->stats.n_badcrc);
|
||||
|
||||
json_object_set_new(rval, "slaves", json_integer(router_inst->stats.n_slaves));
|
||||
json_object_set_new(rval, "session_events", json_integer(router_inst->stats.n_binlogs_ses));
|
||||
json_object_set_new(rval, "total_events", json_integer(router_inst->stats.n_binlogs));
|
||||
json_object_set_new(rval, "bad_crc_count", json_integer(router_inst->stats.n_badcrc));
|
||||
|
||||
minno = router_inst->stats.minno - 1;
|
||||
if (minno == -1)
|
||||
{
|
||||
minno += BLR_NSTATS_MINUTES;
|
||||
}
|
||||
dcb_printf(dcb, "\tNumber of binlog events per minute\n");
|
||||
dcb_printf(dcb, "\tCurrent 5 10 15 30 Min Avg\n");
|
||||
dcb_printf(dcb, "\t %6d %8.1f %8.1f %8.1f %8.1f\n",
|
||||
router_inst->stats.minavgs[minno], min5, min10, min15, min30);
|
||||
dcb_printf(dcb, "\tNumber of fake binlog events: %lu\n",
|
||||
router_inst->stats.n_fakeevents);
|
||||
dcb_printf(dcb, "\tNumber of artificial binlog events: %lu\n",
|
||||
router_inst->stats.n_artificial);
|
||||
dcb_printf(dcb, "\tNumber of binlog events in error: %lu\n",
|
||||
router_inst->stats.n_binlog_errors);
|
||||
dcb_printf(dcb, "\tNumber of binlog rotate events: %lu\n",
|
||||
router_inst->stats.n_rotates);
|
||||
dcb_printf(dcb, "\tNumber of heartbeat events: %u\n",
|
||||
router_inst->stats.n_heartbeats);
|
||||
dcb_printf(dcb, "\tNumber of packets received: %u\n",
|
||||
router_inst->stats.n_reads);
|
||||
dcb_printf(dcb, "\tNumber of residual data packets: %u\n",
|
||||
router_inst->stats.n_residuals);
|
||||
dcb_printf(dcb, "\tAverage events per packet: %.1f\n",
|
||||
router_inst->stats.n_reads != 0 ?
|
||||
((double)router_inst->stats.n_binlogs / router_inst->stats.n_reads) : 0);
|
||||
|
||||
json_object_set_new(rval, "events_0", json_real(router_inst->stats.minavgs[minno]));
|
||||
json_object_set_new(rval, "events_5", json_real(min5));
|
||||
json_object_set_new(rval, "events_10", json_real(min10));
|
||||
json_object_set_new(rval, "events_15", json_real(min15));
|
||||
json_object_set_new(rval, "events_30", json_real(min30));
|
||||
|
||||
json_object_set_new(rval, "fake_events", json_integer(router_inst->stats.n_fakeevents));
|
||||
|
||||
json_object_set_new(rval, "artificial_events", json_integer(router_inst->stats.n_artificial));
|
||||
|
||||
json_object_set_new(rval, "binlog_errors", json_integer(router_inst->stats.n_binlog_errors));
|
||||
json_object_set_new(rval, "binlog_rotates", json_integer(router_inst->stats.n_rotates));
|
||||
json_object_set_new(rval, "heartbeat_events", json_integer(router_inst->stats.n_heartbeats));
|
||||
json_object_set_new(rval, "events_read", json_integer(router_inst->stats.n_reads));
|
||||
json_object_set_new(rval, "residual_packets", json_integer(router_inst->stats.n_residuals));
|
||||
|
||||
double average_packets = router_inst->stats.n_reads != 0 ?
|
||||
((double)router_inst->stats.n_binlogs / router_inst->stats.n_reads) : 0;
|
||||
|
||||
json_object_set_new(rval, "average_events_per_packets", json_real(average_packets));
|
||||
|
||||
spinlock_acquire(&router_inst->lock);
|
||||
if (router_inst->stats.lastReply)
|
||||
@ -1448,15 +1416,14 @@ static json_t* diagnostics(MXS_ROUTER *router)
|
||||
{
|
||||
buf[strlen(buf) - 1] = '\0';
|
||||
}
|
||||
dcb_printf(dcb, "\tLast event from master at: %s (%ld seconds ago)\n",
|
||||
buf, time(0) - router_inst->stats.lastReply);
|
||||
|
||||
json_object_set_new(rval, "latest_event", json_string(buf));
|
||||
|
||||
if (!router_inst->mariadb10_compat)
|
||||
{
|
||||
dcb_printf(dcb, "\tLast event from master: 0x%x, %s\n",
|
||||
router_inst->lastEventReceived,
|
||||
(router_inst->lastEventReceived <= MAX_EVENT_TYPE) ?
|
||||
event_names[router_inst->lastEventReceived] : "unknown");
|
||||
json_object_set_new(rval, "latest_event_type", json_string(
|
||||
(router_inst->lastEventReceived <= MAX_EVENT_TYPE) ?
|
||||
event_names[router_inst->lastEventReceived] : "unknown"));
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -1475,84 +1442,67 @@ static json_t* diagnostics(MXS_ROUTER *router)
|
||||
}
|
||||
}
|
||||
|
||||
dcb_printf(dcb, "\tLast event from master: 0x%x, %s\n",
|
||||
router_inst->lastEventReceived, (ptr != NULL) ? ptr : "unknown");
|
||||
|
||||
json_object_set_new(rval, "latest_event_type", json_string((ptr != NULL) ? ptr : "unknown"));
|
||||
|
||||
if (router_inst->mariadb_gtid &&
|
||||
router_inst->last_mariadb_gtid[0])
|
||||
{
|
||||
dcb_printf(dcb, "\tLast seen MariaDB GTID: %s\n",
|
||||
router_inst->last_mariadb_gtid);
|
||||
json_object_set_new(rval, "latest_gtid", json_string(router_inst->last_mariadb_gtid));
|
||||
}
|
||||
}
|
||||
|
||||
if (router_inst->lastEventTimestamp)
|
||||
{
|
||||
time_t last_event = (time_t)router_inst->lastEventTimestamp;
|
||||
time_t last_event = (time_t)router_inst->lastEventTimestamp;
|
||||
localtime_r(&last_event, &tm);
|
||||
asctime_r(&tm, buf);
|
||||
if (buf[strlen(buf) - 1] == '\n')
|
||||
{
|
||||
buf[strlen(buf) - 1] = '\0';
|
||||
}
|
||||
dcb_printf(dcb, "\tLast binlog event timestamp: %u (%s)\n",
|
||||
router_inst->lastEventTimestamp, buf);
|
||||
|
||||
json_object_set_new(rval, "latest_event_timestamp", json_string(buf));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
dcb_printf(dcb, "\tNo events received from master yet\n");
|
||||
}
|
||||
spinlock_release(&router_inst->lock);
|
||||
|
||||
if (router_inst->active_logs)
|
||||
json_object_set_new(rval, "active_logs", json_boolean(router_inst->active_logs));
|
||||
json_object_set_new(rval, "reconnect_pending", json_boolean(router_inst->reconnect_pending));
|
||||
|
||||
json_t* ev = json_object();
|
||||
|
||||
for (int i = 0; i <= MAX_EVENT_TYPE; i++)
|
||||
{
|
||||
dcb_printf(dcb, "\tRouter processing binlog records\n");
|
||||
}
|
||||
if (router_inst->reconnect_pending)
|
||||
{
|
||||
dcb_printf(dcb, "\tRouter pending reconnect to master\n");
|
||||
}
|
||||
dcb_printf(dcb, "\tEvents received:\n");
|
||||
for (i = 0; i <= MAX_EVENT_TYPE; i++)
|
||||
{
|
||||
dcb_printf(dcb, "\t\t%-38s %lu\n", event_names[i], router_inst->stats.events[i]);
|
||||
json_object_set_new(ev, event_names[i], json_integer(router_inst->stats.events[i]));
|
||||
}
|
||||
|
||||
if (router_inst->mariadb10_compat)
|
||||
{
|
||||
/* Display MariaDB 10 new events */
|
||||
for (i = MARIADB_NEW_EVENTS_BEGIN; i <= MAX_EVENT_TYPE_MARIADB10; i++)
|
||||
for (int i = MARIADB_NEW_EVENTS_BEGIN; i <= MAX_EVENT_TYPE_MARIADB10; i++)
|
||||
{
|
||||
dcb_printf(dcb, "\t\tMariaDB 10 %-38s %lu\n",
|
||||
event_names_mariadb10[(i - MARIADB_NEW_EVENTS_BEGIN)],
|
||||
router_inst->stats.events[i]);
|
||||
json_object_set_new(ev, event_names_mariadb10[(i - MARIADB_NEW_EVENTS_BEGIN)],
|
||||
json_integer(router_inst->stats.events[i]));
|
||||
}
|
||||
}
|
||||
|
||||
#if SPINLOCK_PROFILE
|
||||
dcb_printf(dcb, "\tSpinlock statistics (instlock):\n");
|
||||
spinlock_stats(&instlock, spin_reporter, dcb);
|
||||
dcb_printf(dcb, "\tSpinlock statistics (instance lock):\n");
|
||||
spinlock_stats(&router_inst->lock, spin_reporter, dcb);
|
||||
dcb_printf(dcb, "\tSpinlock statistics (binlog position lock):\n");
|
||||
spinlock_stats(&router_inst->binlog_lock, spin_reporter, dcb);
|
||||
#endif
|
||||
json_object_set_new(rval, "event_types", ev);
|
||||
|
||||
if (router_inst->slaves)
|
||||
{
|
||||
dcb_printf(dcb, "\tSlaves:\n");
|
||||
json_t* arr = json_array();
|
||||
spinlock_acquire(&router_inst->lock);
|
||||
session = router_inst->slaves;
|
||||
while (session)
|
||||
{
|
||||
|
||||
for (ROUTER_SLAVE *session = router_inst->slaves; session; session = session->next)
|
||||
{
|
||||
json_t* slave = json_object();
|
||||
minno = session->stats.minno;
|
||||
min30 = 0.0;
|
||||
min15 = 0.0;
|
||||
min10 = 0.0;
|
||||
min5 = 0.0;
|
||||
for (j = 0; j < BLR_NSTATS_MINUTES; j++)
|
||||
for (int j = 0; j < BLR_NSTATS_MINUTES; j++)
|
||||
{
|
||||
minno--;
|
||||
if (minno < 0)
|
||||
@ -1577,71 +1527,36 @@ static json_t* diagnostics(MXS_ROUTER *router)
|
||||
min15 /= 15.0;
|
||||
min10 /= 10.0;
|
||||
min5 /= 5.0;
|
||||
dcb_printf(dcb,
|
||||
"\t\tServer-id: %d\n",
|
||||
session->serverid);
|
||||
|
||||
json_object_set_new(rval, "server_id", json_integer(session->serverid));
|
||||
|
||||
if (session->hostname)
|
||||
{
|
||||
dcb_printf(dcb,
|
||||
"\t\tHostname: %s\n", session->hostname);
|
||||
json_object_set_new(rval, "hostname", json_string(session->hostname));
|
||||
}
|
||||
if (session->uuid)
|
||||
{
|
||||
dcb_printf(dcb, "\t\tSlave UUID: %s\n", session->uuid);
|
||||
json_object_set_new(rval, "uuid", json_string(session->uuid));
|
||||
}
|
||||
dcb_printf(dcb,
|
||||
"\t\tSlave_host_port: [%s]:%d\n",
|
||||
session->dcb->remote, dcb_get_port(session->dcb));
|
||||
dcb_printf(dcb,
|
||||
"\t\tUsername: %s\n",
|
||||
session->dcb->user);
|
||||
dcb_printf(dcb,
|
||||
"\t\tSlave DCB: %p\n",
|
||||
session->dcb);
|
||||
if (session->dcb->ssl)
|
||||
{
|
||||
dcb_printf(dcb,
|
||||
"\t\tSlave connected with SSL: %s\n",
|
||||
session->dcb->ssl_state == SSL_ESTABLISHED ?
|
||||
"Established" : "Not connected yet");
|
||||
}
|
||||
dcb_printf(dcb,
|
||||
"\t\tNext Sequence No: %d\n",
|
||||
session->seqno);
|
||||
dcb_printf(dcb,
|
||||
"\t\tState: %s\n",
|
||||
blrs_states[session->state]);
|
||||
dcb_printf(dcb,
|
||||
"\t\tBinlog file: %s\n",
|
||||
session->binlogfile);
|
||||
dcb_printf(dcb,
|
||||
"\t\tBinlog position: %u\n",
|
||||
session->binlog_pos);
|
||||
if (session->nocrc)
|
||||
{
|
||||
dcb_printf(dcb,
|
||||
"\t\tMaster Binlog CRC: None\n");
|
||||
}
|
||||
dcb_printf(dcb,
|
||||
"\t\tNo. requests: %u\n",
|
||||
session->stats.n_requests);
|
||||
dcb_printf(dcb,
|
||||
"\t\tNo. events sent: %u\n",
|
||||
session->stats.n_events);
|
||||
dcb_printf(dcb,
|
||||
"\t\tNo. bytes sent: %lu\n",
|
||||
session->stats.n_bytes);
|
||||
dcb_printf(dcb,
|
||||
"\t\tNo. bursts sent: %u\n",
|
||||
session->stats.n_bursts);
|
||||
dcb_printf(dcb,
|
||||
"\t\tNo. transitions to follow mode: %u\n",
|
||||
session->stats.n_bursts);
|
||||
|
||||
json_object_set_new(rval, "address", json_string(session->dcb->remote));
|
||||
json_object_set_new(rval, "port", json_integer(dcb_get_port(session->dcb)));
|
||||
json_object_set_new(rval, "user", json_string(session->dcb->user));
|
||||
json_object_set_new(rval, "ssl_enabled", json_boolean(session->dcb->ssl));
|
||||
json_object_set_new(rval, "state", json_string(blrs_states[session->state]));
|
||||
json_object_set_new(rval, "next_sequence", json_integer(session->seqno));
|
||||
json_object_set_new(rval, "binlog_file", json_string(session->binlogfile));
|
||||
json_object_set_new(rval, "binlog_pos", json_integer(session->binlog_pos));
|
||||
json_object_set_new(rval, "crc", json_boolean(!session->nocrc));
|
||||
|
||||
json_object_set_new(rval, "requests", json_integer(session->stats.n_requests));
|
||||
json_object_set_new(rval, "events_sent", json_integer(session->stats.n_events));
|
||||
json_object_set_new(rval, "bytes_sent", json_integer(session->stats.n_bytes));
|
||||
json_object_set_new(rval, "data_bursts", json_integer(session->stats.n_bursts));
|
||||
|
||||
if (router_inst->send_slave_heartbeat)
|
||||
{
|
||||
dcb_printf(dcb,
|
||||
"\t\tHeartbeat period (seconds): %d\n",
|
||||
session->heartbeat);
|
||||
json_object_set_new(rval, "heartbeat_period", json_integer(session->heartbeat));
|
||||
}
|
||||
|
||||
minno = session->stats.minno - 1;
|
||||
@ -1649,39 +1564,16 @@ static json_t* diagnostics(MXS_ROUTER *router)
|
||||
{
|
||||
minno += BLR_NSTATS_MINUTES;
|
||||
}
|
||||
dcb_printf(dcb, "\t\tNumber of binlog events per minute\n");
|
||||
dcb_printf(dcb, "\t\tCurrent 5 10 15 30 Min Avg\n");
|
||||
dcb_printf(dcb, "\t\t %6d %8.1f %8.1f %8.1f %8.1f\n",
|
||||
session->stats.minavgs[minno], min5, min10,
|
||||
min15, min30);
|
||||
dcb_printf(dcb, "\t\tNo. flow control: %u\n",
|
||||
session->stats.n_flows);
|
||||
dcb_printf(dcb, "\t\tNo. up to date: %u\n",
|
||||
session->stats.n_upd);
|
||||
dcb_printf(dcb, "\t\tNo. of drained cbs %u\n",
|
||||
session->stats.n_dcb);
|
||||
dcb_printf(dcb, "\t\tNo. of failed reads %u\n",
|
||||
session->stats.n_failed_read);
|
||||
|
||||
#ifdef DETAILED_DIAG
|
||||
dcb_printf(dcb, "\t\tNo. of nested distribute events %u\n",
|
||||
session->stats.n_overrun);
|
||||
dcb_printf(dcb, "\t\tNo. of distribute action 1 %u\n",
|
||||
session->stats.n_actions[0]);
|
||||
dcb_printf(dcb, "\t\tNo. of distribute action 2 %u\n",
|
||||
session->stats.n_actions[1]);
|
||||
dcb_printf(dcb, "\t\tNo. of distribute action 3 %u\n",
|
||||
session->stats.n_actions[2]);
|
||||
#endif
|
||||
if (session->lastEventTimestamp
|
||||
&& router_inst->lastEventTimestamp && session->lastEventReceived != HEARTBEAT_EVENT)
|
||||
{
|
||||
unsigned long seconds_behind;
|
||||
time_t session_last_event = (time_t)session->lastEventTimestamp;
|
||||
time_t session_last_event = (time_t)session->lastEventTimestamp;
|
||||
|
||||
if (router_inst->lastEventTimestamp > session->lastEventTimestamp)
|
||||
{
|
||||
seconds_behind = router_inst->lastEventTimestamp - session->lastEventTimestamp;
|
||||
seconds_behind = router_inst->lastEventTimestamp - session->lastEventTimestamp;
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -1690,42 +1582,36 @@ static json_t* diagnostics(MXS_ROUTER *router)
|
||||
|
||||
localtime_r(&session_last_event, &tm);
|
||||
asctime_r(&tm, buf);
|
||||
dcb_printf(dcb, "\t\tLast binlog event timestamp %u, %s",
|
||||
session->lastEventTimestamp, buf);
|
||||
dcb_printf(dcb, "\t\tSeconds behind master %lu\n",
|
||||
seconds_behind);
|
||||
trim(buf);
|
||||
json_object_set_new(rval, "last_binlog_event_timestamp", json_string(buf));
|
||||
json_object_set_new(rval, "seconds_behind_master", json_integer(seconds_behind));
|
||||
}
|
||||
|
||||
if (session->state == 0)
|
||||
{
|
||||
dcb_printf(dcb, "\t\tSlave_mode: connected\n");
|
||||
}
|
||||
else
|
||||
const char *mode = "connected";
|
||||
|
||||
if (session->state)
|
||||
{
|
||||
if ((session->cstate & CS_WAIT_DATA) == CS_WAIT_DATA)
|
||||
{
|
||||
dcb_printf(dcb, "\t\tSlave_mode: wait-for-data\n");
|
||||
mode = "wait-for-data";
|
||||
}
|
||||
else
|
||||
{
|
||||
dcb_printf(dcb, "\t\tSlave_mode: catchup. %s%s\n",
|
||||
((session->cstate & CS_EXPECTCB) == 0 ? "" :
|
||||
"Waiting for DCB queue to drain."),
|
||||
((session->cstate & CS_BUSY) == 0 ? "" :
|
||||
" Busy in slave catchup."));
|
||||
mode = "catchup";
|
||||
}
|
||||
}
|
||||
#if SPINLOCK_PROFILE
|
||||
dcb_printf(dcb, "\tSpinlock statistics (catch_lock):\n");
|
||||
spinlock_stats(&session->catch_lock, spin_reporter, dcb);
|
||||
dcb_printf(dcb, "\tSpinlock statistics (rses_lock):\n");
|
||||
spinlock_stats(&session->rses_lock, spin_reporter, dcb);
|
||||
#endif
|
||||
dcb_printf(dcb, "\t\t--------------------\n\n");
|
||||
session = session->next;
|
||||
|
||||
json_object_set_new(slave, "mode", json_string(mode));
|
||||
|
||||
json_array_append(arr, slave);
|
||||
}
|
||||
spinlock_release(&router_inst->lock);
|
||||
|
||||
json_object_set_new(rval, "slaves", arr);
|
||||
|
||||
}
|
||||
|
||||
return rval;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user