Lines
98.6 %
Functions
100 %
#include "source/server/admin/logs_handler.h"
#include <string>
#include "source/common/common/fine_grain_logger.h"
#include "source/common/common/logger.h"
#include "source/server/admin/utils.h"
#include "absl/strings/str_split.h"
namespace Envoy {
namespace Server {
namespace {
// Build the level string to level enum map.
absl::flat_hash_map<absl::string_view, spdlog::level::level_enum> buildLevelMap() {
absl::flat_hash_map<absl::string_view, spdlog::level::level_enum> levels;
uint32_t i = 0;
for (absl::string_view level_string : LogsHandler::levelStrings()) {
levels[level_string] = static_cast<spdlog::level::level_enum>(i++);
}
return levels;
} // namespace
LogsHandler::LogsHandler(Server::Instance& server)
: HandlerContextBase(server), log_levels_(buildLevelMap()) {}
std::vector<absl::string_view> LogsHandler::levelStrings() {
std::vector<absl::string_view> strings;
strings.reserve(ARRAY_SIZE(spdlog::level::level_string_views));
for (spdlog::string_view_t level : spdlog::level::level_string_views) {
strings.emplace_back(absl::string_view{level.data(), level.size()});
return strings;
Http::Code LogsHandler::handlerLogging(Http::ResponseHeaderMap&, Buffer::Instance& response,
AdminStream& admin_stream) {
Http::Utility::QueryParamsMulti query_params = admin_stream.queryParams();
Http::Code rc = Http::Code::OK;
const absl::Status status = changeLogLevel(query_params);
if (!status.ok()) {
rc = Http::Code::BadRequest;
response.add(fmt::format("error: {}\n\n", status.message()));
response.add("usage: /logging?<name>=<level> (change single level)\n");
response.add("usage: /logging?paths=name1:level1,name2:level2,... (change multiple levels)\n");
response.add("usage: /logging?level=<level> (change all levels)\n");
response.add("levels: ");
for (auto level_string_view : spdlog::level::level_string_views) {
response.add(fmt::format("{} ", level_string_view));
response.add("\n");
if (!Logger::Context::useFineGrainLogger()) {
response.add("active loggers:\n");
for (const Logger::Logger& logger : Logger::Registry::loggers()) {
response.add(fmt::format(" {}: {}\n", logger.name(), logger.levelString()));
} else {
std::string logger_info = getFineGrainLogContext().listFineGrainLoggers();
response.add(logger_info);
return rc;
Http::Code LogsHandler::handlerReopenLogs(Http::ResponseHeaderMap&, Buffer::Instance& response,
AdminStream&) {
server_.accessLogManager().reopen();
response.add("OK\n");
return Http::Code::OK;
absl::Status LogsHandler::changeLogLevel(Http::Utility::QueryParamsMulti& params) {
// "level" and "paths" will be set to the empty string when this is invoked
// from HTML without setting them, so clean out empty values.
auto level = params.getFirstValue("level");
if (level.has_value() && level.value().empty()) {
params.remove("level");
level = std::nullopt;
auto paths = params.getFirstValue("paths");
if (paths.has_value() && paths.value().empty()) {
params.remove("paths");
paths = std::nullopt;
if (params.data().empty()) {
return absl::OkStatus();
if (params.data().size() != 1) {
return absl::InvalidArgumentError("invalid number of parameters");
if (level.has_value()) {
// Change all log levels.
const absl::StatusOr<spdlog::level::level_enum> level_to_use = parseLogLevel(level.value());
if (!level_to_use.ok()) {
return level_to_use.status();
Logger::Context::changeAllLogLevels(*level_to_use);
// Build a map of name:level pairs, a few allocations is ok here since it's
// not common to call this function at a high rate.
absl::flat_hash_map<absl::string_view, spdlog::level::level_enum> name_levels;
std::vector<std::pair<absl::string_view, int>> glob_levels;
const bool use_fine_grain_logger = Logger::Context::useFineGrainLogger();
if (paths.has_value()) {
// Bulk change log level by name:level pairs, separated by comma.
std::vector<absl::string_view> pairs =
absl::StrSplit(paths.value(), ',', absl::SkipWhitespace());
for (const auto& name_level : pairs) {
const std::pair<absl::string_view, absl::string_view> name_level_pair =
absl::StrSplit(name_level, absl::MaxSplits(':', 1), absl::SkipWhitespace());
auto [name, level] = name_level_pair;
if (name.empty() || level.empty()) {
return absl::InvalidArgumentError("empty logger name or empty logger level");
const absl::StatusOr<spdlog::level::level_enum> level_to_use = parseLogLevel(level);
if (use_fine_grain_logger) {
ENVOY_LOG(info, "adding fine-grain log update, glob='{}' level='{}'", name,
spdlog::level::level_string_views[*level_to_use]);
glob_levels.emplace_back(name, *level_to_use);
name_levels[name] = *level_to_use;
// The HTML admin interface will always populate "level" and "paths" though
// they may be empty. There's a legacy non-HTML-accessible mechanism to
// set a single logger to a level, which we'll handle now. In this scenario,
// "level" and "paths" will not be populated.
// Change particular log level by name.
const auto it = params.data().begin();
const std::string& key = it->first;
const std::string& value = it->second[0];
const absl::StatusOr<spdlog::level::level_enum> level_to_use = parseLogLevel(value);
ENVOY_LOG(info, "adding fine-grain log update, glob='{}' level='{}'", key,
glob_levels.emplace_back(key, *level_to_use);
name_levels[key] = *level_to_use;
if (!use_fine_grain_logger) {
return changeLogLevelsForComponentLoggers(name_levels);
getFineGrainLogContext().updateVerbositySetting(glob_levels);
absl::Status LogsHandler::changeLogLevelsForComponentLoggers(
const absl::flat_hash_map<absl::string_view, spdlog::level::level_enum>& changes) {
std::vector<std::pair<Logger::Logger*, spdlog::level::level_enum>> loggers_to_change;
for (Logger::Logger& logger : Logger::Registry::loggers()) {
auto name_level_itr = changes.find(logger.name());
if (name_level_itr == changes.end()) {
continue;
loggers_to_change.emplace_back(std::make_pair(&logger, name_level_itr->second));
// Check if we have any invalid logger in changes.
if (loggers_to_change.size() != changes.size()) {
return absl::InvalidArgumentError("unknown logger name");
for (auto& it : loggers_to_change) {
Logger::Logger* logger = it.first;
spdlog::level::level_enum level = it.second;
ENVOY_LOG(info, "change log level: name='{}' level='{}'", logger->name(),
spdlog::level::level_string_views[level]);
logger->setLevel(level);
} // namespace Server
} // namespace Envoy