def setup_collectd():
"""
Registers callback functions with collectd
"""
collectd.register_init(init)
collectd.register_config(config)
collectd.register_shutdown(shutdown)
def __init__(self, typeinfo):
self.nameserver = "unknown"
self.cluster = "none"
self.ns = None
self.ip = "0.0.0.0"
self.publishTimeout = 600
self.q = multiprocessing.Queue()
self.qthread = None
self.typesdb = "/usr/share/collectd/types.db"
self.types = {}
self.typeinfo = typeinfo
self.cachedValues = {}
collectd.register_config(self.config)
collectd.register_init(self.init)
collectd.register_write(self.write)
collectd.register_shutdown(self.shutdown)
def register_plugin(collectd):
"Bind plugin hooks to collectd and viceversa"
config = Config.instance()
# Setup loggging
log_handler = CollectdLogHandler(collectd=collectd)
log_handler.cfg = config
ROOT_LOGGER.addHandler(log_handler)
ROOT_LOGGER.setLevel(logging.NOTSET)
# Creates collectd plugin instance
instance = Plugin(collectd=collectd, config=config)
# Register plugin callbacks
collectd.register_config(instance.config)
collectd.register_write(instance.write)
collectd.register_shutdown(instance.shutdown)
elif kv.key == 'MinCPUPercent':
if int(kv.values[0]) == 0 or int(kv.values[0]) > 100:
raise Exception('invalid value for ' + kv.key)
MIN_CPU_USAGE_PERCENT = int(kv.values[0])
elif kv.key == 'MinMemoryPercent':
if int(kv.values[0]) == 0 or int(kv.values[0]) > 100:
raise Exception('invalid value for ' + kv.key)
MIN_MEM_USAGE_PERCENT = int(kv.values[0])
elif kv.key == 'ReportDockerContainerNames':
REPORT_DOCKER_CONTAINER_NAMES = kv.values[0]
if type(REPORT_DOCKER_CONTAINER_NAMES).__name__ != 'bool':
REPORT_DOCKER_CONTAINER_NAMES = str2bool(kv.values[0])
else:
raise Exception('unknown config parameter')
collectd.register_read(send_metrics)
def write_metrics(mmaps, plugin_name):
for name,mmap in mmaps.iteritems():
for metric,val in mmap.iteritems():
write_val(plugin_name, name, metric, val)
def send_metrics():
pmaps = get_processes_info()
write_metrics(pmaps, PROCESS_PLUGIN_NAME)
collectd.register_init(process_watch_init)
collectd.register_config(process_watch_config)
if m.has_key('lastHeartbeat'):
self.submit(rs_name, t, '{0}-last_heartbeat'.format(n), tstofloat(m['lastHeartbeat']))
if m.has_key('lastHeartbeatRecv'):
self.submit(rs_name, t, '{0}-last_heartbeat_recv'.format(n), tstofloat(m['lastHeartbeatRecv']))
if m.has_key('pingMs'):
self.submit(rs_name, t, '{0}-ping_ms'.format(n), m['pingMs'])
if self_optime != None and primary_optime != None:
n = "self-{0}".format(self_port)
self.submit(rs_name, t, '{0}-replication_lag'.format(n), int(primary_optime - self_optime))
def config(self, obj):
for node in obj.children:
if node.key == 'Port':
self.mongo_port = int(node.values[0])
elif node.key == 'Host':
self.mongo_host = node.values[0]
elif node.key == 'User':
self.mongo_user = node.values[0]
elif node.key == 'Password':
self.mongo_password = node.values[0]
else:
collectd.warning("mongodb_replset plugin: Unkown configuration key %s" % node.key)
mongodb_replset = MongoDBReplSet()
collectd.register_config(mongodb_replset.config)
collectd.register_read(mongodb_replset.do_status)
self.submit('counter', 'object_count', db_stats['objects'], mongo_db)
self.submit('counter', 'collections', db_stats['collections'], mongo_db)
self.submit('counter', 'num_extents', db_stats['numExtents'], mongo_db)
self.submit('counter', 'indexes', db_stats['indexes'], mongo_db)
# stats sizes
self.submit('file_size', 'storage', db_stats['storageSize'], mongo_db)
self.submit('file_size', 'index', db_stats['indexSize'], mongo_db)
self.submit('file_size', 'data', db_stats['dataSize'], mongo_db)
#con.disconnect()
def config(self, obj):
for node in obj.children:
if node.key == 'Port':
self.mongo_port = int(node.values[0])
elif node.key == 'Host':
self.mongo_host = node.values[0]
elif node.key == 'User':
self.mongo_user = node.values[0]
elif node.key == 'Password':
self.mongo_password = node.values[0]
elif node.key == 'Database':
self.mongo_db = node.values
else:
collectd.warning("mongodb plugin: Unkown configuration key %s" % node.key)
mongodb = MongoDB()
collectd.register_read(mongodb.do_server_status)
collectd.register_config(mongodb.config)
"""Collectd write callback"""
# pylint: disable=broad-except
# pass arguments to the writer
try:
self._writer.write(vl, data)
except Exception as exc:
if collectd is not None:
collectd.error('Exception during write: %s' % exc)
def shutdown(self):
"""Shutdown callback"""
# pylint: disable=broad-except
collectd.info("SHUTDOWN")
try:
self._writer.flush()
except Exception as exc:
if collectd is not None:
collectd.error('Exception during shutdown: %s' % exc)
# The collectd plugin instance
# pylint: disable=invalid-name
instance = Plugin()
# pylint: enable=invalid-name
# Register plugin callbacks
collectd.register_init(instance.init)
collectd.register_config(instance.config)
collectd.register_write(instance.write)
collectd.register_shutdown(instance.shutdown)
collectd.info('buddyinfo plugin: configuring host: %s' % (host_name))
def initer():
get_host_type()
collectd.info('buddyinfo plugin: host of type: %s' % (host_type))
collectd.info('buddyinfo initer: white list: %s ' % (white_list))
init_stats_cache()
collectd.info('buddyinfo init: stats_cache: %s ' % (stats_cache))
def reader(input_data=None):
collect_buddyinfo()
swap_current_cache()
def writer(metric, data=None):
for i in metric.values:
collectd.debug("%s (%s): %f" % (metric.plugin, metric.type, i))
def shutdown():
collectd.info("buddyinfo plugin shutting down")
#== Callbacks ==#
if (os_name == 'Linux'):
collectd.register_config(configer)
collectd.register_init(initer)
collectd.register_read(reader)
collectd.register_write(writer)
collectd.register_shutdown(shutdown)
else:
collectd.warning('buddyinfo plugin currently works for Linux only')
else:
collectd.warning("Unrecognized conf parameter %s - ignoring" % node.values[0])
def init_callback(self):
self.client = DockerClient(base_url=self.BASE_URL)
def read_callback(self):
for container in self.client.containers():
if not container["Status"].startswith("Up"):
continue
stats = self.client.stats(container).next()
t = stats["read"]
for key, value in stats.items():
klass = self.CLASSES.get(key)
if klass:
klass.read(container, value, t)
plugin = DockerPlugin()
if __name__ == "__main__":
if len(sys.argv) > 1:
plugin.BASE_URL = sys.argv[1]
plugin.init_callback()
plugin.read_callback()
else:
collectd.register_config(plugin.configure_callback)
collectd.register_init(plugin.init_callback)
collectd.register_read(plugin.read_callback)
if rlat is not None:
distance = greatcircle(rlat, rlon, a['lat'], a['lon'])
if distance > max_range: max_range = distance
if 'lat' in a.get('mlat', ()):
mlat += 1
V.dispatch(plugin_instance = instance_name,
host=host,
type='dump1090_aircraft',
type_instance='recent',
time=aircraft_data['now'],
values = [total, with_pos])
V.dispatch(plugin_instance = instance_name,
host=host,
type='dump1090_mlat',
type_instance='recent',
time=aircraft_data['now'],
values = [mlat])
if max_range > 0:
V.dispatch(plugin_instance = instance_name,
host=host,
type='dump1090_range',
type_instance='max_range',
time=aircraft_data['now'],
values = [max_range])
collectd.register_config(callback=handle_config, name='dump1090')
ports = portstat.get_bfdstats("localhost")
for port_object in ports:
port_name = port_object["Object"]["IpAddr"]
stat_rx = portstat.parse_bfdrx(port_object)
self.sendToCollect('derive', port_name, stat_rx)
if __name__ == '__main__':
portstat = BfdStat()
portmon = BfdMon()
ports = portstat.get_bfdstats("localhost")
if len(ports) == 0:
dummy_port = "dummy"
self.SendToCollect('derive', dummy_port, 0)
for port_object in ports:
port_name = json.dumps(port_object["Object"]["IpAddr"])
stat_rx = portstat.parse_bfdrx(port_object)
self.sendToCollect('derive', port_name, stat_rx)
sys.exit(0)
else:
import collectd
portmon = BfdMon()
# Register callbacks
collectd.register_init(portmon.init_callback)
collectd.register_config(portmon.configure_callback)
collectd.register_read(portmon.read_callback)
return stats
def pgbouncer_read(data=None):
stats = get_stats()
if not stats:
collectd.error('pgbouncer plugin: No info received')
return
for database, metrics in stats.iteritems():
for metric, value in metrics.iteritems():
type_instance = '%s.%s' % (database, metric)
val = collectd.Values(plugin='pgbouncer_info')
val.type = 'gauge'
val.type_instance = type_instance
val.values = [value]
val.dispatch()
def pgbouncer_config(c):
for child in c.children:
value = child.values[0]
config.update({child.key: value})
#stats=get_stats()
#print stats
collectd.register_read(pgbouncer_read)
collectd.register_config(pgbouncer_config)
log.info("sqlalchemy.collectd server listening for "
"SQLAlchemy clients on UDP %s %d" % (host, port))
listener.listen(receiver_)
monitor_host, monitor_port = config_dict.get("monitor", (None, None))
if monitor_host is not None and monitor_port is not None:
from sqlalchemy_collectd.connmon import plugin as connmon
log.warn(
"the connmon plugin should now be configured separately in its "
"own <Module> section")
connmon.start_plugin(config)
def read(data=None):
"""Extract data from received messages periodically and broadcast to
the collectd server in which we are embedded.
The values are sent as "external" types, meaning we are using the
"derive" and "count" types in collectd types.db.
"""
global receiver_
now = time.time()
receiver_.summarize(collectd, now)
collectd.register_config(get_config)
collectd.register_read(read)
collectd.info('unknown config key %s for plugin disk' % key)
def fake_disk_read():
type_l = [
'disk_io_time', 'disk_merged', 'disk_octets', 'disk_ops', 'disk_time'
]
for i in disk_instances:
for temp_type in type_l:
val = collectd.Values(host=instance,
plugin='disk',
plugin_instance=str(i),
type=temp_type)
if temp_type == 'disk_octets':
values_read = random.randint(0, MAX_VALUE * 1024)
values_write = random.randint(0, MAX_VALUE * 1024)
elif temp_type == 'disk_ops':
values_read = random.randint(0, MAX_VALUE)
values_write = random.randint(0, MAX_VALUE)
else:
values_read = random.randint(0, MAX_VALUE * 1024)
values_write = random.randint(0, MAX_VALUE * 1024)
val.dispatch(values=[values_read, values_write])
collectd.register_config(fake_disk_config)
collectd.register_read(fake_disk_read)
metric = collectd.Values()
metric.plugin = PLUGIN_NAME
metric.plugin_instance = process.process
metric.meta = sample.labels
metric.type = 'gauge'
metric.type_instance = metric_name
metric.values = [sample.value]
metric.dispatch()
collectd.debug(
"Name: {0} Labels: {1} Value: {2}".format(
*sample))
else:
collectd.debug(
"Name: {0} not match Labels: {1} Value: {2}".
format(*sample))
except Exception as e:
collectd.error(
'unable to get prometheus data %s://%s:%s/metrics with current configuration %s: %s'
% (process.protocol, process.host, process.port,
json.dumps(process.__dict__), e))
def init():
signal.signal(signal.SIGCHLD, signal.SIG_DFL)
prom = Prometheus()
collectd.register_init(init)
collectd.register_config(prom.config)
self.ceph_pool_stats_interval)
def run_command(self, command, check_output=True):
"""Run a command for this collectd plugin. Returns a tuple with command
success and output or False and None for output.
"""
output = None
try:
if check_output:
output = subprocess.check_output(command)
else:
stdin, stdout, stderr = os.popen3(' '.join(command))
output = stdout.read()
except Exception as exc:
collectd.error('collectd-ceph-storage: {} exception: {}'.format(
command, exc))
collectd.error('collectd-ceph-storage: {} traceback: {}'.format(
command, traceback.format_exc()))
return False, None
if output is None:
collectd.error(
'collectd-ceph-storage: failed to {}: output is None'.format(
command))
return False, None
return True, output
collectd_ceph_storage = CollectdCephStorage()
collectd.register_config(collectd_ceph_storage.configure_callback)
data[ALLOCATED_MEMORY] = float(memstat.get('actual')) / 1024
# TODO USED_MEMORY is not correct, Need to do more research on this
data[USED_MEMORY] = round(float(memstat.get('rss')) / 1024, 2)
# TODO RAM_UTIL is not correct, Need to do more research on this
data[RAM_UTIL] = round(
((data[USED_MEMORY] / data[ALLOCATED_MEMORY]) * 100.0), 2)
stats = domain.getCPUStats(True)
data[CPU_TIME] = stats[0]['cpu_time']
collectd.info("Memory stats collected for VM: %s" %
(domain.name()))
except libvirt.libvirtError as e:
collectd.warning("Unable to collect memory stats for VM: %s,"
" Reason: %s" %
(domain.name(), e.get_error_message()))
cpu_util = get_cpu_percentage(
self.prev_comp_data.get(data[VMNAME], {}), data)
if cpu_util != NAN:
data[CPU_UTIL] = round(cpu_util, 2)
return data
def read_temp(self):
collectd.unregister_read(self.read_temp)
collectd.register_read(self.read, interval=int(self.interval))
collectd.info("Registering '%s' ... " % PLUGIN_NAME)
virt = LibvirtCompute()
collectd.register_config(virt.read_config)
collectd.register_read(virt.read_temp)
collectd.info("Registered '%s' plugin successfully :)" % PLUGIN_NAME)
for ii in xrange(0, len(tvector)-1):
intervals.append(tvector[ii+1] - tvector[ii])
self._log("tvector: {!r}".format(tvector))
self._log("intervals:{!r}".format(intervals))
## collectd call-back functions
##
def config_cb(config, data):
cfg = util.map_collectd_config(config)
data.config(cfg)
def write_cb(vl, data):
data.track_metric(vl)
## Register the call-back functions
data = MetricWriteTracker()
collectd.register_write(write_cb, data)
collectd.register_config(config_cb, data)
## Local Variables:
## mode: python
## End:
if v.plugin_instance:
metric_fields.append(sanitize_field(v.plugin_instance))
metric_fields.append(v.type)
if v.type_instance:
metric_fields.append(sanitize_field(v.type_instance))
time = v.time
lines = []
for i, value in enumerate(v.values):
ds_name = v_type[i][0]
ds_type = v_type[i][1]
path_fields = metric_fields[:]
path_fields.append(ds_name)
metric = '.'.join(path_fields)
new_value = None
lines.append('%s %f %d' % ( metric, value, time ))
lock.acquire()
channel.basic_publish(amqp.Message('\n'.join(lines)), AMQP_EXCHANGE)
lock.release()
collectd.register_config(amqp_config)
self.plugin_name)
vrouter_traffic = VRouterTraffic()
statuses = vrouter_traffic.get_table1_delta()
#{"nw_src":['dl_src', n_packets, n_bytes]
#{"10.1.4.77":['ac:bc:32:98:c4:83', 513, 66011], }
for key, value in statuses.iteritems():
#type_instance=10.1.4.77
#plugin_instance=ac:bc:32:98:c4:83
#type=n_packets or n_bytes
host = "%s__%s__%s" % (self.account_id, self.hostname,
self.vm_type)
self.dispatch_value(self.plugin_name, host, 'n_packets', key,
value[0], value[1])
self.dispatch_value(self.plugin_name, host, 'n_bytes', key,
value[0], value[2])
except Exception as exp:
self.log_verbose(traceback.print_exc())
self.log_verbose(exp.message)
if __name__ == '__main__':
vpn_status = VRouterTraffic()
result = vpn_status.get_table1_delta()
print str(result)
else:
import collectd
vrouter_mon = VRouterTrafficMon()
collectd.register_config(vrouter_mon.configure_callback)
collectd.register_read(vrouter_mon.read_callback)
dispatch_value(
queue["message_stats"]["publish_details"], "rate", "publish_rate", plugin_instance, type_instance
)
dispatch_value(queue["message_stats"], "deliver_no_ack", "deliver_no_ack", plugin_instance, type_instance)
if "deliver_no_ack_details" in queue["message_stats"]:
dispatch_value(
queue["message_stats"]["deliver_no_ack_details"],
"rate",
"deliver_no_ack_rate",
plugin_instance,
type_instance,
)
dispatch_value(queue["message_stats"], "deliver_get", "deliver_get", plugin_instance, type_instance)
if "deliver_get_details" in queue["message_stats"]:
dispatch_value(
queue["message_stats"]["deliver_get_details"],
"rate",
"deliver_get_rate",
plugin_instance,
type_instance,
)
def shutdown():
collectd.info("python plugin shutting down")
collectd.register_config(configure)
collectd.register_read(read)
collectd.register_shutdown(shutdown)
def handle_write(vl, data=None):
"The collectd write callback."
global sock
if vl.type not in type_db:
return
# Only retry once in this loop to avoid blocking collectd.
if sock is None:
try:
init_socket()
except socket.error:
return
lines = []
for val_type, val in zip(type_db[vl.type], vl.values):
key = value_key(vl, val_type)
lines.append("%s %f %d\n" % (key, val, vl.time))
try:
sock.sendall(''.join(lines))
except socket.error:
# Wait until the next pass to reconnect
sock = None
if collectd:
collectd.register_config(handle_config)
collectd.register_init(handle_init)
collectd.register_write(handle_write)
val = item.values[0]
if key == 'host':
config['host'] = val
elif key == 'port':
config['port'] = int(val)
elif key == 'separator':
config[key] = val
# not applicable to slave
# elif key == 'trackingname':
# config['tracking_name'] = val
elif key == 'configfile':
config['config_file'] = val
else:
collectd.warning('mesos-slave plugin: unknown config key {} = {}'.format(item.key, val))
#
# this cannot be overridden
#
config['master'] = False
client = MesosSlave(config)
def reader():
global client
client.emit_metrics(client.fetch_metrics())
collectd.register_config(configurator)
collectd.register_read(reader)
'appId': 0,
'appAttemptId': 0,
'stageAttemptId': 0,
'stageId': 0,
'time': 0,
'timePeriodStart': 0,
'timePeriodEnd': 0,
'duration': 0,
'taskCount': 0
}]
for doc in docs:
self.add_common_params(doc, doc['_documentType'])
write_json.write(doc)
def read(self):
self.collect_data()
def read_temp(self):
"""
Collectd first calls register_read. At that time default interval is taken,
hence temporary function is made to call, the read callback is unregistered
and read() is called again with interval obtained from conf by register_config callback.
"""
collectd.unregister_read(self.read_temp) # pylint: disable=E1101
collectd.register_read(self.read, interval=int(self.interval)) # pylint: disable=E1101
sparkinstance = Spark()
collectd.register_config(sparkinstance.read_config) # pylint: disable=E1101
collectd.register_read(sparkinstance.read_temp) # pylint: disable=E1101
The data is read from all actions defined in SERVICE_ACTIONS.
This function returns a dict in the following format:
{instance: (value_type, value)} where value_type and instance are
mapped from VALUES and CONVERSION.
"""
values = {}
# Don't try to gather data if the connection is not available
if self._fc is None:
return values
# Combine all values available in SERVICE_ACTIONS into a dict
for service, action in self.SERVICE_ACTIONS:
values.update(self._fc.call_action(service, action))
# Construct a dict: {instance: (value_type, value)} from the queried
# results applying a conversion (if defined)
result = {
instance:
(value_type,
self.CONVERSION.get(key, lambda x: x)(values.get(key)))
for key, (instance, value_type) in self.VALUES.items()
}
return result
FC = FritzCollectd()
collectd.register_config(FC.callback_configure)
collectd.register_init(FC.callback_init)
collectd.register_read(FC.callback_read)
try:
stats.add(exportstats.GetNFSv42IO(export_id))
except Exception:
if "v42" not in self.errors:
collectd.error(traceback.format_exc())
self.errors.add("v42")
self.dispatch_value('read', stats.read_ops)
self.dispatch_value('write', stats.write_ops)
self.dispatch_value('read_bytes', stats.read_bytes)
self.dispatch_value('write_bytes', stats.write_bytes)
except Exception:
collectd.error(traceback.format_exc())
def dispatch_value(self, type_instance, value):
val = collectd.Values()
val.plugin = 'nfsstat'
val.plugin_instance = 'server'
val.type = 'nfsstat'
val.type_instance = type_instance
val.values = [value]
val.meta = {'0': True}
val.dispatch(interval=READ_INTERVAL)
nfs_stat = NFSStat()
collectd.register_config(nfs_stat.config)
collectd.register_init(nfs_stat.init)
collectd.register_read(nfs_stat.read, READ_INTERVAL)
def cache(self):
return self.stats()["CACHE"]
def diff_from(self, old_time):
delta = datetime.datetime.now() - old_time
return delta.seconds + (delta.microseconds / 1000000.0)
def stats_for(self, key):
stats = self.cache()[key]["stats"]
ret = {}
for key in self.keys_to_track:
ret[key] = stats.get(key, None)
return ret
def all_stats(self):
ret = {}
for key in self.keys:
lowered_key = self.field_value_mapping[key]
ret[lowered_key] = self.stats_for(key)
return ret
def info(self, message):
if self.verbose:
collectd.info("solr plugin [verbose]: %s" % (message))
server = SolrServer()
collectd.register_config(server.configure)
collectd.register_read(server.read)
if key == 'instance':
global instance
instance = val
elif key == 'disk_instances':
global disk_instances
disk_instances = val.split()
else:
collectd.info('unknown config key %s for plugin disk' % key)
def fake_disk_read():
type_l = ['disk_io_time', 'disk_merged', 'disk_octets', 'disk_ops', 'disk_time']
for i in disk_instances:
for temp_type in type_l:
val = collectd.Values(host=instance, plugin='disk', plugin_instance=str(i), type=temp_type)
if temp_type == 'disk_octets':
values_read = random.randint(0, MAX_VALUE*1024)
values_write = random.randint(0, MAX_VALUE*1024)
elif temp_type == 'disk_ops':
values_read = random.randint(0, MAX_VALUE)
values_write = random.randint(0, MAX_VALUE)
else:
values_read = random.randint(0, MAX_VALUE*1024)
values_write = random.randint(0, MAX_VALUE*1024)
val.dispatch(values=[values_read, values_write])
collectd.register_config(fake_disk_config)
collectd.register_read(fake_disk_read)
self.submit('file_size', 'index', db_stats['indexSize'], mongo_db)
self.submit('file_size', 'data', db_stats['dataSize'], mongo_db)
con.close()
def config(self, obj):
for node in obj.children:
if node.key == 'Port':
self.mongo_port = int(node.values[0])
elif node.key == 'Host':
self.mongo_host = node.values[0]
elif node.key == 'User':
self.mongo_user = node.values[0]
elif node.key == 'Password':
self.mongo_password = node.values[0]
elif node.key == 'Database':
self.mongo_db = node.values[0]
elif node.key == 'Ssl_certfile':
self.ssl_certfile = node.values[0]
elif node.key == 'Ssl_ca_certs':
self.ssl_ca_certs = node.values[0]
elif node.key == 'ReplicaSet':
self.replicaSet = node.values[0]
else:
collectd.warning(
"mongodb plugin: Unkown configuration key %s" % node.key)
mongodb = MongoDB()
collectd.register_read(mongodb.do_server_status)
collectd.register_config(mongodb.config)
self._batch(host, values)
self.values = not_to_flush
def _batch(self, host, values):
host_id = "collectd:" + host.replace("/", "_")
measures = {host_id: collections.defaultdict(list)}
for v in values:
ident, suffixes = self._serialize_identifier(v)
for i, value in enumerate(v.values):
if not math.isnan(value):
measures[host_id][ident + suffixes[i]].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._ensure_resource_exists(host_id, host)
self.g.metric.batch_resources_metrics_measures(measures,
create_metrics=True)
g = Gnocchi()
collectd.register_config(g.config)
collectd.register_init(g.init)
m.shutdown_flag.set()
def generate_metrics(
target,
success,
failed,
latency,
):
target_str = '%s:%i' % (target[0], target[1])
droprate = failed / (success + failed)
v = collectd.Values(plugin='tcplat',
type='tcplat',
plugin_instance=target_str)
v.dispatch(values=[
droprate,
np.mean(latency),
np.std(latency),
np.amin(latency),
np.amax(latency),
np.percentile(latency, 99),
np.percentile(latency, 95),
np.percentile(latency, 90),
])
collectd.register_config(read_config)
collectd.register_read(read_data)
collectd.register_init(start_monitoring)
collectd.register_shutdown(shutdown)
temperatures = c.call('disk.temperatures', self.disks,
self.powermode)
for disk, temp in temperatures.items():
if temp is not None:
self.dispatch_value(disk,
'temperature',
temp,
data_type='temperature')
except CallTimeout:
collectd.error("Timeout collecting disk temperatures")
except Exception:
collectd.error(traceback.format_exc())
def dispatch_value(self, name, instance, value, data_type=None):
val = collectd.Values()
val.plugin = 'disktemp'
val.plugin_instance = name
if data_type:
val.type = data_type
val.values = [value]
val.meta = {'0': True}
val.dispatch(interval=READ_INTERVAL)
disktemp = DiskTemp()
collectd.register_config(disktemp.config)
collectd.register_init(disktemp.init)
collectd.register_read(disktemp.read, READ_INTERVAL)
list = status.split()
ndx = list.index('Temperature:')
temperature = float(list[ndx + 1])
frequency = float(list[ndx + 16])
signal_noise = float(list[ndx + 41][6:])
signal_power = float(list[ndx + 49][6:])
self.submit('temperature', 'gauge', temperature)
self.submit('frequency', 'gauge', frequency)
self.submit('signal_noise', 'gauge', signal_noise)
self.submit('signal_power', 'gauge', signal_power)
def config(self, obj):
"""
Get the configuration from collectd
"""
for child in obj.children:
if child.key == 'Debug':
self.debug = True
elif child.key == 'SerialDevice':
self.device = child.values[0]
self.set_plugin()
elif child.key == 'SerialSpeed':
self.speed = int(child.values[0])
collectd.info('SierraSerial: configuration')
sierra = SierraSerial()
collectd.register_config(sierra.config)
collectd.register_read(sierra.get_value)
self.dispatch_value(self.plugin_name, host, "mod_dl_dst_n_bytes", key, value[0])
self.dispatch_value(self.plugin_name, host, "mod_dl_dst_n_packets", key, value[1])
except Exception as exp:
self.log_verbose(traceback.print_exc())
self.log_verbose("plugin %s run into exception" % self.plugin_name)
self.log_verbose(exp.message)
if __name__ == '__main__':
stat_1_1 = parse_table_1(1)
stat_6_1 = parse_table_6(6)
print '***********'
print stat_1_1
print stat_6_1
import time
time.sleep(5)
stat_1_2 = parse_table_1(1)
stat_6_2 = parse_table_6(6)
print '***********'
print stat_1_2
print stat_6_2
print '***********'
print get_delta_value(stat_1_1, stat_1_2)
print get_delta_value(stat_6_1, stat_6_2)
else:
import collectd
vrouter_status = VRouterTrafficStatMon()
collectd.register_config(vrouter_status.configure_callback)
collectd.register_init(vrouter_status.init)
collectd.register_read(vrouter_status.read_callback)
private += int(line.split()[1])
elif line.startswith("Pss"):
pss += 0.5 + float(line.split()[1])
F.close()
if pss > 0:
shared = pss - private
M.values = [1024 * int(private + shared)] # in bytes
else:
# rough, but quick estimate
# I'd use `with` statement, but not sure if it's present in Python 2.6
statm = open("/proc/%s/statm" % pid, "rt")
S = statm.readline().split()
statm.close()
statm = S
shared = int(statm[2]) * PAGESIZE
Rss = int(statm[1]) * PAGESIZE
private = Rss - shared
M.values = [int(private) + int(shared)]
M.dispatch()
collectd.register_config(config_memory)
collectd.register_init(init_memory)
collectd.register_read(read_memory)
global memory
memory = val
else:
collectd.info('unknown config key %s for plugin mem' % key)
def fake_mem_read():
plugin_instance_l = [
'used', 'buffered', 'cached', 'free', 'slab_recl', 'slab_unrecl'
]
for temp_instance in plugin_instance_l:
val = collectd.Values(host=instance,
plugin='memory',
plugin_instance=temp_instance,
type='memory')
if temp_instance == 'used':
used_values = random.randint(0, (int(memory) / 2) * 1024 * 1024)
val.dispatch(values=[used_values])
elif temp_instance == 'free':
free_values = int(memory) * 1024 * 1024 - used_values
val.dispatch(values=[free_values])
else:
values = 0
val.dispatch(values=[values])
collectd.register_config(fake_mem_config)
collectd.register_read(fake_mem_read)
values=[pg_json["pg_stats_sum"]["stat_sum"]["num_objects"]]\
).dispatch()
collectd.Values(plugin="cephtool",\
type='pg_stats_sum_num_bytes',\
values=[pg_json["pg_stats_sum"]["stat_sum"]["num_bytes"]]\
).dispatch()
collectd.Values(plugin="cephtool",\
type='num_objects_missing_on_primary',\
values=[pg_json["pg_stats_sum"]["stat_sum"]["num_objects_missing_on_primary"]]\
).dispatch()
collectd.Values(plugin="cephtool",\
type='num_objects_degraded',\
values=[pg_json["pg_stats_sum"]["stat_sum"]["num_objects_degraded"]]\
).dispatch()
collectd.Values(plugin="cephtool",\
type='num_objects_unfound',\
values=[pg_json["pg_stats_sum"]["stat_sum"]["num_objects_unfound"]]\
).dispatch()
collectd.Values(plugin="cephtool",\
type='num_monitors',\
values=[len(mon_json["mons"])],
).dispatch()
collectd.Values(plugin="cephtool",\
type='num_monitors_in_quorum',\
values=[len(mon_json["quorum"])],
).dispatch()
collectd.register_config(cephtool_config)
collectd.register_read(cephtool_read)
job_hostsite = "undefined"
except ValueError:
collectd.info("pandajob module: current job is \'" + job + "\' (hostsite)")
job_hostsite = "undefined"
if (job_hostsite not in metrics):
metrics[job_hostsite] = {'pending':0, 'defined':0, 'waiting':0, \
'assigned':0, 'throttled':0, 'activated':0, 'sent':0, 'starting':0, \
'running':0, 'holding':0, 'merging':0, 'transferring':0, 'finished':0, \
'failing':0, 'failed':0, 'cancelled':0, }
# Increment appropriate job status
try:
job_status = p[p.index('"jobstatus":')+1][1:-2].lower()
metrics[job_hostsite][job_status] += 1
except ValueError:
collectd.info("pandajob module: current job is \'" + job + "\' (status)")
job_status = "undefined"
# Send the data back to collectd
for hostsite in metrics:
for status in metrics[hostsite]:
val = collectd.Values(type='gauge', host='pandajobs', plugin=queue, plugin_instance=hostsite, time=timestamp, type_instance=status)
val.dispatch(values=[metrics[hostsite][status]])
# Collectd register callback functions
collectd.register_config(config_pandajob_plugin)
collectd.register_init(init_pandajob_plugin)
collectd.register_read(read_panda_jobs, 3600) # 3600: only poll once an hour
new_value = value - old_value
if (isinstance(new_value, (float, int)) and
data['differentiate_values_over_time']):
interval = time - old_time
if interval < 1:
interval = 1
new_value = new_value / interval
# update previous value
data['values'][metric] = ( time, value )
else:
new_value = value
if new_value is not None:
line = '%s %f %d' % ( metric, new_value, time )
lines.append(line)
i += 1
data['lock'].release()
lines.append('')
carbon_write_data(data, '\n'.join(lines))
collectd.register_config(carbon_config)
collectd.register_init(carbon_init)
########NEW FILE########
identifier += '/' + self.type
if getattr(self, 'type_instance', None):
identifier += '-' + self.type_instance
print 'PUTVAL', identifier, \
':'.join(map(str, [int(self.time)] + self.values))
class ExecCollectd:
def Values(self):
return ExecCollectdValues()
def warning(self, msg):
print 'WARNING:', msg
def info(self, msg):
print 'INFO:', msg
collectd = ExecCollectd()
plugin = DockerPlugin()
if len(sys.argv) > 1:
plugin.docker_url = sys.argv[1]
if plugin.init_callback():
plugin.read_callback()
# Normal plugin execution via CollectD
else:
import collectd
plugin = DockerPlugin()
collectd.register_config(plugin.configure_callback)
collectd.register_init(plugin.init_callback)
parser.add_option("","--plugin-name", default="RabbitMQ")
parser.add_option("-H", "--host", default="localhost",
help="RabbitMQ hostname. Default localhost")
parser.add_option("-P", "--port", default=55672,
help="RabbitMQ Admin port. Default 55672.")
parser.add_option("", "--username", default="guest",
help="Username credential. Default guest.")
parser.add_option("", "--password", default="guest",
help="Password credential. Default guest.")
parser.add_option("", "--vhost", default="/",
help="Virtual host. Default /")
opts, arg_files = parser.parse_args()
CONFIGS = ([{'plugin_name' : opts.plugin_name, 'host' : opts.host, 'admin_port' : opts.port, 'vhost' : opts.vhost, 'username' : opts.username, 'password' : opts.password }])
co = RabbitMQ()
co.check_run_multi_config()
if co.debug_info:
str_json = json.dumps(METRICS_RESULTS)
print str_json
if not DEBUG:
collectd_rabbitMQ = RabbitMQ()
collectd.register_config(collectd_rabbitMQ.multi_config)
collectd.register_read(collectd_rabbitMQ.check_run_multi_config)
collectd.register_write(collectd_rabbitMQ.write)
if __name__ == '__main__':
main()
# Intentionally *not* wrapped in a try/except so that an
# exception here causes collectd to slow down trying to write
# stats.
client.gauge(path, value)
else:
# No statsd client, be noisy
message = 'Statsd client is None, not sending metrics!'
collectd.warning(message)
# Raise an exception so we aren't *too* noisy.
raise RuntimeError(message)
def get_stats_writer(plugin):
"""
Returns a writer function for the given plugin. If no custom writer
function is defined, the default write_stats function is returned.
"""
return globals().get('write_%s' % plugin, write_stats)
def statsd_write(values, data=None):
"""
Entry point from collectd. Dispatches to a custom writer for the
plugin, if one exists, or calls the default writer.
"""
writer = get_stats_writer(values.plugin)
return writer(values, data['types'], client=data['stats'])
collectd.register_config(configure)
if v not in clist:
clist.append(v)
def enhanceio_read(data=None):
if not len(clist):
return
values = collectd.Values(plugin='enhanceio')
for cache in clist:
d = {}
procfile = '/proc/enhanceio/' + cache + '/stats'
with open(procfile, 'r') as fd:
d = dict(line.strip().split(None, 1) for line in fd)
for key in d:
if key in ['read_hit_pct','write_hit_pct','dirty_write_hit_pct']:
values.dispatch(plugin_instance=cache, type='percent', type_instance=key, values=[d[key]])
elif key in ['nr_blocks', 'nr_dirty', 'nr_sets']:
values.dispatch(plugin_instance=cache, type='gauge', type_instance=key, values=[d[key]])
else:
values.dispatch(plugin_instance=cache, type='derive', type_instance=key, values=[d[key]])
values.dispatch(plugin_instance=cache, type='disk_ops', type_instance='enhanceio_ssd_rw', values=[d['ssd_reads'], d['ssd_writes']])
values.dispatch(plugin_instance=cache, type='df', type_instance='df_cache', values=[d['cached_blocks'],str(int(d['nr_blocks'])-int(d['cached_blocks']))])
fd.close()
collectd.register_read(enhanceio_read)
collectd.register_config(enhanceio_config)
"ReceivedBytes": 0,
"RpcAuthorizationFailures": 0,
"NumOpenConnections": 0,
"RpcAuthorizationSuccesses": 0,
"name": "Hadoop:service=NameNode,name=RpcActivityForPort8020",
"RpcProcessingTimeNumOps": 0,
"RpcQueueTimeNumOps": 0,
"time": 0,
"CallQueueLength": 0
}]
for doc in docs:
self.add_common_params(doc, doc['_documentType'])
write_json.write(doc)
def read(self):
self.collect_data()
def read_temp(self):
"""
Collectd first calls register_read. At that time default interval is taken,
hence temporary function is made to call, the read callback is unregistered
and read() is called again with interval obtained from conf by register_config callback.
"""
collectd.unregister_read(self.read_temp) # pylint: disable=E1101
collectd.register_read(self.read, interval=int(self.interval)) # pylint: disable=E1101
namenodeinstance = Namenode()
collectd.register_config(namenodeinstance.read_config) # pylint: disable=E1101
collectd.register_read(namenodeinstance.read_temp) # pylint: disable=E1101
}
if ds_type == 'GAUGE':
gauges.append(measurement)
else:
counters.append(measurement)
librato_queue_measurements(gauges, counters, data)
def librato_init():
import threading
try:
librato_parse_types_file(config['types_db'])
except:
msg = '%s: ERROR: Unable to open TypesDB file: %s.' % \
(plugin_name, config['types_db'])
raise Exception(msg)
d = {
'lock' : threading.Lock(),
'last_flush_time' : get_time(),
'gauges' : [],
'counters' : []
}
collectd.register_write(librato_write, data = d)
collectd.register_config(librato_config)
collectd.register_init(librato_init)
def request(self, service_id, time_from, time_to):
"""
Requests stats from Fastly's API and return a dict of data. May
contain multiple time periods.
"""
params = {
'from': time_from,
'to': time_to,
'by': "minute",
}
url = self.STATS_URL % {
'service_id': service_id,
}
headers = {
'Fastly-Key': self.api_key,
}
self.auth()
resp = self.session.get(url, params=params, timeout=self.api_timeout)
if resp.status_code != 200:
self._raise("Non-200 response")
data = resp.json()['data']
return data
cdn_fastly = CdnFastly()
collectd.register_config(cdn_fastly.config)
collectd.register_read(cdn_fastly.read, INTERVAL)
def restore_sigchld():
"""
Restore SIGCHLD handler for python <= v2.6
It will BREAK exec plugin!!!
See https://github.com/deniszh/collectd-iostat-python/issues/2 for details
"""
if sys.version_info[0] == 2 and sys.version_info[1] <= 6:
signal.signal(signal.SIGCHLD, signal.SIG_DFL)
if __name__ == '__main__':
iostat = IOStat()
ds = iostat.get_diskstats()
for disk in ds:
for metric in ds[disk]:
tbl = string.maketrans('/-%', '___')
metric_name = metric.translate(tbl)
print("%s.%s:%s" % (disk, metric_name, ds[disk][metric]))
sys.exit(0)
else:
import collectd
iomon = IOMon()
# Register callbacks
collectd.register_init(restore_sigchld)
collectd.register_config(iomon.configure_callback)
with_pos += 1
if rlat is not None:
distance = greatcircle(rlat, rlon, a['lat'], a['lon'])
if distance > max_range: max_range = distance
if 'lat' in a.get('mlat', ()):
mlat += 1
V.dispatch(plugin_instance=instance_name,
host=host,
type='dump1090_aircraft',
type_instance='recent',
time=aircraft_data['now'],
values=[total, with_pos])
V.dispatch(plugin_instance=instance_name,
host=host,
type='dump1090_mlat',
type_instance='recent',
time=aircraft_data['now'],
values=[mlat])
if max_range > 0:
V.dispatch(plugin_instance=instance_name,
host=host,
type='dump1090_range',
type_instance='max_range',
time=aircraft_data['now'],
values=[max_range])
collectd.register_config(callback=handle_config, name='dump1090')
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:
obj.NETWORKS[NETWORK_OAM] = iface(NETWORK_OAM, name, 0)
collectd.info("%s monitoring oam interface: %s" %
(PLUGIN,
obj.NETWORKS[NETWORK_OAM].master['name']))
return 0
# The sample read function - called on every audit interval
def read_func():
if obj.NETWORKS[NETWORK_MGMNT].state == 0:
obj.NETWORKS[NETWORK_MGMNT].state = 100
else:
obj.NETWORKS[NETWORK_MGMNT].state -= 25
# Dispatch usage value to collectd
val = collectd.Values(host=obj.hostname)
val.plugin = 'interface'
val.plugin_instance = 'mgmnt'
val.type = 'absolute'
val.type_instance = 'used'
val.dispatch(values=[obj.NETWORKS[NETWORK_MGMNT].state])
return 0
# register the config, init and read functions
collectd.register_config(config_func)
collectd.register_init(init_func)
collectd.register_read(read_func)
self.dispatch_failed()
def dispatch_failed(self):
type_instance = "failed"
value = int(self.redis_client.get("resque:stat:failed"))
val = collectd.Values(plugin=PLUGIN_NAME, type_instance=type_instance, values=[value], type="gauge")
self.info("Sending value: %s=%s" % (type_instance, value))
val.dispatch()
def dispatch_queue_sized(self):
for key in self.queues():
value = self.queue_size(key)
type_instance = "queue-%s" % (key)
val = collectd.Values(plugin=PLUGIN_NAME, type_instance=type_instance, values=[value], type="gauge")
self.info("Sending value: %s=%s" % (type_instance, value))
val.dispatch()
def queues(self):
return self.redis_client.smembers("resque:queues") - set("*",)
def queue_size(self, key):
return self.redis_client.llen("resque:queue:%s" % key)
def info(self, message):
if self.verbose:
collectd.info("solr plugin [verbose]: %s" % (message))
monitor = ResqueMonitor()
collectd.register_config(monitor.configure)
collectd.register_read(monitor.read)
json += '}'
json += '}'
i += 1
json += ']'
collectd.debug(json)
self.kairosdb_send_http_data(data, json)
@staticmethod
def load_plugin_formatters(formatter_directory):
if os.path.exists(formatter_directory):
plugins_to_format = {}
for filename in os.listdir(formatter_directory):
if filename.endswith(".py"):
formatter_name, extension = os.path.splitext(filename)
plugin_formatter = imp.load_source(
formatter_name, formatter_directory + "/" + filename)
for plugin in plugin_formatter.plugins():
plugins_to_format[plugin] = plugin_formatter
return plugins_to_format
else:
return {}
writer = KairosdbWriter()
collectd.register_config(writer.kairosdb_config)
collectd.register_init(writer.kairosdb_init)
if i > 0:
json += ','
json += '{'
json += '"name":"%s",' % new_name
json += '"datapoints":[[%d, %f]],' % (timestamp, new_value)
json += '"tags": {'
first = True
for tn, tv in tags.iteritems():
if first:
first = False
else:
json += ", "
json += '"%s": "%s"' % (tn, tv)
json += '}'
json += '}'
i += 1
json += ']'
collectd.debug(json)
kairosdb_send_http_data(data, json)
collectd.register_config(kairosdb_config)
collectd.register_init(kairosdb_init)
dispatch_value('variables', key, mysql_variables[key], 'gauge')
mysql_master_status = fetch_mysql_master_stats(conn)
for key in mysql_master_status:
dispatch_value('master', key, mysql_master_status[key], 'gauge')
mysql_states = fetch_mysql_process_states(conn)
for key in mysql_states:
dispatch_value('state', key, mysql_states[key], 'gauge')
slave_status = fetch_mysql_slave_stats(conn)
for key in slave_status:
dispatch_value('slave', key, slave_status[key], 'gauge')
response_times = fetch_mysql_response_times(conn)
for key in response_times:
dispatch_value('response_time_total', str(key),
response_times[key]['total'], 'counter')
dispatch_value('response_time_count', str(key),
response_times[key]['count'], 'counter')
innodb_status = fetch_innodb_stats(conn)
for key in MYSQL_INNODB_STATUS_VARS:
if key not in innodb_status: continue
dispatch_value('innodb', key, innodb_status[key],
MYSQL_INNODB_STATUS_VARS[key])
collectd.register_read(read_callback)
collectd.register_config(configure_callback)
metrics_list = list(metrics(vl, config))
ts = datetime.fromtimestamp(vl.time)
data = []
for i, v in enumerate(vl.values):
fullname, unit, dims = metrics_list[i]
name = fullname[:255]
if len(name) < len(fullname):
collectd.warning('Metric name was truncated for CloudWatch: {}'.format(fullname))
data.append(dict(
MetricName=name,
Timestamp=ts,
Value=v,
Unit=unit,
Dimensions=dims
))
client.put_metric_data(Namespace=vl.plugin, MetricData=data)
except Exception, e:
collectd.error(str(e))
def plugin_init():
collectd.info('Initializing write_cloudwatch')
signal.signal(signal.SIGCHLD, signal.SIG_DFL)
config = Config()
collectd.register_config(plugin_config, config)
collectd.register_init(plugin_init)
collectd.register_write(plugin_write, config)
"""Collects all data."""
start_time = datetime.datetime.now()
dict_linux = self.collect_data()
end_time = datetime.datetime.now()
elapsed_time = end_time - start_time
if not dict_linux:
return
# dispatch data to collectd
dict_linux["elapsed_time"] = elapsed_time.microseconds
self.dispatch_data(dict_linux)
def read_temp(self):
"""
Collectd first calls register_read. At that time default interval is taken,
hence temporary function is made to call, the read callback is unregistered
and read() is called again with interval obtained from conf by register_config callback.
"""
collectd.unregister_read(self.read_temp)
collectd.register_read(self.read, interval=int(self.interval))
def init():
"""When new process is formed, action to SIGCHLD is reset to default behavior."""
signal.signal(signal.SIGCHLD, signal.SIG_DFL)
OBJ = LinuxStats()
collectd.register_config(OBJ.config)
collectd.register_read(OBJ.read_temp)
except Exception as exp:
self.log_verbose(traceback.print_exc())
self.log_verbose("plugin %s run into exception" % (self.plugin_name))
self.log_verbose(exp.message)
if __name__ == '__main__':
print "************\n"
# print str(get_intergrp_stat())
# print "***********\n"
# print str(get_internet_stat())
# print "************\n"
# print str(get_intragrp_stat())
# print "**********\n"
# print str(get_policy_stat())
# print '------------------\n'
a = get_internet_stat()
print a
import time
time.sleep(10)
print '------------------\n'
b = get_internet_stat()
c = get_delta_value(a, b)
print '---delta value----'
print c
else:
import collectd
firewall_status = FireWallUserStatMon()
collectd.register_config(firewall_status.configure_callback)
collectd.register_init(firewall_status.init)
collectd.register_read(firewall_status.read_callback)
collectd.info('fusionio init: stats_cache: %s ' % (stats_cache))
def reader(input_data=None):
get_fiostats()
collect_fiostats()
#dispatch_metrics()
swap_current_cache()
def writer(metric, data=None):
for i in metric.values:
collectd.debug("%s (%s): %f" % (metric.plugin, metric.type, i))
def shutdown():
collectd.info("fusionio plugin shutting down")
#== Callbacks ==#
get_host_type()
if ((host_type == 'search') and (os_name == 'Linux') and (is_fio_device())):
collectd.register_config(configer)
collectd.register_init(initer)
collectd.register_read(reader)
collectd.register_write(writer)
collectd.register_shutdown(shutdown)
else:
collectd.error('fio plugin works for search hosts only; type: %s os: %s' %
(host_type, os_name))
for snapshot in snapshots:
try:
tenant_id = getattr(snapshot, 'os-extended-snapshot-attributes:project_id')
except AttributeError:
continue
try:
data_tenant = data[self.prefix]["tenant-%s" % tenants[tenant_id]]
except KeyError:
continue
data_tenant['volume-snapshots']['count'] += 1
data_tenant['volume-snapshots']['bytes'] += (snapshot.size * 1024 * 1024 * 1024)
return data
try:
plugin = CinderPlugin()
except Exception as exc:
collectd.error("openstack-cinder: failed to initialize cinder plugin :: %s :: %s"
% (exc, traceback.format_exc()))
def configure_callback(conf):
"""Received configuration information"""
plugin.config_callback(conf)
def read_callback():
"""Callback triggerred by collectd on read"""
plugin.read_callback()
collectd.register_config(configure_callback)
collectd.register_read(read_callback, plugin.interval)
self.kafka_client)
self.producer.send_messages(self.kafka_topic, data)
except Exception as exp:
self.log_verbose(traceback.print_exc())
self.log_verbose("plugin %s run into exception" %
(self.plugin_name))
self.log_verbose(exp.message)
raise Exception("Failed to send msg to kafka: %s\n%s" %
(exp.message, traceback.print_exc()))
def _escape_proc_name(self, proc):
if str(proc) == '0':
return '0'
return proc.replace('[',
'').replace(']',
'').replace('/',
'.').replace("-", "_")
if __name__ == '__main__':
# process_status = ProcessStatus("pyth[on], /usr/bin/ss[hd], ja[va]")
producer = create_kafka_producer("172.17.8.113:9092")
producer.send_messages('dms-event', b'this is for test process')
print 'aa'
else:
import collectd
process_status_mon = ProcessStatusMon()
collectd.register_config(process_status_mon.configure_callback)
collectd.register_init(process_status_mon.init)
collectd.register_read(process_status_mon.read_callback)
