def get_check_for_timestamp_test(self):
self._cleanup()
gauges_collection = plugin_model._get_gauges_data_collection()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
plugin_with_error = plugin_model.get_or_create(name='error1', server_id=self.server['_id'])
for i in range(0, 100):
data = {'t': i, 'count.first': 2, 'count.second': 4, 'count.third': 5 }
formated_data = flat_to_tree_dict_helper(data)
formated_data['plugin_id'] = plugin['_id']
formated_data['server_id'] = self.server_id
gauges_collection.insert(formated_data)
error_data = {'plugin_id': plugin_with_error['_id'], 'server_id': self.server_id,
't': 10, 'error': 'Argghh'}
error_collection = plugin_model._get_error_collection()
error_collection.insert(error_data)
result = plugin_model.get_check_for_timestamp(self.server, 10)
for r in result:
assert r['name'] in ['test1', 'error1']
self._cleanup()
def upsert_gauges_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
gauges_data = {'t': 1, 'count.test': 2, 'second.test': 4, 'more.tests': 5 }
plugin_model.upsert_gauges(plugin=plugin, gauges=gauges_data)
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
result = plugin_model.get_gauges_list(plugin=plugin) # Excludes t and plugin_id
self.assertCountEqual(result, ['count', 'second', 'more'])
data = {'t': 1, 'count.test': 2, 'second.test': 4, 'more.tests': 5, 'evenmore.test':2 }
result = plugin_model.upsert_gauges(plugin, gauges=data) # Excludes t and plugin_id
result = plugin_model.get_gauges_list(plugin=plugin) # Excludes t and plugin_id
self.assertCountEqual(result, ['count', 'second', 'evenmore' ,'more'])
data = {'t': 1, 'count.test': 2, 'second.test': 4}
result = plugin_model.upsert_gauges(plugin, gauges=data) # Excludes t and plugin_id
result = plugin_model.get_gauges_list(plugin=plugin) # Excludes t and plugin_id
self.assertCountEqual(result, ['count', 'second', 'evenmore' ,'more'])
self._cleanup()
def get_gauge_keys_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
data = {
't': 1,
'count.first': 2,
'count.second': 4,
'count.third': 5,
}
plugin_model.save_gauges(data=data, plugin=plugin, time=1)
gauge = plugin_model.get_gauge_by_name(name='count', plugin=plugin)
result = plugin_model.get_gauge_keys(gauge=gauge)
self.assertCountEqual(result, [u'second', u'third', u'first'])
self._cleanup()
data = {'t': 1, 'countsecond': 2}
plugin_model.save_gauges(data=data, plugin=plugin, time=1)
gauge = plugin_model.get_gauge_by_name(name='countsecond',
plugin=plugin)
result = plugin_model.get_gauge_keys(gauge=gauge)
self.assertCountEqual(result, [u'value'])
def get_counters_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
counters_collection = plugin_model._get_counters_collection()
data = {'t': 1, 'count.test': 2, 'second.test': 4, 'more.tests': 5}
formated_data = flat_to_tree_dict_helper(data)
formated_data['plugin_id'] = plugin['_id']
formated_data['server_id'] = self.server_id
counters_collection.insert(formated_data)
result = plugin_model.get_counters(
server=self.server, plugin=plugin) # Excludes t and plugin_id
eq_(
result, {
u'count': {
u'test': 2
},
u'second': {
u'test': 4
},
u't': 1,
u'more': {
u'tests': 5
}
})
self._cleanup()
def delete_counters_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
gauge_data = {
u'performance.cpu_load': 1.08719,
u'performance.busy_workers': 117.0,
}
for i in range(0, 10):
plugin_model.save_counters(data=gauge_data,
plugin=plugin,
server=self.server)
collection = plugin_model._get_counters_collection()
result = collection.find().count()
eq_(result, 1)
plugin_model.delete_counters(server=self.server, plugin=plugin)
result = collection.find().count()
eq_(result, 0)
self._cleanup()
def get_gauge_keys_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
data = {'t': 1, 'count.first': 2, 'count.second': 4, 'count.third': 5, }
plugin_model.save_gauges(data=data, plugin=plugin, time=1)
gauge = plugin_model.get_gauge_by_name(name='count', plugin=plugin)
result = plugin_model.get_gauge_keys(gauge=gauge)
self.assertCountEqual(result, [u'second', u'third', u'first'])
self._cleanup()
data = {'t': 1, 'countsecond': 2}
plugin_model.save_gauges(data=data, plugin=plugin, time=1)
gauge = plugin_model.get_gauge_by_name(name='countsecond', plugin=plugin)
result = plugin_model.get_gauge_keys(gauge=gauge)
self.assertCountEqual(result, [u'value'])
def get_or_create_plugin_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
eq_(plugin['name'], 'test1')
def ajax_get_gauge_data_after_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
for i in range(0, 100):
data = {'t': i, 'count.first': 2, 'count.second': 4, 'count.third': 5}
plugin_model.save_gauges(data=data, plugin=plugin, time=i)
gauge = plugin_model.get_gauge_by_name(name='count', plugin=plugin)
url = reverse('ajax_get_gauge_data_after')
url = "{0}?gauge={1}×tamp=30&enddate=59".format(url, gauge['_id'])
response = self.c.get(url)
to_json = json.loads(response.content.decode('utf-8'))
assert to_json['last_update']
assert to_json['now_local']
data = to_json['data']
eq_(len(data), 3)
for i in data:
assert i['name'] in ['second', 'third', 'first']
assert len(i['data']) == 30
self._cleanup()
def get_alerts_for_plugin_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(server_id=self.server_id, name='testplugin')
gauge = plugin_model.get_or_create_gauge_by_name(plugin=plugin, name='gauge')
plugin_alert = {
"above_below": "above",
"rule_type": "plugin",
"server": self.server_id,
"gauge": gauge['_id'],
"plugin": plugin['_id'],
"account_id": self.account_id,
"key": "testkey",
"period": 0,
"metric_value": 5
}
for i in range(0,5):
try:
del plugin_alert['_id']
except:
pass
plugin_alert['period'] = i
plugin_alert['metric_value'] = i+5
self.model.collection.insert(plugin_alert)
result = self.model.get_alerts_for_plugin(plugin=plugin)
assert len(result) == 5
self._cleanup()
def get_table_data_collection_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
result = plugin_model._get_table_data_collection(plugin=plugin, table_name='testme')
eq_(result.name, "plugin_test1_testme_data")
def view_plugin_with_id(self):
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
url = reverse('view_plugins', kwargs={'server_id': self.server['_id']})
url = "&plugin_id={0}".format(plugin['_id'])
response = self.c.get(url)
assert response.status_code == 200
def get_all_metrics_test(self):
self.process_collection.remove()
plugin_model.collection.remove()
for i in range(0, 2):
self.process_collection.insert({
"name": "test-{0}".format(i),
'server': self.server_id
})
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
data = {
't': 1,
'count.count_key': 2,
'second.second_key': 4,
'more.more_key': 5
}
plugin_model.save_gauges(plugin=plugin, data=data, time=1)
result = dashboard_metrics_model.get_all_metrics()
for r in result:
params = r[0].split('.')
final_params = dict(x.split(':') for x in params)
assert final_params['metric_type']
metric_type = final_params['metric_type']
if metric_type == 'system_global':
assert final_params['check'] in [
'disk', 'memory', 'network', 'loadavg', 'cpu'
]
if final_params['check'] == 'network':
assert final_params['key'] in ['i', 'o']
if final_params['check'] == 'disk':
assert final_params['key'] == 'percent'
if final_params['check'] == 'memory':
assert final_params['key'] == 'used_percent'
if final_params['check'] == 'cpu':
assert final_params['key'] in [
'idle', 'system', 'user', 'iowait', 'steal'
]
elif metric_type == 'process_global':
assert final_params['key'] in ['test-0', 'test-1']
assert final_params['check'] in ['cpu', 'memory']
elif metric_type == 'plugin_global':
assert final_params['gauge'] in ['count', 'second', 'more']
assert final_params['key'] in [
'count_key', 'second_key', 'more_key'
]
def upsert_gauges_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
gauges_data = {
't': 1,
'count.test': 2,
'second.test': 4,
'more.tests': 5
}
plugin_model.upsert_gauges(plugin=plugin, gauges=gauges_data)
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
result = plugin_model.get_gauges_list(
plugin=plugin) # Excludes t and plugin_id
self.assertCountEqual(result, ['count', 'second', 'more'])
data = {
't': 1,
'count.test': 2,
'second.test': 4,
'more.tests': 5,
'evenmore.test': 2
}
result = plugin_model.upsert_gauges(
plugin, gauges=data) # Excludes t and plugin_id
result = plugin_model.get_gauges_list(
plugin=plugin) # Excludes t and plugin_id
self.assertCountEqual(result, ['count', 'second', 'evenmore', 'more'])
data = {'t': 1, 'count.test': 2, 'second.test': 4}
result = plugin_model.upsert_gauges(
plugin, gauges=data) # Excludes t and plugin_id
result = plugin_model.get_gauges_list(
plugin=plugin) # Excludes t and plugin_id
self.assertCountEqual(result, ['count', 'second', 'evenmore', 'more'])
self._cleanup()
def test_plugin_alert(self):
self._cleanup()
plugin_alert = {
"above_below": "above",
"rule_type": "plugin",
"server": self.server_id,
"gauge": self.gauge_id,
"plugin": self.plugin_id,
"account_id": self.account_id,
"key": "testkey",
"period": 0,
"metric_value": 5
}
alert_id = alerts_model.collection.insert(plugin_alert)
key_name = '{0}.testkey'.format(self.gauge['name'])
data = {'gauges': {'bla.test': 1, key_name: 6}}
plugin_alerter.check(data=data, plugin=self.plugin)
unsent_alerts = alerts_history_model.get_unsent()
for trigger in unsent_alerts['data']:
assert trigger['alert_id'] == alert_id
assert trigger['average_value'] == 6
eq_(unsent_alerts['data'].count(), 1)
self._cleanup()
plugin = plugin_model.get_or_create(server_id=self.server_id,
name='mongo')
gauge = 'global_gauge.global_key'
plugin_alert = {
"above_below": "above",
"rule_type": "plugin_global",
"server": 'all',
"plugin": 'mongo',
"gauge": 'global_gauge',
"key": 'global_key',
"period": 0,
"metric_value": 5
}
alert_id = alerts_model.collection.insert(plugin_alert)
data = {'gauges': {'bla.test': 1, gauge: 6}}
plugin_alerter.check(data=data, plugin=plugin, server=self.server)
unsent_alerts = alerts_history_model.get_unsent()
for trigger in unsent_alerts['data']:
assert trigger['alert_id'] == alert_id
assert trigger['average_value'] == 6
eq_(unsent_alerts['data'].count(), 1)
def view_plugin_with_id(self):
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
url = reverse('view_plugins', kwargs={'server_id': self.server['_id']})
url = "&plugin_id={0}".format(plugin['_id'])
response = self.c.get(url)
assert response.status_code == 200
def test_plugin_alert(self):
self._cleanup()
plugin_alert = {
"above_below": "above",
"rule_type": "plugin",
"server": self.server_id,
"gauge": self.gauge_id,
"plugin": self.plugin_id,
"account_id": self.account_id,
"key": "testkey",
"period": 0,
"metric_value": 5
}
alert_id = alerts_model.collection.insert(plugin_alert)
key_name = '{0}.testkey'.format(self.gauge['name'])
data = {'gauges': {'bla.test': 1, key_name: 6}}
plugin_alerter.check(data=data, plugin=self.plugin)
unsent_alerts = alerts_history_model.get_unsent()
for trigger in unsent_alerts['data']:
assert trigger['alert_id'] == alert_id
assert trigger['average_value'] == 6
eq_(unsent_alerts['data'].count(), 1)
self._cleanup()
plugin = plugin_model.get_or_create(server_id=self.server_id, name='mongo')
gauge = 'global_gauge.global_key'
plugin_alert = {
"above_below": "above",
"rule_type": "plugin_global",
"server": 'all',
"plugin": 'mongo',
"gauge": 'global_gauge',
"key": 'global_key',
"period": 0,
"metric_value": 5
}
alert_id = alerts_model.collection.insert(plugin_alert)
data = {'gauges': {'bla.test': 1, gauge: 6}}
plugin_alerter.check(data=data, plugin=plugin, server=self.server)
unsent_alerts = alerts_history_model.get_unsent()
for trigger in unsent_alerts['data']:
assert trigger['alert_id'] == alert_id
assert trigger['average_value'] == 6
eq_(unsent_alerts['data'].count(), 1)
def get_table_data_collection_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
result = plugin_model._get_table_data_collection(plugin=plugin,
table_name='testme')
eq_(result.name, "plugin_test1_testme_data")
def save_gauges_test(self):
self._cleanup()
expires_at = datetime.utcnow()+timedelta(hours=24)
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
gauge_data = {
u'performance.cpu_load': 1.08719, u'performance.busy_workers': 117.0,
u'performance.idle_workers': 523.0, u'net.bytes': 86855934115.0,
u'requests.per.second': 140.7, u'net.hits': 35534902.0
}
plugin_model.save_gauges(data=gauge_data, plugin=plugin, time=1, expires_at=expires_at)
collection = plugin_model._get_gauges_data_collection()
gauges = plugin_model.get_gauges_cursor(plugin=plugin)
gauges_dict = {}
for g in gauges:
gauges_dict[str(g['_id'])] = g['name']
for r in collection.find():
gauge_id = str(r['gauge_id'])
gauge_name = gauges_dict[gauge_id]
assert gauge_name in ['net', 'performance', 'requests']
self.assertTrue(r['t'], int)
self.assertEqual(r['expires_at'].date(), expires_at.date())
if gauge_name == 'net':
self.assertCountEqual(r.keys(), [u't', u'hits', u'bytes', u'gauge_id', u'_id', 'expires_at'])
self.assertEqual(r['hits'], 35534902.0)
self.assertEqual(r['bytes'], 86855934115.0)
elif gauge_name == 'performance':
self.assertCountEqual(r.keys(), [u't', u'cpu_load', u'busy_workers', u'idle_workers', u'gauge_id', u'_id', 'expires_at'])
self.assertEqual(r['cpu_load'], 1.08719)
self.assertEqual(r['busy_workers'], 117.0)
self.assertEqual(r['idle_workers'], 523.0)
elif gauge_name == 'requests':
self.assertCountEqual(r.keys(), [u't', u'per_second', u'gauge_id', u'_id', 'expires_at'])
self.assertEqual(r['per_second'], 140.7)
self._cleanup()
def get_all_unique_gauge_keys_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
data = {'t': 1, 'count.count_key': 2, 'second.second_key': 4, 'more.more_key': 5}
plugin_model.save_gauges(plugin=plugin, data=data, time=1)
result = plugin_model.get_all_unique_gauge_keys_list()
assert set(result) == set(['test1.count.count_key' ,'test1.second.second_key', 'test1.more.more_key'])
def get_check_for_timestamp_test(self):
self._cleanup()
gauges_collection = plugin_model._get_gauges_data_collection()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
plugin_with_error = plugin_model.get_or_create(
name='error1', server_id=self.server['_id'])
for i in range(0, 100):
data = {
't': i,
'count.first': 2,
'count.second': 4,
'count.third': 5
}
formated_data = flat_to_tree_dict_helper(data)
formated_data['plugin_id'] = plugin['_id']
formated_data['server_id'] = self.server_id
gauges_collection.insert(formated_data)
error_data = {
'plugin_id': plugin_with_error['_id'],
'server_id': self.server_id,
't': 10,
'error': 'Argghh'
}
error_collection = plugin_model._get_error_collection()
error_collection.insert(error_data)
result = plugin_model.get_check_for_timestamp(self.server, 10)
for r in result:
assert r['name'] in ['test1', 'error1']
self._cleanup()
def get_gauge_data_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
gauges_collection = plugin_model._get_gauges_data_collection()
for i in range(0, 100):
data = {
't': i,
'count.first': 11,
'count.second': 22,
'count.third': 33
}
plugin_model.save_gauges(data=data, plugin=plugin, time=i)
gauge = plugin_model.get_gauge_by_name(name='count', plugin=plugin)
result = plugin_model.get_gauge_data_after(timestamp=0,
enddate=29,
gauge=gauge)
eq_(len(result), 3) # first, second, third
for i in result:
assert i['name'] in ['first', 'second', 'third']
assert len(i['data']) == 30
for point in i['data']:
assert point['y'] in [33, 22, 11]
self._cleanup()
for i in range(0, 100):
data = {'t': i, 'count': 2}
plugin_model.save_gauges(data=data, plugin=plugin, time=i)
result = plugin_model.get_gauge_data_after(timestamp=0,
enddate=29,
gauge=gauge)
eq_(len(result), 1) # count
count = result[0]
eq_(count['name'], 'value') # Single value
eq_(len(count['data']), 30)
self._cleanup()
def get_gauges_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
data = {'t': 1, 'count.test': 2, 'second.test': 4, 'more.tests': 5}
plugin_model.save_gauges(plugin=plugin, data=data, time=1)
result = plugin_model.get_gauges_list(plugin=plugin)
self.assertCountEqual(result, ['count', 'second', 'more'])
self._cleanup()
def get_gauges_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
data = {'t': 1, 'count.test': 2, 'second.test': 4, 'more.tests': 5 }
plugin_model.save_gauges(plugin=plugin, data=data, time=1)
result = plugin_model.get_gauges_list(plugin=plugin)
self.assertCountEqual(result, ['count', 'second', 'more'])
self._cleanup()
def get_gauge_data_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
gauges_collection = plugin_model._get_gauges_data_collection()
for i in range(0, 100):
data = {'t': i, 'count.first': 11, 'count.second': 22, 'count.third': 33 }
plugin_model.save_gauges(data=data, plugin=plugin, time=i)
gauge = plugin_model.get_gauge_by_name(name='count', plugin=plugin)
result = plugin_model.get_gauge_data_after(timestamp=0, enddate=29, gauge=gauge)
eq_(len(result), 3) # first, second, third
for i in result:
assert i['name'] in ['first', 'second', 'third']
assert len(i['data']) == 30
for point in i['data']:
assert point['y'] in [33, 22, 11]
self._cleanup()
for i in range(0, 100):
data = {'t': i, 'count': 2}
plugin_model.save_gauges(data=data, plugin=plugin, time=i)
result = plugin_model.get_gauge_data_after(timestamp=0, enddate=29, gauge=gauge)
eq_(len(result),1 ) # count
count = result[0]
eq_(count['name'], 'value') # Single value
eq_(len(count['data']), 30)
self._cleanup()
def get_all_metrics_test(self):
self.process_collection.remove()
plugin_model.collection.remove()
for i in range(0, 2):
self.process_collection.insert({"name" : "test-{0}".format(i), 'server': self.server_id})
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
data = {'t': 1, 'count.count_key': 2, 'second.second_key': 4, 'more.more_key': 5 }
plugin_model.save_gauges(plugin=plugin, data=data, time=1)
result = dashboard_metrics_model.get_all_metrics()
for r in result:
params = r[0].split('.')
final_params = dict(x.split(':') for x in params)
assert final_params['metric_type']
metric_type = final_params['metric_type']
if metric_type == 'system_global':
assert final_params['check'] in ['disk', 'memory', 'network', 'loadavg', 'cpu']
if final_params['check'] == 'network':
assert final_params['key'] in ['i', 'o']
if final_params['check'] == 'disk':
assert final_params['key'] == 'percent'
if final_params['check'] == 'memory':
assert final_params['key'] == 'used_percent'
if final_params['check'] == 'cpu':
assert final_params['key'] in ['idle', 'system', 'user', 'iowait', 'steal']
elif metric_type == 'process_global':
assert final_params['key'] in ['test-0', 'test-1']
assert final_params['check'] in ['cpu', 'memory']
elif metric_type == 'plugin_global':
assert final_params['gauge'] in ['count', 'second', 'more']
assert final_params['key'] in ['count_key', 'second_key', 'more_key']
def test_plugin_emails(self):
self._cleanup()
plugin = plugin_model.get_or_create(server_id=self.server_id,
name='testplugin')
gauge = plugin_model.get_or_create_gauge_by_name(plugin=plugin,
name='gauge')
plugin_alert = {
"above_below": "above",
"rule_type": "plugin",
"server": self.server_id,
"gauge": gauge['_id'],
"plugin": plugin['_id'],
"account_id": self.account_id,
"key": "testkey",
"period": 0,
"metric_value": 5,
"notifications": self.notifications_list
}
alert_id = alerts_model.collection.insert(plugin_alert)
key_name = '{0}.testkey'.format(gauge['name'])
data = {'gauges': {'bla.test': 1, key_name: 6}}
plugin_alerter.check(data=data, plugin=plugin)
unsent_alerts = alerts_history_model.get_unsent()
for trigger in unsent_alerts['data']:
assert trigger['alert_id'] == alert_id
assert trigger['average_value'] == 6
eq_(unsent_alerts['data'].count(), 1)
notifications = generate_notifications()
for n in notifications:
send_notification_email(notification=n, emails=self.emails)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(
mail.outbox[0].subject,
'Server: test - testplugin.gauge.testkey > 5 (Current value: 6.0)')
self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
self._cleanup()
def get_counters_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
counters_collection = plugin_model._get_counters_collection()
data = {'t': 1, 'count.test': 2, 'second.test': 4, 'more.tests': 5 }
formated_data = flat_to_tree_dict_helper(data)
formated_data['plugin_id'] = plugin['_id']
formated_data['server_id'] = self.server_id
counters_collection.insert(formated_data)
result = plugin_model.get_counters(server=self.server, plugin=plugin) # Excludes t and plugin_id
eq_(result, {u'count': {u'test': 2}, u'second': {u'test': 4}, u't': 1, u'more': {u'tests': 5}})
self._cleanup()
def get_gauge_keys_for_server_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
data = {'t': 1, 'count.count_key': 2, 'second.second_key': 4, 'more.more_key': 5}
plugin_model.save_gauges(plugin=plugin, data=data, time=1)
result = plugin_model.get_gauge_keys_for_server(server_id=self.server['_id'])
assert len(result) == 3 # count, second, more
for r in result:
assert r['plugin']['_id'] == plugin['_id']
for key in r['gauge']['keys']:
assert key in ['count_key', 'second_key', 'more_key']
def setUp(self):
User.objects.all().delete()
self.alerter = server_alerter
self.user = User.objects.create_user(password='******' , email='*****@*****.**')
self.account_id = 1
self.server_key = server_model.add('test', account_id=self.account_id)
self.server = server_model.get_server_by_key(self.server_key)
self.server_id = self.server['_id']
self.process = process_model.get_or_create(server_id=self.server_id, name='test')
self.process_id = self.process['_id']
self.plugin = plugin_model.get_or_create(server_id=self.server_id, name='testplugin')
self.plugin_id = self.plugin['_id']
self.gauge = plugin_model.get_or_create_gauge_by_name(plugin=self.plugin, name='gauge')
self.gauge_id = self.gauge['_id']
def save_counters_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
counter_data = {
u'rows.inserted': 4, u'rows.updated': 6, u'rows.deleted': 4,
u'rows.returned': 1832119, u'rows.fetched': 680425,
u'xact.rollbacks': 0, u'xact.commits': 26869,
u'performance.disk_read': 170, u'performance.buffer_hit': 1711069
}
plugin_model.save_counters(data=counter_data, plugin=plugin, server=self.server)
collection = plugin_model._get_counters_collection()
for r in collection.find():
self.assertEqual(sorted(r.keys()), sorted([u'server_id', u'rows', u't', u'xact', u'performance', u'plugin_id', u'_id']))
rows = r['rows']
eq_(r['plugin_id'], plugin['_id'])
self.assertTrue(r['t'], int)
self.assertEqual(rows, {u'deleted': 4, u'inserted': 4, u'updated': 6, u'fetched': 680425, u'returned': 1832119})
rows = r['xact']
self.assertEqual(rows, {u'commits': 26869, u'rollbacks': 0})
rows = r['performance']
self.assertEqual(rows, {u'buffer_hit': 1711069, u'disk_read': 170})
# Test duplicates - the counters should be only a single entry in the collection
collection.remove()
for i in range(0, 10):
plugin_model.save_counters(data=counter_data, plugin=plugin, server=self.server)
result = collection.find().count()
eq_(result, 1)
self._cleanup()
def delete_counters_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
gauge_data = {u'performance.cpu_load': 1.08719, u'performance.busy_workers': 117.0,}
for i in range(0, 10):
plugin_model.save_counters(data=gauge_data, plugin=plugin, server=self.server)
collection = plugin_model._get_counters_collection()
result = collection.find().count()
eq_(result, 1)
plugin_model.delete_counters(server=self.server, plugin=plugin)
result = collection.find().count()
eq_(result, 0)
self._cleanup()
def test_plugin_emails(self):
self._cleanup()
plugin = plugin_model.get_or_create(server_id=self.server_id, name='testplugin')
gauge = plugin_model.get_or_create_gauge_by_name(plugin=plugin, name='gauge')
plugin_alert = {
"above_below": "above",
"rule_type": "plugin",
"server": self.server_id,
"gauge": gauge['_id'],
"plugin": plugin['_id'],
"account_id": self.account_id,
"key": "testkey",
"period": 0,
"metric_value": 5,
"notifications": self.notifications_list
}
alert_id = alerts_model.collection.insert(plugin_alert)
key_name = '{0}.testkey'.format(gauge['name'])
data = {'gauges': {'bla.test': 1, key_name: 6}}
plugin_alerter.check(data=data, plugin=plugin)
unsent_alerts = alerts_history_model.get_unsent()
for trigger in unsent_alerts['data']:
assert trigger['alert_id'] == alert_id
assert trigger['average_value'] == 6
eq_(unsent_alerts['data'].count(), 1)
notifications = generate_notifications()
for n in notifications:
send_notification_email(notification=n, emails=self.emails)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, 'Server: test - testplugin.gauge.testkey > 5 (Current value: 6.0)')
self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
self._cleanup()
def get_all_unique_gauge_keys_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
data = {
't': 1,
'count.count_key': 2,
'second.second_key': 4,
'more.more_key': 5
}
plugin_model.save_gauges(plugin=plugin, data=data, time=1)
result = plugin_model.get_all_unique_gauge_keys_list()
assert set(result) == set([
'test1.count.count_key', 'test1.second.second_key',
'test1.more.more_key'
])
def setUp(self):
User.objects.all().delete()
self.alerter = server_alerter
self.user = User.objects.create_user(password='******',
email='*****@*****.**')
self.account_id = 1
self.server_key = server_model.add('test', account_id=self.account_id)
self.server = server_model.get_server_by_key(self.server_key)
self.server_id = self.server['_id']
self.process = process_model.get_or_create(server_id=self.server_id,
name='test')
self.process_id = self.process['_id']
self.plugin = plugin_model.get_or_create(server_id=self.server_id,
name='testplugin')
self.plugin_id = self.plugin['_id']
self.gauge = plugin_model.get_or_create_gauge_by_name(
plugin=self.plugin, name='gauge')
self.gauge_id = self.gauge['_id']
def get_by_id_test(self):
self.collection.remove()
server_model.collection.remove()
plugin_model.collection.remove()
server_id = server_model.add('testserver')
plugin = plugin_model.get_or_create(name='testplugin', server_id=server_id)
self.collection.insert({
"rule_type" : "process",
"server": server_id,
"plugin": plugin['_id'],
'sms_recepients': [],
'email_recepients': [],
'webhooks': []}
)
alert = self.collection.find_one()
alert_from_model = self.model.get_by_id(alert['_id'])
assert alert_from_model['plugin'] == plugin['_id']
def get_gauge_keys_for_server_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
data = {
't': 1,
'count.count_key': 2,
'second.second_key': 4,
'more.more_key': 5
}
plugin_model.save_gauges(plugin=plugin, data=data, time=1)
result = plugin_model.get_gauge_keys_for_server(
server_id=self.server['_id'])
assert len(result) == 3 # count, second, more
for r in result:
assert r['plugin']['_id'] == plugin['_id']
for key in r['gauge']['keys']:
assert key in ['count_key', 'second_key', 'more_key']
def ajax_get_gauge_data_after_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
for i in range(0, 100):
data = {
't': i,
'count.first': 2,
'count.second': 4,
'count.third': 5
}
plugin_model.save_gauges(data=data, plugin=plugin, time=i)
gauge = plugin_model.get_gauge_by_name(name='count', plugin=plugin)
url = reverse('ajax_get_gauge_data_after')
url = "{0}?gauge={1}×tamp=30&enddate=59".format(url, gauge['_id'])
response = self.c.get(url)
to_json = json.loads(response.content.decode('utf-8'))
assert to_json['last_update']
assert to_json['now_local']
data = to_json['data']
eq_(len(data), 3)
for i in data:
assert i['name'] in ['second', 'third', 'first']
assert len(i['data']) == 30
self._cleanup()
def get_global_metrics_test(self):
self._cleanup()
process_name = "alertest-process"
plugin_name = "alertest-plugin"
process = process_model.get_or_create(server_id=self.server_id, name=process_name)
plugin = plugin_model.get_or_create(name=plugin_name, server_id=self.server_id)
plugin_data = {
'count.count_first_key': 2,
'second.second_key': 4,
'more.more_key': 5,
'count.count_second_key': 4
}
plugin_model.save_gauges(plugin=plugin, data=plugin_data, time=1)
plugin_gauges_keys = plugin_model.get_gauge_keys_for_server(server_id=self.server_id)
result = self.model.get_global_metrics()
assert len(result) == 14 # 7 system + 3 process(cpu/memory/down) + 4 plugin(for every key)
system_metrics = ['CPU', 'Memory', 'Loadavg', 'Disk', 'Network/inbound', 'Network/outbound', 'Not Sending Data']
process_metrics = ['cpu', 'memory', 'down']
for r in result:
value = r.get('value')
metric_dict = dict(v.split(":") for v in value.split("."))
assert metric_dict['rule_type']
assert metric_dict['rule_type'] in ['global', 'process_global', 'plugin_global']
alert_type = metric_dict.get('rule_type')
if alert_type == 'system':
assert r['metric'] in system_metrics
if alert_type == 'process_global':
assert r['metric'] in process_metrics
def get_or_create_plugin_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1', server_id=self.server['_id'])
eq_(plugin['name'], 'test1')
def get_save_table_data_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='nginx', server_id=self.server['_id'])
data = {
'headers': [u'visitors', u'hits', u'bytes', u'percent', u'data'],
'data': [
[1, 34, 0, 3.91, u'/static/css/screen.css'],
[1, 34, 0, 3.91, u'/static/js/libs/libs.min.js'],
[1, 33, 0, 3.8, u'/static/css/chart.css']
]
}
plugin_model.save_table_data(data=data, server=self.server,
plugin=plugin,
table_name='requests',
find_by_string='data')
data_collection = plugin_model._get_table_data_collection(plugin=plugin, table_name='requests')
assert data_collection.find().count() == 3
result = plugin_model.get_table_data(server=self.server,
plugin=plugin,
table_name='requests')
assert set(result['header']) == set(data['headers'])
assert result['data'].count() == 3
# Check if it doesnt create duplicates
plugin_model.save_table_data(data=data, server=self.server,
plugin=plugin,
table_name='requests',
find_by_string='data')
assert data_collection.find().count() == 3
data_collection.remove()
plugin_model.collection.remove()
# Check for the harders - sql queries
plugin = plugin_model.get_or_create(name='mysql', server_id=self.server['_id'])
data_collection = plugin_model._get_table_data_collection(plugin=plugin, table_name='slow_queries')
data_collection.remove()
data = {'headers': ['query_time', 'rows_sent', 'rows_examined', 'lock_time', 'db', 'query', 'start_time'],
'data': [
[3.0, 1, 0, 0.0, 'wordpress', 'select BENCHMARK(500000000, EXTRACT(YEAR FROM NOW()))', '2015-04-22 23:50:40'],
[12.0, 1, 0, 0.0, 'wordpress', 'select BENCHMARK(5000000, EXTRACT(YEAR FROM NOW()))', '2015-04-22 23:00:22']
]
}
plugin_model.save_table_data(data=data, server=self.server,
plugin=plugin,
table_name='slow_queries',
find_by_string='query',
unique_hash=True)
assert data_collection.find().count() == 2
result = plugin_model.get_table_data(server=self.server,
plugin=plugin,
table_name='slow_queries',
additional_ignore_keys=['unique_hash'])
assert set(result['header']) == set(data['headers'])
assert result['data'].count() == 2
data = {'headers': ['query_time', 'rows_sent', 'rows_examined', 'lock_time', 'db', 'query', 'start_time'],
'data': [
[3.0, 1, 0, 0.0, 'wordpress', 'select BENCHMARK(500000000, EXTRACT(YEAR FROM NOW()))', '2015-04-22 23:50:40'],
[12.0, 1, 0, 0.0, 'wordpress', 'select BENCHMARK(5000000, EXTRACT(YEAR FROM NOW()))', '2015-04-22 23:00:22']
]
}
plugin_model.save_table_data(data=data, server=self.server,
plugin=plugin,
table_name='slow_queries',
find_by_string='query',
unique_hash=True)
assert data_collection.find().count() == 2
result = plugin_model.get_table_data(server=self.server,
plugin=plugin,
table_name='slow_queries',
additional_ignore_keys=['unique_hash'])
assert set(result['header']) == set(data['headers'])
assert result['data'].count() == 2
self._cleanup()
def get_save_table_data_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='nginx',
server_id=self.server['_id'])
data = {
'headers': [u'visitors', u'hits', u'bytes', u'percent', u'data'],
'data': [[1, 34, 0, 3.91, u'/static/css/screen.css'],
[1, 34, 0, 3.91, u'/static/js/libs/libs.min.js'],
[1, 33, 0, 3.8, u'/static/css/chart.css']]
}
plugin_model.save_table_data(data=data,
server=self.server,
plugin=plugin,
table_name='requests',
find_by_string='data')
data_collection = plugin_model._get_table_data_collection(
plugin=plugin, table_name='requests')
assert data_collection.find().count() == 3
result = plugin_model.get_table_data(server=self.server,
plugin=plugin,
table_name='requests')
assert set(result['header']) == set(data['headers'])
assert len(result['data']) == 3
# Check if it doesnt create duplicates
plugin_model.save_table_data(data=data,
server=self.server,
plugin=plugin,
table_name='requests',
find_by_string='data')
assert data_collection.find().count() == 3
data_collection.remove()
plugin_model.collection.remove()
# Check for the harders - sql queries
plugin = plugin_model.get_or_create(name='mysql',
server_id=self.server['_id'])
data_collection = plugin_model._get_table_data_collection(
plugin=plugin, table_name='slow_queries')
data_collection.remove()
data = {
'headers': [
'query_time', 'rows_sent', 'rows_examined', 'lock_time', 'db',
'query', 'start_time'
],
'data': [[
3.0, 1, 0, 0.0, 'wordpress',
'select BENCHMARK(500000000, EXTRACT(YEAR FROM NOW()))',
'2015-04-22 23:50:40'
],
[
12.0, 1, 0, 0.0, 'wordpress',
'select BENCHMARK(5000000, EXTRACT(YEAR FROM NOW()))',
'2015-04-22 23:00:22'
]]
}
plugin_model.save_table_data(data=data,
server=self.server,
plugin=plugin,
table_name='slow_queries',
find_by_string='query',
unique_hash=True)
assert data_collection.find().count() == 2
result = plugin_model.get_table_data(
server=self.server,
plugin=plugin,
table_name='slow_queries',
additional_ignore_keys=['unique_hash'])
assert set(result['header']) == set(data['headers'])
assert len(result['data']) == 2
data = {
'headers': [
'query_time', 'rows_sent', 'rows_examined', 'lock_time', 'db',
'query', 'start_time'
],
'data': [[
3.0, 1, 0, 0.0, 'wordpress',
'select BENCHMARK(500000000, EXTRACT(YEAR FROM NOW()))',
'2015-04-22 23:50:40'
],
[
12.0, 1, 0, 0.0, 'wordpress',
'select BENCHMARK(5000000, EXTRACT(YEAR FROM NOW()))',
'2015-04-22 23:00:22'
]]
}
plugin_model.save_table_data(data=data,
server=self.server,
plugin=plugin,
table_name='slow_queries',
find_by_string='query',
unique_hash=True)
assert data_collection.find().count() == 2
result = plugin_model.get_table_data(
server=self.server,
plugin=plugin,
table_name='slow_queries',
additional_ignore_keys=['unique_hash'])
assert set(result['header']) == set(data['headers'])
assert len(result['data']) == 2
self._cleanup()
def get_server_metrics_test(self):
self._cleanup()
process_name = "alertest-process"
plugin_name = "alertest-plugin"
process = process_model.get_or_create(server_id=self.server_id, name=process_name)
plugin = plugin_model.get_or_create(name=plugin_name, server_id=self.server_id)
plugin_data = {
'count.count_first_key': 2,
'second.second_key': 4,
'more.more_key': 5,
'count.count_second_key': 4
}
plugin_model.save_gauges(plugin=plugin, data=plugin_data, time=1)
plugin_gauges_keys = plugin_model.get_gauge_keys_for_server(server_id=self.server_id)
volumes_model.get_or_create(server_id=self.server_id, name='get_server_metrics_volume')
interfaces_model.get_or_create(server_id=self.server_id, name='get_server_metrics_interface')
result = self.model.get_server_metrics(server_id=self.server_id)
system_metrics = ['CPU', 'Memory', 'Loadavg', 'Disk', 'Network/inbound', 'Network/outbound', 'Not Sending Data']
system_values = ["server:{0}.metric:{1}.rule_type:system".format(self.server_id, x.replace(" ", "")) for x in system_metrics]
volumes = volumes_model.get_all_for_server(server_id=self.server_id)
for v in volumes:
value = "server:{0}.metric:Disk.rule_type:system.volume:{1}".format(self.server_id, v.get('name'))
system_values.append(value)
interfaces = interfaces_model.get_all_for_server(server_id=self.server_id)
for i in interfaces:
value = "server:{0}.metric:Network/inbound.rule_type:system.interface:{1}".format(self.server_id, i.get('name'))
system_values.append(value)
value = "server:{0}.metric:Network/outbound.rule_type:system.interface:{1}".format(self.server_id, i.get('name'))
system_values.append(value)
process_metrics = ['CPU', 'Memory']
process_alerts_names = ["{0}.{1}".format(process_name, x.replace(" ", "")) for x in process_metrics]
process_values = ["server:{0}.process:{1}.metric:{2}.rule_type:process".format(self.server_id, process['_id'], x) for x in process_metrics]
process_uptime = ['Down']
process_uptime_alerts_names = ["{0}.{1}".format(process_name, x.replace(" ", "")) for x in process_uptime]
process_uptime_values = ["server:{0}.process:{1}.metric:{2}.rule_type:uptime".format(self.server_id, process['_id'], x) for x in process_uptime]
plugin_alert_names = ["{0}.{1}".format(plugin_name, x) for x in plugin_data.keys()]
plugin_values = []
for plugin_gauge_key in plugin_gauges_keys:
gauge = plugin_gauge_key.get('gauge')
key = plugin_gauge_key.get('key')
_id = "server:{0}.plugin:{1}.gauge:{2}.key:{3}.rule_type:plugin".format(
self.server_id,
plugin['_id'],
gauge['_id'],
key
)
plugin_values.append(_id)
assert len(plugin_values) == 4 # All the keys from plugin_data
for r in result:
value = r.get('value')
metric_dict = dict(v.split(":") for v in value.split("."))
alert_type = metric_dict.get('rule_type')
assert alert_type != None
assert alert_type in ['system', 'process', 'plugin', 'uptime']
if alert_type == 'system':
assert r.get('metric') in system_metrics
assert r.get('value') in system_values
elif alert_type == 'process':
assert r.get('metric') in ['CPU', 'Memory']
assert r.get('name') in process_alerts_names
assert r.get('value') in process_values
elif alert_type == 'uptime':
assert r.get('metric') in ['Down']
assert r.get('name') in process_uptime_alerts_names
assert r.get('value') in process_uptime_values
elif alert_type == 'plugin':
assert r.get('name') in plugin_alert_names
assert r.get('value') in plugin_values
else:
assert False # Should not be here
def save_gauges_test(self):
self._cleanup()
expires_at = datetime.utcnow() + timedelta(hours=24)
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
gauge_data = {
u'performance.cpu_load': 1.08719,
u'performance.busy_workers': 117.0,
u'performance.idle_workers': 523.0,
u'net.bytes': 86855934115.0,
u'requests.per.second': 140.7,
u'net.hits': 35534902.0
}
plugin_model.save_gauges(data=gauge_data,
plugin=plugin,
time=1,
expires_at=expires_at)
collection = plugin_model._get_gauges_data_collection()
gauges = plugin_model.get_gauges_cursor(plugin=plugin)
gauges_dict = {}
for g in gauges:
gauges_dict[str(g['_id'])] = g['name']
for r in collection.find():
gauge_id = str(r['gauge_id'])
gauge_name = gauges_dict[gauge_id]
assert gauge_name in ['net', 'performance', 'requests']
self.assertTrue(r['t'], int)
self.assertEqual(r['expires_at'].date(), expires_at.date())
if gauge_name == 'net':
self.assertCountEqual(r.keys(), [
u't', u'hits', u'bytes', u'gauge_id', u'_id', 'expires_at'
])
self.assertEqual(r['hits'], 35534902.0)
self.assertEqual(r['bytes'], 86855934115.0)
elif gauge_name == 'performance':
self.assertCountEqual(r.keys(), [
u't', u'cpu_load', u'busy_workers', u'idle_workers',
u'gauge_id', u'_id', 'expires_at'
])
self.assertEqual(r['cpu_load'], 1.08719)
self.assertEqual(r['busy_workers'], 117.0)
self.assertEqual(r['idle_workers'], 523.0)
elif gauge_name == 'requests':
self.assertCountEqual(
r.keys(),
[u't', u'per_second', u'gauge_id', u'_id', 'expires_at'])
self.assertEqual(r['per_second'], 140.7)
self._cleanup()
def save_counters_test(self):
self._cleanup()
plugin = plugin_model.get_or_create(name='test1',
server_id=self.server['_id'])
counter_data = {
u'rows.inserted': 4,
u'rows.updated': 6,
u'rows.deleted': 4,
u'rows.returned': 1832119,
u'rows.fetched': 680425,
u'xact.rollbacks': 0,
u'xact.commits': 26869,
u'performance.disk_read': 170,
u'performance.buffer_hit': 1711069
}
plugin_model.save_counters(data=counter_data,
plugin=plugin,
server=self.server)
collection = plugin_model._get_counters_collection()
for r in collection.find():
self.assertEqual(
sorted(r.keys()),
sorted([
u'server_id', u'rows', u't', u'xact', u'performance',
u'plugin_id', u'_id'
]))
rows = r['rows']
eq_(r['plugin_id'], plugin['_id'])
self.assertTrue(r['t'], int)
self.assertEqual(
rows, {
u'deleted': 4,
u'inserted': 4,
u'updated': 6,
u'fetched': 680425,
u'returned': 1832119
})
rows = r['xact']
self.assertEqual(rows, {u'commits': 26869, u'rollbacks': 0})
rows = r['performance']
self.assertEqual(rows, {u'buffer_hit': 1711069, u'disk_read': 170})
# Test duplicates - the counters should be only a single entry in the collection
collection.remove()
for i in range(0, 10):
plugin_model.save_counters(data=counter_data,
plugin=plugin,
server=self.server)
result = collection.find().count()
eq_(result, 1)
self._cleanup()
