~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/trace.py

  • Committer: mbp at sourcefrog
  • Date: 2005-04-13 04:56:45 UTC
  • Revision ID: mbp@sourcefrog.net-20050413045645-6f0a77d87a206746
- Better progress and completion indicator from check command

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
#! /usr/bin/env python
 
2
# -*- coding: UTF-8 -*-
 
3
 
1
4
# This program is free software; you can redistribute it and/or modify
2
5
# it under the terms of the GNU General Public License as published by
3
6
# the Free Software Foundation; either version 2 of the License, or
13
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
14
17
 
15
18
 
16
 
"""Messages and logging for bazaar-ng.
17
 
 
18
 
Messages are supplied by callers as a string-formatting template, plus values
19
 
to be inserted into it.  The actual %-formatting is deferred to the log
20
 
library so that it doesn't need to be done for messages that won't be emitted.
21
 
 
22
 
Messages are classified by severity levels: critical, error, warning, info,
23
 
and debug.
24
 
 
25
 
They can be sent to two places: to stderr, and to ~/.bzr.log.  For purposes
26
 
such as running the test suite, they can also be redirected away from both of
27
 
those two places to another location.
28
 
 
29
 
~/.bzr.log gets all messages, and full tracebacks for uncaught exceptions.
30
 
 
31
 
Output to stderr depends on the mode chosen by the user.  By default, messages
32
 
of info and above are sent out, which results in progress messages such as the
33
 
list of files processed by add and commit.  In quiet mode, only warnings and
34
 
above are shown.  In debug mode, stderr gets debug messages too.
35
 
 
36
 
Errors that terminate an operation are generally passed back as exceptions;
37
 
others may be just emitted as messages.
38
 
 
39
 
Exceptions are reported in a brief form to stderr so as not to look scary.
40
 
BzrErrors are required to be able to format themselves into a properly
41
 
explanatory message.  This is not true for builtin excexceptions such as
42
 
KeyError, which typically just str to "0".  They're printed in a different
43
 
form.
44
 
"""
45
 
 
46
 
 
47
 
# TODO: in debug mode, stderr should get full tracebacks and also
48
 
# debug messages.  (Is this really needed?)
49
 
 
50
 
# TODO: When running the test suites, we should add an additional
51
 
# logger that sends messages into the test log file.
52
 
 
53
 
# FIXME: Unfortunately it turns out that python's logging module
54
 
# is quite expensive, even when the message is not printed by any handlers.
55
 
# We should perhaps change back to just simply doing it here.
56
 
 
57
 
 
58
 
import sys
59
 
import os
60
 
import logging
61
 
 
 
19
__copyright__ = "Copyright (C) 2005 Canonical Ltd."
 
20
__author__ = "Martin Pool <mbp@canonical.com>"
 
21
 
 
22
 
 
23
import sys, os, time, socket, stat, codecs
62
24
import bzrlib
63
 
from bzrlib.errors import BzrNewError
64
 
 
65
 
 
66
 
_file_handler = None
67
 
_stderr_handler = None
68
 
 
69
 
 
70
 
class QuietFormatter(logging.Formatter):
71
 
    """Formatter that supresses the details of errors.
72
 
 
73
 
    This is used by default on stderr so as not to scare the user.
74
 
    """
75
 
    # At first I tried overriding formatException to suppress the
76
 
    # exception details, but that has global effect: no loggers
77
 
    # can get the exception details is we suppress them here.
78
 
 
79
 
    def format(self, record):
80
 
        if record.levelno >= logging.WARNING:
81
 
            s = 'bzr: ' + record.levelname + ': '
82
 
        else:
83
 
            s = ''
84
 
        s += record.getMessage()
85
 
        if record.exc_info:
86
 
            s += '\n' + format_exception_short(record.exc_info)
87
 
        return s
88
 
        
89
 
 
90
 
 
91
 
 
92
 
################
93
 
# configure convenient aliases for output routines
94
 
 
95
 
_bzr_logger = logging.getLogger('bzr')
96
 
 
97
 
info = note = _bzr_logger.info
98
 
warning =   _bzr_logger.warning
99
 
log_error = _bzr_logger.error
100
 
error =     _bzr_logger.error
101
 
mutter =    _bzr_logger.debug
102
 
debug =     _bzr_logger.debug
103
 
 
104
 
 
105
 
def _rollover_trace_maybe(trace_fname):
106
 
    import stat
107
 
    try:
108
 
        size = os.stat(trace_fname)[stat.ST_SIZE]
109
 
        if size <= 4 << 20:
110
 
            return
111
 
        old_fname = trace_fname + '.old'
112
 
        from osutils import rename
113
 
        rename(trace_fname, old_fname)
114
 
    except OSError:
115
 
        return
116
 
 
117
 
 
118
 
def open_tracefile(tracefilename='~/.bzr.log'):
 
25
 
 
26
######################################################################
 
27
# messages and logging
 
28
 
 
29
## TODO: If --verbose is given then write to both stderr and
 
30
## _tracefile; perhaps replace _tracefile with a tee thing.
 
31
 
 
32
global _tracefile, _starttime
 
33
_tracefile = None
 
34
 
 
35
# used to have % (os.environ['USER'], time.time(), os.getpid()), 'w')
 
36
_starttime = None
 
37
 
 
38
# If false, notes also go to stdout; should replace this with --silent
 
39
# at some point.
 
40
silent = False
 
41
 
 
42
 
 
43
# TODO: Somehow tie this to the --verbose option?
 
44
verbose = False
 
45
 
 
46
 
 
47
def warning(msg):
 
48
    b = 'bzr: warning: ' + msg + '\n'
 
49
    sys.stderr.write(b)
 
50
    _tracefile.write(b)
 
51
    #_tracefile.flush()
 
52
 
 
53
def mutter(msg):
 
54
    _tracefile.write(msg)
 
55
    _tracefile.write('\n')
 
56
    # _tracefile.flush()
 
57
    if verbose:
 
58
        sys.stderr.write('- ' + msg + '\n')
 
59
 
 
60
 
 
61
def note(msg):
 
62
    b = '* ' + str(msg) + '\n'
 
63
    if not silent:
 
64
        sys.stderr.write(b)
 
65
    _tracefile.write(b)
 
66
    # _tracefile.flush()
 
67
 
 
68
 
 
69
def log_error(msg):
 
70
    sys.stderr.write(msg)
 
71
    _tracefile.write(msg)
 
72
    # _tracefile.flush()
 
73
 
 
74
 
 
75
 
 
76
def create_tracefile(argv):
 
77
    # TODO: Also show contents of /etc/lsb-release, if it can be parsed.
 
78
    #       Perhaps that should eventually go into the platform library?
 
79
    # TODO: If the file doesn't exist, add a note describing it.
 
80
 
119
81
    # Messages are always written to here, so that we have some
120
82
    # information if something goes wrong.  In a future version this
121
83
    # file will be removed on successful completion.
122
 
    global _file_handler
123
 
    import stat, codecs
124
 
 
125
 
    trace_fname = os.path.join(os.path.expanduser(tracefilename))
126
 
    _rollover_trace_maybe(trace_fname)
127
 
    try:
128
 
        LINE_BUFFERED = 1
129
 
        tf = codecs.open(trace_fname, 'at', 'utf8', buffering=LINE_BUFFERED)
130
 
 
131
 
        if os.fstat(tf.fileno())[stat.ST_SIZE] == 0:
132
 
            tf.write("\nthis is a debug log for diagnosing/reporting problems in bzr\n")
133
 
            tf.write("you can delete or truncate this file, or include sections in\n")
134
 
            tf.write("bug reports to bazaar-ng@lists.canonical.com\n\n")
135
 
        
136
 
        _file_handler = logging.StreamHandler(tf)
137
 
        fmt = r'[%(process)5d] %(asctime)s.%(msecs)03d %(levelname)s: %(message)s'
138
 
        datefmt = r'%a %H:%M:%S'
139
 
        _file_handler.setFormatter(logging.Formatter(fmt, datefmt))
140
 
        _file_handler.setLevel(logging.DEBUG)
141
 
        logging.getLogger('').addHandler(_file_handler)
142
 
    except IOError, e:
143
 
        warning("failed to open trace file: %s" % (e))
144
 
 
145
 
 
146
 
def log_startup(argv):
147
 
    debug('bzr %s invoked on python %s (%s)',
148
 
          bzrlib.__version__,
149
 
          '.'.join(map(str, sys.version_info)),
150
 
          sys.platform)
151
 
    debug('  arguments: %r', argv)
152
 
    debug('  working dir: %r', os.getcwdu())
153
 
 
154
 
 
155
 
def log_exception(msg=None):
156
 
    """Log the last exception to stderr and the trace file.
157
 
 
158
 
    The exception string representation is used as the error
159
 
    summary, unless msg is given.
160
 
    """
161
 
    exc_str = format_exception_short(sys.exc_info())
162
 
    if msg:
163
 
        _bzr_logger.exception(msg)
164
 
    _bzr_logger.error(exc_str)
165
 
 
166
 
 
167
 
def log_exception_quietly():
168
 
    """Log the last exception to the trace file only.
169
 
 
170
 
    Used for exceptions that occur internally and that may be 
171
 
    interesting to developers but not to users.  For example, 
172
 
    errors loading plugins.
173
 
    """
174
 
    import traceback
175
 
    debug(traceback.format_exc())
176
 
 
177
 
 
178
 
def enable_default_logging():
179
 
    """Configure default logging to stderr and .bzr.log"""
180
 
    global _stderr_handler, _file_handler
181
 
 
182
 
    _stderr_handler = logging.StreamHandler()
183
 
    _stderr_handler.setFormatter(QuietFormatter())
184
 
    logging.getLogger('').addHandler(_stderr_handler)
185
 
 
186
 
    if os.environ.get('BZR_DEBUG'):
187
 
        level = logging.DEBUG
188
 
    else:
189
 
        level = logging.INFO
190
 
 
191
 
    _stderr_handler.setLevel(logging.INFO)
192
 
 
193
 
    if not _file_handler:
194
 
        open_tracefile()
195
 
 
196
 
    if _file_handler:
197
 
        _file_handler.setLevel(level)
198
 
 
199
 
    _bzr_logger.setLevel(level) 
200
 
 
201
 
def disable_default_logging():
202
 
    """Turn off default log handlers.
203
 
 
204
 
    This is intended to be used by the test framework, which doesn't
205
 
    want leakage from the code-under-test into the main logs.
206
 
    """
207
 
 
208
 
    l = logging.getLogger('')
209
 
    l.removeHandler(_stderr_handler)
210
 
    if _file_handler:
211
 
        l.removeHandler(_file_handler)
212
 
 
213
 
 
214
 
def enable_test_log(to_file):
215
 
    """Redirect logging to a temporary file for a test"""
216
 
    disable_default_logging()
217
 
    global _test_log_hdlr
218
 
    hdlr = logging.StreamHandler(to_file)
219
 
    hdlr.setLevel(logging.DEBUG)
220
 
    hdlr.setFormatter(logging.Formatter('%(levelname)8s  %(message)s'))
221
 
    logging.getLogger('').addHandler(hdlr)
222
 
    logging.getLogger('').setLevel(logging.DEBUG)
223
 
    _test_log_hdlr = hdlr
224
 
 
225
 
 
226
 
def disable_test_log():
227
 
    logging.getLogger('').removeHandler(_test_log_hdlr)
228
 
    enable_default_logging()
229
 
 
230
 
 
231
 
def format_exception_short(exc_info):
232
 
    """Make a short string form of an exception.
233
 
 
234
 
    This is used for display to stderr.  It specially handles exception
235
 
    classes without useful string methods.
236
 
 
237
 
    The result has no trailing newline.
238
 
 
239
 
    exc_info - typically an exception from sys.exc_info()
240
 
    """
241
 
    exc_type, exc_object, exc_tb = exc_info
242
 
    try:
243
 
        if exc_type is None:
244
 
            return '(no exception)'
245
 
        if isinstance(exc_object, BzrNewError):
246
 
            return str(exc_object)
247
 
        else:
248
 
            import traceback
249
 
            tb = traceback.extract_tb(exc_tb)
250
 
            msg = '%s: %s' % (exc_type, exc_object)
251
 
            if msg[-1] == '\n':
252
 
                msg = msg[:-1]
253
 
            if tb:
254
 
                msg += '\n  at %s line %d\n  in %s' % (tb[-1][:3])
255
 
            return msg
256
 
    except:
257
 
        return '(error formatting exception of type %s)' % exc_type
 
84
    global _starttime, _tracefile
 
85
 
 
86
    _starttime = os.times()[4]
 
87
 
 
88
    # XXX:  Does this always work on Windows?
 
89
    trace_fname = os.path.join(os.path.expanduser('~/.bzr.log'))
 
90
    _tracefile = codecs.open(trace_fname, 'at', 'utf8')
 
91
    t = _tracefile
 
92
 
 
93
    if os.fstat(t.fileno())[stat.ST_SIZE] == 0:
 
94
        t.write("\nthis is a debug log for diagnosing/reporting problems in bzr\n")
 
95
        t.write("you can delete or truncate this file, or include sections in\n")
 
96
        t.write("bug reports to bazaar-ng@lists.canonical.com\n\n")
 
97
 
 
98
    # TODO: If we failed to create the file, perhaps give a warning
 
99
    # but don't abort; send things to /dev/null instead?
 
100
 
 
101
    
 
102
    t.write('-' * 60 + '\n')
 
103
    t.write('bzr invoked at %s\n' % bzrlib.osutils.format_date(time.time()))
 
104
    t.write('  version: %s\n' % bzrlib.__version__)
 
105
    t.write('  by %s on %s\n' % (bzrlib.osutils.username(), socket.getfqdn()))
 
106
    t.write('  arguments: %r\n' % argv)
 
107
    t.write('  working dir: %s\n' % os.getcwdu())
 
108
 
 
109
    t.write('  platform: %s\n' % sys.platform)
 
110
    t.write('  python: %s\n' % (sys.version_info,))
 
111
 
 
112
    import atexit
 
113
    atexit.register(_close_trace)
 
114
 
 
115
 
 
116
def _close_trace():
 
117
    times = os.times()
 
118
    mutter("finished, %.3fu/%.3fs cpu, %.3fu/%.3fs cum, %.3f elapsed"
 
119
           % (times[:4] + ((times[4] - _starttime),)))
 
120
 
 
121
 
 
122