def test_list_alarm_definitions_multiple_sort_by(self): key = data_utils.rand_name('key') value = data_utils.rand_name('value') expression = 'avg(cpu_utilization{' + str(key) + '=' + str(value) + \ '}) >= 1000' alarm_definitions = [ helpers.create_alarm_definition(name='alarm def sort by 11', expression=expression, severity='MEDIUM'), helpers.create_alarm_definition(name='alarm def sort by 14', expression=expression, severity='MEDIUM'), helpers.create_alarm_definition(name='alarm def sort by 12', expression=expression, severity='LOW'), helpers.create_alarm_definition(name='alarm def sort by 13', expression=expression, severity='MEDIUM') ] for definition in alarm_definitions: resp, response_body = self.monasca_client.create_alarm_definitions( definition) definition['id'] = response_body['id'] resp, response_body = self.monasca_client.list_alarm_definitions( '?dimensions=' + str(key) + ':' + str(value) + '&sort_by=' + urlparse.quote('severity asc,name desc,id')) self.assertEqual(200, resp.status) expected_order = [2, 1, 3, 0] for i, element in enumerate(response_body['elements']): self.assertEqual(alarm_definitions[expected_order[i]]['id'], element['id'])
def test_list_alarm_definitions_with_severity(self): name = data_utils.rand_name('alarm_definition') expression = 'avg(cpu_utilization) >= 1000' alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, severity="LOW") resp, res_body_create_alarm_def = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) name = data_utils.rand_name('alarm_definition') expression = 'avg(cpu_utilization) >= 1000' alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, severity="MEDIUM") resp, res_body_create_alarm_def = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) query_param = '?severity=MEDIUM' resp, response_body = self.monasca_client.\ list_alarm_definitions(query_param) self._verify_list_alarm_definitions_response_body(resp, response_body) elements = response_body['elements'] self._verify_list_get_alarm_definitions_elements( elements, 1, res_body_create_alarm_def) links = response_body['links'] self._verify_list_alarm_definitions_links(links)
def test_list_alarm_definitions_with_severity(self): name = data_utils.rand_name('alarm_definition') expression = 'avg(cpu_utilization) >= 1000' alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, severity="LOW") resp, res_body_create_alarm_def = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) name = data_utils.rand_name('alarm_definition') expression = 'avg(cpu_utilization) >= 1000' alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, severity="MEDIUM") resp, res_body_create_alarm_def = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) query_param = '?severity=MEDIUM' resp, response_body = self.monasca_client.\ list_alarm_definitions(query_param) self._verify_list_alarm_definitions_response_body(resp, response_body) elements = response_body['elements'] self._verify_list_get_alarm_definitions_elements( elements, 1, res_body_create_alarm_def) links = response_body['links'] self._verify_list_alarm_definitions_links(links)
def test_list_alarms_by_severity(self): metric_name = data_utils.rand_name("severity-metric") alarm_defs = [] alarm_defs.append(helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='LOW' )) alarm_defs.append(helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='MEDIUM' )) alarm_defs.append(helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='HIGH' )) alarm_defs.append(helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='CRITICAL' )) alarm_def_ids = [] for definition in alarm_defs: resp, response_body = self.monasca_client.create_alarm_definitions(definition) self.assertEqual(201, resp.status) alarm_def_ids.append(response_body['id']) metric = helpers.create_metric(name=metric_name, value=14) resp, response_body = self.monasca_client.create_metrics(metric) self.assertEqual(204, resp.status) for def_id in alarm_def_ids: self._wait_for_alarms(1, def_id) query_parms = '?severity=LOW' resp, response_body = self.monasca_client.list_alarms(query_parms) self.assertEqual(200, resp.status) for alarm in response_body['elements']: self.assertEqual('LOW', alarm['alarm_definition']['severity']) query_parms = '?severity=HIGH' resp, response_body = self.monasca_client.list_alarms(query_parms) self.assertEqual(200, resp.status) for alarm in response_body['elements']: self.assertEqual('HIGH', alarm['alarm_definition']['severity']) query_parms = '?severity=CRITICAL' resp, response_body = self.monasca_client.list_alarms(query_parms) self.assertEqual(200, resp.status) for alarm in response_body['elements']: self.assertEqual('CRITICAL', alarm['alarm_definition']['severity'])
def test_list_alarms_by_severity(self): metric_name = data_utils.rand_name("severity-metric") alarm_defs = [] alarm_defs.append( helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='LOW')) alarm_defs.append( helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='MEDIUM')) alarm_defs.append( helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='HIGH')) alarm_defs.append( helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='CRITICAL')) alarm_def_ids = [] for definition in alarm_defs: resp, response_body = self.monasca_client.create_alarm_definitions( definition) self.assertEqual(201, resp.status) alarm_def_ids.append(response_body['id']) metric = helpers.create_metric(name=metric_name, value=14) resp, response_body = self.monasca_client.create_metrics(metric) self.assertEqual(204, resp.status) for def_id in alarm_def_ids: self._wait_for_alarms(1, def_id) query_parms = '?severity=LOW' resp, response_body = self.monasca_client.list_alarms(query_parms) self.assertEqual(200, resp.status) for alarm in response_body['elements']: self.assertEqual('LOW', alarm['alarm_definition']['severity']) query_parms = '?severity=HIGH' resp, response_body = self.monasca_client.list_alarms(query_parms) self.assertEqual(200, resp.status) for alarm in response_body['elements']: self.assertEqual('HIGH', alarm['alarm_definition']['severity']) query_parms = '?severity=CRITICAL' resp, response_body = self.monasca_client.list_alarms(query_parms) self.assertEqual(200, resp.status) for alarm in response_body['elements']: self.assertEqual('CRITICAL', alarm['alarm_definition']['severity'])
def resource_setup(cls): super(TestAlarmsStateHistory, cls).resource_setup() start_timestamp = int(time.time() * 1000) end_timestamp = int(time.time() * 1000) + 1000 # create an alarm definition expression = "avg(name-1) > 0" name = data_utils.rand_name('alarm_definition') alarm_definition = helpers.create_alarm_definition( name=name, expression=expression) resp, response_body = cls.monasca_client.create_alarm_definitions( alarm_definition) # create another alarm definition name1 = data_utils.rand_name('alarm_definition1') expression1 = "max(cpu.system_perc) > 0" alarm_definition1 = helpers.create_alarm_definition( name=name1, expression=expression1) resp, response_body1 = cls.monasca_client.create_alarm_definitions( alarm_definition1) # create another alarm definition name2 = data_utils.rand_name('alarm_definition2') expression1 = "avg(mysql.performance.slow_queries) > 10.0" alarm_definition2 = helpers.create_alarm_definition( name=name2, expression=expression1) resp, response_body2 = cls.monasca_client.create_alarm_definitions( alarm_definition2) # create some metrics for i in xrange(180): metric = helpers.create_metric() resp, body = cls.monasca_client.create_metrics(metric) cls._start_timestamp = start_timestamp + i cls._end_timestamp = end_timestamp + i time.sleep(1) resp, response_body = cls.monasca_client.\ list_alarms_state_history() elements = response_body['elements'] if len(elements) > 4: break if len(elements) < 3: cls.assertEqual(1, False)
def test_create_alarm_definition_with_special_chars_in_expression(self): notification_name = data_utils.rand_name("notification-") notification_type = "EMAIL" address = "root@localhost" resp, response_body = self.monasca_client.create_notification_method( notification_name, type=notification_type, address=address ) notification_id = self._verify_create_notification_method( resp, response_body, notification_name, notification_type, address ) # Create an alarm definition alarm_def_name = data_utils.rand_name("monitoring_alarm") alarm_definition = helpers.create_alarm_definition( name=alarm_def_name, expression="avg(mem_total_mb{dev=\usr\local\bin}) " "gt 0", alarm_actions=[notification_id], ok_actions=[notification_id], undetermined_actions=[notification_id], severity="LOW", ) self.assertRaises( exceptions.UnprocessableEntity, self.monasca_client.create_alarm_definitions, alarm_definition )
def test_alarm_max_function(self): metric_def = { 'name': data_utils.rand_name("max_test"), 'dimensions': { 'dim_to_match': data_utils.rand_name("max_match") } } expression = "max(" + metric_def['name'] + ") > 14" definition = helpers.create_alarm_definition(name="Test Max Function", description="", expression=expression, match_by=["dim_to_match"]) resp, resp_body = (self.monasca_client .create_alarm_definitions(definition)) self.assertEqual(201, resp.status) definition_id = resp_body['id'] time.sleep(1) self._send_measurement(metric_def, 1) alarm_id, initial_state = self._wait_for_alarm_creation(definition_id) self.assertEqual("UNDETERMINED", initial_state) self._send_measurement(metric_def, 20) self._wait_for_alarm_transition(alarm_id, "ALARM")
def resource_setup(cls): super(TestAlarmsStateHistoryOneTransition, cls).resource_setup() for i in range(MIN_HISTORY): alarm_definition = helpers.create_alarm_definition( name=data_utils.rand_name('alarm_state_history' + str(i + 1)), expression="min(name-" + str(i + 1) + ") < " + str(i + 1)) cls.monasca_client.create_alarm_definitions(alarm_definition) # Ensure the new Alarm Definitions get to the Threshold Engine time.sleep(constants.ALARM_DEFINITION_CREATION_WAIT) num_transitions = 0 for timer in range(constants.MAX_RETRIES): for i in range(MIN_HISTORY): # Create some metrics to prime the system and waiting for the # alarms to be created and then for them to change state. # MIN_HISTORY number of Alarms State History are needed. metric = helpers.create_metric(name="name-" + str(i + 1)) cls.monasca_client.create_metrics(metric) # Ensure alarms transition at different times time.sleep(0.1) resp, response_body = cls.monasca_client.\ list_alarms_state_history() elements = response_body['elements'] if len(elements) >= MIN_HISTORY: return else: num_transitions = len(elements) time.sleep(constants.RETRY_WAIT_SECS) assert False, "Required {} alarm state transitions, but found {}".\ format(MIN_HISTORY, num_transitions)
def test_alarm_metric_mixcase(self): metric_def = { 'name': data_utils.rand_name("MixCase_Test"), 'dimensions': { 'dim_to_match': data_utils.rand_name("max_match") } } expression = "max(" + metric_def['name'] + ") > 14" definition = helpers.create_alarm_definition( name="Metric Mixcase Test", description="", expression=expression, match_by=["dim_to_match"]) resp, resp_body = self.monasca_client.create_alarm_definitions( definition) self.assertEqual(201, resp.status) definition_id = resp_body['id'] # Ensure the new Alarm Definition gets to the Threshold Engine time.sleep(constants.ALARM_DEFINITION_CREATION_WAIT) self._send_measurement(metric_def, 20) alarm_id, initial_state = self._wait_for_alarm_creation(definition_id) self.assertEqual("ALARM", initial_state)
def test_create_alarm_definition_with_notification(self): notification_name = data_utils.rand_name('notification-') notification_type = 'EMAIL' notification_address = 'root@localhost' resp, response_body = self.monasca_client.create_notification_method( name=notification_name, type=notification_type, address=notification_address) notification_id = self._verify_create_notification_method( resp, response_body, notification_name, notification_type, notification_address) # Create an alarm definition alarm_def_name = data_utils.rand_name('monitoring_alarm_definition') expression = "mem_total_mb > 0" alarm_definition = helpers.create_alarm_definition( name=alarm_def_name, expression=expression, alarm_actions=[notification_id], ok_actions=[notification_id], undetermined_actions=[notification_id], severity="LOW") resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) self._verify_create_alarm_definitions(resp, response_body, alarm_definition) self.assertEqual(notification_id, response_body['ok_actions'][0]) self.assertEqual(notification_id, response_body['alarm_actions'][0]) self.assertEqual(notification_id, response_body['undetermined_actions'][0]) self._delete_notification(notification_id)
def test_list_alarm_definitions_with_multiple_dimensions(self): # Create an alarm definition with random dimensions name = data_utils.rand_name('alarm_definition') dimensions = { data_utils.rand_name('key-1'): data_utils.rand_name('value-1'), data_utils.rand_name('key-2'): data_utils.rand_name('value-2') } dimension_strings = [ key + '=' + value for key, value in dimensions.items() ] expression = 'avg(cpu_utilization{' + ','.join( dimension_strings) + '}) >= 1000' alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression) resp, res_body_create_alarm_def = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) # List alarms query_dimensions = [ key + ':' + value for key, value in dimensions.items() ] query_parms = '?dimensions=' + ','.join(query_dimensions) resp, response_body = self.monasca_client.list_alarm_definitions( query_parms) self._verify_list_alarm_definitions_response_body(resp, response_body) elements = response_body['elements'] self._verify_list_get_alarm_definitions_elements( elements, 1, res_body_create_alarm_def) links = response_body['links'] self._verify_list_alarm_definitions_links(links)
def resource_setup(cls): super(TestAlarmsStateHistoryOneTransition, cls).resource_setup() for i in xrange(MIN_HISTORY): alarm_definition = helpers.create_alarm_definition( name=data_utils.rand_name('alarm_state_history' + str(i + 1)), expression="min(name-" + str(i + 1) + ") < " + str(i + 1)) cls.monasca_client.create_alarm_definitions(alarm_definition) num_transitions = 0 for timer in xrange(constants.MAX_RETRIES): for i in xrange(MIN_HISTORY): # Create some metrics to prime the system and waiting for the # alarms to be created and then for them to change state. # MIN_HISTORY number of Alarms State History are needed. metric = helpers.create_metric(name="name-" + str(i + 1)) cls.monasca_client.create_metrics(metric) # sleep 0.05 second between metrics to make sure timestamps # are different time.sleep(0.05) resp, response_body = cls.monasca_client.\ list_alarms_state_history() elements = response_body['elements'] if len(elements) >= MIN_HISTORY: return else: num_transitions = len(elements) time.sleep(constants.RETRY_WAIT_SECS) assert False, "Required {} alarm state transitions, but found {}".\ format(MIN_HISTORY, num_transitions)
def _create_alarms_for_test_alarms(self, num): metric_name = data_utils.rand_name('name') key = data_utils.rand_name('key') value = data_utils.rand_name('value') alarm_definition_ids = [] for i in xrange(num): # create an alarm definition expression = "max(" + metric_name + ") > 0" name = data_utils.rand_name('name-1') alarm_definition = helpers.create_alarm_definition( name=name, expression=expression) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_ids.append(response_body['id']) expected_metric = helpers.create_metric(name=metric_name, dimensions={key: value}) # create some metrics for j in xrange(num): for i in xrange(constants.MAX_RETRIES): self.monasca_client.create_metrics(expected_metric) time.sleep(constants.RETRY_WAIT_SECS) query_param = '?alarm_definition_id=' + \ str(alarm_definition_ids[j]) resp, response_body = self.monasca_client.list_alarms( query_param) elements = response_body['elements'] if len(elements) >= 1: break return alarm_definition_ids, expected_metric
def create_alarm_definition(cls): # Create an alarm definition name = data_utils.rand_name('alarm_definition') expression = "max(cpu.system_perc) > 0" alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression) return alarm_definition
def test_create_alarms_with_sub_expressions_and_match_by(self): # Create an alarm definition with sub-expressions and match_by name = data_utils.rand_name('alarm_definition_3') expression = "max(cpu.idle_perc{service=monitoring}) < 10 or " \ "max(cpu.user_perc{service=monitoring}) > 60" match_by = ['hostname'] alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, match_by=match_by) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_id = response_body['id'] self._create_metrics_for_match_by_sub_expressions( num=2, alarm_definition_id=alarm_definition_id) query_param = '?alarm_definition_id=' + str(alarm_definition_id) resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=2) elements = response_body['elements'] hostnames = [] for i in xrange(2): self.assertEqual(len(elements[i]['metrics']), 2) for i in xrange(2): for j in xrange(2): hostnames.append( elements[i]['metrics'][j]['dimensions']['hostname']) self.assertEqual(hostnames[0], hostnames[1]) self.assertEqual(hostnames[2], hostnames[3]) self.assertNotEqual(hostnames[0], hostnames[2])
def test_create_alarm_definition_with_notification(self): notification_name = data_utils.rand_name('notification-') notification_type = 'EMAIL' notification_address = 'root@localhost' resp, response_body = self.monasca_client.create_notification_method( name=notification_name, type=notification_type, address=notification_address) notification_id = self._verify_create_notification_method( resp, response_body, notification_name, notification_type, notification_address) # Create an alarm definition alarm_def_name = data_utils.rand_name('monitoring_alarm_definition') expression = "mem_total_mb > 0" alarm_definition = helpers.create_alarm_definition( name=alarm_def_name, expression=expression, alarm_actions=[notification_id], ok_actions=[notification_id], undetermined_actions=[notification_id], severity="LOW") resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) self._verify_create_alarm_definitions(resp, response_body, alarm_definition) self.assertEqual(notification_id, response_body['ok_actions'][0]) self.assertEqual(notification_id, response_body['alarm_actions'][0]) self.assertEqual(notification_id, response_body['undetermined_actions'][0]) self._delete_notification(notification_id)
def _create_alarms_for_test_alarms(self, num): metric_name = data_utils.rand_name('name') key = data_utils.rand_name('key') value = data_utils.rand_name('value') alarm_definition_ids = [] for i in xrange(num): # create an alarm definition expression = "max(" + metric_name + ") > 0" name = data_utils.rand_name('name-1') alarm_definition = helpers.create_alarm_definition( name=name, expression=expression) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_ids.append(response_body['id']) expected_metric = helpers.create_metric(name=metric_name, dimensions={key: value}) # create some metrics for j in xrange(num): for i in xrange(constants.MAX_RETRIES): self.monasca_client.create_metrics(expected_metric) time.sleep(constants.RETRY_WAIT_SECS) query_param = '?alarm_definition_id=' + \ str(alarm_definition_ids[j]) resp, response_body = self.monasca_client.list_alarms( query_param) elements = response_body['elements'] if len(elements) >= 1: break return alarm_definition_ids, expected_metric
def test_create_alarms_with_sub_expressions_and_match_by(self): # Create an alarm definition with sub-expressions and match_by name = data_utils.rand_name('alarm_definition_3') expression = "max(cpu.idle_perc{service=monitoring}) < 10 or " \ "max(cpu.user_perc{service=monitoring}) > 60" match_by = ['hostname'] alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, match_by=match_by) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_id = response_body['id'] self._create_metrics_for_match_by_sub_expressions( num=2, alarm_definition_id=alarm_definition_id) query_param = '?alarm_definition_id=' + str(alarm_definition_id) resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=2) elements = response_body['elements'] hostnames = [] for i in xrange(2): self.assertEqual(len(elements[i]['metrics']), 2) for i in xrange(2): for j in xrange(2): hostnames.append(elements[i]['metrics'][j]['dimensions'][ 'hostname']) self.assertEqual(hostnames[0], hostnames[1]) self.assertEqual(hostnames[2], hostnames[3]) self.assertNotEqual(hostnames[0], hostnames[2])
def test_list_alarms_by_multiple_metric_dimensions(self): metric = helpers.create_metric( name=data_utils.rand_name("multi-dimension"), dimensions={data_utils.rand_name("key-1"): data_utils.rand_name("value-1"), data_utils.rand_name("key-2"): data_utils.rand_name("value-2")}, value=20 ) dimension_strings = [key + '=' + value for key, value in metric['dimensions'].items()] alarm_def = helpers.create_alarm_definition( name=data_utils.rand_name("multi-dimensions"), expression=metric['name'] + "{" + ','.join(dimension_strings) + '} > 15' ) resp, response_body = self.monasca_client.create_alarm_definitions(alarm_def) self.assertEqual(201, resp.status) alarm_def_id = response_body['id'] resp, response_body = self.monasca_client.create_metrics(metric) self.assertEqual(204, resp.status) self._wait_for_alarms(1, alarm_def_id) query_dimensions = [key + ':' + value for key, value in metric['dimensions'].items()] query_parms="?metric_dimensions=" + ','.join(query_dimensions) resp, response_body = self.monasca_client.list_alarms(query_parms) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=1) element = response_body['elements'][0] metric = element['metrics'][0] self._verify_metric_in_alarm(metric, metric) self.assertEqual(alarm_def_id, element['alarm_definition']['id'])
def test_alarm_max_function(self): metric_def = { 'name': data_utils.rand_name("max_test"), 'dimensions': { 'dim_to_match': data_utils.rand_name("max_match") } } expression = "max(" + metric_def['name'] + ") > 14" definition = helpers.create_alarm_definition(name="Test Max Function", description="", expression=expression, match_by=["dim_to_match"]) resp, resp_body = ( self.monasca_client.create_alarm_definitions(definition)) self.assertEqual(201, resp.status) definition_id = resp_body['id'] time.sleep(constants.ALARM_DEFINITION_CREATION_WAIT) self._send_measurement(metric_def, 1) alarm_id, initial_state = self._wait_for_alarm_creation(definition_id) self.assertEqual("UNDETERMINED", initial_state) self._send_measurement(metric_def, 20) self._wait_for_alarm_transition(alarm_id, "ALARM")
def test_alarm_max_with_deterministic(self): metric_def = { 'name': data_utils.rand_name("max_deterministic_test"), 'dimensions': { 'dim_to_match': data_utils.rand_name("max_match") } } expression = "max(" + metric_def['name'] + ",deterministic) > 14" definition = helpers.create_alarm_definition( name="Test Max Deterministic Function", description="", expression=expression, match_by=["dim_to_match"]) resp, resp_body = self.monasca_client.create_alarm_definitions( definition) self.assertEqual(201, resp.status) definition_id = resp_body['id'] time.sleep(1) self._send_measurement(metric_def, 1) alarm_id, initial_state = self._wait_for_alarm_creation(definition_id) self.assertEqual("OK", initial_state) self._send_measurement(metric_def, 20) self._wait_for_alarm_transition(alarm_id, "ALARM")
def test_list_alarm_definitions_with_multiple_dimensions(self): # Create an alarm definition with random dimensions name = data_utils.rand_name('alarm_definition') dimensions = {data_utils.rand_name('key-1'): data_utils.rand_name('value-1'), data_utils.rand_name('key-2'): data_utils.rand_name('value-2')} dimension_strings = [key + '=' + value for key, value in dimensions.items()] expression = 'avg(cpu_utilization{' + ','.join(dimension_strings) + '}) >= 1000' alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression) resp, res_body_create_alarm_def = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) # List alarms query_dimensions = [key + ':' + value for key, value in dimensions.items()] query_parms = '?dimensions=' + ','.join(query_dimensions) resp, response_body = self.monasca_client.list_alarm_definitions(query_parms) self._verify_list_alarm_definitions_response_body(resp, response_body) elements = response_body['elements'] self._verify_list_get_alarm_definitions_elements( elements, 1, res_body_create_alarm_def) links = response_body['links'] self._verify_list_alarm_definitions_links(links)
def test_alarm_last_with_deterministic(self): metric_def = {'name': data_utils.rand_name("last_deterministic_test"), 'dimensions': { 'dim_to_match': data_utils.rand_name("last_match") }} expression = "last(" + metric_def['name'] + ",deterministic) > 14" definition = helpers.create_alarm_definition(name="Test Last Deterministic Function", description="", expression=expression, match_by=["dim_to_match"]) resp, resp_body = self.monasca_client.create_alarm_definitions(definition) self.assertEqual(201, resp.status) definition_id = resp_body['id'] time.sleep(1) self._send_measurement(metric_def, 1) alarm_id, initial_state = self._wait_for_alarm_creation(definition_id) self.assertEqual("OK", initial_state) self._send_measurement(metric_def, 20) self._wait_for_alarm_transition(alarm_id, "ALARM") self._send_measurement(metric_def, 3) self._wait_for_alarm_transition(alarm_id, "OK")
def test_create_alarms_with_match_by_list(self): # Create an alarm definition with match_by as a list name = data_utils.rand_name('alarm_definition') expression = "max(cpu.idle_perc{service=monitoring}) < 10" match_by = ['hostname', 'device'] alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, match_by=match_by) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_id = response_body['id'] query_param = '?alarm_definition_id=' + str(alarm_definition_id) # create some metrics self._create_metrics_for_match_by_sub_expressions_list( num=4, alarm_definition_id=alarm_definition_id) resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=4) elements = response_body['elements'] dimensions = [] for i in xrange(4): self.assertEqual(len(elements[i]['metrics']), 1) dimensions.append(elements[i]['metrics'][0]['dimensions']) for i in xrange(4): for j in xrange(4): if i != j: self.assertNotEqual(dimensions[i], dimensions[j])
def test_create_alarms_with_match_by_list(self): # Create an alarm definition with match_by as a list name = data_utils.rand_name('alarm_definition') expression = "max(cpu.idle_perc{service=monitoring}) < 10" match_by = ['hostname', 'device'] alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, match_by=match_by) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_id = response_body['id'] query_param = '?alarm_definition_id=' + str(alarm_definition_id) # create some metrics self._create_metrics_for_match_by_sub_expressions_list( num=4, alarm_definition_id=alarm_definition_id) resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=4) elements = response_body['elements'] dimensions = [] for i in xrange(4): self.assertEqual(len(elements[i]['metrics']), 1) dimensions.append(elements[i]['metrics'][0]['dimensions']) for i in xrange(4): for j in xrange(4): if i != j: self.assertNotEqual(dimensions[i], dimensions[j])
def test_create_alarm_definition_with_name_exceeds_max_length(self): long_name = "x" * (constants.MAX_ALARM_DEFINITION_NAME_LENGTH + 1) expression = "max(cpu.system_perc) > 0" alarm_definition = helpers.create_alarm_definition( name=long_name, description="description", expression=expression) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_alarm_definitions, alarm_definition)
def test_create_alarm_definition_with_name_exceeds_max_length(self): long_name = "x" * (constants.MAX_ALARM_DEFINITION_NAME_LENGTH + 1) expression = "max(cpu.system_perc) > 0" alarm_definition = helpers.create_alarm_definition( name=long_name, description="description", expression=expression) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_alarm_definitions, alarm_definition)
def resource_setup(cls): super(TestAlarmsStateHistory, cls).resource_setup() start_timestamp = int(time.time() * 1000) end_timestamp = int(time.time() * 1000) + 1000 # create an alarm definition expression = "avg(name-1) > 0" name = data_utils.rand_name('alarm_definition') alarm_definition = helpers.create_alarm_definition( name=name, expression=expression) resp, response_body = cls.monasca_client.create_alarm_definitions( alarm_definition) # create another alarm definition name1 = data_utils.rand_name('alarm_definition1') expression1 = "max(cpu.system_perc) > 0" alarm_definition1 = helpers.create_alarm_definition( name=name1, expression=expression1) resp, response_body1 = cls.monasca_client.create_alarm_definitions( alarm_definition1) # create another alarm definition name2 = data_utils.rand_name('alarm_definition2') expression1 = "avg(mysql.performance.slow_queries) > 10.0" alarm_definition2 = helpers.create_alarm_definition( name=name2, expression=expression1) resp, response_body2 = cls.monasca_client.create_alarm_definitions( alarm_definition2) # create some metrics for i in xrange(180): metric = helpers.create_metric() resp, body = cls.monasca_client.create_metrics(metric) cls._start_timestamp = start_timestamp + i cls._end_timestamp = end_timestamp + i time.sleep(1) resp, response_body = cls.monasca_client.\ list_alarms_state_history() elements = response_body['elements'] if len(elements) > 4: break if len(elements) < 3: cls.assertEqual(1, False)
def test_create_alarms_with_match_by(self): # Create an alarm definition with no match_by name = data_utils.rand_name('alarm_definition_1') expression = "max(cpu.idle_perc{service=monitoring}) < 20" alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_id = response_body['id'] self._create_metrics_for_match_by( num=1, alarm_definition_id=alarm_definition_id) query_param = '?alarm_definition_id=' + str(alarm_definition_id) resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=1) elements = response_body['elements'] metrics = elements[0]['metrics'] self.assertEqual(len(metrics), 2) self.assertNotEqual(metrics[0], metrics[1]) # Create an alarm definition with match_by name = data_utils.rand_name('alarm_definition_2') expression = "max(cpu.idle_perc{service=monitoring}) < 20" match_by = ['hostname'] alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, match_by=match_by) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_id = response_body['id'] # create some metrics self._create_metrics_for_match_by( num=2, alarm_definition_id=alarm_definition_id) query_param = '?alarm_definition_id=' + str(alarm_definition_id) resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=2) elements = response_body['elements'] self.assertEqual(len(elements[0]['metrics']), 1) self.assertEqual(len(elements[1]['metrics']), 1) self.assertNotEqual(elements[0]['metrics'], elements[1]['metrics'])
def test_create_alarm_definition(self): # Create an alarm definition name = data_utils.rand_name("alarm_definition") expression = "max(cpu.system_perc) > 0" alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, match_by=["hostname"], severity="MEDIUM" ) resp, response_body = self.monasca_client.create_alarm_definitions(alarm_definition) self._verify_create_alarm_definitions(resp, response_body, alarm_definition)
def resource_setup(cls): super(TestAlarmDefinitions, cls).resource_setup() cls.rule = {'expression': 'mem_total_mb > 0'} for i in range(NUM_ALARM_DEFINITIONS): alarm_definition = helpers.create_alarm_definition( name='alarm-definition-' + str(i), description='alarm definition description', expression='avg(cpu_utilization{service=compute}) >= 1000') cls.monasca_client.create_alarm_definitions(alarm_definition)
def test_list_alarm_definitions_with_multiple_severity(self): name = data_utils.rand_name('alarm_definition') expression = 'avg(cpu_utilization{alarm=severity}) >= 1000' alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, severity="LOW") resp, res_body_create_alarm_def_low = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) name = data_utils.rand_name('alarm_definition') expression = 'avg(cpu_utilization{alarm=severity}) >= 1000' alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, severity="MEDIUM") resp, res_body_create_alarm_def_medium = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) name = data_utils.rand_name('alarm_definition') expression = 'avg(cpu_utilization{alarm=severity}) >= 1000' alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, severity="HIGH") resp, res_body_create_alarm_def = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) query_param = '?severity=MEDIUM|LOW&dimensions=alarm:severity&sort_by=severity' resp, response_body = self.monasca_client.\ list_alarm_definitions(query_param) self._verify_list_alarm_definitions_response_body(resp, response_body) elements = response_body['elements'] self._verify_alarm_definitions_list(elements, [res_body_create_alarm_def_low, res_body_create_alarm_def_medium]) links = response_body['links'] self._verify_list_alarm_definitions_links(links)
def test_list_alarm_definitions_with_multiple_severity(self): name = data_utils.rand_name('alarm_definition') expression = 'avg(cpu_utilization{alarm=severity}) >= 1000' alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, severity="LOW") resp, res_body_create_alarm_def_low = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) name = data_utils.rand_name('alarm_definition') expression = 'avg(cpu_utilization{alarm=severity}) >= 1000' alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, severity="MEDIUM") resp, res_body_create_alarm_def_medium = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) name = data_utils.rand_name('alarm_definition') expression = 'avg(cpu_utilization{alarm=severity}) >= 1000' alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, severity="HIGH") resp, res_body_create_alarm_def = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) query_param = '?severity=MEDIUM|LOW&dimensions=alarm:severity&sort_by=severity' resp, response_body = self.monasca_client.\ list_alarm_definitions(query_param) self._verify_list_alarm_definitions_response_body(resp, response_body) elements = response_body['elements'] self._verify_alarm_definitions_list( elements, [res_body_create_alarm_def_low, res_body_create_alarm_def_medium]) links = response_body['links'] self._verify_list_alarm_definitions_links(links)
def test_verify_deterministic_alarm(self): metric_name = data_utils.rand_name('log.fancy') metric_dimensions = {'service': 'monitoring', 'hostname': 'mini-mon'} name = data_utils.rand_name('alarm_definition') expression = ('count(%s{service=monitoring},deterministic) > 10' % metric_name) match_by = ['hostname', 'device'] description = 'deterministic' alarm_definition = helpers.create_alarm_definition( name=name, description=description, expression=expression, match_by=match_by) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_id = response_body['id'] query_param = '?alarm_definition_id=' + str(alarm_definition_id) # 1. ensure alarm was not created resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, 0) # 2. put some metrics here to create it, should be in ok metrics_count = 5 for it in range(0, metrics_count): metric = helpers.create_metric(name=metric_name, value=1.0, dimensions=metric_dimensions) self.monasca_client.create_metrics(metric) self._wait_for_alarms(1, alarm_definition_id) resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, 1) element = response_body['elements'][0] self.assertEqual('OK', element['state']) # 3. exceed threshold metrics_count = 20 for it in range(0, metrics_count): metric = helpers.create_metric(name=metric_name, value=1.0, dimensions=metric_dimensions) self.monasca_client.create_metrics(metric) self._wait_for_alarms(1, alarm_definition_id) resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, 1) element = response_body['elements'][0] self.assertEqual('ALARM', element['state'])
def test_create_alarm_definition_with_undeterm_actions_exceeds_max_length(self): name = data_utils.rand_name("alarm_definition") expression = "max(cpu.system_perc) > 0" undetermined_actions = ["x" * (constants.MAX_ALARM_DEFINITION_ACTIONS_LENGTH + 1)] alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, undetermined_actions=undetermined_actions ) self.assertRaises( exceptions.UnprocessableEntity, self.monasca_client.create_alarm_definitions, alarm_definition )
def test_create_alarm_definition_with_description_exceeds_max_length(self): name = data_utils.rand_name('alarm_definition') long_description = "x" * (constants. MAX_ALARM_DEFINITION_DESCRIPTION_LENGTH + 1) expression = "max(cpu.system_perc) > 0" alarm_definition = helpers.create_alarm_definition( name=name, description=long_description, expression=expression) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_alarm_definitions, alarm_definition)
def test_create_alarm_definition_with_invalid_severity(self): invalid_severity = "INVALID" name = data_utils.rand_name("alarm_definition") expression = "max(cpu.system_perc) > 0" alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, severity=invalid_severity ) self.assertRaises( exceptions.UnprocessableEntity, self.monasca_client.create_alarm_definitions, alarm_definition )
def test_create_alarm_definition_with_description_exceeds_max_length(self): name = data_utils.rand_name('alarm_definition') long_description = "x" * (constants. MAX_ALARM_DEFINITION_DESCRIPTION_LENGTH + 1) expression = "max(cpu.system_perc) > 0" alarm_definition = helpers.create_alarm_definition( name=name, description=long_description, expression=expression) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_alarm_definitions, alarm_definition)
def test_create_alarm_definition(self): # Create an alarm definition name = data_utils.rand_name('alarm_definition') expression = "max(cpu.system_perc) > 0" alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, match_by=['hostname'], severity="MEDIUM") resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) self._verify_create_alarm_definitions(resp, response_body, alarm_definition)
def test_create_alarms_with_match_by(self): # Create an alarm definition with no match_by name = data_utils.rand_name('alarm_definition_1') expression = "max(cpu.idle_perc{service=monitoring}) < 20" alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_id = response_body['id'] self._create_metrics_for_match_by( num=1, alarm_definition_id=alarm_definition_id) query_param = '?alarm_definition_id=' + str(alarm_definition_id) resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=1) elements = response_body['elements'] metrics = elements[0]['metrics'] self.assertEqual(len(metrics), 2) self.assertNotEqual(metrics[0], metrics[1]) # Create an alarm definition with match_by name = data_utils.rand_name('alarm_definition_2') expression = "max(cpu.idle_perc{service=monitoring}) < 20" match_by = ['hostname'] alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, match_by=match_by) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_id = response_body['id'] # create some metrics self._create_metrics_for_match_by( num=2, alarm_definition_id=alarm_definition_id) query_param = '?alarm_definition_id=' + str(alarm_definition_id) resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=2) elements = response_body['elements'] self.assertEqual(len(elements[0]['metrics']), 1) self.assertEqual(len(elements[1]['metrics']), 1) self.assertNotEqual(elements[0]['metrics'], elements[1]['metrics'])
def test_create_alarm_definition_with_invalid_severity(self): invalid_severity = "INVALID" name = data_utils.rand_name('alarm_definition') expression = "max(cpu.system_perc) > 0" alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, severity=invalid_severity) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_alarm_definitions, alarm_definition)
def test_list_alarms_by_metric_dimensions_multi_value(self): metric_name = data_utils.rand_name('metric') match_by_key = data_utils.rand_name('key') dim_key = data_utils.rand_name('key') dim_value_1 = data_utils.rand_name('value') dim_value_2 = data_utils.rand_name('value') alarm_def = helpers.create_alarm_definition( name=data_utils.rand_name('definition'), expression=metric_name + " > 1", match_by=[match_by_key]) metric_1 = helpers.create_metric( metric_name, { match_by_key: data_utils.rand_name('value'), dim_key: dim_value_1 }) metric_2 = helpers.create_metric( metric_name, { match_by_key: data_utils.rand_name('value'), dim_key: dim_value_2 }) metric_3 = helpers.create_metric( metric_name, {match_by_key: data_utils.rand_name('value')}) metrics = [metric_1, metric_2, metric_3] resp, response_body = self.monasca_client.create_alarm_definitions( alarm_def) self.assertEqual(201, resp.status) for i in xrange(constants.MAX_RETRIES): resp, alarm_def_result = self.monasca_client.create_metrics( metrics) self.assertEqual(204, resp.status) resp, response_body = self.monasca_client.list_alarms( '?metric_name=' + metric_name) self.assertEqual(200, resp.status) if len(response_body['elements']) >= 3: break time.sleep(constants.RETRY_WAIT_SECS) if i >= constants.MAX_RETRIES - 1: self.fail( "Timeout creating alarms, required 3 but found {}".format( len(response_body['elements']))) query_parms = '?metric_dimensions=' + dim_key + ':' + dim_value_1 + '|' + dim_value_2 resp, response_body = self.monasca_client.list_alarms(query_parms) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=2) dimension_sets = [] for element in response_body['elements']: self.assertEqual(metric_name, element['metrics'][0]['name']) dimension_sets.append(element['metrics'][0]['dimensions']) self.assertIn(metric_1['dimensions'], dimension_sets) self.assertIn(metric_2['dimensions'], dimension_sets) self.assertNotIn(metric_3['dimensions'], dimension_sets)
def test_create_alarm_definition_with_multiple_notifications(self): notification_name1 = data_utils.rand_name('notification-') notification_type1 = 'EMAIL' address1 = 'root@localhost' notification_name2 = data_utils.rand_name('notification-') notification_type2 = 'PAGERDUTY' address2 = 'http://localhost.com' resp, body = self.monasca_client.create_notification_method( notification_name1, type=notification_type1, address=address1) self.assertEqual(201, resp.status) self.assertEqual(notification_name1, body['name']) notification_id1 = body['id'] resp, body = self.monasca_client.create_notification_method( notification_name2, type=notification_type2, address=address2) self.assertEqual(201, resp.status) self.assertEqual(notification_name2, body['name']) notification_id2 = body['id'] # Create an alarm definition alarm_def_name = data_utils.rand_name('monitoring_alarm_definition') alarm_definition = helpers.create_alarm_definition( name=alarm_def_name, expression="mem_total_mb > 0", alarm_actions=[notification_id1, notification_id2], ok_actions=[notification_id1, notification_id2], severity="LOW") resp, body = self.monasca_client.create_alarm_definitions( alarm_definition) self.assertEqual(201, resp.status) self.assertEqual(alarm_def_name, body['name']) alarm_def_id = body['id'] self.assertEqual("mem_total_mb > 0", body['expression']) # Delete alarm definition and validate if deleted resp, body = self.monasca_client.delete_alarm_definition(alarm_def_id) self.assertEqual(204, resp.status) self.assertRaises(exceptions.NotFound, self.monasca_client.get_alarm_definition, alarm_def_id) # Delete notification 1 resp, body = self.monasca_client.delete_notification_method( notification_id1) self.assertEqual(204, resp.status) # Delete notification 2 resp, body = self.monasca_client.delete_notification_method( notification_id2) self.assertEqual(204, resp.status)
def test_list_alarm_definitions_multiple_sort_by(self): key = data_utils.rand_name('key') value = data_utils.rand_name('value') expression = 'avg(cpu_utilization{' + str(key) + '=' + str(value) + \ '}) >= 1000' alarm_definitions = [helpers.create_alarm_definition( name='alarm def sort by 11', expression=expression, severity='MEDIUM' ), helpers.create_alarm_definition( name='alarm def sort by 14', expression=expression, severity='MEDIUM' ), helpers.create_alarm_definition( name='alarm def sort by 12', expression=expression, severity='LOW' ), helpers.create_alarm_definition( name='alarm def sort by 13', expression=expression, severity='MEDIUM' )] for definition in alarm_definitions: resp, response_body = self.monasca_client.create_alarm_definitions(definition) definition['id'] = response_body['id'] resp, response_body = self.monasca_client.list_alarm_definitions( '?dimensions=' + str(key) + ':' + str(value) + '&sort_by=' + urlparse.quote('severity asc,name desc,id')) self.assertEqual(200, resp.status) expected_order = [2, 1, 3, 0] for i, element in enumerate(response_body['elements']): self.assertEqual(alarm_definitions[expected_order[i]]['id'], element['id'])
def test_create_alarm_definition_with_undeterm_actions_exceeds_max_length( self): name = data_utils.rand_name('alarm_definition') expression = "max(cpu.system_perc) > 0" undetermined_actions = ["x" * (constants. MAX_ALARM_DEFINITION_ACTIONS_LENGTH + 1)] alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, undetermined_actions=undetermined_actions) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_alarm_definitions, alarm_definition)
def test_list_alarm_definitions_with_name(self): name = data_utils.rand_name("alarm_definition") alarm_definition = helpers.create_alarm_definition( name=name, description=data_utils.rand_name("description"), expression="max(cpu.system_perc) > 0" ) resp, res_body_create_alarm_def = self.monasca_client.create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) query_parms = "?name=" + str(name) resp, response_body = self.monasca_client.list_alarm_definitions(query_parms) self._verify_list_alarm_definitions_response_body(resp, response_body) elements = response_body["elements"] self._verify_list_get_alarm_definitions_elements(elements, 1, res_body_create_alarm_def) links = response_body["links"] self._verify_list_alarm_definitions_links(links)
def _create_alarm_definitions(self, expression, number_of_definitions): self.rule = {'expression': 'mem_total_mb > 0'} if expression is None: expression = "max(cpu.system_perc) > 0" response_body_list = [] for i in xrange(number_of_definitions): alarm_definition = helpers.create_alarm_definition( name=data_utils.rand_name('alarm_definition'), description=data_utils.rand_name('description'), expression=expression, match_by=['device']) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) self.assertEqual(201, resp.status) response_body_list.append(response_body) return response_body_list
def test_create_deterministic_alarm_definition(self): name = data_utils.rand_name('log.error') expression = "count(log.error{},deterministic) > 0" alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, match_by=['hostname'], severity="MEDIUM") resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) self._verify_create_alarm_definitions(resp, response_body, alarm_definition, deterministic=True)
def _create_alarm_definitions(self, expression, number_of_definitions): self.rule = {'expression': 'mem_total_mb > 0'} if expression is None: expression = "max(cpu.system_perc) > 0" response_body_list = [] for i in xrange(number_of_definitions): alarm_definition = helpers.create_alarm_definition( name=data_utils.rand_name('alarm_definition'), description=data_utils.rand_name('description'), expression=expression, match_by=['device']) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) self.assertEqual(201, resp.status) response_body_list.append(response_body) return response_body_list
def create_alarms_for_test_alarms(cls): # create an alarm definition expression = "avg(name-1) > 0" name = data_utils.rand_name('name-1') alarm_definition = helpers.create_alarm_definition( name=name, expression=expression) resp, response_body = cls.monasca_client.create_alarm_definitions( alarm_definition) # create some metrics for i in xrange(30): metric = helpers.create_metric() resp, response_body = cls.monasca_client.create_metrics(metric) time.sleep(1) resp, response_body = cls.monasca_client.list_alarms() elements = response_body['elements'] if len(elements) > 0: break
def create_alarms_for_test_alarms(cls): # create an alarm definition expression = "avg(name-1) > 0" name = data_utils.rand_name('name-1') alarm_definition = helpers.create_alarm_definition( name=name, expression=expression) resp, response_body = cls.monasca_client.create_alarm_definitions( alarm_definition) # create some metrics for i in xrange(30): metric = helpers.create_metric() resp, response_body = cls.monasca_client.create_metrics(metric) time.sleep(1) resp, response_body = cls.monasca_client.list_alarms() elements = response_body['elements'] if len(elements) > 0: break
def resource_setup(cls): super(TestAlarmStateHistoryMultipleTransitions, cls).resource_setup() alarm_definition = helpers.create_alarm_definition( name=data_utils.rand_name('alarm_state_history'), expression="min(name-1) < 1.0") cls.monasca_client.create_alarm_definitions(alarm_definition) for timer in xrange(constants.MAX_RETRIES): # create some metrics to prime the system and create # MIN_HISTORY alarms metric = helpers.create_metric(name="name-1", dimensions={'key1': 'value1'}, value=0.0) cls.monasca_client.create_metrics(metric) # sleep 1 second between metrics to make sure timestamps # are different in the second field. Influxdb has a bug # where it does not sort properly by milliseconds. .014 # is sorted as greater than .138 time.sleep(1.0) resp, response_body = cls.monasca_client.\ list_alarms_state_history() elements = response_body['elements'] if len(elements) >= 1: break time.sleep(constants.RETRY_WAIT_SECS) time.sleep(constants.MAX_RETRIES) for timer in xrange(constants.MAX_RETRIES * 2): metric = helpers.create_metric(name="name-1", dimensions={'key2': 'value2'}, value=2.0) cls.monasca_client.create_metrics(metric) # sleep 0.05 second between metrics to make sure timestamps # are different time.sleep(0.05) resp, response_body = \ cls.monasca_client.list_alarms_state_history() elements = response_body['elements'] if len(elements) >= 2: return else: num_transitions = len(elements) time.sleep(constants.RETRY_WAIT_SECS) assert False, "Required {} alarm state transitions, but found {}".\ format(MIN_HISTORY, num_transitions)
def test_create_deterministic_alarm_definition(self): name = data_utils.rand_name('log.error') expression = "count(log.error{},deterministic) > 0" alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, match_by=['hostname'], severity="MEDIUM" ) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition ) self._verify_create_alarm_definitions(resp, response_body, alarm_definition, deterministic=True)
def test_create_non_deterministic_alarm_definition_compound_mixed_expr( self): name = data_utils.rand_name('log.error.and.disk.used_perc') expression = ('max(disk.used_perc{hostname=node_1}) > 99.0 AND ' 'count(log.error{hostname=node_1},deterministic) > 0') alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, match_by=['hostname'], severity="MEDIUM") resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) self._verify_create_alarm_definitions(resp, response_body, alarm_definition, deterministic=False)
def test_list_alarm_definitions_with_dimensions(self): # Create an alarm definition with random dimensions name = data_utils.rand_name("alarm_definition") key = data_utils.rand_name("key") value = data_utils.rand_name("value") expression = "avg(cpu_utilization{" + str(key) + "=" + str(value) + "}) >= 1000" alarm_definition = helpers.create_alarm_definition(name=name, description="description", expression=expression) resp, res_body_create_alarm_def = self.monasca_client.create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) # List alarms query_parms = "?dimensions=" + str(key) + ":" + str(value) resp, response_body = self.monasca_client.list_alarm_definitions(query_parms) self._verify_list_alarm_definitions_response_body(resp, response_body) elements = response_body["elements"] self._verify_list_get_alarm_definitions_elements(elements, 1, res_body_create_alarm_def) links = response_body["links"] self._verify_list_alarm_definitions_links(links)
def test_create_non_deterministic_alarm_definition_compound_mixed_expr(self): name = data_utils.rand_name('log.error.and.disk.used_perc') expression = ('max(disk.used_perc{hostname=node_1}) > 99.0 AND ' 'count(log.error{hostname=node_1},deterministic) > 0') alarm_definition = helpers.create_alarm_definition( name=name, description="description", expression=expression, match_by=['hostname'], severity="MEDIUM" ) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition ) self._verify_create_alarm_definitions(resp, response_body, alarm_definition, deterministic=False)
def resource_setup(cls): super(TestAlarmsStateHistory, cls).resource_setup() for i in xrange(1, NUM_ALARM_DEFINITIONS + 1): alarm_definition = helpers.create_alarm_definition( name=data_utils.rand_name('alarm_state_history' + str(i)), expression="min(name-1) < " + str(i)) cls.monasca_client.create_alarm_definitions(alarm_definition) # create some metrics to prime the system and create three alarms for i in xrange(60): metric = helpers.create_metric() cls.monasca_client.create_metrics(metric) resp, response_body = cls.monasca_client.\ list_alarms_state_history() elements = response_body['elements'] if len(elements) >= MIN_HISTORY: break time.sleep(5)
def test_list_alarm_definitions_with_name(self): name = data_utils.rand_name('alarm_definition') alarm_definition = helpers.create_alarm_definition( name=name, description=data_utils.rand_name('description'), expression="max(cpu.system_perc) > 0") resp, res_body_create_alarm_def = self.monasca_client.\ create_alarm_definitions(alarm_definition) self.assertEqual(201, resp.status) query_parms = "?name=" + str(name) resp, response_body = self.monasca_client.list_alarm_definitions( query_parms) self._verify_list_alarm_definitions_response_body(resp, response_body) elements = response_body['elements'] self._verify_list_get_alarm_definitions_elements( elements, 1, res_body_create_alarm_def) links = response_body['links'] self._verify_list_alarm_definitions_links(links)
def test_list_alarms_by_metric_dimensions_no_value(self): metric_name = data_utils.rand_name('metric') match_by_key = data_utils.rand_name('key') dim_key = data_utils.rand_name('key') alarm_def = helpers.create_alarm_definition( name=data_utils.rand_name('definition'), expression=metric_name + " > 1", match_by=[match_by_key]) metric_1 = helpers.create_metric(metric_name, {match_by_key: data_utils.rand_name('value'), dim_key: data_utils.rand_name('value')}) metric_2 = helpers.create_metric(metric_name, {match_by_key: data_utils.rand_name('value'), dim_key: data_utils.rand_name('value')}) metric_3 = helpers.create_metric(metric_name, {match_by_key: data_utils.rand_name('value')}) metrics = [metric_1, metric_2, metric_3] resp, response_body = self.monasca_client.create_alarm_definitions(alarm_def) self.assertEqual(201, resp.status) for i in xrange(constants.MAX_RETRIES): resp, alarm_def_result = self.monasca_client.create_metrics(metrics) self.assertEqual(204, resp.status) resp, response_body = self.monasca_client.list_alarms('?metric_name=' + metric_name) self.assertEqual(200, resp.status) if len(response_body['elements']) >= 3: break time.sleep(constants.RETRY_WAIT_SECS) if i >= constants.MAX_RETRIES - 1: self.fail("Timeout creating alarms, required 3 but found {}".format( len(response_body['elements']))) query_parms = '?metric_dimensions=' + dim_key resp, response_body = self.monasca_client.list_alarms(query_parms) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=2) dimension_sets = [] for element in response_body['elements']: self.assertEqual(metric_name, element['metrics'][0]['name']) dimension_sets.append(element['metrics'][0]['dimensions']) self.assertIn(metric_1['dimensions'], dimension_sets) self.assertIn(metric_2['dimensions'], dimension_sets) self.assertNotIn(metric_3['dimensions'], dimension_sets)