benchmark_health_report: Query anomalies by benchmark/master.

dashboard/dashboard/benchmark_health_report.py

 # Copyright 2017 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Provides the web interface for a report on benchmark alert health."""
 
 import datetime
 import json
 
 from dashboard import alerts
-from dashboard import list_tests
 from dashboard import update_test_suites
 from dashboard.common import request_handler
-from dashboard.common import utils
 from dashboard.models import anomaly
 
 
 class BenchmarkHealthReportHandler(request_handler.RequestHandler):
 
   def get(self):
     """Renders the UI for the group report page."""
     self.RenderStaticHtml('benchmark_health_report.html')
 
   def post(self):
@@ skipping 19 matching lines @@
           benchmark, num_days, master)
     else:
       response_values = self._GetResponseValuesForMaster(master)
 
     self.response.out.write(json.dumps(response_values))
 
   def _GetResponseValuesForBenchmark(self, benchmark, num_days, master):
     values = {}
 
     # The cached test suite info contains info about monitoring and bots.
+    query = anomaly.Anomaly.query(
+        anomaly.Anomaly.benchmark_name == benchmark,
+        anomaly.Anomaly.master_name == master,
+        anomaly.Anomaly.is_improvement == False,
+        anomaly.Anomaly.timestamp >
+        datetime.datetime.now() - datetime.timedelta(days=num_days))
+    query = query.order(-anomaly.Anomaly.timestamp)
+    anomalies = query.fetch()
+    values['alerts'] = alerts.AnomalyDicts(anomalies)
     benchmarks = update_test_suites.FetchCachedTestSuites()
-    sheriff = self._GetSheriffForBenchmark(benchmark, master, benchmarks)
-    if sheriff:
-      query = anomaly.Anomaly.query(anomaly.Anomaly.sheriff == sheriff)
-      query = query.filter(anomaly.Anomaly.is_improvement == False)
-      query = query.filter(
-          anomaly.Anomaly.timestamp >
-          datetime.datetime.now() - datetime.timedelta(days=num_days))
-      query = query.order(-anomaly.Anomaly.timestamp)
-      anomalies = query.fetch()
-      anomalies = [a for a in anomalies if self._BenchmarkName(a) == benchmark]
+    if benchmarks[benchmark].get('mon'):

[shatch, 2017/02/23 15:58:30]

nit: Is it possible to have alerts and not be monitored? Then we can just query
on monitored.

[sullivan, 2017/02/23 16:11:42]

It is possible to have alerts and not be monitored.

The thing we are actually poking at here is the monitored property for all of
master/*/benchmark. Would you prefer to eliminate the dependency on cached test
suites by querying that directly?

       values['monitored'] = True
-      values['alerts'] = alerts.AnomalyDicts(anomalies)
     else:
       values['monitored'] = False
-
     values['bots'] = benchmarks[benchmark]['mas'][master].keys()
     return values
 
-  def _GetSheriffForBenchmark(self, benchmark, master, benchmarks):
-    # TODO(sullivan): There can be multiple sheriffs; implement this.
-    if not benchmarks[benchmark]['mon']:
-      return None
-    monitored_test_path = benchmarks[benchmark]['mon'][0]
-    pattern = '%s/*/%s/%s' % (master, benchmark, monitored_test_path)
-    monitored_tests = list_tests.GetTestsMatchingPattern(
-        pattern, list_entities=True)
-    return monitored_tests[0].sheriff
-
-  def _BenchmarkName(self, alert):
-    return utils.TestPath(alert.test).split('/')[2]
-
   def _GetResponseValuesForMaster(self, master):
     benchmarks = update_test_suites.FetchCachedTestSuites()
     benchmarks = [b for b in benchmarks if master in benchmarks[b]['mas']]
     return {'benchmarks': sorted(benchmarks)}