← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/trace.py

(jelmer) Reduce the number of connections made during "bzr branch
 --stacked". (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/trace.py
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
112
111
 
113
112
    :return: None
114
113
    """
 
114
    # FIXME note always emits utf-8, regardless of the terminal encoding
 
115
    #
115
116
    # FIXME: clearing the ui and then going through the abstract logging
116
117
    # framework is whack; we should probably have a logging Handler that
117
118
    # deals with terminal output if needed.
284
285
    """
285
286
    start_time = osutils.format_local_date(_bzr_log_start_time,
286
287
                                           timezone='local')
 
288
    # create encoded wrapper around stderr
287
289
    bzr_log_file = _open_bzr_log()
288
290
    if bzr_log_file is not None:
289
291
        bzr_log_file.write(start_time.encode('utf-8') + '\n')
292
294
        r'%Y-%m-%d %H:%M:%S')
293
295
    # after hooking output into bzr_log, we also need to attach a stderr
294
296
    # handler, writing only at level info and with encoding
295
 
    stderr_handler = EncodedStreamHandler(sys.stderr,
296
 
        osutils.get_terminal_encoding(), 'replace', level=logging.INFO)
 
297
    term_encoding = osutils.get_terminal_encoding()
 
298
    writer_factory = codecs.getwriter(term_encoding)
 
299
    encoded_stderr = writer_factory(sys.stderr, errors='replace')
 
300
    stderr_handler = logging.StreamHandler(encoded_stderr)
 
301
    stderr_handler.setLevel(logging.INFO)
297
302
    logging.getLogger('bzr').addHandler(stderr_handler)
298
303
    return memento
299
304
 
308
313
    """
309
314
    global _trace_file
310
315
    # make a new handler
311
 
    new_handler = EncodedStreamHandler(to_file, "utf-8", level=logging.DEBUG)
 
316
    new_handler = logging.StreamHandler(to_file)
 
317
    new_handler.setLevel(logging.DEBUG)
312
318
    if log_format is None:
313
319
        log_format = '%(levelname)8s  %(message)s'
314
320
    new_handler.setFormatter(logging.Formatter(log_format, date_format))
485
491
        print_exception(exc_info, err_file)
486
492
        return errors.EXIT_ERROR
487
493
    exc_type, exc_object, exc_tb = exc_info
488
 
    if isinstance(exc_object, KeyboardInterrupt):
 
494
    if (isinstance(exc_object, IOError)
 
495
        and getattr(exc_object, 'errno', None) == errno.EPIPE):
 
496
        err_file.write("bzr: broken pipe\n")
 
497
        return errors.EXIT_ERROR
 
498
    elif isinstance(exc_object, KeyboardInterrupt):
489
499
        err_file.write("bzr: interrupted\n")
490
500
        return errors.EXIT_ERROR
491
501
    elif isinstance(exc_object, MemoryError):
503
513
    elif not getattr(exc_object, 'internal_error', True):
504
514
        report_user_error(exc_info, err_file)
505
515
        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
 
516
    elif isinstance(exc_object, (OSError, IOError)) or (
 
517
        # GZ 2010-05-20: Like (exc_type is pywintypes.error) but avoid import
 
518
        exc_type.__name__ == "error" and exc_type.__module__ == "pywintypes"):
510
519
        # Might be nice to catch all of these and show them as something more
511
520
        # specific, but there are too many cases at the moment.
512
521
        report_user_error(exc_info, err_file)
569
578
        _trace_file.flush()
570
579
 
571
580
 
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
581
class Config(object):
616
582
    """Configuration of message tracing in bzrlib.
617
583