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']