Update buildbots to parse new telemetry JSON format.

scripts/slave/runtest.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """A tool used to run a Chrome test executable and process the output.
 
 This script is used by the buildbot slaves. It must be run from the outer
 build directory, e.g. chrome-release/build/.
 
@@ skipping 36 matching lines @@
 # TODO(crbug.com/403564). We almost certainly shouldn't be importing this.
 import config
 
 from slave import annotation_utils
 from slave import build_directory
 from slave import crash_utils
 from slave import gtest_slave_utils
 from slave import performance_log_processor
 from slave import results_dashboard
 from slave import slave_utils
+from slave import telemetry_utils
 from slave import xvfb
 
 USAGE = '%s [options] test.exe [test args]' % os.path.basename(sys.argv[0])
 
 CHROME_SANDBOX_PATH = '/opt/chromium/chrome_sandbox'
 
 # Directory to write JSON for test results into.
 DEST_DIR = 'gtest_results'
 
 # Names of httpd configuration file under different platforms.
@@ skipping 474 matching lines @@
   shouldlist = selection and selection == 'list'
   if shouldlist:
     print
     print 'Available log processors:'
     for p in LOG_PROCESSOR_CLASSES:
       print ' ', p, LOG_PROCESSOR_CLASSES[p].__name__
 
   return shouldlist
 
 
-def _SelectLogProcessor(options):
+def _SelectLogProcessor(options, test_exe):
   """Returns a log processor class based on the command line options.
 
   Args:
     options: Command-line options (from OptionParser).
+    test_exe: Name of the test to execute
 
   Returns:
     A log processor class, or None.
   """
   if _UsingGtestJson(options):
     return gtest_utils.GTestJSONParser
 
+  if test_exe and test_exe.endswith('telemetry.py'):
+    return telemetry_utils.TelemetryResultsTracker
+
   if options.annotate:
     if options.annotate in LOG_PROCESSOR_CLASSES:
       if options.generate_json_file and options.annotate != 'gtest':
         raise NotImplementedError('"%s" doesn\'t make sense with '
                                   'options.generate_json_file.')
       else:
         return LOG_PROCESSOR_CLASSES[options.annotate]
     else:
       raise KeyError('"%s" is not a valid GTest parser!' % options.annotate)
   elif options.generate_json_file:
     return LOG_PROCESSOR_CLASSES['gtest']
 
   return None
 
 
 def _GetCommitPos(build_properties):
   """Extracts the commit position from the build properties, if its there."""
   if 'got_revision_cp' not in build_properties:
     return None
   commit_pos = build_properties['got_revision_cp']
   return int(re.search(r'{#(\d+)}', commit_pos).group(1))
 
 
+def _GetMainRevision(options):
+  build_dir = os.path.abspath(options.build_dir)
+  commit_pos_num = _GetCommitPos(options.build_properties)
+  if commit_pos_num is not None:
+    revision = commit_pos_num
+  elif options.revision:
+    revision = options.revision
+  else:
+    revision = _GetRevision(os.path.dirname(build_dir))
+  return revision
+
+
+def _GetBlinkRevision(options):
+  build_dir = os.path.abspath(options.build_dir)
+
+  if options.webkit_revision:
+    webkit_revision = options.webkit_revision
+  else:
+    try:
+      webkit_dir = chromium_utils.FindUpward(
+          build_dir, 'third_party', 'WebKit', 'Source')
+      webkit_revision = _GetRevision(webkit_dir)
+    except Exception:
+      webkit_revision = None
+  return webkit_revision
+
+
+def _GetTelemetryRevisions(options):
+  """Fills in the same revisions fields that process_log_utils does."""
+
+  versions = {}
+  versions['rev'] = _GetMainRevision(options)
+  versions['webkit_rev'] = _GetBlinkRevision(options)
+  versions['webrtc_rev'] = options.build_properties.get('got_webrtc_revision')
+  versions['v8_rev'] = options.build_properties.get('got_v8_revision')
+  versions['ver'] = options.build_properties.get('version')
+  versions['git_revision'] = options.build_properties.get('git_revision')
+  return versions
+
+
 def _CreateLogProcessor(log_processor_class, options):
   """Creates a log processor instance.
 
   Args:
     log_processor_class: A subclass of PerformanceLogProcessor or similar class.
     options: Command-line options (from OptionParser).
 
   Returns:
     An instance of a log processor class, or None.
   """
   if not log_processor_class:
     return None
 
-  if log_processor_class.__name__ in ('GTestLogParser',):
+  if log_processor_class.__name__ in ('GTestLogParser',
+                                      'TelemetryResultsTracker'):
     tracker_obj = log_processor_class()
   elif log_processor_class.__name__ in ('GTestJSONParser',):
     tracker_obj = log_processor_class(
         options.build_properties.get('mastername'))
   else:
-    build_dir = os.path.abspath(options.build_dir)
-
-    if options.webkit_revision:
-      webkit_revision = options.webkit_revision
-    else:
-      try:
-        webkit_dir = chromium_utils.FindUpward(
-            build_dir, 'third_party', 'WebKit', 'Source')
-        webkit_revision = _GetRevision(webkit_dir)
-      except Exception:
-        webkit_revision = 'undefined'
-
-    commit_pos_num = _GetCommitPos(options.build_properties)
-    if commit_pos_num is not None:
-      revision = commit_pos_num
-    elif options.revision:
-      revision = options.revision
-    else:
-      revision = _GetRevision(os.path.dirname(build_dir))
+    webkit_revision = _GetBlinkRevision(options) or 'undefined'
+    revision = _GetMainRevision(options) or 'undefined'
 
     tracker_obj = log_processor_class(
         revision=revision,
         build_properties=options.build_properties,
         factory_properties=options.factory_properties,
         webkit_revision=webkit_revision)
 
   if options.annotate and options.generate_json_file:
     tracker_obj.ProcessLine(_GetMasterString(_GetMaster()))
 
@@ skipping 14 matching lines @@
   supplemental_columns = {}
   supplemental_columns_file = os.path.join(build_dir,
                                            results_dashboard.CACHE_DIR,
                                            supplemental_colummns_file_name)
   if os.path.exists(supplemental_columns_file):
     with file(supplemental_columns_file, 'r') as f:
       supplemental_columns = json.loads(f.read())
   return supplemental_columns
 
 
-def _SendResultsToDashboard(log_processor, system, test, url, build_dir,
-                            mastername, buildername, buildnumber,
-                            supplemental_columns_file, extra_columns=None):
+def _ResultsDashboardDict(options):
+  """Generates a dict of info needed by the results dashboard.
+
+  Args:
+    options: Program arguments.
+
+  Returns:
+    dict containing data the dashboard needs.
+  """
+  build_dir = os.path.abspath(options.build_dir)
+  supplemental_columns = _GetSupplementalColumns(
+      build_dir, options.supplemental_columns_file)
+  extra_columns = options.perf_config
+  if extra_columns:
+    supplemental_columns.update(extra_columns)
+  fields = {
+      'system': _GetPerfID(options),
+      'test': options.test_type,
+      'url': options.results_url,
+      'mastername': options.build_properties.get('mastername'),
+      'buildername': options.build_properties.get('buildername'),
+      'buildnumber': options.build_properties.get('buildnumber'),
+      'build_dir': build_dir,
+      'supplemental_columns': supplemental_columns,
+      'revisions': _GetTelemetryRevisions(options),
+  }
+  return fields
+
+
+def _SendResultsToDashboard(log_processor, args):
   """Sends results from a log processor instance to the dashboard.
 
   Args:
     log_processor: An instance of a log processor class, which has been used to
         process the test output, so it contains the test results.
-    system: A string such as 'linux-release', which comes from perf_id.
-    test: Test "suite" name string.
-    url: Dashboard URL.
-    build_dir: Build dir name (used for cache file by results_dashboard).
-    mastername: Buildbot master name, e.g. 'chromium.perf'.
-        WARNING! This is incorrectly called "masterid" in some parts of the
-        dashboard code.
-    buildername: Builder name, e.g. 'Linux QA Perf (1)'
-    buildnumber: Build number (as a string).
-    supplemental_columns_file: Filename for JSON supplemental columns file.
-    extra_columns: A dict of extra values to add to the supplemental columns
-        dict.
+    args: Dict of additional args to send to results_dashboard.
   """
-  if system is None:
+  if args['system'] is None:
     # perf_id not specified in factory properties.
     print 'Error: No system name (perf_id) specified when sending to dashboard.'
     return
-  supplemental_columns = _GetSupplementalColumns(
-      build_dir, supplemental_columns_file)
-  if extra_columns:
-    supplemental_columns.update(extra_columns)
 
-  charts = _GetDataFromLogProcessor(log_processor)
-  points = results_dashboard.MakeListOfPoints(
-      charts, system, test, mastername, buildername, buildnumber,
-      supplemental_columns)
-  results_dashboard.SendResults(points, url, build_dir)
+  results = []
+  if log_processor.IsChartJson():
+    results = [results_dashboard.MakeDashboardJsonV1(
+        log_processor.ChartJson(),
+        args['revisions'], args['system'], args['mastername'],
+        args['buildername'], args['buildnumber'],
+        args['supplemental_columns'], False)]
+    ref_json = log_processor.RefJson()
+    if ref_json:
+      results.append(results_dashboard.MakeDashboardJsonV1(
+          ref_json, args['revisions'], args['system'], args['mastername'],
+          args['buildername'], args['buildnumber'],
+          args['supplemental_columns'], True))
+    log_processor.Cleanup()
+  else:
+    charts = _GetDataFromLogProcessor(log_processor)
+    results = [results_dashboard.MakeListOfPoints(
+        charts, args['system'], args['test'], args['mastername'],
+        args['buildername'], args['buildnumber'], args['supplemental_columns'])]
+  for result in results:
+    results_dashboard.SendResults(result, args['url'], args['build_dir'])
 
 
 def _GetDataFromLogProcessor(log_processor):
   """Returns a mapping of chart names to chart data.
 
   Args:
     log_processor: A log processor (aka results tracker) object.
 
   Returns:
     A dictionary mapping chart name to lists of chart data.
@@ skipping 247 matching lines @@
   through the specified annotation parser (aka log processor).
   """
   if not options.annotate:
     raise chromium_utils.MissingArgument('--parse-input doesn\'t make sense '
                                          'without --annotate.')
 
   # If --annotate=list was passed, list the log processor classes and exit.
   if _ListLogProcessors(options.annotate):
     return 0
 
-  log_processor_class = _SelectLogProcessor(options)
+  log_processor_class = _SelectLogProcessor(options, None)
   log_processor = _CreateLogProcessor(log_processor_class, options)
 
   if options.generate_json_file:
     if os.path.exists(options.test_output_xml):
       # remove the old XML output file.
       os.remove(options.test_output_xml)
 
   if options.parse_input == '-':
     f = sys.stdin
   else:
@@ skipping 46 matching lines @@
     command = [sys.executable, test_exe]
   else:
     command = [test_exe_path]
     if options.annotate == 'gtest':
       command.extend(['--brave-new-test-launcher', '--test-launcher-bot-mode'])
   command.extend(args[1:])
 
   # If --annotate=list was passed, list the log processor classes and exit.
   if _ListLogProcessors(options.annotate):
     return 0
-  log_processor_class = _SelectLogProcessor(options)
+  log_processor_class = _SelectLogProcessor(options, test_exe)
   log_processor = _CreateLogProcessor(log_processor_class, options)
+  if hasattr(log_processor, 'IsChartJson') and log_processor.IsChartJson():
+    command.extend(log_processor.GetArguments())
 
   if options.generate_json_file:
     if os.path.exists(options.test_output_xml):
       # remove the old XML output file.
       os.remove(options.test_output_xml)
 
   try:
     http_server = None
     if options.document_root:
       http_server = _StartHttpServer('mac', build_dir=build_dir,
@@ skipping 28 matching lines @@
     if not _GenerateJSONForTestResults(options, log_processor):
       return 1
 
   if options.annotate:
     annotation_utils.annotate(
         options.test_type, result, log_processor,
         options.factory_properties.get('full_test_name'),
         perf_dashboard_id=options.perf_dashboard_id)
 
   if options.results_url:
-    _SendResultsToDashboard(
-        log_processor, _GetPerfID(options),
-        options.test_type, options.results_url, options.build_dir,
-        options.build_properties.get('mastername'),
-        options.build_properties.get('buildername'),
-        options.build_properties.get('buildnumber'),
-        options.supplemental_columns_file,
-        options.perf_config)
+    _SendResultsToDashboard(log_processor, _ResultsDashboardDict(options))
 
   return result
 
 
 def _MainIOS(options, args, extra_env):
   """Runs the test on iOS."""
   if len(args) < 1:
     raise chromium_utils.MissingArgument('Usage: %s' % USAGE)
 
   def kill_simulator():
@@ skipping 175 matching lines @@
     command = [sys.executable, test_exe]
   else:
     command = [test_exe_path]
     if options.annotate == 'gtest':
       command.extend(['--brave-new-test-launcher', '--test-launcher-bot-mode'])
   command.extend(args[1:])
 
   # If --annotate=list was passed, list the log processor classes and exit.
   if _ListLogProcessors(options.annotate):
     return 0
-  log_processor_class = _SelectLogProcessor(options)
+  log_processor_class = _SelectLogProcessor(options, test_exe)
   log_processor = _CreateLogProcessor(log_processor_class, options)
+  if hasattr(log_processor, 'IsChartJson') and log_processor.IsChartJson():
+    command.extend(log_processor.GetArguments())
 
   if options.generate_json_file:
     if os.path.exists(options.test_output_xml):
       # remove the old XML output file.
       os.remove(options.test_output_xml)
 
   try:
     start_xvfb = False
     http_server = None
     json_file_name = None
@@ skipping 51 matching lines @@
     if not _GenerateJSONForTestResults(options, log_processor):
       return 1
 
   if options.annotate:
     annotation_utils.annotate(
         options.test_type, result, log_processor,
         options.factory_properties.get('full_test_name'),
         perf_dashboard_id=options.perf_dashboard_id)
 
   if options.results_url:
-    _SendResultsToDashboard(
-        log_processor, _GetPerfID(options),
-        options.test_type, options.results_url, options.build_dir,
-        options.build_properties.get('mastername'),
-        options.build_properties.get('buildername'),
-        options.build_properties.get('buildnumber'),
-        options.supplemental_columns_file,
-        options.perf_config)
+    _SendResultsToDashboard(log_processor, _ResultsDashboardDict(options))
 
   return result
 
 
 def _MainWin(options, args, extra_env):
   """Runs tests on windows.
 
   Using the target build configuration, run the executable given in the
   first non-option argument, passing any following arguments to that
   executable.
@@ skipping 48 matching lines @@
                '--'] + command
   command.extend(args[1:])
 
   # Nuke anything that appears to be stale chrome items in the temporary
   # directory from previous test runs (i.e.- from crashes or unittest leaks).
   slave_utils.RemoveChromeTemporaryFiles()
 
   # If --annotate=list was passed, list the log processor classes and exit.
   if _ListLogProcessors(options.annotate):
     return 0
-  log_processor_class = _SelectLogProcessor(options)
+  log_processor_class = _SelectLogProcessor(options, test_exe)
   log_processor = _CreateLogProcessor(log_processor_class, options)
+  if hasattr(log_processor, 'IsChartJson') and log_processor.IsChartJson():
+    command.extend(log_processor.GetArguments())
 
   if options.generate_json_file:
     if os.path.exists(options.test_output_xml):
       # remove the old XML output file.
       os.remove(options.test_output_xml)
 
   try:
     http_server = None
     if options.document_root:
       http_server = _StartHttpServer('win', build_dir=build_dir,
@@ skipping 24 matching lines @@
     if not _GenerateJSONForTestResults(options, log_processor):
       return 1
 
   if options.annotate:
     annotation_utils.annotate(
         options.test_type, result, log_processor,
         options.factory_properties.get('full_test_name'),
         perf_dashboard_id=options.perf_dashboard_id)
 
   if options.results_url:
-    _SendResultsToDashboard(
-        log_processor, _GetPerfID(options),
-        options.test_type, options.results_url, options.build_dir,
-        options.build_properties.get('mastername'),
-        options.build_properties.get('buildername'),
-        options.build_properties.get('buildnumber'),
-        options.supplemental_columns_file,
-        options.perf_config)
+    _SendResultsToDashboard(log_processor, _ResultsDashboardDict(options))
 
   return result
 
 
 def _MainAndroid(options, args, extra_env):
   """Runs tests on android.
 
   Running GTest-based tests on android is different than on Linux as it requires
   src/build/android/test_runner.py to deploy and communicate with the device.
   Python scripts are the same as with Linux.
 
   Args:
     options: Command-line options for this invocation of runtest.py.
     args: Command and arguments for the test.
     extra_env: A dictionary of extra environment variables to set.
 
   Returns:
     Exit status code.
   """
   if options.run_python_script:
     return _MainLinux(options, args, extra_env)
 
   if len(args) < 1:
     raise chromium_utils.MissingArgument('Usage: %s' % USAGE)
 
   if _ListLogProcessors(options.annotate):
     return 0
-  log_processor_class = _SelectLogProcessor(options)
+  log_processor_class = _SelectLogProcessor(options, args[0])
   log_processor = _CreateLogProcessor(log_processor_class, options)
 
   if options.generate_json_file:
     if os.path.exists(options.test_output_xml):
       # remove the old XML output file.
       os.remove(options.test_output_xml)
 
   # Assume it's a gtest apk, so use the android harness.
   test_suite = args[0]
   run_test_target_option = '--release'
   if options.target == 'Debug':
     run_test_target_option = '--debug'
   command = ['src/build/android/test_runner.py', 'gtest',
              run_test_target_option, '-s', test_suite]
   result = _RunGTestCommand(command, extra_env, log_processor=log_processor)
 
   if options.generate_json_file:
     if not _GenerateJSONForTestResults(options, log_processor):
       return 1
 
   if options.annotate:
     annotation_utils.annotate(
         options.test_type, result, log_processor,
         options.factory_properties.get('full_test_name'),
         perf_dashboard_id=options.perf_dashboard_id)
 
   if options.results_url:
-    _SendResultsToDashboard(
-        log_processor, _GetPerfID(options),
-        options.test_type, options.results_url, options.build_dir,
-        options.build_properties.get('mastername'),
-        options.build_properties.get('buildername'),
-        options.build_properties.get('buildnumber'),
-        options.supplemental_columns_file,
-        options.perf_config)
+    _SendResultsToDashboard(log_processor, _ResultsDashboardDict(options))
 
   return result
 
 
 def main():
   """Entry point for runtest.py.
 
   This function:
     (1) Sets up the command-line options.
     (2) Sets environment variables based on those options.
@@ skipping 387 matching lines @@
   finally:
     if did_launch_dbus:
       # It looks like the command line argument --exit-with-session
       # isn't working to clean up the spawned dbus-daemon. Kill it
       # manually.
       _ShutdownDBus()
 
 
 if '__main__' == __name__:
   sys.exit(main())