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 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 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)
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())