def test_service_handlers(self):
"""
Test if we can calculate metrics
"""
self.client.login(username=self.user, password=self.passwd)
for idx, l in enumerate(Layer.objects.all()):
for inum in range(0, idx + 1):
self.client.get(reverse('layer_detail', args=(l.alternate, )),
**{"HTTP_USER_AGENT": self.ua})
requests = RequestEvent.objects.all()
c = CollectorAPI()
q = requests.order_by('created')
c.process_requests(self.service, requests,
q.last().created,
q.first().created)
interval = self.service.check_interval
now = datetime.utcnow().replace(tzinfo=pytz.utc)
valid_from = now - (2 * interval)
valid_to = now
self.assertTrue(isinstance(valid_from, datetime))
self.assertTrue(isinstance(valid_to, datetime))
self.assertTrue(isinstance(interval, timedelta))
metrics = c.get_metrics_for(metric_name='request.ip',
valid_from=valid_from,
valid_to=valid_to,
interval=interval)
self.assertIsNotNone(metrics)
def handle(self, *args, **options):
self.collector = CollectorAPI()
if options['list_metrics']:
self.list_metrics()
return
interval = timedelta(seconds=options['interval'])
metric_names = options['metric_name']
resource = options['resource']
service = options['service']
label = options['label']
if not metric_names:
raise CommandError("No metric name")
if isinstance(metric_names, types.StringTypes):
metric_names = [metric_names]
for m in metric_names:
#def get_metrics_for(self, metric_name, valid_from=None, valid_to=None, interval=None, service=None, label=None, resource=None):
if options['list_labels']:
self.list_labels(m)
elif options['list_resources']:
self.list_resources(m)
else:
self.show_metrics(m,
options['since'],
options['until'],
interval,
resource=resource,
label=label)
def get(self, request, *args, **kwargs):
capi = CollectorAPI()
checks = capi.get_notifications()
data = {'status': 'ok', 'success': True, 'data': {}}
d = data['data']
d['problems'] = problems = []
d['health_level'] = 'ok'
_levels = (
'fatal',
'error',
'warning',
)
levels = set([])
for nc, ncdata in checks:
for ncd in ncdata:
levels.add(ncd.severity)
problems.append(dump(ncd, self.fields))
if levels:
for l in _levels:
if l in levels:
d['health_level'] = l
break
return json_response(data)
def test_service_handlers(self):
"""
Test if we can calculate metrics
"""
self.client.login(username=self.user, password=self.passwd)
for idx, _l in enumerate(Layer.objects.all()):
for inum in range(0, idx + 1):
self.client.get(
reverse('layer_detail',
args=(_l.alternate,
)),
**{"HTTP_USER_AGENT": self.ua})
requests = RequestEvent.objects.all()
c = CollectorAPI()
q = requests.order_by('created')
c.process_requests(
self.service,
requests,
q.last().created,
q.first().created)
interval = self.service.check_interval
now = datetime.utcnow().replace(tzinfo=pytz.utc)
valid_from = now - (2 * interval)
valid_to = now
self.assertTrue(isinstance(valid_from, datetime))
self.assertTrue(isinstance(valid_to, datetime))
self.assertTrue(isinstance(interval, timedelta))
def handle(self, *args, **options):
oservice = options['service']
if not oservice:
services = Service.objects.all()
else:
services = [oservice]
if options['list_services']:
print('available services')
for s in services:
print(' ', s.name, '(', s.url, ')')
print(' type', s.service_type.name)
print(' running on', s.host.name, s.host.ip)
print(' active:', s.active)
if s.last_check:
print(' last check:', s.last_check)
else:
print(' not checked yet')
print(' ')
return
c = CollectorAPI()
for s in services:
try:
self.run_check(s, collector=c,
since=options['since'],
until=options['until'],
force_check=options['force_check'],
format=options['format'])
except Exception, err:
log.error("Cannot collect from %s: %s", s, err, exc_info=err)
if options['halt_on_errors']:
raise
def get(self, request, *args, **kwargs):
capi = CollectorAPI()
checks = capi.get_notifications()
data = {'status': 'ok', 'success': True, 'data': {}}
d = data['data']
d['problems'] = problems = []
d['health_level'] = 'ok'
_levels = ('fatal', 'error', 'warning',)
levels = set([])
for nc, ncdata in checks:
for ncd in ncdata:
levels.add(ncd.severity)
problems.append(dump(ncd, self.fields))
if levels:
for l in _levels:
if l in levels:
d['health_level'] = l
break
return json_response(data)
def handle(self, *args, **options):
self.collector = CollectorAPI()
if options['list_metrics']:
self.list_metrics()
return
interval = timedelta(seconds=options['interval'])
metric_names = options['metric_name']
resource = options['resource']
service = options['service']
label = options['label']
if not metric_names:
raise CommandError("No metric name")
if isinstance(metric_names, types.StringTypes):
metric_names = [metric_names]
for m in metric_names:
#def get_metrics_for(self, metric_name, valid_from=None, valid_to=None, interval=None, service=None, label=None, resource=None):
if options['list_labels']:
self.list_labels(m)
elif options['list_resources']:
self.list_resources(m)
else:
self.show_metrics(m, options['since'], options['until'], interval, resource=resource, label=label)
class Command(BaseCommand):
"""
Run collecting for monitoring
"""
def add_arguments(self, parser):
parser.add_argument('-m',
'--list-metrics',
dest='list_metrics',
action='store_true',
default=False,
help=_("Show list of metrics"))
parser.add_argument('-l',
'--list-labels',
dest='list_labels',
action='store_true',
default=False,
help=_("Show list of labels for metric"))
parser.add_argument('-r',
'--list-resources',
dest='list_resources',
action='store_true',
default=False,
help=_("Show list of resources for metric"))
parser.add_argument(
'-s',
'--since',
dest='since',
default=None,
type=parse_datetime,
help=
_("Process data since specific timestamp (YYYY-MM-DD HH:MM:SS format). If not provided, last sync will be used."
))
parser.add_argument(
'-u',
'--until',
dest='until',
default=None,
type=parse_datetime,
help=
_("Process data until specific timestamp (YYYY-MM-DD HH:MM:SS format). If not provided, now will be used."
))
parser.add_argument(
'-i',
'--interval',
dest='interval',
default=60,
type=int,
help=_("Data aggregation interval in seconds (default: 60)"))
parser.add_argument('metric_name',
default=None,
nargs="?",
help=_("Metric name"))
parser.add_argument(
'-rr',
'--for-resource',
dest='resource',
type=TypeChecks.resource_type,
help=
_("Show data for specific resource in resource_type=resource_name format"
))
parser.add_argument('-ss',
'--service',
dest='service',
type=TypeChecks.service_type,
help=_("Show data for specific resource"))
parser.add_argument('-ll',
'--label',
dest='label',
type=TypeChecks.label_type,
help=_("Show data for specific label"))
def handle(self, *args, **options):
self.collector = CollectorAPI()
if options['list_metrics']:
self.list_metrics()
return
interval = timedelta(seconds=options['interval'])
metric_names = options['metric_name']
resource = options['resource']
service = options['service']
label = options['label']
if not metric_names:
raise CommandError("No metric name")
if isinstance(metric_names, types.StringTypes):
metric_names = [metric_names]
for m in metric_names:
#def get_metrics_for(self, metric_name, valid_from=None, valid_to=None, interval=None, service=None, label=None, resource=None):
if options['list_labels']:
self.list_labels(m)
elif options['list_resources']:
self.list_resources(m)
else:
self.show_metrics(m,
options['since'],
options['until'],
interval,
resource=resource,
label=label)
def list_labels(self, metric, resource=None):
labels = self.collector.get_labels_for_metric(metric,
resource=resource)
print('Labels for metric {}'.format(metric))
for label in labels:
print(' ', *label)
def list_resources(self, metric):
resources = self.collector.get_resources_for_metric(metric)
print('Resources for metric {}'.format(metric))
for res in resources:
print(' ', '='.join(res))
def show_metrics(self,
metric,
since,
until,
interval,
resource=None,
label=None,
service=None):
print('Monitoring Metric values for {}'.format(metric))
if service:
print(' for service: {} '.format(service))
if resource:
print(' for resource: {}={} '.format(resource.type, resource.name))
if label:
print(' for label: {} label'.format(label.name))
data = self.collector.get_metrics_for(metric,
valid_from=since,
valid_to=until,
interval=interval,
resource=resource,
label=label,
service=service)
print(' since {} until {}\n'.format(
data['input_valid_from'].strftime(TIMESTAMP_OUTPUT),
data['input_valid_to'].strftime(TIMESTAMP_OUTPUT)))
for row in data['data']:
val = None
if row['data']:
val = row['data'][0]['val']
print(' ', row['valid_to'].strftime(TIMESTAMP_OUTPUT), '->',
'' if not val else val)
def list_metrics(self):
_metrics = self.collector.get_metric_names()
for stype, metrics in _metrics:
print('service type', stype.name)
for m in metrics:
print(' {}[{}]'.format(m.name, m.type))
class Command(BaseCommand):
"""
Run collecting for monitoring
"""
def add_arguments(self, parser):
parser.add_argument('-m', '--list-metrics', dest='list_metrics', action='store_true', default=False,
help=_("Show list of metrics"))
parser.add_argument('-l', '--list-labels', dest='list_labels', action='store_true', default=False,
help=_("Show list of labels for metric"))
parser.add_argument('-r', '--list-resources', dest='list_resources', action='store_true', default=False,
help=_("Show list of resources for metric"))
parser.add_argument('-s', '--since', dest='since', default=None, type=parse_datetime,
help=_("Process data since specific timestamp (YYYY-MM-DD HH:MM:SS format). If not provided, last sync will be used."))
parser.add_argument('-u', '--until', dest='until', default=None, type=parse_datetime,
help=_("Process data until specific timestamp (YYYY-MM-DD HH:MM:SS format). If not provided, now will be used."))
parser.add_argument('-i', '--interval', dest='interval', default=60, type=int,
help=_("Data aggregation interval in seconds (default: 60)"))
parser.add_argument('metric_name', default=None, nargs="?", help=_("Metric name"))
parser.add_argument('-rr', '--for-resource', dest='resource', type=TypeChecks.resource_type,
help=_("Show data for specific resource in resource_type=resource_name format"))
parser.add_argument('-ss', '--service', dest='service', type=TypeChecks.service_type,
help=_("Show data for specific resource"))
parser.add_argument('-ll', '--label', dest='label', type=TypeChecks.label_type,
help=_("Show data for specific label"))
@timeout_decorator.timeout(LOCAL_TIMEOUT)
def handle(self, *args, **options):
self.collector = CollectorAPI()
if options['list_metrics']:
self.list_metrics()
return
interval = timedelta(seconds=options['interval'])
metric_names = options['metric_name']
resource = options['resource']
service = options['service']
label = options['label']
if not metric_names:
raise CommandError("No metric name")
if isinstance(metric_names, types.StringTypes):
metric_names = [metric_names]
for m in metric_names:
#def get_metrics_for(self, metric_name, valid_from=None, valid_to=None, interval=None, service=None, label=None, resource=None):
if options['list_labels']:
self.list_labels(m)
elif options['list_resources']:
self.list_resources(m)
else:
self.show_metrics(m, options['since'], options['until'], interval, resource=resource, label=label)
@timeout_decorator.timeout(LOCAL_TIMEOUT)
def list_labels(self, metric, resource=None):
labels = self.collector.get_labels_for_metric(metric, resource=resource)
print('Labels for metric {}'.format(metric))
for label in labels:
print(' ', *label)
@timeout_decorator.timeout(LOCAL_TIMEOUT)
def list_resources(self, metric):
resources = self.collector.get_resources_for_metric(metric)
print('Resources for metric {}'.format(metric))
for res in resources:
print(' ', '='.join(res))
@timeout_decorator.timeout(LOCAL_TIMEOUT)
def show_metrics(self, metric, since, until, interval, resource=None, label=None, service=None):
print('Monitoring Metric values for {}'.format(metric))
if service:
print(' for service: {} '.format(service))
if resource:
print(' for resource: {}={} '.format(resource.type, resource.name))
if label:
print(' for label: {} label'.format(label.name))
utc = pytz.utc
now = datetime.utcnow().replace(tzinfo=utc)
since = since.replace(tzinfo=utc) if since else None
until = until.replace(tzinfo=utc) if until else None
data = self.collector.get_metrics_for(metric,
valid_from=since,
valid_to=until,
interval=interval,
resource=resource,
label=label,
service=service)
print(' since {} until {}\n'.format(data['input_valid_from'].strftime(TIMESTAMP_OUTPUT),
data['input_valid_to'].strftime(TIMESTAMP_OUTPUT)))
for row in data['data']:
val = None
if row['data']:
val = row['data'][0]['val']
print(' ', row['valid_to'].strftime(TIMESTAMP_OUTPUT), '->', '' if not val else val)
@timeout_decorator.timeout(LOCAL_TIMEOUT)
def list_metrics(self):
_metrics = self.collector.get_metric_names()
for stype, metrics in _metrics:
print('service type', stype.name)
for m in metrics:
print(' {}[{}]'.format(m.name, m.type))
Metric,
ServiceTypeMetric,
MetricLabel,
MonitoredResource,
ExceptionEvent,
OWSService,
NotificationCheck,
MetricNotificationCheck,
)
from geonode.contrib.monitoring.models import do_autoconfigure
from geonode.contrib.monitoring.utils import TypeChecks, dump
from geonode.contrib.monitoring.service_handlers import exposes
# Create your views here.
capi = CollectorAPI()
class MetricsList(View):
def get(self, *args, **kwargs):
_metrics = capi.get_metric_names()
out = []
for srv, mlist in _metrics:
out.append({
'service':
srv.name,
'metrics': [{
'name': m.name,
'unit': m.unit,
'type': m.type
} for m in mlist]
def test_notifications_api(self):
capi = CollectorAPI()
start = datetime.utcnow().replace(tzinfo=pytz.utc)
start_aligned = align_period_start(start, self.service.check_interval)
end_aligned = start_aligned + self.service.check_interval
# for (metric_name, field_opt, use_service,
# use_resource, use_label, use_ows_service,
# minimum, maximum, thresholds,) in thresholds:
notifications_config = (
'geonode is not working', 'detects when requests are not handled',
(
(
'request.count',
'min_value',
False,
False,
False,
False,
0,
10,
None,
'Number of handled requests is lower than',
),
(
'response.time',
'max_value',
False,
False,
False,
False,
500,
None,
None,
'Response time is higher than',
),
))
nc = NotificationCheck.create(*notifications_config)
self.assertTrue(nc.definitions.all().count() == 2)
user = self.u2
pwd = self.passwd2
self.client.login(username=user.username, password=pwd)
for nc in NotificationCheck.objects.all():
notifications_config_url = reverse(
'monitoring:api_user_notification_config', args=(nc.id, ))
nc_form = nc.get_user_form()
self.assertTrue(nc_form)
self.assertTrue(nc_form.fields.keys())
vals = [1000000, 100000]
data = {'emails': []}
data['emails'] = '\n'.join(data['emails'])
idx = 0
for fname, field in nc_form.fields.items():
if fname in self.reserved_fields:
continue
data[fname] = vals[idx]
idx += 1
resp = self.client.post(notifications_config_url, data)
self.assertEqual(resp.status_code, 400)
vals = [7, 600]
data = {
'emails':
'\n'.join([self.u.email, self.u2.email, '*****@*****.**'])
}
idx = 0
for fname, field in nc_form.fields.items():
if fname in self.reserved_fields:
continue
data[fname] = vals[idx]
idx += 1
# data['emails'] = '\n'.join(data['emails'])
resp = self.client.post(notifications_config_url, data)
nc.refresh_from_db()
self.assertEqual(resp.status_code, 200, resp)
_emails = data['emails'].split('\n')[-1:]
_users = data['emails'].split('\n')[:-1]
self.assertEqual(set([u.email for u in nc.get_users()]),
set(_users))
self.assertEqual(set([email for email in nc.get_emails()]),
set(_emails))
metric_rq_count = Metric.objects.get(name='request.count')
metric_rq_time = Metric.objects.get(name='response.time')
MetricValue.add(metric_rq_count,
start_aligned,
end_aligned,
self.service,
label="Count",
value_raw=0,
value_num=0,
value=0)
MetricValue.add(metric_rq_time,
start_aligned,
end_aligned,
self.service,
label="Count",
value_raw=700,
value_num=700,
value=700)
nc = NotificationCheck.objects.get()
self.assertTrue(len(nc.get_emails()) > 0)
self.assertTrue(len(nc.get_users()) > 0)
self.assertEqual(nc.last_send, None)
self.assertTrue(nc.can_send)
self.assertEqual(len(mail.outbox), 0)
# make sure inactive will not trigger anything
nc.active = False
nc.save()
capi.emit_notifications(start)
self.assertEqual(len(mail.outbox), 0)
nc.active = True
nc.save()
capi.emit_notifications(start)
self.assertTrue(nc.receivers.all().count() > 0)
self.assertEqual(len(mail.outbox), nc.receivers.all().count())
nc.refresh_from_db()
notifications_url = reverse('monitoring:api_user_notifications')
nresp = self.client.get(notifications_url)
self.assertEqual(nresp.status_code, 200)
ndata = json.loads(nresp.content)
self.assertEqual(
set([n['id'] for n in ndata['data']]),
set(NotificationCheck.objects.all().values_list('id', flat=True)))
self.assertTrue(isinstance(nc.last_send, datetime))
self.assertFalse(nc.can_send)
mail.outbox = []
self.assertEqual(len(mail.outbox), 0)
capi.emit_notifications(start)
self.assertEqual(len(mail.outbox), 0)
nc.last_send = start - nc.grace_period
nc.save()
self.assertTrue(nc.can_send)
mail.outbox = []
self.assertEqual(len(mail.outbox), 0)
capi.emit_notifications(start)
self.assertEqual(len(mail.outbox), nc.receivers.all().count())
def test_notifications_api(self):
capi = CollectorAPI()
start = datetime.utcnow().replace(tzinfo=pytz.utc)
start_aligned = align_period_start(start, self.service.check_interval)
end_aligned = start_aligned + self.service.check_interval
# for (metric_name, field_opt, use_service,
# use_resource, use_label, use_ows_service,
# minimum, maximum, thresholds,) in thresholds:
notifications_config = ('geonode is not working',
'detects when requests are not handled',
(('request.count', 'min_value', False, False,
False, False, 0, 10, None, 'Number of handled requests is lower than',),
('response.time', 'max_value', False, False,
False, False, 500, None, None, 'Response time is higher than',),))
nc = NotificationCheck.create(*notifications_config)
self.assertTrue(nc.definitions.all().count() == 2)
user = self.u2
pwd = self.passwd2
self.client.login(username=user.username, password=pwd)
for nc in NotificationCheck.objects.all():
notifications_config_url = reverse(
'monitoring:api_user_notification_config', args=(nc.id,))
nc_form = nc.get_user_form()
self.assertTrue(nc_form)
self.assertTrue(nc_form.fields.keys())
vals = [1000000, 100000]
data = {'emails': []}
data['emails'] = '\n'.join(data['emails'])
idx = 0
for fname, field in nc_form.fields.items():
if fname in self.reserved_fields:
continue
data[fname] = vals[idx]
idx += 1
resp = self.client.post(notifications_config_url, data)
self.assertEqual(resp.status_code, 400)
vals = [7, 600]
data = {'emails': '\n'.join(
[self.u.email,
self.u2.email,
'*****@*****.**'])}
idx = 0
for fname, field in nc_form.fields.items():
if fname in self.reserved_fields:
continue
data[fname] = vals[idx]
idx += 1
# data['emails'] = '\n'.join(data['emails'])
resp = self.client.post(notifications_config_url, data)
nc.refresh_from_db()
self.assertEqual(resp.status_code, 200, resp)
_emails = data['emails'].split('\n')[-1:]
_users = data['emails'].split('\n')[:-1]
self.assertEqual(
set([u.email for u in nc.get_users()]),
set(_users))
self.assertEqual(
set([email for email in nc.get_emails()]),
set(_emails))
metric_rq_count = Metric.objects.get(name='request.count')
metric_rq_time = Metric.objects.get(name='response.time')
MetricValue.add(metric_rq_count,
start_aligned,
end_aligned,
self.service,
label="Count",
value_raw=0,
value_num=0,
value=0)
MetricValue.add(metric_rq_time,
start_aligned,
end_aligned,
self.service,
label="Count",
value_raw=700,
value_num=700,
value=700)
nc = NotificationCheck.objects.get()
self.assertTrue(len(nc.get_emails()) > 0)
self.assertTrue(len(nc.get_users()) > 0)
self.assertEqual(nc.last_send, None)
self.assertTrue(nc.can_send)
self.assertEqual(len(mail.outbox), 0)
# make sure inactive will not trigger anything
nc.active = False
nc.save()
capi.emit_notifications(start)
self.assertEqual(len(mail.outbox), 0)
nc.active = True
nc.save()
capi.emit_notifications(start)
self.assertTrue(nc.receivers.all().count() > 0)
self.assertEqual(len(mail.outbox), nc.receivers.all().count())
nc.refresh_from_db()
notifications_url = reverse('monitoring:api_user_notifications')
nresp = self.client.get(notifications_url)
self.assertEqual(nresp.status_code, 200)
ndata = json.loads(nresp.content)
self.assertEqual(set([n['id'] for n in ndata['data']]),
set(NotificationCheck.objects.all().values_list('id', flat=True)))
self.assertTrue(isinstance(nc.last_send, datetime))
self.assertFalse(nc.can_send)
mail.outbox = []
self.assertEqual(len(mail.outbox), 0)
capi.emit_notifications(start)
self.assertEqual(len(mail.outbox), 0)
nc.last_send = start - nc.grace_period
nc.save()
self.assertTrue(nc.can_send)
mail.outbox = []
self.assertEqual(len(mail.outbox), 0)
capi.emit_notifications(start)
self.assertEqual(len(mail.outbox), nc.receivers.all().count())