Line data Source code
1 : /*
2 : * If not stated otherwise in this file or this component's LICENSE file the
3 : * following copyright and licenses apply:
4 : *
5 : * Copyright 2022 Sky UK
6 : *
7 : * Licensed under the Apache License, Version 2.0 (the "License");
8 : * you may not use this file except in compliance with the License.
9 : * You may obtain a copy of the License at
10 : *
11 : * http://www.apache.org/licenses/LICENSE-2.0
12 : *
13 : * Unless required by applicable law or agreed to in writing, software
14 : * distributed under the License is distributed on an "AS IS" BASIS,
15 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 : * See the License for the specific language governing permissions and
17 : * limitations under the License.
18 : */
19 :
20 : #include <atomic>
21 : #include <cstdarg>
22 : #include <cstdio>
23 : #include <cstring>
24 : #include <ctime>
25 : #include <mutex>
26 : #include <sys/syscall.h>
27 : #include <sys/uio.h>
28 : #include <unistd.h>
29 :
30 : #include "EnvVariableParser.h"
31 : #include "LogFileHandle.h"
32 : #include "RialtoLogging.h"
33 :
34 : #ifdef USE_ETHANLOG
35 :
36 : #include <ethanlog.h>
37 :
38 : #define SYSTEM_LOG_FATAL(filename, function, line, ...) ethanlog(ETHAN_LOG_FATAL, filename, function, line, __VA_ARGS__)
39 : #define SYSTEM_LOG_ERROR(filename, function, line, ...) ethanlog(ETHAN_LOG_ERROR, filename, function, line, __VA_ARGS__)
40 : #define SYSTEM_LOG_WARN(filename, function, line, ...) \
41 : ethanlog(ETHAN_LOG_WARNING, filename, function, line, __VA_ARGS__)
42 : #define SYSTEM_LOG_MIL(filename, function, line, ...) \
43 : ethanlog(ETHAN_LOG_MILESTONE, filename, function, line, __VA_ARGS__)
44 : #define SYSTEM_LOG_INFO(filename, function, line, ...) ethanlog(ETHAN_LOG_INFO, filename, function, line, __VA_ARGS__)
45 : #define SYSTEM_LOG_DEBUG(filename, function, line, ...) ethanlog(ETHAN_LOG_DEBUG, filename, function, line, __VA_ARGS__)
46 :
47 : #else
48 :
49 : #include <syslog.h>
50 :
51 : #define SYSTEM_LOG_FATAL(filename, function, line, ...) syslog(LOG_CRIT, __VA_ARGS__)
52 : #define SYSTEM_LOG_ERROR(filename, function, line, ...) syslog(LOG_ERR, __VA_ARGS__)
53 : #define SYSTEM_LOG_WARN(filename, function, line, ...) syslog(LOG_WARNING, __VA_ARGS__)
54 : #define SYSTEM_LOG_MIL(filename, function, line, ...) syslog(LOG_NOTICE, __VA_ARGS__)
55 : #define SYSTEM_LOG_INFO(filename, function, line, ...) syslog(LOG_INFO, __VA_ARGS__)
56 : #define SYSTEM_LOG_DEBUG(filename, function, line, ...) syslog(LOG_DEBUG, __VA_ARGS__)
57 :
58 : #endif
59 :
60 : namespace
61 : {
62 : /**
63 : * Log levels for each component. By default will print all fatals, errors, warnings & milestones.
64 : */
65 : std::atomic<RIALTO_DEBUG_LEVEL> g_rialtoLogLevels[RIALTO_COMPONENT_LAST] = {};
66 :
67 : /**
68 : * Default Log levels defined by RIALTO_DEBUG environment variable
69 : */
70 : const firebolt::rialto::logging::EnvVariableParser g_envVariableParser;
71 :
72 : /**
73 : * Log handler for each component. By default will use journaldLogHandler.
74 : */
75 : void fdLogHandler(int fd, RIALTO_COMPONENT component, RIALTO_DEBUG_LEVEL level, const char *file, int line,
76 : const char *function, const char *message, size_t messageLen);
77 : void journaldLogHandler(RIALTO_COMPONENT component, RIALTO_DEBUG_LEVEL level, const char *file, int line,
78 : const char *function, const char *message, size_t messageLen);
79 :
80 : firebolt::rialto::logging::LogHandler g_logHandler[RIALTO_COMPONENT_LAST] = {};
81 : bool g_ignoreLogLevels[RIALTO_COMPONENT_LAST] = {};
82 : std::string g_applicationName{};
83 : std::mutex g_logHandlerMutex;
84 :
85 : std::string componentToString(RIALTO_COMPONENT component);
86 : std::string levelToString(RIALTO_DEBUG_LEVEL level);
87 :
88 10968 : std::string componentToString(RIALTO_COMPONENT component)
89 : {
90 10968 : switch (component)
91 : {
92 7 : case RIALTO_COMPONENT_DEFAULT:
93 14 : return "DEF";
94 : break;
95 3230 : case RIALTO_COMPONENT_CLIENT:
96 6460 : return "CLI";
97 : break;
98 7009 : case RIALTO_COMPONENT_SERVER:
99 14018 : return "SRV";
100 : break;
101 154 : case RIALTO_COMPONENT_IPC:
102 308 : return "IPC";
103 : break;
104 490 : case RIALTO_COMPONENT_SERVER_MANAGER:
105 980 : return "SMG";
106 : break;
107 78 : case RIALTO_COMPONENT_COMMON:
108 156 : return "COM";
109 : break;
110 0 : case RIALTO_COMPONENT_EXTERNAL:
111 0 : return "EXT";
112 : break;
113 0 : default:
114 0 : return "UNK";
115 : break;
116 : }
117 : }
118 :
119 10968 : std::string levelToString(RIALTO_DEBUG_LEVEL level)
120 : {
121 10968 : switch (level)
122 : {
123 2 : case RIALTO_DEBUG_LEVEL_FATAL:
124 4 : return "FTL";
125 : break;
126 1021 : case RIALTO_DEBUG_LEVEL_ERROR:
127 2042 : return "ERR";
128 : break;
129 378 : case RIALTO_DEBUG_LEVEL_WARNING:
130 756 : return "WRN";
131 : break;
132 1139 : case RIALTO_DEBUG_LEVEL_MILESTONE:
133 2278 : return "MIL";
134 : break;
135 1448 : case RIALTO_DEBUG_LEVEL_INFO:
136 2896 : return "NFO";
137 : break;
138 6980 : case RIALTO_DEBUG_LEVEL_DEBUG:
139 13960 : return "DBG";
140 : break;
141 0 : case RIALTO_DEBUG_LEVEL_EXTERNAL:
142 0 : return "EXT";
143 : break;
144 0 : default:
145 0 : return ":";
146 : break;
147 : }
148 : }
149 :
150 : /**
151 : * File descriptor logging function for the library.
152 : */
153 10968 : void fdLogHandler(int fd, RIALTO_COMPONENT component, RIALTO_DEBUG_LEVEL level, const char *file, int line,
154 : const char *function, const char *message, size_t messageLen)
155 : {
156 10968 : timespec ts = {0, 0};
157 10968 : clock_gettime(CLOCK_MONOTONIC, &ts);
158 : struct iovec iov[6];
159 : char tbuf[32];
160 :
161 10968 : iov[0].iov_base = tbuf;
162 10968 : iov[0].iov_len = snprintf(tbuf, sizeof(tbuf), "%.010lu.%.06lu ", ts.tv_sec, ts.tv_nsec / 1000);
163 10968 : iov[0].iov_len = std::min(iov[0].iov_len, sizeof(tbuf));
164 :
165 : char lbuf[8];
166 10968 : iov[1].iov_base = reinterpret_cast<void *>(lbuf);
167 10968 : iov[1].iov_len =
168 10968 : std::min(static_cast<size_t>(snprintf(lbuf, sizeof(lbuf), "%s: ", levelToString(level).c_str())), sizeof(lbuf));
169 :
170 : char cbuf[8];
171 10968 : iov[2].iov_base = reinterpret_cast<void *>(cbuf);
172 10968 : iov[2].iov_len =
173 10968 : std::min(static_cast<size_t>(snprintf(cbuf, sizeof(cbuf), "%s: ", componentToString(component).c_str())),
174 10968 : sizeof(cbuf));
175 :
176 : static thread_local pid_t threadId = 0;
177 10968 : if (threadId <= 0)
178 94 : threadId = syscall(SYS_gettid);
179 : char fbuf[180];
180 10968 : iov[3].iov_base = reinterpret_cast<void *>(fbuf);
181 :
182 10968 : std::string applicationName{};
183 : {
184 10968 : std::unique_lock<std::mutex> lock{g_logHandlerMutex};
185 10968 : if (!g_applicationName.empty())
186 : {
187 80 : applicationName = "A:" + g_applicationName + " ";
188 : }
189 10968 : }
190 :
191 10968 : if (RIALTO_DEBUG_LEVEL_EXTERNAL == level)
192 : {
193 0 : iov[3].iov_len = snprintf(fbuf, sizeof(fbuf), "< %sT:%d >", applicationName.c_str(), threadId);
194 : }
195 10968 : else if (!file || !function || (line <= 0))
196 : {
197 0 : iov[3].iov_len = snprintf(fbuf, sizeof(fbuf), "< %sT:%d M:? F:? L:? > ", applicationName.c_str(), threadId);
198 : }
199 : else
200 : {
201 10968 : iov[3].iov_len = snprintf(fbuf, sizeof(fbuf), "< %sT:%d M:%.*s F:%.*s L:%d > ", applicationName.c_str(),
202 : threadId, 64, file, 64, function, line);
203 : }
204 10968 : iov[3].iov_len = std::min(iov[3].iov_len, sizeof(fbuf));
205 10968 : iov[4].iov_base = const_cast<void *>(reinterpret_cast<const void *>(message));
206 10968 : iov[4].iov_len = messageLen;
207 10968 : iov[5].iov_base = const_cast<void *>(reinterpret_cast<const void *>("\n"));
208 10968 : iov[5].iov_len = 1;
209 : // TODO(RIALTO-38): consider using standard write(2) and handle EINTR properly.
210 10968 : std::ignore = writev(fd, iov, 6);
211 : }
212 : /**
213 : * Journald logging function for the library.
214 : */
215 0 : void journaldLogHandler(RIALTO_COMPONENT component, RIALTO_DEBUG_LEVEL level, const char *file, int line,
216 : const char *function, const char *message, size_t messageLen)
217 : {
218 : static thread_local pid_t threadId = 0;
219 0 : if (threadId <= 0)
220 0 : threadId = syscall(SYS_gettid);
221 : char fbuf[180];
222 0 : std::string applicationName{};
223 : {
224 0 : std::unique_lock<std::mutex> lock{g_logHandlerMutex};
225 0 : if (!g_applicationName.empty())
226 : {
227 0 : applicationName = "A:" + g_applicationName + " ";
228 : }
229 : }
230 0 : if (RIALTO_DEBUG_LEVEL_EXTERNAL == level)
231 : {
232 0 : snprintf(fbuf, sizeof(fbuf), "%s: %s: < %sT:%d >", levelToString(level).c_str(),
233 0 : componentToString(component).c_str(), applicationName.c_str(), threadId);
234 : }
235 0 : else if (!file || !function || (line <= 0))
236 : {
237 0 : snprintf(fbuf, sizeof(fbuf), "%s: %s: < %sT:%d M:? F:? L:? >", levelToString(level).c_str(),
238 0 : componentToString(component).c_str(), applicationName.c_str(), threadId);
239 : }
240 : else
241 : {
242 0 : snprintf(fbuf, sizeof(fbuf), "%s: %s: < %sT:%d M:%.*s F:%.*s L:%d >", levelToString(level).c_str(),
243 0 : componentToString(component).c_str(), applicationName.c_str(), threadId, 64, file, 64, function, line);
244 : }
245 :
246 0 : switch (level)
247 : {
248 0 : case RIALTO_DEBUG_LEVEL_FATAL:
249 0 : SYSTEM_LOG_FATAL(file, function, line, "%s %s", fbuf, message);
250 0 : break;
251 0 : case RIALTO_DEBUG_LEVEL_ERROR:
252 0 : SYSTEM_LOG_ERROR(file, function, line, "%s %s", fbuf, message);
253 0 : break;
254 0 : case RIALTO_DEBUG_LEVEL_WARNING:
255 0 : SYSTEM_LOG_WARN(file, function, line, "%s %s", fbuf, message);
256 0 : break;
257 0 : case RIALTO_DEBUG_LEVEL_MILESTONE:
258 0 : SYSTEM_LOG_MIL(file, function, line, "%s %s", fbuf, message);
259 0 : break;
260 0 : case RIALTO_DEBUG_LEVEL_INFO:
261 0 : SYSTEM_LOG_INFO(file, function, line, "%s %s", fbuf, message);
262 0 : break;
263 0 : case RIALTO_DEBUG_LEVEL_DEBUG:
264 0 : SYSTEM_LOG_DEBUG(file, function, line, "%s %s", fbuf, message);
265 0 : break;
266 0 : case RIALTO_DEBUG_LEVEL_EXTERNAL:
267 0 : SYSTEM_LOG_INFO(file, function, line, "%s %s", fbuf, message);
268 0 : break;
269 0 : default:
270 0 : break;
271 : }
272 : }
273 :
274 11694 : void rialtoLog(RIALTO_COMPONENT component, RIALTO_DEBUG_LEVEL level, const char *file, const char *func, int line,
275 : const char *fmt, va_list ap, const char *append)
276 : {
277 : /* Must be valid component */
278 11694 : if (component >= RIALTO_COMPONENT_LAST)
279 517 : return;
280 :
281 : /* If log levels have not been set, set to Default */
282 11694 : if (!g_rialtoLogLevels[component])
283 17 : g_rialtoLogLevels[component] = g_envVariableParser.getLevel(component);
284 :
285 11694 : if (!(level & g_rialtoLogLevels[component]) && !g_ignoreLogLevels[component])
286 517 : return;
287 : char mbuf[512];
288 : int len;
289 11177 : len = vsnprintf(mbuf, sizeof(mbuf), fmt, ap);
290 11177 : if (len < 1)
291 0 : return;
292 11177 : if (len > static_cast<int>(sizeof(mbuf) - 1))
293 0 : len = sizeof(mbuf) - 1;
294 11177 : if (mbuf[len - 1] == '\n')
295 29 : len--;
296 11177 : mbuf[len] = '\0';
297 11177 : if (append && (len < static_cast<int>(sizeof(mbuf) - 1)))
298 : {
299 56 : size_t extra = std::min<size_t>(strlen(append), (sizeof(mbuf) - len - 1));
300 56 : memcpy(mbuf + len, append, extra);
301 56 : len += static_cast<int>(extra);
302 56 : mbuf[len] = '\0';
303 : }
304 11177 : const char *kFname = nullptr;
305 11177 : if (file)
306 : {
307 11177 : if ((kFname = strrchr(file, '/')) == nullptr)
308 0 : kFname = file;
309 : else
310 11177 : kFname++;
311 : }
312 :
313 11177 : const auto &kLogFileHandle = firebolt::rialto::logging::LogFileHandle::instance();
314 : /* If log handler had not been set, use default */
315 11177 : firebolt::rialto::logging::LogHandler logHandler = g_logHandler[component]; // local copy for thread safety
316 11177 : if (logHandler)
317 : {
318 209 : logHandler(level, kFname, line, func, mbuf, len);
319 : }
320 10968 : else if (g_envVariableParser.isFileLoggingEnabled() && kLogFileHandle.isOpen())
321 : {
322 0 : fdLogHandler(kLogFileHandle.fd(), component, level, kFname, line, func, mbuf, len);
323 : }
324 10968 : else if (g_envVariableParser.isConsoleLoggingEnabled())
325 : {
326 10968 : fdLogHandler(STDERR_FILENO, component, level, kFname, line, func, mbuf, len);
327 : }
328 : else
329 : {
330 0 : journaldLogHandler(component, level, kFname, line, func, mbuf, len);
331 : }
332 11177 : }
333 :
334 : } // namespace
335 :
336 0 : void rialtoLogVPrintf(RIALTO_COMPONENT component, RIALTO_DEBUG_LEVEL level, const char *file, const char *func,
337 : int line, const char *fmt, va_list ap)
338 : {
339 0 : rialtoLog(component, level, file, func, line, fmt, ap, nullptr);
340 : }
341 :
342 11598 : void rialtoLogPrintf(RIALTO_COMPONENT component, RIALTO_DEBUG_LEVEL level, const char *file, const char *func, int line,
343 : const char *fmt, ...)
344 : {
345 : va_list ap;
346 11598 : va_start(ap, fmt);
347 11598 : rialtoLog(component, level, file, func, line, fmt, ap, nullptr);
348 11598 : va_end(ap);
349 : }
350 :
351 96 : void rialtoLogSysPrintf(RIALTO_COMPONENT component, int err, RIALTO_DEBUG_LEVEL level, const char *file,
352 : const char *func, int line, const char *fmt, ...)
353 : {
354 : va_list ap;
355 96 : const char *kErrmsg{nullptr};
356 : char appendbuf[96];
357 96 : const char *kAppend = nullptr;
358 : #if defined(__linux__)
359 : char errbuf[64];
360 96 : kErrmsg = strerror_r(err, errbuf, sizeof(errbuf));
361 : #elif defined(__APPLE__)
362 : char errbuf[64];
363 : if (strerror_r(err, errbuf, sizeof(errbuf)) != 0)
364 : kErrmsg = "Unknown error";
365 : else
366 : kErrmsg = errbuf;
367 : #endif
368 96 : if (kErrmsg)
369 : {
370 96 : snprintf(appendbuf, sizeof(appendbuf), " (%d - %s)", err, kErrmsg);
371 96 : appendbuf[sizeof(appendbuf) - 1] = '\0';
372 96 : kAppend = appendbuf;
373 : }
374 96 : va_start(ap, fmt);
375 96 : rialtoLog(component, level, file, func, line, fmt, ap, kAppend);
376 96 : va_end(ap);
377 : }
378 :
379 : namespace firebolt::rialto::logging
380 : {
381 54 : RialtoLoggingStatus setLogLevels(RIALTO_COMPONENT component, RIALTO_DEBUG_LEVEL logLevels)
382 : {
383 54 : RialtoLoggingStatus status = RIALTO_LOGGING_STATUS_ERROR;
384 54 : if (component < RIALTO_COMPONENT_LAST && !g_ignoreLogLevels[component])
385 : {
386 53 : g_rialtoLogLevels[component] = logLevels;
387 53 : status = RIALTO_LOGGING_STATUS_OK;
388 : }
389 :
390 54 : return status;
391 : }
392 :
393 42 : RIALTO_DEBUG_LEVEL getLogLevels(RIALTO_COMPONENT component)
394 : {
395 42 : if (component < RIALTO_COMPONENT_LAST)
396 : {
397 42 : if (g_ignoreLogLevels[component])
398 10 : return RIALTO_DEBUG_LEVEL_EXTERNAL;
399 :
400 32 : if (!g_rialtoLogLevels[component])
401 0 : g_rialtoLogLevels[component] = g_envVariableParser.getLevel(component);
402 32 : return g_rialtoLogLevels[component];
403 : }
404 0 : return RIALTO_DEBUG_LEVEL_DEFAULT;
405 : }
406 :
407 178 : RialtoLoggingStatus setLogHandler(RIALTO_COMPONENT component, LogHandler handler, bool ignoreLogLevels)
408 : {
409 178 : RialtoLoggingStatus status = RIALTO_LOGGING_STATUS_ERROR;
410 178 : if (component < RIALTO_COMPONENT_LAST)
411 : {
412 177 : std::unique_lock<std::mutex> lock{g_logHandlerMutex};
413 :
414 177 : g_logHandler[component] = std::move(handler);
415 :
416 : // Ignoring log levels is only an option if we're registering
417 : // a non-null log handler
418 177 : g_ignoreLogLevels[component] = (g_logHandler[component]) ? ignoreLogLevels : false;
419 :
420 177 : status = RIALTO_LOGGING_STATUS_OK;
421 : }
422 :
423 178 : return status;
424 101 : }
425 :
426 0 : bool isConsoleLoggingEnabled()
427 : {
428 0 : return g_envVariableParser.isConsoleLoggingEnabled();
429 : }
430 :
431 4 : void setApplicationName(const char *appName)
432 : {
433 4 : std::unique_lock<std::mutex> lock{g_logHandlerMutex};
434 4 : g_applicationName = appName;
435 : }
436 : } // namespace firebolt::rialto::logging
|