/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/trace.py

  • Committer: Jelmer Vernooij
  • Date: 2019-05-29 03:22:34 UTC
  • mfrom: (7303 work)
  • mto: This revision was merged to the branch mainline in revision 7306.
  • Revision ID: jelmer@jelmer.uk-20190529032234-mt3fuws8gq03tapi
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/trace.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
23
23
Messages are classified by severity levels: critical, error, warning, info,
24
24
and debug.
25
25
 
26
 
They can be sent to two places: to stderr, and to ~/.bzr.log.  For purposes
 
26
They can be sent to two places: to stderr, and to ~/.brz.log.  For purposes
27
27
such as running the test suite, they can also be redirected away from both of
28
28
those two places to another location.
29
29
 
30
 
~/.bzr.log gets all messages, and full tracebacks for uncaught exceptions.
 
30
~/.brz.log gets all messages, and full tracebacks for uncaught exceptions.
31
31
This trace file is always in UTF-8, regardless of the user's default encoding,
32
32
so that we can always rely on writing any message.
33
33
 
45
45
form.
46
46
"""
47
47
 
 
48
from __future__ import absolute_import
 
49
 
48
50
# FIXME: Unfortunately it turns out that python's logging module
49
51
# is quite expensive, even when the message is not printed by any handlers.
50
52
# We should perhaps change back to just simply doing it here.
54
56
# increased cost of logging.py is not so bad, and we could standardize on
55
57
# that.
56
58
 
57
 
import codecs
 
59
import errno
58
60
import logging
59
61
import os
60
62
import sys
61
63
import time
62
64
 
63
 
from bzrlib.lazy_import import lazy_import
 
65
from .lazy_import import lazy_import
64
66
lazy_import(globals(), """
65
 
from cStringIO import StringIO
66
 
import errno
67
 
import locale
 
67
import tempfile
68
68
import traceback
69
69
""")
70
70
 
71
 
import bzrlib
72
 
 
73
 
from bzrlib.symbol_versioning import (
74
 
    deprecated_function,
75
 
    deprecated_in,
76
 
    )
 
71
import breezy
77
72
 
78
73
lazy_import(globals(), """
79
 
from bzrlib import (
 
74
from breezy import (
80
75
    debug,
81
76
    errors,
82
77
    osutils,
83
 
    plugin,
84
 
    symbol_versioning,
85
78
    ui,
86
79
    )
87
80
""")
88
81
 
89
 
 
90
 
# global verbosity for bzrlib; controls the log level for stderr; 0=normal; <0
 
82
from .sixish import (
 
83
    PY3,
 
84
    StringIO,
 
85
    text_type,
 
86
    )
 
87
 
 
88
 
 
89
# global verbosity for breezy; controls the log level for stderr; 0=normal; <0
91
90
# is quiet; >0 is verbose.
92
91
_verbosity_level = 0
93
92
 
97
96
# than push/pop_log_file.
98
97
_trace_file = None
99
98
 
100
 
# Absolute path for ~/.bzr.log.  Not changed even if the log/trace output is
 
99
# Absolute path for ~/.brz.log.  Not changed even if the log/trace output is
101
100
# redirected elsewhere.  Used to show the location in --version.
102
 
_bzr_log_filename = None
 
101
_brz_log_filename = None
103
102
 
104
103
# The time the first message was written to the trace file, so that we can
105
104
# show relative times since startup.
106
 
_bzr_log_start_time = bzrlib._start_time
 
105
_brz_log_start_time = breezy._start_time
107
106
 
108
107
 
109
108
# held in a global for quick reference
110
 
_bzr_logger = logging.getLogger('bzr')
 
109
_brz_logger = logging.getLogger('brz')
111
110
 
112
111
 
113
112
def note(*args, **kwargs):
114
113
    """Output a note to the user.
115
114
 
116
115
    Takes the same parameters as logging.info.
 
116
 
117
117
    :return: None
118
118
    """
119
 
    # FIXME note always emits utf-8, regardless of the terminal encoding
120
 
    #
121
119
    # FIXME: clearing the ui and then going through the abstract logging
122
120
    # framework is whack; we should probably have a logging Handler that
123
121
    # deals with terminal output if needed.
124
 
    import bzrlib.ui
125
 
    bzrlib.ui.ui_factory.clear_term()
126
 
    _bzr_logger.info(*args, **kwargs)
 
122
    ui.ui_factory.clear_term()
 
123
    _brz_logger.info(*args, **kwargs)
127
124
 
128
125
 
129
126
def warning(*args, **kwargs):
130
 
    import bzrlib.ui
131
 
    bzrlib.ui.ui_factory.clear_term()
132
 
    _bzr_logger.warning(*args, **kwargs)
133
 
 
134
 
 
135
 
@deprecated_function(deprecated_in((2, 1, 0)))
136
 
def info(*args, **kwargs):
137
 
    """Deprecated: use trace.note instead."""
138
 
    note(*args, **kwargs)
139
 
 
140
 
 
141
 
@deprecated_function(deprecated_in((2, 1, 0)))
142
 
def log_error(*args, **kwargs):
143
 
    """Deprecated: use bzrlib.trace.show_error instead"""
144
 
    _bzr_logger.error(*args, **kwargs)
145
 
 
146
 
 
147
 
@deprecated_function(deprecated_in((2, 1, 0)))
148
 
def error(*args, **kwargs):
149
 
    """Deprecated: use bzrlib.trace.show_error instead"""
150
 
    _bzr_logger.error(*args, **kwargs)
 
127
    ui.ui_factory.clear_term()
 
128
    _brz_logger.warning(*args, **kwargs)
151
129
 
152
130
 
153
131
def show_error(*args, **kwargs):
155
133
 
156
134
    Don't use this for exceptions, use report_exception instead.
157
135
    """
158
 
    _bzr_logger.error(*args, **kwargs)
 
136
    _brz_logger.error(*args, **kwargs)
 
137
 
 
138
 
 
139
class _Bytes(str):
 
140
    """Compat class for displaying bytes on Python 2."""
 
141
 
 
142
    def __repr__(self):
 
143
        return 'b' + str.__repr__(self)
 
144
 
 
145
    def __unicode__(self):
 
146
        return self.decode('ascii', 'replace')
159
147
 
160
148
 
161
149
def mutter(fmt, *args):
166
154
    if (getattr(_trace_file, 'closed', None) is not None) and _trace_file.closed:
167
155
        return
168
156
 
169
 
    if isinstance(fmt, unicode):
170
 
        fmt = fmt.encode('utf8')
 
157
    # Let format strings be specified as ascii bytes to help Python 2
 
158
    if isinstance(fmt, bytes):
 
159
        fmt = fmt.decode('ascii', 'replace')
171
160
 
172
 
    if len(args) > 0:
173
 
        # It seems that if we do ascii % (unicode, ascii) we can
174
 
        # get a unicode cannot encode ascii error, so make sure that "fmt"
175
 
        # is a unicode string
176
 
        real_args = []
177
 
        for arg in args:
178
 
            if isinstance(arg, unicode):
179
 
                arg = arg.encode('utf8')
180
 
            real_args.append(arg)
181
 
        out = fmt % tuple(real_args)
 
161
    if args:
 
162
        if not PY3:
 
163
            args = tuple(
 
164
                _Bytes(arg) if isinstance(arg, bytes) else arg for arg in args)
 
165
        out = fmt % args
182
166
    else:
183
167
        out = fmt
184
168
    now = time.time()
185
 
    timestamp = '%0.3f  ' % (now - _bzr_log_start_time,)
186
 
    out = timestamp + out + '\n'
187
 
    _trace_file.write(out)
 
169
    out = '%0.3f  %s\n' % (now - _brz_log_start_time, out)
 
170
    _trace_file.write(out.encode('utf-8'))
188
171
    # there's no explicit flushing; the file is typically line buffered.
189
172
 
190
173
 
219
202
        return
220
203
 
221
204
 
222
 
def _get_bzr_log_filename():
223
 
    bzr_log = os.environ.get('BZR_LOG')
224
 
    if bzr_log:
225
 
        return bzr_log
226
 
    home = os.environ.get('BZR_HOME')
 
205
def _get_brz_log_filename():
 
206
    brz_log = osutils.path_from_environ('BRZ_LOG')
 
207
    if brz_log:
 
208
        return brz_log
 
209
    home = osutils.path_from_environ('BRZ_HOME')
227
210
    if home is None:
228
 
        if sys.platform == 'win32':
229
 
            from bzrlib import win32utils
230
 
            home = win32utils.get_home_location()
231
 
        else:
232
 
            home = os.path.expanduser('~')
233
 
    return os.path.join(home, '.bzr.log')
234
 
 
235
 
 
236
 
def _open_bzr_log():
237
 
    """Open the .bzr.log trace file.
 
211
        # GZ 2012-02-01: Logging to the home dir is bad, but XDG is unclear
 
212
        #                over what would be better. On windows, bug 240550
 
213
        #                suggests LOCALAPPDATA be used instead.
 
214
        home = osutils._get_home_dir()
 
215
    return os.path.join(home, '.brz.log')
 
216
 
 
217
 
 
218
def _open_brz_log():
 
219
    """Open the .brz.log trace file.
238
220
 
239
221
    If the log is more than a particular length, the old file is renamed to
240
 
    .bzr.log.old and a new file is started.  Otherwise, we append to the
 
222
    .brz.log.old and a new file is started.  Otherwise, we append to the
241
223
    existing file.
242
224
 
243
 
    This sets the global _bzr_log_filename.
 
225
    This sets the global _brz_log_filename.
244
226
    """
245
 
    global _bzr_log_filename
 
227
    global _brz_log_filename
246
228
 
247
229
    def _open_or_create_log_file(filename):
248
230
        """Open existing log file, or create with ownership and permissions
256
238
            try:
257
239
                fd = os.open(filename, flags)
258
240
                break
259
 
            except OSError, e:
 
241
            except OSError as e:
260
242
                if e.errno != errno.ENOENT:
261
243
                    raise
262
244
            try:
263
 
                fd = os.open(filename, flags | os.O_CREAT | os.O_EXCL, 0666)
264
 
            except OSError, e:
 
245
                fd = os.open(filename, flags | os.O_CREAT | os.O_EXCL, 0o666)
 
246
            except OSError as e:
265
247
                if e.errno != errno.EEXIST:
266
248
                    raise
267
249
            else:
268
250
                osutils.copy_ownership_from_path(filename)
269
251
                break
270
 
        return os.fdopen(fd, 'at', 0) # unbuffered
271
 
 
272
 
 
273
 
    _bzr_log_filename = _get_bzr_log_filename()
274
 
    _rollover_trace_maybe(_bzr_log_filename)
 
252
        return os.fdopen(fd, 'ab', 0)  # unbuffered
 
253
 
 
254
    _brz_log_filename = _get_brz_log_filename()
 
255
    _rollover_trace_maybe(_brz_log_filename)
275
256
    try:
276
 
        bzr_log_file = _open_or_create_log_file(_bzr_log_filename)
277
 
        bzr_log_file.write('\n')
278
 
        if bzr_log_file.tell() <= 2:
279
 
            bzr_log_file.write("this is a debug log for diagnosing/reporting problems in bzr\n")
280
 
            bzr_log_file.write("you can delete or truncate this file, or include sections in\n")
281
 
            bzr_log_file.write("bug reports to https://bugs.launchpad.net/bzr/+filebug\n\n")
282
 
 
283
 
        return bzr_log_file
284
 
 
285
 
    except EnvironmentError, e:
 
257
        brz_log_file = _open_or_create_log_file(_brz_log_filename)
 
258
        brz_log_file.write(b'\n')
 
259
        if brz_log_file.tell() <= 2:
 
260
            brz_log_file.write(
 
261
                b"this is a debug log for diagnosing/reporting problems in brz\n")
 
262
            brz_log_file.write(
 
263
                b"you can delete or truncate this file, or include sections in\n")
 
264
            brz_log_file.write(
 
265
                b"bug reports to https://bugs.launchpad.net/brz/+filebug\n\n")
 
266
 
 
267
        return brz_log_file
 
268
 
 
269
    except EnvironmentError as e:
286
270
        # If we are failing to open the log, then most likely logging has not
287
271
        # been set up yet. So we just write to stderr rather than using
288
272
        # 'warning()'. If we using warning(), users get the unhelpful 'no
289
 
        # handlers registered for "bzr"' when something goes wrong on the
 
273
        # handlers registered for "brz"' when something goes wrong on the
290
274
        # server. (bug #503886)
291
275
        sys.stderr.write("failed to open trace file: %s\n" % (e,))
292
276
    # TODO: What should happen if we fail to open the trace file?  Maybe the
296
280
 
297
281
 
298
282
def enable_default_logging():
299
 
    """Configure default logging: messages to stderr and debug to .bzr.log
 
283
    """Configure default logging: messages to stderr and debug to .brz.log
300
284
 
301
285
    This should only be called once per process.
302
286
 
303
 
    Non-command-line programs embedding bzrlib do not need to call this.  They
 
287
    Non-command-line programs embedding breezy do not need to call this.  They
304
288
    can instead either pass a file to _push_log_file, or act directly on
305
 
    logging.getLogger("bzr").
 
289
    logging.getLogger("brz").
306
290
 
307
291
    Output can be redirected away by calling _push_log_file.
 
292
 
 
293
    :return: A memento from push_log_file for restoring the log state.
308
294
    """
309
 
    # Do this before we open the log file, so we prevent
310
 
    # get_terminal_encoding() from mutter()ing multiple times
311
 
    term_encoding = osutils.get_terminal_encoding()
312
 
    start_time = osutils.format_local_date(_bzr_log_start_time,
 
295
    start_time = osutils.format_local_date(_brz_log_start_time,
313
296
                                           timezone='local')
314
 
    # create encoded wrapper around stderr
315
 
    bzr_log_file = _open_bzr_log()
316
 
    if bzr_log_file is not None:
317
 
        bzr_log_file.write(start_time.encode('utf-8') + '\n')
318
 
    push_log_file(bzr_log_file,
 
297
    brz_log_file = _open_brz_log()
 
298
    if brz_log_file is not None:
 
299
        brz_log_file.write(start_time.encode('utf-8') + b'\n')
 
300
    memento = push_log_file(
 
301
        brz_log_file,
319
302
        r'[%(process)5d] %(asctime)s.%(msecs)03d %(levelname)s: %(message)s',
320
303
        r'%Y-%m-%d %H:%M:%S')
321
 
    # after hooking output into bzr_log, we also need to attach a stderr
 
304
    # after hooking output into brz_log, we also need to attach a stderr
322
305
    # handler, writing only at level info and with encoding
323
 
    writer_factory = codecs.getwriter(term_encoding)
324
 
    encoded_stderr = writer_factory(sys.stderr, errors='replace')
325
 
    stderr_handler = logging.StreamHandler(encoded_stderr)
326
 
    stderr_handler.setLevel(logging.INFO)
327
 
    logging.getLogger('bzr').addHandler(stderr_handler)
 
306
    if sys.version_info[0] == 2:
 
307
        stderr_handler = EncodedStreamHandler(
 
308
            sys.stderr, osutils.get_terminal_encoding(), 'replace',
 
309
            level=logging.INFO)
 
310
    else:
 
311
        stderr_handler = logging.StreamHandler(stream=sys.stderr)
 
312
    logging.getLogger('brz').addHandler(stderr_handler)
 
313
    return memento
328
314
 
329
315
 
330
316
def push_log_file(to_file, log_format=None, date_format=None):
333
319
    :param to_file: A file-like object to which messages will be sent.
334
320
 
335
321
    :returns: A memento that should be passed to _pop_log_file to restore the
336
 
    previously active logging.
 
322
        previously active logging.
337
323
    """
338
324
    global _trace_file
339
325
    # make a new handler
340
 
    new_handler = logging.StreamHandler(to_file)
341
 
    new_handler.setLevel(logging.DEBUG)
 
326
    new_handler = EncodedStreamHandler(to_file, "utf-8", level=logging.DEBUG)
342
327
    if log_format is None:
343
328
        log_format = '%(levelname)8s  %(message)s'
344
329
    new_handler.setFormatter(logging.Formatter(log_format, date_format))
345
330
    # save and remove any existing log handlers
346
 
    bzr_logger = logging.getLogger('bzr')
347
 
    old_handlers = bzr_logger.handlers[:]
348
 
    del bzr_logger.handlers[:]
 
331
    brz_logger = logging.getLogger('brz')
 
332
    old_handlers = brz_logger.handlers[:]
 
333
    del brz_logger.handlers[:]
349
334
    # set that as the default logger
350
 
    bzr_logger.addHandler(new_handler)
351
 
    bzr_logger.setLevel(logging.DEBUG)
 
335
    brz_logger.addHandler(new_handler)
 
336
    brz_logger.setLevel(logging.DEBUG)
352
337
    # TODO: check if any changes are needed to the root logger
353
338
    #
354
 
    # TODO: also probably need to save and restore the level on bzr_logger.
 
339
    # TODO: also probably need to save and restore the level on brz_logger.
355
340
    # but maybe we can avoid setting the logger level altogether, and just set
356
341
    # the level on the handler?
357
342
    #
359
344
    old_trace_file = _trace_file
360
345
    # send traces to the new one
361
346
    _trace_file = to_file
362
 
    result = new_handler, _trace_file
363
347
    return ('log_memento', old_handlers, new_handler, old_trace_file, to_file)
364
348
 
365
349
 
366
 
def pop_log_file((magic, old_handlers, new_handler, old_trace_file, new_trace_file)):
 
350
def pop_log_file(entry):
367
351
    """Undo changes to logging/tracing done by _push_log_file.
368
352
 
369
 
    This flushes, but does not close the trace file.
 
353
    This flushes, but does not close the trace file (so that anything that was
 
354
    in it is output.
370
355
 
371
356
    Takes the memento returned from _push_log_file."""
 
357
    (magic, old_handlers, new_handler, old_trace_file, new_trace_file) = entry
372
358
    global _trace_file
373
359
    _trace_file = old_trace_file
374
 
    bzr_logger = logging.getLogger('bzr')
375
 
    bzr_logger.removeHandler(new_handler)
376
 
    # must be closed, otherwise logging will try to close it atexit, and the
 
360
    brz_logger = logging.getLogger('brz')
 
361
    brz_logger.removeHandler(new_handler)
 
362
    # must be closed, otherwise logging will try to close it at exit, and the
377
363
    # file will likely already be closed underneath.
378
364
    new_handler.close()
379
 
    bzr_logger.handlers = old_handlers
380
 
    new_trace_file.flush()
 
365
    brz_logger.handlers = old_handlers
 
366
    if new_trace_file is not None:
 
367
        new_trace_file.flush()
381
368
 
382
369
 
383
370
def log_exception_quietly():
419
406
def _update_logging_level(quiet=True):
420
407
    """Hide INFO messages if quiet."""
421
408
    if quiet:
422
 
        _bzr_logger.setLevel(logging.WARNING)
 
409
        _brz_logger.setLevel(logging.WARNING)
423
410
    else:
424
 
        _bzr_logger.setLevel(logging.INFO)
 
411
        _brz_logger.setLevel(logging.INFO)
425
412
 
426
413
 
427
414
def is_quiet():
437
424
def debug_memory(message='', short=True):
438
425
    """Write out a memory dump."""
439
426
    if sys.platform == 'win32':
440
 
        from bzrlib import win32utils
 
427
        from breezy import win32utils
441
428
        win32utils.debug_memory_win32api(message=message, short=short)
442
429
    else:
443
430
        _debug_memory_proc(message=message, short=short)
445
432
 
446
433
_short_fields = ('VmPeak', 'VmSize', 'VmRSS')
447
434
 
 
435
 
448
436
def _debug_memory_proc(message='', short=True):
449
437
    try:
450
 
        status_file = file('/proc/%s/status' % os.getpid(), 'rb')
 
438
        status_file = open('/proc/%s/status' % os.getpid(), 'rb')
451
439
    except IOError:
452
440
        return
453
441
    try:
466
454
                    break
467
455
 
468
456
 
 
457
def _dump_memory_usage(err_file):
 
458
    try:
 
459
        try:
 
460
            fd, name = tempfile.mkstemp(prefix="brz_memdump", suffix=".json")
 
461
            dump_file = os.fdopen(fd, 'w')
 
462
            from meliae import scanner
 
463
            scanner.dump_gc_objects(dump_file)
 
464
            err_file.write("Memory dumped to %s\n" % name)
 
465
        except ImportError:
 
466
            err_file.write("Dumping memory requires meliae module.\n")
 
467
            log_exception_quietly()
 
468
        except BaseException:
 
469
            err_file.write("Exception while dumping memory.\n")
 
470
            log_exception_quietly()
 
471
    finally:
 
472
        if dump_file is not None:
 
473
            dump_file.close()
 
474
        elif fd is not None:
 
475
            os.close(fd)
 
476
 
 
477
 
 
478
def _qualified_exception_name(eclass, unqualified_breezy_errors=False):
 
479
    """Give name of error class including module for non-builtin exceptions
 
480
 
 
481
    If `unqualified_breezy_errors` is True, errors specific to breezy will
 
482
    also omit the module prefix.
 
483
    """
 
484
    class_name = eclass.__name__
 
485
    module_name = eclass.__module__
 
486
    if module_name in ("builtins", "exceptions", "__main__") or (
 
487
            unqualified_breezy_errors and module_name == "breezy.errors"):
 
488
        return class_name
 
489
    return "%s.%s" % (module_name, class_name)
 
490
 
 
491
 
469
492
def report_exception(exc_info, err_file):
470
 
    """Report an exception to err_file (typically stderr) and to .bzr.log.
 
493
    """Report an exception to err_file (typically stderr) and to .brz.log.
471
494
 
472
495
    This will show either a full traceback or a short message as appropriate.
473
496
 
474
497
    :return: The appropriate exit code for this error.
475
498
    """
476
 
    # Log the full traceback to ~/.bzr.log
 
499
    # Log the full traceback to ~/.brz.log
477
500
    log_exception_quietly()
478
501
    if 'error' in debug.debug_flags:
479
502
        print_exception(exc_info, err_file)
480
503
        return errors.EXIT_ERROR
481
504
    exc_type, exc_object, exc_tb = exc_info
482
 
    if (isinstance(exc_object, IOError)
483
 
        and getattr(exc_object, 'errno', None) == errno.EPIPE):
484
 
        err_file.write("bzr: broken pipe\n")
485
 
        return errors.EXIT_ERROR
486
 
    elif isinstance(exc_object, KeyboardInterrupt):
487
 
        err_file.write("bzr: interrupted\n")
 
505
    if isinstance(exc_object, KeyboardInterrupt):
 
506
        err_file.write("brz: interrupted\n")
488
507
        return errors.EXIT_ERROR
489
508
    elif isinstance(exc_object, MemoryError):
490
 
        err_file.write("bzr: out of memory\n")
 
509
        err_file.write("brz: out of memory\n")
 
510
        if 'mem_dump' in debug.debug_flags:
 
511
            _dump_memory_usage(err_file)
 
512
        else:
 
513
            err_file.write("Use -Dmem_dump to dump memory to a file.\n")
491
514
        return errors.EXIT_ERROR
492
515
    elif isinstance(exc_object, ImportError) \
493
 
        and str(exc_object).startswith("No module named "):
494
 
        report_user_error(exc_info, err_file,
 
516
            and str(exc_object).startswith("No module named "):
 
517
        report_user_error(
 
518
            exc_info, err_file,
495
519
            'You may need to install this Python library separately.')
496
520
        return errors.EXIT_ERROR
497
521
    elif not getattr(exc_object, 'internal_error', True):
498
522
        report_user_error(exc_info, err_file)
499
523
        return errors.EXIT_ERROR
500
 
    elif isinstance(exc_object, (OSError, IOError)):
 
524
    elif osutils.is_environment_error(exc_object):
 
525
        if getattr(exc_object, 'errno', None) == errno.EPIPE:
 
526
            err_file.write("brz: broken pipe\n")
 
527
            return errors.EXIT_ERROR
501
528
        # Might be nice to catch all of these and show them as something more
502
529
        # specific, but there are too many cases at the moment.
503
530
        report_user_error(exc_info, err_file)
509
536
 
510
537
def print_exception(exc_info, err_file):
511
538
    exc_type, exc_object, exc_tb = exc_info
512
 
    err_file.write("bzr: ERROR: %s.%s: %s\n" % (
513
 
        exc_type.__module__, exc_type.__name__, exc_object))
 
539
    err_file.write("brz: ERROR: %s: %s\n" % (
 
540
        _qualified_exception_name(exc_type), exc_object))
514
541
    err_file.write('\n')
515
542
    traceback.print_exception(exc_type, exc_object, exc_tb, file=err_file)
516
543
 
525
552
    :param advice: Extra advice to the user to be printed following the
526
553
        exception.
527
554
    """
528
 
    err_file.write("bzr: ERROR: %s\n" % (exc_info[1],))
 
555
    err_file.write(("brz: ERROR: %s\n" % (str(exc_info[1]),)))
529
556
    if advice:
530
 
        err_file.write("%s\n" % (advice,))
 
557
        err_file.write(("%s\n" % advice))
531
558
 
532
559
 
533
560
def report_bug(exc_info, err_file):
534
 
    """Report an exception that probably indicates a bug in bzr"""
535
 
    from bzrlib.crash import report_bug
 
561
    """Report an exception that probably indicates a bug in brz"""
 
562
    from breezy.crash import report_bug
536
563
    report_bug(exc_info, err_file)
537
564
 
538
565
 
539
566
def _flush_stdout_stderr():
540
 
    # installed into an atexit hook by bzrlib.initialize()
 
567
    # called from the breezy library finalizer returned by breezy.initialize()
541
568
    try:
542
569
        sys.stdout.flush()
543
570
        sys.stderr.flush()
544
 
    except IOError, e:
 
571
    except ValueError:
 
572
        # On Windows, I get ValueError calling stdout.flush() on a closed
 
573
        # handle
 
574
        pass
 
575
    except IOError as e:
545
576
        import errno
546
577
        if e.errno in [errno.EINVAL, errno.EPIPE]:
547
578
            pass
550
581
 
551
582
 
552
583
def _flush_trace():
553
 
    # run from atexit hook
 
584
    # called from the breezy library finalizer returned by breezy.initialize()
554
585
    global _trace_file
555
586
    if _trace_file:
556
587
        _trace_file.flush()
 
588
 
 
589
 
 
590
class EncodedStreamHandler(logging.Handler):
 
591
    """Robustly write logging events to a stream using the specified encoding
 
592
 
 
593
    Messages are expected to be formatted to unicode, but UTF-8 byte strings
 
594
    are also accepted. An error during formatting or a str message in another
 
595
    encoding will be quitely noted as an error in the Bazaar log file.
 
596
 
 
597
    The stream is not closed so sys.stdout or sys.stderr may be passed.
 
598
    """
 
599
 
 
600
    def __init__(self, stream, encoding=None, errors='strict', level=0):
 
601
        logging.Handler.__init__(self, level)
 
602
        self.stream = stream
 
603
        if encoding is None:
 
604
            encoding = getattr(stream, "encoding", "ascii")
 
605
        self.encoding = encoding
 
606
        self.errors = errors
 
607
 
 
608
    def flush(self):
 
609
        flush = getattr(self.stream, "flush", None)
 
610
        if flush is not None:
 
611
            flush()
 
612
 
 
613
    def emit(self, record):
 
614
        try:
 
615
            if not isinstance(record.msg, text_type):
 
616
                msg = record.msg.decode("utf-8")
 
617
                if PY3:
 
618
                    record.msg = msg
 
619
            line = self.format(record)
 
620
            if not isinstance(line, text_type):
 
621
                line = line.decode("utf-8")
 
622
            self.stream.write(line.encode(self.encoding, self.errors) + b"\n")
 
623
        except Exception:
 
624
            log_exception_quietly()
 
625
            # Try saving the details that would have been logged in some form
 
626
            msg = args = "<Unformattable>"
 
627
            try:
 
628
                msg = repr(record.msg)
 
629
                args = repr(record.args)
 
630
            except Exception:
 
631
                pass
 
632
            # Using mutter() bypasses the logging module and writes directly
 
633
            # to the file so there's no danger of getting into a loop here.
 
634
            mutter("Logging record unformattable: %s %% %s", msg, args)
 
635
 
 
636
 
 
637
class Config(object):
 
638
    """Configuration of message tracing in breezy.
 
639
 
 
640
    This implements the context manager protocol and should manage any global
 
641
    variables still used. The default config used is DefaultConfig, but
 
642
    embedded uses of breezy may wish to use a custom manager.
 
643
    """
 
644
 
 
645
    def __enter__(self):
 
646
        return self  # This is bound to the 'as' clause in a with statement.
 
647
 
 
648
    def __exit__(self, exc_type, exc_val, exc_tb):
 
649
        return False  # propogate exceptions.
 
650
 
 
651
 
 
652
class DefaultConfig(Config):
 
653
    """A default configuration for tracing of messages in breezy.
 
654
 
 
655
    This implements the context manager protocol.
 
656
    """
 
657
 
 
658
    def __enter__(self):
 
659
        self._original_filename = _brz_log_filename
 
660
        self._original_state = enable_default_logging()
 
661
        return self  # This is bound to the 'as' clause in a with statement.
 
662
 
 
663
    def __exit__(self, exc_type, exc_val, exc_tb):
 
664
        pop_log_file(self._original_state)
 
665
        global _brz_log_filename
 
666
        _brz_log_filename = self._original_filename
 
667
        return False  # propogate exceptions.