/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: Breezy landing bot
  • Author(s): Colin Watson
  • Date: 2020-11-16 21:47:08 UTC
  • mfrom: (7521.1.1 remove-lp-workaround)
  • Revision ID: breezy.the.bot@gmail.com-20201116214708-jos209mgxi41oy15
Remove breezy.git workaround for bazaar.launchpad.net.

Merged from https://code.launchpad.net/~cjwatson/brz/remove-lp-workaround/+merge/393710

Show diffs side-by-side

added added

removed removed

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