def create_multi_day_report(self):
owner_id = uuid.uuid4()
r = Report.select_or_insert(owner_id, 'pi')
def process(val, minus_days, tags):
res = r.process_input(str(val),
created=datetime.datetime.utcnow() -
datetime.timedelta(days=minus_days),
tags=tags)
self.assertIsNotNone(res.report_instance)
process(0, 500, ['t1', 't2'])
process(-1, 532, ['t2'])
process(1, 432, ['t1', 't2'])
process(2, 410, ['t1', 't2'])
process(3, 360, ['t1', 't2'])
process(4, 330, ['t1'])
process(5, 73, ['t1'])
process(6, 12, ['t2'])
process(7, 11, ['t1'])
all_ris = r.fetch_instances(
datetime.datetime.utcnow() - datetime.timedelta(days=600),
datetime.datetime.utcnow())
self.assertEqual('-1 0 1 2 3 4 5 6 7'.split(),
[ri['input_string'] for ri in all_ris])
return r, all_ris
def main():
owner_id = uuid.uuid4()
report = Report.select_or_insert(owner_id, 'simple_report')
res = report.process_input('1 2 3')
assert res.report_instance
owner_dashboards = OwnerDashboards(
owner_id, insert_if_no_dashboards='Default Dashboard')
assert owner_dashboards.dashboards
tile_config = {
'series_spec_list': [SeriesSpec(0, -1, {
'op': 'eq',
'args': ['0']
})],
}
tile = Tile.insert(owner_id, report.report_id,
owner_dashboards.dashboards[0].dashboard_id,
tile_config)
assert tile
assert tile.get_tile_data()
print 'Successfully created a dashboard with a tile'
owner_dashboards.dashboards[0].delete()
def test_process_input_invalid_args(self):
owner_id = uuid.uuid4()
r = Report.select_or_insert(owner_id, 'pi')
self.assertRaises(AssertionError, lambda: r.process_input(43))
self.assertRaises(
ValueError, lambda: r.process_input(
'3', created=datetime.datetime(1990, 3, 4)))
def test_process_input_format_spec(self):
owner_id = uuid.uuid4()
r = Report.select_or_insert(owner_id, 'pi')
res = r.process_input('v1:10\nv2:20',
input_type='csv',
ip_options={'delimiter': ':'},
force_header=[0])
self.assertEqual(
EnrichedTable(Table([['v1', '10'], ['v2', '20']], [0])),
res.report_instance.table)
def test_insert_and_select(self):
owner_id = uuid.uuid4()
r1 = Report.insert(owner_id, 'rep')
self.assertIsNotNone(r1)
r2 = Report.insert(owner_id, 'rep')
self.assertIsNone(r2)
rs = Report.select_by_name(owner_id, 'rep')
self.assertEqual(r1, rs)
rs2 = Report.select(rs.report_id)
self.assertEqual(rs2, rs)
r2 = Report.insert(owner_id, 'rep_2')
self.assertIsNotNone(r2)
self.assertNotEqual(r2, rs)
r3 = Report.select_or_insert(owner_id, 'rep_3')
r3_2 = Report.select(r3.report_id)
r3_3 = Report.select_or_insert(owner_id, 'rep_3')
self.assertEqual(r3, r3_2)
self.assertEqual(r3, r3_3)
def test_process_input(self):
owner_id = uuid.uuid4()
r = Report.select_or_insert(owner_id, 'pi')
dt = datetime.datetime(2010, 5, 30, 6, 30)
res = r.process_input('10 20 30',
tags=['t1', 't2', 't3'],
created=dt,
extra_ri_data=[1, 2, 3])
self.assertEqual(['t1', 't2', 't3'], res.report_instance.all_tags)
self.assertEqual(dt, res.report_instance.created)
self.assertEqual(EnrichedTable(Table([['10', '20', '30']])),
res.report_instance.table)
self.assertEqual([1, 2, 3], res.report_instance.fetch_extra_ri_data())
desc = res.report_instance.desc(True, True)
self.assertEqual(res.report_instance.report_instance_id.hex,
desc['id'])
self.assertEqual(1, len(desc['rows']))
self.assertIn(' 20 ', desc['input'])
def main():
vars = tutorial.main()
owner_id = vars['owner_id']
owner_dashboards = vars['owner_dashboards']
dashboard = vars['dashboard']
SECTION('tags')
cpu_report = Report.select_or_insert(owner_id, 'cpu_usage')
metrics = [
('user', 92.3),
('system', 3.4),
('io', 4.4),
]
cpu_report.process_input(json.dumps(metrics),
tags=['ip:192.168.1.18', 'warning'])
tile_config_1 = {
'tags': ['ip:192.168.1.18'],
'series_spec_list': [
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['user']
}),
],
}
tile_1 = Tile.insert(owner_id, cpu_report.report_id,
dashboard.dashboard_id, tile_config_1)
tile_config_2 = {
'tags': ['ip:192.168.1.18', 'warning'],
'series_spec_list': [
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['user']
}),
],
}
tile_2 = Tile.insert(owner_id, cpu_report.report_id,
dashboard.dashboard_id, tile_config_2)
def main():
vars = tutorial.main()
owner_id = vars['owner_id']
owner_dashboards = vars['owner_dashboards']
dashboard = vars['dashboard']
SECTION('Using tags for identifying entities')
from mqe.reports import Report
cpu_report = Report.select_or_insert(owner_id, 'cpu_usage')
metrics = [
('user', 42.3),
('system', 13.4),
('io', 8.4),
]
cpu_report.process_input(json.dumps(metrics), tags=['ip:192.168.1.18'])
SECTION('Creating a master tile')
from mqe.dataseries import SeriesSpec
from mqe.tiles import Tile
from mqe.layouts import place_tile, Layout, replace_tiles
dashboard = owner_dashboards.insert_dashboard('CPU')
master_tile_config = {
'tw_type':
'Range',
'tags': ['ip:192.168.1.18'],
'series_spec_list': [
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['user']
}),
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['system']
}),
],
'tile_options': {
'tile_title': 'CPU usage',
'tpcreator_uispec': [{
'tag': 'ip:192.168.1.18',
'prefix': 'ip:'
}]
}
}
master_tile = Tile.insert(owner_id, cpu_report.report_id,
dashboard.dashboard_id, master_tile_config)
print place_tile(master_tile)
SECTION('Creating tiles from a master tile')
metrics = json.dumps(metrics)
cpu_report.process_input(metrics, tags=['ip:192.168.1.30'])
cpu_report.process_input(metrics, tags=['ip:192.168.2.51'])
cpu_report.process_input(metrics, tags=['ip:192.168.2.51'])
layout = Layout.select(owner_id, dashboard.dashboard_id)
for tile in layout.tile_dict:
print tile.tags
SECTION('Synchronizing options of tpcreated tiles')
new_master_tile_config = {
'tw_type':
'Range',
'tags': ['ip:192.168.1.18'],
'series_spec_list': [
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['user']
}),
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['system']
}),
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['io']
}),
],
'tile_options': {
'tile_title': 'CPU usage',
'tpcreator_uispec': [{
'tag': 'ip:192.168.1.18',
'prefix': 'ip:'
}]
}
}
new_master_tile = Tile.insert(owner_id, cpu_report.report_id,
dashboard.dashboard_id,
new_master_tile_config)
assert replace_tiles({master_tile: new_master_tile}, for_layout_id=None)
layout = Layout.select(owner_id, dashboard.dashboard_id)
for tile in layout.tile_dict:
print len(tile.get_tile_data()['series_data'])
SECTION('Expiring tiles and promoting new masters')
from mqe.tpcreator import make_master_from_tpcreated
old_master = [tile for tile in layout.tile_dict
if tile.is_master_tile()][0]
new_chosen_master = [
tile for tile in layout.tile_dict if tile.tags == ['ip:192.168.2.51']
][0]
assert not new_chosen_master.is_master_tile()
new_master = make_master_from_tpcreated(old_master, new_chosen_master)
res = replace_tiles({
old_master: new_master,
new_chosen_master: None
},
for_layout_id=None)
print 'replaced %d tiles' % len(res.tile_replacement)
layout = Layout.select(owner_id, dashboard.dashboard_id)
tile = [
tile for tile in layout.tile_dict if tile.tags == ['ip:192.168.2.51']
][0]
print tile.is_master_tile()
def test_fetch_instances(self):
owner_id = uuid.uuid4()
r = Report.select_or_insert(owner_id, 'pi')
for i in range(4):
r.process_input(str(i), tags=['t1', 't2'])
r.process_input('4', tags=['t1'], created=datetime.datetime.utcnow())
for i in range(5, 8):
r.process_input(str(i), tags=['t1'])
r.process_input('-1',
tags=['t2'],
created=datetime.datetime.utcnow() -
datetime.timedelta(seconds=10))
all_ris = r.fetch_instances(
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow())
self.assertEqual('-1 0 1 2 3 4 5 6 7'.split(),
[ri['input_string'] for ri in all_ris])
ris = r.fetch_instances(all_ris[4].created, datetime.datetime.utcnow())
self.assertEqual('3 4 5 6 7'.split(),
[ri['input_string'] for ri in ris])
ris = r.fetch_instances(all_ris[4].created,
datetime.datetime.utcnow(),
order='desc')
self.assertEqual('7 6 5 4 3'.split(),
[ri['input_string'] for ri in ris])
ris = r.fetch_instances(all_ris[2].created, all_ris[4].created)
self.assertEqual('1 2 3'.split(), [ri['input_string'] for ri in ris])
ris = r.fetch_instances(datetime.datetime.utcnow(),
datetime.datetime.utcnow())
self.assertFalse(ris)
ris = r.fetch_instances(
datetime.datetime.utcnow() - datetime.timedelta(days=10),
datetime.datetime.utcnow() - datetime.timedelta(days=8))
self.assertFalse(ris)
ris = r.fetch_instances(datetime.datetime.utcnow() -
datetime.timedelta(days=10),
datetime.datetime.utcnow(),
order='desc',
limit=1)
self.assertEqual('7', ris[0]['input_string'])
ris = r.fetch_instances(all_ris[2].created,
all_ris[4].created,
limit=2)
self.assertEqual('1 2'.split(), [ri['input_string'] for ri in ris])
ris = r.fetch_instances(all_ris[2].created,
all_ris[4].created,
limit=2,
order='desc')
self.assertEqual('3 2'.split(), [ri['input_string'] for ri in ris])
ris = r.fetch_instances(all_ris[4].created,
datetime.datetime.utcnow(),
tags=['t2'])
self.assertEqual('3'.split(), [ri['input_string'] for ri in ris])
ris = r.fetch_instances(after=all_ris[-3].report_instance_id,
limit=100)
self.assertEqual('6 7'.split(), [ri['input_string'] for ri in ris])
ris = r.fetch_instances(after=all_ris[-3].report_instance_id,
before=all_ris[-1].report_instance_id)
self.assertEqual('6'.split(), [ri['input_string'] for ri in ris])
def main():
vars = tutorial.main()
owner_id = vars['owner_id']
owner_dashboards = vars['owner_dashboards']
dashboard = vars['dashboard']
points_report = vars['points_report']
SECTION('Label-less report instances')
numbers = Report.select_or_insert(owner_id, 'numbers')
input = """\
10 20 30
40 50 60
"""
res = numbers.process_input(input)
series_spec = SeriesSpec(1, -1, {'op': 'eq', 'args': ['1']})
print series_spec.get_cell(res.report_instance)
metric = Report.select_or_insert(owner_id, 'metric')
res = metric.process_input('32.4')
series_spec = SeriesSpec(0, -1, {'op': 'eq', 'args': ['0']})
print series_spec.get_cell(res.report_instance)
SECTION('Handling reordering of columns')
input = """\
user_name is_active points
john true 128
monique true 210
"""
res = points_report.process_input(input, force_header=[0])
series_spec = SeriesSpec(2, 0, {'op': 'eq', 'args': ['monique']})
print series_spec.get_cell(res.report_instance)
input_2 = """\
user_name points is_active
john 128 true
monique 210 true
"""
res_2 = points_report.process_input(input_2, force_header=[0])
print series_spec.get_cell(res_2.report_instance)
series_spec.promote_colnos_to_headers(res.report_instance)
print series_spec.get_cell(res_2.report_instance)
SECTION('A lower-level interface to data series')
from mqe.dataseries import SeriesDef, get_series_values
from datetime import datetime
series_spec = SeriesSpec(2, 0, {'op': 'eq', 'args': ['monique']})
series_id = SeriesDef.insert(points_report.report_id, [], series_spec)
series_def = SeriesDef.select(points_report.report_id, [], series_id)
series_values = get_series_values(series_def,
points_report,
from_dt=datetime(2017, 1, 1),
to_dt=datetime(2018, 1, 1))
point_values = [sv.value for sv in series_values]
