#pragma once

#include <bitset>

#include <chrono>

#include <cstdint>

#include <memory>

#include <string>

#include <vector>

#include "envoy/thread/thread.h"

#include "source/common/common/base_logger.h"

#include "source/common/common/fine_grain_logger.h"

#include "source/common/common/fmt.h"

#include "source/common/common/logger_impl.h"

#include "source/common/common/macros.h"

#include "source/common/common/non_copyable.h"

#include "source/common/protobuf/protobuf.h"

#include "absl/container/flat_hash_map.h"

#include "absl/strings/string_view.h"

#include "absl/synchronization/mutex.h"

#include "fmt/ostream.h"

#include "spdlog/spdlog.h"

namespace Envoy {

namespace Logger {

#ifdef ENVOY_DISABLE_LOGGING

const static bool should_log = false;

#else

const static bool should_log = true;

#endif

// TODO: find a way for extensions to register new logger IDs

#define ALL_LOGGER_IDS(FUNCTION) \

FUNCTION(admin) \

FUNCTION(alternate_protocols_cache) \

FUNCTION(aws) \

FUNCTION(assert) \

FUNCTION(backtrace) \

FUNCTION(basic_auth) \

FUNCTION(cache_filter) \

FUNCTION(client) \

FUNCTION(config) \

FUNCTION(connection) \

FUNCTION(conn_handler) \

FUNCTION(compression) \

FUNCTION(credential_injector) \

FUNCTION(decompression) \

FUNCTION(dns) \

FUNCTION(dubbo) \

FUNCTION(envoy_bug) \

FUNCTION(ext_authz) \

FUNCTION(ext_proc) \

FUNCTION(rocketmq) \

FUNCTION(file) \

FUNCTION(filter) \

FUNCTION(forward_proxy) \

FUNCTION(geolocation) \

FUNCTION(grpc) \

FUNCTION(happy_eyeballs) \

FUNCTION(hc) \

FUNCTION(health_checker) \

FUNCTION(http) \

FUNCTION(http2) \

FUNCTION(hystrix) \

FUNCTION(init) \

FUNCTION(io) \

FUNCTION(jwt) \

FUNCTION(kafka) \

FUNCTION(key_value_store) \

FUNCTION(lua) \

FUNCTION(main) \

FUNCTION(matcher) \

FUNCTION(misc) \

FUNCTION(mongo) \

FUNCTION(multi_connection) \

FUNCTION(oauth2) \

FUNCTION(quic) \

FUNCTION(quic_stream) \

FUNCTION(pool) \

FUNCTION(rate_limit_quota) \

FUNCTION(rbac) \

FUNCTION(rds) \

FUNCTION(redis) \

FUNCTION(router) \

FUNCTION(runtime) \

FUNCTION(stats) \

FUNCTION(secret) \

FUNCTION(tap) \

FUNCTION(testing) \

FUNCTION(thrift) \

FUNCTION(tracing) \

FUNCTION(upstream) \

FUNCTION(udp) \

FUNCTION(wasm) \

FUNCTION(websocket) \

FUNCTION(golang) \

FUNCTION(stats_sinks)

// clang-format off

enum class Id {

ALL_LOGGER_IDS(GENERATE_ENUM)

};

// clang-format on

/**

* Logger that uses the DelegatingLogSink.

*/

class StandardLogger : public Logger {

};

class DelegatingLogSink;

using DelegatingLogSinkSharedPtr = std::shared_ptr<DelegatingLogSink>;

/**

* Captures a logging sink that can be delegated to for a bounded amount of time.

* On destruction, logging is reverted to its previous state. SinkDelegates must

* be allocated/freed as a stack.

*/

class SinkDelegate : NonCopyable {

};

/**

* SinkDelegate that writes log messages to stderr.

*/

class StderrSinkDelegate : public SinkDelegate {

};

/**

* Stacks logging sinks, so you can temporarily override the logging mechanism, restoring

* the previous state when the DelegatingSink is destructed.

*/

class DelegatingLogSink : public spdlog::sinks::sink {

};

enum class LoggerMode { Envoy, FineGrainLog };

/**

* Defines a scope for the logging system with the specified lock and log level.

* This is equivalent to setLogLevel, setLogFormat, and setLock, which can be

* called individually as well, e.g. to set the log level without changing the

* lock or format.

*

* Contexts can be nested. When a nested context is destroyed, the previous

* context is restored. When all contexts are destroyed, the lock is cleared,

* and logging will remain unlocked, the same state it is in prior to

* instantiating a Context.

*

* Settings for Fine-Grain Logger, a file level logger without explicit implementation

* of Envoy::Logger:Loggable, are integrated here, as they should be updated when

* context switch occurs.

*/

class Context {

};

/**

* A registry of all named loggers in envoy. Usable for adjusting levels of each logger

* individually.

*/

class Registry {

};

/**

* Mixin class that allows any class to perform logging with a logger of a particular ID.

*/

template <Id id> class Loggable {

};

namespace Utility {

constexpr static absl::string_view TagsPrefix = "[Tags: ";

constexpr static absl::string_view TagsSuffix = "] ";

constexpr static absl::string_view TagsSuffixForSearch = "\"] ";

/**

* Sets the log format for a specific logger.

*/

void setLogFormatForLogger(spdlog::logger& logger, const std::string& log_format);

/**

* Serializes custom log tags to a string that will be prepended to the log message.

* In case JSON logging is enabled, the keys and values will be serialized with JSON escaping.

*/

std::string serializeLogTags(const std::map<std::string, std::string>& tags);

/**

* Escapes the payload to a JSON string and writes the output to the destination buffer.

*/

void escapeMessageJsonString(absl::string_view payload, spdlog::memory_buf_t& dest);

} // namespace Utility

// Contains custom flags to introduce user defined flags in log pattern. Reference:

// https://github.com/gabime/spdlog#user-defined-flags-in-the-log-pattern.

namespace CustomFlagFormatter {

/**

* When added to a formatter, this adds '_' as a user defined flag in the log pattern that escapes

* newlines.

*/

class EscapeMessageNewLine : public spdlog::custom_flag_formatter {

};

/**

* When added to a formatter, this adds 'j' as a user defined flag in the log pattern that makes a

* log payload message a valid JSON escaped string.

*/

class EscapeMessageJsonString : public spdlog::custom_flag_formatter {

};

class ExtractedTags : public spdlog::custom_flag_formatter {

};

class ExtractedMessage : public spdlog::custom_flag_formatter {

};

} // namespace CustomFlagFormatter

} // namespace Logger

/**

* Base logging macros. It is expected that users will use the convenience macros below rather than

* invoke these directly.

*/

#define ENVOY_SPDLOG_LEVEL(LEVEL) \

(static_cast<spdlog::level::level_enum>(Envoy::Logger::Logger::LEVEL))

#define ENVOY_LOG_COMP_LEVEL(LOGGER, LEVEL) (ENVOY_SPDLOG_LEVEL(LEVEL) >= (LOGGER).level())

/**

* Compare levels and use the fine grain logger if fine grain logging is enabled.

*/

#define ENVOY_LOG_COMP_LEVEL_FINE_GRAIN_IF(LOGGER, LEVEL) \

(Envoy::Logger::Context::useFineGrainLogger() \

? (ENVOY_SPDLOG_LEVEL(LEVEL) >= (*FINE_GRAIN_LOGGER()).level()) \

: (ENVOY_SPDLOG_LEVEL(LEVEL) >= (LOGGER).level()))

/**

* Compare levels before invoking logger. This is an optimization to avoid

* executing expressions computing log contents when they would be suppressed.

* The same filtering will also occur in spdlog::logger.

*/

#define ENVOY_LOG_COMP_AND_LOG(LOGGER, LEVEL, ...) \

do { \

if (Envoy::Logger::should_log && ENVOY_LOG_COMP_LEVEL(LOGGER, LEVEL)) { \

LOGGER.log(::spdlog::source_loc{__FILE__, __LINE__, __func__}, ENVOY_SPDLOG_LEVEL(LEVEL), \

__VA_ARGS__); \

} \

} while (0)

#define ENVOY_LOG_CHECK_LEVEL(LEVEL) ENVOY_LOG_COMP_LEVEL(ENVOY_LOGGER(), LEVEL)

/**

* Convenience macro to log to a user-specified logger. When fine-grain logging is used, the

* specific logger is ignored and instead the file-specific logger is used.

*/

#define ENVOY_LOG_TO_LOGGER(LOGGER, LEVEL, ...) \

do { \

if (Envoy::Logger::should_log && Envoy::Logger::Context::useFineGrainLogger()) { \

FINE_GRAIN_LOG(LEVEL, ##__VA_ARGS__); \

} else { \

ENVOY_LOG_COMP_AND_LOG(LOGGER, LEVEL, ##__VA_ARGS__); \

} \

} while (0)

/**

* Convenience macro to get logger.

*/

#define ENVOY_LOGGER() __log_do_not_use_read_comment()

/**

* Convenience macro to log to the misc logger, which allows for logging without of direct access to

* a logger.

*/

#define GET_MISC_LOGGER() ::Envoy::Logger::Registry::getLog(::Envoy::Logger::Id::misc)

#define ENVOY_LOG_MISC(LEVEL, ...) ENVOY_LOG_TO_LOGGER(GET_MISC_LOGGER(), LEVEL, ##__VA_ARGS__)

// TODO(danielhochman): macros(s)/function(s) for logging structures that support iteration.

/**

* Command line options for log macros: use Fine-Grain Logger or not.

*/

#define ENVOY_LOG(LEVEL, ...) ENVOY_LOG_TO_LOGGER(ENVOY_LOGGER(), LEVEL, ##__VA_ARGS__)

#define ENVOY_TAGGED_LOG_TO_LOGGER(LOGGER, LEVEL, TAGS, FORMAT, ...) \

do { \

if (ENVOY_LOG_COMP_LEVEL(LOGGER, LEVEL)) { \

ENVOY_LOG_TO_LOGGER(LOGGER, LEVEL, "{}" FORMAT, \

::Envoy::Logger::Utility::serializeLogTags(TAGS), ##__VA_ARGS__); \

} \

} while (0)

#define ENVOY_TAGGED_CONN_LOG_TO_LOGGER(LOGGER, LEVEL, TAGS, CONNECTION, FORMAT, ...) \

do { \

if (ENVOY_LOG_COMP_LEVEL(LOGGER, LEVEL)) { \

std::map<std::string, std::string> log_tags = TAGS; \

log_tags.emplace("ConnectionId", std::to_string((CONNECTION).id())); \

ENVOY_LOG_TO_LOGGER(LOGGER, LEVEL, "{}" FORMAT, \

::Envoy::Logger::Utility::serializeLogTags(log_tags), ##__VA_ARGS__); \

} \

} while (0)

#define ENVOY_TAGGED_STREAM_LOG_TO_LOGGER(LOGGER, LEVEL, TAGS, STREAM, FORMAT, ...) \

do { \

if (ENVOY_LOG_COMP_LEVEL(LOGGER, LEVEL)) { \

std::map<std::string, std::string> log_tags = TAGS; \

log_tags.emplace("ConnectionId", \

(STREAM).connection() ? std::to_string((STREAM).connection()->id()) : "0"); \

log_tags.emplace("StreamId", std::to_string((STREAM).streamId())); \

ENVOY_LOG_TO_LOGGER(LOGGER, LEVEL, "{}" FORMAT, \

::Envoy::Logger::Utility::serializeLogTags(log_tags), ##__VA_ARGS__); \

} \

} while (0)

#define ENVOY_CONN_LOG_TO_LOGGER(LOGGER, LEVEL, FORMAT, CONNECTION, ...) \

do { \

if (ENVOY_LOG_COMP_LEVEL_FINE_GRAIN_IF(LOGGER, LEVEL)) { \

std::map<std::string, std::string> log_tags; \

log_tags.emplace("ConnectionId", std::to_string((CONNECTION).id())); \

ENVOY_LOG_TO_LOGGER(LOGGER, LEVEL, "{}" FORMAT, \

::Envoy::Logger::Utility::serializeLogTags(log_tags), ##__VA_ARGS__); \

} \

} while (0)

#define ENVOY_STREAM_LOG_TO_LOGGER(LOGGER, LEVEL, FORMAT, STREAM, ...) \

do { \

if (ENVOY_LOG_COMP_LEVEL_FINE_GRAIN_IF(LOGGER, LEVEL)) { \

std::map<std::string, std::string> log_tags; \

log_tags.emplace("ConnectionId", \

(STREAM).connection() ? std::to_string((STREAM).connection()->id()) : "0"); \

log_tags.emplace("StreamId", std::to_string((STREAM).streamId())); \

ENVOY_LOG_TO_LOGGER(LOGGER, LEVEL, "{}" FORMAT, \

::Envoy::Logger::Utility::serializeLogTags(log_tags), ##__VA_ARGS__); \

} \

} while (0)

/**

* Log with tags which are a map of key and value strings. When ENVOY_TAGGED_LOG is used, the tags

* are serialized and prepended to the log message.

* For example, the map {{"key1","val1","key2","val2"}} would be serialized to:

* [Tags: "key1":"val1","key2":"val2"]. The serialization pattern is defined by

* Envoy::Logger::Utility::serializeLogTags function.

*/

#define ENVOY_TAGGED_LOG(LEVEL, TAGS, FORMAT, ...) \

ENVOY_TAGGED_LOG_TO_LOGGER(ENVOY_LOGGER(), LEVEL, TAGS, FORMAT, ##__VA_ARGS__)

/**

* Log with tags which are a map of key and value strings. Has the same operation as

* ENVOY_TAGGED_LOG, only this macro will also add the connection ID to the tags, if the provided

* tags do not already have a ConnectionId key existing.

*/

#define ENVOY_TAGGED_CONN_LOG(LEVEL, TAGS, CONNECTION, FORMAT, ...) \

ENVOY_TAGGED_CONN_LOG_TO_LOGGER(ENVOY_LOGGER(), LEVEL, TAGS, CONNECTION, FORMAT, ##__VA_ARGS__)

/**

* Log with tags which are a map of key and value strings. Has the same operation as

* ENVOY_TAGGED_LOG, only this macro will also add the connection and stream ID to the tags,

* if the provided tags do not already have a ConnectionId or StreamId keys existing.

*/

#define ENVOY_TAGGED_STREAM_LOG(LEVEL, TAGS, STREAM, FORMAT, ...) \

ENVOY_TAGGED_STREAM_LOG_TO_LOGGER(ENVOY_LOGGER(), LEVEL, TAGS, STREAM, FORMAT, ##__VA_ARGS__)

#define ENVOY_CONN_LOG(LEVEL, FORMAT, CONNECTION, ...) \

ENVOY_CONN_LOG_TO_LOGGER(ENVOY_LOGGER(), LEVEL, FORMAT, CONNECTION, ##__VA_ARGS__);

#define ENVOY_STREAM_LOG(LEVEL, FORMAT, STREAM, ...) \

ENVOY_STREAM_LOG_TO_LOGGER(ENVOY_LOGGER(), LEVEL, FORMAT, STREAM, ##__VA_ARGS__);

/**

* Log with a stable event name. This allows emitting a log line with a stable name in addition to

* the standard log line. The stable log line is passed to custom sinks that may want to intercept

* these log messages.

*

* By default these named logs are not handled, but a custom log sink may intercept them by

* implementing the logWithStableName function.

*/

#define ENVOY_LOG_EVENT(LEVEL, EVENT_NAME, ...) \

ENVOY_LOG_EVENT_TO_LOGGER(ENVOY_LOGGER(), LEVEL, EVENT_NAME, ##__VA_ARGS__)

#define ENVOY_LOG_EVENT_TO_LOGGER(LOGGER, LEVEL, EVENT_NAME, ...) \

do { \

ENVOY_LOG_TO_LOGGER(LOGGER, LEVEL, ##__VA_ARGS__); \

if (ENVOY_LOG_COMP_LEVEL_FINE_GRAIN_IF(LOGGER, LEVEL)) { \

::Envoy::Logger::Registry::getSink()->logWithStableName(EVENT_NAME, #LEVEL, (LOGGER).name(), \

fmt::format(__VA_ARGS__)); \

} \

} while (0)

#define ENVOY_CONN_LOG_EVENT(LEVEL, EVENT_NAME, FORMAT, CONNECTION, ...) \

do { \

if (ENVOY_LOG_COMP_LEVEL_FINE_GRAIN_IF(ENVOY_LOGGER(), LEVEL)) { \

std::map<std::string, std::string> log_tags; \

log_tags.emplace("ConnectionId", std::to_string((CONNECTION).id())); \

ENVOY_LOG_TO_LOGGER(ENVOY_LOGGER(), LEVEL, "{}" FORMAT, \

::Envoy::Logger::Utility::serializeLogTags(log_tags), ##__VA_ARGS__); \

::Envoy::Logger::Registry::getSink()->logWithStableName( \

EVENT_NAME, #LEVEL, (ENVOY_LOGGER()).name(), \

fmt::format("{}" FORMAT, ::Envoy::Logger::Utility::serializeLogTags(log_tags), \

##__VA_ARGS__)); \

} \

} while (0)

#define ENVOY_LOG_FIRST_N_TO_LOGGER(LOGGER, LEVEL, N, ...) \

do { \

if (ENVOY_LOG_COMP_LEVEL(LOGGER, LEVEL)) { \

static auto* countdown = new std::atomic<uint64_t>(); \

if (countdown->fetch_add(1) < N) { \

ENVOY_LOG_TO_LOGGER(LOGGER, LEVEL, ##__VA_ARGS__); \

} \

} \

} while (0)

#define ENVOY_LOG_FIRST_N_TO_LOGGER_IF(LOGGER, LEVEL, N, CONDITION, ...) \

do { \

if (ENVOY_LOG_COMP_LEVEL(LOGGER, LEVEL) && (CONDITION)) { \

static auto* countdown = new std::atomic<uint64_t>(); \

if (countdown->fetch_add(1) < N) { \

ENVOY_LOG_TO_LOGGER(LOGGER, LEVEL, ##__VA_ARGS__); \

} \

} \

} while (0)

#define ENVOY_LOG_FIRST_N(LEVEL, N, ...) \

ENVOY_LOG_FIRST_N_TO_LOGGER(ENVOY_LOGGER(), LEVEL, N, ##__VA_ARGS__)

#define ENVOY_LOG_FIRST_N_IF(LEVEL, N, CONDITION, ...) \

ENVOY_LOG_FIRST_N_TO_LOGGER_IF(ENVOY_LOGGER(), LEVEL, N, (CONDITION), ##__VA_ARGS__)

#define ENVOY_LOG_FIRST_N_MISC(LEVEL, N, ...) \

ENVOY_LOG_FIRST_N_TO_LOGGER(GET_MISC_LOGGER(), LEVEL, N, ##__VA_ARGS__)

#define ENVOY_LOG_FIRST_N_MISC_IF(LEVEL, N, CONDITION, ...) \

ENVOY_LOG_FIRST_N_TO_LOGGER_IF(GET_MISC_LOGGER(), LEVEL, N, (CONDITION), ##__VA_ARGS__)

#define ENVOY_LOG_ONCE_TO_LOGGER(LOGGER, LEVEL, ...) \

ENVOY_LOG_FIRST_N_TO_LOGGER(LOGGER, LEVEL, 1, ##__VA_ARGS__)

#define ENVOY_LOG_ONCE_TO_LOGGER_IF(LOGGER, LEVEL, CONDITION, ...) \

ENVOY_LOG_FIRST_N_TO_LOGGER_IF(LOGGER, LEVEL, 1, (CONDITION), ##__VA_ARGS__)

#define ENVOY_LOG_ONCE(LEVEL, ...) ENVOY_LOG_ONCE_TO_LOGGER(ENVOY_LOGGER(), LEVEL, ##__VA_ARGS__)

#define ENVOY_LOG_ONCE_IF(LEVEL, CONDITION, ...) \

ENVOY_LOG_ONCE_TO_LOGGER_IF(ENVOY_LOGGER(), LEVEL, (CONDITION), ##__VA_ARGS__)

#define ENVOY_LOG_ONCE_MISC(LEVEL, ...) \

ENVOY_LOG_ONCE_TO_LOGGER(GET_MISC_LOGGER(), LEVEL, ##__VA_ARGS__)

#define ENVOY_LOG_ONCE_MISC_IF(LEVEL, CONDITION, ...) \

ENVOY_LOG_ONCE_TO_LOGGER_IF(GET_MISC_LOGGER(), LEVEL, (CONDITION), ##__VA_ARGS__)

#define ENVOY_LOG_EVERY_NTH_TO_LOGGER(LOGGER, LEVEL, N, ...) \

do { \

if (ENVOY_LOG_COMP_LEVEL(LOGGER, LEVEL)) { \

static auto* count = new std::atomic<uint64_t>(); \

if ((count->fetch_add(1) % N) == 0) { \

ENVOY_LOG_TO_LOGGER(LOGGER, LEVEL, ##__VA_ARGS__); \

} \

} \

} while (0)

#define ENVOY_LOG_EVERY_NTH(LEVEL, N, ...) \

ENVOY_LOG_EVERY_NTH_TO_LOGGER(ENVOY_LOGGER(), LEVEL, N, ##__VA_ARGS__)

#define ENVOY_LOG_EVERY_NTH_MISC(LEVEL, N, ...) \

ENVOY_LOG_EVERY_NTH_TO_LOGGER(GET_MISC_LOGGER(), LEVEL, N, ##__VA_ARGS__)

#define ENVOY_LOG_EVERY_POW_2_TO_LOGGER(LOGGER, LEVEL, ...) \

do { \

if (ENVOY_LOG_COMP_LEVEL(LOGGER, LEVEL)) { \

static auto* count = new std::atomic<uint64_t>(); \

if (std::bitset<64>(1 /* for the first hit*/ + count->fetch_add(1)).count() == 1) { \

ENVOY_LOG_TO_LOGGER(LOGGER, LEVEL, ##__VA_ARGS__); \

} \

} \

} while (0)

#define ENVOY_LOG_EVERY_POW_2(LEVEL, ...) \

ENVOY_LOG_EVERY_POW_2_TO_LOGGER(ENVOY_LOGGER(), LEVEL, ##__VA_ARGS__)

#define ENVOY_LOG_EVERY_POW_2_MISC(LEVEL, ...) \

ENVOY_LOG_EVERY_POW_2_TO_LOGGER(GET_MISC_LOGGER(), LEVEL, ##__VA_ARGS__)

// This is to get us to pass the format check. We reference a real-world time source here.

// We'd have to introduce a singleton for a time source here, and consensus was that avoiding

// that is preferable.

using t_logclock = std::chrono::steady_clock; // NOLINT

#define ENVOY_LOG_PERIODIC_TO_LOGGER(LOGGER, LEVEL, CHRONO_DURATION, ...) \

do { \

if (ENVOY_LOG_COMP_LEVEL(LOGGER, LEVEL)) { \

static auto* last_hit = new std::atomic<int64_t>(); \

auto last = last_hit->load(); \

const auto now = t_logclock::now().time_since_epoch().count(); \

if ((now - last) > \

std::chrono::duration_cast<std::chrono::nanoseconds>(CHRONO_DURATION).count() && \

last_hit->compare_exchange_strong(last, now)) { \

ENVOY_LOG_TO_LOGGER(LOGGER, LEVEL, ##__VA_ARGS__); \

} \

} \

} while (0)

#define ENVOY_LOG_PERIODIC(LEVEL, CHRONO_DURATION, ...) \

ENVOY_LOG_PERIODIC_TO_LOGGER(ENVOY_LOGGER(), LEVEL, CHRONO_DURATION, ##__VA_ARGS__)

#define ENVOY_LOG_PERIODIC_MISC(LEVEL, CHRONO_DURATION, ...) \

ENVOY_LOG_PERIODIC_TO_LOGGER(GET_MISC_LOGGER(), LEVEL, CHRONO_DURATION, ##__VA_ARGS__)

#define ENVOY_FLUSH_LOG() \

do { \

if (Envoy::Logger::Context::useFineGrainLogger()) { \

FINE_GRAIN_FLUSH_LOG(); \

} else { \

ENVOY_LOGGER().flush(); \

} \

} while (0)

} // namespace Envoy