]>
Commit | Line | Data |
---|---|---|
7c673cae | 1 | #include <syslog.h> |
7c673cae FG |
2 | #include <boost/algorithm/string/predicate.hpp> |
3 | ||
4 | #include "LogEntry.h" | |
5 | #include "Formatter.h" | |
7c673cae FG |
6 | #include "include/stringify.h" |
7 | ||
8 | // ---- | |
9 | // LogEntryKey | |
10 | ||
11 | void LogEntryKey::encode(bufferlist& bl, uint64_t features) const | |
12 | { | |
13 | ::encode(who, bl, features); | |
14 | ::encode(stamp, bl); | |
15 | ::encode(seq, bl); | |
16 | } | |
17 | ||
18 | void LogEntryKey::decode(bufferlist::iterator& bl) | |
19 | { | |
20 | ::decode(who, bl); | |
21 | ::decode(stamp, bl); | |
22 | ::decode(seq, bl); | |
31f18b77 | 23 | _calc_hash(); |
7c673cae FG |
24 | } |
25 | ||
26 | void LogEntryKey::dump(Formatter *f) const | |
27 | { | |
28 | f->dump_stream("who") << who; | |
29 | f->dump_stream("stamp") << stamp; | |
30 | f->dump_unsigned("seq", seq); | |
31 | } | |
32 | ||
33 | void LogEntryKey::generate_test_instances(list<LogEntryKey*>& o) | |
34 | { | |
35 | o.push_back(new LogEntryKey); | |
36 | o.push_back(new LogEntryKey(entity_inst_t(), utime_t(1,2), 34)); | |
37 | } | |
38 | ||
39 | // ---- | |
40 | ||
41 | int clog_type_to_syslog_level(clog_type t) | |
42 | { | |
43 | switch (t) { | |
44 | case CLOG_DEBUG: | |
45 | return LOG_DEBUG; | |
46 | case CLOG_INFO: | |
47 | return LOG_INFO; | |
48 | case CLOG_WARN: | |
49 | return LOG_WARNING; | |
50 | case CLOG_ERROR: | |
51 | return LOG_ERR; | |
52 | case CLOG_SEC: | |
53 | return LOG_CRIT; | |
54 | default: | |
55 | ceph_abort(); | |
56 | return 0; | |
57 | } | |
58 | } | |
59 | ||
60 | clog_type string_to_clog_type(const string& s) | |
61 | { | |
62 | if (boost::iequals(s, "debug") || | |
63 | boost::iequals(s, "dbg")) | |
64 | return CLOG_DEBUG; | |
65 | if (boost::iequals(s, "info") || | |
66 | boost::iequals(s, "inf")) | |
67 | return CLOG_INFO; | |
68 | if (boost::iequals(s, "warning") || | |
69 | boost::iequals(s, "warn") || | |
70 | boost::iequals(s, "wrn")) | |
71 | return CLOG_WARN; | |
72 | if (boost::iequals(s, "error") || | |
73 | boost::iequals(s, "err")) | |
74 | return CLOG_ERROR; | |
75 | if (boost::iequals(s, "security") || | |
76 | boost::iequals(s, "sec")) | |
77 | return CLOG_SEC; | |
78 | ||
79 | return CLOG_UNKNOWN; | |
80 | } | |
81 | ||
82 | int string_to_syslog_level(string s) | |
83 | { | |
84 | if (boost::iequals(s, "debug")) | |
85 | return LOG_DEBUG; | |
86 | if (boost::iequals(s, "info") || | |
87 | boost::iequals(s, "notice")) | |
88 | return LOG_INFO; | |
89 | if (boost::iequals(s, "warning") || | |
90 | boost::iequals(s, "warn")) | |
91 | return LOG_WARNING; | |
92 | if (boost::iequals(s, "error") || | |
93 | boost::iequals(s, "err")) | |
94 | return LOG_ERR; | |
95 | if (boost::iequals(s, "crit") || | |
96 | boost::iequals(s, "critical") || | |
97 | boost::iequals(s, "emerg")) | |
98 | return LOG_CRIT; | |
99 | ||
100 | // err on the side of noise! | |
101 | return LOG_DEBUG; | |
102 | } | |
103 | ||
104 | int string_to_syslog_facility(string s) | |
105 | { | |
106 | if (boost::iequals(s, "auth")) | |
107 | return LOG_AUTH; | |
108 | if (boost::iequals(s, "authpriv")) | |
109 | return LOG_AUTHPRIV; | |
110 | if (boost::iequals(s, "cron")) | |
111 | return LOG_CRON; | |
112 | if (boost::iequals(s, "daemon")) | |
113 | return LOG_DAEMON; | |
114 | if (boost::iequals(s, "ftp")) | |
115 | return LOG_FTP; | |
116 | if (boost::iequals(s, "kern")) | |
117 | return LOG_KERN; | |
118 | if (boost::iequals(s, "local0")) | |
119 | return LOG_LOCAL0; | |
120 | if (boost::iequals(s, "local1")) | |
121 | return LOG_LOCAL1; | |
122 | if (boost::iequals(s, "local2")) | |
123 | return LOG_LOCAL2; | |
124 | if (boost::iequals(s, "local3")) | |
125 | return LOG_LOCAL3; | |
126 | if (boost::iequals(s, "local4")) | |
127 | return LOG_LOCAL4; | |
128 | if (boost::iequals(s, "local5")) | |
129 | return LOG_LOCAL5; | |
130 | if (boost::iequals(s, "local6")) | |
131 | return LOG_LOCAL6; | |
132 | if (boost::iequals(s, "local7")) | |
133 | return LOG_LOCAL7; | |
134 | if (boost::iequals(s, "lpr")) | |
135 | return LOG_LPR; | |
136 | if (boost::iequals(s, "mail")) | |
137 | return LOG_MAIL; | |
138 | if (boost::iequals(s, "news")) | |
139 | return LOG_NEWS; | |
140 | if (boost::iequals(s, "syslog")) | |
141 | return LOG_SYSLOG; | |
142 | if (boost::iequals(s, "user")) | |
143 | return LOG_USER; | |
144 | if (boost::iequals(s, "uucp")) | |
145 | return LOG_UUCP; | |
146 | ||
147 | // default to USER | |
148 | return LOG_USER; | |
149 | } | |
150 | ||
151 | string clog_type_to_string(clog_type t) | |
152 | { | |
153 | switch (t) { | |
154 | case CLOG_DEBUG: | |
155 | return "debug"; | |
156 | case CLOG_INFO: | |
157 | return "info"; | |
158 | case CLOG_WARN: | |
159 | return "warn"; | |
160 | case CLOG_ERROR: | |
161 | return "err"; | |
162 | case CLOG_SEC: | |
163 | return "crit"; | |
164 | default: | |
165 | ceph_abort(); | |
166 | return 0; | |
167 | } | |
168 | } | |
169 | ||
170 | void LogEntry::log_to_syslog(string level, string facility) | |
171 | { | |
172 | int min = string_to_syslog_level(level); | |
173 | int l = clog_type_to_syslog_level(prio); | |
174 | if (l <= min) { | |
175 | int f = string_to_syslog_facility(facility); | |
176 | syslog(l | f, "%s %llu : %s", | |
177 | stringify(who).c_str(), | |
178 | (long long unsigned)seq, | |
179 | msg.c_str()); | |
180 | } | |
181 | } | |
182 | ||
183 | void LogEntry::encode(bufferlist& bl, uint64_t features) const | |
184 | { | |
31f18b77 | 185 | ENCODE_START(4, 2, bl); |
7c673cae FG |
186 | __u16 t = prio; |
187 | ::encode(who, bl, features); | |
188 | ::encode(stamp, bl); | |
189 | ::encode(seq, bl); | |
190 | ::encode(t, bl); | |
191 | ::encode(msg, bl); | |
192 | ::encode(channel, bl); | |
31f18b77 | 193 | ::encode(name, bl); |
7c673cae FG |
194 | ENCODE_FINISH(bl); |
195 | } | |
196 | ||
197 | void LogEntry::decode(bufferlist::iterator& bl) | |
198 | { | |
31f18b77 | 199 | DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl); |
7c673cae FG |
200 | __u16 t; |
201 | ::decode(who, bl); | |
202 | ::decode(stamp, bl); | |
203 | ::decode(seq, bl); | |
204 | ::decode(t, bl); | |
205 | prio = (clog_type)t; | |
206 | ::decode(msg, bl); | |
207 | if (struct_v >= 3) { | |
208 | ::decode(channel, bl); | |
209 | } else { | |
210 | // prior to having logging channels we only had a cluster log. | |
211 | // Ensure we keep that appearance when the other party has no | |
212 | // clue of what a 'channel' is. | |
213 | channel = CLOG_CHANNEL_CLUSTER; | |
214 | } | |
31f18b77 FG |
215 | if (struct_v >= 4) { |
216 | ::decode(name, bl); | |
217 | } | |
7c673cae FG |
218 | DECODE_FINISH(bl); |
219 | } | |
220 | ||
221 | void LogEntry::dump(Formatter *f) const | |
222 | { | |
223 | f->dump_stream("who") << who; | |
31f18b77 | 224 | f->dump_stream("name") << name; |
7c673cae FG |
225 | f->dump_stream("stamp") << stamp; |
226 | f->dump_unsigned("seq", seq); | |
227 | f->dump_string("channel", channel); | |
228 | f->dump_stream("priority") << prio; | |
229 | f->dump_string("message", msg); | |
230 | } | |
231 | ||
232 | void LogEntry::generate_test_instances(list<LogEntry*>& o) | |
233 | { | |
234 | o.push_back(new LogEntry); | |
235 | } | |
236 | ||
237 | ||
238 | // ----- | |
239 | ||
240 | void LogSummary::encode(bufferlist& bl, uint64_t features) const | |
241 | { | |
242 | ENCODE_START(2, 2, bl); | |
243 | ::encode(version, bl); | |
244 | ::encode(tail, bl, features); | |
245 | ENCODE_FINISH(bl); | |
246 | } | |
247 | ||
248 | void LogSummary::decode(bufferlist::iterator& bl) | |
249 | { | |
250 | DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl); | |
251 | ::decode(version, bl); | |
252 | ::decode(tail, bl); | |
253 | DECODE_FINISH(bl); | |
31f18b77 FG |
254 | keys.clear(); |
255 | for (auto& p : tail) { | |
256 | keys.insert(p.key()); | |
257 | } | |
7c673cae FG |
258 | } |
259 | ||
260 | void LogSummary::dump(Formatter *f) const | |
261 | { | |
262 | f->dump_unsigned("version", version); | |
263 | f->open_array_section("tail"); | |
264 | for (list<LogEntry>::const_iterator p = tail.begin(); p != tail.end(); ++p) { | |
265 | f->open_object_section("entry"); | |
266 | p->dump(f); | |
267 | f->close_section(); | |
268 | } | |
269 | f->close_section(); | |
270 | } | |
271 | ||
272 | void LogSummary::generate_test_instances(list<LogSummary*>& o) | |
273 | { | |
274 | o.push_back(new LogSummary); | |
275 | // more! | |
276 | } |