]> mj.ucw.cz Git - moe.git/blob - ucw/log-conf.c
Updated libucw to current version (Sherlock commit 17f29eb1ab186e9f053299c25f47ce368e...
[moe.git] / ucw / log-conf.c
1 /*
2  *      UCW Library -- Logging: Configuration of Log Streams
3  *
4  *      (c) 2009 Martin Mares <mj@ucw.cz>
5  *
6  *      This software may be freely distributed and used according to the terms
7  *      of the GNU Lesser General Public License.
8  */
9
10 #include "ucw/lib.h"
11 #include "ucw/log.h"
12 #include "ucw/log-internal.h"
13 #include "ucw/conf.h"
14 #include "ucw/simple-lists.h"
15 #include "ucw/tbf.h"
16 #include "ucw/threads.h"
17
18 #include <stdio.h>
19 #include <string.h>
20 #include <syslog.h>
21 #include <sys/time.h>
22
23 /*** Configuration of streams ***/
24
25 struct stream_config {
26   cnode n;
27   char *name;
28   char *file_name;
29   char *syslog_facility;
30   u32 levels;
31   clist types;                          // simple_list of names
32   clist substreams;                     // simple_list of names
33   clist limits;                         // of struct limit_config's
34   int microseconds;                     // Enable logging of precise timestamps
35   int show_types;
36   int syslog_pids;
37   int errors_fatal;
38   int stderr_follows;
39   struct log_stream *ls;
40   int mark;                             // Used temporarily in log_config_commit()
41 };
42
43 struct limit_config {
44   cnode n;
45   clist types;                          // simple_list of names
46   double rate;
47   uns burst;
48 };
49
50 static char *
51 stream_init(void *ptr)
52 {
53   struct stream_config *c = ptr;
54
55   c->levels = ~0U;
56   return NULL;
57 }
58
59 static char *
60 stream_commit(void *ptr)
61 {
62   struct stream_config *c = ptr;
63
64   if (c->syslog_facility)
65     {
66       if (!log_syslog_facility_exists(c->syslog_facility))
67         return cf_printf("SyslogFacility `%s' is not recognized", c->syslog_facility);
68       if (c->file_name)
69         return "Both FileName and SyslogFacility selected";
70       if (c->microseconds)
71         return "Syslog streams do not support microsecond precision";
72     }
73   if (c->stderr_follows && !c->file_name)
74     return "StdErrFollows requires a file-based stream";
75   return NULL;
76 }
77
78 static const char * const level_names[] = {
79 #define P(x) #x,
80   LOG_LEVEL_NAMES
81 #undef P
82   NULL
83 };
84
85 static struct cf_section limit_config = {
86   CF_TYPE(struct limit_config),
87   CF_ITEMS {
88 #define P(x) PTR_TO(struct limit_config, x)
89     CF_LIST("Types", P(types), &cf_string_list_config),
90     CF_DOUBLE("Rate", P(rate)),
91     CF_UNS("Burst", P(burst)),
92 #undef P
93     CF_END
94   }
95 };
96
97 static struct cf_section stream_config = {
98   CF_TYPE(struct stream_config),
99   CF_INIT(stream_init),
100   CF_COMMIT(stream_commit),
101   CF_ITEMS {
102 #define P(x) PTR_TO(struct stream_config, x)
103     CF_STRING("Name", P(name)),
104     CF_STRING("FileName", P(file_name)),
105     CF_STRING("SyslogFacility", P(syslog_facility)),
106     CF_BITMAP_LOOKUP("Levels", P(levels), level_names),
107     CF_LIST("Types", P(types), &cf_string_list_config),
108     CF_LIST("Substream", P(substreams), &cf_string_list_config),
109     CF_LIST("Limit", P(limits), &limit_config),
110     CF_INT("Microseconds", P(microseconds)),
111     CF_INT("ShowTypes", P(show_types)),
112     CF_INT("SyslogPID", P(syslog_pids)),
113     CF_INT("ErrorsFatal", P(errors_fatal)),
114     CF_INT("StdErrFollows", P(stderr_follows)),
115 #undef P
116     CF_END
117   }
118 };
119
120 static clist log_stream_confs;
121
122 static struct stream_config *
123 stream_find(const char *name)
124 {
125   CLIST_FOR_EACH(struct stream_config *, c, log_stream_confs)
126     if (!strcmp(c->name, name))
127       return c;
128   return NULL;
129 }
130
131 static char *
132 stream_resolve(struct stream_config *c)
133 {
134   if (c->mark == 2)
135     return NULL;
136   if (c->mark == 1)
137     return cf_printf("Log stream `%s' has substreams which refer to itself", c->name);
138
139   c->mark = 1;
140   char *err;
141   CLIST_FOR_EACH(simp_node *, s, c->substreams)
142     {
143       struct stream_config *d = stream_find(s->s);
144       if (!d)
145         return cf_printf("Log stream `%s' refers to unknown substream `%s'", c->name, s->s);
146       if (err = stream_resolve(d))
147         return err;
148     }
149   c->mark = 2;
150   return NULL;
151 }
152
153 static char *
154 log_config_commit(void *ptr UNUSED)
155 {
156   // Verify uniqueness of names
157   CLIST_FOR_EACH(struct stream_config *, c, log_stream_confs)
158     if (stream_find(c->name) != c)
159       return cf_printf("Log stream `%s' defined twice", c->name);
160
161   // Check that all substreams resolve and that there are no cycles
162   char *err;
163   CLIST_FOR_EACH(struct stream_config *, c, log_stream_confs)
164     if (err = stream_resolve(c))
165       return err;
166
167   return NULL;
168 }
169
170 static struct cf_section log_config = {
171   CF_COMMIT(log_config_commit),
172   CF_ITEMS {
173     CF_LIST("Stream", &log_stream_confs, &stream_config),
174     CF_END
175   }
176 };
177
178 static void CONSTRUCTOR
179 log_config_init(void)
180 {
181   cf_declare_section("Logging", &log_config, 0);
182 }
183
184 /*** Type sets ***/
185
186 static uns
187 log_type_mask(clist *l)
188 {
189   if (clist_empty(l))
190     return ~0U;
191
192   uns types = 0;
193   CLIST_FOR_EACH(simp_node *, s, *l)
194     if (!strcmp(s->s, "all"))
195       return ~0U;
196     else
197       {
198         /*
199          *  We intentionally ignore unknown types as not all types are known
200          *  to all programs sharing a common configuration file. This is also
201          *  the reason why Types is a list and not a bitmap.
202          */
203         int type = log_find_type(s->s);
204         if (type >= 0)
205           types |= 1 << LS_GET_TYPE(type);
206       }
207   return types;
208 }
209
210 /*** Generating limiters ***/
211
212 /*
213  *  When limiting is enabled, we let log_stream->filter point to this function
214  *  and log_stream->user_data point to an array of pointers to token bucket
215  *  filters for individual message types.
216  */
217 static int
218 log_limiter(struct log_stream *ls, struct log_msg *m)
219 {
220   struct token_bucket_filter **limits = ls->user_data;
221   if (!limits)
222     return 0;
223   struct token_bucket_filter *tbf = limits[LS_GET_TYPE(m->flags)];
224   if (!tbf)
225     return 0;
226
227   ASSERT(!(m->flags & L_SIGHANDLER));
228   if (m->flags & L_LOGGER_ERR)
229     return 0;
230
231   timestamp_t now = ((timestamp_t) m->tv->tv_sec * 1000) + (m->tv->tv_usec / 1000);
232   ucwlib_lock();
233   int res = tbf_limit(tbf, now);
234   ucwlib_unlock();
235
236   if (res < 0)
237     {
238       if (res == -1)
239         {
240           struct log_msg mm = *m;
241           mm.flags |= L_LOGGER_ERR;
242           mm.raw_msg = "(maximum logging rate exceeded, some messages will be suppressed)";
243           log_pass_msg(0, ls, &mm);
244         }
245       return 1;
246     }
247   else
248     return 0;
249 }
250
251 static void
252 log_apply_limits(struct log_stream *ls, struct limit_config *lim)
253 {
254   uns mask = log_type_mask(&lim->types);
255   if (!mask)
256     return;
257
258   if (!ls->user_data)
259     {
260       ls->user_data = cf_malloc_zero(LS_NUM_TYPES * sizeof(struct token_bucket_filter *));
261       ls->filter = log_limiter;
262     }
263   struct token_bucket_filter **limits = ls->user_data;
264   struct token_bucket_filter *tbf = cf_malloc_zero(sizeof(*lim));
265   tbf->rate = lim->rate;
266   tbf->burst = lim->burst;
267   tbf_init(tbf);
268
269   for (uns i=0; i < LS_NUM_TYPES; i++)
270     if (mask & (1 << i))
271       limits[i] = tbf;
272 }
273
274 /*** Generating streams ***/
275
276 char *
277 log_check_configured(const char *name)
278 {
279   if (stream_find(name))
280     return NULL;
281   else
282     return cf_printf("Log stream `%s' not found", name);
283 }
284
285 static struct log_stream *
286 do_new_configured(struct stream_config *c)
287 {
288   struct log_stream *ls;
289   ASSERT(c);
290
291   if (c->ls)
292     return c->ls;
293
294   if (c->file_name)
295     ls = log_new_file(c->file_name, (c->stderr_follows ? FF_FD2_FOLLOWS : 0));
296   else if (c->syslog_facility)
297     ls = log_new_syslog(c->syslog_facility, (c->syslog_pids ? LOG_PID : 0));
298   else
299     ls = log_new_stream(sizeof(*ls));
300
301   CLIST_FOR_EACH(simp_node *, s, c->substreams)
302     log_add_substream(ls, do_new_configured(stream_find(s->s)));
303
304   ls->levels = c->levels;
305   if (c->microseconds)
306     ls->msgfmt |= LSFMT_USEC;
307   if (c->show_types)
308     ls->msgfmt |= LSFMT_TYPE;
309   if (c->errors_fatal)
310     ls->stream_flags |= LSFLAG_ERR_IS_FATAL;
311   ls->types = log_type_mask(&c->types);
312
313   CLIST_FOR_EACH(struct limit_config *, lim, c->limits)
314     log_apply_limits(ls, lim);
315
316   c->ls = ls;
317   return ls;
318 }
319
320 struct log_stream *
321 log_new_configured(const char *name)
322 {
323   struct stream_config *c = stream_find(name);
324   if (!c)
325     die("Unable to find log stream %s", name);
326   if (c->ls)
327     return log_ref_stream(c->ls);
328   return do_new_configured(c);
329 }
330
331 void
332 log_configured(const char *name)
333 {
334   struct log_stream *ls = log_new_configured(name);
335   struct log_stream *def = log_stream_by_flags(0);
336   log_rm_substream(def, NULL);
337   log_add_substream(def, ls);
338   log_close_stream(ls);
339 }
340
341 #ifdef TEST
342
343 #include <unistd.h>
344 #include "ucw/getopt.h"
345
346 int main(int argc, char **argv)
347 {
348   log_init(argv[0]);
349   int c;
350   while ((c = cf_getopt(argc, argv, CF_SHORT_OPTS, CF_NO_LONG_OPTS, NULL)) >= 0)
351     die("No options here.");
352
353   int type = log_register_type("foo");
354   struct log_stream *ls = log_new_configured("combined");
355   for (uns i=0; i<10; i++)
356     {
357       msg(L_INFO | ls->regnum | type, "Hello, universe!");
358       usleep(200000);
359     }
360   fprintf(stderr, "Alas, this was printed to stderr.\n");
361
362   log_close_all();
363   return 0;
364 }
365
366 #endif