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: