← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/trace.py

  • Committer: John Arbash Meinel
  • Author(s): Mark Hammond
  • Date: 2008-09-09 17:02:21 UTC
  • mto: This revision was merged to the branch mainline in revision 3697.
  • Revision ID: john@arbash-meinel.com-20080909170221-svim3jw2mrz0amp3
An updated transparent icon for bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/trace.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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
49
49
# FIXME: Unfortunately it turns out that python's logging module
50
50
# is quite expensive, even when the message is not printed by any handlers.
51
51
# We should perhaps change back to just simply doing it here.
 
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.
52
57
 
 
58
import codecs
 
59
import logging
53
60
import os
54
61
import sys
55
62
import re
 
63
import time
56
64
 
57
65
from bzrlib.lazy_import import lazy_import
58
66
lazy_import(globals(), """
59
67
from cStringIO import StringIO
60
68
import errno
61
69
import locale
62
 
import logging
63
70
import traceback
64
71
""")
65
72
 
71
78
    errors,
72
79
    osutils,
73
80
    plugin,
 
81
    symbol_versioning,
74
82
    )
75
83
""")
76
84
 
77
 
_file_handler = None
78
 
_stderr_handler = None
 
85
 
 
86
# global verbosity for bzrlib; controls the log level for stderr; 0=normal; <0
 
87
# is quiet; >0 is verbose.
79
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.
80
94
_trace_file = None
81
 
_trace_depth = 0
82
 
_bzr_log_file = None
 
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.
83
98
_bzr_log_filename = None
84
99
 
85
 
 
86
 
# configure convenient aliases for output routines
87
 
 
 
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
88
106
_bzr_logger = logging.getLogger('bzr')
89
107
 
 
108
 
90
109
def note(*args, **kwargs):
91
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.
92
115
    import bzrlib.ui
93
116
    bzrlib.ui.ui_factory.clear_term()
94
117
    _bzr_logger.info(*args, **kwargs)
95
118
 
 
119
 
96
120
def warning(*args, **kwargs):
97
121
    import bzrlib.ui
98
122
    bzrlib.ui.ui_factory.clear_term()
99
123
    _bzr_logger.warning(*args, **kwargs)
100
124
 
 
125
 
 
126
# configure convenient aliases for output routines
 
127
#
 
128
# TODO: deprecate them, have one name for each.
101
129
info = note
102
130
log_error = _bzr_logger.error
103
131
error =     _bzr_logger.error
124
152
        out = fmt % tuple(real_args)
125
153
    else:
126
154
        out = fmt
127
 
    out += '\n'
 
155
    timestamp = '%0.3f  ' % (time.time() - _bzr_log_start_time,)
 
156
    out = timestamp + out + '\n'
128
157
    _trace_file.write(out)
129
 
    # TODO: jam 20051227 Consider flushing the trace file to help debugging
130
 
    #_trace_file.flush()
 
158
    # no need to flush here, the trace file is now linebuffered when it's
 
159
    # opened.
131
160
 
132
161
 
133
162
def mutter_callsite(stacklevel, fmt, *args):
139
168
    :param args: A list of substitution variables.
140
169
    """
141
170
    outf = StringIO()
142
 
    traceback.print_stack(limit=stacklevel + 1, file=outf)
 
171
    if stacklevel is None:
 
172
        limit = None
 
173
    else:
 
174
        limit = stacklevel + 1
 
175
    traceback.print_stack(limit=limit, file=outf)
143
176
    formatted_lines = outf.getvalue().splitlines()
144
177
    formatted_stack = '\n'.join(formatted_lines[:-2])
145
178
    mutter(fmt + "\nCalled from:\n%s", *(args + (formatted_stack,)))
157
190
        return
158
191
 
159
192
 
160
 
def open_tracefile(tracefilename=None):
161
 
    # Messages are always written to here, so that we have some
162
 
    # information if something goes wrong.  In a future version this
163
 
    # file will be removed on successful completion.
164
 
    global _file_handler, _bzr_log_file, _bzr_log_filename
165
 
    import codecs
166
 
 
167
 
    if tracefilename is None:
 
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:
168
199
        if sys.platform == 'win32':
169
200
            from bzrlib import win32utils
170
201
            home = win32utils.get_home_location()
171
202
        else:
172
203
            home = os.path.expanduser('~')
173
 
        _bzr_log_filename = os.path.join(home, '.bzr.log')
174
 
    else:
175
 
        _bzr_log_filename = tracefilename
176
 
 
177
 
    _bzr_log_filename = os.path.expanduser(_bzr_log_filename)
 
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()
178
218
    _rollover_trace_maybe(_bzr_log_filename)
179
219
    try:
180
 
        LINE_BUFFERED = 1
181
 
        #tf = codecs.open(trace_fname, 'at', 'utf8', buffering=LINE_BUFFERED)
182
 
        tf = open(_bzr_log_filename, 'at', LINE_BUFFERED)
183
 
        _bzr_log_file = tf
184
 
        # tf.tell() on windows always return 0 until some writing done
185
 
        tf.write('\n')
186
 
        if tf.tell() <= 2:
187
 
            tf.write("this is a debug log for diagnosing/reporting problems in bzr\n")
188
 
            tf.write("you can delete or truncate this file, or include sections in\n")
189
 
            tf.write("bug reports to bazaar@lists.canonical.com\n\n")
190
 
        _file_handler = logging.StreamHandler(tf)
191
 
        fmt = r'[%(process)5d] %(asctime)s.%(msecs)03d %(levelname)s: %(message)s'
192
 
        datefmt = r'%a %H:%M:%S'
193
 
        _file_handler.setFormatter(logging.Formatter(fmt, datefmt))
194
 
        _file_handler.setLevel(logging.DEBUG)
195
 
        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
196
228
    except IOError, e:
197
229
        warning("failed to open trace file: %s" % (e))
 
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)
198
326
 
199
327
 
200
328
def log_exception_quietly():
204
332
    interesting to developers but not to users.  For example, 
205
333
    errors loading plugins.
206
334
    """
207
 
    import traceback
208
335
    mutter(traceback.format_exc())
209
336
 
210
337
 
211
 
def enable_default_logging():
212
 
    """Configure default logging to stderr and .bzr.log"""
213
 
    # FIXME: if this is run twice, things get confused
214
 
    global _stderr_handler, _file_handler, _trace_file, _bzr_log_file
215
 
    _stderr_handler = logging.StreamHandler()
216
 
    logging.getLogger('').addHandler(_stderr_handler)
217
 
    _stderr_handler.setLevel(logging.INFO)
218
 
    if not _file_handler:
219
 
        open_tracefile()
220
 
    _trace_file = _bzr_log_file
221
 
    if _file_handler:
222
 
        _file_handler.setLevel(logging.DEBUG)
223
 
    _bzr_logger.setLevel(logging.DEBUG)
224
 
 
225
 
 
226
338
def set_verbosity_level(level):
227
339
    """Set the verbosity level.
228
340
 
252
364
def _update_logging_level(quiet=True):
253
365
    """Hide INFO messages if quiet."""
254
366
    if quiet:
255
 
        _stderr_handler.setLevel(logging.WARNING)
 
367
        _bzr_logger.setLevel(logging.WARNING)
256
368
    else:
257
 
        _stderr_handler.setLevel(logging.INFO)
 
369
        _bzr_logger.setLevel(logging.INFO)
258
370
 
259
371
 
260
372
def is_quiet():
267
379
    return _verbosity_level > 0
268
380
 
269
381
 
 
382
@symbol_versioning.deprecated_function(symbol_versioning.one_two)
270
383
def disable_default_logging():
271
384
    """Turn off default log handlers.
272
385
 
273
 
    This is intended to be used by the test framework, which doesn't
274
 
    want leakage from the code-under-test into the main logs.
275
 
    """
276
 
 
277
 
    l = logging.getLogger('')
278
 
    l.removeHandler(_stderr_handler)
279
 
    if _file_handler:
280
 
        l.removeHandler(_file_handler)
281
 
    _trace_file = None
282
 
 
283
 
 
284
 
def enable_test_log(to_file):
285
 
    """Redirect logging to a temporary file for a test
286
 
    
287
 
    returns an opaque reference that should be passed to disable_test_log
288
 
    after the test completes.
289
 
    """
290
 
    disable_default_logging()
291
 
    global _trace_file
292
 
    global _trace_depth
293
 
    hdlr = logging.StreamHandler(to_file)
294
 
    hdlr.setLevel(logging.DEBUG)
295
 
    hdlr.setFormatter(logging.Formatter('%(levelname)8s  %(message)s'))
296
 
    _bzr_logger.addHandler(hdlr)
297
 
    _bzr_logger.setLevel(logging.DEBUG)
298
 
    result = hdlr, _trace_file, _trace_depth
299
 
    _trace_file = to_file
300
 
    _trace_depth += 1
301
 
    return result
302
 
 
303
 
 
304
 
def disable_test_log((test_log_hdlr, old_trace_file, old_trace_depth)):
305
 
    _bzr_logger.removeHandler(test_log_hdlr)
306
 
    test_log_hdlr.close()
307
 
    global _trace_file
308
 
    global _trace_depth
309
 
    _trace_file = old_trace_file
310
 
    _trace_depth = old_trace_depth
311
 
    if not _trace_depth:
312
 
        enable_default_logging()
 
386
    Don't call this method, use _push_log_file and _pop_log_file instead.
 
387
    """
 
388
    pass
313
389
 
314
390
 
315
391
def report_exception(exc_info, err_file):
329
405
    elif isinstance(exc_object, KeyboardInterrupt):
330
406
        err_file.write("bzr: interrupted\n")
331
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
332
413
    elif not getattr(exc_object, 'internal_error', True):
333
414
        report_user_error(exc_info, err_file)
334
415
        return errors.EXIT_ERROR
342
423
        return errors.EXIT_INTERNAL_ERROR
343
424
 
344
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
 
345
434
# TODO: Should these be specially encoding the output?
346
 
def report_user_error(exc_info, err_file):
 
435
def report_user_error(exc_info, err_file, advice=None):
347
436
    """Report to err_file an error that's not an internal error.
348
437
 
349
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.
350
443
    """
351
444
    if 'error' in debug.debug_flags:
352
 
        report_bug(exc_info, err_file)
 
445
        print_exception(exc_info, err_file)
353
446
        return
354
447
    err_file.write("bzr: ERROR: %s\n" % (exc_info[1],))
 
448
    if advice:
 
449
        err_file.write("%s\n" % (advice,))
355
450
 
356
451
 
357
452
def report_bug(exc_info, err_file):
358
453
    """Report an exception that probably indicates a bug in bzr"""
359
 
    import traceback
360
 
    exc_type, exc_object, exc_tb = exc_info
361
 
    err_file.write("bzr: ERROR: %s.%s: %s\n" % (
362
 
        exc_type.__module__, exc_type.__name__, exc_object))
363
 
    err_file.write('\n')
364
 
    traceback.print_exception(exc_type, exc_object, exc_tb, file=err_file)
 
454
    print_exception(exc_info, err_file)
365
455
    err_file.write('\n')
366
456
    err_file.write('bzr %s on python %s (%s)\n' % \
367
457
                       (bzrlib.__version__,
368
 
                        '.'.join(map(str, sys.version_info)),
 
458
                        bzrlib._format_version_tuple(sys.version_info),
369
459
                        sys.platform))
370
460
    err_file.write('arguments: %r\n' % sys.argv)
371
461
    err_file.write(
377
467
        err_file.write("  %-20s %s [%s]\n" %
378
468
            (name, a_plugin.path(), a_plugin.__version__))
379
469
    err_file.write(
380
 
        "\n"
381
 
        "** Please send this report to bazaar@lists.ubuntu.com\n"
382
 
        "   with a description of what you were doing when the\n"
383
 
        "   error occurred.\n"
384
 
        )
 
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
""")