def get_ingestions(self, num=None, filter_opts=None): log.info('getting ingestion history') if num: chunk_size = num log.info('explicit number of results requested: %s', chunk_size) elif filter_opts: chunk_size = 10 log.info('filters detected, defaulting number of results to %s', chunk_size) else: chunk_size = 100 log.info('using catch all default result limit of %s', chunk_size) settings = {'chunkSize': chunk_size, 'currentPage': 1} if filter_opts is not None: if not isDict(filter_opts): code_error('passed non-dictionary for filter opts to get_ingestions') for key, value in sorted(filter_opts.items()): log.info("filter: '%s' = '%s'", key, value) settings = merge_dicts(settings, filter_opts) log.info('settings: %s', settings) log.info('querying Zaloni for ingestion history') (req, self.query_time) = self.req(url='{url_base}/ingestion/publish/getFileIndex' .format(url_base=self.url_base), # orders by newest first, but seems to return last 10 anyway body=json.dumps(settings)) try: log.info('parsing JSON response') json_dict = json.loads(req.content) except ValueError as _: qquit('UNKNOWN', 'error parsing json returned by Zaloni: {0}'.format(_)) return json_dict
def run(self): log.info('querying %s', self.software) url = '{protocol}://{host}:{port}/PolicyManagement/{api_version}/resources'\ .format(host=self.host, port=self.port, api_version=self.api_version, protocol=self.protocol) log.debug('GET %s', url) try: req = requests.get(url, auth=HTTPBasicAuth(self.user, self.password)) except requests.exceptions.RequestException as _: errhint = '' if 'BadStatusLine' in str(_.message): errhint = ' (possibly connecting to an SSL secured port without using --ssl?)' elif self.protocol == 'https' and 'unknown protocol' in str( _.message): errhint = ' (possibly connecting to a plain HTTP port with the -S / --ssl switch enabled?)' qquit('CRITICAL', str(_) + errhint) log.debug("response: %s %s", req.status_code, req.reason) log.debug("content:\n%s\n%s\n%s", '=' * 80, req.content.strip(), '=' * 80) if req.status_code != 200: qquit('CRITICAL', '{0}: {1}'.format(req.status_code, req.reason)) try: json_dict = json.loads(req.content) if log.isEnabledFor(logging.DEBUG): print(jsonpp(json_dict)) print('=' * 80) if not isDict(json_dict): raise ValueError( "non-dict returned by Blue Talon API (got type '{0}')". format(type(json_dict))) resource_domains_list = json_dict['resource_domains'] if not isList(resource_domains_list): raise ValueError("non-list returned for 'resource_domains' key by Blue Talon API (got type '{0}')"\ .format(type(resource_domains_list))) num_resource_domains = len(resource_domains_list) num_resources = 0 for resource_domain in resource_domains_list: resources = resource_domain['resources'] if not isList(resources): raise ValueError("non-list found for resources in resource_domain '{0}' (got type '{1}'"\ .format(resource_domain['resource_domain_name'], type(resources))) num_resources += len(resources) self.msg += '{num_resources} resources'.format( num_resources=num_resources) self.check_thresholds(num_resources) self.msg += ' across {num_resource_domains} resource domains'\ .format(num_resource_domains=num_resource_domains) self.msg += ' | num_resources={num_resources}{perf} num_resource_domains={num_resource_domains}'\ .format(num_resources=num_resources, num_resource_domains=num_resource_domains, perf=self.get_perf_thresholds()) except (KeyError, ValueError) as _: qquit('UNKNOWN', 'error parsing output from {software}: {exception}: {error}. {support_msg}'\ .format(software=self.software, exception=type(_).__name__, error=_, support_msg=support_msg_api()))
def run(self): content = self.get() try: json_dict = json.loads(content) if log.isEnabledFor(logging.DEBUG): print(jsonpp(json_dict)) print('=' * 80) if not isDict(json_dict): raise ValueError('returned content is not a dict') status = json_dict['status'] if status != 'success': qquit( 'CRITICAL', "request status = '{0}' (expected 'success')".format( status)) status_code = json_dict['statusCode'] if status_code != 200: qquit( 'CRITICAL', "request status code = '{0}' (expected '200')".format( status_code)) message = json_dict['message'] data = json_dict['data'] if not data: num_endpoints = 0 elif not isList(data): qquit('CRITICAL', 'non-list returned for policy end points data') else: num_endpoints = len(data) match = re.match( message, r'Total [(\d+)] policy engine end point\(s\) found', re.I) if not match: raise ValueError( 'failed to parse message for confirmation of number of endpoints' ) message_num_endpoints = int(match.group(1)) if num_endpoints != message_num_endpoints: raise ValueError( 'num endpoints does not match parsed value from returned message' ) except (KeyError, ValueError) as _: qquit('UNKNOWN', 'error parsing output from {software}: {exception}: {error}. {support_msg}'\ .format(software=self.software, exception=type(_).__name__, error=_, support_msg=support_msg_api())) self.msg = "{software} number of policy end points = {num_endpoints}"\ .format(software=self.software, num_endpoints=num_endpoints) self.check_thresholds(num_endpoints) self.msg += ' | num_endpoints={num_endpoints}'.format( num_endpoints=num_endpoints) + self.get_perf_thresholds()
def parse_results(self, content): try: json_dict = json.loads(content) if log.isEnabledFor(logging.DEBUG): print(jsonpp(content)) print('=' * 80) # looks like syshealthok child div is only there in browser, but give syshealthspin in code #if soup.find('div', id='syshealthstatus').find('div', id='syshealthok'): if not isDict(json_dict): raise ValueError("non-dict returned by Attivio AIE server response (type was '{0}')"\ .format(type(json_dict))) # if this is true from warnings would ruin the more appropriate warnings check #if json_dict['haserrors']: # self.critical() # self.msg += 'errors detected, ' nodes_down = json_dict['nodesdown'] warnings = json_dict['warnings'] fatals = json_dict['fatals'] acknowledged = json_dict['acknowledged'] if not isInt(nodes_down): raise ValueError( 'non-integer returned for nodes down count by Attivio AIE') if not isInt(warnings): raise ValueError( 'non-integer returned for warnings count by Attivio AIE') if not isInt(fatals): raise ValueError( 'non-integer returned for fatals count by Attivio AIE') if not isInt(acknowledged): raise ValueError( 'non-integer returned for acknowledged count by Attivio AIE' ) nodes_down = int(nodes_down) warnings = int(warnings) fatals = int(fatals) acknowledged = int(acknowledged) if nodes_down > 0 or fatals > 0: self.critical() elif warnings > 0: self.warning() self.msg += '{nodes_down} nodes down, {fatals} fatals, {warnings} warnings, {acknowledged} acknowledged'\ .format(nodes_down=nodes_down, fatals=fatals, warnings=warnings, acknowledged=acknowledged) if json_dict['perfmondown']: self.warning() self.msg += ', warning: performance monitoring down' self.msg += ' | nodes_down={nodes_down} fatals={fatals} warnings={warnings} acknowledged={acknowledged}'\ .format(nodes_down=nodes_down, fatals=fatals, warnings=warnings, acknowledged=acknowledged) except (KeyError, ValueError) as _: qquit('UNKNOWN', 'error parsing output from {software}: {exception}: {error}. {support_msg}'\ .format(software=self.software, exception=type(_).__name__, error=_, support_msg=support_msg_api()))
def check_table(self): log.info('checking table \'%s\'', self.table) is_enabled = None families = None try: is_enabled = self.conn.is_table_enabled(self.table) log.info('enabled: %s', is_enabled) table = self.conn.table(self.table) families = table.families() except HBaseIOError as _: #if 'org.apache.hadoop.hbase.TableNotFoundException' in _.message: if 'TableNotFoundException' in _.message: qquit('CRITICAL', 'table \'{0}\' does not exist'.format(self.table)) else: qquit('CRITICAL', _) except (socket.timeout, ThriftException) as _: qquit('CRITICAL', _) if log.isEnabledFor(logging.DEBUG): log.debug('column families:\n' + jsonpp(families)) if not families: qquit( 'CRITICAL', 'failed to get column families for table \'{0}\''.format( self.table)) if not isDict(families): qquit( 'UNKNOWN', 'column family info returned was not a dictionary! ' + support_msg_api()) num_families = len(families) log.info('num families: %s', num_families) self.msg = 'HBase table \'{0}\' is '.format(self.table) if is_enabled: self.msg += 'enabled, ' else: self.critical() self.msg += 'disabled! ' self.msg += '{0} column '.format(num_families) if num_families == 1: self.msg += 'family' else: self.msg += 'families' self.check_thresholds(num_families) self.msg += ' | num_column_families={0}'.format( num_families) + self.get_perf_thresholds(boundary='lower') log.info('finished, closing connection') self.conn.close()
def run(self): log.info('querying %s', self.software) url = '{protocol}://{host}:{port}/PolicyManagement/{api_version}/resources'\ .format(host=self.host, port=self.port, api_version=self.api_version, protocol=self.protocol) log.debug('GET %s', url) try: req = requests.get(url, auth=HTTPBasicAuth(self.user, self.password)) except requests.exceptions.RequestException as _: errhint = '' if 'BadStatusLine' in str(_.message): errhint = ' (possibly connecting to an SSL secured port without using --ssl?)' elif self.protocol == 'https' and 'unknown protocol' in str(_.message): errhint = ' (possibly connecting to a plain HTTP port with the -S / --ssl switch enabled?)' qquit('CRITICAL', str(_) + errhint) log.debug("response: %s %s", req.status_code, req.reason) log.debug("content:\n%s\n%s\n%s", '='*80, req.content.strip(), '='*80) if req.status_code != 200: qquit('CRITICAL', '{0}: {1}'.format(req.status_code, req.reason)) try: json_dict = json.loads(req.content) if log.isEnabledFor(logging.DEBUG): print(jsonpp(json_dict)) print('='*80) if not isDict(json_dict): raise ValueError("non-dict returned by Blue Talon API (got type '{0}')".format(type(json_dict))) resource_domains_list = json_dict['resource_domains'] if not isList(resource_domains_list): raise ValueError("non-list returned for 'resource_domains' key by Blue Talon API (got type '{0}')"\ .format(type(resource_domains_list))) num_resource_domains = len(resource_domains_list) num_resources = 0 for resource_domain in resource_domains_list: resources = resource_domain['resources'] if not isList(resources): raise ValueError("non-list found for resources in resource_domain '{0}' (got type '{1}'"\ .format(resource_domain['resource_domain_name'], type(resources))) num_resources += len(resources) self.msg += '{num_resources} resources'.format(num_resources=num_resources) self.check_thresholds(num_resources) self.msg += ' across {num_resource_domains} resource domains'\ .format(num_resource_domains=num_resource_domains) self.msg += ' | num_resources={num_resources}{perf} num_resource_domains={num_resource_domains}'\ .format(num_resources=num_resources, num_resource_domains=num_resource_domains, perf=self.get_perf_thresholds()) except (KeyError, ValueError) as _: qquit('UNKNOWN', 'error parsing output from {software}: {exception}: {error}. {support_msg}'\ .format(software=self.software, exception=type(_).__name__, error=_, support_msg=support_msg_api()))
def get_version(self): content = self.get() try: json_list = json.loads(content) if log.isEnabledFor(logging.DEBUG): print(jsonpp(json_list)) print('=' * 80) if not isList(json_list): raise ValueError( "non-list returned by API (is type '{0}')".format( type(json_list))) json_dict = json_list[0] if not isDict(json_dict): raise ValueError( "non-dict found inside returned list (is type '{0}')". format(type(json_dict))) company_name = json_dict['company_name'] company_website = json_dict['company_website'] regex = re.compile(r'Blue\s*Talon', re.I) if not regex.match(company_name) and \ not regex.match(company_website): qquit('UNKNOWN', 'Blue Talon name was not found in either company_name or company_website fields' \ + ', are you definitely querying a Blue Talon server?') build_version = json_dict['build_version'] update_date = json_dict['update_date'] api_version = json_dict['api_version'] if not isVersion(api_version): qquit('UNKNOWN', '{0} api version unrecognized \'{1}\'. {2}'\ .format(self.software, api_version, support_msg_api())) if api_version != self.api_version: qquit('UNKNOWN', "unexpected API version '{0}' returned (expected '{1}')"\ .format(api_version, self.api_version)) if self.verbose: extra_info = ' revision {revision} build {build}, schema revision = {schema_revision}'\ .format(revision=json_dict['revision_no'], build=json_dict['build_no'], schema_revision=json_dict['schema_revision']) extra_info += ', api version = {api_version}, update date = {update_date}'\ .format(api_version=api_version, update_date=update_date) else: extra_info = ', update date = {update_date}'.format( update_date=update_date) except (KeyError, ValueError) as _: qquit('UNKNOWN', 'error parsing output from {software}: {exception}: {error}. {support_msg}'\ .format(software=self.software, exception=type(_).__name__, error=_, support_msg=support_msg_api())) return (build_version, extra_info)
def parse_results(self, content): try: json_dict = json.loads(content) if log.isEnabledFor(logging.DEBUG): print(jsonpp(content)) print('='*80) # looks like syshealthok child div is only there in browser, but give syshealthspin in code #if soup.find('div', id='syshealthstatus').find('div', id='syshealthok'): if not isDict(json_dict): raise ValueError("non-dict returned by Attivio AIE server response (type was '{0}')"\ .format(type(json_dict))) # if this is true from warnings would ruin the more appropriate warnings check #if json_dict['haserrors']: # self.critical() # self.msg += 'errors detected, ' nodes_down = json_dict['nodesdown'] warnings = json_dict['warnings'] fatals = json_dict['fatals'] acknowledged = json_dict['acknowledged'] if not isInt(nodes_down): raise ValueError('non-integer returned for nodes down count by Attivio AIE') if not isInt(warnings): raise ValueError('non-integer returned for warnings count by Attivio AIE') if not isInt(fatals): raise ValueError('non-integer returned for fatals count by Attivio AIE') if not isInt(acknowledged): raise ValueError('non-integer returned for acknowledged count by Attivio AIE') nodes_down = int(nodes_down) warnings = int(warnings) fatals = int(fatals) acknowledged = int(acknowledged) if nodes_down > 0 or fatals > 0: self.critical() elif warnings > 0: self.warning() self.msg += '{nodes_down} nodes down, {fatals} fatals, {warnings} warnings, {acknowledged} acknowledged'\ .format(nodes_down=nodes_down, fatals=fatals, warnings=warnings, acknowledged=acknowledged) if json_dict['perfmondown']: self.warning() self.msg += ', warning: performance monitoring down' self.msg += ' | nodes_down={nodes_down} fatals={fatals} warnings={warnings} acknowledged={acknowledged}'\ .format(nodes_down=nodes_down, fatals=fatals, warnings=warnings, acknowledged=acknowledged) except (KeyError, ValueError) as _: qquit('UNKNOWN', 'error parsing output from {software}: {exception}: {error}. {support_msg}'\ .format(software=self.software, exception=type(_).__name__, error=_, support_msg=support_msg_api()))
def check_queue(self, json_data): if not isDict(json_data): raise UnknownError("non-dict passed to check_queue(), got type '{0}".format(type(json_data))) if json_data['name'] != self.queue: raise CriticalError("queue name returned '{0}' does not match expected queue '{1}'"\ .format(json_data['name'], self.queue)) self.msg += 'exists' state = json_data['state'] self.msg += ", state = '{0}'".format(state) if state != self.expected_queue_state: self.msg += " (expected '{0}')".format(self.expected_queue_state) queue_durable = str(json_data['durable']).lower() self.msg += ', durable = {0}'.format(queue_durable) if self.expected_durable and self.expected_durable != queue_durable: self.critical() self.msg += " (expected '{0}')".format(self.expected_durable)
def check_exchange(self, json_data): if not isDict(json_data): raise UnknownError("non-dict passed to check_exchange), got type '{0}".format(type(json_data))) if json_data['name'] != self.exchange: raise CriticalError("exchange name returned '{0}' does not match expected exchange '{1}'"\ .format(json_data['name'], self.exchange)) self.msg += 'exists' exchange_type = str(json_data['type']).lower() self.msg += ', type = {0}'.format(exchange_type) if self.expected_type and self.expected_type != exchange_type: self.critical() self.msg += " (expected '{0}')".format(self.expected_type) exchange_durable = str(json_data['durable']).lower() self.msg += ', durable = {0}'.format(exchange_durable) if self.expected_durable and self.expected_durable != exchange_durable: self.critical() self.msg += " (expected '{0}')".format(self.expected_durable)
def parse_json(self, json_data): if not isDict(json_data): raise UnknownError('non-dict returned for hot threads. {}'.format(support_msg_api())) hot_threads = json_data['hot_threads']['threads'] top_3 = self.get_opt('top_3') sum_percent = 0 last_percent = None for thread in hot_threads: thread_percent = thread['percent_of_cpu_time'] if last_percent is None: last_percent = thread_percent if thread_percent > last_percent: raise UnknownError('assertion failure - subsequent thread percent is unexpectedly higher' + \ ', out of expected order. {}'.format(support_msg_api())) sum_percent += thread_percent self.msg = 'Logstash ' if top_3: self.msg += 'top 3 hot threads cpu percentage = {}%'.format(sum_percent) self.check_thresholds(sum_percent) self.msg += ', ' # they come sorted with highest at top top_thread = hot_threads[0] name = top_thread['name'] percent = top_thread['percent_of_cpu_time'] state = top_thread['state'] # not available in 5.0, only later versions such as 6.0 #thread_id = top_thread['thread_id'] self.msg += 'top hot thread \'{}\' cpu percentage = {}%'.format(name, percent) if not top_3: self.check_thresholds(percent) self.msg += ', state = \'{}\''.format(state) #self.msg += ', id = {}'.format(state, thread_id) if self.verbose: if not isList(top_thread['traces']): raise UnknownError('hot thread\'s trace field is not a list. {}'.format(support_msg_api())) traces = '\\n'.join(top_thread['traces']) self.msg += ', traces: {}'.format(traces) if not top_3: self.msg += ', top 3 hot threads cpu percentage = {}%'.format(sum_percent) self.msg += ' | top_hot_thread_cpu_percentage={}%'.format(percent) if not top_3: self.msg += '{}'.format(self.get_perf_thresholds()) self.msg += ' top_three_hot_thread_cpu_percentage={}%'.format(sum_percent) if top_3: self.msg += '{}'.format(self.get_perf_thresholds())
def check_queue(self, json_data): if not isDict(json_data): raise UnknownError( "non-dict passed to check_queue(), got type '{0}".format( type(json_data))) if json_data['name'] != self.queue: raise CriticalError("queue name returned '{0}' does not match expected queue '{1}'"\ .format(json_data['name'], self.queue)) self.msg += 'exists' state = json_data['state'] self.msg += ", state = '{0}'".format(state) if state != self.expected_queue_state: self.msg += " (expected '{0}')".format(self.expected_queue_state) queue_durable = str(json_data['durable']).lower() self.msg += ', durable = {0}'.format(queue_durable) if self.expected_durable and self.expected_durable != queue_durable: self.critical() self.msg += " (expected '{0}')".format(self.expected_durable)
def check_table(self): log.info('checking table \'%s\'', self.table) is_enabled = None families = None try: is_enabled = self.conn.is_table_enabled(self.table) log.info('enabled: %s', is_enabled) table = self.conn.table(self.table) families = table.families() except HBaseIOError as _: #if 'org.apache.hadoop.hbase.TableNotFoundException' in _.message: if 'TableNotFoundException' in _.message: qquit('CRITICAL', 'table \'{0}\' does not exist'.format(self.table)) else: qquit('CRITICAL', _) except (socket.error, socket.timeout, ThriftException) as _: qquit('CRITICAL', _) if log.isEnabledFor(logging.DEBUG): log.debug('column families:\n%s', jsonpp(families)) if not families: qquit('CRITICAL', 'failed to get column families for table \'{0}\''.format(self.table)) if not isDict(families): qquit('UNKNOWN', 'column family info returned was not a dictionary! ' + support_msg_api()) num_families = len(families) log.info('num families: %s', num_families) self.msg = 'HBase table \'{0}\' is '.format(self.table) if is_enabled: self.msg += 'enabled, ' else: self.critical() self.msg += 'disabled! ' self.msg += '{0} column '.format(num_families) if num_families == 1: self.msg += 'family' else: self.msg += 'families' self.check_thresholds(num_families) self.msg += ' | num_column_families={0}'.format(num_families) + self.get_perf_thresholds(boundary='lower') log.info('finished, closing connection') self.conn.close()
def get_version(self): content = self.get() try: json_list = json.loads(content) if log.isEnabledFor(logging.DEBUG): print(jsonpp(json_list)) print('='*80) if not isList(json_list): raise ValueError("non-list returned by API (is type '{0}')".format(type(json_list))) json_dict = json_list[0] if not isDict(json_dict): raise ValueError("non-dict found inside returned list (is type '{0}')".format(type(json_dict))) company_name = json_dict['company_name'] company_website = json_dict['company_website'] regex = re.compile(r'Blue\s*Talon', re.I) if not regex.match(company_name) and \ not regex.match(company_website): qquit('UNKNOWN', 'Blue Talon name was not found in either company_name or company_website fields' \ + ', are you definitely querying a Blue Talon server?') build_version = json_dict['build_version'] update_date = json_dict['update_date'] api_version = json_dict['api_version'] if not isVersion(api_version): qquit('UNKNOWN', '{0} api version unrecognized \'{1}\'. {2}'\ .format(self.software, api_version, support_msg_api())) if api_version != self.api_version: qquit('UNKNOWN', "unexpected API version '{0}' returned (expected '{1}')"\ .format(api_version, self.api_version)) if self.verbose: extra_info = ' revision {revision} build {build}, schema revision = {schema_revision}'\ .format(revision=json_dict['revision_no'], build=json_dict['build_no'], schema_revision=json_dict['schema_revision']) extra_info += ', api version = {api_version}, update date = {update_date}'\ .format(api_version=api_version, update_date=update_date) else: extra_info = ', update date = {update_date}'.format(update_date=update_date) except (KeyError, ValueError) as _: qquit('UNKNOWN', 'error parsing output from {software}: {exception}: {error}. {support_msg}'\ .format(software=self.software, exception=type(_).__name__, error=_, support_msg=support_msg_api())) return (build_version, extra_info)
def parse_metrics(self, json_struct): if not isList(json_struct): raise ValueError("non-list returned by Attivio AIE Perfmon metrics API (got type '{0}')"\ .format(type(json_struct))) metrics = {} if not json_struct: qquit('UNKNOWN', "no matching metrics found for '{0}'".format(self.metrics) + \ ", use --list-metrics to check you've specified a correct metric") for item in json_struct: if not isDict(item): raise ValueError("non-dict item found in list returned by Attivio AIE Perfmon API (got type '{0}')"\ .format(type(item))) if not isList(item['values']): raise ValueError("non-list returned for metric value by Attivio AIE Perfmon API (got type '{0}')"\ .format(type(item['values']))) metric = item['metric'] log.info('metric = %s', metric) if self.skip_metric(item): log.info('skipping metric %s due to filters', metric) continue for key in ('nodeset', 'hostname', 'workflowType', 'workflow', 'component', 'path', 'networkInterface'): if key in item: val = item[key] log.info('%s = %s', key, val) # Attivio returns network interfaces in form "lo - 127.0.0.1" if key == 'networkInterface': val = val.split()[0] metric += '.{0}'.format(val) value = item['values'][0] log.info('value = %s\n', value) if self.precision and isFloat(value): # leaving as string will result in lots of trailing zeros value = float('{value:.{precision}f}'.format( value=value, precision=self.precision)) if metric in metrics: qquit('UNKNOWN', "duplicate metric '{metric}' discovered! {support_msg}"\ .format(metric=metric, support_msg=support_msg_api())) metrics[metric] = value return metrics
def run(self): content = self.get() try: json_dict = json.loads(content) if log.isEnabledFor(logging.DEBUG): print(jsonpp(json_dict)) print('='*80) if not isDict(json_dict): raise ValueError('returned content is not a dict') status = json_dict['status'] if status != 'success': qquit('CRITICAL', "request status = '{0}' (expected 'success')".format(status)) status_code = json_dict['statusCode'] if status_code != 200: qquit('CRITICAL', "request status code = '{0}' (expected '200')".format(status_code)) message = json_dict['message'] data = json_dict['data'] if not data: num_endpoints = 0 elif not isList(data): qquit('CRITICAL', 'non-list returned for policy end points data') else: num_endpoints = len(data) match = re.match(message, r'Total [(\d+)] policy engine end point\(s\) found', re.I) if not match: raise ValueError('failed to parse message for confirmation of number of endpoints') message_num_endpoints = int(match.group(1)) if num_endpoints != message_num_endpoints: raise ValueError('num endpoints does not match parsed value from returned message') except (KeyError, ValueError) as _: qquit('UNKNOWN', 'error parsing output from {software}: {exception}: {error}. {support_msg}'\ .format(software=self.software, exception=type(_).__name__, error=_, support_msg=support_msg_api())) self.msg = "{software} number of policy end points = {num_endpoints}"\ .format(software=self.software, num_endpoints=num_endpoints) self.check_thresholds(num_endpoints) self.msg += ' | num_endpoints={num_endpoints}'.format(num_endpoints=num_endpoints) + self.get_perf_thresholds()
def parse_metrics(self, json_struct): if not isList(json_struct): raise ValueError("non-list returned by Attivio AIE Perfmon metrics API (got type '{0}')"\ .format(type(json_struct))) metrics = {} if not json_struct: qquit('UNKNOWN', "no matching metrics found for '{0}'".format(self.metrics) + \ ", use --list-metrics to check you've specified a correct metric") for item in json_struct: if not isDict(item): raise ValueError("non-dict item found in list returned by Attivio AIE Perfmon API (got type '{0}')"\ .format(type(item))) if not isList(item['values']): raise ValueError("non-list returned for metric value by Attivio AIE Perfmon API (got type '{0}')"\ .format(type(item['values']))) metric = item['metric'] log.info('metric = %s', metric) if self.skip_metric(item): log.info('skipping metric %s due to filters', metric) continue for key in ('nodeset', 'hostname', 'workflowType', 'workflow', 'component', 'path', 'networkInterface'): if key in item: val = item[key] log.info('%s = %s', key, val) # Attivio returns network interfaces in form "lo - 127.0.0.1" if key == 'networkInterface': val = val.split()[0] metric += '.{0}'.format(val) value = item['values'][0] log.info('value = %s\n', value) if self.precision and isFloat(value): # leaving as string will result in lots of trailing zeros value = float('{value:.{precision}f}'.format(value=value, precision=self.precision)) if metric in metrics: qquit('UNKNOWN', "duplicate metric '{metric}' discovered! {support_msg}"\ .format(metric=metric, support_msg=support_msg_api())) metrics[metric] = value return metrics