/
pylogger.py
196 lines (149 loc) · 5.65 KB
/
pylogger.py
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
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
import time
import os
from datetime import datetime
__version__ = '0.1'
class PyLogger():
"""The PyLogger class"""
def __init__(self,filename='pylogger.log',
defaultlogtype='INFO',
logformat='[{timestamp}] {logtype}: {message}',
timestamp='%Y-%m-%d %H:%M:%S',
prefix='',
postfix='\n'):
"""Initialize a PyLogger object.
:param filename: The filename to use
:type filename: str
:param defaultlogtype: Initial log type to use [INFO]
:type defaultlogtype: str
:param timestamp: Initial timestamp format [%Y-%m-%d %H:%M:%S]
:type timestamp: str
:param prefix: String to insert before the log message
:type prefix: str
:param postfix: String to append to the log message
:type postfix: str
"""
self.fileName = filename
self.logType = defaultlogtype
self.logFormat = logformat
self.timeStamp = timestamp
self.postfix = postfix
self.prefix = prefix
self.enabled = False
def open(self, *args):
"""Initialize a new logger"""
self.__init__(*args)
def clear(self):
"""Clear the content of the log file
:returns: True -- file cleared
:raises: IOError, Exception
"""
try:
open(self.fileName, 'w').close()
return True
except IOError, e:
raise Exception("Could not clear log file: {0}\nInfo: {1}".format(self.fileName, e))
def delete(self):
"""Delete the log file
:returns: True -- file deleted
:raises: OSError, Exception
"""
try:
if os.path.isfile(self.fileName):
os.remove(self.fileName)
except OSError, e:
raise Exception("Could not delete log file: {0}\nInfo: {1}".format(self.fileName, e))
def pause(self):
"""Pause the logging until resumed"""
self.enabled = False
def isEnabled(self):
"""Check if enabled/paused
:returns: True -- enabled
"""
return self.enabled
def resume(self):
"""Resume the logging from paused"""
self.enabled = True
def setLogType(self, logtype):
"""Set the log type
:param logtype: Log type
:type logtype: str
"""
self.logType = logtype
def setLogFormat(self, logformat):
"""Set custom log format
:param logformat: Log format
Available options: {timestamp}, {logtype}, {message}
Example: [{timestamp}]{logtype}: {message}
:type logformat: str
"""
self.logFormat = logformat
def resetLogFormat(self):
"""Reset log format to default format"""
self.logFormat = '[{timestamp}]{logtype}: {message}'
def setTimestampFormat(self, timestamp):
"""Set custom timestamp format
:param timestamp: Timestamp
Example: %Y-%m-%d %H:%M:%S
:type timestamp: str
"""
self.timeStamp = timestamp
def resetTimestampFormat(self):
"""Reset timestamp format"""
self.timeStamp = '%Y-%m-%d %H:%M:%S'
def getTimeStamp(self):
"""Function to get the current time, returns in the timestamp format
:returns: Timestamp string
"""
if len(self.timeStamp) >= 2:
ts = datetime.fromtimestamp(time.time()).strftime(self.timeStamp)
return ts
else:
return ''
def createIfNonExistent(self):
"""Create an empty log file if non existant
:returns: True -- file cleared
:raises: IOError, Exception
"""
if not os.path.isfile(self.fileName):
return self.clear()
def log(self, logstr, logtype=''):
"""Function to log message to file.
:param logstr: The string you want to log
:type logstr: str
:param logtype: Optional argument, custom log type.
If not provided, defaults to defined log type.
:type logtype: str
:returns: True -- String has been logged to file
:raises: IOError,Exception7
"""
if not self.enabled:
return False
try:
self.createIfNonExistent()
cLogType = self.logType
if logtype != '':
cLogType = logtype
logMessage = self.logFormat.format(timestamp=self.getTimeStamp(),
logtype=cLogType,
message=logstr)
with open(self.fileName, 'a') as f:
f.write(self.prefix + logMessage + self.postfix)
f.close()
return True
except IOError, e:
raise Exception("Could not save log file: {0}\nDetails: {1}".format(self.fileName, e))
def info(self, logstr):
"""Function that calls the log function with type INFO"""
self.log(logstr, "INFO")
def warning(self, logstr):
"""Function that calls the log function with type WARNING"""
self.log(logstr, "WARNING")
def error(self, logstr):
"""Function that calls the log function with type ERROR"""
self.log(logstr, "ERROR")
def critical(self, logstr):
"""Function that calls the log function with type CRITICAL"""
self.log(logstr, "CRITICAL")
def exception(self, logstr):
"""Function that calls the log function with type EXCEPTION"""
self.log(logstr, "EXCEPTION")