diff --git a/accountstats/views.py b/accountstats/views.py
index 0399274..3997caa 100644
--- a/accountstats/views.py
+++ b/accountstats/views.py
@@ -46,7 +46,7 @@ def account(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 def graph_application(request, account):
     data = []
     query_alloc = 'slurm_job:process_usage:sum_account{{account="{}", {}}}'.format(account, prom.get_filter())
@@ -70,7 +70,11 @@ def graph_application(request, account):
 
 def graph(request, query, stacked=True, unit=None):
     data = []
-    stats_alloc = prom.query_prometheus_multiple(query, request.start, request.end, step=request.step)
+    stats_alloc = prom.query_prometheus_multiple(
+        query,
+        request.start,
+        end=request.end,
+        step=request.step)
     for line in stats_alloc:
         user = line['metric']['user']
         x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
@@ -94,7 +98,7 @@ def graph(request, query, stacked=True, unit=None):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 def graph_cpu_allocated(request, account):
     query_alloc = 'sum(slurm_job:allocated_core:count_user_account{{account="{}", {}}}) by (user)'.format(account, prom.get_filter())
     return graph(request, query_alloc, unit=_('cores'))
@@ -102,7 +106,7 @@ def graph_cpu_allocated(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 def graph_cpu_used(request, account):
     query_used = 'sum(slurm_job:used_core:sum_user_account{{account="{}", {}}}) by (user)'.format(account, prom.get_filter())
     return graph(request, query_used, unit=_('cores'))
@@ -110,7 +114,7 @@ def graph_cpu_used(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 def graph_cpu_wasted(request, account):
     query_alloc = 'clamp_min(sum(slurm_job:allocated_core:count_user_account{{account="{}", {}}}) by (user) - sum(slurm_job:used_core:sum_user_account{{account="{}", {}}}) by (user), 0)'.format(account, prom.get_filter(), account, prom.get_filter())
     return graph(request, query_alloc, stacked=False, unit=_('cores'))
@@ -118,7 +122,7 @@ def graph_cpu_wasted(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 def graph_mem_allocated(request, account):
     query_alloc = 'sum(slurm_job:allocated_memory:sum_user_account{{account="{}", {}}}) by (user) /(1024*1024*1024)'.format(account, prom.get_filter())
     return graph(request, query_alloc, unit=_('GiB'))
@@ -126,7 +130,7 @@ def graph_mem_allocated(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 def graph_mem_used(request, account):
     query_used = 'sum(slurm_job:rss_memory:sum_user_account{{account="{}", {}}}) by (user) /(1024*1024*1024)'.format(account, prom.get_filter())
     return graph(request, query_used, unit=_('GiB'))
@@ -134,7 +138,7 @@ def graph_mem_used(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 def graph_mem_wasted(request, account):
     query_alloc = 'clamp_min(sum(slurm_job:allocated_memory:sum_user_account{{account="{}", {}}}) by (user) - sum(slurm_job:rss_memory:sum_user_account{{account="{}", {}}}) by (user), 0) /(1024*1024*1024)'.format(account, prom.get_filter(), account, prom.get_filter())
     return graph(request, query_alloc, stacked=False, unit=_('GiB'))
@@ -142,7 +146,7 @@ def graph_mem_wasted(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(hours=6))
+@parse_start_end(default_start=datetime.now() - timedelta(hours=6), minimum=prom.rate('lustre_exporter'))
 def graph_lustre_mdt(request, account):
     query = 'sum(rate(lustre_job_stats_total{{component=~"mdt",account=~"{}", {}}}[5m])) by (user, fs) !=0'.format(account, prom.get_filter())
     return graph(request, query, stacked=False, unit=_('IOPS'))
@@ -150,11 +154,16 @@ def graph_lustre_mdt(request, account):
 
 @login_required
 @account_or_staff
+@parse_start_end(default_start=datetime.now() - timedelta(hours=6), minimum=prom.rate('lustre_exporter'))
 def graph_lustre_ost(request, account):
     data = []
     for i in ['read', 'write']:
         query = '(sum(rate(lustre_job_{}_bytes_total{{component=~"ost",account=~"{}",target=~".*-OST.*", {}}}[5m])) by (user, fs)) / (1024*1024)'.format(i, account, prom.get_filter())
-        stats = prom.query_prometheus_multiple(query, datetime.now() - timedelta(hours=6), datetime.now())
+        stats = prom.query_prometheus_multiple(
+            query,
+            request.start,
+            request.end,
+            step=request.step)
 
         for line in stats:
             fs = line['metric']['fs']
@@ -183,7 +192,7 @@ def graph_lustre_ost(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 def graph_gpu_allocated(request, account):
     query = 'sum(slurm_job:allocated_gpu:count_user_account{{account="{}", {}}}) by (user)'.format(account, prom.get_filter())
     return graph(request, query, unit=_('GPUs'))
@@ -191,7 +200,7 @@ def graph_gpu_allocated(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 def graph_gpu_used(request, account):
     query = 'sum(slurm_job:used_gpu:sum_user_account{{account="{}", {}}}) by (user)'.format(account, prom.get_filter())
     return graph(request, query, unit=_('GPUs'))
@@ -199,7 +208,7 @@ def graph_gpu_used(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 def graph_gpu_wasted(request, account):
     query = 'sum(slurm_job:allocated_gpu:count_user_account{{account="{}", {}}}) by (user) - sum(slurm_job:used_gpu:sum_user_account{{account="{}", {}}}) by (user)'.format(account, prom.get_filter(), account, prom.get_filter())
     return graph(request, query, stacked=False, unit=_('GPUs'))
@@ -207,7 +216,7 @@ def graph_gpu_wasted(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 # kinda broken when using multiple GPUs
 def graph_gpu_power_allocated(request, account):
     query = 'count(slurm_job_power_gpu{{account="{}", {}}}) by (user) * 300'.format(account, prom.get_filter())
@@ -216,7 +225,7 @@ def graph_gpu_power_allocated(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 # kinda broken when using multiple GPUs
 def graph_gpu_power_used(request, account):
     query = 'sum(slurm_job_power_gpu{{account="{}", {}}}) by (user) / 1000'.format(account, prom.get_filter())
@@ -225,7 +234,7 @@ def graph_gpu_power_used(request, account):
 
 @login_required
 @account_or_staff
-@parse_start_end(default_start=datetime.now() - timedelta(days=30))
+@parse_start_end(default_start=datetime.now() - timedelta(days=30), minimum=prom.rate('slurm-job-exporter'))
 # kinda broken when using multiple GPUs
 def graph_gpu_power_wasted(request, account):
     query = '(count(slurm_job_power_gpu{{account="{}", {}}}) by (user) * 300) - (sum(slurm_job_power_gpu{{account="{}", {}}}) by (user) / 1000)'.format(account, prom.get_filter(), account, prom.get_filter())
@@ -245,7 +254,7 @@ def graph_gpu_priority(request, account):
 
 
 # auth done in functions above
-@parse_start_end(default_start=datetime.now() - timedelta(days=90))
+@parse_start_end(default_start=datetime.now() - timedelta(days=90), minimum=prom.rate('slurm-job-exporter'))
 def graph_cpu_or_gpu_priority(request, account, gpu_or_cpu):
     data = []
     if gpu_or_cpu == 'gpu':
diff --git a/cloudstats/views.py b/cloudstats/views.py
index 2f2b2dc..7fbac91 100644
--- a/cloudstats/views.py
+++ b/cloudstats/views.py
@@ -1,6 +1,6 @@
 from django.shortcuts import render
 from django.http import JsonResponse
-from userportal.common import openstackproject_or_staff, cloud_projects_by_user, request_to_username, staff, Prometheus, query_time
+from userportal.common import openstackproject_or_staff, cloud_projects_by_user, request_to_username, staff, Prometheus, parse_start_end
 from userportal.common import anonymize as a
 from django.conf import settings
 from datetime import datetime, timedelta
@@ -63,13 +63,17 @@ def instance(request, project, uuid):
 
 @login_required
 @openstackproject_or_staff
+@parse_start_end(minimum=prom.rate('libvirtd_exporter'))
 def project_graph_cpu(request, project):
     data = []
-    timing = query_time(request)
     query_used = 'sum(rate(libvirtd_domain_vcpu_time{{project_name="{project}", {filter}}}[1m])) by (uuid,instance_name) / 1000000000'.format(
         project=project,
         filter=prom.get_filter('cloudstats'))
-    stats_used = prom.query_prometheus_multiple(query_used, timing[0], step=timing[1])
+    stats_used = prom.query_prometheus_multiple(
+        query_used,
+        request.start,
+        end=request.end,
+        step=request.step)
 
     # Only show UUID if required
     instance_names = []
@@ -97,7 +101,11 @@ def project_graph_cpu(request, project):
     query_running = 'sum(count(libvirtd_domain_vcpu_time{{project_name="{project}", {filter}}}))'.format(
         project=project,
         filter=prom.get_filter('cloudstats'))
-    stats_running = prom.query_prometheus_multiple(query_running, timing[0], step=timing[1])
+    stats_running = prom.query_prometheus_multiple(
+        query_running,
+        request.start,
+        end=request.end,
+        step=request.step)
     for line in stats_running:
         x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
         y = line['y']
@@ -120,12 +128,16 @@ def project_graph_cpu(request, project):
 
 @login_required
 @staff
+@parse_start_end(minimum=prom.rate('libvirtd_exporter'))
 def projects_graph_cpu(request):
     data = []
-    timing = query_time(request)
     query_used = 'sum(rate(libvirtd_domain_vcpu_time{{ {filter} }}[5m])) by (project_name) / 1000000000'.format(
         filter=prom.get_filter('cloudstats'))
-    stats_used = prom.query_prometheus_multiple(query_used, timing[0], step=timing[1])
+    stats_used = prom.query_prometheus_multiple(
+        query_used,
+        request.start,
+        end=request.end,
+        step=request.step)
     for line in stats_used:
         data.append({
             'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x'])),
@@ -138,7 +150,11 @@ def projects_graph_cpu(request):
 
     query_running = 'sum(count(libvirtd_domain_vcpu_time{{ {filter} }})) by (project_name)'.format(
         filter=prom.get_filter('cloudstats'))
-    stats_running = prom.query_prometheus_multiple(query_running, timing[0], step=timing[1])
+    stats_running = prom.query_prometheus_multiple(
+        query_running,
+        request.start,
+        end=request.end,
+        step=request.step)
     for line in stats_running:
         data.append({
             'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x'])),
@@ -158,14 +174,18 @@ def projects_graph_cpu(request):
 
 @login_required
 @openstackproject_or_staff
+@parse_start_end(minimum=prom.rate('libvirtd_exporter'))
 def instance_graph_cpu(request, project, uuid):
     data = []
-    timing = query_time(request)
     query_used = 'rate(libvirtd_domain_vcpu_time{{project_name="{project}", uuid="{uuid}", {filter}}}[1m]) / 1000000000'.format(
         project=project,
         uuid=uuid,
         filter=prom.get_filter('cloudstats'))
-    stats_used = prom.query_prometheus_multiple(query_used, timing[0], step=timing[1])
+    stats_used = prom.query_prometheus_multiple(
+        query_used,
+        request.start,
+        end=request.end,
+        step=request.step)
 
     for line in stats_used:
         x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
@@ -184,7 +204,11 @@ def instance_graph_cpu(request, project, uuid):
         project=project,
         uuid=uuid,
         filter=prom.get_filter('cloudstats'))
-    stats_running = prom.query_prometheus_multiple(query_running, timing[0], step=timing[1])
+    stats_running = prom.query_prometheus_multiple(
+        query_running,
+        request.start,
+        end=request.end,
+        step=request.step)
     for line in stats_running:
         x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
         y = line['y']
@@ -207,13 +231,17 @@ def instance_graph_cpu(request, project, uuid):
 
 @login_required
 @openstackproject_or_staff
+@parse_start_end(minimum=prom.rate('libvirtd_exporter'))
 def project_graph_memory(request, project):
     data = []
-    timing = query_time(request)
     query_used = '(libvirtd_domain_balloon_current{{project_name="{project}", {filter}}} - libvirtd_domain_balloon_usable{{project_name="{project}", {filter}}})/1024/1024'.format(
         project=project,
         filter=prom.get_filter('cloudstats'))
-    stats_used = prom.query_prometheus_multiple(query_used, timing[0], step=timing[1])
+    stats_used = prom.query_prometheus_multiple(
+        query_used,
+        request.start,
+        end=request.end,
+        step=request.step)
 
     # Only show UUID if required
     instance_names = []
@@ -240,7 +268,11 @@ def project_graph_memory(request, project):
     query_running = 'sum(libvirtd_domain_balloon_current{{project_name="{project}", {filter}}})/1024/1024'.format(
         project=project,
         filter=prom.get_filter('cloudstats'))
-    stats_running = prom.query_prometheus_multiple(query_running, timing[0], step=timing[1])
+    stats_running = prom.query_prometheus_multiple(
+        query_running,
+        request.start,
+        end=request.end,
+        step=request.step)
     for line in stats_running:
         x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
         y = line['y']
@@ -264,14 +296,18 @@ def project_graph_memory(request, project):
 
 @login_required
 @openstackproject_or_staff
+@parse_start_end(minimum=prom.rate('libvirtd_exporter'))
 def instance_graph_memory(request, project, uuid):
     data = []
-    timing = query_time(request)
     query_used = '(libvirtd_domain_balloon_current{{project_name="{project}", uuid="{uuid}", {filter}}} - libvirtd_domain_balloon_usable{{project_name="{project}", uuid="{uuid}", {filter}}})/1024/1024'.format(
         project=project,
         uuid=uuid,
         filter=prom.get_filter('cloudstats'))
-    stats_used = prom.query_prometheus_multiple(query_used, timing[0], step=timing[1])
+    stats_used = prom.query_prometheus_multiple(
+        query_used,
+        request.start,
+        end=request.end,
+        step=request.step)
 
     for line in stats_used:
         x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
@@ -288,7 +324,11 @@ def instance_graph_memory(request, project, uuid):
         project=project,
         uuid=uuid,
         filter=prom.get_filter('cloudstats'))
-    stats_running = prom.query_prometheus_multiple(query_running, timing[0], step=timing[1])
+    stats_running = prom.query_prometheus_multiple(
+        query_running,
+        request.start,
+        end=request.end,
+        step=request.step)
     for line in stats_running:
         x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
         y = line['y']
@@ -312,12 +352,16 @@ def instance_graph_memory(request, project, uuid):
 
 @login_required
 @staff
+@parse_start_end(minimum=prom.rate('libvirtd_exporter'))
 def projects_graph_mem(request):
     data = []
-    timing = query_time(request)
     query_used = 'sum((libvirtd_domain_balloon_current{{ {filter} }} - libvirtd_domain_balloon_usable{{ {filter} }})/1024/1024) by (project_name)'.format(
         filter=prom.get_filter('cloudstats'))
-    stats_used = prom.query_prometheus_multiple(query_used, timing[0], step=timing[1])
+    stats_used = prom.query_prometheus_multiple(
+        query_used,
+        request.start,
+        end=request.end,
+        step=request.step)
     for line in stats_used:
         data.append({
             'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x'])),
@@ -330,7 +374,11 @@ def projects_graph_mem(request):
 
     query_running = 'sum((libvirtd_domain_balloon_current{{ {filter} }})/1024/1024)'.format(
         filter=prom.get_filter('cloudstats'))
-    stats_running = prom.query_prometheus_multiple(query_running, timing[0], step=timing[1])
+    stats_running = prom.query_prometheus_multiple(
+        query_running,
+        request.start,
+        end=request.end,
+        step=request.step)
     for line in stats_running:
         data.append({
             'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x'])),
@@ -352,16 +400,20 @@ def projects_graph_mem(request):
 
 @login_required
 @openstackproject_or_staff
+@parse_start_end(minimum=prom.rate('libvirtd_exporter'))
 def project_graph_disk_bandwidth(request, project):
     data = []
-    timing = query_time(request)
 
     for direction in ['read', 'write']:
         query_bandwidth = 'rate(libvirtd_domain_block_{direction}_bytes{{project_name="{project}", {filter}}}[1m])/1024/1024'.format(
             direction=direction,
             project=project,
             filter=prom.get_filter('cloudstats'))
-        stats_bandwidth = prom.query_prometheus_multiple(query_bandwidth, timing[0], step=timing[1])
+        stats_bandwidth = prom.query_prometheus_multiple(
+            query_bandwidth,
+            request.start,
+            end=request.end,
+            step=request.step)
 
         # Only show UUID if required
         instance_names = []
@@ -399,9 +451,9 @@ def project_graph_disk_bandwidth(request, project):
 
 @login_required
 @openstackproject_or_staff
+@parse_start_end(minimum=prom.rate('libvirtd_exporter'))
 def instance_graph_disk_bandwidth(request, project, uuid):
     data = []
-    timing = query_time(request)
 
     for direction in ['read', 'write']:
         query_bandwidth = 'rate(libvirtd_domain_block_{direction}_bytes{{project_name="{project}", uuid="{uuid}", {filter}}}[1m])/1024/1024'.format(
@@ -409,7 +461,11 @@ def instance_graph_disk_bandwidth(request, project, uuid):
             project=project,
             uuid=uuid,
             filter=prom.get_filter('cloudstats'))
-        stats_bandwidth = prom.query_prometheus_multiple(query_bandwidth, timing[0], step=timing[1])
+        stats_bandwidth = prom.query_prometheus_multiple(
+            query_bandwidth,
+            request.start,
+            end=request.end,
+            step=request.step)
 
         for line in stats_bandwidth:
             x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
@@ -438,16 +494,20 @@ def instance_graph_disk_bandwidth(request, project, uuid):
 
 @login_required
 @openstackproject_or_staff
+@parse_start_end(minimum=prom.rate('libvirtd_exporter'))
 def project_graph_disk_iops(request, project):
     data = []
-    timing = query_time(request)
 
     for direction in ['read', 'write']:
         query_bandwidth = 'rate(libvirtd_domain_block_{direction}_requests{{project_name="{project}", {filter}}}[1m])'.format(
             direction=direction,
             project=project,
             filter=prom.get_filter('cloudstats'))
-        stats_bandwidth = prom.query_prometheus_multiple(query_bandwidth, timing[0], step=timing[1])
+        stats_bandwidth = prom.query_prometheus_multiple(
+            query_bandwidth,
+            request.start,
+            end=request.end,
+            step=request.step)
 
         # Only show UUID if required
         instance_names = []
@@ -484,9 +544,9 @@ def project_graph_disk_iops(request, project):
 
 @login_required
 @openstackproject_or_staff
+@parse_start_end(minimum=prom.rate('libvirtd_exporter'))
 def instance_graph_disk_iops(request, project, uuid):
     data = []
-    timing = query_time(request)
 
     for direction in ['read', 'write']:
         query_bandwidth = 'rate(libvirtd_domain_block_{direction}_requests{{project_name="{project}", uuid="{uuid}", {filter}}}[1m])'.format(
@@ -494,7 +554,11 @@ def instance_graph_disk_iops(request, project, uuid):
             project=project,
             uuid=uuid,
             filter=prom.get_filter('cloudstats'))
-        stats_bandwidth = prom.query_prometheus_multiple(query_bandwidth, timing[0], step=timing[1])
+        stats_bandwidth = prom.query_prometheus_multiple(
+            query_bandwidth,
+            request.start,
+            end=request.end,
+            step=request.step)
 
         for line in stats_bandwidth:
             x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
@@ -521,16 +585,20 @@ def instance_graph_disk_iops(request, project, uuid):
 
 @login_required
 @openstackproject_or_staff
+@parse_start_end(minimum=prom.rate('libvirtd_exporter'))
 def project_graph_network_bandwidth(request, project):
     data = []
-    timing = query_time(request)
 
     for direction in ['rx', 'tx']:
         query_bandwidth = 'rate(libvirtd_domain_net_{direction}_bytes{{project_name="{project}", {filter}}}[1m])/1024/1024'.format(
             direction=direction,
             project=project,
             filter=prom.get_filter('cloudstats'))
-        stats_bandwidth = prom.query_prometheus_multiple(query_bandwidth, timing[0], step=timing[1])
+        stats_bandwidth = prom.query_prometheus_multiple(
+            query_bandwidth,
+            request.start,
+            end=request.end,
+            step=request.step)
 
         # Only show UUID if required
         instance_names = []
@@ -568,9 +636,9 @@ def project_graph_network_bandwidth(request, project):
 
 @login_required
 @openstackproject_or_staff
+@parse_start_end(minimum=prom.rate('libvirtd_exporter'))
 def instance_graph_network_bandwidth(request, project, uuid):
     data = []
-    timing = query_time(request)
 
     for direction in ['rx', 'tx']:
         query_bandwidth = 'rate(libvirtd_domain_net_{direction}_bytes{{project_name="{project}", uuid="{uuid}", {filter}}}[1m])/1024/1024'.format(
@@ -578,7 +646,11 @@ def instance_graph_network_bandwidth(request, project, uuid):
             project=project,
             uuid=uuid,
             filter=prom.get_filter('cloudstats'))
-        stats_bandwidth = prom.query_prometheus_multiple(query_bandwidth, timing[0], step=timing[1])
+        stats_bandwidth = prom.query_prometheus_multiple(
+            query_bandwidth,
+            request.start,
+            end=request.end,
+            step=request.step)
 
         for line in stats_bandwidth:
             x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
diff --git a/jobstats/templates/jobstats/job.html b/jobstats/templates/jobstats/job.html
index d0458de..9b0bb46 100644
--- a/jobstats/templates/jobstats/job.html
+++ b/jobstats/templates/jobstats/job.html
@@ -794,45 +794,45 @@ <h3 class="card-title">{% translate "Power used" %}</h3>
   {% include "notes.js" %}
 
   <script>
-  loadGraph('graph_cpu', 'graph/cpu.json?step={{step}}');
-  loadGraph('graph_mem', 'graph/mem.json?step={{step}}');
-  loadGraph('graph_thread', 'graph/thread.json?step={{step}}');
+  loadGraph('graph_cpu', 'graph/cpu.json');
+  loadGraph('graph_mem', 'graph/mem.json');
+  loadGraph('graph_thread', 'graph/thread.json');
   {% if 'lustre_exporter' in settings.EXPORTER_INSTALLED %}
-    loadGraph('graph_lustre_mdt', 'graph/lustre_mdt.json?step={{step}}');
-    loadGraph('graph_lustre_ost', 'graph/lustre_ost.json?step={{step}}');
+    loadGraph('graph_lustre_mdt', 'graph/lustre_mdt.json');
+    loadGraph('graph_lustre_ost', 'graph/lustre_ost.json');
   {% endif %}
 
   {% if 'pcm-sensor-server' in settings.EXPORTER_INSTALLED %}
-    loadGraph('graph_l2_rate', 'graph/l2_rate.json?step={{step}}');
-    loadGraph('graph_l3_rate', 'graph/l3_rate.json?step={{step}}');
-    loadGraph('graph_ipc', 'graph/ipc.json?step={{step}}');
+    loadGraph('graph_l2_rate', 'graph/l2_rate.json');
+    loadGraph('graph_l3_rate', 'graph/l3_rate.json');
+    loadGraph('graph_ipc', 'graph/ipc.json');
   {% endif %}
 
   {% if gpu_count > 0 %}
-    loadGraph('graph_gpu_utilization', 'graph/gpu_utilization.json?step={{step}}');
-    loadGraph('graph_gpu_memory_utilization', 'graph/gpu_memory_utilization.json?step={{step}}');
-    loadGraph('graph_gpu_memory', 'graph/gpu_memory.json?step={{step}}');
-    loadGraph('graph_gpu_power', 'graph/gpu_power.json?step={{step}}');
-    loadGraph('graph_gpu_pcie', 'graph/gpu_pcie.json?step={{step}}');
+    loadGraph('graph_gpu_utilization', 'graph/gpu_utilization.json');
+    loadGraph('graph_gpu_memory_utilization', 'graph/gpu_memory_utilization.json');
+    loadGraph('graph_gpu_memory', 'graph/gpu_memory.json');
+    loadGraph('graph_gpu_power', 'graph/gpu_power.json');
+    loadGraph('graph_gpu_pcie', 'graph/gpu_pcie.json');
     {% if gpu_count > 1 %}
-    loadGraph('graph_gpu_nvlink', 'graph/gpu_nvlink.json?step={{step}}');
+    loadGraph('graph_gpu_nvlink', 'graph/gpu_nvlink.json');
     {% endif %}
   {% endif %}
 
   {% if 'node_exporter' in settings.EXPORTER_INSTALLED and multiple_jobs is False %}
-    loadGraph('graph_infiniband_bdw', 'graph/infiniband_bdw.json?step={{step}}');
-    loadGraph('graph_ethernet_bdw', 'graph/ethernet_bdw.json?step={{step}}');
-    loadGraph('graph_disk_iops', 'graph/disk_iops.json?step={{step}}');
-    loadGraph('graph_disk_bdw', 'graph/disk_bdw.json?step={{step}}');
-    loadGraph('graph_disk_used', 'graph/disk_used.json?step={{step}}');
+    loadGraph('graph_infiniband_bdw', 'graph/infiniband_bdw.json');
+    loadGraph('graph_ethernet_bdw', 'graph/ethernet_bdw.json');
+    loadGraph('graph_disk_iops', 'graph/disk_iops.json');
+    loadGraph('graph_disk_bdw', 'graph/disk_bdw.json');
+    loadGraph('graph_disk_used', 'graph/disk_used.json');
   
     {% if 'pcm-sensor-server' in settings.EXPORTER_INSTALLED %}
-      loadGraph('graph_mem_bdw', 'graph/mem_bdw.json?step={{step}}');
-      loadGraph('graph_cpu_interconnect', 'graph/cpu_interconnect.json?step={{step}}');
+      loadGraph('graph_mem_bdw', 'graph/mem_bdw.json');
+      loadGraph('graph_cpu_interconnect', 'graph/cpu_interconnect.json');
     {% endif %}
 
     {% if 'redfish_exporter' in settings.EXPORTER_INSTALLED %}
-      loadGraph('graph_power', 'graph/power.json?step={{step}}');
+      loadGraph('graph_power', 'graph/power.json');
     {% endif %}
   {% endif %}
 
diff --git a/jobstats/views.py b/jobstats/views.py
index 085d08c..9efe234 100644
--- a/jobstats/views.py
+++ b/jobstats/views.py
@@ -93,21 +93,6 @@
 prom = Prometheus(settings.PROMETHEUS)
 
 
-def sanitize_step(request, minimum=30):
-    # all in seconds, will return the smallest interval allowed to drap a graph
-    try:
-        step = int(request.GET.get('step'))
-    except ValueError:
-        step = minimum
-    except TypeError:
-        step = minimum
-
-    if step < minimum:
-        return minimum
-    else:
-        return step
-
-
 def jobid_str_to_list(jobid_str):
     # split range of jobids in format 100-105,107,109,110-120 to a list of jobids
     jobs_blocks = jobid_str.split(',')
@@ -142,7 +127,7 @@ def get_job_ids_regex(jobs):
     return '|'.join([str(job.id_job) for job in jobs])
 
 
-def context_job_info(username, job_id):
+def context_job_info(request, username, job_id):
     context = {'job_id': job_id, 'username': username}
     uid = username_to_uid(username)
     context['uid'] = uid
@@ -165,7 +150,6 @@ def context_job_info(username, job_id):
             time_end=end.timestamp(),
         )
 
-        context['step'] = get_step(start, end)
         context['jobs'] = jobs
         context['id_regex'] = get_job_ids_regex(context['jobs'])
         context['gpu_count'] = 0
@@ -175,8 +159,27 @@ def context_job_info(username, job_id):
         context['job'] = jobs[0]
         context['multiple_jobs'] = False
         context['id_regex'] = str(context['job'].id_job)
-        context['step'] = get_step(context['job'].time_start_dt(), context['job'].time_end_dt())
         context['gpu_count'] = context['job'].gpu_count()
+
+    context['start'] = context['job'].time_start_dt()
+    context['end'] = context['job'].time_end_dt()
+    # Handle start and end time from request GET params
+    if request is not None:
+        if 'start' in request.GET:
+            try:
+                get_start = datetime.fromtimestamp(int(request.GET['start']))
+                if get_start > context['start']:
+                    context['start'] = get_start
+            except ValueError:
+                pass
+        if 'end' in request.GET:
+            try:
+                get_end = datetime.fromtimestamp(int(request.GET['end']))
+                if get_end < context['end']:
+                    context['end'] = get_end
+            except ValueError:
+                pass
+    context['step'] = get_step(context['start'], context['end'])
     return context
 
 
@@ -255,7 +258,7 @@ def user(request, username):
 @login_required
 @user_or_staff
 def job(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
 
     if context['multiple_jobs']:
         return render(request, 'jobstats/job.html', context)
@@ -270,9 +273,6 @@ def job(request, username, job_id):
         # list all jobs in the array
         context['array_jobs'] = JobTable.objects.filter(id_array_job=job.id_array_job).order_by('id_array_task')
 
-    # Adjust the precision of the graphs.
-    context['step'] = get_step(job.time_start_dt(), job.time_end_dt())
-
     if request.user.is_staff:
         context['notes'] = Note.objects.filter(job_id=job_id).filter(deleted_at=None).order_by('-modified_at')
 
@@ -538,14 +538,14 @@ def job(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_cpu(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
 
     query = 'rate(slurm_job_core_usage_total{{slurmjobid=~"{}", {}}}[{}s]) / 1000000000'.format(context['id_regex'], prom.get_filter(), prom.rate('slurm-job-exporter'))
     stats = prom.query_prometheus_multiple(
         query,
-        context['job'].time_start_dt(),
-        context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('slurm-job-exporter')))
 
     data = []
     for line in stats:
@@ -576,9 +576,9 @@ def graph_cpu(request, username, job_id):
         query_count = 'count(slurm_job_core_usage_total{{slurmjobid=~"{}", {}}})'.format(context['id_regex'], prom.get_filter())
         line = prom.query_prometheus(
             query_count,
-            context['job'].time_start_dt(),
-            context['job'].time_end_dt(),
-            step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+            context['start'],
+            context['end'],
+            step=max(context['step'], prom.rate('slurm-job-exporter')))
         x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line[0]))
         y = line[1]
         data.append({
@@ -683,7 +683,7 @@ def graph_mem_user(request, username):
 @login_required
 @user_or_staff
 def graph_mem(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
 
     data = []
 
@@ -708,9 +708,9 @@ def graph_mem(request, username, job_id):
         query = '{}{{slurmjobid=~"{}", {}}}/(1024*1024*1024)'.format(stat[0], context['id_regex'], prom.get_filter())
         stats = prom.query_prometheus_multiple(
             query,
-            context['job'].time_start_dt(),
-            context['job'].time_end_dt(),
-            step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+            context['start'],
+            context['end'],
+            step=max(context['step'], prom.rate('slurm-job-exporter')))
         for line in stats:
             compute_name = display_compute_name(stats, line)
             x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
@@ -736,9 +736,9 @@ def graph_mem(request, username, job_id):
         query_count = 'sum(slurm_job_memory_limit{{slurmjobid=~"{}", {}}})/(1024*1024*1024)'.format(context['id_regex'], prom.get_filter())
         line = prom.query_prometheus(
             query_count,
-            context['job'].time_start_dt(),
-            context['job'].time_end_dt(),
-            step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+            context['start'],
+            context['end'],
+            step=max(context['step'], prom.rate('slurm-job-exporter')))
         x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line[0]))
         y = line[1]
         data.append({
@@ -764,16 +764,16 @@ def graph_mem(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_thread(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
 
     data = []
 
     query_procs = 'slurm_job_process_count{{slurmjobid=~"{}", {}}}'.format(context['id_regex'], prom.get_filter())
     stats_procs = prom.query_prometheus_multiple(
         query_procs,
-        context['job'].time_start_dt(),
-        context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('slurm-job-exporter')))
     for line in stats_procs:
         compute_name = display_compute_name(stats_procs, line)
         x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
@@ -793,9 +793,9 @@ def graph_thread(request, username, job_id):
     query_threads = 'slurm_job_threads_count{{slurmjobid=~"{}", {}}}'.format(context['id_regex'], prom.get_filter())
     stats_threads = prom.query_prometheus_multiple(
         query_threads,
-        context['job'].time_start_dt(),
-        context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('slurm-job-exporter')))
     for line in stats_threads:
         if line['metric']['state'] == '?':
             # ignore "?" state
@@ -825,9 +825,9 @@ def graph_thread(request, username, job_id):
     query_exe = 'sum(deriv(slurm_job_process_usage_total{{slurmjobid=~"{}", {}}}[1m])) by (exe)'.format(context['id_regex'], prom.get_filter())
     stats_exe = prom.query_prometheus_multiple(
         query_exe,
-        context['job'].time_start_dt(),
-        context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('slurm-job-exporter')))
 
     for line in stats_exe:
         x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
@@ -853,17 +853,17 @@ def graph_thread(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_lustre_mdt(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
 
     query = 'sum(rate(lustre_job_stats_total{{component="mdt",jobid=~"{job_id}", {filter}}}[{step}s])) by (operation, fs, jobid) !=0'.format(
         job_id=context['id_regex'],
-        step=sanitize_step(request, minimum=prom.rate('lustre_exporter')),
+        step=max(context['step'], prom.rate('lustre_exporter')),
         filter=prom.get_filter())
     stats = prom.query_prometheus_multiple(
         query,
-        context['job'].time_start_dt(),
-        context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('lustre_exporter')))
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('lustre_exporter')))
 
     data = []
     for line in stats:
@@ -924,20 +924,20 @@ def graph_lustre_mdt_user(request, username):
 @login_required
 @user_or_staff
 def graph_lustre_ost(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
 
     data = []
     for i in ['read', 'write']:
         query = '(sum(rate(lustre_job_{i}_bytes_total{{component="ost",jobid=~"{job_id}",target=~".*-OST.*", {filter}}}[{step}s])) by (fs, jobid)) / (1024*1024)'.format(
             i=i,
             job_id=context['id_regex'],
-            step=sanitize_step(request, minimum=prom.rate('lustre_exporter')),
+            step=max(context['step'], prom.rate('lustre_exporter')),
             filter=prom.get_filter())
         stats = prom.query_prometheus_multiple(
             query,
-            context['job'].time_start_dt(),
-            context['job'].time_end_dt(),
-            step=sanitize_step(request, minimum=prom.rate('lustre_exporter')))
+            context['start'],
+            context['end'],
+            step=max(context['step'], prom.rate('lustre_exporter')))
 
         for line in stats:
             fs = line['metric']['fs']
@@ -1009,7 +1009,7 @@ def graph_lustre_ost_user(request, username):
 @login_required
 @user_or_staff
 def graph_gpu_utilization(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
 
     data = []
 
@@ -1026,9 +1026,9 @@ def graph_gpu_utilization(request, username, job_id):
         query = '{}{{slurmjobid=~"{}", {}}}'.format(q[0], context['id_regex'], prom.get_filter())
         stats = prom.query_prometheus_multiple(
             query,
-            context['job'].time_start_dt(),
-            context['job'].time_end_dt(),
-            step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+            context['start'],
+            context['end'],
+            step=max(context['step'], prom.rate('slurm-job-exporter')))
 
         for line in stats:
             gpu_id = display_gpu_id(line)
@@ -1094,14 +1094,14 @@ def graph_gpu_utilization_user(request, username):
 @login_required
 @user_or_staff
 def graph_gpu_memory_utilization(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
 
     query = 'slurm_job_utilization_gpu_memory{{slurmjobid=~"{}", {}}}'.format(context['id_regex'], prom.get_filter())
     stats = prom.query_prometheus_multiple(
         query,
-        context['job'].time_start_dt(),
-        context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('slurm-job-exporter')))
 
     data = []
     for line in stats:
@@ -1133,14 +1133,14 @@ def graph_gpu_memory_utilization(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_gpu_memory(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
 
     query = 'slurm_job_memory_usage_gpu{{slurmjobid=~"{}", {}}} /(1024*1024*1024)'.format(context['id_regex'], prom.get_filter())
     stats = prom.query_prometheus_multiple(
         query,
-        context['job'].time_start_dt(),
-        context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('slurm-job-exporter')))
 
     data = []
     for line in stats:
@@ -1173,14 +1173,14 @@ def graph_gpu_memory(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_gpu_power(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
 
     query = 'slurm_job_power_gpu{{slurmjobid=~"{}", {}}}/1000'.format(context['id_regex'], prom.get_filter())
     stats = prom.query_prometheus_multiple(
         query,
-        context['job'].time_start_dt(),
-        context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('slurm-job-exporter')))
 
     data = []
     for line in stats:
@@ -1273,7 +1273,7 @@ def graph_gpu_power_user(request, username):
 @login_required
 @user_or_staff
 def graph_gpu_pcie(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
 
     data = []
     query = 'slurm_job_pcie_gpu{{slurmjobid=~"{}", {}}} /1024/1024/1024'.format(
@@ -1281,9 +1281,9 @@ def graph_gpu_pcie(request, username, job_id):
         prom.get_filter())
     stats = prom.query_prometheus_multiple(
         query,
-        context['job'].time_start_dt(),
-        context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('slurm-job-exporter')))
 
     for line in stats:
         gpu_id = display_gpu_id(line)
@@ -1318,7 +1318,7 @@ def graph_gpu_pcie(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_gpu_nvlink(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
 
     data = []
     query = 'slurm_job_nvlink_gpu{{slurmjobid="{}", {}}} /1024/1024/1024'.format(
@@ -1326,9 +1326,9 @@ def graph_gpu_nvlink(request, username, job_id):
         prom.get_filter())
     stats = prom.query_prometheus_multiple(
         query,
-        context['job'].time_start_dt(),
-        context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('slurm-job-exporter')))
 
     for line in stats:
         gpu_id = display_gpu_id(line)
@@ -1363,11 +1363,11 @@ def graph_gpu_nvlink(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_ethernet_bdw(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
     instances = instances_regex(context)
 
     data = []
-    step = sanitize_step(request, minimum=prom.rate('node_exporter'))
+    step = max(context['step'], prom.rate('node_exporter'))
 
     for direction in ['receive', 'transmit']:
         query = 'rate(node_network_{direction}_bytes_total{{device!~"ib.*|lo", {hostname_label}=~"{instances}", {filter}}}[{step}s]) * 8 / (1000*1000)'.format(
@@ -1376,7 +1376,11 @@ def graph_ethernet_bdw(request, username, job_id):
             instances=instances,
             filter=prom.get_filter(),
             step=step)
-        stats = prom.query_prometheus_multiple(query, context['job'].time_start_dt(), context['job'].time_end_dt(), step=step)
+        stats = prom.query_prometheus_multiple(
+            query,
+            context['start'],
+            context['end'],
+            step=step)
         for line in stats:
             compute_name = display_compute_name(stats, line)
             if direction == 'receive':
@@ -1404,11 +1408,11 @@ def graph_ethernet_bdw(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_infiniband_bdw(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
     instances = instances_regex(context)
 
     data = []
-    step = sanitize_step(request, minimum=prom.rate('node_exporter'))
+    step = max(context['step'], prom.rate('node_exporter'))
 
     for direction in ['received', 'transmitted']:
         query = 'rate(node_infiniband_port_data_{direction}_bytes_total{{{hostname_label}=~"{instances}", {filter}}}[{step}s]) * 8 / (1000*1000*1000)'.format(
@@ -1417,7 +1421,11 @@ def graph_infiniband_bdw(request, username, job_id):
             instances=instances,
             filter=prom.get_filter(),
             step=step)
-        stats = prom.query_prometheus_multiple(query, context['job'].time_start_dt(), context['job'].time_end_dt(), step=step)
+        stats = prom.query_prometheus_multiple(
+            query,
+            context['start'],
+            context['end'],
+            step=step)
         for line in stats:
             compute_name = display_compute_name(stats, line)
             if direction == 'received':
@@ -1445,11 +1453,11 @@ def graph_infiniband_bdw(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_disk_iops(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
     instances = instances_regex(context)
 
     data = []
-    step = sanitize_step(request, minimum=prom.rate('node_exporter'))
+    step = max(context['step'], prom.rate('node_exporter'))
 
     for direction in ['reads', 'writes']:
         query = 'rate(node_disk_{direction}_completed_total{{{hostname_label}=~"{instances}",device=~"nvme.n.|sd.|vd.", {filter}}}[{step}s])'.format(
@@ -1458,7 +1466,11 @@ def graph_disk_iops(request, username, job_id):
             instances=instances,
             filter=prom.get_filter(),
             step=step)
-        stats = prom.query_prometheus_multiple(query, context['job'].time_start_dt(), context['job'].time_end_dt(), step=step)
+        stats = prom.query_prometheus_multiple(
+            query,
+            context['start'],
+            context['end'],
+            step=step)
         for line in stats:
             compute_name = "{} {}".format(
                 line['metric']['device'],
@@ -1488,11 +1500,11 @@ def graph_disk_iops(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_disk_bdw(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
     instances = instances_regex(context)
 
     data = []
-    step = sanitize_step(request, minimum=prom.rate('node_exporter'))
+    step = max(context['step'], prom.rate('node_exporter'))
 
     for direction in ['read', 'written']:
         query = 'rate(node_disk_{direction}_bytes_total{{{hostname_label}=~"{instances}",device=~"nvme.n.|sd.|vd.", {filter}}}[{step}s])'.format(
@@ -1501,7 +1513,11 @@ def graph_disk_bdw(request, username, job_id):
             instances=instances,
             filter=prom.get_filter(),
             step=step)
-        stats = prom.query_prometheus_multiple(query, context['job'].time_start_dt(), context['job'].time_end_dt(), step=step)
+        stats = prom.query_prometheus_multiple(
+            query,
+            context['start'],
+            context['end'],
+            step=step)
         for line in stats:
             compute_name = "{} {}".format(
                 line['metric']['device'],
@@ -1531,7 +1547,7 @@ def graph_disk_bdw(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_disk_used(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
     instances = instances_regex(context)
 
     data = []
@@ -1541,7 +1557,11 @@ def graph_disk_used(request, username, job_id):
         instances=instances,
         localscratch=settings.LOCALSCRATCH,
         filter=prom.get_filter())
-    stats_disk = prom.query_prometheus_multiple(query_disk, context['job'].time_start_dt(), context['job'].time_end_dt(), step=sanitize_step(request, minimum=prom.rate('node_exporter')))
+    stats_disk = prom.query_prometheus_multiple(
+        query_disk,
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('node_exporter')))
     for line in stats_disk:
         compute_name = "{} {}".format(
             line['metric']['device'],
@@ -1569,7 +1589,7 @@ def graph_disk_used(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_mem_bdw(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
     instances = instances_regex(context)
 
     data = []
@@ -1580,7 +1600,11 @@ def graph_mem_bdw(request, username, job_id):
             direction=direction,
             instances=instances,
             filter=prom.get_filter())
-        stats = prom.query_prometheus_multiple(query, context['job'].time_start_dt(), context['job'].time_end_dt(), step=sanitize_step(request, minimum=prom.rate('pcm-sensor-server')))
+        stats = prom.query_prometheus_multiple(
+            query,
+            context['start'],
+            context['end'],
+            step=max(context['step'], prom.rate('pcm-sensor-server')))
         for line in stats:
             if 'socket' not in line['metric']:
                 continue
@@ -1631,7 +1655,7 @@ def map_pcm_cores(request, context):
         query_mapping,
         context['job'].time_start_dt(),
         context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('pcm-sensor-server')))
+        step=max(context['step'], prom.rate('pcm-sensor-server')))
 
     all_cores_mapping = {}  # key is the OS core, value is the (socket, core, thread)
     reverse_mapping = {}  # key is the (socket, core, thread), value is the OS core
@@ -1659,7 +1683,7 @@ def map_pcm_cores(request, context):
         query_cpu,
         context['job'].time_start_dt(),
         context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('slurm-job-exporter')))
+        step=max(context['step'], prom.rate('slurm-job-exporter')))
 
     used_mapping = {}
     for line in stats_cpu:
@@ -1698,7 +1722,7 @@ def filter_stats(stats, used_mapping, reverse_mapping):
 
 
 def graph_cache_rate(request, username, job_id, l_cache):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
     instances = instances_regex(context)
 
     used_mapping, reverse_mapping = map_pcm_cores(request, context)
@@ -1713,9 +1737,9 @@ def graph_cache_rate(request, username, job_id, l_cache):
         rate=prom.rate('pcm-sensor-server'))
     stats_cache = prom.query_prometheus_multiple(
         query_cache,
-        context['job'].time_start_dt(),
-        context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('pcm-sensor-server')))
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('pcm-sensor-server')))
 
     # from all the L3 cache hits and misses, keep only the ones used by the job
     data = filter_stats(stats_cache, used_mapping, reverse_mapping)
@@ -1732,7 +1756,7 @@ def graph_cache_rate(request, username, job_id, l_cache):
 
 
 def graph_ipc(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
     instances = instances_regex(context)
 
     used_mapping, reverse_mapping = map_pcm_cores(request, context)
@@ -1751,9 +1775,9 @@ def graph_ipc(request, username, job_id):
         rate=prom.rate('pcm-sensor-server'))
     stats_ipc = prom.query_prometheus_multiple(
         query_ipc,
-        context['job'].time_start_dt(),
-        context['job'].time_end_dt(),
-        step=sanitize_step(request, minimum=prom.rate('pcm-sensor-server')))
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('pcm-sensor-server')))
 
     data = filter_stats(stats_ipc, used_mapping, reverse_mapping)
 
@@ -1769,7 +1793,7 @@ def graph_ipc(request, username, job_id):
 @login_required
 @user_or_staff
 def graph_cpu_interconnect(request, username, job_id):
-    context = context_job_info(username, job_id)
+    context = context_job_info(request, username, job_id)
     instances = instances_regex(context)
 
     data = []
@@ -1780,7 +1804,11 @@ def graph_cpu_interconnect(request, username, job_id):
         instances=instances,
         filter=prom.get_filter(),
         rate=prom.rate('pcm-sensor-server'))
-    stats = prom.query_prometheus_multiple(query, context['job'].time_start_dt(), context['job'].time_end_dt(), step=sanitize_step(request, minimum=prom.rate('pcm-sensor-server')))
+    stats = prom.query_prometheus_multiple(
+        query,
+        context['start'],
+        context['end'],
+        step=max(context['step'], prom.rate('pcm-sensor-server')))
     for line in stats:
         compute_name = "Received socket {} {}".format(
             line['metric']['socket'],
@@ -1840,14 +1868,10 @@ def power(job, step):
 @login_required
 @user_or_staff
 def graph_power(request, username, job_id):
-    uid = username_to_uid(username)
-    try:
-        job = JobTable.objects.filter(id_user=uid).filter(id_job=job_id).get()
-    except JobTable.DoesNotExist:
-        return HttpResponseNotFound('Job not found')
+    context = context_job_info(request, username, job_id)
 
     data = []
-    for line in power(job, step=sanitize_step(request, minimum=prom.rate('redfish_exporter'))):
+    for line in power(context['job'], step=max(context['step'], prom.rate('redfish_exporter'))):
         compute_name = "{}".format(line['metric'][settings.PROM_NODE_HOSTNAME_LABEL])
         x = list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), line['x']))
         data.append({
diff --git a/pages/views.py b/pages/views.py
index c54485a..0b709de 100644
--- a/pages/views.py
+++ b/pages/views.py
@@ -1,7 +1,7 @@
 from django.shortcuts import render
 from django.http import JsonResponse
 from django.conf import settings
-from userportal.common import Prometheus, query_time
+from userportal.common import Prometheus, parse_start_end
 from django.utils.translation import gettext as _
 from datetime import datetime, timedelta
 import statistics
@@ -46,13 +46,16 @@ def software(request):
     return render(request, 'pages/software.html', context)
 
 
+@parse_start_end(minimum=prom.rate('lustre_exporter'))
 def graph_lustre_mdt(request, fs):
     if fs not in settings.LUSTRE_FS_NAMES:
         return JsonResponse({'error': 'Unknown filesystem'})
-    timing = query_time(request)
 
     query = 'sum(lustre:metadata:rate3m{{fs="{}", {}}}) by (operation) !=0'.format(fs, prom.get_filter())
-    stats = prom.query_prometheus_multiple(query, timing[0], step=timing[1])
+    stats = prom.query_prometheus_multiple(
+        query,
+        request.start,
+        end=request.end)
 
     data = []
     for line in stats:
@@ -82,15 +85,19 @@ def graph_lustre_mdt(request, fs):
     return JsonResponse({'data': data, 'layout': layout})
 
 
+@parse_start_end(minimum=prom.rate('lustre_exporter'))
 def graph_lustre_ost(request, fs):
     if fs not in settings.LUSTRE_FS_NAMES:
         return JsonResponse({'error': 'Unknown filesystem'})
-    timing = query_time(request)
 
     data = []
     for i in ['read', 'write']:
         query = 'lustre:{}_bytes:rate3m{{fs="{}", {}}}'.format(i, fs, prom.get_filter())
-        stats = prom.query_prometheus_multiple(query, timing[0], step=timing[1])
+        stats = prom.query_prometheus_multiple(
+            query,
+            request.start,
+            end=request.end,
+            step=request.step)
         for line in stats:
             if i == 'read':
                 y = line['y']
@@ -128,25 +135,33 @@ def graph_lustre_ost(request, fs):
     return JsonResponse({'data': data, 'layout': layout})
 
 
+@parse_start_end(minimum=prom.rate('node_exporter'))
 def graph_login_cpu(request, login):
     if login not in settings.LOGINS.keys():
         return JsonResponse({'error': 'Unknown login node'})
-    timing = query_time(request)
 
     core_count_query = 'count(node_cpu_seconds_total{{mode="system",{hostname_label}=~"{login}(:.*)?", {filter} }})'.format(
         hostname_label=settings.PROM_NODE_HOSTNAME_LABEL,
         login=login,
         filter=prom.get_filter(),
     )
-    core_count = max(prom.query_prometheus(core_count_query, timing[0], step=timing[1])[1])
+    core_count = max(prom.query_prometheus(
+        core_count_query,
+        request.start,
+        end=request.end,
+        step=request.step)[1])
     data = []
     query = 'sum by (mode)(rate(node_cpu_seconds_total{{mode=~"system|user|iowait",{hostname_label}=~"{login}(:.*)?", {filter} }}[{step}s]))'.format(
         hostname_label=settings.PROM_NODE_HOSTNAME_LABEL,
         login=login,
         filter=prom.get_filter(),
-        step=timing[1],
+        step=request.step,
     )
-    stats = prom.query_prometheus_multiple(query, timing[0], step=timing[1])
+    stats = prom.query_prometheus_multiple(
+        query,
+        request.start,
+        end=request.end,
+        step=request.step)
 
     for line in stats:
         data.append({
@@ -181,23 +196,31 @@ def graph_login_cpu(request, login):
     return JsonResponse({'data': data, 'layout': layout})
 
 
+@parse_start_end(minimum=prom.rate('node_exporter'))
 def graph_login_memory(request, login):
     if login not in settings.LOGINS.keys():
         return JsonResponse({'error': 'Unknown login node'})
-    timing = query_time(request)
 
     total_mem_query = 'node_memory_MemTotal_bytes{{instance=~"{login}(:.*)?", {filter} }}'.format(
         login=login,
         filter=prom.get_filter(),
     )
-    total_mem = max(prom.query_prometheus(total_mem_query, timing[0], step=timing[1])[1])
+    total_mem = max(prom.query_prometheus(
+        total_mem_query,
+        request.start,
+        end=request.end,
+        step=request.step)[1])
     data = []
     query = 'node_memory_MemTotal_bytes{{{hostname_label}=~"{login}(:.*)?", {filter} }} - node_memory_MemFree_bytes{{{hostname_label}=~"{login}(:.*)?", {filter} }} - node_memory_Buffers_bytes{{{hostname_label}=~"{login}(:.*)?", {filter} }} - node_memory_Cached_bytes{{{hostname_label}=~"{login}(:.*)?", {filter} }} - node_memory_Slab_bytes{{{hostname_label}=~"{login}(:.*)?", {filter} }} - node_memory_PageTables_bytes{{{hostname_label}=~"{login}(:.*)?", {filter} }} - node_memory_SwapCached_bytes{{{hostname_label}=~"{login}(:.*)?", {filter} }}'.format(
         hostname_label=settings.PROM_NODE_HOSTNAME_LABEL,
         login=login,
         filter=prom.get_filter(),
     )
-    stats = prom.query_prometheus(query, timing[0], step=timing[1])
+    stats = prom.query_prometheus(
+        query,
+        request.start,
+        end=request.end,
+        step=request.step)
     data.append({
         'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), stats[0])),
         'y': stats[1],
@@ -226,10 +249,10 @@ def graph_login_memory(request, login):
     return JsonResponse({'data': data, 'layout': layout})
 
 
+@parse_start_end(minimum=prom.rate('node_exporter'))
 def graph_login_load(request, login):
     if login not in settings.LOGINS.keys():
         return JsonResponse({'error': 'Unknown login node'})
-    timing = query_time(request)
     data = []
 
     query = 'node_load1{{{hostname_label}=~"{login}(:.*)?", {filter} }}'.format(
@@ -237,7 +260,11 @@ def graph_login_load(request, login):
         login=login,
         filter=prom.get_filter(),
     )
-    stats = prom.query_prometheus(query, timing[0], step=timing[1])
+    stats = prom.query_prometheus(
+        query,
+        request.start,
+        end=request.end,
+        step=request.step)
     data.append({
         'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), stats[0])),
         'y': stats[1],
@@ -279,17 +306,21 @@ def graph_dtn_network(request, dtn):
     return graph_network(request, dtn, device)
 
 
+@parse_start_end(minimum=prom.rate('node_exporter'))
 def graph_network(request, node, device):
-    timing = query_time(request)
     data = []
     query_rx = 'rate(node_network_receive_bytes_total{{{hostname_label}=~"{node}(:.*)?", device="{device}", {filter} }}[{step}s]) * 8'.format(
         hostname_label=settings.PROM_NODE_HOSTNAME_LABEL,
         node=node,
         filter=prom.get_filter(),
         device=device,
-        step=timing[1],
+        step=request.step,
     )
-    stats_rx = prom.query_prometheus(query_rx, timing[0], step=timing[1])
+    stats_rx = prom.query_prometheus(
+        query_rx,
+        request.start,
+        end=request.end,
+        step=request.step)
 
     data.append({
         'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), stats_rx[0])),
@@ -304,9 +335,13 @@ def graph_network(request, node, device):
         node=node,
         filter=prom.get_filter(),
         device=device,
-        step=timing[1],
+        step=request.step,
     )
-    stats_tx = prom.query_prometheus(query_tx, timing[0], step=timing[1])
+    stats_tx = prom.query_prometheus(
+        query_tx,
+        request.start,
+        end=request.end,
+        step=request.step)
 
     data.append({
         'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), stats_tx[0])),
@@ -349,8 +384,8 @@ def graph_scheduler_gpu(request):
     return graph_scheduler_cpu_gpu(request, 'gpu')
 
 
+@parse_start_end(minimum=prom.rate('node_exporter'))
 def graph_scheduler_cpu_gpu(request, res_type='cpu'):
-    timing = query_time(request)
     data = []
     if res_type == 'cpu':
         query_used = 'slurm_job:used_core:sum{{ {filter} }}'.format(
@@ -361,7 +396,11 @@ def graph_scheduler_cpu_gpu(request, res_type='cpu'):
             filter=prom.get_filter(),
         )
 
-    stats_used = prom.query_prometheus(query_used, timing[0], step=timing[1])
+    stats_used = prom.query_prometheus(
+        query_used,
+        request.start,
+        end=request.end,
+        step=request.step)
     data.append({
         'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), stats_used[0])),
         'y': stats_used[1],
@@ -373,7 +412,11 @@ def graph_scheduler_cpu_gpu(request, res_type='cpu'):
         res_type=res_type,
         filter=prom.get_filter(),
     )
-    stats_alloc = prom.query_prometheus(query_alloc, timing[0], step=timing[1])
+    stats_alloc = prom.query_prometheus(
+        query_alloc,
+        request.start,
+        end=request.end,
+        step=request.step)
     data.append({
         'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), stats_alloc[0])),
         'y': stats_alloc[1],
@@ -385,7 +428,11 @@ def graph_scheduler_cpu_gpu(request, res_type='cpu'):
         res_type=res_type,
         filter=prom.get_filter(),
     )
-    stats_alloc = prom.query_prometheus(query_alloc, timing[0], step=timing[1])
+    stats_alloc = prom.query_prometheus(
+        query_alloc,
+        request.start,
+        end=request.end,
+        step=request.step)
     data.append({
         'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), stats_alloc[0])),
         'y': stats_alloc[1],
@@ -397,7 +444,11 @@ def graph_scheduler_cpu_gpu(request, res_type='cpu'):
         query_non_idle = 'sum(slurm_job:non_idle_gpu:sum_user_account{{ {filter} }})'.format(
             filter=prom.get_filter(),
         )
-        stats_non_idle = prom.query_prometheus(query_non_idle, timing[0], step=timing[1])
+        stats_non_idle = prom.query_prometheus(
+            query_non_idle,
+            request.start,
+            end=request.end,
+            step=request.step)
         data.append({
             'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), stats_non_idle[0])),
             'y': stats_non_idle[1],
@@ -409,7 +460,11 @@ def graph_scheduler_cpu_gpu(request, res_type='cpu'):
         res_type=res_type,
         filter=prom.get_filter(),
     )
-    stats_total = prom.query_prometheus(query_total, timing[0], step=timing[1])
+    stats_total = prom.query_prometheus(
+        query_total,
+        request.start,
+        end=request.end,
+        step=request.step)
     data.append({
         'x': list(map(lambda x: x.strftime('%Y-%m-%d %H:%M:%S'), stats_total[0])),
         'y': stats_total[1],
diff --git a/static/custom.js b/static/custom.js
index 3aff744..2687186 100644
--- a/static/custom.js
+++ b/static/custom.js
@@ -72,19 +72,34 @@ function loadGraph(container, url){
                     Plotly.newPlot(container, content['data'], content['layout'], content['config']);
 
                     $(container_div).on('plotly_relayout', function(self, relayout_data){
-                        var end_date = new Date(relayout_data['xaxis.range[1]']);
-                        var end_date_unix = Math.round(end_date.getTime() / 1000);
+                        if(relayout_data['xaxis.autorange'] == true && relayout_data['xaxis.showspikes'] == false){
+                            // reset X axis event (unzoom)
+                            // remove the old parameters from the url string
+                            var url_splitted = url.split('?');
+                            url = url_splitted[0];
+                            debounce_loadGraph(container, url);
+                        }
+                        else if(relayout_data['xaxis.range[0]']){
+                            // zoom event
+                            // the date is in UTC and we need to convert it to unix timestamp
+                            var start_date = new Date(relayout_data['xaxis.range[0]'] + " Z");
+                            var start_date_unix = Math.round(start_date.getTime() / 1000);
 
-                        var start_date = new Date(relayout_data['xaxis.range[0]']);
-                        var start_date_unix = Math.round(start_date.getTime() / 1000);
+                            var end_date = new Date(relayout_data['xaxis.range[1]'] + " Z");
+                            var end_date_unix = Math.round(end_date.getTime() / 1000);
 
-                        // remove the old parameters from the url string
-                        var url_splitted = url.split('?');
-                        url = url_splitted[0];
+                            // remove the old parameters from the url string
+                            var url_splitted = url.split('?');
+                            url = url_splitted[0];
 
-                        // get the new range and reload the graph
-                        var newurl = url + '?start=' + start_date_unix + '&end=' + end_date_unix;
-                        debounce_loadGraph(container, newurl);
+                            // get the new range and reload the graph
+                            var newurl = url + '?start=' + start_date_unix + '&end=' + end_date_unix;
+                            debounce_loadGraph(container, newurl);
+                        }
+                        else{
+                            // event not handled
+                            // autoscale will end up here and it will not refresh the graph on purpose
+                        }
                     });
                 }
             }
diff --git a/userportal/common.py b/userportal/common.py
index 9b644c8..d592287 100644
--- a/userportal/common.py
+++ b/userportal/common.py
@@ -152,55 +152,46 @@ def request_to_username(request):
     return request.user.username.split('@')[0]
 
 
-def query_time(request, exporter_name=None):
-    delta = int(request.GET.get('delta', 0))
-
-    if delta > 3600 * 24 * 7 * 30 * 6:
-        # more than 6 months
-        delta = 3600 * 24 * 7 * 30 * 6
-
-    start = datetime.now() - timedelta(seconds=delta)
-
-    if exporter_name in settings.EXPORTER_SAMPLING_RATE:
-        step = max(int(delta / RESOLUTION), settings.EXPORTER_SAMPLING_RATE[exporter_name]) * 2
-    else:
-        step = max(int(delta / RESOLUTION), 30) * 2
-
-    return (start, step)
-
-
-def get_step(start, end=None):
-    if end is None:
-        end = datetime.now()
-    if start is None:
-        start = datetime.now()
+def get_step(start, end, minimum=60):
     delta = end - start
 
     if delta.days > 6 * 30:
         # more than 6 months
         return 3600 * 24
     else:
-        return int(delta.total_seconds() / RESOLUTION)
+        span = int(delta.total_seconds() / RESOLUTION)
+        if span < minimum:
+            return minimum
+        else:
+            return span
 
 
-def parse_start_end(default_start=datetime.now() - timedelta(days=1), default_end=datetime.now()):
+def parse_start_end(default_start=datetime.now() - timedelta(days=1), default_end=datetime.now(), minimum=60):
+    """ From the GET parameters, add start and end to the request object
+    if delta is set, it will be used to calculate the start time from now() instead of start and end
+    """
     def decorator_wrapper(view_func):
         def func_wrapper(request, *args, **kwargs):
-            if 'start' in request.GET:
-                try:
-                    start = datetime.fromtimestamp(int(request.GET['start']))
-                except ValueError:
-                    start = default_start
+            if 'delta' in request.GET:
+                delta = int(request.GET['delta'])
+                start = datetime.now() - timedelta(seconds=delta)
+                end = datetime.now()
             else:
-                start = default_start
+                if 'start' in request.GET:
+                    try:
+                        start = datetime.fromtimestamp(int(request.GET['start']))
+                    except ValueError:
+                        start = default_start
+                else:
+                    start = default_start
 
-            if 'end' in request.GET:
-                try:
-                    end = datetime.fromtimestamp(int(request.GET['end']))
-                except ValueError:
+                if 'end' in request.GET:
+                    try:
+                        end = datetime.fromtimestamp(int(request.GET['end']))
+                    except ValueError:
+                        end = default_end
+                else:
                     end = default_end
-            else:
-                end = default_end
 
             # start and end can't be in the future
             if start > datetime.now():
@@ -209,7 +200,7 @@ def func_wrapper(request, *args, **kwargs):
                 end = datetime.now()
             request.start = start
             request.end = end
-            request.step = get_step(start, end)
+            request.step = get_step(start, end, minimum)
             return view_func(request, *args, **kwargs)
         return func_wrapper
     return decorator_wrapper
diff --git a/userportal/settings/30-cluster.py b/userportal/settings/30-cluster.py
index 3deb54d..1c3d859 100644
--- a/userportal/settings/30-cluster.py
+++ b/userportal/settings/30-cluster.py
@@ -15,6 +15,7 @@
     'lustre_exporter': 90,
     'slurm_exporter': 60,
     'pcm-sensor-server': 30,
+    'libvirtd_exporter': 30,
 }
 
 CLUSTER_NAME = 'narval'  # used for slurm stats