def _create_vertex(self, entity_event):
metadata = {
VProps.NAME: get_label(entity_event, PAlertLabels.ALERT_NAME),
VProps.SEVERITY: get_label(entity_event, PAlertLabels.SEVERITY),
PProps.STATUS: entity_event.get(PProps.STATUS),
}
return graph_utils.create_vertex(
self._create_entity_key(entity_event),
vitrage_category=ECategory.ALARM,
vitrage_type=entity_event[DSProps.ENTITY_TYPE],
vitrage_sample_timestamp=entity_event[DSProps.SAMPLE_DATE],
entity_state=self._get_alarm_state(entity_event),
update_timestamp=get_alarm_update_time(entity_event),
metadata=metadata)
def get_enrich_query(event):
LOG.debug('event for enrich query: %s', str(event))
hostname = get_label(event, PLabels.INSTANCE)
if not hostname:
return None
hostname = hostname[:hostname.index(':')]
return {VProps.ID: hostname}
def _create_entity_key(self, entity_event):
return tbase.build_key((ECategory.ALARM,
entity_event[DSProps.ENTITY_TYPE],
get_label(entity_event,
PAlertLabels.ALERT_NAME),
str(entity_event.get(
PDProps.ENTITY_UNIQUE_PROPS))))
def _get_resource_alert_values(self, alert):
"""Get values of the alert labels from alert's resource in config file.
For the example above. The function returns:
{u'instance': u'1.1.1.1:9999', u'domain': u'instance-00000004'}
"""
resource_alert_labels = self._get_conf_resource(alert).values()
alert_values = {label: get_label(alert, label)
for label in resource_alert_labels}
return alert_values
def _calculate_vitrage_entity_unique_props(self, alert):
"""Build a vitrage entity unique props.
The unique props are based on the alert and the conf file.
:param alert: Prometheus alert
:type alert: dict
:return: Unique properties of vitrage entity
":rtype: dict
For the example above. The function returns:
{u'instance_name': 'instance-00000004',
u'host_id': 'my-host-name'}
"""
resource_labels = self._get_conf_resource(alert)
vitrage_entity_unique_props = {}
for vitrage_label in resource_labels:
prometheus_label = resource_labels[vitrage_label]
label_value = str(get_label(alert, prometheus_label))
vitrage_entity_unique_props[vitrage_label] = \
self._adjust_label_value(label_value)
return vitrage_entity_unique_props
def _create_entity_key(self, entity_event):
return tbase.build_key(
(ECategory.ALARM, entity_event[DSProps.ENTITY_TYPE],
get_label(entity_event, PLabels.ALERT_NAME),
get_label(entity_event, PLabels.INSTANCE)))
def _alarm_key(self, alert):
return self.AlarmKey(alertname=get_label(alert,
PAlertLabels.ALERT_NAME),
resource=str(
self._get_resource_alert_values(alert)))
def _alarm_key(self, alarm):
return self.AlarmKey(alert_name=get_label(alarm, PLabels.ALERT_NAME),
instance=str(get_label(alarm, PLabels.INSTANCE)))
def _validate_vertex_props(self, vertex, event):
self._validate_alarm_vertex_props(vertex,
get_label(event, PLabels.ALERT_NAME),
PROMETHEUS_DATASOURCE,
event[DSProps.SAMPLE_DATE])
def enrich_event(self, event, event_type):
"""Get an event from Prometheus and create a list of alarm events
:param event: dictionary of this form:
{
"details":
{
"status": "firing",
"groupLabels": {
"alertname": "HighInodeUsage"
},
"groupKey": "{}:{alertname=\"HighInodeUsage\"}",
"commonAnnotations": {
"mount_point": "/%",
"description": "\"Consider ssh\"ing into instance \"\n",
"title": "High number of inode usage",
"value": "96.81%",
"device": "/dev/vda1%",
"runbook": "troubleshooting/filesystem_alerts_inodes.md"
},
"alerts": [
{
"status": "firing",
"labels": {
"severity": "critical",
"fstype": "ext4",
"instance": "localhost:9100",
"job": "node",
"alertname": "HighInodeUsage",
"device": "/dev/vda1",
"mountpoint": "/"
},
"endsAt": "0001-01-01T00:00:00Z",
"generatorURL": "http://devstack-4:9090/graph?g0.htm1",
"startsAt": "2018-05-03T12:25:38.231388525Z",
"annotations": {
"mount_point": "/%",
"description": "\"Consider ssh\"ing into instance\"\n",
"title": "High number of inode usage",
"value": "96.81%",
"device": "/dev/vda1%",
"runbook": "filesystem_alerts_inodes.md"
}
}
],
"version": "4",
"receiver": "vitrage",
"externalURL": "http://devstack-rocky-4:9093",
"commonLabels": {
"severity": "critical",
"fstype": "ext4",
"instance": "localhost:9100",
"job": "node",
"alertname": "HighInodeUsage",
"device": "/dev/vda1",
"mountpoint": "/"
}
}
}
:param event_type: The type of the event. Always 'prometheus.alarm'.
:return: a list of events, one per Prometheus alert
"""
LOG.debug('Going to enrich event: %s', str(event))
alarms = []
details = event.get(EProps.DETAILS)
if details:
for alarm in details.get(PProps.ALERTS, []):
alarm[DSProps.EVENT_TYPE] = event_type
alarm[PProps.STATUS] = details[PProps.STATUS]
instance_id = get_label(alarm, PLabels.INSTANCE)
if ':' in instance_id:
instance_id = instance_id[:instance_id.index(':')]
# The 'instance' label can be instance ip or hostname.
# we try to fetch the instance id from nova by its ip,
# and if not found we leave it as it is.
nova_instance = self.nova_client.servers.list(
search_opts={'all_tenants': 1, 'ip': instance_id})
if nova_instance:
instance_id = nova_instance[0].id
alarm[PLabels.INSTANCE_ID] = instance_id
old_alarm = self._old_alarm(alarm)
alarm = self._filter_and_cache_alarm(
alarm, old_alarm,
self._filter_get_erroneous,
get_alarm_update_time(alarm))
if alarm:
alarms.append(alarm)
LOG.debug('Enriched event. Created alarm events: %s', str(alarms))
return self.make_pickleable(alarms, PROMETHEUS_DATASOURCE,
DatasourceAction.UPDATE)