[Android] LogcatMonitor.FindAll returns regex match objects

build/android/pylib/device/logcat_monitor.py

 # Copyright 2015 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.
 
 # pylint: disable=unused-argument
 
 import collections
 import itertools
 import logging
 import subprocess
 import tempfile
 import time
 import re
 
 from pylib.device import adb_wrapper
 from pylib.device import decorators
 from pylib.device import device_errors
 
 
 class LogcatMonitor(object):
 
-  # Format: <DATE> <TIME> <PID> <TID> <LEVEL> <COMPONENT>: <MESSAGE>
-  _THREADTIME_RE_FORMAT = r'\S* +\S* +(%s) +(%s) +(%s) +(%s): +(%s)$'
+  _THREADTIME_RE_FORMAT = (
+      r'(?P<date>\S*) +(?P<time>\S*) +(?P<proc_id>%s) +(?P<thread_id>%s) +'
+      r'(?P<log_level>%s) +(?P<component>%s): +(?P<message>%s)$')
 
   def __init__(self, adb, clear=True, filter_specs=None):
     """Create a LogcatMonitor instance.
 
     Args:
       adb: An instance of adb_wrapper.AdbWrapper.
       clear: If True, clear the logcat when monitoring starts.
       filter_specs: An optional list of '<tag>[:priority]' strings.
     """
     if isinstance(adb, adb_wrapper.AdbWrapper):
@@ skipping 56 matching lines @@
     """Finds all lines in the logcat that match the provided constraints.
 
     Args:
       message_regex: The regular expression that the <message> section must
         match.
       proc_id: The process ID to match. If None, matches any process ID.
       thread_id: The thread ID to match. If None, matches any thread ID.
       log_level: The log level to match. If None, matches any log level.
       component: The component to match. If None, matches any component.
 
-    Returns:
-      An iterable containing objects with five attributes:
-        |proc_id|: the process ID
-        |thread_id|: the thread ID
-        |log_level|: the log level
-        |component|: the component
-        |message|: the logcat message
+    Yields:

[jbudorick, 2015/03/18 16:58:40]

Why is this more useful? Why is it easier to do:

  for m in logmon.FindAll(...):
    m.group('log_level')

than

  for m in logmon.FindAll(...):
    m.log_level

[perezju, 2015/03/18 17:38:41]

I want to be able to write, e.g.:

    for m in logmon.FindAll(r'>>> (?P<crash_process>.+) <<<', log_level='I',
component='DEBUG'):
      logging.warning('%s crashed', m.group('crash_process'))

[jbudorick, 2015/03/18 17:43:43]

I can see the case for wanting named capture groups in the message. Would that
work with the current implementation? You'd wind up attempting to compile:

  '(?P<message>>>> (?P<crash_process>.+) <<<)$'

(I've never tried nested named capture groups.)

+      A match object for each matching line in the logcat. The match object
+      will always contain, in addition to groups defined in |message_regex|,
+      the following named groups: 'date', 'time', 'proc_id', 'thread_id',
+      'log_level', 'component', and 'message'.
     """
-    LogcatLine = collections.namedtuple(
-        'LogcatLine',
-        ['proc_id', 'thread_id', 'log_level', 'component', 'message'])
-
     if proc_id is None:
       proc_id = r'\d+'
     if thread_id is None:
       thread_id = r'\d+'
     if log_level is None:
       log_level = r'[VDIWEF]'
     if component is None:
       component = r'[^\s:]+'
     threadtime_re = re.compile(
         type(self)._THREADTIME_RE_FORMAT % (
             proc_id, thread_id, log_level, component, message_regex))
 
-    regexed_lines = (
-        re.match(threadtime_re, l)
-        for l in self._adb.Logcat(dump=True, logcat_format='threadtime'))
-    only_matches = (m for m in regexed_lines if m)
-    return (LogcatLine(*m.group(1, 2, 3, 4, 5)) for m in only_matches)
+    for line in self._adb.Logcat(dump=True, logcat_format='threadtime'):
+      m = re.match(threadtime_re, line)
+      if m:
+        yield m
 
   def Start(self):
     """Starts the logcat monitor.
 
     Clears the logcat if |clear| was set in |__init__|.
     """
     if self._clear:
       self._adb.Logcat(clear=True)
 
   def __enter__(self):
     """Starts the logcat monitor."""
     self.Start()
     return self
 
   def __exit__(self, exc_type, exc_val, exc_tb):
     """Stops the logcat monitor."""
     pass