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
|
/* +------------------------------------+
* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
* InspIRCd: (C) 2002-2008 InspIRCd Development Team
* See: http://www.inspircd.org/wiki/index.php/Credits
*
* This program is free but copyrighted software; see
* the file COPYING for details.
*
* ---------------------------------------------------
*/
/* $Core: libIRCDlogger */
#include "inspircd.h"
/*
* Suggested implementation...
* class LogManager
* bool AddLogType(const std::string &type, enum loglevel, LogStream *)
* bool DelLogType(const std::string &type, LogStream *)
* Log(const std::string &type, enum loglevel, const std::string &msg)
* std::map<std::string, std::vector<LogStream *> > logstreams (holds a 'chain' of logstreams for each type that are all notified when a log happens)
*
* class LogStream
* std::string type
* virtual void OnLog(enum loglevel, const std::string &msg)
*
* How it works:
* Modules create their own logstream types (core will create one for 'file logging' for example) and create instances of these logstream types
* and register interest in a certain logtype. Globbing is not here, with the exception of * - for all events.. loglevel is used to drop
* events that are of no interest to a logstream.
*
* When Log is called, the vector of logstreams for that type is iterated (along with the special vector for "*"), and all registered logstreams
* are called back ("OnLog" or whatever) to do whatever they like with the message. In the case of the core, this will write to a file.
* In the case of the module I plan to write (m_logtochannel or something), it will log to the channel(s) for that logstream, etc.
*
* NOTE: Somehow we have to let LogManager manage the non-blocking file streams and provide an interface to share them with various LogStreams,
* as, for example, a user may want to let 'KILL' and 'XLINE' snotices go to /home/ircd/inspircd/logs/operactions.log, or whatever. How
* can we accomplish this easily? I guess with a map of pre-loved logpaths, and a pointer of FILE *..
*
*/
void LogManager::CloseLogs()
{
/*
* This doesn't remove logstreams from the map/vector etc, because if this is called, shit is hitting the fan
* and we're going down anyway - this just provides a "nice" way for logstreams to clean up. -- w
*/
std::map<std::string, std::vector<LogStream *> >::iterator i;
while (LogStreams.begin() != LogStreams.end())
{
i = LogStreams.begin();
while (i->second.begin() != i->second.end())
{
std::vector<LogStream *>::iterator it = i->second.begin();
delete (*it);
i->second.erase(it);
}
LogStreams.erase(i);
}
}
bool LogManager::AddLogType(const std::string &type, LogStream *l)
{
std::map<std::string, std::vector<LogStream *> >::iterator i = LogStreams.find(type);
if (i != LogStreams.end())
i->second.push_back(l);
else
{
std::vector<LogStream *> v;
v.push_back(l);
LogStreams[type] = v;
}
if (type == "*")
GlobalLogStreams.push_back(l);
return true;
}
bool LogManager::DelLogType(const std::string &type, LogStream *l)
{
std::map<std::string, std::vector<LogStream *> >::iterator i = LogStreams.find(type);
std::vector<LogStream *>::iterator gi = GlobalLogStreams.begin();
while (gi != GlobalLogStreams.end())
{
if ((*gi) == l)
{
GlobalLogStreams.erase(gi);
break;
}
}
if (i != LogStreams.end())
{
std::vector<LogStream *>::iterator it = i->second.begin();
while (it != i->second.end())
{
if (*it == l)
{
i->second.erase(it);
if (i->second.size() == 0)
{
LogStreams.erase(i);
}
delete l;
return true;
}
it++;
}
}
return false;
}
void LogManager::Log(const std::string &type, int loglevel, const char *fmt, ...)
{
if (Logging)
return;
va_list a;
static char buf[65536];
va_start(a, fmt);
vsnprintf(buf, 65536, fmt, a);
va_end(a);
this->Log(type, loglevel, std::string(buf));
}
void LogManager::Log(const std::string &type, int loglevel, const std::string &msg)
{
if (Logging)
return;
Logging = true;
std::vector<LogStream *>::iterator gi = GlobalLogStreams.begin();
while (gi != GlobalLogStreams.end())
{
(*gi)->OnLog(loglevel, type, msg);
gi++;
}
std::map<std::string, std::vector<LogStream *> >::iterator i = LogStreams.find(type);
if (i != LogStreams.end())
{
std::vector<LogStream *>::iterator it = i->second.begin();
while (it != i->second.end())
{
(*it)->OnLog(loglevel, type, msg);
it++;
}
}
Logging = false;
}
|
