void JournalLogProvider::Log(AbstractLogProvider::LogLevel level, const char *message, const char *fileName, int line, const char *function) const { try { sd_journal_send("PRIORITY=%d", journalLevel.at(level), "CODE_FILE=%s", fileName, "CODE_FUNC=%s", function, "CODE_LINE=%d", line, // add file, line & function info to log message "MESSAGE=[%s:%d] %s(): %s", fileName, line, function, message, NULL); } catch (const std::out_of_range&) { sd_journal_send( "PRIORITY=%d", LOG_ERR, "CODE_FILE=%s", fileName, "CODE_FUNC=%s", function, "CODE_LINE=%d", line, // add file, line & function info to log message "MESSAGE=[%s:%d] %s(): Unsupported log level %d", fileName, line, function, level, NULL); } }
static int update_pid_file(struct runtime_config *rtc) { FILE *fd; char *pidfile; if (access(rtc->statedir, W_OK)) if (mkdir(rtc->statedir, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) return 1; pidfile = construct_pidfile(rtc); if (!(fd = fopen(pidfile, "w"))) { #ifdef USE_SYSTEMD sd_journal_send("MESSAGE=could not open file", "MESSAGE_ID=%s", SD_ID128_CONST_STR(MESSAGE_ERROR), "PID_FILE=%s", pidfile, "STRERROR=%s", strerror(errno), "PRIORITY=3", NULL); #else syslog(LOG_ERR, "could not open file: %s: %s", pidfile, strerror(errno)); #endif return 1; } fprintf(fd, "%u %d", getpid(), rtc->msg_type); if (close_stream(fd)) #ifdef USE_SYSTEMD sd_journal_send("MESSAGE=close failed", "MESSAGE_ID=%s", SD_ID128_CONST_STR(MESSAGE_ERROR), "PID_FILE=%s", pidfile, "STRERROR=%s", strerror(errno), "PRIORITY=3", NULL); #else syslog(LOG_ERR, "close failed: %s: %s", pidfile, strerror(errno)); #endif free(pidfile); return 0; }
static tlog_grc tlog_journal_json_writer_write(struct tlog_json_writer *writer, size_t id, const uint8_t *buf, size_t len) { struct tlog_journal_json_writer *journal_json_writer = (struct tlog_journal_json_writer*)writer; int sd_rc; #define BASE_ARGS \ "PRIORITY=%d", journal_json_writer->priority, \ "MESSAGE=%.*s", len, buf if (journal_json_writer->augment) { sd_rc = sd_journal_send( "TLOG_REC=%s", journal_json_writer->recording, "TLOG_USER=%s", journal_json_writer->username, "TLOG_SESSION=%u", journal_json_writer->session_id, "TLOG_ID=%zu", id, BASE_ARGS, NULL); } else { sd_rc = sd_journal_send(BASE_ARGS, NULL); } #undef BASE_ARGS return (sd_rc < 0) ? TLOG_GRC_FROM(systemd, sd_rc) : TLOG_RC_OK; }
static void run_server(struct runtime_config *rtc) { struct sockaddr_in client_addr; socklen_t addr_len; pthread_attr_t attr; #ifdef USE_SYSTEMD int ret; ret = sd_listen_fds(0); if (1 < ret) faillog("no or too many file descriptors received"); else if (ret == 1) rtc->server_s = SD_LISTEN_FDS_START + 0; else { #endif if (!(rtc->server_s = socket(rtc->res->ai_family, rtc->res->ai_socktype, rtc->res->ai_protocol))) err(EXIT_FAILURE, "cannot create socket"); if (bind(rtc->server_s, rtc->res->ai_addr, rtc->res->ai_addrlen)) err(EXIT_FAILURE, "unable to bind"); if (listen(rtc->server_s, SOMAXCONN)) err(EXIT_FAILURE, "unable to listen"); #ifdef USE_SYSTEMD } #endif if (pthread_attr_init(&attr)) err(EXIT_FAILURE, "cannot init thread attribute"); if (pthread_rwlock_init(&(rtc->lock), NULL)) err(EXIT_FAILURE, "cannot init read-write lock"); daemonize(); if (rtc->msg_type == STATE_UNKNOWN) read_status_from_file(rtc); if (update_pid_file(rtc)) faillog("cannot write pid file"); openlog(PACKAGE_NAME, LOG_PID, LOG_DAEMON); signal(SIGHUP, stop_server); signal(SIGINT, stop_server); signal(SIGTERM, stop_server); #ifdef USE_SYSTEMD sd_journal_send("MESSAGE=service started", "MESSAGE_ID=%s", SD_ID128_CONST_STR(MESSAGE_STOP_START), "STATE=%s", state_messages[rtc->msg_type], "PRIORITY=6", NULL); #else syslog(LOG_INFO, "started in state %s", state_messages[rtc->msg_type]); #endif while (1) { int accepted; pthread_t thread; int *newsock; addr_len = sizeof(client_addr); accepted = accept(rtc->server_s, (struct sockaddr *)&client_addr, &addr_len); newsock = malloc(sizeof(int)); *newsock = accepted; pthread_create(&thread, NULL, handle_request, newsock); pthread_detach(thread); } }
int main(int argc, char *argv[]) { pid_t pid; sd_journal_print(LOG_DEBUG, "Hi, I am a Screamer and I will make some mess in your Journal log."); sd_journal_print(LOG_NOTICE, "Let me note that you can see various message priorities in Journal and you can filter them."); sd_journal_print(LOG_ERR, "While previous messages are mostly informational, this one reports some error that happend in your system."); sd_journal_print(LOG_ALERT, "Error and Alert get same color, but the latter is much more severe."); sd_journal_send("MESSAGE=You may find some interesting details about logged messages in stored fields. Try to list all fields of messages from process %lu.", (unsigned long) getpid(), "PRIORITY=%i", LOG_NOTICE, "HOME=%s", getenv("HOME"), NULL); // pid = fork(); // if (pid == 0) { // sleep(5); // fprintf(stderr, L_ERROR "No! It's not true! That's impossible!!!\n"); // sleep(1); // return 0; // } else if (pid > 0) { // fprintf(stderr, L_NOTICE "Luke, I am your father!\n"); // } else { // return errno; // } sleep(2); return 0; }
static void debug_systemd_log(int msg_level, const char *msg, const char *msg_no_nl) { sd_journal_send("MESSAGE=%s", msg_no_nl, "PRIORITY=%d", debug_level_to_priority(msg_level), "LEVEL=%d", msg_level, NULL); }
faillog(char *msg) { #ifdef USE_SYSTEMD sd_journal_send("MESSAGE=%s", msg, "STRERROR=%s", strerror(errno), "MESSAGE_ID=%s", SD_ID128_CONST_STR(MESSAGE_ERROR), "PRIORITY=3", NULL); #else syslog(LOG_ERR, "%s: %s", msg, strerror(errno)); #endif exit(EXIT_FAILURE); }
static void stop_server(int sig __attribute__ ((__unused__))) { pthread_rwlock_destroy(&(rtc.lock)); freeaddrinfo(rtc.res); close(rtc.server_s); #ifdef USE_SYSTEMD sd_journal_send("MESSAGE=service stopped", "MESSAGE_ID=%s", SD_ID128_CONST_STR(MESSAGE_STOP_START), "PRIORITY=6", NULL); #else syslog(LOG_INFO, "stopped"); #endif closelog(); }
static void catch_signals(int signal) { if (pthread_rwlock_wrlock(&rtc.lock)) { #ifdef USE_SYSTEMD sd_journal_send("MESSAGE=could not get lock", "MESSAGE_ID=%s", SD_ID128_CONST_STR(MESSAGE_ERROR), "STRERROR=%s", strerror(errno), "PRIORITY=3", NULL); #else syslog(LOG_ERR, "could not get lock"); #endif return; } switch (signal) { case SIGUSR1: rtc.msg_type = STATE_DISABLE; break; case SIGUSR2: rtc.msg_type = STATE_MAINTENANCE; break; case SIGWINCH: rtc.msg_type = STATE_ENABLE; break; default: /* should be impossible to reach */ abort(); } rtc.msg_len = strlen(state_messages[rtc.msg_type]); update_pid_file(&rtc); pthread_rwlock_unlock(&(rtc.lock)); #ifdef USE_SYSTEMD sd_journal_send("MESSAGE=signal received", "MESSAGE_ID=%s", SD_ID128_CONST_STR(MESSAGE_STATE_CHANGE), "NEW_STATE=%s", state_messages[rtc.msg_type], "PRIORITY=6", NULL); #else syslog(LOG_INFO, "signal received, state is %s", state_messages[rtc.msg_type]); #endif closelog(); }
static int print_it(const char const *formatwithtid, const char const *msg, int log_level) { int ret; // fusedav-valhalla standardizing on names BINDING, SITE, and ENVIRONMENT ret = sd_journal_send("MESSAGE=%s%s", formatwithtid, msg, "PRIORITY=%d", log_level, "USER_AGENT=%s", get_user_agent(), "SITE=%s", log_key_value[SITE], "ENVIRONMENT=%s", log_key_value[ENVIRONMENT], "HOST_ADDRESS=%s", log_key_value[HOST_ADDRESS], "TID=%lu", syscall(SYS_gettid), "PACKAGE_VERSION=%s", PACKAGE_VERSION, NULL); return ret; }
void AuditLog::log(const PolicyKey &policyKey, const PolicyResult &policyResult) { if (m_logLevel == AL_NONE) return; PolicyType policyType = policyResult.policyType(); namespace PPT = PredefinedPolicyType; if (m_logLevel == AL_ALL || (m_logLevel == AL_DENY && policyType == PPT::DENY) || (m_logLevel == AL_ALLOW && policyType == PPT::ALLOW) || (m_logLevel == AL_OTHER && policyType != PPT::ALLOW && policyType != PPT::DENY)) { sd_journal_send("MESSAGE=%s;%s;%s => %s", policyKey.client().toString().c_str(), policyKey.user().toString().c_str(), policyKey.privilege().toString().c_str(), policyResultToString(policyResult), "PRIORITY=%i", LOG_INFO, "CYNARA_LOG_TYPE=AUDIT", NULL); } }
void JournaldLogHandler::log(const qi::LogLevel verb, const char* category, const char* msg, const char* file, const char* fct, const int line) { // systemd uses the log level defined by syslog. // Here is how we mix both. // LOG_EMERG(0) LogLevel_Fatal(1) // LOG_ALERT(1) // LOG_CRIT(2) // LOG_ERR(3) LogLevel_Error(2) // LOG_WARNING(4) LogLevel_Warning(3) // LOG_NOTICE(5) LogLevel_Info(4) // LOG_INFO(6) LogLevel_Verbose(5) // LOG_DEBUG(7) LogLevel_Debug(6) int _verb = static_cast<int>(verb); if (_verb == 1) _verb = 0; else _verb += 1; int i = sd_journal_send("MESSAGE=%s", msg, "QI_CATEGORY=%s", category, "PRIORITY=%i", _verb, "CODE_FILE=%s", file, "CODE_LINE=%i", line, "CODE_FUNC=%s", fct, NULL ); if (i == 0) return; // If it fail try to do a simpler call to journald int j = sd_journal_print(_verb, "%s; %s", category, msg); if (j == 0) return; // If it fail again print an error message std::cerr << "Can't send message to journald." << std::endl; }
int main(int argc, char **argv) { int c, server = 0; char *listen = NULL, *port = PORT_NUM; struct addrinfo hints; int e; enum { STATEDIR_OPT = CHAR_MAX + 1 }; static const struct option longopts[] = { {"disable", no_argument, NULL, 'd'}, {"maintenance", no_argument, NULL, 'm'}, {"enable", no_argument, NULL, 'e'}, {"server", no_argument, NULL, 's'}, {"listen", required_argument, NULL, 'l'}, {"port", required_argument, NULL, 'p'}, {"state", required_argument, NULL, STATEDIR_OPT}, {"version", no_argument, NULL, 'V'}, {"help", no_argument, NULL, 'h'}, {NULL, 0, NULL, 0} }; set_program_name(argv[0]); atexit(close_stdout); memset(&rtc, 0, sizeof(struct runtime_config)); rtc.argv = argv; rtc.statedir = F5GS_RUNDIR; while ((c = getopt_long(argc, argv, "dmesl:p:Vh", longopts, NULL)) != -1) { switch (c) { case 'd': rtc.send_signal = state_signals[STATE_DISABLE]; break; case 'm': rtc.send_signal = state_signals[STATE_MAINTENANCE]; break; case 'e': rtc.send_signal = state_signals[STATE_ENABLE]; break; case 's': server = 1; break; case 'l': listen = optarg; break; case 'p': port = optarg; break; case STATEDIR_OPT: rtc.statedir = optarg; break; case 'V': printf("%s version %s", PACKAGE_NAME, PACKAGE_VERSION); #ifdef USE_SYSTEMD puts(" with systemd support"); #else puts(""); #endif return EXIT_SUCCESS; case 'h': usage(stdout); default: usage(stderr); } } if (signal(state_signals[STATE_DISABLE], catch_signals) == SIG_ERR || signal(state_signals[STATE_MAINTENANCE], catch_signals) == SIG_ERR || signal(state_signals[STATE_ENABLE], catch_signals) == SIG_ERR) err(EXIT_FAILURE, "cannot set signal handler"); memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = AI_PASSIVE; e = getaddrinfo(listen, port, &hints, &(rtc.res)); if (e) { warnx("getaddrinfo: %s port %s: %s", listen, port, gai_strerror(e)); exit(EXIT_FAILURE); } if (rtc.send_signal && server) change_state(&rtc, getpid()); else if (server) { rtc.msg_type = STATE_UNKNOWN; rtc.msg_len = strlen(state_messages[STATE_UNKNOWN]); } else if (rtc.send_signal) { char *eptr; pid_t pid; FILE *pidfd; char *pid_file = construct_pidfile(&rtc); if (!(pidfd = fopen(pid_file, "r"))) err(EXIT_FAILURE, "cannot open pid file: %s", pid_file); fscanf(pidfd, "%d", &pid); if (close_stream(pidfd)) #ifdef USE_SYSTEMD sd_journal_send("MESSAGE=close failed", "PID_FILE=%s", pid_file, "MESSAGE_ID=%s", SD_ID128_CONST_STR(MESSAGE_ERROR), "STRERROR=%s", strerror(errno), "PRIORITY=3", NULL); #else syslog(LOG_ERR, "close failed: %s: %s", pid_file, strerror(errno)); #endif free(pid_file); if (change_state(&rtc, pid)) { if (errno == 0) { errx(EXIT_FAILURE, "execution of %s failed", F5GS_PRE); } else { err(EXIT_FAILURE, "sending signal failed"); } } openlog(PACKAGE_NAME, LOG_PID, LOG_DAEMON); eptr = getenv("USER"); if (eptr != NULL) #ifdef USE_SYSTEMD sd_journal_send("MESSAGE=signal was sent", "MESSAGE_ID=%s", SD_ID128_CONST_STR(MESSAGE_STATE_CHANGE), "USER=%s", eptr, "PRIORITY=6", NULL); #else syslog(LOG_INFO, "signal was sent by USER: %s", eptr); #endif eptr = getenv("SUDO_USER"); if (eptr != NULL) #ifdef USE_SYSTEMD sd_journal_send("MESSAGE=signal was sent", "MESSAGE_ID=%s", SD_ID128_CONST_STR(MESSAGE_STATE_CHANGE), "SUDO_USER=%s", eptr, "PRIORITY=6", NULL); #else syslog(LOG_INFO, "signal was sent by SUDO_USER: %s", eptr); #endif } if (server) run_server(&rtc); printf("current status is: %s\n", get_server_status(&rtc)); freeaddrinfo(rtc.res); return EXIT_SUCCESS; }
#include "stdlog-intern.h" #include "stdlog.h" /* dummies just needed for driver interface */ static void jrnl_init(stdlog_channel_t __attribute__((unused)) ch) { } static void jrnl_open(stdlog_channel_t __attribute__((unused)) ch) { } static void jrnl_close(stdlog_channel_t __attribute__((unused)) ch) { } static int jrnl_log(stdlog_channel_t ch, const int severity, const char *fmt, va_list ap, char *__restrict__ const wrkbuf, const size_t buflen) { int r; ch->vsnprintf(wrkbuf, buflen, fmt, ap); r = sd_journal_send("MESSAGE=%s", wrkbuf, "PRIORITY=%d", severity, NULL); if(r) errno = -r; return r; } void __stdlog_set_jrnl_drvr(stdlog_channel_t ch) { ch->drvr.init = jrnl_init; ch->drvr.open = jrnl_open; ch->drvr.close = jrnl_close; ch->drvr.log = jrnl_log; }
static int emit_log_msg(int level, const char *zone, size_t zone_len, const char *msg) { rcu_read_lock(); struct log_sink *log = s_log; if(!log_isopen()) { rcu_read_unlock(); return KNOT_ERROR; } int ret = 0; uint8_t *f = facility_at(log, LOGT_SYSLOG); logsrc_t src = zone ? LOG_ZONE : LOG_SERVER; // Syslog if (facility_levels(f, src) & LOG_MASK(level)) { #ifdef ENABLE_SYSTEMD char *zone_fmt = zone ? "ZONE=%.*s" : NULL; sd_journal_send("PRIORITY=%d", level, "MESSAGE=%s", msg, zone_fmt, zone_len, zone, NULL); #else syslog(level, "%s", msg); #endif ret = 1; // To prevent considering the message as ignored. } // Convert level to mask level = LOG_MASK(level); /* Prefix date and time. */ char tstr[LOG_BUFLEN] = {0}; struct tm lt; struct timeval tv; gettimeofday(&tv, NULL); time_t sec = tv.tv_sec; if (localtime_r(&sec, <) != NULL) { strftime(tstr, sizeof(tstr), KNOT_LOG_TIME_FORMAT " ", <); } // Log streams for (int i = LOGT_STDERR; i < LOGT_FILE + log->file_count; ++i) { // Check facility levels mask f = facility_at(log, i); if (facility_levels(f, src) & level) { // Select stream FILE *stream; switch(i) { case LOGT_STDERR: stream = stderr; break; case LOGT_STDOUT: stream = stdout; break; default: stream = log->file[i - LOGT_FILE]; break; } // Print ret = fprintf(stream, "%s%s\n", tstr, msg); if (stream == stdout) { fflush(stream); } } } rcu_read_unlock(); if (ret < 0) { return KNOT_EINVAL; } return ret; }
BEGINdoAction msg_t *pMsg; uchar *tag; int lenTag; int sev; int r; CODESTARTdoAction pMsg = (msg_t*) ppString[0]; MsgGetSeverity(pMsg, &sev); getTAG(pMsg, &tag, &lenTag); /* we can use more properties here, but let's see if there * is some real user interest. We can always add later... */ r = sd_journal_send("MESSAGE=%s", getMSG(pMsg), "PRIORITY=%d", sev, "SYSLOG_FACILITY=%d", pMsg->iFacility, "SYSLOG_IDENTIFIER=%s", tag, NULL); /* FIXME: think about what to do with errors ;) */ (void) r; /* prevent compiler warning */ ENDdoAction BEGINparseSelectorAct CODESTARTparseSelectorAct CODE_STD_STRING_REQUESTparseSelectorAct(1) if(!strncmp((char*) p, ":omjournal:", sizeof(":omjournal:") - 1)) { errmsg.LogError(0, RS_RET_LEGA_ACT_NOT_SUPPORTED, "omjournal supports only v6+ config format, use: " "action(type=\"omjournal\" ...)"); }
void cockpit_journal_log_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data) { gboolean to_journal = TRUE; int priority; const gchar *domains; /* In case we have generate our own log lines */ const gchar *prefix; /* * Note: we should not call GLib fucntions here. * * Mapping glib log levels to syslog priorities * is not at all obvious. */ switch (log_level & G_LOG_LEVEL_MASK) { /* * In GLib this is always fatal, caller of this * function aborts() */ case G_LOG_LEVEL_ERROR: priority = LOG_CRIT; prefix = "ERROR"; break; /* * By convention in GLib applications, critical warnings * are usually internal programmer error (ie: precondition * failures). This maps well to LOG_CRIT. */ case G_LOG_LEVEL_CRITICAL: priority = LOG_CRIT; prefix = "CRITICAL"; break; /* * By convention in GLib apps, g_warning() is used for * non-fatal problems, but ones that should be corrected * or not be encountered in normal system behavior. */ case G_LOG_LEVEL_WARNING: priority = LOG_ERR; prefix = "WARNING"; break; /* * These are related to bad input, or other hosts behaving * badly. Map well to syslog warnings. */ case G_LOG_LEVEL_MESSAGE: default: priority = LOG_WARNING; prefix = "MESSAGE"; break; /* Informational messages, startup, shutdown etc. */ case G_LOG_LEVEL_INFO: priority = LOG_INFO; prefix = "INFO"; break; /* Debug messages. */ case G_LOG_LEVEL_DEBUG: domains = g_getenv ("G_MESSAGES_DEBUG"); if (domains == NULL || (strcmp (domains, "all") != 0 && (!log_domain || !strstr (domains, log_domain)))) { to_journal = FALSE; } priority = LOG_INFO; prefix = "DEBUG"; break; } if (to_journal) { if (have_journal) { sd_journal_send ("MESSAGE=%s", message, "PRIORITY=%d", (int)priority, "COCKPIT_DOMAIN=%s", log_domain ? log_domain : "", NULL); } else if (old_handler == NULL) { g_printerr ("%s: %s: %s\n", prefix, log_domain ? log_domain : "Unknown", message); } } /* After journal, since this may have side effects */ if (old_handler) old_handler (log_domain, log_level, message, NULL); }