def create_sddc_health_objects(self, vrops, target: str, token: str, inventory_config: dict): sddc_adapter_instances, self.response_codes[target]["sddc_health_adapter"] = \ Vrops.get_sddc_health_adapter_intance(vrops, target, token) if not sddc_adapter_instances: return False resourcekinds = [ rk for rk in inventory_config.get('resourcekinds', {}).get( 'sddc_resourcekinds', []) ] query_specs = inventory_config.get('query_specs', {}) sddc_objects, self.response_codes[target]["sddc_health_objects"] = \ Vrops.get_sddc_instances(vrops, target, token, parent_uuids=[s.uuid for s in sddc_adapter_instances], resourcekinds=resourcekinds, query_specs=query_specs) for sddc_adapter in sddc_adapter_instances: logger.debug(f'Collecting SDDC adapter: {sddc_adapter.name}') sddc_adapter.sddc_health_objects = list() for sddc_object in sddc_objects: if sddc_object.parent == sddc_adapter.uuid: logger.debug(f'Collecting SDDC object: {sddc_object.name}') sddc_adapter.sddc_health_objects.append(sddc_object) return sddc_adapter_instances
def collect(self): logger.info(f'{self.name} starts with collecting the metrics') token = self.get_target_tokens() token = token.setdefault(self.target, None) if not token: logger.warning(f'skipping {self.target} in {self.name}, no token') return gauges = self.generate_gauges('property', self.name, self.vrops_entity_name, [self.vrops_entity_name]) infos = self.generate_infos(self.name, self.vrops_entity_name, [self.vrops_entity_name]) states = self.generate_states(self.name, self.vrops_entity_name, [self.vrops_entity_name, 'state']) vc = self.get_vcenters(self.target) uuid = [vc[uuid]['uuid'] for uuid in vc][0] for metric_suffix in gauges: propkey = gauges[metric_suffix]['property'] metric_value = Vrops.get_property(self.target, token, uuid, propkey, self.name) if not metric_value: logging.warning(f'Skipping {propkey}, no value in respond') continue gauges[metric_suffix]['gauge'].add_metric( labels=[self.vcenters[uuid]['name']], value=metric_value) for metric_suffix in states: propkey = states[metric_suffix]['property'] value = Vrops.get_property(self.target, token, uuid, propkey, self.name) if not value: logging.warning(f'Skipping {propkey}, no value in respond') continue metric_value = (1 if states[metric_suffix]['expected'] == value else 0) states[metric_suffix]['state'].add_metric( labels=[self.vcenters[uuid]['name'], value], value=metric_value) for metric_suffix in infos: propkey = infos[metric_suffix]['property'] info_value = Vrops.get_property(self.target, token, uuid, propkey, self.name) if not info_value: logging.warning(f'Skipping {propkey}, no value in respond') continue infos[metric_suffix]['info'].add_metric( labels=[self.vcenters[uuid]['name']], value={metric_suffix: info_value}) for metric_suffix in gauges: yield gauges[metric_suffix]['gauge'] for metric_suffix in infos: yield infos[metric_suffix]['info'] for metric_suffix in states: yield states[metric_suffix]['state']
def add_host(self): vrops = Vrops() for hosts in vrops.get_hosts(target=self.target, token=self.token, parentid=self.uuid): self.hosts.append( Host(target=self.target, token=self.token, name=hosts['name'], uuid=hosts['uuid']))
def add_datastore(self): vrops = Vrops() for ds in vrops.get_datastores(target=self.target, token=self.token, parentid=self.uuid): self.datastores.append( Datastore(target=self.target, token=self.token, name=ds['name'], uuid=ds['uuid']))
def add_cluster(self): vrops = Vrops() for cluster in Vrops.get_cluster(vrops, target=self.target, token=self.token, parentid=self.uuid): self.clusters.append( Cluster(target=self.target, token=self.token, name=cluster['name'], uuid=cluster['uuid']))
def add_datacenter(self): vrops = Vrops() for dc in Vrops.get_datacenter(vrops, target=self.target, token=self.token, parentid=self.uuid): self.datacenter.append( Datacenter(target=self.target, token=self.token, name=dc['name'], uuid=dc['uuid']))
def add_vm(self): vrops = Vrops() for vm in Vrops.get_virtualmachines(vrops, target=self.target, token=self.token, parentid=self.uuid): self.vms.append( VirtualMachine(target=self.target, token=self.token, name=vm['name'], uuid=vm['uuid']))
def collect(self): gauges = self.generate_gauges('property', self.name, self.vrops_entity_name, [self.vrops_entity_name]) infos = self.generate_infos(self.name, self.vrops_entity_name, [self.vrops_entity_name]) states = self.generate_states(self.name, self.vrops_entity_name, [self.vrops_entity_name, 'state']) if os.environ['DEBUG'] >= '1': print(self.name, 'starts with collecting the metrics') token = self.get_target_tokens() token = token[self.target] if not token: print("skipping", self.target, "in", self.name, ", no token") vc = self.get_vcenters(self.target) uuid = [vc[uuid]['uuid'] for uuid in vc][0] for metric_suffix in gauges: propkey = gauges[metric_suffix]['property'] metric_value = Vrops.get_property(self.target, token, uuid, propkey) if not metric_value: continue gauges[metric_suffix]['gauge'].add_metric( labels=[self.vcenters[uuid]['name']], value=metric_value) for metric_suffix in states: propkey = states[metric_suffix]['property'] value = Vrops.get_property(self.target, token, uuid, propkey) if not value: continue metric_value = (1 if states[metric_suffix]['expected'] == value else 0) states[metric_suffix]['state'].add_metric( labels=[self.vcenters[uuid]['name'], value], value=metric_value) for metric_suffix in infos: propkey = infos[metric_suffix]['property'] info_value = Vrops.get_property(self.target, token, uuid, propkey) if not info_value: continue infos[metric_suffix]['info'].add_metric( labels=[self.vcenters[uuid]['name']], value={metric_suffix: info_value}) for metric_suffix in gauges: yield gauges[metric_suffix]['gauge'] for metric_suffix in infos: yield infos[metric_suffix]['info'] for metric_suffix in states: yield states[metric_suffix]['state']
def collect(self): gauges = self.generate_gauges('stats', self.name, self.vrops_entity_name, ['vcenter', 'vccluster', 'datacenter']) if not gauges: return if os.environ['DEBUG'] >= '1': print(self.name, 'starts with collecting the metrics') token = self.get_target_tokens() token = token[self.target] if not token: print("skipping " + self.target + " in " + self.name + ", no token") uuids = self.get_clusters_by_target() for metric_suffix in gauges: statkey = gauges[metric_suffix]['statkey'] values = Vrops.get_latest_stat_multiple(self.target, token, uuids, statkey) if not values: print("skipping statkey " + str(statkey) + " in", self.name, ", no return") continue for value_entry in values: metric_value = value_entry['stat-list']['stat'][0]['data'] if metric_value: metric_value = metric_value[0] cluster_id = value_entry['resourceId'] gauges[metric_suffix]['gauge'].add_metric( labels=[self.clusters[cluster_id]['vcenter'], self.clusters[cluster_id]['name'], self.clusters[cluster_id]['parent_dc_name'].lower()], value=metric_value) for metric_suffix in gauges: yield gauges[metric_suffix]['gauge']
def collect(self): logger.info(f'{self.name} starts with collecting the metrics') token = self.get_target_tokens() token = token.setdefault(self.target, None) if not token: logger.warning(f'skipping {self.target} in {self.name}, no token') return gauges = self.generate_gauges('stats', self.name, self.vrops_entity_name, [self.vrops_entity_name]) vc = self.get_vcenters(self.target) uuid = [vc[uuid]['uuid'] for uuid in vc][0] for metric_suffix in gauges: statkey = gauges[metric_suffix]['statkey'] values = Vrops.get_latest_stat(self.target, token, uuid, statkey, self.name) if not values: logger.warning( f'Skipping statkey: {statkey} in {self.name} , no return') continue metric_value = float(values) gauges[metric_suffix]['gauge'].add_metric( labels=[self.vcenters[uuid]['name']], value=metric_value) for metric_suffix in gauges: yield gauges[metric_suffix]['gauge']
def create_resource_objects(self, vrops, token): for adapter in Vrops.get_adapter(target=vrops, token=token): if os.environ['DEBUG'] >= '2': print("Collecting vcenter: " + adapter['name']) vcenter = Vcenter(target=vrops, token=token, name=adapter['name'], uuid=adapter['uuid']) vcenter.add_datacenter() for dc_object in vcenter.datacenter: if os.environ['DEBUG'] >= '2': print("Collecting Datacenter: " + dc_object.name) dc_object.add_cluster() for cl_object in dc_object.clusters: if os.environ['DEBUG'] >= '2': print("Collecting Cluster: " + cl_object.name) cl_object.add_host() for hs_object in cl_object.hosts: if os.environ['DEBUG'] >= '2': print("Collecting Host: " + hs_object.name) hs_object.add_datastore() for ds_object in hs_object.datastores: if os.environ['DEBUG'] >= '2': print("Collecting Datastore: " + ds_object.name) hs_object.add_vm() for vm_object in hs_object.vms: if os.environ['DEBUG'] >= '2': print("Collecting VM: " + vm_object.name) return vcenter
def collect(self): gauges = self.generate_gauges('stats', self.name, self.vrops_entity_name, [self.vrops_entity_name]) if os.environ['DEBUG'] >= '1': print(self.name, 'starts with collecting the metrics') token = self.get_target_tokens() token = token[self.target] if not token: print("skipping " + self.target + " in", self.name, ", no token") vc = self.get_vcenters(self.target) uuid = [vc[uuid]['uuid'] for uuid in vc][0] for metric_suffix in gauges: statkey = gauges[metric_suffix]['statkey'] values = Vrops.get_latest_stat(self.target, token, uuid, statkey) if not values: print("skipping statkey " + str(statkey) + " in", self.name, ", no return") continue metric_value = float(values) gauges[metric_suffix]['gauge'].add_metric( labels=[self.vcenters[uuid]['name']], value=metric_value) for metric_suffix in gauges: yield gauges[metric_suffix]['gauge']
def query_vrops(self, vrops): if os.environ['DEBUG'] >= '1': print("querying " + vrops) token = Vrops.get_token(target=vrops) if not token: return False self.target_tokens[vrops] = token vcenter = self.create_resource_objects(vrops, token) self.vcenter_dict[vrops] = vcenter return True
def collect(self): gauges = self.generate_gauges( 'stats', self.name, self.vrops_entity_name, [ self.vrops_entity_name, 'vcenter', 'datacenter', 'vccluster', 'hostsystem', 'project' ]) project_ids = self.get_project_ids_by_target() if os.environ['DEBUG'] >= '1': print(self.name, 'starts with collecting the metrics') token = self.get_target_tokens() token = token[self.target] if not token: print("skipping " + self.target + " in " + self.name + ", no token") uuids = self.get_vms_by_target() for metric_suffix in gauges: statkey = gauges[metric_suffix]['statkey'] values = Vrops.get_latest_stat_multiple(self.target, token, uuids, statkey) if os.environ['DEBUG'] >= '1': print(self.target, statkey) print("amount uuids", str(len(uuids))) print("fetched ", str(len(values))) if not values: print("skipping statkey " + str(statkey) + " in", self.name, ", no return") continue for value_entry in values: metric_value = value_entry['stat-list']['stat'][0]['data'] if metric_value: metric_value = metric_value[0] vm_id = value_entry['resourceId'] project_id = "internal" if project_ids: for vm_id_project_mapping in project_ids: if vm_id in vm_id_project_mapping: project_id = vm_id_project_mapping[vm_id] gauges[metric_suffix]['gauge'].add_metric( labels=[ self.vms[vm_id]['name'], self.vms[vm_id]['vcenter'], self.vms[vm_id]['datacenter'].lower(), self.vms[vm_id]['cluster'], self.vms[vm_id]['parent_host_name'], project_id ], value=metric_value) for metric_suffix in gauges: yield gauges[metric_suffix]['gauge']
def get_project_ids_by_target(self): try: token = self.get_target_tokens() token = token[self.target] uuids = self.get_vms_by_target() project_ids = Vrops.get_project_ids(self.target, token, uuids, self.collector) return project_ids except requests.exceptions.ConnectionError as e: logger.critical( f'No connection to inventory: {os.environ["INVENTORY"]} - Error: {e}' ) return []
def create_nsxt_objects(self, target: str, token: str): vrops = Vrops() nsxt_adapter = Vrops.get_nsxt_adapter(vrops, target, token) if not nsxt_adapter: return False nsxt_mgmt_plane = NSXTMgmtPlane(target, token) for adapter in nsxt_adapter: logger.debug(f'Collecting NSX-T adapter: {adapter.name}') nsxt_mgmt_plane.add_adapter(adapter) nsxt_mgmt_cluster = Vrops.get_nsxt_mgmt_cluster( vrops, target, token, [a.uuid for a in nsxt_adapter]) for adapter_object in nsxt_mgmt_plane.adapter: for mgmt_cluster in nsxt_mgmt_cluster: if mgmt_cluster.parent == adapter_object.uuid: adapter_object.add_mgmt_cluster(mgmt_cluster) logger.debug( f'Collecting NSX-T management cluster: {mgmt_cluster.name}' ) return nsxt_mgmt_plane
def create_vcops_objects(self, vrops, target: str, token: str, inventory_config: dict): vcops_adapter_instance, self.response_codes[target]["vcops_adapter"] = \ Vrops.get_vcenter_operations_adapter_intance(vrops, target, token) vcops_adapter_instance = vcops_adapter_instance[0] if not vcops_adapter_instance: logger.critical(f'Could not get vcops adapter!') return False resourcekinds = [ rk for rk in inventory_config.get('resourcekinds', {}).get( 'vcops_resourcekinds', []) ] query_specs = inventory_config.get('query_specs', {}) vcops_objects, self.response_codes[target]["vcops_self_monitoring_objects"] = \ Vrops.get_vcops_instances(vrops, target, token, parent_uuids=[vcops_adapter_instance.uuid], resourcekinds=resourcekinds, query_specs=query_specs) vcops_adapter_instance.vcops_objects = list() for vcops_object in vcops_objects: vcops_adapter_instance.vcops_objects.append(vcops_object) return vcops_adapter_instance
def query_vrops(self, vrops): logger.info(f'Querying {vrops}') token = Vrops.get_token(target=vrops) if not token: return False self.target_tokens[vrops] = token logger.info(f'##############################################') logger.info(f'########## Collecting resources... ##########') logger.info(f'##############################################') vcenter = self.create_resource_objects(vrops, token) self.vcenter_dict[vrops] = vcenter return True
def query_vrops(self, target, vrops_short_name, iteration): vrops = Vrops() logger.info(f'Querying {target}') token, self.response_codes[target]["token"] = Vrops.get_token( target=target) if not token: logger.warning( f'retrying connection to {target} in next iteration {self.iteration + 1}' ) return False self.target_tokens[target] = token logger.info( f'########## Collecting resources {vrops_short_name}... ##########' ) inventory_config = self.read_inventory_config() query_specs = inventory_config.get('query_specs', {}) vcenter = self.create_vcenter_objects(vrops, target, token, query_specs) nsxt_adapter = self.create_nsxt_objects(vrops, target, token, query_specs) vcops_adapter = self.create_vcops_objects(vrops, target, token, inventory_config) sddc_adapter = self.create_sddc_health_objects(vrops, target, token, inventory_config) self.vcenter_dict[target] = vcenter self.nsxt_dict[target] = nsxt_adapter self.vcops_dict[target] = vcops_adapter self.sddc_dict[target] = sddc_adapter if iteration == 1: self.alertdefinitions = Vrops.get_alertdefinitions( vrops, target, token) return True
def __init__(self): self.vrops_entity_name = 'base' while os.environ['TARGET'] not in self.get_target_tokens(): logger.critical('Cannot start exporter without valid target!') logger.critical( f'{os.environ["TARGET"]} is not in vrops_list from inventory') logger.critical( f'The following vrops are known from inventory: {[t for t in self.target_tokens]}, retrying in 60s' ) time.sleep(60) self.target = os.environ.get('TARGET') self.vrops = Vrops() self.name = self.__class__.__name__ self.label_names = [] self.project_ids = []
def query_vrops(self, vrops, vrops_short_name): logger.info(f'Querying {vrops}') token, self.response_codes[vrops] = Vrops.get_token(target=vrops) if not token: logger.warning(f'retrying connection to {vrops} in next iteration {self.iteration + 1}') return False self.target_tokens[vrops] = token logger.info(f'########## Collecting resources {vrops_short_name}... ##########') vcenter = self.create_resource_objects(vrops, token) if not vcenter: return False self.vcenter_dict[vrops] = vcenter return True
def collect(self): logger.info(f' {self.name} starts with collecting the metrics') token = self.get_target_tokens() token = token.setdefault(self.target, None) if not token: logger.warning(f'skipping {self.target} in {self.name}, no token') return if self.rubricated and not self.rubric: logger.warning(f'{self.name} has no rubric given. Considering all.') gauges = self.generate_gauges('stats', self.name, self.vrops_entity_name, [self.vrops_entity_name, 'vcenter', 'datacenter', 'vccluster', 'hostsystem', 'project'], rubric=self.rubric) project_ids = self.get_project_ids_by_target() uuids = self.get_vms_by_target() for metric_suffix in gauges: statkey = gauges[metric_suffix]['statkey'] values = Vrops.get_latest_stat_multiple(self.target, token, uuids, statkey, self.name) if not values: logger.warning(f'Skipping statkey: {statkey} in {self.name} , no return') continue for value_entry in values: metric_value = value_entry['stat-list']['stat'][0]['data'] if metric_value: metric_value = metric_value[0] vm_id = value_entry['resourceId'] project_id = "internal" if project_ids: for vm_id_project_mapping in project_ids: if vm_id in vm_id_project_mapping: project_id = vm_id_project_mapping[vm_id] gauges[metric_suffix]['gauge'].add_metric( labels=[self.vms[vm_id]['name'], self.vms[vm_id]['vcenter'], self.vms[vm_id]['datacenter'].lower(), self.vms[vm_id]['cluster'], self.vms[vm_id]['parent_host_name'], project_id], value=metric_value) for metric_suffix in gauges: yield gauges[metric_suffix]['gauge']
def collect(self): logger.info(f'{self.name} starts with collecting the metrics') token = self.get_target_tokens() token = token.setdefault(self.target, None) if not token: logger.warning(f'skipping {self.target} in {self.name}, no token') return gauges = self.generate_gauges( 'stats', self.name, self.vrops_entity_name, [ self.vrops_entity_name, 'type', 'vcenter', 'datacenter', 'vccluster', 'hostsystem' ]) uuids = self.get_datastores_by_target() for metric_suffix in gauges: statkey = gauges[metric_suffix]['statkey'] values = Vrops.get_latest_stat_multiple(self.target, token, uuids, statkey, self.name) if not values: logger.warning( f'Skipping statkey: {statkey} in {self.name} , no return') continue for value_entry in values: metric_value = value_entry['stat-list']['stat'][0]['data'] if metric_value: metric_value = metric_value[0] datastore_id = value_entry['resourceId'] gauges[metric_suffix]['gauge'].add_metric( labels=[ self.datastores[datastore_id]['name'], self.datastores[datastore_id]['type'], self.datastores[datastore_id]['vcenter'], self.datastores[datastore_id] ['datacenter'].lower(), self.datastores[datastore_id]['cluster'], self.datastores[datastore_id]['parent_host_name'] ], value=metric_value) for metric_suffix in gauges: yield gauges[metric_suffix]['gauge']
def create_vcenter_objects(self, target: str, token: str): vrops = Vrops() vcenter_adapter = Vrops.get_vcenter_adapter(vrops, target, token) if not vcenter_adapter: logger.critical(f'Could not get vcenter adapter!') return False logger.debug(f'Collecting vcenter: {vcenter_adapter.name}') datacenter = Vrops.get_datacenter(vrops, target, token, [vcenter_adapter.uuid]) cluster = Vrops.get_cluster(vrops, target, token, [dc.uuid for dc in datacenter]) datastores = Vrops.get_datastores(vrops, target, token, [dc.uuid for dc in datacenter]) hosts = Vrops.get_hosts(vrops, target, token, [cl.uuid for cl in cluster]) vms = Vrops.get_vms(vrops, target, token, [hs.uuid for hs in hosts], vcenter_adapter.uuid) for dc in datacenter: vcenter_adapter.add_datacenter(dc) for dc_object in vcenter_adapter.datacenter: logger.debug(f'Collecting datacenter: {dc_object.name}') for ds in datastores: if ds.parent == dc_object.uuid: dc_object.add_datastore(ds) logger.debug(f'Collecting datastore: {ds.name}') for cl in cluster: dc_object.add_cluster(cl) for cl_object in dc_object.clusters: logger.debug(f'Collecting cluster: {cl_object.name}') for hs in hosts: if hs.parent == cl_object.uuid: cl_object.add_host(hs) for hs_object in cl_object.hosts: logger.debug(f'Collecting host: {hs_object.name}') for vm in vms: if vm.parent == hs_object.uuid: hs_object.add_vm(vm) logger.debug(f'Collecting VM: {vm.name}') return vcenter_adapter
def create_resource_objects(self, vrops, token): for adapter in Vrops.get_adapter(target=vrops, token=token): logger.debug(f'Collecting vcenter: {adapter["name"]}') vcenter = Vcenter(target=vrops, token=token, name=adapter['name'], uuid=adapter['uuid']) vcenter.add_datacenter() for dc_object in vcenter.datacenter: logger.debug(f'Collecting datacenter: {dc_object.name}') dc_object.add_cluster() for cl_object in dc_object.clusters: logger.debug(f'Collecting cluster: {cl_object.name}') cl_object.add_host() for hs_object in cl_object.hosts: logger.debug(f'Collecting host: {hs_object.name}') hs_object.add_datastore() for ds_object in hs_object.datastores: logger.debug( f'Collecting datastore: {ds_object.name}') hs_object.add_vm() for vm_object in hs_object.vms: logger.debug(f'Collecting VM: {vm_object.name}') return vcenter
def create_resource_objects(self, target: str, token: str) -> Vcenter: vrops = Vrops() vcenter_name, vcenter_uuid = Vrops.get_adapter(vrops, target, token) if not vcenter_name: return False logger.debug(f'Collecting vcenter: {vcenter_name}') datacenter = Vrops.get_datacenter(vrops, target, token, [vcenter_uuid]) cluster_and_ds = Vrops.get_cluster_and_datastores(vrops, target, token, [dc.get('uuid') for dc in datacenter]) cluster = [cl for cl in cluster_and_ds if cl.get('resourcekind') == "ClusterComputeResource"] dss = [ds for ds in cluster_and_ds if ds.get('resourcekind') == "Datastore"] hosts = Vrops.get_hosts(vrops, target, token, [cl.get('uuid') for cl in cluster]) vms = Vrops.get_vms(vrops, target, token, [hs.get('uuid') for hs in hosts]) vcenter = Vcenter(target, token, vcenter_uuid, vcenter_name) for dc in datacenter: vcenter.add_datacenter(dc) for dc_object in vcenter.datacenter: logger.debug(f'Collecting datacenter: {dc_object.name}') for ds in dss: if ds.get('parent') == dc_object.uuid: dc_object.add_datastore(ds) logger.debug(f'Collecting Datastore: {ds.get("name")}') for cl in cluster: dc_object.add_cluster(cl) for cl_object in dc_object.clusters: logger.debug(f'Collecting cluster: {cl_object.name}') for hs in hosts: if hs.get('parent') == cl_object.uuid: cl_object.add_host(hs) for hs_object in cl_object.hosts: logger.debug(f'Collecting host: {hs_object.name}') for vm in vms: if vm.get('parent') == hs_object.uuid: hs_object.add_vm(vm) logger.debug(f'Collecting VM: {vm.get("name")}') return vcenter
def collect(self): logger.info(f'{self.name} starts with collecting the metrics') token = self.get_target_tokens() token = token.setdefault(self.target, None) if not token: logger.warning(f'skipping {self.target} in {self.name}, no token') return gauges = self.generate_gauges( 'property', self.name, self.vrops_entity_name, [self.vrops_entity_name, 'vcenter', 'datacenter', 'vccluster']) infos = self.generate_infos( self.name, self.vrops_entity_name, [self.vrops_entity_name, 'vcenter', 'datacenter', 'vccluster']) states = self.generate_states(self.name, self.vrops_entity_name, [ self.vrops_entity_name, 'vcenter', 'datacenter', 'vccluster', 'state' ]) uuids = self.get_hosts_by_target() for metric_suffix in gauges: propkey = gauges[metric_suffix]['property'] values = Vrops.get_latest_number_properties_multiple( self.target, token, uuids, propkey, self.name) if not values: logger.warning( f'Skipping property: {propkey} in {self.name} , no return') continue for value_entry in values: if 'data' not in value_entry: continue metric_value = value_entry['data'] host_id = value_entry['resourceId'] gauges[metric_suffix]['gauge'].add_metric(labels=[ self.hosts[host_id]['name'], self.hosts[host_id]['vcenter'], self.hosts[host_id]['datacenter'].lower(), self.hosts[host_id]['parent_cluster_name'] ], value=metric_value) for metric_suffix in states: propkey = states[metric_suffix]['property'] values = Vrops.get_latest_enum_properties_multiple( self.target, token, uuids, propkey, self.name) if not values: logger.warning( f'Skipping property: {propkey} in {self.name} , no return') continue for value_entry in values: if 'value' not in value_entry: continue metric_value = (1 if states[metric_suffix]['expected'] == value_entry['value'] else 0) host_id = value_entry['resourceId'] states[metric_suffix]['state'].add_metric(labels=[ self.hosts[host_id]['name'], self.hosts[host_id]['vcenter'], self.hosts[host_id]['datacenter'].lower(), self.hosts[host_id]['parent_cluster_name'], value_entry['value'] ], value=metric_value) for metric_suffix in infos: propkey = infos[metric_suffix]['property'] values = Vrops.get_latest_info_properties_multiple( self.target, token, uuids, propkey, self.name) if not values: logger.warning( f'Skipping property: {propkey} in {self.name} , no return') continue for value_entry in values: if 'data' not in value_entry: continue host_id = value_entry['resourceId'] info_value = value_entry['data'] infos[metric_suffix]['info'].add_metric( labels=[ self.hosts[host_id]['name'], self.hosts[host_id]['vcenter'], self.hosts[host_id]['datacenter'].lower(), self.hosts[host_id]['parent_cluster_name'] ], value={metric_suffix: info_value}) for metric_suffix in gauges: yield gauges[metric_suffix]['gauge'] for metric_suffix in infos: yield infos[metric_suffix]['info'] for metric_suffix in states: yield states[metric_suffix]['state']
def collect(self): gauges = self.generate_gauges('property', self.name, self.vrops_entity_name, [self.vrops_entity_name, 'vcenter', 'datacenter', 'vccluster', 'hostsystem', 'project']) infos = self.generate_infos(self.name, self.vrops_entity_name, [self.vrops_entity_name, 'vcenter', 'datacenter', 'vccluster', 'hostsystem', 'project']) states = self.generate_states(self.name, self.vrops_entity_name, [self.vrops_entity_name, 'vcenter', 'datacenter', 'vccluster', 'hostsystem', 'state', 'project']) project_ids = self.get_project_ids_by_target() if os.environ['DEBUG'] >= '1': print(self.name, 'starts with collecting the metrics') token = self.get_target_tokens() token = token[self.target] if not token: print("skipping", self.target, "in", self.name, ", no token") uuids = self.get_vms_by_target() for metric_suffix in gauges: propkey = gauges[metric_suffix]['property'] values = Vrops.get_latest_number_properties_multiple(self.target, token, uuids, propkey) if not values: continue for value_entry in values: if 'data' not in value_entry: continue metric_value = value_entry['data'] vm_id = value_entry['resourceId'] project_id = "internal" if project_ids: for vm_id_project_mapping in project_ids: if vm_id in vm_id_project_mapping: project_id = vm_id_project_mapping[vm_id] gauges[metric_suffix]['gauge'].add_metric( labels=[self.vms[vm_id]['name'], self.vms[vm_id]['vcenter'], self.vms[vm_id]['datacenter'].lower(), self.vms[vm_id]['cluster'], self.vms[vm_id]['parent_host_name'], project_id], value=metric_value) for metric_suffix in states: propkey = states[metric_suffix]['property'] values = Vrops.get_latest_enum_properties_multiple(self.target, token, uuids, propkey) if not values: continue for value_entry in values: if 'value' not in value_entry: continue data = (1 if states[metric_suffix]['expected'] == value_entry['value'] else 0) vm_id = value_entry['resourceId'] project_id = "internal" if project_ids: for vm_id_project_mapping in project_ids: if vm_id in vm_id_project_mapping: project_id = vm_id_project_mapping[vm_id] states[metric_suffix]['state'].add_metric( labels=[self.vms[vm_id]['name'], self.vms[vm_id]['vcenter'], self.vms[vm_id]['datacenter'].lower(), self.vms[vm_id]['cluster'], self.vms[vm_id]['parent_host_name'], value_entry['value'], project_id], value=data) for metric_suffix in infos: propkey = infos[metric_suffix]['property'] values = Vrops.get_latest_info_properties_multiple(self.target, token, uuids, propkey) if not values: continue for value_entry in values: if 'data' not in value_entry: continue vm_id = value_entry['resourceId'] project_id = "internal" if project_ids: for vm_id_project_mapping in project_ids: if vm_id in vm_id_project_mapping: project_id = vm_id_project_mapping[vm_id] info_value = value_entry['data'] infos[metric_suffix]['info'].add_metric( labels=[self.vms[vm_id]['name'], self.vms[vm_id]['vcenter'], self.vms[vm_id]['datacenter'].lower(), self.vms[vm_id]['cluster'], self.vms[vm_id]['parent_host_name'], project_id], value={metric_suffix: info_value}) for metric_suffix in gauges: yield gauges[metric_suffix]['gauge'] for metric_suffix in infos: yield infos[metric_suffix]['info'] for metric_suffix in states: yield states[metric_suffix]['state']
def get_project_ids_by_target(self): token = self.get_target_tokens() token = token[self.target] uuids = self.get_vms_by_target() project_ids = Vrops.get_project_ids(self.target, token, uuids) return project_ids
def collect(self): logger.info(f' {self.name} starts with collecting the metrics') token = self.get_target_tokens() token = token.setdefault(self.target, None) if not token: logger.warning(f'skipping {self.target} in {self.name}, no token') return gauges = self.generate_gauges('property', self.name, self.vrops_entity_name, [self.vrops_entity_name, 'vcenter', 'datacenter', 'vccluster', 'hostsystem', 'project']) infos = self.generate_infos(self.name, self.vrops_entity_name, [self.vrops_entity_name, 'vcenter', 'datacenter', 'vccluster', 'hostsystem', 'project']) states = self.generate_states(self.name, self.vrops_entity_name, [self.vrops_entity_name, 'vcenter', 'datacenter', 'vccluster', 'hostsystem', 'state', 'project']) project_ids = self.get_project_ids_by_target() uuids = self.get_vms_by_target() for metric_suffix in gauges: propkey = gauges[metric_suffix]['property'] values = Vrops.get_latest_number_properties_multiple(self.target, token, uuids, propkey, self.name) if not values: logging.warning(f'Skipping {propkey}, no values in respond') continue for value_entry in values: if 'data' not in value_entry: continue metric_value = value_entry['data'] vm_id = value_entry['resourceId'] project_id = "internal" if project_ids: for vm_id_project_mapping in project_ids: if vm_id in vm_id_project_mapping: project_id = vm_id_project_mapping[vm_id] gauges[metric_suffix]['gauge'].add_metric( labels=[self.vms[vm_id]['name'], self.vms[vm_id]['vcenter'], self.vms[vm_id]['datacenter'].lower(), self.vms[vm_id]['cluster'], self.vms[vm_id]['parent_host_name'], project_id], value=metric_value) for metric_suffix in states: propkey = states[metric_suffix]['property'] values = Vrops.get_latest_enum_properties_multiple(self.target, token, uuids, propkey, self.name) if not values: continue for value_entry in values: if 'value' not in value_entry: continue data = (1 if states[metric_suffix]['expected'] == value_entry['value'] else 0) vm_id = value_entry['resourceId'] project_id = "internal" if project_ids: for vm_id_project_mapping in project_ids: if vm_id in vm_id_project_mapping: project_id = vm_id_project_mapping[vm_id] states[metric_suffix]['state'].add_metric( labels=[self.vms[vm_id]['name'], self.vms[vm_id]['vcenter'], self.vms[vm_id]['datacenter'].lower(), self.vms[vm_id]['cluster'], self.vms[vm_id]['parent_host_name'], value_entry['value'], project_id], value=data) for metric_suffix in infos: propkey = infos[metric_suffix]['property'] values = Vrops.get_latest_info_properties_multiple(self.target, token, uuids, propkey, self.name) if not values: continue for value_entry in values: if 'data' not in value_entry: continue vm_id = value_entry['resourceId'] project_id = "internal" if project_ids: for vm_id_project_mapping in project_ids: if vm_id in vm_id_project_mapping: project_id = vm_id_project_mapping[vm_id] info_value = value_entry['data'] infos[metric_suffix]['info'].add_metric( labels=[self.vms[vm_id]['name'], self.vms[vm_id]['vcenter'], self.vms[vm_id]['datacenter'].lower(), self.vms[vm_id]['cluster'], self.vms[vm_id]['parent_host_name'], project_id], value={metric_suffix: info_value}) for metric_suffix in gauges: yield gauges[metric_suffix]['gauge'] for metric_suffix in infos: yield infos[metric_suffix]['info'] for metric_suffix in states: yield states[metric_suffix]['state']