Slowly transition to the "with api.get_tracer() as tracer:".

tools/isolate/trace_inputs.py

 #!/usr/bin/env python
 # coding=utf-8
 # 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.
 
 """Traces an executable and its child processes and extract the files accessed
 by them.
 
 The implementation uses OS-specific API. The native Kernel logger and the ETL
@@ skipping 625 matching lines @@
       self._initialized = False
 
     def __enter__(self):
       """Enables 'with' statement."""
       return self
 
     def __exit__(self, exc_type, exc_value, traceback):
       """Enables 'with' statement."""
       self.close()
 
-  def get_tracer(self, logname=None):
+  def get_tracer(self, logname):
     """Returns an ApiBase.Tracer instance.
 
     Initializes the tracing subsystem, which is a requirement for kernel-based
     tracers. Only one tracer instance should be live at a time!
 
     logname is the filepath to the json file that will contain the meta-data
     about the logs.
     """
     return self.Tracer(logname)
 
@@ skipping 324 matching lines @@
 
     @classmethod
     def traces(cls):
       """Returns the list of all handled traces to pass this as an argument to
       strace.
       """
       prefix = 'handle_'
       return [i[len(prefix):] for i in dir(cls.Process) if i.startswith(prefix)]
 
   class Tracer(ApiBase.Tracer):
-    @classmethod
-    def trace(cls, cmd, cwd, logname, output):
-      """Runs strace on an executable.
-
-      Since the logs are per pid, we need to log the list of the initial pid.
-      """
-      logging.info('trace(%s, %s, %s, %s)' % (cmd, cwd, logname, output))
+    def trace(self, cmd, cwd, tracename, output):
+      """Runs strace on an executable."""
+      logging.info('trace(%s, %s, %s, %s)' % (cmd, cwd, tracename, output))
       stdout = stderr = None
       if output:
         stdout = subprocess.PIPE
         stderr = subprocess.STDOUT
       traces = ','.join(Strace.Context.traces())
       trace_cmd = [
         'strace',
         '-ff',
         '-s', '256',
         '-e', 'trace=%s' % traces,
-        '-o', logname,
+        '-o', self._logname,
       ]
       child = subprocess.Popen(
           trace_cmd + cmd,
           cwd=cwd,
           stdin=subprocess.PIPE,
           stdout=stdout,
           stderr=stderr)
       out = child.communicate()[0]
       # Once it's done, write metadata into the log file to be able to follow
       # the pid files.
       value = {
         'cwd': cwd,
         # The pid of strace process, not very useful.
         'pid': child.pid,
       }
-      write_json(logname, value, False)
+      write_json(self._logname, value, False)
       return child.returncode, out
 
   @staticmethod
   def clean_trace(logname):
     if os.path.isfile(logname):
       os.remove(logname)
     # Also delete any pid specific file from previous traces.
     for i in glob.iglob(logname + '.*'):
       if i.rsplit('.', 1)[1].isdigit():
         os.remove(i)
@@ skipping 555 matching lines @@
       - there is no way to figure out the absolute path of cwd in kernel on OSX
       """
       cwd = os.path.realpath(cwd).replace('\\', '\\\\').replace('%', '%%')
       return (
           'inline int TRACER_PID = %d;\n'
           'inline string CWD = "%s";\n'
           '\n'
           '%s\n'
           '%s') % (pid, cwd, cls.D_CODE, cls.D_CODE_EXECVE)
 
-    @classmethod
-    def trace(cls, cmd, cwd, logname, output):
+    def trace(self, cmd, cwd, tracename, output):
       """Runs dtrace on an executable.
 
       This dtruss is broken when it starts the process itself or when tracing
       child processes, this code starts a wrapper process
       trace_child_process.py, which waits for dtrace to start, then
       trace_child_process.py starts the executable to trace.
       """
-      logging.info('trace(%s, %s, %s, %s)' % (cmd, cwd, logname, output))
+      logging.info('trace(%s, %s, %s, %s)' % (cmd, cwd, tracename, output))
       logging.info('Running: %s' % cmd)
       signal = 'Go!'
       logging.debug('Our pid: %d' % os.getpid())
 
       # Part 1: start the child process.
       stdout = stderr = None
       if output:
         stdout = subprocess.PIPE
         stderr = subprocess.STDOUT
       child_cmd = [
@@ skipping 11 matching lines @@
 
       # Part 2: start dtrace process.
       # Note: do not use the -p flag. It's useless if the initial process quits
       # too fast, resulting in missing traces from the grand-children. The D
       # code manages the dtrace lifetime itself.
       trace_cmd = [
         'sudo',
         'dtrace',
         '-x', 'dynvarsize=4m',
         '-x', 'evaltime=exec',
-        '-n', cls.code(child.pid, cwd),
+        '-n', self.code(child.pid, cwd),
         '-o', '/dev/stderr',
         '-q',
       ]
-      with open(logname, 'w') as logfile:
+      with open(self._logname, 'w') as logfile:
         dtrace = subprocess.Popen(
             trace_cmd, stdout=logfile, stderr=subprocess.STDOUT)
       logging.debug('Started dtrace pid: %d' % dtrace.pid)
 
       # Part 3: Read until one line is printed, which signifies dtrace is up and
       # ready.
-      with open(logname, 'r') as logfile:
+      with open(self._logname, 'r') as logfile:
         while 'dtrace_BEGIN' not in logfile.readline():
           if dtrace.poll() is not None:
             break
 
       try:
         # Part 4: We can now tell our child to go.
         # TODO(maruel): Another pipe than stdin could be used instead. This
         # would be more consistent with the other tracing methods.
         out = child.communicate(signal)[0]
 
         dtrace.wait()
         if dtrace.returncode != 0:
           print 'dtrace failure: %d' % dtrace.returncode
-          with open(logname) as logfile:
+          with open(self._logname) as logfile:
             print ''.join(logfile.readlines()[-100:])
           # Find a better way.
-          os.remove(logname)
+          os.remove(self._logname)
         else:
           # Short the log right away to simplify our life. There isn't much
           # advantage in keeping it out of order.
-          cls._sort_log(logname)
+          self._sort_log(self._logname)
       except KeyboardInterrupt:
         # Still sort when testing.
-        cls._sort_log(logname)
+        self._sort_log(self._logname)
         raise
 
       return dtrace.returncode or child.returncode, out
 
     @staticmethod
     def _sort_log(logname):
       """Sorts the log back in order when each call occured.
 
       dtrace doesn't save the buffer in strict order since it keeps one buffer
         per CPU.
@@ skipping 355 matching lines @@
     def supported_events(cls):
       """Returns all the procesed events."""
       out = []
       for member in dir(cls):
         match = re.match(r'^handle_([A-Za-z]+)_([A-Za-z]+)$', member)
         if match:
           out.append(match.groups())
       return out
 
   class Tracer(ApiBase.Tracer):
-    @classmethod
-    def trace(cls, cmd, cwd, logname, output):
+    def trace(self, cmd, cwd, tracename, output):
       """Uses logman.exe to start and stop the NT Kernel Logger while the
       executable to be traced is run.
       """
-      logging.info('trace(%s, %s, %s, %s)' % (cmd, cwd, logname, output))
+      logging.info('trace(%s, %s, %s, %s)' % (cmd, cwd, tracename, output))
       # Use "logman -?" for help.
 
       stdout = stderr = None
       if output:
         stdout = subprocess.PIPE
         stderr = subprocess.STDOUT
 
       # 1. Start the log collection.
-      cls._start_log(logname + '.etl')
+      self._start_log(self._logname + '.etl')
 
       # 2. Run the child process.
       logging.debug('Running: %s' % cmd)
       try:
         # Use trace_child_process.py so we have a clear pid owner. Since
         # trace_inputs.py can be used as a library and could trace mulitple
         # processes simultaneously, it makes it more complex if the executable
         # to be traced is executed directly here. It also solves issues related
         # to logman.exe that needs to be executed to control the kernel trace.
         child_cmd = [
           sys.executable,
           os.path.join(BASE_DIR, 'trace_child_process.py'),
         ]
         child = subprocess.Popen(
             child_cmd + cmd,
             cwd=cwd,
             stdin=subprocess.PIPE,
             stdout=stdout,
             stderr=stderr)
         logging.debug('Started child pid: %d' % child.pid)
         out = child.communicate()[0]
       finally:
         # 3. Stop the log collection.
-        cls._stop_log()
+        self._stop_log()
 
       # 4. Convert log
       # TODO(maruel): Temporary, remove me.
-      LogmanTrace.process_log(logname)
+      LogmanTrace.process_log(self._logname)
 
       # 5. Save metadata.
       value = {
         'pid': child.pid,
         'format': 'csv',
       }
-      write_json(logname, value, False)
+      write_json(self._logname, value, False)
       return child.returncode, out
 
     @classmethod
     def _start_log(cls, etl):
       """Starts the log collection.
 
       One can get the list of potentially interesting providers with:
       "logman query providers | findstr /i file"
       """
       cmd_start = [
@@ skipping 321 matching lines @@
   Arguments:
   - logfile: file to write to.
   - cmd: command to run.
   - cwd: current directory to start the process in.
   - api: a tracing api instance.
   - output: if True, returns output, otherwise prints it at the console.
   """
   cmd = fix_python_path(cmd)
   assert os.path.isabs(cmd[0]), cmd[0]
   api.clean_trace(logfile)
-  return api.get_tracer().trace(cmd, cwd, logfile, output)
+  with api.get_tracer(logfile) as tracer:
+    return tracer.trace(cmd, cwd, 'default', output)
 
 
 def load_trace(logfile, root_dir, api):
   """Loads a trace file and returns the Results instance.
 
   Arguments:
   - logfile: File to load.
   - root_dir: Root directory to use to determine if a file is relevant to the
               trace or not.
   - api: A tracing api instance.
@@ skipping 156 matching lines @@
       for fn in dir(sys.modules[__name__])
       if fn.startswith('CMD')))
 
   command = get_command_handler(argv[0] if argv else None)
   parser = gen_parser(command)
   return command(parser, argv[1:])
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))