def add_write_callback(self, callback, **kwargs): """ Register a write callback with collectd. kwargs will be passed to collectd.register_read. The callback will be called by collectd with a collectd.Values object as the only argument. """ collectd.register_write(callback)
def aws_init(): """ Collectd callback entry used to initialize plugin """ config = ConfigHelper() flusher = Flusher(config_helper=config, dataset_resolver=get_dataset_resolver()) collectd.register_write(aws_write, data = flusher) _LOGGER.info('Initialization finished successfully.')
def redis_queue_init(): import threading d = {"host": REDIS_HOST, "port": REDIS_PORT, "queue": REDIS_QUEUE, "hotqueue": None, "lock": threading.Lock()} create_queue(d) collectd.register_write(redis_write, data=d)
def maasi_init(): d = { 'server_uri': server_uri, 'interval': interval } logging.info('initiating maasi daemon') collectd.register_write(maasi_collect, data=d) collectd.register_read(maasi_send)
def handle_init(): global types types = write_common.parse_types_db(config['TypesDB'], plugin_name) # If we made it this far, go ahead and register the write plugin collectd.register_write(handle_write) collectd.info( '%s: Initialized and registered write handler.' % plugin_name)
def add_write_callback(self, callback, **kwargs): """Register a write callback with collectd. kwargs will be passed to collectd.register_read. The callback will be called by collectd with a collectd. Values object as the only argument. """ collectd.register_write(callback)
def aws_init(): """ Collectd callback entry used to initialize plugin """ try: config = ConfigHelper() flusher = Flusher(config_helper=config, dataset_resolver=get_dataset_resolver()) collectd.register_write(aws_write, data = flusher) _LOGGER.info('Initialization finished successfully.') except Exception as e: _LOGGER.error("Cannot initialize plugin. Cause: " + str(e) + "\n" + traceback.format_exc())
def influxdb_init(): import threading try: influxdb_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(), "series": {}} collectd.register_write(influxdb_write, data=d)
def handle_init(): global types types = write_common.parse_types_db(config['TypesDB'], plugin_name) # global connection # connection = Connection("%s/%s@%s:%s" % ( # config['User'], config['Password'], config['Host'], config['Port'])) # If we made it this far, go ahead and register the write plugin collectd.register_write(handle_write) collectd.info('%s: Initialized and registered write handler.' % plugin_name)
def initialize(data=None): """ Create the statsd client object that will be used by the statsd_write function to send stats to statsd. This object will be shared between collectd threads, but because we are not using pipelines, the statsd object is thread safe. """ data['stats'] = statsd.StatsClient(host=data['conf']['host'], port=int(data['conf']['port']), prefix=data['conf']['prefix']) collectd.register_write(statsd_write, data=data)
def plugin_config(conf): """ :param conf: https://collectd.org/documentation/manpages/collectd-python.5.shtml#config Parse the config object for config parameters: ProcessInfo: true or false, whether or not to collect process information. Default is true. Notifications: true or false, whether or not to emit notifications if Notifications is true: URL: where to POST the notifications to Token: what auth to send along Timeout: timeout for the POST NotifyLevel: what is the lowest level of notification to emit. Default is to only emit notifications generated by this plugin """ DOGSTATSD_INSTANCE.config.configure_callback(conf) for kv in conf.children: if kv.key == 'Notifications': if kv.values[0]: log("sending collectd notifications") collectd.register_notification(receive_notifications) elif kv.key == 'ProcessInfo': global PROCESS_INFO PROCESS_INFO = kv.values[0] elif kv.key == 'DPM': global DPM DPM = kv.values[0] if DPM: collectd.register_write(receive_datapoint) elif kv.key == 'URL': global POST_URL POST_URL = kv.values[0] elif kv.key == 'Token': global API_TOKEN API_TOKEN = kv.values[0] elif kv.key == 'Timeout': global TIMEOUT TIMEOUT = int(kv.values[0]) elif kv.key == 'Interval': global INTERVAL INTERVAL = int(kv.values[0]) elif kv.key == 'NotifyLevel': global NOTIFY_LEVEL if string.lower(kv.values[0]) == "okay": NOTIFY_LEVEL = 4 elif string.lower(kv.values[0]) == "warning": NOTIFY_LEVEL = 2 elif string.lower(kv.values[0]) == "failure": NOTIFY_LEVEL = 1
def stomp_config(c): global config for child in c.children: if child.key == 'host': config['host'] = child.values[0] elif child.key == 'port': config['port'] = int(child.values[0]) elif child.key == 'destination': config['destination'] = child.values[0] # register writer collectd.register_write(stomp_write)
def initialize(data=None): """ Create the statsd client object that will be used by the statsd_write function to send stats to statsd. This object will be shared between collectd threads, but because we are not using pipelines, the statsd object is thread safe. """ data['stats'] = statsd.StatsClient( host=data['conf']['host'], port=int(data['conf']['port']), prefix=data['conf']['prefix'] ) collectd.register_write(statsd_write, data=data)
def kairosdb_init(self): # Param validation has to happen here, exceptions thrown in kairosdb_config # do not prevent the plugin from loading. if not self.uri: raise Exception('KairosDBURI not defined') if not self.tags_map and not self.add_host_tag: raise Exception('Tags not defined') split = self.uri.strip('/').split(':') # collectd.info(repr(split)) if len(split) != 3 and len(split) != 2: raise Exception( 'KairosDBURI must be in the format of <protocol>://<host>[:<port>]' ) # validate protocol and set default ports self.protocol = split[0] if self.protocol == 'http': port = 80 elif self.protocol == 'https': port = 443 elif self.protocol == 'telnet': port = 4242 else: raise Exception( 'Invalid protocol specified. Must be either "http", "https" or "telnet"' ) host = split[1].strip('/') if len(split) == 3: port = int(split[2]) collectd.info('Initializing kairosdb_writer client in %s mode.' % self.protocol.upper()) d = { 'host': host, 'port': port, 'lowercase_metric_names': self.lowercase_metric_names, 'conn': None, 'lock': threading.Lock(), 'values': {}, 'last_connect_time': 0 } self.kairosdb_connect(d) collectd.register_write(self.kairosdb_write, data=d)
def kairosdb_init(): import threading global uri, tags_map, add_host_tag, protocol #Param validation has to happen here, exceptions thrown in kairosdb_config #do not prevent the plugin from loading. if not uri: raise Exception('KairosDBURI not defined') if not tags_map and not add_host_tag : raise Exception('Tags not defined') split = uri.strip('/').split(':') #collectd.info(repr(split)) if len(split) != 3 and len(split) != 2: raise Exception('KairosDBURI must be in the format of <protocol>://<host>[:<port>]') #validate protocol and set default ports protocol = split[0] if protocol == 'http': port = 80 elif protocol == 'https': port = 443 elif protocol == 'telnet': port = 4242 else: raise Exception('Invalid protocol specified. Must be either "http", "https" or "telnet"') host = split[1].strip('/') if (len(split) == 3): port = int(split[2]) collectd.info('Initializing kairosdb_writer client in %s mode.' % protocol.upper()) d = { 'host': host, 'port': port, 'lowercase_metric_names': lowercase_metric_names, 'conn': None, 'lock': threading.Lock(), 'values': {}, 'last_connect_time': 0 } kairosdb_connect(d) collectd.register_write(kairosdb_write, data=d)
def redis_queue_init(): import threading d = { 'host': REDIS_HOST, 'port': REDIS_PORT, 'queue': REDIS_QUEUE, 'hotqueue': None, 'lock': threading.Lock(), } create_queue(d) collectd.register_write(redis_write, data=d)
def oci_init(): """collectd initialization callback method""" global _configuration, _data_reporter logger = None try: while not _configuration: time.sleep(1) data_processor = DataProcessor(configuration=_configuration) collectd.register_write(oci_write, data=data_processor) _data_reporter = DataReporter(_configuration, data_processor) logger = oci_logger.get_logger(__name__, _configuration.logging_level) logger.info('Initialization completed successfully.') except Exception as e: logger.error("Cannot initialize plugin. Cause: " + str(e) + "\n" + traceback.format_exc())
def register(cls): assert collectd is not None LOG.info("Register plugin: %s", cls) log_handler = CollectdLogHandler(collectd=collectd) log_handler.setFormatter(logging.Formatter(LOG_FORMAT)) logging.getLogger('collectd_pandas').addHandler(log_handler) instance = cls() collectd.register_config(instance.configure) collectd.register_init(instance.initialize) collectd.register_write(instance.write) LOG.info("Plugin registered as: %r.", instance) return instance
def kairosdb_init(): import threading d = { 'host': host, 'port': port, 'lowercase_metric_names': lowercase_metric_names, 'sock': None, 'lock': threading.Lock(), 'values': { }, 'last_connect_time': 0 } kairosdb_connect(d) collectd.register_write(kairosdb_write, data=d)
def kairosdb_init(): import threading d = { 'host': host, 'port': port, 'lowercase_metric_names': lowercase_metric_names, 'sock': None, 'lock': threading.Lock(), 'values': {}, 'last_connect_time': 0 } kairosdb_connect(d) collectd.register_write(kairosdb_write, data=d)
def carbon_init(): import threading d = { 'host': host, 'port': port, 'differentiate_values': differentiate_values, 'differentiate_values_over_time': differentiate_values_over_time, 'sock': None, 'lock': threading.Lock(), 'values': { }, 'last_connect_time': 0 } carbon_connect(d) collectd.register_write(carbon_write, data=d)
def carbon_init(): global host, port, derive import threading d = { 'host': host, 'port': port, 'derive': derive, 'sock': None, 'lock': threading.Lock(), 'values': { }, 'last_connect_time': 0 } carbon_connect(d) collectd.register_write(carbon_write, data=d)
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 carbon_init(): global host, port, derive import threading d = { 'host': host, 'port': port, 'derive': derive, 'sock': None, 'lock': threading.Lock(), 'values': {}, 'last_connect_time': 0 } carbon_connect(d) collectd.register_write(carbon_write, data=d)
def init(): import threading data = { 'lock': threading.Lock(), 'conf': cfg, 'last_flush_time': time.time(), 'types': parse_types_file(cfg.get('TypesDB', '/usr/share/collectd/types.db')), 'metrics': {} } for key in ('URL', 'Tenant'): if key not in cfg: collectd.error('{}: No {} key is present in config file'.format(plugin_name, key)) return # can't register write earlier cause of threading import constraints collectd.register_write(write, data)
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_shutdown(instance.shutdown) collectd.register_write(instance.write)
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 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)
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)
def sensu_init(): """Prepare to send data to Sensu""" import threading try: sensu_parse_types_file(CONFIG['types_db']) except: msg = '%s: ERROR: Unable to open TypesDB file: %s.' % \ (PLUGIN_NAME, CONFIG['types_db']) raise Exception(msg) data_init = { 'lock': threading.Lock(), 'last_flush_time': get_time(), 'output': [], } collectd.register_write(sensu_write, data=data_init)
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 carbon_init(): import threading d = { "host": host, "port": port, "differentiate_values": differentiate_values, "differentiate_values_over_time": differentiate_values_over_time, "lowercase_metric_names": lowercase_metric_names, "sock": None, "lock": threading.Lock(), "values": {}, "last_connect_time": 0, } carbon_connect(d) collectd.register_write(carbon_write, data=d)
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)
def sensu_init(): """Prepare to send data to Sensu""" import threading try: sensu_parse_types_file(CONFIG['types_db']) except: msg = '%s: ERROR: Unable to open TypesDB file: %s.' % \ (PLUGIN_NAME, CONFIG['types_db']) raise Exception(msg) data_init = { 'lock' : threading.Lock(), 'last_flush_time' : get_time(), 'output' : [], } collectd.register_write(sensu_write, data = data_init)
def carbon_init(): import threading d = { 'host': host, 'port': port, 'differentiate_values': differentiate_values, 'differentiate_values_over_time': differentiate_values_over_time, 'lowercase_metric_names': lowercase_metric_names, 'sock': None, 'lock': threading.Lock(), 'values': { }, 'last_connect_time': 0 } carbon_connect(d) collectd.register_write(carbon_write, data=d)
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)
def init_callback(): global diskMetrics, networkMetrics, diskMetricsNames, networkMetricsNames, cpuMetricsNames, cpuMetrics, memoryMetrics, memoryMetricsNames, sysSpecsMetrics i = len(disks)*2 for x in range(0, i): diskMetrics.insert(x, 0) diskMetricsNames = ['disk_octets'] y = len(networks)*4 for z in range(0, y): networkMetrics.insert(x, 0) networkMetricsNames = ['if_octets', 'if_packets'] cpuMetricsNames = ['load', 'totalCpuTime', 'system', 'user', 'idle'] cpuMetrics = [0, 0, 0, 0, 0] memoryMetricsNames = ['UsedPercantage', 'FreePercentage', 'used', 'free'] memoryMetrics = [0, 0, 0, 0] sysSpecsMetrics = [0, 0, 0, 0] collectd.register_write(write_onos, data=None)
def amqp_config(config): global AMQP_EXCHANGE, AMQP_HOST, AMQP_PORT global METRIC_PREFIX global SSL_CERT, SSL_KEY, SSL_CACERT global connection, channel for child in config.children: if child.key == 'TypesDB': for v in child.values: parse_types_file(v) elif child.key == 'AMQP_EXCHANGE': AMQP_EXCHANGE = child.values[0] elif child.key == 'AMQP_HOST': AMQP_HOST = child.values[0] elif child.key == 'METRIC_PREFIX': METRIC_PREFIX = child.values[0] elif child.key == 'SSL_CERT': SSL_CERT = child.values[0] elif child.key == 'SSL_KEY': SSL_KEY = child.values[0] elif child.key == 'SSL_CACERT': SSL_CACERT = child.values[0] if SSL_KEY is not None: connection = amqp.Connection( host = AMQP_HOST, ssl = { 'ca_certs': SSL_CACERT, 'keyfile' : SSL_KEY, 'certfile': SSL_CERT, 'cert_reqs': ssl.CERT_REQUIRED }) else: connection = amqp.Connection(host=AMQP_HOST) channel = connection.channel() channel.exchange_declare(AMQP_EXCHANGE, type='topic', durable=True, auto_delete=False) collectd.register_write(amqp_write)
def config(cfg): # Handle legacy config (not multiple-endpoint capable) if not any([n.key == 'Endpoint' for n in cfg.children]): # Create fake intermediary Endpoint node cfg.children = (collectd.Config('Endpoint', cfg, ('default', ), cfg.children), ) endpoints = [] for node in cfg.children: if node.key == 'Endpoint': endpoint = WriteWarp10.config_endpoint(node) if endpoint: if any(e['name'] == endpoint['name'] for e in endpoints): collectd.warning('write_warp10 plugin: Duplicate ' 'endpoint: %s' % endpoint['name']) else: endpoints.append(endpoint) else: collectd.warning('write_warp10 plugin: Unknown config key: ' '%s' % node.key) if endpoints: for e in endpoints: ww10 = WriteWarp10(e['url'], e['token'], e['flush_interval'], e['flush_retry_interval'], e['buffer_size'], e['default_labels'], e['rewrite_rules'], e['rewrite_limit']) collectd.info('write_warp10 plugin: register init write and ' 'shutdown functions') collectd.register_init(ww10.init, name='write_warp10/%s' % e['name']) collectd.register_write(ww10.write, name='write_warp10/%s' % e['name']) collectd.register_shutdown(ww10.shutdown, name='write_warp10/%s' % e['name']) else: collectd.warning('write_warp10 plugin: No valid endpoints found')
def wallarm_init(self): for typedb_file in self.config['types_db']: try: self.wallarm_parse_types_file(typedb_file) except IOError as e: msg = "{0}: Unable to open TypesDB file '{1}': {2}.".format( self.plugin_name, typedb_file, str(e) ) self.log('warning', msg) if not len(self.types): msg = ( "{0}: Didn't find any valid type in TypesDB files: {1}".format( self.plugin_name, self.config['types_db'], ) ) self.log('error', msg) raise ValueError(msg) self.last_try_time = self.get_time() self.last_flush_time = self.get_time() self.main_queue = Queue.Queue() self.send_queue = [] self.measr_avg_size = self.config['measr_avg_size'] self.update_queue_size() self.shutdown_event = threading.Event() self.send_lock = threading.Lock() self.send_thread = threading.Thread(target=self.send_watchdog) self.send_thread.start() collectd.register_write(self.wallarm_write) collectd.register_shutdown(self.shutdown_callback)
def writer_init(): global sandbox, debug, apikey, secretkey, monitors # last values and timestamps must be shared across collectd threads # collectd will pass this shared object into write on all calls # all accessess to this data should be protected by threading.Lock shared_data = {'monitors': dict(), 'lock': threading.Lock()} if sandbox: Monitis.sandbox = True os.environ['MONITIS_SANDBOX_APIKEY'] = apikey os.environ['MONITIS_SANDBOX_SECRETKEY'] = secretkey else: Monitis.sandbox = False os.environ['MONITIS_APIKEY'] = apikey os.environ['MONITIS_SECRETKEY'] = secretkey if debug: Monitis.debug = True else: Monitis.debug = False for monitor_name in monitors.keys(): monitors[monitor_name]['monitis'] = CustomMonitor.fetch( monitor_id=monitors[monitor_name]['id']) # hold lock while initializing shared_data with shared_data['lock']: for monitor_name in monitors.keys(): shared_data['monitors'][monitor_name] = { 'last_value': None, 'last_time': None } collectd.register_write(write, data=shared_data)
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)
"""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)
upload_thread = UploadThread() upload_thread.daemon = True upload_thread.start() collectd.info('cloudhealth - plugin configured successfully') def write_func(values): perf_data_mapping = {'memory': MEMORY} type_filter = {'memory': ['percent']} type_instance_filter = {'memory': ['used']} if not (CONFIG.get('token') and REGION_NAME and AWS_ACCOUNT_ID and INSTANCE_ID): collectd.warning('cloudhealth - plugin not configured properly') return if values.plugin not in perf_data_mapping.keys(): return if values.type in type_filter.get(values.plugin, []): if values.type_instance in type_instance_filter.get(values.plugin, []): update_min(perf_data_mapping[values.plugin], values.plugin, values.type, values.type_instance, values.values[0]) update_max(perf_data_mapping[values.plugin], values.plugin, values.type, values.type_instance, values.values[0]) update_avg(perf_data_mapping[values.plugin], values.plugin, values.type, values.type_instance, values.values[0]) update_values(perf_data_mapping[values.plugin]) if __name__ != '__main__': collectd.register_config(config_func) collectd.register_write(write_func)
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:
def notify(self, n): """Collectd notification callback""" # type='gauge',type_instance='link_status',plugin='ovs_events',plugin_instance='br0', # host='silv-vmytnyk-nos.ir.intel.com',time=1476441572.7450583,severity=4, # message='link state of "br0" interface has been changed to "UP"') collectd_event_severity_map = { collectd.NOTIF_FAILURE : 'CRITICAL', collectd.NOTIF_WARNING : 'WARNING', collectd.NOTIF_OKAY : 'NORMAL' } fault = Fault(self.get_event_id()) fault.event_severity = collectd_event_severity_map[n.severity] fault.specific_problem = '{}-{}'.format(n.plugin_instance, n.type_instance) fault.alarm_condition = n.message self.event_send(fault) def shutdown(self): """Collectd shutdown callback""" # stop the timer self.stop_timer() # The collectd plugin instance plugin_instance = VESPlugin() # Register plugin callbacks collectd.register_config(plugin_instance.config) collectd.register_init(plugin_instance.init) collectd.register_write(plugin_instance.write) collectd.register_notification(plugin_instance.notify) collectd.register_shutdown(plugin_instance.shutdown)
def plugin_config(conf): """ :param conf: https://collectd.org/documentation/manpages/collectd-python.5.shtml #config Parse the config object for config parameters """ global POST_URLS for kv in conf.children: if kv.key == 'ProcessInfo': global PROCESS_INFO PROCESS_INFO = kv.values[0] elif kv.key == 'Datapoints': global DATAPOINTS DATAPOINTS = kv.values[0] elif kv.key == 'Utilization': global UTILIZATION UTILIZATION = kv.values[0] elif kv.key == 'PerCoreCPUUtil': global PERCORECPUUTIL PERCORECPUUTIL = kv.values[0] elif kv.key == 'OverallCPUUtil': global OVERALLCPUUTIL OVERALLCPUUTIL = kv.values[0] elif kv.key == 'Verbose': global DEBUG DEBUG = kv.values[0] log('setting verbose to %s' % DEBUG) elif kv.key == 'URL': POST_URLS.extend(kv.values) elif kv.key == 'Token': global API_TOKEN API_TOKENS.extend(kv.values) elif kv.key == 'Timeout': global TIMEOUT TIMEOUT = int(kv.values[0]) elif kv.key == 'Interval': global INTERVAL INTERVAL = int(kv.values[0]) elif kv.key == 'NotifyLevel': global NOTIFY_LEVEL if string.lower(kv.values[0]) == "okay": NOTIFY_LEVEL = 4 elif string.lower(kv.values[0]) == "warning": NOTIFY_LEVEL = 2 elif string.lower(kv.values[0]) == "failure": NOTIFY_LEVEL = 1 elif kv.key == 'EtcPath': global ETC_PATH ETC_PATH = kv.values[0].rstrip(os.pathsep).rstrip(os.sep) debug("Setting etc path to %s for os release detection" % ETC_PATH) elif kv.key == 'PersistencePath': global PERSISTENCE_PATH PERSISTENCE_PATH = kv.values[0] load_persistent_data() if not POST_URLS: POST_URLS = [DEFAULT_POST_URL] if API_TOKENS and len(POST_URLS) != len(API_TOKENS): log("You have specified a different number of Tokens than URLs, " "please fix this") sys.exit(0) collectd.register_write(write) if UTILIZATION: collectd.register_read(UTILIZATION_INSTANCE.read, 1, name="utilization_reads") if OVERALLCPUUTIL is not True: log("Overall cpu utilization has been disabled via configuration") if PERCORECPUUTIL is True: log("Cpu utilization per core has been enabled via configuration") collectd.register_read(send, INTERVAL) get_aws_info()
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)
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()
if [vl.plugin,vl.type,vl.plugin_instance,vl.type_instance] in d[vl.host]: pass else: # add service d[vl.host].append([vl.plugin,vl.type,vl.plugin_instance,vl.type_instance]) pluginname = vl.plugin + "/" + vl.type if len(vl.plugin_instance) != 0: pluginname = vl.plugin + "-" + vl.plugin_instance + "/" + vl.type if len(vl.type_instance) != 0: pluginname = pluginname + "-" + vl.type_instance sendCommand("-o SERVICE -a add -v \""+vl.host+";"+pluginname+";generic-service\"") sendCommand("-o SERVICE -a setparam -v \""+vl.host+";"+pluginname+";command;check_collectd\"") sendCommand("-o SERVICE -a setparam -v \""+vl.host+";"+pluginname+";normal_check_interval;1\"") sendCommand("-o SERVICE -a setparam -v \""+vl.host+";"+pluginname+";retry_check_interval;5\"") sendCommand("-o SERVICE -a setparam -v \""+vl.host+";"+pluginname+";check_period;24x7\"") sendCommand("-o SERVICE -a setparam -v \""+vl.host+";"+pluginname+";max_check_attempts;5\"") sendCommand("-o SERVICE -a setparam -v \""+vl.host+";"+pluginname+";active_checks_enabled;1\"") sendCommand("-o SERVICE -a setparam -v \""+vl.host+";"+pluginname+";notif_period;24x7\"") sendCommand("-o SERVICE -a setparam -v \""+vl.host+";"+pluginname+";args;!"+pluginname+"!\"") sendCommand("-o SERVICE -a setcg -v \""+vl.host+";"+pluginname+";Supervisors\"") # Regenerates the centreon configuration #TODO: currently we flood the centreon regenerating each service that we add. sendCommand("-a POLLERGENERATE -v 1") sendCommand("-a CFGMOVE -v 1") sendCommand("-a POLLERRELOAD -v 1") collectd.register_init(init); collectd.register_write(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)
if len(append_names) != len(value.values): collectd.error("len(ds_names) != len(value.values)") return msg = "".join([ "%s %f %d host=%s%s\n" % (prefix + metric_name + postfix, metric_value, value.time, value.host, tags_append) for (postfix, metric_value) in zip(append_names, value.values) ]) try: CONFIG['queue'].put(msg, block=False) except Exception, e: collectd.error("Failed to message:" + str(e)) except Exception: collectd.error("Exception in write_callback: " + traceback.format_exc()) if 'collectd' in globals().keys(): collectd.register_config(configure_callback) collectd.register_write(write_callback) collectd.register_init(init_callback) else: print "Not running under collectd" import sys sys.exit(1)
try: tags_append = ' ' + CONFIG['tags_append'] except KeyError, e: tags_append = '' append_names = [ '.' + append_name if append_name != 'value' else '' for (append_name, _, _, _) in collectd.get_dataset(value.type) ] if len(append_names) != len(value.values): collectd.error("len(ds_names) != len(value.values)") return msg = "".join([ "%s %f %d host=%s%s\n" % (prefix + metric_name + postfix, metric_value, value.time, value.host, tags_append) for (postfix, metric_value) in zip(append_names, value.values) ]) try: CONFIG['queue'].put(msg, block=False) except Exception, e: collectd.error("Failed to message:" + str(e)) if 'collectd' in globals().keys(): collectd.register_config(configure_callback) collectd.register_write(write_callback) collectd.register_init(init_callback) else: print "Not running under collectd" import sys sys.exit(1)
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')
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')
""" This is for debugging. Use with `collectd -fC <CONF>`. """ import collectd import sys import re def cb_write(values): collectd.info('write_info: {}'.format(repr(values))) collectd.register_write(cb_write)
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)
def plugin_config(conf): """ :param conf: https://collectd.org/documentation/manpages/collectd-python.5.shtml #config Parse the config object for config parameters """ DOGSTATSD_INSTANCE.config.configure_callback(conf) global POST_URLS for kv in conf.children: if kv.key == 'Notifications': if kv.values[0]: global NOTIFICATIONS NOTIFICATIONS = kv.values[0] elif kv.key == 'ProcessInfo': global PROCESS_INFO PROCESS_INFO = kv.values[0] elif kv.key == 'Datapoints': global DATAPOINTS DATAPOINTS = kv.values[0] elif kv.key == 'Utilization': global UTILIZATION UTILIZATION = kv.values[0] elif kv.key == 'DPM': global DPM DPM = kv.values[0] elif kv.key == 'Verbose': global DEBUG DEBUG = kv.values[0] log('setting verbose to %s' % DEBUG) elif kv.key == 'URL': POST_URLS.extend(kv.values) elif kv.key == 'Token': global API_TOKEN API_TOKENS.extend(kv.values) elif kv.key == 'Timeout': global TIMEOUT TIMEOUT = int(kv.values[0]) elif kv.key == 'Interval': global INTERVAL INTERVAL = int(kv.values[0]) elif kv.key == 'NotifyLevel': global NOTIFY_LEVEL if string.lower(kv.values[0]) == "okay": NOTIFY_LEVEL = 4 elif string.lower(kv.values[0]) == "warning": NOTIFY_LEVEL = 2 elif string.lower(kv.values[0]) == "failure": NOTIFY_LEVEL = 1 if not POST_URLS: POST_URLS = [DEFAULT_POST_URL] if API_TOKENS and len(POST_URLS) != len(API_TOKENS): log("You have specified a different number of Tokens than URLs, " "please fix this") sys.exit(0) if NOTIFICATIONS: log("sending collectd notifications") collectd.register_notification(receive_notifications) else: collectd.register_notification(steal_host_from_notifications) collectd.register_write(write) if UTILIZATION: collectd.register_read(UTILIZATION_INSTANCE.read, 1, name="utilization_reads") collectd.register_read(send, INTERVAL) set_aws_url(get_aws_info())
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: