← Back to branch summary

~ubuntu-branches/ubuntu/lucid/pytagsfs/lucid

« back to all changes in this revision

Viewing changes to modules/pytagsfs/debug.py

  • Committer: Bazaar Package Importer
  • Author(s): Y Giridhar Appaji Nag
  • Date: 2009-01-28 22:11:56 UTC
  • mfrom: (1.1.3 upstream) (3.1.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090128221156-tbhq0bau1tke233i
Tags: 0.9.0~rc1-1
* New upstream release
  + Needs python-fuse to build add to Build-Depends

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/pytagsfs/debug.py
9
9
 
10
10
from sclapp import locale
11
11
 
12
 
import sys, traceback, logging, time
 
12
import traceback, logging, time
13
13
from logging import DEBUG, INFO, WARNING, ERROR, CRITICAL
14
14
 
15
15
try:
17
17
except ImportError:
18
18
    from sclapp.legacy_support import wraps
19
19
 
20
 
from pytagsfs.specialfile.logfile import VirtualLogFile
21
20
 
22
21
class VirtualLogFileStream(object):
23
22
    def write(self, s):
24
 
        VirtualLogFile.log_write(s)
 
23
        # Re-bind write method on first invocation to avoid performance hit
 
24
        # from importing on every call (necessary to avoid import loop via
 
25
        # pytagsfs.file).
 
26
        from pytagsfs.specialfile.logfile import VirtualLogFile
 
27
        self.write = VirtualLogFile.log_write
 
28
        return self.write(s)
25
29
 
26
30
    def flush(self):
27
31
        pass
28
32
 
 
33
 
29
34
logger = logging.getLogger()
30
35
 
 
36
 
31
37
class FormatterWithMicroseconds(logging.Formatter):
32
38
    def formatTime(self, record, datefmt):
33
39
        ct = self.converter(record.created)
36
42
            s = s.replace('${us}', '%03d' % record.msecs)
37
43
        return s
38
44
 
 
45
 
39
46
formatter = FormatterWithMicroseconds(
40
47
  '[%(asctime)s] %(message)s',
41
48
  '%H:%M:%S,${us}',
42
49
)
43
50
 
 
51
 
44
52
stderr_handler = logging.StreamHandler()
45
53
stderr_handler.setFormatter(formatter)
46
54
 
 
55
 
47
56
virtual_log_file_handler = logging.StreamHandler(VirtualLogFileStream())
48
57
virtual_log_file_handler.setFormatter(formatter)
49
58
 
 
59
 
50
60
logger.addHandler(virtual_log_file_handler)
51
61
 
 
62
 
52
63
def set_log_level(lvl):
53
64
    logger.setLevel(lvl)
54
65
 
 
66
 
55
67
def set_logsize(size):
 
68
    from pytagsfs.specialfile.logfile import VirtualLogFile
56
69
    VirtualLogFile.set_max_length(size)
57
70
 
 
71
 
58
72
stderr_enabled = False
 
73
 
59
74
def enable_stderr():
60
75
    global stderr_enabled
61
76
    if not stderr_enabled:
62
77
        logger.addHandler(stderr_handler)
63
78
        stderr_enabled = True
64
79
 
65
 
def log_debug(s):
66
 
    logger.debug(s)
67
 
 
68
 
def log_info(s):
69
 
    logger.info(s)
70
 
 
71
 
def log_warning(s):
72
 
    logger.warning(s)
73
 
 
74
 
def log_error(s):
75
 
    logger.error(s)
76
 
 
77
 
def log_critical(s):
78
 
    logger.critical(s)
79
 
 
80
 
def log_loud(s):
81
 
    log_critical(s)
 
80
 
 
81
def log_debug(*args, **kwargs):
 
82
    logger.debug(*args, **kwargs)
 
83
 
 
84
 
 
85
def log_info(*args, **kwargs):
 
86
    logger.info(*args, **kwargs)
 
87
 
 
88
 
 
89
def log_warning(*args, **kwargs):
 
90
    logger.warning(*args, **kwargs)
 
91
 
 
92
 
 
93
def log_error(*args, **kwargs):
 
94
    logger.error(*args, **kwargs)
 
95
 
 
96
 
 
97
def log_critical(*args, **kwargs):
 
98
    logger.critical(*args, **kwargs)
 
99
 
 
100
 
 
101
def log_loud(*args, **kwargs):
82
102
    if not stderr_enabled:
83
 
        print >>sys.stderr, s
 
103
        logger.addHandler(stderr_handler)
 
104
        try:
 
105
            log_critical(*args, **kwargs)
 
106
        finally:
 
107
            logger.removeHandler(stderr_handler)
 
108
    else:
 
109
        log_critical(*args, **kwargs)
 
110
 
84
111
 
85
112
def log_traceback():
86
113
    log_critical(traceback.format_exc())
87
114
 
 
115
 
88
116
def ignore_exceptions(*ignored_exceptions):
89
117
    def decorator(fn):
90
118
        @wraps(fn)
95
123
                pass
96
124
        return new_fn
97
125
    return decorator
98
 
 
99
 
def exceptionally_logged(ignore):
100
 
    decorate_immediately = False
101
 
    if hasattr(ignore, '__call__'):
102
 
        decorate_immediately = True
103
 
        fn = ignore
104
 
        ignore = ()
105
 
 
106
 
    def decorator(fn):
107
 
        @wraps(fn)
108
 
        def new_fn(*args, **kwargs):
109
 
            try:
110
 
                return fn(*args, **kwargs)
111
 
            except ignore:
112
 
                raise
113
 
            except Exception:
114
 
                log_traceback()
115
 
                raise
116
 
        return new_fn
117
 
 
118
 
    if decorate_immediately:
119
 
        return decorator(fn)
120
 
    return decorator
121
 
 
122
 
def describe_function(fn):
123
 
    parts = []
124
 
    if hasattr(fn, 'im_class') and fn.im_class:
125
 
        parts.append(fn.im_class.__module__)
126
 
        parts.append(fn.im_class.__name__)
127
 
        parts.append(fn.im_func.__name__)
128
 
    elif hasattr(fn, 'im_func') and fn.im_func:
129
 
        parts.append(fn.im_func.__module__)
130
 
        parts.append(fn.im_func.__name__)
131
 
    else:
132
 
        parts.append(fn.__name__)
133
 
    return '.'.join(parts)
134
 
 
135
 
def logged(fn):
136
 
    @wraps(fn)
137
 
    def new_fn(*args, **kwargs):
138
 
        log_debug('(Entering %s)' % describe_function(fn))
139
 
        try:
140
 
            retval = fn(*args, **kwargs)
141
 
        finally:
142
 
            log_debug('(Leaving %s)' % describe_function(fn))
143
 
        return retval
144
 
    return new_fn
145
 
 
146
 
def verbosely_logged(fn):
147
 
    @wraps(fn)
148
 
    def new_fn(*args, **kwargs):
149
 
        log_debug('(Entering %s: args=%s, kwargs=%s)' % (
150
 
          describe_function(fn), repr(args), repr(kwargs)))
151
 
        try:
152
 
            retval = fn(*args, **kwargs)
153
 
        except Exception, e:
154
 
            log_debug('(Exception raised in %s: %s)' % (describe_function(fn), repr(e)))
155
 
            raise
156
 
        log_debug('(Leaving %s: returning %s)' % (describe_function(fn), repr(retval)))
157
 
        return retval
158
 
    return new_fn