diff options
Diffstat (limited to 'coverage/debug.py')
| -rw-r--r-- | coverage/debug.py | 193 |
1 files changed, 153 insertions, 40 deletions
diff --git a/coverage/debug.py b/coverage/debug.py index dff8beba..e68736f6 100644 --- a/coverage/debug.py +++ b/coverage/debug.py @@ -8,7 +8,12 @@ import inspect import os import re import sys +try: + import _thread +except ImportError: + import thread as _thread +from coverage.backward import StringIO from coverage.misc import isolate_module os = isolate_module(os) @@ -28,18 +33,27 @@ class DebugControl(object): def __init__(self, options, output): """Configure the options and output file for debugging.""" - self.options = options - self.output = output + self.options = list(options) + FORCED_DEBUG + self.raw_output = output self.suppress_callers = False + filters = [] + if self.should('pid'): + filters.append(add_pid_and_tid) + self.output = DebugOutputFile( + self.raw_output, + show_process=self.should('process'), + filters=filters, + ) + def __repr__(self): - return "<DebugControl options=%r output=%r>" % (self.options, self.output) + return "<DebugControl options=%r raw_output=%r>" % (self.options, self.raw_output) def should(self, option): """Decide whether to output debug information in category `option`.""" if option == "callers" and self.suppress_callers: return False - return (option in self.options or option in FORCED_DEBUG) + return (option in self.options) @contextlib.contextmanager def without_callers(self): @@ -57,18 +71,20 @@ class DebugControl(object): `msg` is the line to write. A newline will be appended. """ - if self.should('pid'): - msg = "pid %5d: %s" % (os.getpid(), msg) self.output.write(msg+"\n") if self.should('callers'): dump_stack_frames(out=self.output, skip=1) self.output.flush() - def write_formatted_info(self, header, info): - """Write a sequence of (label,data) pairs nicely.""" - self.write(info_header(header)) - for line in info_formatter(info): - self.write(" %s" % line) + +class DebugControlString(DebugControl): + """A `DebugControl` that writes to a StringIO, for testing.""" + def __init__(self, options): + super(DebugControlString, self).__init__(options, StringIO()) + + def get_output(self): + """Get the output text from the `DebugControl`.""" + return self.raw_output.getvalue() def info_header(label): @@ -99,6 +115,13 @@ def info_formatter(info): yield "%*s: %s" % (label_len, label, data) +def write_formatted_info(writer, header, info): + """Write a sequence of (label,data) pairs nicely.""" + writer.write(info_header(header)) + for line in info_formatter(info): + writer.write(" %s" % line) + + def short_stack(limit=None, skip=0): """Return a string summarizing the call stack. @@ -122,18 +145,122 @@ def short_stack(limit=None, skip=0): def dump_stack_frames(limit=None, out=None, skip=0): - """Print a summary of the stack to stdout, or some place else.""" + """Print a summary of the stack to stdout, or someplace else.""" out = out or sys.stdout out.write(short_stack(limit=limit, skip=skip+1)) out.write("\n") +def short_id(id64): + """Given a 64-bit id, make a shorter 16-bit one.""" + id16 = 0 + for offset in range(0, 64, 16): + id16 ^= id64 >> offset + return id16 & 0xFFFF + + +def add_pid_and_tid(text): + """A filter to add pid and tid to debug messages.""" + # Thread ids are useful, but too long. Make a shorter one. + tid = "{0:04x}".format(short_id(_thread.get_ident())) + text = "{0:5d}.{1}: {2}".format(os.getpid(), tid, text) + return text + + +def filter_text(text, filters): + """Run `text` through a series of filters. + + `filters` is a list of functions. Each takes a string and returns a + string. Each is run in turn. + + Returns: the final string that results after all of the filters have + run. + + """ + clean_text = text.rstrip() + ending = text[len(clean_text):] + text = clean_text + for fn in filters: + lines = [] + for line in text.splitlines(): + lines.extend(fn(line).splitlines()) + text = "\n".join(lines) + return text + ending + + +class CwdTracker(object): # pragma: debugging + """A class to add cwd info to debug messages.""" + def __init__(self): + self.cwd = None + + def filter(self, text): + """Add a cwd message for each new cwd.""" + cwd = os.getcwd() + if cwd != self.cwd: + text = "cwd is now {0!r}\n".format(cwd) + text + self.cwd = cwd + return text + + +class DebugOutputFile(object): # pragma: debugging + """A file-like object that includes pid and cwd information.""" + def __init__(self, outfile, show_process, filters): + self.outfile = outfile + self.show_process = show_process + self.filters = list(filters) + + if self.show_process: + self.filters.append(CwdTracker().filter) + cmd = " ".join(getattr(sys, 'argv', ['???'])) + self.write("New process: executable: %s\n" % (sys.executable,)) + self.write("New process: cmd: %s\n" % (cmd,)) + if hasattr(os, 'getppid'): + self.write("New process: parent pid: %s\n" % (os.getppid(),)) + + SYS_MOD_NAME = '$coverage.debug.DebugOutputFile.the_one' + + @classmethod + def the_one(cls, fileobj=None, show_process=True, filters=()): + """Get the process-wide singleton DebugOutputFile. + + If it doesn't exist yet, then create it as a wrapper around the file + object `fileobj`. `show_process` controls whether the debug file adds + process-level information. + + """ + # Because of the way igor.py deletes and re-imports modules, + # this class can be defined more than once. But we really want + # a process-wide singleton. So stash it in sys.modules instead of + # on a class attribute. Yes, this is aggressively gross. + the_one = sys.modules.get(cls.SYS_MOD_NAME) + if the_one is None: + assert fileobj is not None + sys.modules[cls.SYS_MOD_NAME] = the_one = cls(fileobj, show_process, filters) + return the_one + + def write(self, text): + """Just like file.write, but filter through all our filters.""" + self.outfile.write(filter_text(text, self.filters)) + self.outfile.flush() + + def flush(self): + """Flush our file.""" + self.outfile.flush() + + def log(msg, stack=False): # pragma: debugging """Write a log message as forcefully as possible.""" - with open("/tmp/covlog.txt", "a") as f: - f.write("{pid}: {msg}\n".format(pid=os.getpid(), msg=msg)) - if stack: - dump_stack_frames(out=f, skip=1) + out = DebugOutputFile.the_one() + out.write(msg+"\n") + if stack: + dump_stack_frames(out=out, skip=1) + + +def filter_aspectlib_frames(text): # pragma: debugging + """Aspectlib prints stack traces, but includes its own frames. Scrub those out.""" + # <<< aspectlib/__init__.py:257:function_wrapper < igor.py:143:run_tests < ... + text = re.sub(r"(?<= )aspectlib/[^.]+\.py:\d+:\w+ < ", "", text) + return text def enable_aspectlib_maybe(): # pragma: debugging @@ -142,7 +269,9 @@ def enable_aspectlib_maybe(): # pragma: debugging Define COVERAGE_ASPECTLIB to enable and configure aspectlib to trace execution:: - COVERAGE_ASPECTLIB=covaspect.txt:coverage.Coverage:coverage.data.CoverageData program... + $ export COVERAGE_LOG=covaspect.txt + $ export COVERAGE_ASPECTLIB=coverage.Coverage:coverage.data.CoverageData + $ coverage run blah.py ... This will trace all the public methods on Coverage and CoverageData, writing the information to covaspect.txt. @@ -155,28 +284,12 @@ def enable_aspectlib_maybe(): # pragma: debugging import aspectlib # pylint: disable=import-error import aspectlib.debug # pylint: disable=import-error - class AspectlibOutputFile(object): - """A file-like object that includes pid and cwd information.""" - def __init__(self, outfile): - self.outfile = outfile - self.cwd = None - - def write(self, text): - """Just like file.write""" - cwd = os.getcwd() - if cwd != self.cwd: - self._write("cwd is now {0!r}\n".format(cwd)) - self.cwd = cwd - self._write(text) - - def _write(self, text): - """The raw text-writer, so that we can use it ourselves.""" - self.outfile.write("{0:5d}: {1}".format(os.getpid(), text)) - - aspects = aspects.split(':') - aspects_file = AspectlibOutputFile(open(aspects[0], "a")) - aspect_log = aspectlib.debug.log(print_to=aspects_file, use_logging=False) - aspects = aspects[1:] + filename = os.environ.get("COVERAGE_LOG", "/tmp/covlog.txt") + filters = [add_pid_and_tid, filter_aspectlib_frames] + aspects_file = DebugOutputFile.the_one(open(filename, "a"), show_process=True, filters=filters) + aspect_log = aspectlib.debug.log( + print_to=aspects_file, attributes=['id'], stacktrace=30, use_logging=False + ) public_methods = re.compile(r'^(__init__|[a-zA-Z].*)$') - for aspect in aspects: + for aspect in aspects.split(':'): aspectlib.weave(aspect, aspect_log, methods=public_methods) |