/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 bzrlib/trace.py

  • Committer: Vincent Ladeuil
  • Date: 2011-06-16 10:45:17 UTC
  • mto: This revision was merged to the branch mainline in revision 5981.
  • Revision ID: v.ladeuil+lp@free.fr-20110616104517-4qzhmzkxgozji88y
Add copyright notice, some docs and some cleanups.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
68
69
import traceback
69
70
""")
70
71
 
80
81
    debug,
81
82
    errors,
82
83
    osutils,
83
 
    plugin,
84
 
    symbol_versioning,
85
84
    ui,
86
85
    )
87
86
""")
122
121
    # FIXME: clearing the ui and then going through the abstract logging
123
122
    # framework is whack; we should probably have a logging Handler that
124
123
    # deals with terminal output if needed.
125
 
    import bzrlib.ui
126
 
    bzrlib.ui.ui_factory.clear_term()
 
124
    ui.ui_factory.clear_term()
127
125
    _bzr_logger.info(*args, **kwargs)
128
126
 
129
127
 
130
128
def warning(*args, **kwargs):
131
 
    import bzrlib.ui
132
 
    bzrlib.ui.ui_factory.clear_term()
 
129
    ui.ui_factory.clear_term()
133
130
    _bzr_logger.warning(*args, **kwargs)
134
131
 
135
132
 
306
303
    logging.getLogger("bzr").
307
304
 
308
305
    Output can be redirected away by calling _push_log_file.
 
306
 
 
307
    :return: A memento from push_log_file for restoring the log state.
309
308
    """
310
 
    # Do this before we open the log file, so we prevent
311
 
    # get_terminal_encoding() from mutter()ing multiple times
312
 
    term_encoding = osutils.get_terminal_encoding()
313
309
    start_time = osutils.format_local_date(_bzr_log_start_time,
314
310
                                           timezone='local')
315
311
    # create encoded wrapper around stderr
316
312
    bzr_log_file = _open_bzr_log()
317
313
    if bzr_log_file is not None:
318
314
        bzr_log_file.write(start_time.encode('utf-8') + '\n')
319
 
    push_log_file(bzr_log_file,
 
315
    memento = push_log_file(bzr_log_file,
320
316
        r'[%(process)5d] %(asctime)s.%(msecs)03d %(levelname)s: %(message)s',
321
317
        r'%Y-%m-%d %H:%M:%S')
322
318
    # after hooking output into bzr_log, we also need to attach a stderr
323
319
    # handler, writing only at level info and with encoding
 
320
    term_encoding = osutils.get_terminal_encoding()
324
321
    writer_factory = codecs.getwriter(term_encoding)
325
322
    encoded_stderr = writer_factory(sys.stderr, errors='replace')
326
323
    stderr_handler = logging.StreamHandler(encoded_stderr)
327
324
    stderr_handler.setLevel(logging.INFO)
328
325
    logging.getLogger('bzr').addHandler(stderr_handler)
 
326
    return memento
329
327
 
330
328
 
331
329
def push_log_file(to_file, log_format=None, date_format=None):
334
332
    :param to_file: A file-like object to which messages will be sent.
335
333
 
336
334
    :returns: A memento that should be passed to _pop_log_file to restore the
337
 
    previously active logging.
 
335
        previously active logging.
338
336
    """
339
337
    global _trace_file
340
338
    # make a new handler
367
365
def pop_log_file((magic, old_handlers, new_handler, old_trace_file, new_trace_file)):
368
366
    """Undo changes to logging/tracing done by _push_log_file.
369
367
 
370
 
    This flushes, but does not close the trace file.
 
368
    This flushes, but does not close the trace file (so that anything that was
 
369
    in it is output.
371
370
 
372
371
    Takes the memento returned from _push_log_file."""
373
372
    global _trace_file
374
373
    _trace_file = old_trace_file
375
374
    bzr_logger = logging.getLogger('bzr')
376
375
    bzr_logger.removeHandler(new_handler)
377
 
    # must be closed, otherwise logging will try to close it atexit, and the
 
376
    # must be closed, otherwise logging will try to close it at exit, and the
378
377
    # file will likely already be closed underneath.
379
378
    new_handler.close()
380
379
    bzr_logger.handlers = old_handlers
381
 
    new_trace_file.flush()
 
380
    if new_trace_file is not None:
 
381
        new_trace_file.flush()
382
382
 
383
383
 
384
384
def log_exception_quietly():
466
466
                    note(line)
467
467
                    break
468
468
 
 
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
 
469
503
 
470
504
def report_exception(exc_info, err_file):
471
505
    """Report an exception to err_file (typically stderr) and to .bzr.log.
489
523
        return errors.EXIT_ERROR
490
524
    elif isinstance(exc_object, MemoryError):
491
525
        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")
492
530
        return errors.EXIT_ERROR
493
531
    elif isinstance(exc_object, ImportError) \
494
532
        and str(exc_object).startswith("No module named "):
498
536
    elif not getattr(exc_object, 'internal_error', True):
499
537
        report_user_error(exc_info, err_file)
500
538
        return errors.EXIT_ERROR
501
 
    elif isinstance(exc_object, (OSError, IOError)):
 
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"):
502
542
        # Might be nice to catch all of these and show them as something more
503
543
        # specific, but there are too many cases at the moment.
504
544
        report_user_error(exc_info, err_file)
538
578
 
539
579
 
540
580
def _flush_stdout_stderr():
541
 
    # installed into an atexit hook by bzrlib.initialize()
 
581
    # called from the bzrlib library finalizer returned by bzrlib.initialize()
542
582
    try:
543
583
        sys.stdout.flush()
544
584
        sys.stderr.flush()
551
591
 
552
592
 
553
593
def _flush_trace():
554
 
    # run from atexit hook
 
594
    # called from the bzrlib library finalizer returned by bzrlib.initialize()
555
595
    global _trace_file
556
596
    if _trace_file:
557
597
        _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.