Enable writing to logdog for tombstones.py.

build/android/tombstones.py

 #!/usr/bin/env python
 #
 # Copyright 2013 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.
 #
 # Find the most recent tombstone file(s) on all connected devices
 # and prints their stacks.
 #
 # Assumes tombstone file was created with current symbols.
 
 import argparse
 import datetime
 import logging
 import multiprocessing
 import os
 import re
 import subprocess
 import sys
 
 import devil_chromium
 
 from devil.android import device_blacklist
 from devil.android import device_errors
 from devil.android import device_utils
 from devil.utils import run_tests_helper
 from pylib import constants
 
+sys.path.insert(0, os.path.abspath(os.path.join(
+    constants.DIR_SOURCE_ROOT, 'tools', 'swarming_client')))
+from libs.logdog import bootstrap # pylint: disable=import-error
+
 
 _TZ_UTC = {'TZ': 'UTC'}
 
 
 def _ListTombstones(device):
   """List the tombstone files on the device.
 
   Args:
     device: An instance of DeviceUtils.
 
@@ skipping 57 matching lines @@
 
 def _DeviceAbiToArch(device_abi):
   # The order of this list is significant to find the more specific match (e.g.,
   # arm64) before the less specific (e.g., arm).
   arches = ['arm64', 'arm', 'x86_64', 'x86_64', 'x86', 'mips']
   for arch in arches:
     if arch in device_abi:
       return arch
   raise RuntimeError('Unknown device ABI: %s' % device_abi)
 
+
 def _ResolveSymbols(tombstone_data, include_stack, device_abi):
   """Run the stack tool for given tombstone input.
 
   Args:
     tombstone_data: a list of strings of tombstone data.
     include_stack: boolean whether to include stack data in output.
     device_abi: the default ABI of the device which generated the tombstone.
 
   Yields:
     A string for each line of resolved stack output.
@@ skipping 47 matching lines @@
   if len(tombstones) == 1:
     data = [_ResolveTombstone(tombstones[0])]
   else:
     pool = multiprocessing.Pool(processes=jobs)
     data = pool.map(_ResolveTombstone, tombstones)
   resolved_tombstones = []
   for tombstone in data:
     resolved_tombstones.extend(tombstone)
   return resolved_tombstones
 
+
 def _GetTombstonesForDevice(device, resolve_all_tombstones,
                             include_stack_symbols,
                             wipe_tombstones):
   """Returns a list of tombstones on a given device.
 
   Args:
     device: An instance of DeviceUtils.
     resolve_all_tombstone: Whether to resolve every tombstone.
     include_stack_symbols: Whether to include symbols for stack data.
     wipe_tombstones: Whether to wipe tombstones.
@@ skipping 26 matching lines @@
       logging.info('%s: %s', str(device), entry)
     raise
 
   # Erase all the tombstones if desired.
   if wipe_tombstones:
     for tombstone_file, _ in all_tombstones:
       _EraseTombstone(device, tombstone_file)
 
   return ret
 
+
 def ClearAllTombstones(device):
   """Clear all tombstones in the device.
 
   Args:
     device: An instance of DeviceUtils.
   """
   all_tombstones = list(_ListTombstones(device))
   if not all_tombstones:
     logging.warning('No tombstones to clear.')
 
   for tombstone_file, _ in all_tombstones:
     _EraseTombstone(device, tombstone_file)
 
+
 def ResolveTombstones(device, resolve_all_tombstones, include_stack_symbols,
                       wipe_tombstones, jobs=4):
   """Resolve tombstones in the device.
 
   Args:
     device: An instance of DeviceUtils.
     resolve_all_tombstone: Whether to resolve every tombstone.
     include_stack_symbols: Whether to include symbols for stack data.
     wipe_tombstones: Whether to wipe tombstones.
     jobs: Number of jobs to use when processing multiple crash stacks.
+
+  Returns:
+    A list of resolved tombstones.
   """
   return _ResolveTombstones(jobs,
                             _GetTombstonesForDevice(device,
                                                     resolve_all_tombstones,
                                                     include_stack_symbols,
                                                     wipe_tombstones))
 
+
+def LogdogTombstones(resolved_tombstones, stream_name):
+  """Save resolved tombstones to logdog and return the url.
+
+  Args:
+    stream_name: The name of the logdog stream that records tombstones.
+    resolved_tombstones: Resolved tombstones (output of ResolveTombstones).
+
+  Returns:
+    A url link to the recorded tombstones.
+  """
+  try:
+    tombstones_url = ''
+    stream_client = bootstrap.ButlerBootstrap.probe().stream_client()
+    with stream_client.open_text(stream_name) as logdog_stream:

[jbudorick, 2016/12/14 17:58:44]

stream_client.text(stream_name), not stream_client.open_text(stream_name):
https://codesearch.chromium.org/chromium/src/tools/swarming_client/libs/logdo...

[BigBossZhiling, 2016/12/14 21:42:30]

Done.

+      for tombstones_line in resolved_tombstones:
+        logdog_stream.write(tombstones_line + '\n')
+      tombstones_url = logdog_stream.get_viewer_url(stream_name)
+  except bootstrap.NotBootstrappedError:
+    logging.exception('Error not bootstrapped. Failed to start logdog')
+  except (KeyError, ValueError) as e:
+    logging.exception('Error when creating stream_client/stream: %s.', e)
+  except Exception as e: # pylint: disable=broad-except
+    logging.exception('Unknown Error: %s.', e)
+  return tombstones_url
+
+
 def main():
   custom_handler = logging.StreamHandler(sys.stdout)
   custom_handler.setFormatter(run_tests_helper.CustomFormatter())
   logging.getLogger().addHandler(custom_handler)
   logging.getLogger().setLevel(logging.INFO)
 
   parser = argparse.ArgumentParser()
   parser.add_argument('--device',
                       help='The serial number of the device. If not specified '
                            'will use all devices.')
@@ skipping 34 matching lines @@
   # This must be done serially because strptime can hit a race condition if
   # used for the first time in a multithreaded environment.
   # http://bugs.python.org/issue7980
   for device in devices:
     resolved_tombstones = ResolveTombstones(
         device, args.all_tombstones,
         args.stack, args.wipe_tombstones, args.jobs)
     for line in resolved_tombstones:
       logging.info(line)
 
+
 if __name__ == '__main__':
   sys.exit(main())