xref: /unit/src/nxt_log.h (revision 63:b79fe37d9f24)
1 
2 /*
3  * Copyright (C) Igor Sysoev
4  * Copyright (C) NGINX, Inc.
5  */
6 
7 #ifndef _NXT_LOG_H_INCLUDED_
8 #define _NXT_LOG_H_INCLUDED_
9 
10 
11 #define NXT_LOG_EMERG      0
12 #define NXT_LOG_ALERT      1
13 #define NXT_LOG_CRIT       2
14 #define NXT_LOG_ERR        3
15 #define NXT_LOG_WARN       4
16 #define NXT_LOG_NOTICE     5
17 #define NXT_LOG_INFO       6
18 #define NXT_LOG_DEBUG      7
19 
20 
21 #define NXT_MAX_ERROR_STR  2048
22 
23 
24 typedef void nxt_cdecl (*nxt_log_handler_t)(nxt_uint_t level, nxt_log_t *log,
25     const char *fmt, ...);
26 typedef u_char *(*nxt_log_ctx_handler_t)(void *ctx, u_char *pos, u_char *end);
27 
28 
29 struct nxt_log_s {
30     uint32_t               level;
31     uint32_t               ident;
32     nxt_log_handler_t      handler;
33     nxt_log_ctx_handler_t  ctx_handler;
34     void                   *ctx;
35 };
36 
37 
38 NXT_EXPORT void nxt_log_start(const char *name);
39 NXT_EXPORT nxt_log_t *nxt_log_set_ctx(nxt_log_t *log,
40     nxt_log_ctx_handler_t handler, void *ctx);
41 
42 NXT_EXPORT void nxt_cdecl nxt_log_handler(nxt_uint_t level, nxt_log_t *log,
43     const char *fmt, ...);
44 
45 
46 #define                                                                       \
47 nxt_log_level_enough(log, level)                                              \
48     ((log)->level >= (level))
49 
50 
51 #define                                                                       \
52 nxt_log_emerg(_log, ...)                                                      \
53     do {                                                                      \
54         nxt_log_t  *_log_ = (_log);                                           \
55                                                                               \
56         _log_->handler(NXT_LOG_EMERG, _log_, __VA_ARGS__);                    \
57     } while (0)
58 
59 
60 #define                                                                       \
61 nxt_log_alert(_log, ...)                                                      \
62     do {                                                                      \
63         nxt_log_t  *_log_ = (_log);                                           \
64                                                                               \
65         _log_->handler(NXT_LOG_ALERT, _log_, __VA_ARGS__);                    \
66     } while (0)
67 
68 
69 #define nxt_log(task, _level, ...)                                            \
70     do {                                                                      \
71         nxt_log_t   *log = (task)->log;                                       \
72         nxt_uint_t  _level_ = (_level);                                       \
73                                                                               \
74         if (nxt_slow_path(log->level >= _level_)) {                           \
75             log->handler(_level_, log, __VA_ARGS__);                          \
76         }                                                                     \
77     } while (0)
78 
79 
80 #define nxt_trace(task, ...)                                                  \
81     do {                                                                      \
82         nxt_log_t  *log = (task)->log;                                        \
83                                                                               \
84         if (nxt_slow_path(log->level >= NXT_LOG_NOTICE || nxt_trace)) {       \
85             log->handler(NXT_LOG_NOTICE, log, __VA_ARGS__);                   \
86         }                                                                     \
87     } while (0)
88 
89 
90 #define                                                                       \
91 nxt_log_error(_level, _log, ...)                                              \
92     do {                                                                      \
93         nxt_log_t   *_log_ = (_log);                                          \
94         nxt_uint_t  _level_ = (_level);                                       \
95                                                                               \
96         if (nxt_slow_path(_log_->level >= _level_)) {                         \
97             _log_->handler(_level_, _log_, __VA_ARGS__);                      \
98         }                                                                     \
99     } while (0)
100 
101 
102 #if (NXT_DEBUG)
103 
104 #define nxt_debug(task, ...)                                                  \
105     do {                                                                      \
106         nxt_log_t  *log = (task)->log;                                        \
107                                                                               \
108         if (nxt_slow_path(log->level == NXT_LOG_DEBUG || nxt_debug)) {        \
109             log->handler(NXT_LOG_DEBUG, log, __VA_ARGS__);                    \
110         }                                                                     \
111     } while (0)
112 
113 
114 #define                                                                       \
115 nxt_log_debug(_log, ...)                                                      \
116     do {                                                                      \
117         nxt_log_t  *_log_ = (_log);                                           \
118                                                                               \
119         if (nxt_slow_path(_log_->level == NXT_LOG_DEBUG || nxt_debug)) {      \
120             _log_->handler(NXT_LOG_DEBUG, _log_, __VA_ARGS__);                \
121         }                                                                     \
122     } while (0)
123 
124 
125 #define nxt_debug_alloc(...)
126 
127 #else
128 
129 #define nxt_debug(...)
130 #define nxt_debug_alloc(...)
131 
132 #define                                                                       \
133 nxt_log_debug(...)
134 
135 #endif
136 
137 
138 #define                                                                       \
139 nxt_main_log_emerg(...)                                                       \
140     nxt_log_emerg(&nxt_main_log, __VA_ARGS__)
141 
142 
143 #define                                                                       \
144 nxt_main_log_alert(...)                                                       \
145     nxt_log_alert(&nxt_main_log, __VA_ARGS__)
146 
147 
148 #define                                                                       \
149 nxt_main_log_error(level, ...)                                                \
150     nxt_log_error(level, &nxt_main_log, __VA_ARGS__)
151 
152 
153 #define                                                                       \
154 nxt_main_log_debug(...)                                                       \
155     nxt_log_debug(&nxt_main_log, __VA_ARGS__)
156 
157 
158 NXT_EXPORT extern nxt_uint_t  nxt_debug;
159 NXT_EXPORT extern nxt_uint_t  nxt_trace;
160 NXT_EXPORT extern nxt_log_t   nxt_main_log;
161 NXT_EXPORT extern nxt_str_t   nxt_log_levels[];
162 
163 
164 #endif /* _NXT_LOG_H_INCLUDED_ */
165