static lua_module_closure_t *lmc_tls_get(mtev_image_t *mod) {
lua_module_closure_t *lmc;
struct loader_conf *c;
if(mod->magic == MTEV_LOADER_MAGIC) {
c = mtev_image_get_userdata(mod);
}
else {
struct module_conf *mc;
mc = mtev_image_get_userdata(mod);
c = mc->c;
}
lmc = pthread_getspecific(c->key);
return lmc;
}
static lua_module_closure_t *noit_lua_setup_lmc(noit_module_t *mod, const char **obj) {
lua_module_closure_t *lmc;
struct module_conf *mc;
struct module_tls_conf *mtlsc;
mc = mtev_image_get_userdata(&mod->hdr);
if(obj) *obj = mc->object;
lmc = pthread_getspecific(mc->c->key);
if(lmc == NULL) {
int rv;
lmc = calloc(1, sizeof(*lmc));
lmc->pending = calloc(1, sizeof(*lmc->pending));
mtev_hash_init(lmc->pending);
lmc->owner = pthread_self();
lmc->resume = noit_lua_check_resume;
pthread_setspecific(mc->c->key, lmc);
mtevL(nldeb, "lua_state[%s]: new state\n", mod->hdr.name);
lmc->lua_state = mtev_lua_open(mod->hdr.name, lmc,
mc->c->script_dir, mc->c->cpath);
require(lmc->lua_state, rv, noit);
}
mtlsc = __get_module_tls_conf(&mod->hdr);
if(!mtlsc->loaded) {
if(mod->hdr.onload(&mod->hdr) == -1) {
return NULL;
}
mtlsc->loaded = 1;
}
mtevL(nldeb, "lua_state[%s]: %p\n", mod->hdr.name, lmc->lua_state);
return lmc;
}
static int
histogram_config(mtev_dso_generic_t *self, mtev_hash_table *o) {
struct histogram_config *conf = mtev_image_get_userdata(&self->hdr);
const char *duty;
char *duty_copy, *cp, *brk;
int i;
if(!mtev_hash_retr_str(o, "duty", strlen("duty"), &duty)) {
duty = "histogram";
}
if(!conf) conf = calloc(1, sizeof(*conf));
mtev_image_set_userdata(&self->hdr, conf);
duty_copy = strdup(duty);
for(i = 0, cp = strtok_r(duty_copy, ",", &brk);
cp; cp = strtok_r(NULL, ",", &brk), i++);
free(duty_copy);
conf->quantiles = calloc(1, sizeof(double)*i);
duty_copy = strdup(duty);
for(cp = strtok_r(duty_copy, ",", &brk);
cp; cp = strtok_r(NULL, ",", &brk)) {
if(!strcmp(cp,"histogram")) conf->histogram = mtev_true;
else if(!strcmp(cp,"mean")) conf->mean = mtev_true;
else if(!strcmp(cp,"sum")) conf->sum = mtev_true;
else {
char *endptr;
double q;
q = strtod(cp, &endptr);
if(*endptr == '\0') conf->quantiles[conf->n_quantiles++] = q;
}
}
qsort(conf->quantiles, conf->n_quantiles, sizeof(double), double_sort);
free(duty_copy);
return 0;
}
static mtev_hook_return_t
histogram_hb_hook_impl(void *closure, noit_module_t *self,
noit_check_t *check, noit_check_t *cause) {
/* We'll use this as an artificial heartbeat to induce a histo sweep-n-roll
* if no new data has come in yet.
*/
struct histogram_config *conf = mtev_image_get_userdata(&self->hdr);
noit_check_t *metrics_source = check;
mtev_hash_table *metrics;
#define NEED_PARENT (NP_TRANSIENT | NP_PASSIVE_COLLECTION)
/* If this is a passive check, we should be looking at the source
* from which it was cloned as this fella isn't getting any data
* pushed into it.
*/
if((check->flags & NEED_PARENT) == NEED_PARENT) {
metrics_source = noit_poller_lookup(check->checkid);
if(metrics_source == NULL) return MTEV_HOOK_CONTINUE;
}
/* quick disqualifictaion */
metrics = noit_check_get_module_metadata(metrics_source, histogram_module_id);
if(!metrics || mtev_hash_size(metrics) == 0) return MTEV_HOOK_CONTINUE;
heartbeat_all_metrics(conf, check, metrics);
return MTEV_HOOK_CONTINUE;
}
static lua_web_conf_t *get_config(mtev_dso_generic_t *self) {
if(the_one_conf) return the_one_conf;
the_one_conf = mtev_image_get_userdata(&self->hdr);
if(the_one_conf) return the_one_conf;
the_one_conf = calloc(1, sizeof(*the_one_conf));
mtev_image_set_userdata(&self->hdr, the_one_conf);
return the_one_conf;
}
static lua_general_conf_t *get_config(mtev_dso_generic_t *self) {
lua_general_conf_t *conf = mtev_image_get_userdata(&self->hdr);
if(conf) return conf;
conf = calloc(1, sizeof(*conf));
pthread_key_create(&conf->key, NULL);
mtev_image_set_userdata(&self->hdr, conf);
return conf;
}
static mtev_hook_return_t
histogram_stats_fixup(void *closure, noit_check_t *check) {
mtev_dso_generic_t *self = closure;
struct histogram_config *conf = mtev_image_get_userdata(&self->hdr);
if(check->flags & NP_TRANSIENT) return MTEV_HOOK_CONTINUE;
histogram_sweep_calculations(conf, check);
return MTEV_HOOK_CONTINUE;
}
static int
noit_lua_module_onload(mtev_image_t *img) {
int rv;
lua_State *L;
lua_module_closure_t *lmc;
struct module_conf *mc;
mc = mtev_image_get_userdata(img);
lmc = lmc_tls_get(img);
L = lmc->lua_state;
if(!L) return -1;
lua_getglobal(L, "require");
lua_pushstring(L, mc->object);
rv = lua_pcall(L, 1, 1, 0);
if(rv) {
int i;
mtevL(nlerr, "lua: %s.onload failed\n", mc->object);
i = lua_gettop(L);
if(i>0) {
if(lua_isstring(L, i)) {
const char *err;
size_t len;
err = lua_tolstring(L, i, &len);
mtevL(nlerr, "lua: %s\n", err);
}
}
lua_pop(L,i);
return -1;
}
lua_pop(L, lua_gettop(L));
mtev_lua_pushmodule(L, mc->object);
if(lua_isnil(L, -1)) {
lua_pop(L, 1);
mtevL(nlerr, "lua: no such object %s\n", mc->object);
return -1;
}
lua_getfield(L, -1, "onload");
lua_remove(L, -2);
if(!lua_isfunction(L, -1)) {
lua_pop(L, 1);
/* No onload */
return 0;
}
noit_lua_setup_module(L, (noit_module_t *)img);
lua_pcall(L, 1, 1, 0);
if(lua_isnumber(L, -1)) {
int rv;
rv = lua_tointeger(L, -1);
lua_pop(L, 1);
return rv;
}
mtevL(nlerr, "%s.onload must return a integer not %s (%s)\n", mc->object, mtev_lua_type_name(lua_type(L,-1)), lua_tostring(L,-1));
lua_pop(L,1);
return -1;
}
static struct loader_conf *__get_loader_conf(mtev_dso_loader_t *self) {
struct loader_conf *c;
c = mtev_image_get_userdata(&self->hdr);
if(!c) {
c = calloc(1, sizeof(*c));
pthread_key_create(&c->key, NULL);
mtev_image_set_userdata(&self->hdr, c);
}
return c;
}
static struct module_tls_conf *__get_module_tls_conf(mtev_image_t *img) {
struct module_conf *mc;
struct module_tls_conf *mtlsc;
mc = mtev_image_get_userdata(img);
mtlsc = pthread_getspecific(mc->key);
if(mtlsc == NULL) {
mtlsc = calloc(1, sizeof(*mtlsc));
pthread_setspecific(mc->key, mtlsc);
}
return mtlsc;
}
static mtev_hook_return_t
histogram_hook_special_impl(void *closure, noit_check_t *check, stats_t *stats,
const char *metric_name, metric_type_t type, const char *v,
mtev_boolean success) {
void *vht;
histotier *ht;
mtev_hash_table *config, *metrics;
const char *track = "";
mtev_dso_generic_t *self = closure;
struct histogram_config *conf = mtev_image_get_userdata(&self->hdr);
if(success) return MTEV_HOOK_CONTINUE;
config = noit_check_get_module_config(check, histogram_module_id);
if(!config || mtev_hash_size(config) == 0) return MTEV_HOOK_CONTINUE;
mtev_hash_retr_str(config, metric_name, strlen(metric_name), &track);
if(!track || strcmp(track, "add"))
return MTEV_HOOK_CONTINUE;
metrics = noit_check_get_module_metadata(check, histogram_module_id);
if(!metrics) {
metrics = calloc(1, sizeof(*metrics));
noit_check_set_module_metadata(check, histogram_module_id,
metrics, free_hash_o_histotier);
}
if(!mtev_hash_retrieve(metrics, metric_name, strlen(metric_name),
&vht)) {
ht = calloc(1, sizeof(*ht));
vht = ht;
mtev_hash_store(metrics, strdup(metric_name), strlen(metric_name),
vht);
}
else ht = vht;
if(v != NULL) {
/* We expect: H[<float>]=%d */
const char *lhs;
char *endptr;
double bucket;
u_int64_t cnt;
if(v[0] != 'H' || v[1] != '[') return MTEV_HOOK_CONTINUE;
if(NULL == (lhs = strchr(v+2, ']'))) return MTEV_HOOK_CONTINUE;
lhs++;
if(*lhs++ != '=') return MTEV_HOOK_CONTINUE;
bucket = strtod(v+2, &endptr);
if(endptr == v+2) return MTEV_HOOK_CONTINUE;
cnt = strtoull(lhs, &endptr, 10);
if(endptr == lhs) return MTEV_HOOK_CONTINUE;
update_histotier(ht, time(NULL), conf, check, metric_name, bucket, cnt);
}
return MTEV_HOOK_CONTINUE;
}
static mtev_hook_return_t
histogram_hook_impl(void *closure, noit_check_t *check, stats_t *stats,
metric_t *m) {
void *vht;
histotier *ht;
mtev_hash_table *config, *metrics;
const char *track = "";
mtev_dso_generic_t *self = closure;
struct histogram_config *conf = mtev_image_get_userdata(&self->hdr);
config = noit_check_get_module_config(check, histogram_module_id);
if(!config || mtev_hash_size(config) == 0) return MTEV_HOOK_CONTINUE;
mtev_hash_retr_str(config, m->metric_name, strlen(m->metric_name), &track);
if(!track || strcmp(track, "add"))
return MTEV_HOOK_CONTINUE;
metrics = noit_check_get_module_metadata(check, histogram_module_id);
if(!metrics) {
metrics = calloc(1, sizeof(*metrics));
noit_check_set_module_metadata(check, histogram_module_id,
metrics, free_hash_o_histotier);
}
if(!mtev_hash_retrieve(metrics, m->metric_name, strlen(m->metric_name),
&vht)) {
ht = calloc(1, sizeof(*ht));
vht = ht;
mtev_hash_store(metrics, strdup(m->metric_name), strlen(m->metric_name),
vht);
}
else ht = vht;
if(m->metric_value.vp != NULL) {
#define UPDATE_HISTOTIER(a) update_histotier(ht, time(NULL), conf, check, m->metric_name, *m->metric_value.a, 1)
switch(m->metric_type) {
case METRIC_UINT64:
UPDATE_HISTOTIER(L); break;
case METRIC_INT64:
UPDATE_HISTOTIER(l); break;
case METRIC_UINT32:
UPDATE_HISTOTIER(I); break;
case METRIC_INT32:
UPDATE_HISTOTIER(i); break;
case METRIC_DOUBLE:
UPDATE_HISTOTIER(n); break;
default: /*noop*/
break;
}
}
return MTEV_HOOK_CONTINUE;
}
