The logging streams now do almost no work when there is no output target for them.
For example, if LL_VERBOSE has no output targets, then `verbosestream << x` will return a StreamProxy with a null target. Any further `<<` operations applied to it will do nothing.
# - action
# - info
# - verbose
-debug_log_level (Debug log level) enum action ,none,error,warning,action,info,verbose
+# - trace
+debug_log_level (Debug log level) enum action ,none,error,warning,action,info,verbose,trace
# If the file size of debug.txt exceeds the number of megabytes specified in
# this setting when it is opened, the file is moved to debug.txt.1,
debug_log_size_max (Debug log file size threshold) int 50
# Minimal level of logging to be written to chat.
-chat_log_level (Chat log level) enum error ,none,error,warning,action,info,verbose
+chat_log_level (Chat log level) enum error ,none,error,warning,action,info,verbose,trace
# Enable IPv6 support (for both client and server).
# Required for IPv6 connections to work at all.
# - action
# - info
# - verbose
-# type: enum values: , none, error, warning, action, info, verbose
+# - trace
+# type: enum values: , none, error, warning, action, info, verbose, trace
# debug_log_level = action
# If the file size of debug.txt exceeds the number of megabytes specified in
# debug_log_size_max = 50
# Minimal level of logging to be written to chat.
-# type: enum values: , none, error, warning, action, info, verbose
+# type: enum values: , none, error, warning, action, info, verbose, trace
# chat_log_level = error
# Enable IPv6 support (for both client and server).
client->m_simple_singleplayer_mode = simple_singleplayer_mode;
infostream << "Connecting to server at ";
- connect_address.print(&infostream);
+ connect_address.print(infostream);
infostream << std::endl;
client->connect(connect_address,
}
SIrrlichtCreationParameters params = SIrrlichtCreationParameters();
- if (g_logger.getTraceEnabled())
+ if (tracestream)
params.LoggingLevel = irr::ELL_DEBUG;
params.DriverType = driverType;
params.WindowSize = core::dimension2d<u32>(screen_w, screen_h);
#include <cerrno>
#include <cstring>
-const int BUFFER_LENGTH = 256;
-
-class StringBuffer : public std::streambuf {
+class LevelTarget : public LogTarget {
public:
- StringBuffer() {
- buffer_index = 0;
- }
-
- int overflow(int c);
- virtual void flush(const std::string &buf) = 0;
- std::streamsize xsputn(const char *s, std::streamsize n);
- void push_back(char c);
-
-private:
- char buffer[BUFFER_LENGTH];
- int buffer_index;
-};
-
-
-class LogBuffer : public StringBuffer {
-public:
- LogBuffer(Logger &logger, LogLevel lev) :
- logger(logger),
- level(lev)
+ LevelTarget(Logger &logger, LogLevel level, bool raw = false) :
+ m_logger(logger),
+ m_level(level),
+ m_raw(raw)
{}
- void flush(const std::string &buffer);
-
-private:
- Logger &logger;
- LogLevel level;
-};
+ virtual bool hasOutput() override {
+ return m_logger.hasOutput(m_level);
+ }
+ virtual void log(const std::string &buf) override {
+ if (!m_raw) {
+ m_logger.log(m_level, buf);
+ } else {
+ m_logger.logRaw(m_level, buf);
+ }
+ }
-class RawLogBuffer : public StringBuffer {
-public:
- void flush(const std::string &buffer);
+private:
+ Logger &m_logger;
+ LogLevel m_level;
+ bool m_raw;
};
////
Logger g_logger;
+#ifdef __ANDROID__
+AndroidLogOutput stdout_output;
+AndroidLogOutput stderr_output;
+#else
StreamLogOutput stdout_output(std::cout);
StreamLogOutput stderr_output(std::cerr);
-std::ostream null_stream(NULL);
-
-RawLogBuffer raw_buf;
-
-LogBuffer none_buf(g_logger, LL_NONE);
-LogBuffer error_buf(g_logger, LL_ERROR);
-LogBuffer warning_buf(g_logger, LL_WARNING);
-LogBuffer action_buf(g_logger, LL_ACTION);
-LogBuffer info_buf(g_logger, LL_INFO);
-LogBuffer verbose_buf(g_logger, LL_VERBOSE);
-
-// Connection
-std::ostream *dout_con_ptr = &null_stream;
-std::ostream *derr_con_ptr = &verbosestream;
-
-// Common streams
-std::ostream rawstream(&raw_buf);
-std::ostream dstream(&none_buf);
-std::ostream errorstream(&error_buf);
-std::ostream warningstream(&warning_buf);
-std::ostream actionstream(&action_buf);
-std::ostream infostream(&info_buf);
-std::ostream verbosestream(&verbose_buf);
+#endif
+
+LevelTarget none_target_raw(g_logger, LL_NONE, true);
+LevelTarget none_target(g_logger, LL_NONE);
+LevelTarget error_target(g_logger, LL_ERROR);
+LevelTarget warning_target(g_logger, LL_WARNING);
+LevelTarget action_target(g_logger, LL_ACTION);
+LevelTarget info_target(g_logger, LL_INFO);
+LevelTarget verbose_target(g_logger, LL_VERBOSE);
+LevelTarget trace_target(g_logger, LL_TRACE);
+
+thread_local LogStream dstream(none_target);
+thread_local LogStream rawstream(none_target_raw);
+thread_local LogStream errorstream(error_target);
+thread_local LogStream warningstream(warning_target);
+thread_local LogStream actionstream(action_target);
+thread_local LogStream infostream(info_target);
+thread_local LogStream verbosestream(verbose_target);
+thread_local LogStream tracestream(trace_target);
+thread_local LogStream derr_con(verbose_target);
+thread_local LogStream dout_con(trace_target);
// Android
#ifdef __ANDROID__
//ANDROID_LOG_INFO,
ANDROID_LOG_DEBUG, // LL_INFO
ANDROID_LOG_VERBOSE, // LL_VERBOSE
+ ANDROID_LOG_VERBOSE, // LL_TRACE
};
-class AndroidSystemLogOutput : public ICombinedLogOutput {
- public:
- AndroidSystemLogOutput()
- {
- g_logger.addOutput(this);
- }
- ~AndroidSystemLogOutput()
- {
- g_logger.removeOutput(this);
- }
- void logRaw(LogLevel lev, const std::string &line)
- {
- STATIC_ASSERT(ARRLEN(g_level_to_android) == LL_MAX,
- mismatch_between_android_and_internal_loglevels);
- __android_log_print(g_level_to_android[lev],
- PROJECT_NAME_C, "%s", line.c_str());
- }
-};
-
-AndroidSystemLogOutput g_android_log_output;
-
+void AndroidLogOutput::logRaw(LogLevel lev, const std::string &line) {
+ STATIC_ASSERT(ARRLEN(g_level_to_android) == LL_MAX,
+ mismatch_between_android_and_internal_loglevels);
+ __android_log_print(g_level_to_android[lev],
+ PROJECT_NAME_C, "%s", line.c_str());
+}
#endif
///////////////////////////////////////////////////////////////////////////////
return LL_INFO;
else if (name == "verbose")
return LL_VERBOSE;
+ else if (name == "trace")
+ return LL_TRACE;
else
return LL_MAX;
}
void Logger::addOutput(ILogOutput *out, LogLevel lev)
{
m_outputs[lev].push_back(out);
+ m_has_outputs[lev] = true;
}
void Logger::addOutputMasked(ILogOutput *out, LogLevelMask mask)
{
for (size_t i = 0; i < LL_MAX; i++) {
- if (mask & LOGLEVEL_TO_MASKLEVEL(i))
+ if (mask & LOGLEVEL_TO_MASKLEVEL(i)) {
m_outputs[i].push_back(out);
+ m_has_outputs[i] = true;
+ }
}
}
void Logger::addOutputMaxLevel(ILogOutput *out, LogLevel lev)
{
assert(lev < LL_MAX);
- for (size_t i = 0; i <= lev; i++)
+ for (size_t i = 0; i <= lev; i++) {
m_outputs[i].push_back(out);
+ m_has_outputs[i] = true;
+ }
}
LogLevelMask Logger::removeOutput(ILogOutput *out)
if (it != m_outputs[i].end()) {
ret_mask |= LOGLEVEL_TO_MASKLEVEL(i);
m_outputs[i].erase(it);
+ m_has_outputs[i] = !m_outputs[i].empty();
}
}
return ret_mask;
"ACTION",
"INFO",
"VERBOSE",
+ "TRACE",
};
assert(lev < LL_MAX && lev >= 0);
STATIC_ASSERT(ARRLEN(names) == LL_MAX,
m_outputs[lev][i]->log(lev, combined, time, thread_name, payload_text);
}
-
////
//// *LogOutput methods
////
m_stream << "\033[37m";
break;
case LL_VERBOSE:
+ case LL_TRACE:
// verbose is darker than info
m_stream << "\033[2m";
break;
color = "\x1b(c@#BBB)";
break;
case LL_VERBOSE: // dark grey
+ case LL_TRACE:
color = "\x1b(c@#888)";
break;
default: break;
m_buffer.push(color.append(line));
}
-
-////
-//// *Buffer methods
-////
-
-int StringBuffer::overflow(int c)
-{
- push_back(c);
- return c;
-}
-
-
-std::streamsize StringBuffer::xsputn(const char *s, std::streamsize n)
-{
- for (int i = 0; i < n; ++i)
- push_back(s[i]);
- return n;
-}
-
-void StringBuffer::push_back(char c)
-{
- if (c == '\n' || c == '\r') {
- if (buffer_index)
- flush(std::string(buffer, buffer_index));
- buffer_index = 0;
- } else {
- buffer[buffer_index++] = c;
- if (buffer_index >= BUFFER_LENGTH) {
- flush(std::string(buffer, buffer_index));
- buffer_index = 0;
- }
- }
-}
-
-
-void LogBuffer::flush(const std::string &buffer)
-{
- logger.log(level, buffer);
-}
-
-void RawLogBuffer::flush(const std::string &buffer)
-{
- g_logger.logRaw(LL_NONE, buffer);
-}
#pragma once
+#include <atomic>
#include <map>
#include <queue>
#include <string>
#if !defined(_WIN32) // POSIX
#include <unistd.h>
#endif
+#include "util/basic_macros.h"
+#include "util/stream.h"
#include "irrlichttypes.h"
class ILogOutput;
LL_ACTION, // In-game actions
LL_INFO,
LL_VERBOSE,
+ LL_TRACE,
LL_MAX,
};
// Logs without a prefix
void logRaw(LogLevel lev, const std::string &text);
- void setTraceEnabled(bool enable) { m_trace_enabled = enable; }
- bool getTraceEnabled() { return m_trace_enabled; }
-
static LogLevel stringToLevel(const std::string &name);
static const std::string getLevelLabel(LogLevel lev);
+ bool hasOutput(LogLevel level) {
+ return m_has_outputs[level].load(std::memory_order_relaxed);
+ }
+
static LogColor color_mode;
private:
const std::string getThreadName();
std::vector<ILogOutput *> m_outputs[LL_MAX];
+ std::atomic<bool> m_has_outputs[LL_MAX];
// Should implement atomic loads and stores (even though it's only
// written to when one thread has access currently).
volatile bool m_silenced_levels[LL_MAX];
std::map<std::thread::id, std::string> m_thread_names;
mutable std::mutex m_mutex;
- bool m_trace_enabled;
};
class ILogOutput {
Logger &m_logger;
};
+#ifdef __ANDROID__
+class AndroidLogOutput : public ICombinedLogOutput {
+public:
+ void logRaw(LogLevel lev, const std::string &line);
+};
+#endif
-extern StreamLogOutput stdout_output;
-extern StreamLogOutput stderr_output;
-extern std::ostream null_stream;
+/*
+ * LogTarget
+ *
+ * This is the interface that sits between the LogStreams and the global logger.
+ * Primarily used to route streams to log levels, but could also enable other
+ * custom behavior.
+ *
+ */
+class LogTarget {
+public:
+ // Must be thread-safe. These can be called from any thread.
+ virtual bool hasOutput() = 0;
+ virtual void log(const std::string &buf) = 0;
+};
-extern std::ostream *dout_con_ptr;
-extern std::ostream *derr_con_ptr;
-extern std::ostream *derr_server_ptr;
-extern Logger g_logger;
+/*
+ * StreamProxy
+ *
+ * An ostream-like object that can proxy to a real ostream or do nothing,
+ * depending on how it is configured. See LogStream below.
+ *
+ */
+class StreamProxy {
+public:
+ StreamProxy(std::ostream *os) : m_os(os) { }
+
+ template<typename T>
+ StreamProxy& operator<<(T&& arg) {
+ if (m_os) {
+ *m_os << std::forward<T>(arg);
+ }
+ return *this;
+ }
-// Writes directly to all LL_NONE log outputs for g_logger with no prefix.
-extern std::ostream rawstream;
+ StreamProxy& operator<<(std::ostream& (*manip)(std::ostream&)) {
+ if (m_os) {
+ *m_os << manip;
+ }
+ return *this;
+ }
-extern std::ostream errorstream;
-extern std::ostream warningstream;
-extern std::ostream actionstream;
-extern std::ostream infostream;
-extern std::ostream verbosestream;
-extern std::ostream dstream;
+private:
+ std::ostream *m_os;
+};
-#define TRACEDO(x) do { \
- if (g_logger.getTraceEnabled()) { \
- x; \
- } \
-} while (0)
-#define TRACESTREAM(x) TRACEDO(verbosestream x)
+/*
+ * LogStream
+ *
+ * The public interface for log streams (infostream, verbosestream, etc).
+ *
+ * LogStream minimizes the work done when a given stream is off. (meaning
+ * it has no output targets, so it goes to /dev/null)
+ *
+ * For example, consider:
+ *
+ * verbosestream << "hello world" << 123 << std::endl;
+ *
+ * The compiler evaluates this as:
+ *
+ * (((verbosestream << "hello world") << 123) << std::endl)
+ * ^ ^
+ *
+ * If `verbosestream` is on, the innermost expression (marked by ^) will return
+ * a StreamProxy that forwards to a real ostream, that feeds into the logger.
+ * However, if `verbosestream` is off, it will return a StreamProxy that does
+ * nothing on all later operations. Specifically, CPU time won't be wasted
+ * writing "hello world" and 123 into a buffer, or formatting the log entry.
+ *
+ * It is also possible to directly check if the stream is on/off:
+ *
+ * if (verbosestream) {
+ * auto data = ComputeExpensiveDataForTheLog();
+ * verbosestream << data << endl;
+ * }
+ *
+*/
-#define dout_con (*dout_con_ptr)
-#define derr_con (*derr_con_ptr)
+class LogStream {
+public:
+ LogStream() = delete;
+ DISABLE_CLASS_COPY(LogStream);
+
+ LogStream(LogTarget &target) :
+ m_target(target),
+ m_buffer(std::bind(&LogStream::internalFlush, this, std::placeholders::_1)),
+ m_dummy_buffer(),
+ m_stream(&m_buffer),
+ m_dummy_stream(&m_dummy_buffer),
+ m_proxy(&m_stream),
+ m_dummy_proxy(nullptr) { }
+
+ template<typename T>
+ StreamProxy& operator<<(T&& arg) {
+ StreamProxy& sp = m_target.hasOutput() ? m_proxy : m_dummy_proxy;
+ sp << std::forward<T>(arg);
+ return sp;
+ }
+ StreamProxy& operator<<(std::ostream& (*manip)(std::ostream&)) {
+ StreamProxy& sp = m_target.hasOutput() ? m_proxy : m_dummy_proxy;
+ sp << manip;
+ return sp;
+ }
+
+ operator bool() {
+ return m_target.hasOutput();
+ }
+
+ void internalFlush(const std::string &buf) {
+ m_target.log(buf);
+ }
+
+ operator std::ostream&() {
+ return m_target.hasOutput() ? m_stream : m_dummy_stream;
+ }
+
+private:
+ // 10 streams per thread x (256 + overhead) ~ 3K per thread
+ static const int BUFFER_LENGTH = 256;
+ LogTarget &m_target;
+ StringStreamBuffer<BUFFER_LENGTH> m_buffer;
+ DummyStreamBuffer m_dummy_buffer;
+ std::ostream m_stream;
+ std::ostream m_dummy_stream;
+ StreamProxy m_proxy;
+ StreamProxy m_dummy_proxy;
+
+};
+
+#ifdef __ANDROID__
+extern AndroidLogOutput stdout_output;
+extern AndroidLogOutput stderr_output;
+#else
+extern StreamLogOutput stdout_output;
+extern StreamLogOutput stderr_output;
+#endif
+
+extern Logger g_logger;
+
+/*
+ * By making the streams thread_local, each thread has its own
+ * private buffer. Two or more threads can write to the same stream
+ * simultaneously (lock-free), and there won't be any interference.
+ *
+ * The finished lines are sent to a LogTarget which is a global (not thread-local)
+ * object, and from there relayed to g_logger. The final writes are serialized
+ * by the mutex in g_logger.
+*/
+
+extern thread_local LogStream dstream;
+extern thread_local LogStream rawstream; // Writes directly to all LL_NONE log outputs with no prefix.
+extern thread_local LogStream errorstream;
+extern thread_local LogStream warningstream;
+extern thread_local LogStream actionstream;
+extern thread_local LogStream infostream;
+extern thread_local LogStream verbosestream;
+extern thread_local LogStream tracestream;
+// TODO: Search/replace these with verbose/tracestream
+extern thread_local LogStream derr_con;
+extern thread_local LogStream dout_con;
+
+#define TRACESTREAM(x) do { \
+ if (tracestream) { \
+ tracestream x; \
+ } \
+} while (0)
}
}
- // If trace is enabled, enable logging of certain things
- if (cmd_args.getFlag("trace")) {
- dstream << _("Enabling trace level debug output") << std::endl;
- g_logger.setTraceEnabled(true);
- dout_con_ptr = &verbosestream; // This is somewhat old
- socket_enable_debug_output = true; // Sockets doesn't use log.h
- }
-
// In certain cases, output info level on stderr
if (cmd_args.getFlag("info") || cmd_args.getFlag("verbose") ||
cmd_args.getFlag("trace") || cmd_args.getFlag("speedtests"))
if (cmd_args.getFlag("verbose") || cmd_args.getFlag("trace"))
g_logger.addOutput(&stderr_output, LL_VERBOSE);
+ if (cmd_args.getFlag("trace")) {
+ dstream << _("Enabling trace level debug output") << std::endl;
+ g_logger.addOutput(&stderr_output, LL_TRACE);
+ socket_enable_debug_output = true;
+ }
+
return true;
}
warningstream << "Deprecated use of debug_log_level with an "
"integer value; please update your configuration." << std::endl;
static const char *lev_name[] =
- {"", "error", "action", "info", "verbose"};
+ {"", "error", "action", "info", "verbose", "trace"};
int lev_i = atoi(conf_loglev.c_str());
if (lev_i < 0 || lev_i >= (int)ARRLEN(lev_name)) {
warningstream << "Supplied invalid debug_log_level!"
m_port = port;
}
-void Address::print(std::ostream *s) const
+void Address::print(std::ostream& s) const
{
if (m_addr_family == AF_INET6)
- *s << "[" << serializeString() << "]:" << m_port;
+ s << "[" << serializeString() << "]:" << m_port;
else if (m_addr_family == AF_INET)
- *s << serializeString() << ":" << m_port;
+ s << serializeString() << ":" << m_port;
else
- *s << "(undefined)";
+ s << "(undefined)";
}
bool Address::isLocalhost() const
int getFamily() const { return m_addr_family; }
bool isIPv6() const { return m_addr_family == AF_INET6; }
bool isZero() const;
- void print(std::ostream *s) const;
+ void print(std::ostream &s) const;
std::string serializeString() const;
bool isLocalhost() const;
/* defines used for debugging and profiling */
/******************************************************************************/
#ifdef NDEBUG
- #define LOG(a) a
#define PROFILE(a)
#else
- #if 0
- /* this mutex is used to achieve log message consistency */
- std::mutex log_message_mutex;
- #define LOG(a) \
- { \
- MutexAutoLock loglock(log_message_mutex); \
- a; \
- }
- #else
- // Prevent deadlocks until a solution is found after 5.2.0 (TODO)
- #define LOG(a) a
- #endif
-
#define PROFILE(a) a
#endif
+// TODO: Clean this up.
+#define LOG(a) a
+
#define PING_TIMEOUT 5.0
u16 BufferedPacket::getSeqnum() const
/* defines used for debugging and profiling */
/******************************************************************************/
#ifdef NDEBUG
-#define LOG(a) a
#define PROFILE(a)
#undef DEBUG_CONNECTION_KBPS
#else
/* this mutex is used to achieve log message consistency */
-std::mutex log_conthread_mutex;
-#define LOG(a) \
- { \
- MutexAutoLock loglock(log_conthread_mutex); \
- a; \
- }
#define PROFILE(a) a
//#define DEBUG_CONNECTION_KBPS
#undef DEBUG_CONNECTION_KBPS
#endif
+// TODO: Clean this up.
+#define LOG(a) a
+
#define WINDOW_SIZE 5
static session_t readPeerId(const u8 *packetdata)
if (socket_enable_debug_output) {
// Print packet destination and size
dstream << (int)m_handle << " -> ";
- destination.print(&dstream);
+ destination.print(dstream);
dstream << ", size=" << size;
// Print packet contents
if (socket_enable_debug_output) {
// Print packet sender and size
dstream << (int)m_handle << " <- ";
- sender.print(&dstream);
+ sender.print(dstream);
dstream << ", size=" << received;
// Print packet contents
actionstream << "World at [" << m_path_world << "]" << std::endl;
actionstream << "Server for gameid=\"" << m_gamespec.id
<< "\" listening on ";
- m_bind_addr.print(&actionstream);
+ m_bind_addr.print(actionstream);
actionstream << "." << std::endl;
}
--- /dev/null
+/*
+Minetest
+Copyright (C) 2022 Minetest Authors
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#pragma once
+
+#include <iostream>
+#include <string>
+#include <functional>
+
+template<int BufferLength, typename Emitter = std::function<void(const std::string &)> >
+class StringStreamBuffer : public std::streambuf {
+public:
+ StringStreamBuffer(Emitter emitter) : m_emitter(emitter) {
+ buffer_index = 0;
+ }
+
+ int overflow(int c) {
+ push_back(c);
+ return c;
+ }
+
+ void push_back(char c) {
+ if (c == '\n' || c == '\r') {
+ if (buffer_index)
+ m_emitter(std::string(buffer, buffer_index));
+ buffer_index = 0;
+ } else {
+ buffer[buffer_index++] = c;
+ if (buffer_index >= BufferLength) {
+ m_emitter(std::string(buffer, buffer_index));
+ buffer_index = 0;
+ }
+ }
+ }
+
+ std::streamsize xsputn(const char *s, std::streamsize n) {
+ for (int i = 0; i < n; ++i)
+ push_back(s[i]);
+ return n;
+ }
+private:
+ Emitter m_emitter;
+ char buffer[BufferLength];
+ int buffer_index;
+};
+
+class DummyStreamBuffer : public std::streambuf {
+ int overflow(int c) {
+ return c;
+ }
+ std::streamsize xsputn(const char *s, std::streamsize n) {
+ return n;
+ }
+};
projects / dragonfireclient.git / commitdiff