Adding upstream version 1.12.0.upstream/1.12.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 551 insertions, 0 deletions

diff --git a/libnetdata/log/Makefile.am b/libnetdata/log/Makefile.am
new file mode 100644
index 0000000..1cb69ed
--- /dev/null
+++ b/libnetdata/log/Makefile.am
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+AUTOMAKE_OPTIONS = subdir-objects
+MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
+
+
+dist_noinst_DATA = \
+	README.md \
+	$(NULL)
diff --git a/libnetdata/log/README.md b/libnetdata/log/README.md
new file mode 100644
index 0000000..28e3c3f
--- /dev/null
+++ b/libnetdata/log/README.md
@@ -0,0 +1,2 @@
+
+[![analytics](https://www.google-analytics.com/collect?v=1&aip=1&t=pageview&_s=1&ds=github&dr=https%3A%2F%2Fgithub.com%2Fnetdata%2Fnetdata&dl=https%3A%2F%2Fmy-netdata.io%2Fgithub%2Flibnetdata%2Flog%2FREADME&_u=MAC~&cid=5792dfd7-8dc4-476b-af31-da2fdb9f93d2&tid=UA-64295674-3)]()
diff --git a/libnetdata/log/log.c b/libnetdata/log/log.c
new file mode 100644
index 0000000..66a923f
--- /dev/null
+++ b/libnetdata/log/log.c
@@ -0,0 +1,445 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <daemon/main.h>
+#include "../libnetdata.h"
+
+int web_server_is_multithreaded = 1;
+
+const char *program_name = "";
+uint64_t debug_flags = DEBUG;
+
+int access_log_syslog = 1;
+int error_log_syslog = 1;
+int output_log_syslog = 1;  // debug log
+
+int stdaccess_fd = -1;
+FILE *stdaccess = NULL;
+
+const char *stdaccess_filename = NULL;
+const char *stderr_filename = NULL;
+const char *stdout_filename = NULL;
+
+void syslog_init(void) {
+    static int i = 0;
+
+    if(!i) {
+        openlog(program_name, LOG_PID, LOG_DAEMON);
+        i = 1;
+    }
+}
+
+#define LOG_DATE_LENGTH 26
+
+static inline void log_date(char *buffer, size_t len) {
+    if(unlikely(!buffer || !len))
+        return;
+
+    time_t t;
+    struct tm *tmp, tmbuf;
+
+    t = now_realtime_sec();
+    tmp = localtime_r(&t, &tmbuf);
+
+    if (tmp == NULL) {
+        buffer[0] = '\0';
+        return;
+    }
+
+    if (unlikely(strftime(buffer, len, "%Y-%m-%d %H:%M:%S", tmp) == 0))
+        buffer[0] = '\0';
+
+    buffer[len - 1] = '\0';
+}
+
+static netdata_mutex_t log_mutex = NETDATA_MUTEX_INITIALIZER;
+static inline void log_lock() {
+    netdata_mutex_lock(&log_mutex);
+}
+static inline void log_unlock() {
+    netdata_mutex_unlock(&log_mutex);
+}
+
+static FILE *open_log_file(int fd, FILE *fp, const char *filename, int *enabled_syslog, int is_stdaccess, int *fd_ptr) {
+    int f, devnull = 0;
+
+    if(!filename || !*filename || !strcmp(filename, "none") ||  !strcmp(filename, "/dev/null")) {
+        filename = "/dev/null";
+        devnull = 1;
+    }
+
+    if(!strcmp(filename, "syslog")) {
+        filename = "/dev/null";
+        devnull = 1;
+        syslog_init();
+        if(enabled_syslog) *enabled_syslog = 1;
+    }
+    else if(enabled_syslog) *enabled_syslog = 0;
+
+    // don't do anything if the user is willing
+    // to have the standard one
+    if(!strcmp(filename, "system")) {
+        if(fd != -1 && !is_stdaccess) {
+            if(fd_ptr) *fd_ptr = fd;
+            return fp;
+        }
+
+        filename = "stderr";
+    }
+
+    if(!strcmp(filename, "stdout"))
+        f = STDOUT_FILENO;
+
+    else if(!strcmp(filename, "stderr"))
+        f = STDERR_FILENO;
+
+    else {
+        f = open(filename, O_WRONLY | O_APPEND | O_CREAT, 0664);
+        if(f == -1) {
+            error("Cannot open file '%s'. Leaving %d to its default.", filename, fd);
+            if(fd_ptr) *fd_ptr = fd;
+            return fp;
+        }
+    }
+
+    // if there is a level-2 file pointer
+    // flush it before switching the level-1 fds
+    if(fp)
+        fflush(fp);
+
+    if(devnull && is_stdaccess) {
+        fd = -1;
+        fp = NULL;
+    }
+
+    if(fd != f && fd != -1) {
+        // it automatically closes
+        int t = dup2(f, fd);
+        if (t == -1) {
+            error("Cannot dup2() new fd %d to old fd %d for '%s'", f, fd, filename);
+            close(f);
+            if(fd_ptr) *fd_ptr = fd;
+            return fp;
+        }
+        // info("dup2() new fd %d to old fd %d for '%s'", f, fd, filename);
+        close(f);
+    }
+    else fd = f;
+
+    if(!fp) {
+        fp = fdopen(fd, "a");
+        if (!fp)
+            error("Cannot fdopen() fd %d ('%s')", fd, filename);
+        else {
+            if (setvbuf(fp, NULL, _IOLBF, 0) != 0)
+                error("Cannot set line buffering on fd %d ('%s')", fd, filename);
+        }
+    }
+
+    if(fd_ptr) *fd_ptr = fd;
+    return fp;
+}
+
+void reopen_all_log_files() {
+    if(stdout_filename)
+        open_log_file(STDOUT_FILENO, stdout, stdout_filename, &output_log_syslog, 0, NULL);
+
+    if(stderr_filename)
+        open_log_file(STDERR_FILENO, stderr, stderr_filename, &error_log_syslog, 0, NULL);
+
+    if(stdaccess_filename)
+         stdaccess = open_log_file(stdaccess_fd, stdaccess, stdaccess_filename, &access_log_syslog, 1, &stdaccess_fd);
+}
+
+void open_all_log_files() {
+    // disable stdin
+    open_log_file(STDIN_FILENO, stdin, "/dev/null", NULL, 0, NULL);
+
+    open_log_file(STDOUT_FILENO, stdout, stdout_filename, &output_log_syslog, 0, NULL);
+    open_log_file(STDERR_FILENO, stderr, stderr_filename, &error_log_syslog, 0, NULL);
+    stdaccess = open_log_file(stdaccess_fd, stdaccess, stdaccess_filename, &access_log_syslog, 1, &stdaccess_fd);
+}
+
+// ----------------------------------------------------------------------------
+// error log throttling
+
+time_t error_log_throttle_period = 1200;
+unsigned long error_log_errors_per_period = 200;
+unsigned long error_log_errors_per_period_backup = 0;
+
+int error_log_limit(int reset) {
+    static time_t start = 0;
+    static unsigned long counter = 0, prevented = 0;
+
+    // fprintf(stderr, "FLOOD: counter=%lu, allowed=%lu, backup=%lu, period=%llu\n", counter, error_log_errors_per_period, error_log_errors_per_period_backup, (unsigned long long)error_log_throttle_period);
+
+    // do not throttle if the period is 0
+    if(error_log_throttle_period == 0)
+        return 0;
+
+    // prevent all logs if the errors per period is 0
+    if(error_log_errors_per_period == 0)
+#ifdef NETDATA_INTERNAL_CHECKS
+        return 0;
+#else
+        return 1;
+#endif
+
+    time_t now = now_monotonic_sec();
+    if(!start) start = now;
+
+    if(reset) {
+        if(prevented) {
+            char date[LOG_DATE_LENGTH];
+            log_date(date, LOG_DATE_LENGTH);
+            fprintf(stderr, "%s: %s LOG FLOOD PROTECTION reset for process '%s' (prevented %lu logs in the last %ld seconds).\n"
+                    , date
+                    , program_name
+                    , program_name
+                    , prevented
+                    , now - start
+            );
+        }
+
+        start = now;
+        counter = 0;
+        prevented = 0;
+    }
+
+    // detect if we log too much
+    counter++;
+
+    if(now - start > error_log_throttle_period) {
+        if(prevented) {
+            char date[LOG_DATE_LENGTH];
+            log_date(date, LOG_DATE_LENGTH);
+            fprintf(stderr, "%s: %s LOG FLOOD PROTECTION resuming logging from process '%s' (prevented %lu logs in the last %ld seconds).\n"
+                    , date
+                    , program_name
+                    , program_name
+                    , prevented
+                    , error_log_throttle_period
+            );
+        }
+
+        // restart the period accounting
+        start = now;
+        counter = 1;
+        prevented = 0;
+
+        // log this error
+        return 0;
+    }
+
+    if(counter > error_log_errors_per_period) {
+        if(!prevented) {
+            char date[LOG_DATE_LENGTH];
+            log_date(date, LOG_DATE_LENGTH);
+            fprintf(stderr, "%s: %s LOG FLOOD PROTECTION too many logs (%lu logs in %ld seconds, threshold is set to %lu logs in %ld seconds). Preventing more logs from process '%s' for %ld seconds.\n"
+                    , date
+                    , program_name
+                    , counter
+                    , now - start
+                    , error_log_errors_per_period
+                    , error_log_throttle_period
+                    , program_name
+                    , start + error_log_throttle_period - now);
+        }
+
+        prevented++;
+
+        // prevent logging this error
+#ifdef NETDATA_INTERNAL_CHECKS
+        return 0;
+#else
+        return 1;
+#endif
+    }
+
+    return 0;
+}
+
+// ----------------------------------------------------------------------------
+// debug log
+
+void debug_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... ) {
+    va_list args;
+
+    char date[LOG_DATE_LENGTH];
+    log_date(date, LOG_DATE_LENGTH);
+
+    va_start( args, fmt );
+    printf("%s: %s DEBUG : %s : (%04lu@%-10.10s:%-15.15s): ", date, program_name, netdata_thread_tag(), line, file, function);
+    vprintf(fmt, args);
+    va_end( args );
+    putchar('\n');
+
+    if(output_log_syslog) {
+        va_start( args, fmt );
+        vsyslog(LOG_ERR,  fmt, args );
+        va_end( args );
+    }
+
+    fflush(stdout);
+}
+
+// ----------------------------------------------------------------------------
+// info log
+
+void info_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... )
+{
+    va_list args;
+
+    // prevent logging too much
+    if(error_log_limit(0)) return;
+
+    if(error_log_syslog) {
+        va_start( args, fmt );
+        vsyslog(LOG_INFO,  fmt, args );
+        va_end( args );
+    }
+
+    char date[LOG_DATE_LENGTH];
+    log_date(date, LOG_DATE_LENGTH);
+
+    log_lock();
+
+    va_start( args, fmt );
+    if(debug_flags) fprintf(stderr, "%s: %s INFO  : %s : (%04lu@%-10.10s:%-15.15s): ", date, program_name, netdata_thread_tag(), line, file, function);
+    else            fprintf(stderr, "%s: %s INFO  : %s : ", date, program_name, netdata_thread_tag());
+    vfprintf( stderr, fmt, args );
+    va_end( args );
+
+    fputc('\n', stderr);
+
+    log_unlock();
+}
+
+// ----------------------------------------------------------------------------
+// error log
+
+#if defined(STRERROR_R_CHAR_P)
+// GLIBC version of strerror_r
+static const char *strerror_result(const char *a, const char *b) { (void)b; return a; }
+#elif defined(HAVE_STRERROR_R)
+// POSIX version of strerror_r
+static const char *strerror_result(int a, const char *b) { (void)a; return b; }
+#elif defined(HAVE_C__GENERIC)
+
+// what a trick!
+// http://stackoverflow.com/questions/479207/function-overloading-in-c
+static const char *strerror_result_int(int a, const char *b) { (void)a; return b; }
+static const char *strerror_result_string(const char *a, const char *b) { (void)b; return a; }
+
+#define strerror_result(a, b) _Generic((a), \
+    int: strerror_result_int, \
+    char *: strerror_result_string \
+    )(a, b)
+
+#else
+#error "cannot detect the format of function strerror_r()"
+#endif
+
+void error_int( const char *prefix, const char *file, const char *function, const unsigned long line, const char *fmt, ... ) {
+    // save a copy of errno - just in case this function generates a new error
+    int __errno = errno;
+
+    va_list args;
+
+    // prevent logging too much
+    if(error_log_limit(0)) return;
+
+    if(error_log_syslog) {
+        va_start( args, fmt );
+        vsyslog(LOG_ERR,  fmt, args );
+        va_end( args );
+    }
+
+    char date[LOG_DATE_LENGTH];
+    log_date(date, LOG_DATE_LENGTH);
+
+    log_lock();
+
+    va_start( args, fmt );
+    if(debug_flags) fprintf(stderr, "%s: %s %-5.5s : %s : (%04lu@%-10.10s:%-15.15s): ", date, program_name, prefix, netdata_thread_tag(), line, file, function);
+    else            fprintf(stderr, "%s: %s %-5.5s : %s : ", date, program_name, prefix, netdata_thread_tag());
+    vfprintf( stderr, fmt, args );
+    va_end( args );
+
+    if(__errno) {
+        char buf[1024];
+        fprintf(stderr, " (errno %d, %s)\n", __errno, strerror_result(strerror_r(__errno, buf, 1023), buf));
+        errno = 0;
+    }
+    else
+        fputc('\n', stderr);
+
+    log_unlock();
+}
+
+void fatal_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... ) {
+    // save a copy of errno - just in case this function generates a new error
+    int __errno = errno;
+    va_list args;
+
+    if(error_log_syslog) {
+        va_start( args, fmt );
+        vsyslog(LOG_CRIT,  fmt, args );
+        va_end( args );
+    }
+
+    char date[LOG_DATE_LENGTH];
+    log_date(date, LOG_DATE_LENGTH);
+
+    log_lock();
+
+    va_start( args, fmt );
+    if(debug_flags) fprintf(stderr, "%s: %s FATAL : %s : (%04lu@%-10.10s:%-15.15s): ", date, program_name, netdata_thread_tag(), line, file, function);
+    else            fprintf(stderr, "%s: %s FATAL : %s :", date, program_name, netdata_thread_tag());
+    vfprintf( stderr, fmt, args );
+    va_end( args );
+
+    perror(" # ");
+    fputc('\n', stderr);
+
+    log_unlock();
+
+    char action_data[70+1];
+	snprintfz(action_data, 70, "%04lu@%-10.10s:%-15.15s/%d", line, file, function, __errno);
+	char action_result[60+1];
+	snprintfz(action_result, 60, "%s:%s",program_name, netdata_thread_tag());
+	send_statistics("FATAL", action_result, action_data);
+
+    netdata_cleanup_and_exit(1);
+}
+
+// ----------------------------------------------------------------------------
+// access log
+
+void log_access( const char *fmt, ... ) {
+    va_list args;
+
+    if(access_log_syslog) {
+        va_start( args, fmt );
+        vsyslog(LOG_INFO,  fmt, args );
+        va_end( args );
+    }
+
+    if(stdaccess) {
+        static netdata_mutex_t access_mutex = NETDATA_MUTEX_INITIALIZER;
+
+        if(web_server_is_multithreaded)
+            netdata_mutex_lock(&access_mutex);
+
+        char date[LOG_DATE_LENGTH];
+        log_date(date, LOG_DATE_LENGTH);
+        fprintf(stdaccess, "%s: ", date);
+
+        va_start( args, fmt );
+        vfprintf( stdaccess, fmt, args );
+        va_end( args );
+        fputc('\n', stdaccess);
+
+        if(web_server_is_multithreaded)
+            netdata_mutex_unlock(&access_mutex);
+    }
+}
diff --git a/libnetdata/log/log.h b/libnetdata/log/log.h
new file mode 100644
index 0000000..44670f3
--- /dev/null
+++ b/libnetdata/log/log.h
@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef NETDATA_LOG_H
+#define NETDATA_LOG_H 1
+
+#include "../libnetdata.h"
+
+#define D_WEB_BUFFER        0x0000000000000001
+#define D_WEB_CLIENT        0x0000000000000002
+#define D_LISTENER          0x0000000000000004
+#define D_WEB_DATA          0x0000000000000008
+#define D_OPTIONS           0x0000000000000010
+#define D_PROCNETDEV_LOOP   0x0000000000000020
+#define D_RRD_STATS         0x0000000000000040
+#define D_WEB_CLIENT_ACCESS 0x0000000000000080
+#define D_TC_LOOP           0x0000000000000100
+#define D_DEFLATE           0x0000000000000200
+#define D_CONFIG            0x0000000000000400
+#define D_PLUGINSD          0x0000000000000800
+#define D_CHILDS            0x0000000000001000
+#define D_EXIT              0x0000000000002000
+#define D_CHECKS            0x0000000000004000
+#define D_NFACCT_LOOP       0x0000000000008000
+#define D_PROCFILE          0x0000000000010000
+#define D_RRD_CALLS         0x0000000000020000
+#define D_DICTIONARY        0x0000000000040000
+#define D_MEMORY            0x0000000000080000
+#define D_CGROUP            0x0000000000100000
+#define D_REGISTRY          0x0000000000200000
+#define D_VARIABLES         0x0000000000400000
+#define D_HEALTH            0x0000000000800000
+#define D_CONNECT_TO        0x0000000001000000
+#define D_RRDHOST           0x0000000002000000
+#define D_LOCKS             0x0000000004000000
+#define D_BACKEND           0x0000000008000000
+#define D_STATSD            0x0000000010000000
+#define D_POLLFD            0x0000000020000000
+#define D_STREAM            0x0000000040000000
+#define D_SYSTEM            0x8000000000000000
+
+//#define DEBUG (D_WEB_CLIENT_ACCESS|D_LISTENER|D_RRD_STATS)
+//#define DEBUG 0xffffffff
+#define DEBUG (0)
+
+extern int web_server_is_multithreaded;
+
+extern uint64_t debug_flags;
+
+extern const char *program_name;
+
+extern int stdaccess_fd;
+extern FILE *stdaccess;
+
+extern const char *stdaccess_filename;
+extern const char *stderr_filename;
+extern const char *stdout_filename;
+
+extern int access_log_syslog;
+extern int error_log_syslog;
+extern int output_log_syslog;
+
+extern time_t error_log_throttle_period;
+extern unsigned long error_log_errors_per_period, error_log_errors_per_period_backup;
+extern int error_log_limit(int reset);
+
+extern void open_all_log_files();
+extern void reopen_all_log_files();
+
+static inline void debug_dummy(void) {}
+
+#define error_log_limit_reset() do { error_log_errors_per_period = error_log_errors_per_period_backup; error_log_limit(1); } while(0)
+#define error_log_limit_unlimited() do { \
+        error_log_limit_reset(); \
+        error_log_errors_per_period = ((error_log_errors_per_period_backup * 10) < 10000) ? 10000 : (error_log_errors_per_period_backup * 10); \
+    } while(0)
+
+#ifdef NETDATA_INTERNAL_CHECKS
+#define debug(type, args...) do { if(unlikely(debug_flags & type)) debug_int(__FILE__, __FUNCTION__, __LINE__, ##args); } while(0)
+#else
+#define debug(type, args...) debug_dummy()
+#endif
+
+#define info(args...)    info_int(__FILE__, __FUNCTION__, __LINE__, ##args)
+#define infoerr(args...) error_int("INFO", __FILE__, __FUNCTION__, __LINE__, ##args)
+#define error(args...)   error_int("ERROR", __FILE__, __FUNCTION__, __LINE__, ##args)
+#define fatal(args...)   fatal_int(__FILE__, __FUNCTION__, __LINE__, ##args)
+
+extern void send_statistics(const char *action, const char *action_result, const char *action_data);
+extern void debug_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... ) PRINTFLIKE(4, 5);
+extern void info_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... ) PRINTFLIKE(4, 5);
+extern void error_int( const char *prefix, const char *file, const char *function, const unsigned long line, const char *fmt, ... ) PRINTFLIKE(5, 6);
+extern void fatal_int( const char *file, const char *function, const unsigned long line, const char *fmt, ... ) NORETURN PRINTFLIKE(4, 5);
+extern void log_access( const char *fmt, ... ) PRINTFLIKE(1, 2);
+
+#endif /* NETDATA_LOG_H */