def add_flush_callback(self, callback, **kwargs): """ Register a flush callback with collectd. kwargs will be passed to collectd.register_flush. The callback will be called by collectd with two arguments, a timeout and an identifier. """ collectd.register_flush(callback, **kwargs)
def add_flush_callback(self, callback, **kwargs): """Register a flush callback with collectd. kwargs will be passed to collectd.register_flush. The callback will be called by collectd with two arguments, a timeout and an identifier. """ collectd.register_flush(callback, **kwargs)
def config_cb(self, config, data=None): self.config = util.map_collectd_config(config) if "Module.config" in self.config: self._log("config_cb: {!r}".format(self.config)) if "Module.init" in self.config: collectd.register_init(util.init_closure(self), name=self.__module__) if "Module.read" in self.config: collectd.register_read(util.read_closure(self), name=self.__module__) if "Module.write" in self.config: collectd.register_write(util.write_closure(self), name=self.__module__) if "Module.notification" in self.config: collectd.register_notification(util.notification_closure(self), name=self.__module__) if "Module.flush" in self.config: collectd.register_flush(util.flush_closure(self), name=self.__module__) if "Module.log" in self.config: collectd.register_log(util.log_closure(self), name=self.__module__) if "Module.shutdown" in self.config: collectd.register_shutdown(util.shutdown_closure(self), name=self.__module__)
def init(self): auth_mode = self.conf.get('auth_mode', 'basic').lower() if auth_mode == 'keystone': auth_url = self.conf.get("auth_url", self.conf.get("authurl")) if auth_url is None: raise RuntimeError( "Please specify `auth_url` for Keystone auth_mode") kwargs = {} for arg in ("auth_url", "username", "user_id", "project_id", "project_name", "tenant_id", "tenant_name", "password", "user_domain_id", "user_domain_name", "project_domain_id", "project_domain_name"): if arg in self.conf: kwargs[arg] = self.conf.get(arg) auth = identity.Password(**kwargs) elif auth_mode == "basic": auth = gnocchiclient.auth.GnocchiBasicPlugin( self.conf.get("user", "admin"), self.conf.get("endpoint")) elif auth_mode == "noauth": auth = gnocchiclient.auth.GnocchiNoAuthPlugin( self.conf.get("userid", "admin"), self.conf.get("projectid", "admin"), self.conf.get("roles", "admin"), self.conf.get("endpoint")) else: raise RuntimeError("Unknown auth_mode `%s'" % auth_mode) s = session.Session(auth=auth) self.g = client.Client( 1, s, adapter_options=dict(interface=self.conf.get('interface'), region_name=self.conf.get('region_name'), endpoint_override=self.conf.get('endpoint'))) self._resource_type = self.conf.get("resourcetype", "collectd") self.values = [] self.batch_size = self.conf.get("batchsize", 10) collectd.register_write(self.write) collectd.register_flush(self.flush)
return def flush_cb(timeout, identifier, data=None): return def log_cb(severity, message, data=None): return ## Register the call-back functions data = "stub-string" # placeholder name = init_cb.__module__ # the default interval = 10 # the default collectd.register_config(config_cb, data, name) collectd.register_init(init_cb, data, name) collectd.register_shutdown(shutdown_cb, data, name) collectd.register_read(read_cb, interval, data, name) collectd.register_write(write_cb, data, name) collectd.register_notification(notification_cb, data, name) collectd.register_flush(flush_cb, data, name) collectd.register_log(log_cb, data, name) ## Local Variables: ## mode: python ## End:
for host, values in itertools.groupby(to_flush, operator.attrgetter("host")): measures = {host: collections.defaultdict(list)} for value_obj in values: for i, value in enumerate(value_obj.values): measures[host][self._serialize_identifier( i, value_obj)].append({ "timestamp": v.time, "value": value, }) try: self.g.metric.batch_resources_metrics_measures( measures, create_metrics=True) except exceptions.BadRequest: # Create the resource and try again self.g.resource.create( self._resource_type, { "id": "collectd:" + host.replace("/", "_"), "host": host, }) self.g.metric.batch_resources_metrics_measures( measures, create_metrics=True) self.values = not_to_flush g = Gnocchi() collectd.register_config(g.config) collectd.register_write(g.write) collectd.register_flush(g.flush)
new_value = value sample.values[i] = new_value points.extend(sample.values) columns.extend(('host', 'type')) points.extend((sample.host, sample.type)) if sample.plugin_instance: columns.append('plugin_instance') points.append(sample.plugin_instance) if sample.type_instance: columns.append('type_instance') points.append(sample.type_instance) data = {'name': sample.plugin, 'columns': columns, 'points': [points]} self._queues[identifier].put(data) self._flush() db = InfluxDB() collectd.register_config(db.config) collectd.register_flush(db.flush) collectd.register_init(db.init) collectd.register_shutdown(db.shutdown) collectd.register_write(db.write)
else: collectd.warn('unrecognized ds_type {}'.format(ds_type)) new_value = value sample.values[i] = new_value points.extend(sample.values) columns.extend(('host', 'type')) points.extend((sample.host, sample.type)) if sample.plugin_instance: columns.append('plugin_instance') points.append(sample.plugin_instance) if sample.type_instance: columns.append('type_instance') points.append(sample.type_instance) data = {'name': sample.plugin, 'columns': columns, 'points': [points]} self._queues[identifier].put(data) self._flush() db = InfluxDB() collectd.register_config(db.config) collectd.register_flush(db.flush) collectd.register_init(db.init) collectd.register_shutdown(db.shutdown) collectd.register_write(db.write)
def flush_cb(timeout, identifier, data=None): collectd.info("flush_cb: [{0}] {1}".format(timeout, identifier)) def log_cb(severity, message, data=None): # print here, if logging is used it will cause infinite recursion. print("log_cb: severity({}) - {}".format(severity, message)) ## Register the call-back functions collectd.register_config(config_cb) collectd.register_init(init_cb) collectd.register_shutdown(shutdown_cb) collectd.register_read(read_cb) collectd.register_write(write_cb) collectd.register_notification(notification_cb) collectd.register_flush(flush_cb) collectd.register_log(log_cb) collectd.info("trace plugin module loaded") ## Local Variables: ## mode: python ## End: