LCOV - code coverage report
Current view: top level - logging/source - RialtoLogging.cpp (source / functions) Coverage Total Hit
Test: coverage.info Lines: 67.9 % 187 127
Test Date: 2026-11-10 16:58:19 Functions: 76.9 % 13 10

            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
        

Generated by: LCOV version 2.0-1