← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/trace.py

  • Committer: Robert Collins
  • Date: 2010-05-06 23:54:05 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506235405-wii4elupfhzl3jvy
Add __str__ to the new helper classes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/trace.py
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
65
65
from cStringIO import StringIO
66
66
import errno
67
67
import locale
68
 
import tempfile
69
68
import traceback
70
69
""")
71
70
 
81
80
    debug,
82
81
    errors,
83
82
    osutils,
 
83
    plugin,
 
84
    symbol_versioning,
84
85
    ui,
85
86
    )
86
87
""")
110
111
 
111
112
 
112
113
def note(*args, **kwargs):
113
 
    """Output a note to the user.
114
 
 
115
 
    Takes the same parameters as logging.info.
116
 
 
117
 
    :return: None
118
 
    """
119
114
    # FIXME note always emits utf-8, regardless of the terminal encoding
120
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()
 
119
    import bzrlib.ui
 
120
    bzrlib.ui.ui_factory.clear_term()
125
121
    _bzr_logger.info(*args, **kwargs)
126
122
 
127
123
 
128
124
def warning(*args, **kwargs):
129
 
    ui.ui_factory.clear_term()
 
125
    import bzrlib.ui
 
126
    bzrlib.ui.ui_factory.clear_term()
130
127
    _bzr_logger.warning(*args, **kwargs)
131
128
 
132
129
 
303
300
    logging.getLogger("bzr").
304
301
 
305
302
    Output can be redirected away by calling _push_log_file.
306
 
 
307
 
    :return: A memento from push_log_file for restoring the log state.
308
303
    """
 
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()
309
307
    start_time = osutils.format_local_date(_bzr_log_start_time,
310
308
                                           timezone='local')
311
309
    # create encoded wrapper around stderr
312
310
    bzr_log_file = _open_bzr_log()
313
311
    if bzr_log_file is not None:
314
312
        bzr_log_file.write(start_time.encode('utf-8') + '\n')
315
 
    memento = push_log_file(bzr_log_file,
 
313
    push_log_file(bzr_log_file,
316
314
        r'[%(process)5d] %(asctime)s.%(msecs)03d %(levelname)s: %(message)s',
317
315
        r'%Y-%m-%d %H:%M:%S')
318
316
    # after hooking output into bzr_log, we also need to attach a stderr
319
317
    # handler, writing only at level info and with encoding
320
 
    term_encoding = osutils.get_terminal_encoding()
321
318
    writer_factory = codecs.getwriter(term_encoding)
322
319
    encoded_stderr = writer_factory(sys.stderr, errors='replace')
323
320
    stderr_handler = logging.StreamHandler(encoded_stderr)
324
321
    stderr_handler.setLevel(logging.INFO)
325
322
    logging.getLogger('bzr').addHandler(stderr_handler)
326
 
    return memento
327
323
 
328
324
 
329
325
def push_log_file(to_file, log_format=None, date_format=None):
332
328
    :param to_file: A file-like object to which messages will be sent.
333
329
 
334
330
    :returns: A memento that should be passed to _pop_log_file to restore the
335
 
        previously active logging.
 
331
    previously active logging.
336
332
    """
337
333
    global _trace_file
338
334
    # make a new handler
365
361
def pop_log_file((magic, old_handlers, new_handler, old_trace_file, new_trace_file)):
366
362
    """Undo changes to logging/tracing done by _push_log_file.
367
363
 
368
 
    This flushes, but does not close the trace file (so that anything that was
369
 
    in it is output.
 
364
    This flushes, but does not close the trace file.
370
365
 
371
366
    Takes the memento returned from _push_log_file."""
372
367
    global _trace_file
373
368
    _trace_file = old_trace_file
374
369
    bzr_logger = logging.getLogger('bzr')
375
370
    bzr_logger.removeHandler(new_handler)
376
 
    # must be closed, otherwise logging will try to close it at exit, and the
 
371
    # must be closed, otherwise logging will try to close it atexit, and the
377
372
    # file will likely already be closed underneath.
378
373
    new_handler.close()
379
374
    bzr_logger.handlers = old_handlers
380
 
    if new_trace_file is not None:
381
 
        new_trace_file.flush()
 
375
    new_trace_file.flush()
382
376
 
383
377
 
384
378
def log_exception_quietly():
466
460
                    note(line)
467
461
                    break
468
462
 
469
 
def _dump_memory_usage(err_file):
470
 
    try:
471
 
        try:
472
 
            fd, name = tempfile.mkstemp(prefix="bzr_memdump", suffix=".json")
473
 
            dump_file = os.fdopen(fd, 'w')
474
 
            from meliae import scanner
475
 
            scanner.dump_gc_objects(dump_file)
476
 
            err_file.write("Memory dumped to %s\n" % name)
477
 
        except ImportError:
478
 
            err_file.write("Dumping memory requires meliae module.\n")
479
 
            log_exception_quietly()
480
 
        except:
481
 
            err_file.write("Exception while dumping memory.\n")
482
 
            log_exception_quietly()
483
 
    finally:
484
 
        if dump_file is not None:
485
 
            dump_file.close()
486
 
        elif fd is not None:
487
 
            os.close(fd)
488
 
 
489
 
 
490
 
def _qualified_exception_name(eclass, unqualified_bzrlib_errors=False):
491
 
    """Give name of error class including module for non-builtin exceptions
492
 
 
493
 
    If `unqualified_bzrlib_errors` is True, errors specific to bzrlib will
494
 
    also omit the module prefix.
495
 
    """
496
 
    class_name = eclass.__name__
497
 
    module_name = eclass.__module__
498
 
    if module_name in ("exceptions", "__main__") or (
499
 
            unqualified_bzrlib_errors and module_name == "bzrlib.errors"):
500
 
        return class_name
501
 
    return "%s.%s" % (module_name, class_name)
502
 
 
503
463
 
504
464
def report_exception(exc_info, err_file):
505
465
    """Report an exception to err_file (typically stderr) and to .bzr.log.
523
483
        return errors.EXIT_ERROR
524
484
    elif isinstance(exc_object, MemoryError):
525
485
        err_file.write("bzr: out of memory\n")
526
 
        if 'mem_dump' in debug.debug_flags:
527
 
            _dump_memory_usage(err_file)
528
 
        else:
529
 
            err_file.write("Use -Dmem_dump to dump memory to a file.\n")
530
486
        return errors.EXIT_ERROR
531
487
    elif isinstance(exc_object, ImportError) \
532
488
        and str(exc_object).startswith("No module named "):
536
492
    elif not getattr(exc_object, 'internal_error', True):
537
493
        report_user_error(exc_info, err_file)
538
494
        return errors.EXIT_ERROR
539
 
    elif isinstance(exc_object, (OSError, IOError)) or (
540
 
        # GZ 2010-05-20: Like (exc_type is pywintypes.error) but avoid import
541
 
        exc_type.__name__ == "error" and exc_type.__module__ == "pywintypes"):
 
495
    elif isinstance(exc_object, (OSError, IOError)):
542
496
        # Might be nice to catch all of these and show them as something more
543
497
        # specific, but there are too many cases at the moment.
544
498
        report_user_error(exc_info, err_file)
578
532
 
579
533
 
580
534
def _flush_stdout_stderr():
581
 
    # called from the bzrlib library finalizer returned by bzrlib.initialize()
 
535
    # installed into an atexit hook by bzrlib.initialize()
582
536
    try:
583
537
        sys.stdout.flush()
584
538
        sys.stderr.flush()
591
545
 
592
546
 
593
547
def _flush_trace():
594
 
    # called from the bzrlib library finalizer returned by bzrlib.initialize()
 
548
    # run from atexit hook
595
549
    global _trace_file
596
550
    if _trace_file:
597
551
        _trace_file.flush()
598
 
 
599
 
 
600
 
class Config(object):
601
 
    """Configuration of message tracing in bzrlib.
602
 
 
603
 
    This implements the context manager protocol and should manage any global
604
 
    variables still used. The default config used is DefaultConfig, but
605
 
    embedded uses of bzrlib may wish to use a custom manager.
606
 
    """
607
 
 
608
 
    def __enter__(self):
609
 
        return self # This is bound to the 'as' clause in a with statement.
610
 
 
611
 
    def __exit__(self, exc_type, exc_val, exc_tb):
612
 
        return False # propogate exceptions.
613
 
 
614
 
 
615
 
class DefaultConfig(Config):
616
 
    """A default configuration for tracing of messages in bzrlib.
617
 
 
618
 
    This implements the context manager protocol.
619
 
    """
620
 
 
621
 
    def __enter__(self):
622
 
        self._original_filename = _bzr_log_filename
623
 
        self._original_state = enable_default_logging()
624
 
        return self # This is bound to the 'as' clause in a with statement.
625
 
 
626
 
    def __exit__(self, exc_type, exc_val, exc_tb):
627
 
        pop_log_file(self._original_state)
628
 
        global _bzr_log_filename
629
 
        _bzr_log_filename = self._original_filename
630
 
        return False # propogate exceptions.