/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 bzrlib/trace.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

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