def handle(self, *args, **options):
# Exit early if MONITORING_ENABLED=False
if not settings.MONITORING_ENABLED:
return
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, str):
metric_names = [metric_names]
for m in metric_names:
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):
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 lyr in _levels:
if lyr in levels:
d['health_level'] = lyr
break
return json_response(data)
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 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 _init_server(self):
"""
Initializing Dispatcher with basic information
:return: None
"""
# self.manage_task()
if IS_ENABLED:
self._centralized_server = self._get_centralized_server()
if self._centralized_server:
# self._centralized_server.sync_periodic_task()
host = self._centralized_server.host
port = self._centralized_server.port
db_path = self._centralized_server.db_path if self._centralized_server.db_path else None
self._logger = logging.getLogger('geonode-logstash-logger')
self._logger.setLevel(logging.INFO)
self._handler = GeonodeAsynchronousLogstashHandler(
host,
port,
database_path=db_path,
transport=GeonodeTcpTransport)
self._logger.addHandler(self._handler)
# self.client_ip = socket.gethostbyname(socket.gethostname())
self.client_ip = self._centralized_server.local_ip
self._collector = CollectorAPI()
self._set_time_range()
else:
log.error(
"Monitoring/analytics disabled, centralized server cannot be set up."
)
def test_metric_data_endpoints(self):
"""
Test GeoNode collect metrics
"""
# Login (optional)
self.client.force_login(self.u)
self.assertTrue(get_user(self.client).is_authenticated())
_l = Layer.objects.all().first()
# Event
self.client.get(reverse('layer_detail', args=(_l.alternate, )),
**{"HTTP_USER_AGENT": self.ua})
requests = RequestEvent.objects.all()
self.assertTrue(requests.count() > 0)
# First check for MetricValue table
self.assertTrue(MetricValue.objects.all().count() == 0)
# Metric data collection
collector = CollectorAPI()
q = requests.order_by('created')
collector.process_requests(self.service, requests,
q.first().created,
q.last().created)
# Second check for MetricValue table
self.assertTrue(MetricValue.objects.all().count() >= 0)
# Call endpoint
url = "%s?%s" % (
reverse('monitoring:api_metric_data', args={'request.users'}),
'last=86400&interval=86400&event_type=view&resource_type=layer')
response = self.client.get(url) # noqa
def test_service_handlers(self):
"""
Test if we can calculate metrics
"""
self.client.force_login(self.u)
self.assertTrue(get_user(self.client).is_authenticated())
_l = file_upload(
os.path.join(gisdata.VECTOR_DATA,
"san_andres_y_providencia_poi.shp"),
name="san_andres_y_providencia_poi",
user=self.u,
overwrite=True,
)
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})
# Works only with Postgres
requests = RequestEvent.objects.all()
c = CollectorAPI()
q = requests.order_by('created')
c.process_requests(self.service, requests,
q.first().created,
q.last().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))
# Works only with Postgres
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):
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 as err:
log.error("Cannot collect from %s: %s", s, err, exc_info=err)
if options['halt_on_errors']:
raise
if not options['do_not_clear']:
log.info("Clearing old data")
c.clear_old_data()
if options['emit_notifications']:
log.info("Processing notifications for %s", options['until'])
s = Service.objects.first()
interval = s.check_interval
now = datetime.utcnow().replace(tzinfo=pytz.utc)
notifications_check = now - interval
c.emit_notifications() #notifications_check)
def handle(self, *args, **kwargs):
c = CollectorAPI()
c.aggregate_past_periods()
Metric,
ServiceTypeMetric,
MetricLabel,
MonitoredResource,
ExceptionEvent,
EventType,
NotificationCheck,
MetricNotificationCheck,
)
from geonode.monitoring.models import do_autoconfigure
from geonode.monitoring.utils import TypeChecks, dump, extend_datetime_input_formats
from geonode.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 collect_metric(**options):
from geonode.celery_app import app
from geonode.tasks.tasks import memcache_lock
from geonode.monitoring.models import Service
from geonode.monitoring.collector import CollectorAPI
_start_time = None
_end_time = None
# The cache key consists of the task name and the MD5 digest
# of the name.
name = b'collect_metric'
hexdigest = md5(name).hexdigest()
lock_id = '{0}-lock-{1}'.format(name, hexdigest)
_start_time = datetime.utcnow().isoformat()
log.info('[{}] Collecting Metrics - started @ {}'.format(
lock_id, _start_time))
with memcache_lock(lock_id, app.oid) as acquired:
if acquired:
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:
run_check(s,
collector=c,
since=options['since'],
until=options['until'],
force_check=options['force_check'],
format=options['format'])
except Exception as err:
log.error("Cannot collect from %s: %s",
s,
err,
exc_info=err)
if options['halt_on_errors']:
raise
if not options['do_not_clear']:
log.debug("Clearing old data")
c.clear_old_data()
if options['emit_notifications']:
log.debug("Processing notifications for %s", options['until'])
# s = Service.objects.first()
# interval = s.check_interval
# now = datetime.utcnow().replace(tzinfo=pytz.utc)
# notifications_check = now - interval
c.emit_notifications() # notifications_check))
_end_time = datetime.utcnow().isoformat()
log.info('[{}] Collecting Metrics - finished @ {}'.format(
lock_id, _end_time))
return (_start_time, _end_time)
def collect_metric(**options):
from geonode.tasks.tasks import memcache_lock
from geonode.monitoring.models import Service
from geonode.monitoring.collector import CollectorAPI
_start_time = None
_end_time = None
# The cache key consists of the task name and the MD5 digest
# of the name.
name = b'collect_metric'
hexdigest = md5(name).hexdigest()
lock_id = f'{name.decode()}-lock-{hexdigest}'
_start_time = _end_time = datetime.utcnow().isoformat()
log.info('[{}] Collecting Metrics - started @ {}'.format(
lock_id, _start_time))
lock = memcache_lock(lock_id)
if lock.acquire(blocking=False) is True:
log.info('[{}] Collecting Metrics - [...acquired lock] @ {}'.format(
lock_id, _start_time))
try:
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:
run_check(s,
collector=c,
since=options['since'],
until=options['until'],
force_check=options['force_check'],
format=options['format'])
except Exception as e:
log.warning(e)
if not options['do_not_clear']:
log.info("Clearing old data")
c.clear_old_data()
if options['emit_notifications']:
log.info("Processing notifications for %s", options['until'])
# s = Service.objects.first()
# interval = s.check_interval
# now = datetime.utcnow().replace(tzinfo=pytz.utc)
# notifications_check = now - interval
c.emit_notifications() # notifications_check))
_end_time = datetime.utcnow().isoformat()
log.info('[{}] Collecting Metrics - finished @ {}'.format(
lock_id, _end_time))
except Exception as e:
log.info('[{}] Collecting Metrics - errored @ {}'.format(
lock_id, _end_time))
log.exception(e)
finally:
lock.release()
log.info('[{}] Collecting Metrics - exit @ {}'.format(lock_id, _end_time))
return (_start_time, _end_time)
def handle(self, *args, **kwargs):
# Exit early if MONITORING_ENABLED=False
if not settings.MONITORING_ENABLED:
return
c = CollectorAPI()
c.aggregate_past_periods()