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