-
Notifications
You must be signed in to change notification settings - Fork 1
Expand file tree
/
Copy path__init__.py
More file actions
180 lines (139 loc) · 4.58 KB
/
Copy path__init__.py
File metadata and controls
180 lines (139 loc) · 4.58 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
"""
for create stream logger and file logger
usage:
from cgpython import io
io.debug('debug')
"""
import os
import sys
import inspect
import logging
import logging.handlers
# create custom level between info and warning
ORDINARY = 25
logging.addLevelName(ORDINARY, 'ORDINARY')
def createTempFile():
"""
create temp file
@return: temp file path
"""
import tempfile
return tempfile.NamedTemporayFile(suffix='.log', delete=False)
def _getCallerStatus():
try:
frame = sys._getframe(4)
except Exception:
frame = sys._getframe(3)
fileName = frame.f_code.co_filename
callerFrameRecorder = inspect.stack()[1]
moduleName = inspect.getmodule(callerFrameRecorder[0]).__name__
lineNumber = frame.f_lineno
functionName = frame.f_code.co_name
# For class
if 'self' in frame.f_locals.keys():
className = frame.f_locals['self'].__class__.__name__
if moduleName and className and functionName:
if functionName == '?':
logger = ".".join((moduleName, className))
else:
logger = ".".join(
(moduleName, className, functionName))
else:
logger = None
else:
className = None
if moduleName and functionName:
if functionName == '?':
logger = moduleName
else:
logger = ".".join([moduleName, functionName])
else:
logger = None
return (logger, fileName, lineNumber)
class CgLogger(logging.Logger):
"""
Custom logger to add 'write' method.
"""
def write(self, msg, *args, **kwargs):
self._log(ORDINARY, msg, args, **kwargs)
class Log(object):
"""
class for create stream logger and file logger
"""
def __init__(self, logger=None):
"""
@param logger: logger instance,
example: logging.getLogger('root')
@type logger: logger (default:None)
@param logLevel: the logger's level
@type logLevel: str type(default:'debug')
"""
if not logger:
logName = _getCallerStatus()[0]
self.log = CgLogger(logName)
self._createStreamLogger()
def _getLogLevel(self):
if os.environ.get('DEBUG'):
logLevel = logging.DEBUG
elif os.environ.get('INFO'):
logLevel = logging.INFO
elif os.environ.get('WARNING'):
logLevel = logging.WARNING
elif os.environ.get('ERROR'):
logLevel = logging.ERROR
elif os.environ.get('CRITICAL'):
logLevel = logging.CRITICAL
else:
logLevel = ORDINARY
return logLevel
def _createStreamLogger(self):
"""
create default stream logger
"""
# create console handler and set level to debug
handler = logging.StreamHandler()
handler.setLevel(self._getLogLevel())
# create formatter
formatter = logging.Formatter("%(levelname)s %(asctime)s %(message)s")
# add formatter to handler
handler.setFormatter(formatter)
# add handler to logger
self.handler = handler
self.log.addHandler(handler)
def _createFileLogger(self, logFile=None):
"""
create file logger
@param logFile: file logger path
@type logFile: str (default:None)
"""
self.log.propagate = False
# use temp file as logger file if user not set
if not logFile:
logFile = createTempFile()
print('log:{0}'.format(logFile))
handler = logging.handlers.RotatingFileHandler(logFile,
maxBytes=2097152,
backupCount=5)
handler.setLevel(self._getLogLevel())
formatter = logging.Formatter('(%(asctime)s %(filename)s[line:)'
'(%(lineno)d] %(levelname)s %(message)s)')
handler.setFormatter(formatter)
self.log.addHandler(handler)
self.handler = handler
def __getLogger(logger=None, logFile=None, **kwargs):
if logger is None:
logger = Log().log
return logger
# Converience functions
def info(msg, **kwargs):
__getLogger(**kwargs).info(msg)
def debug(msg, **kwargs):
__getLogger(**kwargs).debug(msg)
def write(msg, **kwargs):
__getLogger(**kwargs).write(msg)
def warn(msg, **kwargs):
__getLogger(**kwargs).warn(msg)
def error(msg, **kwargs):
__getLogger(**kwargs).error(msg)
def critical(msg, **kwargs):
__getLogger(**kwargs).critical(msg)