static void mysql_log_results(noit_module_t *self, noit_check_t *check) {
struct timeval duration, now;
mysql_check_info_t *ci = check->closure;
gettimeofday(&now, NULL);
sub_timeval(now, check->last_fire_time, &duration);
noit_stats_set_whence(check, &now);
noit_stats_set_duration(check, duration.tv_sec * 1000 + duration.tv_usec / 1000);
noit_stats_set_available(check, NP_UNAVAILABLE);
noit_stats_set_state(check, NP_BAD);
if(ci->error) noit_stats_set_status(check, ci->error);
else if(ci->timed_out) noit_stats_set_status(check, "timeout");
else if(ci->rv == 0) {
noit_stats_set_available(check, NP_AVAILABLE);
noit_stats_set_state(check, NP_GOOD);
noit_stats_set_status(check, "no rows, ok");
}
else {
noit_stats_set_available(check, NP_AVAILABLE);
noit_stats_set_state(check, NP_GOOD);
noit_stats_set_status(check, "got rows, ok");
}
if(ci->rv >= 0)
noit_stats_set_metric(check, "row_count", METRIC_INT32, &ci->rv);
if(ci->connect_duration)
noit_stats_set_metric(check, "connect_duration", METRIC_DOUBLE,
ci->connect_duration);
if(ci->query_duration)
noit_stats_set_metric(check, "query_duration", METRIC_DOUBLE,
ci->query_duration);
noit_check_set_stats(check);
}
static int example_initiate(noit_module_t *self, noit_check_t *check,
noit_check_t *cause) {
struct example_check_info *ci = check->closure;
const char *limit = "0";
struct timeval now, diff;
BAIL_ON_RUNNING_CHECK(check);
check->flags |= NP_RUNNING;
mtev_hash_retrieve(check->config, "limit", strlen("limit"), (void **)&limit);
ci->limit = atoi(limit);
mtev_gettimeofday(&now, NULL);
sub_timeval(now, check->last_fire_time, &diff);
noit_stats_set_whence(check, &now);
noit_stats_set_duration(check, diff.tv_sec * 1000 + diff.tv_usec / 1000);
noit_stats_set_available(check, NP_AVAILABLE);
noit_stats_set_status(check, "hello world");
if(ci->limit) {
int value = (int)(lrand48() % ci->limit);
noit_stats_set_metric(check, "random", METRIC_INT32, &value);
noit_stats_set_state(check, NP_GOOD);
}
else {
noit_stats_set_metric(check, "random", METRIC_INT32, NULL);
noit_stats_set_state(check, NP_BAD);
}
noit_check_set_stats(check);
check->flags &= ~NP_RUNNING;
return 0;
}
static int
noit_lua_set_available(lua_State *L) {
noit_check_t *check;
if(lua_gettop(L)) luaL_error(L, "wrong number of arguments");
check = lua_touserdata(L, lua_upvalueindex(1));
noit_stats_set_available(check, lua_tointeger(L, lua_upvalueindex(2)));
return 0;
}
static void ping_icmp_log_results(noit_module_t *self, noit_check_t *check) {
struct check_info *data;
double avail = 0.0, min = MAXFLOAT, max = 0.0, avg = 0.0, cnt;
int avail_needed = 100;
const char *config_val = NULL;
int i, points = 0;
char human_buffer[256];
struct timeval now, duration;
data = (struct check_info *)check->closure;
for(i=0; i<data->expected_count; i++) {
if(data->turnaround[i] >= 0.0) {
points++;
avg += data->turnaround[i];
if(data->turnaround[i] > max) max = data->turnaround[i];
if(data->turnaround[i] < min) min = data->turnaround[i];
}
}
cnt = data->expected_count;
if(points == 0) {
min = 0.0 / 0.0;
max = 0.0 / 0.0;
avg = 0.0 / 0.0;
}
else {
avail = (float)points /cnt;
avg /= (float)points;
}
if(mtev_hash_retr_str(check->config, "avail_needed", strlen("avail_needed"),
&config_val))
avail_needed = atoi(config_val);
snprintf(human_buffer, sizeof(human_buffer),
"cnt=%d,avail=%0.0f,min=%0.4f,max=%0.4f,avg=%0.4f",
(int)cnt, 100.0*avail, min, max, avg);
mtevL(nldeb, "ping_icmp(%s) [%s]\n", check->target_ip, human_buffer);
mtev_gettimeofday(&now, NULL);
sub_timeval(now, check->last_fire_time, &duration);
noit_stats_set_whence(check, &now);
noit_stats_set_duration(check, duration.tv_sec * 1000 + duration.tv_usec / 1000);
noit_stats_set_available(check, (avail > 0.0) ? NP_AVAILABLE : NP_UNAVAILABLE);
noit_stats_set_state(check, (avail < ((float)avail_needed / 100.0)) ? NP_BAD : NP_GOOD);
noit_stats_set_status(check, human_buffer);
noit_stats_set_metric(check, "count",
METRIC_INT32, &data->expected_count);
avail *= 100.0;
noit_stats_set_metric(check, "available", METRIC_DOUBLE, &avail);
noit_stats_set_metric(check, "minimum",
METRIC_DOUBLE, avail > 0.0 ? &min : NULL);
noit_stats_set_metric(check, "maximum",
METRIC_DOUBLE, avail > 0.0 ? &max : NULL);
noit_stats_set_metric(check, "average",
METRIC_DOUBLE, avail > 0.0 ? &avg : NULL);
noit_check_set_stats(check);
}
static int
statsd_submit(noit_module_t *self, noit_check_t *check,
noit_check_t *cause) {
statsd_closure_t *ccl;
struct timeval now, duration;
statsd_mod_config_t *conf;
conf = noit_module_get_userdata(self);
if(!conf->primary_active) conf->check = NULL;
if(0 == memcmp(conf->primary, check->checkid, sizeof(uuid_t))) {
conf->check = check;
if(NOIT_CHECK_DISABLED(check) || NOIT_CHECK_KILLED(check)) {
conf->check = NULL;
return 0;
}
}
/* We are passive, so we don't do anything for transient checks */
if(check->flags & NP_TRANSIENT) return 0;
if(!check->closure) {
ccl = check->closure = calloc(1, sizeof(*ccl));
ccl->self = self;
} else {
// Don't count the first run
char human_buffer[256];
ccl = (statsd_closure_t*)check->closure;
mtev_gettimeofday(&now, NULL);
sub_timeval(now, check->last_fire_time, &duration);
noit_stats_set_whence(check, &now);
noit_stats_set_duration(check, duration.tv_sec * 1000 + duration.tv_usec / 1000);
snprintf(human_buffer, sizeof(human_buffer),
"dur=%ld,run=%d,stats=%d", duration.tv_sec * 1000 + duration.tv_usec / 1000,
check->generation, ccl->stats_count);
mtevL(nldeb, "statsd(%s) [%s]\n", check->target, human_buffer);
// Not sure what to do here
noit_stats_set_available(check, (ccl->stats_count > 0) ?
NP_AVAILABLE : NP_UNAVAILABLE);
noit_stats_set_state(check, (ccl->stats_count > 0) ?
NP_GOOD : NP_BAD);
noit_stats_set_status(check, human_buffer);
if(check->last_fire_time.tv_sec)
noit_check_passive_set_stats(check);
memcpy(&check->last_fire_time, &now, sizeof(duration));
}
ccl->stats_count = 0;
return 0;
}
static int httptrap_submit(noit_module_t *self, noit_check_t *check,
noit_check_t *cause) {
httptrap_closure_t *ccl;
struct timeval duration;
/* We are passive, so we don't do anything for transient checks */
if(check->flags & NP_TRANSIENT) return 0;
mtev_httptrap_check_aynsch(self, check);
if(!check->closure) {
ccl = check->closure = (void *)calloc(1, sizeof(httptrap_closure_t));
memset(ccl, 0, sizeof(httptrap_closure_t));
ccl->self = self;
} else {
// Don't count the first run
struct timeval now, *last;
stats_t *inprogress;
char human_buffer[256];
ccl = (httptrap_closure_t*)check->closure;
gettimeofday(&now, NULL);
sub_timeval(now, check->last_fire_time, &duration);
noit_stats_set_whence(check, &now);
noit_stats_set_duration(check, duration.tv_sec * 1000 + duration.tv_usec / 1000);
snprintf(human_buffer, sizeof(human_buffer),
"dur=%ld,run=%d,stats=%d", duration.tv_sec * 1000 + duration.tv_usec / 1000,
check->generation, ccl->stats_count);
mtevL(nldeb, "httptrap(%s) [%s]\n", check->target, human_buffer);
// Not sure what to do here
noit_stats_set_available(check, (ccl->stats_count > 0) ?
NP_AVAILABLE : NP_UNAVAILABLE);
noit_stats_set_state(check, (ccl->stats_count > 0) ?
NP_GOOD : NP_BAD);
noit_stats_set_status(check, human_buffer);
if(check->last_fire_time.tv_sec)
noit_check_passive_set_stats(check);
inprogress = noit_check_get_stats_inprogress(check);
last = noit_check_stats_whence(inprogress, NULL);
memcpy(&check->last_fire_time, last, sizeof(duration));
}
ccl->stats_count = 0;
return 0;
}
static int test_abort_drive_session(eventer_t e, int mask, void *closure,
struct timeval *passed_now) {
struct timespec rqtp;
struct timeval target_time, now, diff;
double i, r;
test_abort_check_info_t *ci = closure;
noit_check_t *check = ci->check;
if(mask & (EVENTER_READ | EVENTER_WRITE)) {
/* this case is impossible from the eventer. It is called as
* such on the synchronous completion of the event.
*/
noit_stats_set_available(check, NP_AVAILABLE);
noit_stats_set_state(check, ci->timed_out ? NP_BAD : NP_GOOD);
mtevL(nlerr, "test_abort: EVENTER_READ | EVENTER_WRITE\n");
noit_check_set_stats(check);
check->flags &= ~NP_RUNNING;
return 0;
}
switch(mask) {
case EVENTER_ASYNCH_WORK:
mtevL(nlerr, "test_abort: EVENTER_ASYNCH_WORK\n");
r = modf(ci->timeout, &i);
ci->timed_out = 1;
if(ci->ignore_signals) { /* compuational loop */
double trash = 1.0;
gettimeofday(&now, NULL);
diff.tv_sec = (int)i;
diff.tv_usec = (int)(r * 1000000.0);
add_timeval(now, diff, &target_time);
do {
for(i=0; i<100000; i++) {
trash += drand48();
trash = log(trash);
trash += 1.1;
trash = exp(trash);
}
gettimeofday(&now, NULL);
sub_timeval(target_time, now, &diff);
} while(diff.tv_sec >= 0 && diff.tv_usec >= 0);
}
else {
rqtp.tv_sec = (int)i;
rqtp.tv_nsec = (int)(r * 1000000000.0);
nanosleep(&rqtp,NULL);
}
mtevL(nlerr, "test_abort: EVENTER_ASYNCH_WORK (done)\n");
ci->timed_out = 0;
return 0;
break;
case EVENTER_ASYNCH_CLEANUP:
/* This sets us up for a completion call. */
mtevL(nlerr, "test_abort: EVENTER_ASYNCH_CLEANUP\n");
e->mask = EVENTER_READ | EVENTER_WRITE;
break;
default:
abort();
}
return 0;
}
