← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/trace.py

Merge fix for overflow issues in pack_stat from 2.4

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.
194
195
 
195
196
 
196
197
def _get_bzr_log_filename():
197
 
    bzr_log = osutils.path_from_environ('BZR_LOG')
 
198
    bzr_log = os.environ.get('BZR_LOG')
198
199
    if bzr_log:
199
200
        return bzr_log
200
 
    home = osutils.path_from_environ('BZR_HOME')
 
201
    home = os.environ.get('BZR_HOME')
201
202
    if home is None:
202
 
        # GZ 2012-02-01: Logging to the home dir is bad, but XDG is unclear
203
 
        #                over what would be better. On windows, bug 240550
204
 
        #                suggests LOCALAPPDATA be used instead.
205
 
        home = osutils._get_home_dir()
 
203
        if sys.platform == 'win32':
 
204
            from bzrlib import win32utils
 
205
            home = win32utils.get_home_location()
 
206
        else:
 
207
            home = os.path.expanduser('~')
206
208
    return os.path.join(home, '.bzr.log')
207
209
 
208
210
 
283
285
    """
284
286
    start_time = osutils.format_local_date(_bzr_log_start_time,
285
287
                                           timezone='local')
 
288
    # create encoded wrapper around stderr
286
289
    bzr_log_file = _open_bzr_log()
287
290
    if bzr_log_file is not None:
288
291
        bzr_log_file.write(start_time.encode('utf-8') + '\n')
291
294
        r'%Y-%m-%d %H:%M:%S')
292
295
    # after hooking output into bzr_log, we also need to attach a stderr
293
296
    # handler, writing only at level info and with encoding
294
 
    stderr_handler = EncodedStreamHandler(sys.stderr,
295
 
        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)
296
302
    logging.getLogger('bzr').addHandler(stderr_handler)
297
303
    return memento
298
304
 
307
313
    """
308
314
    global _trace_file
309
315
    # make a new handler
310
 
    new_handler = EncodedStreamHandler(to_file, "utf-8", level=logging.DEBUG)
 
316
    new_handler = logging.StreamHandler(to_file)
 
317
    new_handler.setLevel(logging.DEBUG)
311
318
    if log_format is None:
312
319
        log_format = '%(levelname)8s  %(message)s'
313
320
    new_handler.setFormatter(logging.Formatter(log_format, date_format))
484
491
        print_exception(exc_info, err_file)
485
492
        return errors.EXIT_ERROR
486
493
    exc_type, exc_object, exc_tb = exc_info
487
 
    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):
488
499
        err_file.write("bzr: interrupted\n")
489
500
        return errors.EXIT_ERROR
490
501
    elif isinstance(exc_object, MemoryError):
502
513
    elif not getattr(exc_object, 'internal_error', True):
503
514
        report_user_error(exc_info, err_file)
504
515
        return errors.EXIT_ERROR
505
 
    elif osutils.is_environment_error(exc_object):
506
 
        if getattr(exc_object, 'errno', None) == errno.EPIPE:
507
 
            err_file.write("bzr: broken pipe\n")
508
 
            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"):
509
519
        # Might be nice to catch all of these and show them as something more
510
520
        # specific, but there are too many cases at the moment.
511
521
        report_user_error(exc_info, err_file)
549
559
    try:
550
560
        sys.stdout.flush()
551
561
        sys.stderr.flush()
552
 
    except ValueError, e:
553
 
        # On Windows, I get ValueError calling stdout.flush() on a closed
554
 
        # handle
555
 
        pass
556
562
    except IOError, e:
557
563
        import errno
558
564
        if e.errno in [errno.EINVAL, errno.EPIPE]:
568
574
        _trace_file.flush()
569
575
 
570
576
 
571
 
class EncodedStreamHandler(logging.Handler):
572
 
    """Robustly write logging events to a stream using the specified encoding
573
 
 
574
 
    Messages are expected to be formatted to unicode, but UTF-8 byte strings
575
 
    are also accepted. An error during formatting or a str message in another
576
 
    encoding will be quitely noted as an error in the Bazaar log file.
577
 
 
578
 
    The stream is not closed so sys.stdout or sys.stderr may be passed.
579
 
    """
580
 
 
581
 
    def __init__(self, stream, encoding=None, errors='strict', level=0):
582
 
        logging.Handler.__init__(self, level)
583
 
        self.stream = stream
584
 
        if encoding is None:
585
 
            encoding = getattr(stream, "encoding", "ascii")
586
 
        self.encoding = encoding
587
 
        self.errors = errors
588
 
 
589
 
    def flush(self):
590
 
        flush = getattr(self.stream, "flush", None)
591
 
        if flush is not None:
592
 
            flush()
593
 
 
594
 
    def emit(self, record):
595
 
        try:
596
 
            line = self.format(record)
597
 
            if not isinstance(line, unicode):
598
 
                line = line.decode("utf-8")
599
 
            self.stream.write(line.encode(self.encoding, self.errors) + "\n")
600
 
        except Exception:
601
 
            log_exception_quietly()
602
 
            # Try saving the details that would have been logged in some form
603
 
            msg = args = "<Unformattable>"
604
 
            try:
605
 
                msg = repr(record.msg).encode("ascii")
606
 
                args = repr(record.args).encode("ascii")
607
 
            except Exception:
608
 
                pass
609
 
            # Using mutter() bypasses the logging module and writes directly
610
 
            # to the file so there's no danger of getting into a loop here.
611
 
            mutter("Logging record unformattable: %s %% %s", msg, args)
612
 
 
613
 
 
614
577
class Config(object):
615
578
    """Configuration of message tracing in bzrlib.
616
579