~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/trace.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-09-03 08:32:49 UTC
  • mfrom: (1739.2.13 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080903083249-e76ygekseh1peidm
Fix typo in ReadDirFeature.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
2
16
 
3
17
"""Messages and logging for bazaar-ng.
4
18
 
27
41
 
28
42
Exceptions are reported in a brief form to stderr so as not to look scary.
29
43
BzrErrors are required to be able to format themselves into a properly
30
 
explanatory message.  This is not true for builtin excexceptions such as
 
44
explanatory message.  This is not true for builtin exceptions such as
31
45
KeyError, which typically just str to "0".  They're printed in a different
32
46
form.
33
47
"""
34
48
 
35
 
# TODO: in debug mode, stderr should get full tracebacks and also
36
 
# debug messages.  (Is this really needed?)
37
 
 
38
49
# FIXME: Unfortunately it turns out that python's logging module
39
50
# is quite expensive, even when the message is not printed by any handlers.
40
51
# We should perhaps change back to just simply doing it here.
41
 
 
42
 
 
 
52
#
 
53
# On the other hand, as of 1.2 we generally only call the mutter() statement
 
54
# if (according to debug_flags) we actually intend to write it.  So the
 
55
# increased cost of logging.py is not so bad, and we could standardize on
 
56
# that.
 
57
 
 
58
import codecs
 
59
import logging
 
60
import os
43
61
import sys
44
 
import os
45
 
import logging
 
62
import re
 
63
import time
 
64
 
 
65
from bzrlib.lazy_import import lazy_import
 
66
lazy_import(globals(), """
 
67
from cStringIO import StringIO
 
68
import errno
 
69
import locale
 
70
import traceback
 
71
""")
46
72
 
47
73
import bzrlib
48
 
from bzrlib.errors import BzrError, BzrNewError
49
 
 
50
 
 
51
 
_file_handler = None
52
 
_stderr_handler = None
53
 
_stderr_quiet = False
 
74
 
 
75
lazy_import(globals(), """
 
76
from bzrlib import (
 
77
    debug,
 
78
    errors,
 
79
    osutils,
 
80
    plugin,
 
81
    symbol_versioning,
 
82
    )
 
83
""")
 
84
 
 
85
 
 
86
# global verbosity for bzrlib; controls the log level for stderr; 0=normal; <0
 
87
# is quiet; >0 is verbose.
 
88
_verbosity_level = 0
 
89
 
 
90
# File-like object where mutter/debug output is currently sent.  Can be
 
91
# changed by _push_log_file etc.  This is directly manipulated by some
 
92
# external code; maybe there should be functions to do that more precisely
 
93
# than push/pop_log_file.
54
94
_trace_file = None
55
 
_bzr_log_file = None
56
 
 
57
 
 
58
 
class QuietFormatter(logging.Formatter):
59
 
    """Formatter that supresses the details of errors.
60
 
 
61
 
    This is used by default on stderr so as not to scare the user.
62
 
    """
63
 
    # At first I tried overriding formatException to suppress the
64
 
    # exception details, but that has global effect: no loggers
65
 
    # can get the exception details is we suppress them here.
66
 
 
67
 
    def format(self, record):
68
 
        if record.levelno >= logging.WARNING:
69
 
            s = 'bzr: ' + record.levelname + ': '
70
 
        else:
71
 
            s = ''
72
 
        s += record.getMessage()
73
 
        if record.exc_info:
74
 
            s += '\n' + format_exception_short(record.exc_info)
75
 
        return s
76
 
        
 
95
 
 
96
# Absolute path for ~/.bzr.log.  Not changed even if the log/trace output is
 
97
# redirected elsewhere.  Used to show the location in --version.
 
98
_bzr_log_filename = None
 
99
 
 
100
# The time the first message was written to the trace file, so that we can
 
101
# show relative times since startup.
 
102
_bzr_log_start_time = bzrlib._start_time
 
103
 
 
104
 
 
105
# held in a global for quick reference
 
106
_bzr_logger = logging.getLogger('bzr')
 
107
 
 
108
 
 
109
def note(*args, **kwargs):
 
110
    # FIXME note always emits utf-8, regardless of the terminal encoding
 
111
    #
 
112
    # FIXME: clearing the ui and then going through the abstract logging
 
113
    # framework is whack; we should probably have a logging Handler that
 
114
    # deals with terminal output if needed.
 
115
    import bzrlib.ui
 
116
    bzrlib.ui.ui_factory.clear_term()
 
117
    _bzr_logger.info(*args, **kwargs)
 
118
 
 
119
 
 
120
def warning(*args, **kwargs):
 
121
    import bzrlib.ui
 
122
    bzrlib.ui.ui_factory.clear_term()
 
123
    _bzr_logger.warning(*args, **kwargs)
 
124
 
 
125
 
77
126
# configure convenient aliases for output routines
78
 
 
79
 
_bzr_logger = logging.getLogger('bzr')
80
 
 
81
 
info = note = _bzr_logger.info
82
 
warning =   _bzr_logger.warning
 
127
#
 
128
# TODO: deprecate them, have one name for each.
 
129
info = note
83
130
log_error = _bzr_logger.error
84
131
error =     _bzr_logger.error
85
132
 
87
134
def mutter(fmt, *args):
88
135
    if _trace_file is None:
89
136
        return
90
 
    if hasattr(_trace_file, 'closed') and _trace_file.closed:
 
137
    if (getattr(_trace_file, 'closed', None) is not None) and _trace_file.closed:
91
138
        return
 
139
 
 
140
    if isinstance(fmt, unicode):
 
141
        fmt = fmt.encode('utf8')
 
142
 
92
143
    if len(args) > 0:
93
 
        out = fmt % args
 
144
        # It seems that if we do ascii % (unicode, ascii) we can
 
145
        # get a unicode cannot encode ascii error, so make sure that "fmt"
 
146
        # is a unicode string
 
147
        real_args = []
 
148
        for arg in args:
 
149
            if isinstance(arg, unicode):
 
150
                arg = arg.encode('utf8')
 
151
            real_args.append(arg)
 
152
        out = fmt % tuple(real_args)
94
153
    else:
95
154
        out = fmt
96
 
    out += '\n'
 
155
    timestamp = '%0.3f  ' % (time.time() - _bzr_log_start_time,)
 
156
    out = timestamp + out + '\n'
97
157
    _trace_file.write(out)
98
 
debug = mutter
 
158
    # no need to flush here, the trace file is now linebuffered when it's
 
159
    # opened.
 
160
 
 
161
 
 
162
def mutter_callsite(stacklevel, fmt, *args):
 
163
    """Perform a mutter of fmt and args, logging the call trace.
 
164
 
 
165
    :param stacklevel: The number of frames to show. None will show all
 
166
        frames.
 
167
    :param fmt: The format string to pass to mutter.
 
168
    :param args: A list of substitution variables.
 
169
    """
 
170
    outf = StringIO()
 
171
    if stacklevel is None:
 
172
        limit = None
 
173
    else:
 
174
        limit = stacklevel + 1
 
175
    traceback.print_stack(limit=limit, file=outf)
 
176
    formatted_lines = outf.getvalue().splitlines()
 
177
    formatted_stack = '\n'.join(formatted_lines[:-2])
 
178
    mutter(fmt + "\nCalled from:\n%s", *(args + (formatted_stack,)))
99
179
 
100
180
 
101
181
def _rollover_trace_maybe(trace_fname):
105
185
        if size <= 4 << 20:
106
186
            return
107
187
        old_fname = trace_fname + '.old'
108
 
        from osutils import rename
109
 
        rename(trace_fname, old_fname)
 
188
        osutils.rename(trace_fname, old_fname)
110
189
    except OSError:
111
190
        return
112
191
 
113
192
 
114
 
def open_tracefile(tracefilename='~/.bzr.log'):
115
 
    # Messages are always written to here, so that we have some
116
 
    # information if something goes wrong.  In a future version this
117
 
    # file will be removed on successful completion.
118
 
    global _file_handler, _bzr_log_file
119
 
    import stat, codecs
120
 
 
121
 
    trace_fname = os.path.join(os.path.expanduser(tracefilename))
122
 
    _rollover_trace_maybe(trace_fname)
 
193
def _get_bzr_log_filename():
 
194
    bzr_log = os.environ.get('BZR_LOG')
 
195
    if bzr_log:
 
196
        return bzr_log
 
197
    home = os.environ.get('BZR_HOME')
 
198
    if home is None:
 
199
        if sys.platform == 'win32':
 
200
            from bzrlib import win32utils
 
201
            home = win32utils.get_home_location()
 
202
        else:
 
203
            home = os.path.expanduser('~')
 
204
    return os.path.join(home, '.bzr.log')
 
205
 
 
206
 
 
207
def _open_bzr_log():
 
208
    """Open the .bzr.log trace file.  
 
209
 
 
210
    If the log is more than a particular length, the old file is renamed to
 
211
    .bzr.log.old and a new file is started.  Otherwise, we append to the
 
212
    existing file.
 
213
 
 
214
    This sets the global _bzr_log_filename.
 
215
    """
 
216
    global _bzr_log_filename
 
217
    _bzr_log_filename = _get_bzr_log_filename()
 
218
    _rollover_trace_maybe(_bzr_log_filename)
123
219
    try:
124
 
        LINE_BUFFERED = 1
125
 
        tf = codecs.open(trace_fname, 'at', 'utf8', buffering=LINE_BUFFERED)
126
 
        _bzr_log_file = tf
127
 
        if tf.tell() == 0:
128
 
            tf.write("\nthis is a debug log for diagnosing/reporting problems in bzr\n")
129
 
            tf.write("you can delete or truncate this file, or include sections in\n")
130
 
            tf.write("bug reports to bazaar-ng@lists.canonical.com\n\n")
131
 
        _file_handler = logging.StreamHandler(tf)
132
 
        fmt = r'[%(process)5d] %(asctime)s.%(msecs)03d %(levelname)s: %(message)s'
133
 
        datefmt = r'%a %H:%M:%S'
134
 
        _file_handler.setFormatter(logging.Formatter(fmt, datefmt))
135
 
        _file_handler.setLevel(logging.DEBUG)
136
 
        logging.getLogger('').addHandler(_file_handler)
 
220
        bzr_log_file = open(_bzr_log_filename, 'at', 1) # line buffered
 
221
        # bzr_log_file.tell() on windows always return 0 until some writing done
 
222
        bzr_log_file.write('\n')
 
223
        if bzr_log_file.tell() <= 2:
 
224
            bzr_log_file.write("this is a debug log for diagnosing/reporting problems in bzr\n")
 
225
            bzr_log_file.write("you can delete or truncate this file, or include sections in\n")
 
226
            bzr_log_file.write("bug reports to https://bugs.launchpad.net/bzr/+filebug\n\n")
 
227
        return bzr_log_file
137
228
    except IOError, e:
138
229
        warning("failed to open trace file: %s" % (e))
139
 
 
140
 
 
141
 
def log_startup(argv):
142
 
    debug('\n\nbzr %s invoked on python %s (%s)',
143
 
          bzrlib.__version__,
144
 
          '.'.join(map(str, sys.version_info)),
145
 
          sys.platform)
146
 
    debug('  arguments: %r', argv)
147
 
    debug('  working dir: %r', os.getcwdu())
148
 
 
149
 
 
150
 
def log_exception(msg=None):
151
 
    """Log the last exception to stderr and the trace file.
152
 
 
153
 
    The exception string representation is used as the error
154
 
    summary, unless msg is given.
155
 
    """
156
 
    if msg:
157
 
        error(msg)
158
 
    else:
159
 
        exc_str = format_exception_short(sys.exc_info())
160
 
        error(exc_str)
161
 
    log_exception_quietly()
 
230
    # TODO: What should happen if we fail to open the trace file?  Maybe the
 
231
    # objects should be pointed at /dev/null or the equivalent?  Currently
 
232
    # returns None which will cause failures later.
 
233
 
 
234
 
 
235
def enable_default_logging():
 
236
    """Configure default logging: messages to stderr and debug to .bzr.log
 
237
    
 
238
    This should only be called once per process.
 
239
 
 
240
    Non-command-line programs embedding bzrlib do not need to call this.  They
 
241
    can instead either pass a file to _push_log_file, or act directly on
 
242
    logging.getLogger("bzr").
 
243
    
 
244
    Output can be redirected away by calling _push_log_file.
 
245
    """
 
246
    # create encoded wrapper around stderr
 
247
    bzr_log_file = _open_bzr_log()
 
248
    push_log_file(bzr_log_file,
 
249
        r'[%(process)5d] %(asctime)s.%(msecs)03d %(levelname)s: %(message)s',
 
250
        r'%Y-%m-%d %H:%M:%S')
 
251
    # after hooking output into bzr_log, we also need to attach a stderr
 
252
    # handler, writing only at level info and with encoding
 
253
    writer_factory = codecs.getwriter(osutils.get_terminal_encoding())
 
254
    encoded_stderr = writer_factory(sys.stderr, errors='replace')
 
255
    stderr_handler = logging.StreamHandler(encoded_stderr)
 
256
    stderr_handler.setLevel(logging.INFO)
 
257
    logging.getLogger('bzr').addHandler(stderr_handler)
 
258
 
 
259
 
 
260
def push_log_file(to_file, log_format=None, date_format=None):
 
261
    """Intercept log and trace messages and send them to a file.
 
262
 
 
263
    :param to_file: A file-like object to which messages will be sent.
 
264
 
 
265
    :returns: A memento that should be passed to _pop_log_file to restore the 
 
266
    previously active logging.
 
267
    """
 
268
    global _trace_file
 
269
    # make a new handler
 
270
    new_handler = logging.StreamHandler(to_file)
 
271
    new_handler.setLevel(logging.DEBUG)
 
272
    if log_format is None:
 
273
        log_format = '%(levelname)8s  %(message)s'
 
274
    new_handler.setFormatter(logging.Formatter(log_format, date_format))
 
275
    # save and remove any existing log handlers
 
276
    bzr_logger = logging.getLogger('bzr')
 
277
    old_handlers = bzr_logger.handlers[:]
 
278
    del bzr_logger.handlers[:]
 
279
    # set that as the default logger
 
280
    bzr_logger.addHandler(new_handler)
 
281
    bzr_logger.setLevel(logging.DEBUG)
 
282
    # TODO: check if any changes are needed to the root logger
 
283
    #
 
284
    # TODO: also probably need to save and restore the level on bzr_logger.
 
285
    # but maybe we can avoid setting the logger level altogether, and just set
 
286
    # the level on the handler?
 
287
    #
 
288
    # save the old trace file
 
289
    old_trace_file = _trace_file
 
290
    # send traces to the new one
 
291
    _trace_file = to_file
 
292
    result = new_handler, _trace_file
 
293
    return ('log_memento', old_handlers, new_handler, old_trace_file, to_file)
 
294
 
 
295
 
 
296
def pop_log_file((magic, old_handlers, new_handler, old_trace_file, new_trace_file)):
 
297
    """Undo changes to logging/tracing done by _push_log_file.
 
298
 
 
299
    This flushes, but does not close the trace file.
 
300
    
 
301
    Takes the memento returned from _push_log_file."""
 
302
    global _trace_file
 
303
    _trace_file = old_trace_file
 
304
    bzr_logger = logging.getLogger('bzr')
 
305
    bzr_logger.removeHandler(new_handler)
 
306
    # must be closed, otherwise logging will try to close it atexit, and the
 
307
    # file will likely already be closed underneath.
 
308
    new_handler.close()
 
309
    bzr_logger.handlers = old_handlers
 
310
    new_trace_file.flush()
 
311
 
 
312
 
 
313
@symbol_versioning.deprecated_function(symbol_versioning.one_two)
 
314
def enable_test_log(to_file):
 
315
    """Redirect logging to a temporary file for a test
 
316
    
 
317
    :returns: an opaque reference that should be passed to disable_test_log
 
318
    after the test completes.
 
319
    """
 
320
    return push_log_file(to_file)
 
321
 
 
322
 
 
323
@symbol_versioning.deprecated_function(symbol_versioning.one_two)
 
324
def disable_test_log(memento):
 
325
    return pop_log_file(memento)
162
326
 
163
327
 
164
328
def log_exception_quietly():
168
332
    interesting to developers but not to users.  For example, 
169
333
    errors loading plugins.
170
334
    """
171
 
    import traceback
172
 
    debug(traceback.format_exc())
173
 
 
174
 
 
175
 
def enable_default_logging():
176
 
    """Configure default logging to stderr and .bzr.log"""
177
 
    # FIXME: if this is run twice, things get confused
178
 
    global _stderr_handler, _file_handler, _trace_file, _bzr_log_file
179
 
    _stderr_handler = logging.StreamHandler()
180
 
    _stderr_handler.setFormatter(QuietFormatter())
181
 
    logging.getLogger('').addHandler(_stderr_handler)
182
 
    _stderr_handler.setLevel(logging.INFO)
183
 
    if not _file_handler:
184
 
        open_tracefile()
185
 
    _trace_file = _bzr_log_file
186
 
    if _file_handler:
187
 
        _file_handler.setLevel(logging.DEBUG)
188
 
    _bzr_logger.setLevel(logging.DEBUG) 
189
 
 
 
335
    mutter(traceback.format_exc())
 
336
 
 
337
 
 
338
def set_verbosity_level(level):
 
339
    """Set the verbosity level.
 
340
 
 
341
    :param level: -ve for quiet, 0 for normal, +ve for verbose
 
342
    """
 
343
    global _verbosity_level
 
344
    _verbosity_level = level
 
345
    _update_logging_level(level < 0)
 
346
 
 
347
 
 
348
def get_verbosity_level():
 
349
    """Get the verbosity level.
 
350
 
 
351
    See set_verbosity_level() for values.
 
352
    """
 
353
    return _verbosity_level
190
354
 
191
355
 
192
356
def be_quiet(quiet=True):
193
 
    global _stderr_handler, _stderr_quiet
194
 
    
195
 
    _stderr_quiet = quiet
196
 
    if quiet:
197
 
        _stderr_handler.setLevel(logging.WARNING)
198
 
    else:
199
 
        _stderr_handler.setLevel(logging.INFO)
 
357
    # Perhaps this could be deprecated now ...
 
358
    if quiet:
 
359
        set_verbosity_level(-1)
 
360
    else:
 
361
        set_verbosity_level(0)
 
362
 
 
363
 
 
364
def _update_logging_level(quiet=True):
 
365
    """Hide INFO messages if quiet."""
 
366
    if quiet:
 
367
        _bzr_logger.setLevel(logging.WARNING)
 
368
    else:
 
369
        _bzr_logger.setLevel(logging.INFO)
200
370
 
201
371
 
202
372
def is_quiet():
203
 
    global _stderr_quiet
204
 
    return _stderr_quiet
205
 
 
206
 
 
 
373
    """Is the verbosity level negative?"""
 
374
    return _verbosity_level < 0
 
375
 
 
376
 
 
377
def is_verbose():
 
378
    """Is the verbosity level positive?"""
 
379
    return _verbosity_level > 0
 
380
 
 
381
 
 
382
@symbol_versioning.deprecated_function(symbol_versioning.one_two)
207
383
def disable_default_logging():
208
384
    """Turn off default log handlers.
209
385
 
210
 
    This is intended to be used by the test framework, which doesn't
211
 
    want leakage from the code-under-test into the main logs.
212
 
    """
213
 
 
214
 
    l = logging.getLogger('')
215
 
    l.removeHandler(_stderr_handler)
216
 
    if _file_handler:
217
 
        l.removeHandler(_file_handler)
218
 
    _trace_file = None
219
 
 
220
 
 
221
 
def enable_test_log(to_file):
222
 
    """Redirect logging to a temporary file for a test"""
223
 
    disable_default_logging()
224
 
    global _test_log_hdlr, _trace_file
225
 
    hdlr = logging.StreamHandler(to_file)
226
 
    hdlr.setLevel(logging.DEBUG)
227
 
    hdlr.setFormatter(logging.Formatter('%(levelname)8s  %(message)s'))
228
 
    _bzr_logger.addHandler(hdlr)
229
 
    _bzr_logger.setLevel(logging.DEBUG)
230
 
    _test_log_hdlr = hdlr
231
 
    _trace_file = to_file
232
 
 
233
 
 
234
 
def disable_test_log():
235
 
    _bzr_logger.removeHandler(_test_log_hdlr)
236
 
    _trace_file = None
237
 
    enable_default_logging()
238
 
 
239
 
 
240
 
def format_exception_short(exc_info):
241
 
    """Make a short string form of an exception.
242
 
 
243
 
    This is used for display to stderr.  It specially handles exception
244
 
    classes without useful string methods.
245
 
 
246
 
    The result has no trailing newline.
247
 
 
248
 
    exc_info - typically an exception from sys.exc_info()
249
 
    """
250
 
    exc_type, exc_object, exc_tb = exc_info
251
 
    try:
252
 
        if exc_type is None:
253
 
            return '(no exception)'
254
 
        if isinstance(exc_object, (BzrError, BzrNewError)):
255
 
            return str(exc_object)
256
 
        else:
257
 
            import traceback
258
 
            tb = traceback.extract_tb(exc_tb)
259
 
            msg = '%s: %s' % (exc_type, exc_object)
260
 
            if msg[-1] == '\n':
261
 
                msg = msg[:-1]
262
 
            if tb:
263
 
                msg += '\n  at %s line %d\n  in %s' % (tb[-1][:3])
264
 
            return msg
265
 
    except Exception, formatting_exc:
266
 
        # XXX: is this really better than just letting it run up?
267
 
        return '(error formatting exception of type %s: %s)' \
268
 
                % (exc_type, formatting_exc)
 
386
    Don't call this method, use _push_log_file and _pop_log_file instead.
 
387
    """
 
388
    pass
 
389
 
 
390
 
 
391
def report_exception(exc_info, err_file):
 
392
    """Report an exception to err_file (typically stderr) and to .bzr.log.
 
393
 
 
394
    This will show either a full traceback or a short message as appropriate.
 
395
 
 
396
    :return: The appropriate exit code for this error.
 
397
    """
 
398
    exc_type, exc_object, exc_tb = exc_info
 
399
    # Log the full traceback to ~/.bzr.log
 
400
    log_exception_quietly()
 
401
    if (isinstance(exc_object, IOError)
 
402
        and getattr(exc_object, 'errno', None) == errno.EPIPE):
 
403
        err_file.write("bzr: broken pipe\n")
 
404
        return errors.EXIT_ERROR
 
405
    elif isinstance(exc_object, KeyboardInterrupt):
 
406
        err_file.write("bzr: interrupted\n")
 
407
        return errors.EXIT_ERROR
 
408
    elif isinstance(exc_object, ImportError) \
 
409
        and str(exc_object).startswith("No module named "):
 
410
        report_user_error(exc_info, err_file,
 
411
            'You may need to install this Python library separately.')
 
412
        return errors.EXIT_ERROR
 
413
    elif not getattr(exc_object, 'internal_error', True):
 
414
        report_user_error(exc_info, err_file)
 
415
        return errors.EXIT_ERROR
 
416
    elif isinstance(exc_object, (OSError, IOError)):
 
417
        # Might be nice to catch all of these and show them as something more
 
418
        # specific, but there are too many cases at the moment.
 
419
        report_user_error(exc_info, err_file)
 
420
        return errors.EXIT_ERROR
 
421
    else:
 
422
        report_bug(exc_info, err_file)
 
423
        return errors.EXIT_INTERNAL_ERROR
 
424
 
 
425
 
 
426
def print_exception(exc_info, err_file):
 
427
    exc_type, exc_object, exc_tb = exc_info
 
428
    err_file.write("bzr: ERROR: %s.%s: %s\n" % (
 
429
        exc_type.__module__, exc_type.__name__, exc_object))
 
430
    err_file.write('\n')
 
431
    traceback.print_exception(exc_type, exc_object, exc_tb, file=err_file)
 
432
 
 
433
 
 
434
# TODO: Should these be specially encoding the output?
 
435
def report_user_error(exc_info, err_file, advice=None):
 
436
    """Report to err_file an error that's not an internal error.
 
437
 
 
438
    These don't get a traceback unless -Derror was given.
 
439
 
 
440
    :param exc_info: 3-tuple from sys.exc_info()
 
441
    :param advice: Extra advice to the user to be printed following the
 
442
        exception.
 
443
    """
 
444
    if 'error' in debug.debug_flags:
 
445
        print_exception(exc_info, err_file)
 
446
        return
 
447
    err_file.write("bzr: ERROR: %s\n" % (exc_info[1],))
 
448
    if advice:
 
449
        err_file.write("%s\n" % (advice,))
 
450
 
 
451
 
 
452
def report_bug(exc_info, err_file):
 
453
    """Report an exception that probably indicates a bug in bzr"""
 
454
    print_exception(exc_info, err_file)
 
455
    err_file.write('\n')
 
456
    err_file.write('bzr %s on python %s (%s)\n' % \
 
457
                       (bzrlib.__version__,
 
458
                        bzrlib._format_version_tuple(sys.version_info),
 
459
                        sys.platform))
 
460
    err_file.write('arguments: %r\n' % sys.argv)
 
461
    err_file.write(
 
462
        'encoding: %r, fsenc: %r, lang: %r\n' % (
 
463
            osutils.get_user_encoding(), sys.getfilesystemencoding(),
 
464
            os.environ.get('LANG')))
 
465
    err_file.write("plugins:\n")
 
466
    for name, a_plugin in sorted(plugin.plugins().items()):
 
467
        err_file.write("  %-20s %s [%s]\n" %
 
468
            (name, a_plugin.path(), a_plugin.__version__))
 
469
    err_file.write(
 
470
"""\
 
471
*** Bazaar has encountered an internal error.
 
472
    Please report a bug at https://bugs.launchpad.net/bzr/+filebug
 
473
    including this traceback, and a description of what you
 
474
    were doing when the error occurred.
 
475
""")