← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/trace.py

  • Committer: Andrew Bennetts
  • Date: 2010-10-13 06:14:37 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101013061437-2e2m9gro1eusnbb8
Tweaks to the sphinx build.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/trace.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
45
45
form.
46
46
"""
47
47
 
48
 
from __future__ import absolute_import
49
 
 
50
48
# FIXME: Unfortunately it turns out that python's logging module
51
49
# is quite expensive, even when the message is not printed by any handlers.
52
50
# We should perhaps change back to just simply doing it here.
56
54
# increased cost of logging.py is not so bad, and we could standardize on
57
55
# that.
58
56
 
 
57
import codecs
59
58
import logging
60
59
import os
61
60
import sys
62
61
import time
 
62
import tempfile
63
63
 
64
64
from bzrlib.lazy_import import lazy_import
65
65
lazy_import(globals(), """
66
66
from cStringIO import StringIO
67
67
import errno
68
68
import locale
69
 
import tempfile
70
69
import traceback
71
70
""")
72
71
 
73
72
import bzrlib
74
73
 
 
74
from bzrlib.symbol_versioning import (
 
75
    deprecated_function,
 
76
    deprecated_in,
 
77
    )
 
78
 
75
79
lazy_import(globals(), """
76
80
from bzrlib import (
77
81
    debug,
78
82
    errors,
79
83
    osutils,
 
84
    plugin,
 
85
    symbol_versioning,
80
86
    ui,
81
87
    )
82
88
""")
112
118
 
113
119
    :return: None
114
120
    """
 
121
    # FIXME note always emits utf-8, regardless of the terminal encoding
 
122
    #
115
123
    # FIXME: clearing the ui and then going through the abstract logging
116
124
    # framework is whack; we should probably have a logging Handler that
117
125
    # deals with terminal output if needed.
118
 
    ui.ui_factory.clear_term()
 
126
    import bzrlib.ui
 
127
    bzrlib.ui.ui_factory.clear_term()
119
128
    _bzr_logger.info(*args, **kwargs)
120
129
 
121
130
 
122
131
def warning(*args, **kwargs):
123
 
    ui.ui_factory.clear_term()
 
132
    import bzrlib.ui
 
133
    bzrlib.ui.ui_factory.clear_term()
124
134
    _bzr_logger.warning(*args, **kwargs)
125
135
 
126
136
 
 
137
@deprecated_function(deprecated_in((2, 1, 0)))
 
138
def info(*args, **kwargs):
 
139
    """Deprecated: use trace.note instead."""
 
140
    note(*args, **kwargs)
 
141
 
 
142
 
 
143
@deprecated_function(deprecated_in((2, 1, 0)))
 
144
def log_error(*args, **kwargs):
 
145
    """Deprecated: use bzrlib.trace.show_error instead"""
 
146
    _bzr_logger.error(*args, **kwargs)
 
147
 
 
148
 
 
149
@deprecated_function(deprecated_in((2, 1, 0)))
 
150
def error(*args, **kwargs):
 
151
    """Deprecated: use bzrlib.trace.show_error instead"""
 
152
    _bzr_logger.error(*args, **kwargs)
 
153
 
 
154
 
127
155
def show_error(*args, **kwargs):
128
156
    """Show an error message to the user.
129
157
 
284
312
    """
285
313
    start_time = osutils.format_local_date(_bzr_log_start_time,
286
314
                                           timezone='local')
 
315
    # create encoded wrapper around stderr
287
316
    bzr_log_file = _open_bzr_log()
288
317
    if bzr_log_file is not None:
289
318
        bzr_log_file.write(start_time.encode('utf-8') + '\n')
292
321
        r'%Y-%m-%d %H:%M:%S')
293
322
    # after hooking output into bzr_log, we also need to attach a stderr
294
323
    # handler, writing only at level info and with encoding
295
 
    stderr_handler = EncodedStreamHandler(sys.stderr,
296
 
        osutils.get_terminal_encoding(), 'replace', level=logging.INFO)
 
324
    term_encoding = osutils.get_terminal_encoding()
 
325
    writer_factory = codecs.getwriter(term_encoding)
 
326
    encoded_stderr = writer_factory(sys.stderr, errors='replace')
 
327
    stderr_handler = logging.StreamHandler(encoded_stderr)
 
328
    stderr_handler.setLevel(logging.INFO)
297
329
    logging.getLogger('bzr').addHandler(stderr_handler)
298
330
    return memento
299
331
 
304
336
    :param to_file: A file-like object to which messages will be sent.
305
337
 
306
338
    :returns: A memento that should be passed to _pop_log_file to restore the
307
 
        previously active logging.
 
339
    previously active logging.
308
340
    """
309
341
    global _trace_file
310
342
    # make a new handler
311
 
    new_handler = EncodedStreamHandler(to_file, "utf-8", level=logging.DEBUG)
 
343
    new_handler = logging.StreamHandler(to_file)
 
344
    new_handler.setLevel(logging.DEBUG)
312
345
    if log_format is None:
313
346
        log_format = '%(levelname)8s  %(message)s'
314
347
    new_handler.setFormatter(logging.Formatter(log_format, date_format))
457
490
        elif fd is not None:
458
491
            os.close(fd)
459
492
 
460
 
 
461
 
def _qualified_exception_name(eclass, unqualified_bzrlib_errors=False):
462
 
    """Give name of error class including module for non-builtin exceptions
463
 
 
464
 
    If `unqualified_bzrlib_errors` is True, errors specific to bzrlib will
465
 
    also omit the module prefix.
466
 
    """
467
 
    class_name = eclass.__name__
468
 
    module_name = eclass.__module__
469
 
    if module_name in ("exceptions", "__main__") or (
470
 
            unqualified_bzrlib_errors and module_name == "bzrlib.errors"):
471
 
        return class_name
472
 
    return "%s.%s" % (module_name, class_name)
473
 
 
474
 
 
475
493
def report_exception(exc_info, err_file):
476
494
    """Report an exception to err_file (typically stderr) and to .bzr.log.
477
495
 
485
503
        print_exception(exc_info, err_file)
486
504
        return errors.EXIT_ERROR
487
505
    exc_type, exc_object, exc_tb = exc_info
488
 
    if isinstance(exc_object, KeyboardInterrupt):
 
506
    if (isinstance(exc_object, IOError)
 
507
        and getattr(exc_object, 'errno', None) == errno.EPIPE):
 
508
        err_file.write("bzr: broken pipe\n")
 
509
        return errors.EXIT_ERROR
 
510
    elif isinstance(exc_object, KeyboardInterrupt):
489
511
        err_file.write("bzr: interrupted\n")
490
512
        return errors.EXIT_ERROR
491
513
    elif isinstance(exc_object, MemoryError):
503
525
    elif not getattr(exc_object, 'internal_error', True):
504
526
        report_user_error(exc_info, err_file)
505
527
        return errors.EXIT_ERROR
506
 
    elif osutils.is_environment_error(exc_object):
507
 
        if getattr(exc_object, 'errno', None) == errno.EPIPE:
508
 
            err_file.write("bzr: broken pipe\n")
509
 
            return errors.EXIT_ERROR
 
528
    elif isinstance(exc_object, (OSError, IOError)) or (
 
529
        # GZ 2010-05-20: Like (exc_type is pywintypes.error) but avoid import
 
530
        exc_type.__name__ == "error" and exc_type.__module__ == "pywintypes"):
510
531
        # Might be nice to catch all of these and show them as something more
511
532
        # specific, but there are too many cases at the moment.
512
533
        report_user_error(exc_info, err_file)
550
571
    try:
551
572
        sys.stdout.flush()
552
573
        sys.stderr.flush()
553
 
    except ValueError, e:
554
 
        # On Windows, I get ValueError calling stdout.flush() on a closed
555
 
        # handle
556
 
        pass
557
574
    except IOError, e:
558
575
        import errno
559
576
        if e.errno in [errno.EINVAL, errno.EPIPE]:
569
586
        _trace_file.flush()
570
587
 
571
588
 
572
 
class EncodedStreamHandler(logging.Handler):
573
 
    """Robustly write logging events to a stream using the specified encoding
574
 
 
575
 
    Messages are expected to be formatted to unicode, but UTF-8 byte strings
576
 
    are also accepted. An error during formatting or a str message in another
577
 
    encoding will be quitely noted as an error in the Bazaar log file.
578
 
 
579
 
    The stream is not closed so sys.stdout or sys.stderr may be passed.
580
 
    """
581
 
 
582
 
    def __init__(self, stream, encoding=None, errors='strict', level=0):
583
 
        logging.Handler.__init__(self, level)
584
 
        self.stream = stream
585
 
        if encoding is None:
586
 
            encoding = getattr(stream, "encoding", "ascii")
587
 
        self.encoding = encoding
588
 
        self.errors = errors
589
 
 
590
 
    def flush(self):
591
 
        flush = getattr(self.stream, "flush", None)
592
 
        if flush is not None:
593
 
            flush()
594
 
 
595
 
    def emit(self, record):
596
 
        try:
597
 
            line = self.format(record)
598
 
            if not isinstance(line, unicode):
599
 
                line = line.decode("utf-8")
600
 
            self.stream.write(line.encode(self.encoding, self.errors) + "\n")
601
 
        except Exception:
602
 
            log_exception_quietly()
603
 
            # Try saving the details that would have been logged in some form
604
 
            msg = args = "<Unformattable>"
605
 
            try:
606
 
                msg = repr(record.msg).encode("ascii")
607
 
                args = repr(record.args).encode("ascii")
608
 
            except Exception:
609
 
                pass
610
 
            # Using mutter() bypasses the logging module and writes directly
611
 
            # to the file so there's no danger of getting into a loop here.
612
 
            mutter("Logging record unformattable: %s %% %s", msg, args)
613
 
 
614
 
 
615
589
class Config(object):
616
590
    """Configuration of message tracing in bzrlib.
617
591