rename global variable "logger" -> "ns_log_logger"

5 files changed, 95 insertions, 88 deletions

diff --git a/vespalog/src/test/bufferedlogskiptest.cpp b/vespalog/src/test/bufferedlogskiptest.cpp
index ac0bb585be9..8b7f1982678 100644
--- a/vespalog/src/test/bufferedlogskiptest.cpp
+++ b/vespalog/src/test/bufferedlogskiptest.cpp
@@ -75,7 +75,7 @@ main(int argc, char **argv)
     }
     ns_log::Logger::fakePid = true;
     uint64_t timer;
-    logger.setTimer(std::unique_ptr<ns_log::Timer>(new ns_log::TestTimer(timer)));
+    ns_log_logger.setTimer(std::unique_ptr<ns_log::Timer>(new ns_log::TestTimer(timer)));
     ns_log::BufferedLogger::instance().setTimer(std::unique_ptr<ns_log::Timer>(new ns_log::TestTimer(timer)));
 
     reset(timer);
diff --git a/vespalog/src/test/bufferedlogtest.cpp b/vespalog/src/test/bufferedlogtest.cpp
index 8399fa81dfa..365f8fb85a7 100644
--- a/vespalog/src/test/bufferedlogtest.cpp
+++ b/vespalog/src/test/bufferedlogtest.cpp
@@ -386,7 +386,7 @@ main(int argc, char **argv)
     ns_log::Logger::fakePid = true;
     ns_log::BufferedLogger::instance().setMaxCacheSize(10);
     uint64_t timer;
-    logger.setTimer(std::unique_ptr<ns_log::Timer>(new ns_log::TestTimer(timer)));
+    ns_log_logger.setTimer(std::unique_ptr<ns_log::Timer>(new ns_log::TestTimer(timer)));
     ns_log::BufferedLogger::instance().setTimer(std::unique_ptr<ns_log::Timer>(new ns_log::TestTimer(timer)));
 
     reset(timer);
diff --git a/vespalog/src/vespa/log/bufferedlogger.h b/vespalog/src/vespa/log/bufferedlogger.h
index 9326f9bf0ba..8baa32445a5 100644
--- a/vespalog/src/vespa/log/bufferedlogger.h
+++ b/vespalog/src/vespa/log/bufferedlogger.h
@@ -93,11 +93,11 @@
     do {                                                           \
         if (LOG_WOULD_LOG(level)) {                                \
             if (LOG_WOULD_LOG(debug)) {                            \
-                logger.doLog(ns_log::Logger::level,                \
+                ns_log_logger.doLog(ns_log::Logger::level,         \
                              __FILE__, __LINE__, __VA_ARGS__);     \
                 ns_log::BufferedLogger::instance().trimCache();    \
             } else {                                               \
-                ns_log::BufferedLogger::instance().doLog(logger,   \
+                ns_log::BufferedLogger::instance().doLog(ns_log_logger, \
                         ns_log::Logger::level, __FILE__, __LINE__, \
                         "", __VA_ARGS__);                          \
             }                                                      \
@@ -112,11 +112,11 @@
     do {                                                           \
         if (LOG_WOULD_LOG(level)) {                                \
             if (LOG_WOULD_LOG(debug)) {                            \
-                logger.doLog(ns_log::Logger::level,                \
+                ns_log_logger.doLog(ns_log::Logger::level,         \
                              __FILE__, __LINE__, __VA_ARGS__);     \
                 ns_log::BufferedLogger::instance().trimCache();    \
             } else {                                               \
-                ns_log::BufferedLogger::instance().doLog(logger,   \
+                ns_log::BufferedLogger::instance().doLog(ns_log_logger, \
                         ns_log::Logger::level, __FILE__, __LINE__, \
                         "", __VA_ARGS__);                          \
             }                                                      \
@@ -129,13 +129,13 @@
     do {                                                           \
         if (LOG_WOULD_LOG(level)) {                                \
             if (LOG_WOULD_LOG(debug)) {                            \
-                logger.doLog(ns_log::Logger::level,                \
+                ns_log_logger.doLog(ns_log::Logger::level,         \
                              __FILE__, __LINE__, ##ARGS);          \
                 ns_log::BufferedLogger::instance().trimCache();    \
             } else {                                               \
                 std::ostringstream ost123;                         \
                 ost123 << __FILE__ << ":" << __LINE__;             \
-                ns_log::BufferedLogger::instance().doLog(logger,   \
+                ns_log::BufferedLogger::instance().doLog(ns_log_logger, \
                         ns_log::Logger::level,                     \
                         __FILE__, __LINE__, ost123.str(), ##ARGS); \
             }                                                      \
@@ -147,11 +147,11 @@
     do {                                                         \
         if (LOG_WOULD_LOG(level)) {                              \
             if (LOG_WOULD_LOG(debug)) {                          \
-                logger.doLog(ns_log::Logger::level,              \
+                ns_log_logger.doLog(ns_log::Logger::level,       \
                              __FILE__, __LINE__, __VA_ARGS__);   \
                 ns_log::BufferedLogger::instance().trimCache();  \
             } else {                                             \
-                ns_log::BufferedLogger::instance().doLog(logger, \
+                ns_log::BufferedLogger::instance().doLog(ns_log_logger, \
                         ns_log::Logger::level,                   \
                         __FILE__, __LINE__, token, __VA_ARGS__); \
             }                                                    \
diff --git a/vespalog/src/vespa/log/log.cpp b/vespalog/src/vespa/log/log.cpp
index 7f2668a97ce..9a65c39c17d 100644
--- a/vespalog/src/vespa/log/log.cpp
+++ b/vespalog/src/vespa/log/log.cpp
@@ -175,19 +175,19 @@ Logger::Logger(const char *name, const char *rcsId)
 
 Logger::~Logger()
 {
-  _numInstances--;
-  if (_numInstances == 1) {
-    if (logger != nullptr) {
-      logger->~Logger();
-      free(logger);
-      logger = nullptr;
+    _numInstances--;
+    if (_numInstances == 1) {
+        if (ns_log_indirect_logger != nullptr) {
+            ns_log_indirect_logger->~Logger();
+            free(ns_log_indirect_logger);
+            ns_log_indirect_logger = nullptr;
+        }
+    } else if (_numInstances == 0) {
+        delete _controlFile;
+        logInitialised = false;
+        delete _target;
+        _target = nullptr;
     }
-  } else if (_numInstances == 0) {
-    delete _controlFile;
-    logInitialised = false;
-    delete _target;
-    _target = nullptr;
-  }
 }
 
 
diff --git a/vespalog/src/vespa/log/log.h b/vespalog/src/vespa/log/log.h
index 11e82e5218b..8598bfda6d6 100644
--- a/vespalog/src/vespa/log/log.h
+++ b/vespalog/src/vespa/log/log.h
@@ -21,35 +21,37 @@
 // Used to use anonymous namespaces, but they fail miserably in gdb 5.3
 
 #define LOG_SETUP(...)                          \
-static ns_log::Logger logger(__VA_ARGS__)  // NOLINT
+static ns_log::Logger ns_log_logger(__VA_ARGS__)  // NOLINT
 
-#define LOG_SETUP_INDIRECT(x, id)               \
-static ns_log::Logger *logger=NULL;             \
-static bool logInitialised = false;             \
-static const char *logName = x;                 \
+#define LOG_SETUP_INDIRECT(x, id)                   \
+static ns_log::Logger *ns_log_indirect_logger=NULL; \
+static bool logInitialised = false;                 \
+static const char *logName = x;                     \
 static const char *indirectRcsId = id
 
-#define LOG_WOULD_LOG(level) logger.wants(ns_log::Logger::level)
-#define LOG_WOULD_VLOG(level) logger.wants(level)
+#define LOG_WOULD_LOG(level) ns_log_logger.wants(ns_log::Logger::level)
+#define LOG_WOULD_VLOG(level) ns_log_logger.wants(level)
 #define LOG_INDIRECT_WOULD_LOG(levelName) \
-    logger->wants(ns_log::Logger::levelName)
+    ns_log_indirect_logger->wants(ns_log::Logger::levelName)
 
 #define LOG_RCSID(x)                                            \
-static int log_dummmy __attribute__((unused)) = logger.setRcsId(x)
+static int log_dummmy __attribute__((unused)) = ns_log_logger.setRcsId(x)
 
 // Define LOG if not using log buffer. Otherwise log buffer will define them
 #ifndef VESPA_LOG_USELOGBUFFERFORREGULARLOG
-#define LOG(level, ...)                                                       \
-do {                                                                          \
-    if (__builtin_expect(LOG_WOULD_LOG(level), false)) {                      \
-        logger.doLog(ns_log::Logger::level, __FILE__, __LINE__, __VA_ARGS__); \
-    }                                                                         \
+#define LOG(level, ...)                                       \
+do {                                                          \
+    if (__builtin_expect(LOG_WOULD_LOG(level), false)) {      \
+        ns_log_logger.doLog(ns_log::Logger::level,            \
+                            __FILE__, __LINE__, __VA_ARGS__); \
+    }                                                         \
 } while (false)
 
 #define VLOG(level, ...)                                      \
 do {                                                          \
     if (__builtin_expect(LOG_WOULD_VLOG(level), false)) {     \
-        logger.doLog(level, __FILE__, __LINE__, __VA_ARGS__); \
+        ns_log_logger.doLog(level,                            \
+                            __FILE__, __LINE__, __VA_ARGS__); \
     }                                                         \
 } while (false)
 #endif
@@ -57,82 +59,87 @@ do {                                                          \
 // Must use placement new in the following definition, since the variable
 // "logger" must be a valid logger object DURING the construction of the
 // logger object itself.
-#define LOG_INDIRECT_MUST                                                       \
-    if (!logInitialised) {                                                      \
-        logInitialised = true;                                                  \
-        logger = static_cast<Logger *>(malloc(sizeof *logger));                 \
-        new (logger) Logger(logName, indirectRcsId);                            \
+#define LOG_INDIRECT_MUST                                               \
+    if (!logInitialised) {                                              \
+        logInitialised = true;                                          \
+        ns_log_indirect_logger =                                        \
+                static_cast<Logger *>(                                  \
+                        malloc(sizeof *ns_log_indirect_logger));        \
+        new (ns_log_indirect_logger) Logger(logName, indirectRcsId);    \
     }
-#define LOG_INDIRECT(level, ...)                                                \
-do {                                                                            \
-    LOG_INDIRECT_MUST                                                           \
-    if (LOG_INDIRECT_WOULD_LOG(level)) {                                        \
-        logger->doLog(ns_log::Logger::level, __FILE__, __LINE__, __VA_ARGS__);  \
-    }                                                                           \
+#define LOG_INDIRECT(level, ...)                                        \
+do {                                                                    \
+    LOG_INDIRECT_MUST                                                   \
+            if (LOG_INDIRECT_WOULD_LOG(level)) {                        \
+        ns_log_indirect_logger->doLog(ns_log::Logger::level,            \
+                                      __FILE__, __LINE__, __VA_ARGS__); \
+    }                                                                   \
 } while (false)
 
 
-#define EV_STARTING(name)                       \
-do {                                            \
-    if (LOG_WOULD_LOG(event)) {                 \
-        logger.doEventStarting(name);           \
-    }                                           \
+#define EV_STARTING(name)                    \
+do {                                         \
+    if (LOG_WOULD_LOG(event)) {              \
+        ns_log_logger.doEventStarting(name); \
+    }                                        \
 } while (false)
 
-#define EV_STOPPING(name,why)                   \
-do {                                            \
-    if (LOG_WOULD_LOG(event)) {                 \
-        logger.doEventStopping(name, why);      \
-    }                                           \
+#define EV_STOPPING(name,why)                     \
+do {                                              \
+    if (LOG_WOULD_LOG(event)) {                   \
+        ns_log_logger.doEventStopping(name, why); \
+    }                                             \
 } while (false)
 
 #define EV_STARTED(name)                        \
 do {                                            \
     if (LOG_WOULD_LOG(event)) {                 \
-        logger.doEventStarted(name);            \
+        ns_log_logger.doEventStarted(name);     \
     }                                           \
 } while (false)
 
-#define EV_STOPPED(name,pid,exitcode)                   \
-do {                                                    \
-    if (LOG_WOULD_LOG(event)) {                         \
-        logger.doEventStopped(name, pid, exitcode);     \
-    }                                                   \
-} while (false)
-
-#define EV_CRASH(name,pid,signal)               \
+#define EV_STOPPED(name,pid,exitcode)           \
 do {                                            \
     if (LOG_WOULD_LOG(event)) {                 \
-        logger.doEventCrash(name, pid, signal); \
+        ns_log_logger.doEventStopped(name, pid, \
+                                     exitcode); \
     }                                           \
 } while (false)
 
-#define EV_PROGRESS(name, ...)                          \
-do {                                                    \
-    if (LOG_WOULD_LOG(event)) {                         \
-        logger.doEventProgress(name, __VA_ARGS__);      \
-    }                                                   \
+#define EV_CRASH(name,pid,signal)                      \
+do {                                                   \
+    if (LOG_WOULD_LOG(event)) {                        \
+        ns_log_logger.doEventCrash(name, pid, signal); \
+    }                                                  \
 } while (false)
 
-#define EV_COUNT(name,value)                    \
-do {                                            \
-    if (LOG_WOULD_LOG(event)) {                 \
-        logger.doEventCount(name, value);       \
-    }                                           \
+#define EV_PROGRESS(name, ...)                      \
+do {                                                \
+    if (LOG_WOULD_LOG(event)) {                     \
+        ns_log_logger.doEventProgress(name,         \
+                                      __VA_ARGS__); \
+    }                                               \
 } while (false)
 
-#define EV_VALUE(name,value)                    \
-do {                                            \
-    if (LOG_WOULD_LOG(event)) {                 \
-        logger.doEventValue(name, value);       \
-    }                                           \
+#define EV_COUNT(name,value)                     \
+    do {                                         \
+    if (LOG_WOULD_LOG(event)) {                  \
+        ns_log_logger.doEventCount(name, value); \
+    }                                            \
 } while (false)
 
-#define EV_STATE(name,value)                    \
-do {                                            \
-    if (LOG_WOULD_LOG(event)) {                 \
-        logger.doEventState(name, value);       \
-    }                                           \
+#define EV_VALUE(name,value)                     \
+do {                                             \
+    if (LOG_WOULD_LOG(event)) {                  \
+        ns_log_logger.doEventValue(name, value); \
+    }                                            \
+} while (false)
+
+#define EV_STATE(name,value)                     \
+do {                                             \
+    if (LOG_WOULD_LOG(event)) {                  \
+        ns_log_logger.doEventState(name, value); \
+    }                                            \
 } while (false)
 
 namespace ns_log {