MB-60861: Replace use LOG_WARNING with LOG_WARNING_CTX

The macros remain as there is still two entries left in mc_time.cc
which needs updating (need some think time to figure out how to
represent those ;-))

Change-Id: I44368c9bde860868400d10f9af99e40886e5ad9f
Reviewed-on: https://review.couchbase.org/c/kv_engine/+/222594
Tested-by: Build Bot <build@couchbase.com>
Reviewed-by: Paolo Cocchi <paolo.cocchi@couchbase.com>

Author: trondn

auditd/src/audit.cc

@@ -59,8 +59,8 @@ AuditImpl::~AuditImpl() {
         create_audit_event(AUDITD_AUDIT_SHUTTING_DOWN_AUDIT_DAEMON, payload);
         put_event(AUDITD_AUDIT_SHUTTING_DOWN_AUDIT_DAEMON, payload);
     } catch (const std::exception& exception) {
-        LOG_WARNING("AuditImpl::~AuditImpl(): Failed to add audit event: {}",
-                    exception.what());
+        LOG_WARNING_CTX("AuditImpl::~AuditImpl(): Failed to add audit event",
+                        {"error", exception.what()});
     }
 
     {
@@ -118,40 +118,38 @@ bool AuditImpl::configure() {
         file_content = cb::dek::Manager::instance().load(
                 cb::dek::Entity::Config, configfile, std::chrono::seconds{5});
         if (file_content.empty()) {
-            LOG_WARNING(R"(Audit::configure: No data in "{}")", configfile);
+            LOG_WARNING_CTX("Audit::configure: No data in file",
+                            {"path", configfile});
             return false;
         }
     } catch (const std::exception& exception) {
-        LOG_WARNING(R"(Audit::configure: Failed to load "{}": {})",
-                    configfile,
-                    exception.what());
+        LOG_WARNING_CTX("Audit::configure: Failed to load",
+                        {"path", configfile},
+                        {"error", exception.what()});
         return false;
     }
 
     nlohmann::json config_json;
     try {
         config_json = nlohmann::json::parse(file_content);
     } catch (const nlohmann::json::exception&) {
-        LOG_WARNING(
-                R"(Audit::configure: JSON parsing error of "{}" with content: "{}")",
-                configfile,
-                cb::UserDataView(file_content));
+        LOG_WARNING_CTX("Audit::configure: JSON parsing error",
+                        {"path", configfile},
+                        {"content", cb::UserDataView(file_content)});
         return false;
     }
 
     try {
         config = AuditConfig(config_json);
     } catch (const nlohmann::json::exception& e) {
-        LOG_WARNING(
-                R"(Audit::configure:: Configuration error in "{}". Error: {}.)"
-                R"(Content: {})",
-                cb::UserDataView(configfile),
-                cb::UserDataView(e.what()),
-                cb::UserDataView(file_content));
+        LOG_WARNING_CTX("Audit::configure:: Configuration error",
+                        {"path", cb::UserDataView(configfile)},
+                        {"error", cb::UserDataView(e.what())},
+                        {"content", cb::UserDataView(file_content)});
         return false;
     } catch (const std::exception& exception) {
-        LOG_WARNING("Audit::configure: Initialization failed: {}",
-                    exception.what());
+        LOG_WARNING_CTX("Audit::configure: Initialization failed",
+                        {"error", exception.what()});
         return false;
     }
 
@@ -182,10 +180,10 @@ bool AuditImpl::configure() {
             }
         } catch (const std::exception& exception) {
             dropped_events++;
-            LOG_WARNING(
+            LOG_WARNING_CTX(
                     "Audit::configure(): Failed to add audit event for "
-                    "audit configure: {}",
-                    exception.what());
+                    "audit configure",
+                    {"error", exception.what()});
         }
     }
 
@@ -284,7 +282,7 @@ bool AuditImpl::put_event(uint32_t event_id, nlohmann::json payload) {
     }
 
     dropped_events++;
-    LOG_WARNING("Audit: Dropping audit event {}", event_id);
+    LOG_WARNING_CTX("Audit: Dropping audit event", {"id", event_id});
     return false;
 }
 
@@ -338,12 +336,12 @@ void AuditImpl::consume_events() {
                     }
                 }
             } catch (const std::exception& e) {
-                LOG_WARNING(
+                LOG_WARNING_CTX(
                         "AuditImpl::consume_events(): Got exception while "
-                        "processing event: {} ({}): {}",
-                        event->id,
-                        cb::tagUserData(event->payload.dump()),
-                        e.what());
+                        "processing event",
+                        {"id", event->id},
+                        {"content", cb::tagUserData(event->payload.dump())},
+                        {"error", e.what()});
                 dropped_events++;
             }
             processeventqueue.pop();
@@ -362,17 +360,17 @@ std::unique_ptr<AuditEventFilter> AuditImpl::createAuditEventFilter() {
 
 bool AuditImpl::write_to_audit_trail(const nlohmann::json& json) {
     if (!auditfile.ensure_open()) {
-        LOG_WARNING("Audit: error opening audit file. Dropping event: {}",
-                    cb::UserDataView(json.dump()));
+        LOG_WARNING_CTX("Audit: error opening audit file. Dropping event",
+                        {"content", cb::UserDataView(json.dump())});
         return false;
     }
 
     if (auditfile.write_event_to_disk(json)) {
         return true;
     }
 
-    LOG_WARNING("Audit: error writing event to disk. Dropping event: {}",
-                cb::UserDataView(json.dump()));
+    LOG_WARNING_CTX("Audit: error writing event to disk. Dropping event",
+                    {"content", cb::UserDataView(json.dump())});
 
     // If the write_event_to_disk function returns false then it is
     // possible the audit file has been closed. Therefore, ensure

auditd/src/audit_interface.cc

@@ -28,7 +28,7 @@ UniqueAuditPtr create_audit_daemon(std::string config_file) {
         return std::make_unique<AuditImpl>(std::move(config_file),
                                            cb::net::getHostname());
     } catch (std::runtime_error& err) {
-        LOG_WARNING("{}", err.what());
+        LOG_WARNING_CTX("Failed to start audit", {"error", err.what()});
     } catch (std::bad_alloc&) {
         LOG_WARNING_RAW("Failed to start audit: Out of memory");
     }

auditd/src/auditfile.cc

@@ -45,11 +45,10 @@ void AuditFile::iterate_old_files(
                 callback(path);
             }
         } catch (const std::exception& e) {
-            LOG_WARNING(
-                    "AuditFile::iterate_old_files(): Exception occurred "
-                    "while inspecting \"{}\": {}",
-                    p.path().generic_string(),
-                    e.what());
+            LOG_WARNING_CTX(
+                    "AuditFile::iterate_old_files(): Exception occurred",
+                    {"path", p.path().generic_string()},
+                    {"error", e.what()});
         }
     }
 }
@@ -203,9 +202,9 @@ bool AuditFile::open() {
                 "Audit file",
                 {"encrypted", file->is_encrypted() ? "encrypted" : "plain"});
     } catch (const std::exception& exception) {
-        LOG_WARNING("Audit: open error on file {}: {}",
-                    open_file_name.generic_string(),
-                    exception.what());
+        LOG_WARNING_CTX("Audit: Failed to open file",
+                        {"path", open_file_name.generic_string()},
+                        {"error", exception.what()});
         return false;
     }
 
@@ -214,9 +213,9 @@ bool AuditFile::open() {
         create_symlink(std::filesystem::path{"."} / open_file_name.filename(),
                        log_directory / current_audit_link_name);
     } catch (const std::exception& e) {
-        LOG_WARNING("Audit: Failed to create {} symbolic link: {}",
-                    current_audit_link_name,
-                    e.what());
+        LOG_WARNING_CTX("Audit: Failed to create symbolic link",
+                        {"path", current_audit_link_name},
+                        {"error", e.what()});
     }
 
     open_time = auditd_time();
@@ -259,8 +258,8 @@ bool AuditFile::write_event_to_disk(const nlohmann::json& output) {
                 "Audit: memory allocation error for writing audit event to "
                 "disk");
     } catch (const std::exception& exception) {
-        LOG_WARNING("Audit: Failed to write event to disk: {}",
-                    exception.what());
+        LOG_WARNING_CTX("Audit: Failed to write event to disk",
+                        {"error", exception.what()});
         close_and_rotate_log();
     }
 
@@ -284,9 +283,9 @@ void AuditFile::set_log_directory(const std::string& new_directory) {
         // The directory does not exist and we failed to create
         // it. This is not a fatal error, but it does mean that the
         // node won't be able to do any auditing
-        LOG_WARNING(R"(Audit: failed to create audit directory "{}": {})",
-                    new_directory,
-                    error.what());
+        LOG_WARNING_CTX("Audit: failed to create audit directory",
+                        {"path", new_directory},
+                        {"error", error.what()});
     }
 }
 
@@ -308,7 +307,8 @@ bool AuditFile::flush() {
         try {
             file->flush();
         } catch (const std::exception& exception) {
-            LOG_WARNING("Audit: writing to disk error: {}", exception.what());
+            LOG_WARNING_CTX("Audit: writing to disk failed",
+                            {"error", exception.what()});
             close_and_rotate_log();
             return false;
         }
@@ -322,9 +322,9 @@ void AuditFile::remove_file(const std::filesystem::path& path) {
         try {
             remove(path);
         } catch (const std::exception& exception) {
-            LOG_WARNING("Audit: Failed to remove \"{}\": {}",
-                        path.generic_string(),
-                        exception.what());
+            LOG_WARNING_CTX("Audit: Failed to remove file",
+                            {"path", path.generic_string()},
+                            {"error", exception.what()});
         }
     }
 }

daemon/get_authorization_task.cc

@@ -54,11 +54,10 @@ void GetAuthorizationTask::externalResponse(cb::mcbp::Status statusCode,
                 }
             }
         } catch (const std::exception& e) {
-            LOG_WARNING(
-                    R"({} GetAuthorizationTask::externalResponse() failed. UUID[{}] "{}")",
-                    cookie.getConnectionId(),
-                    cookie.getEventId(),
-                    e.what());
+            LOG_WARNING_CTX("GetAuthorizationTask::externalResponse() failed",
+                            {"conn_id", cookie.getConnectionId()},
+                            {"event_id", cookie.getEventId()},
+                            {"error", e.what()});
             status = cb::sasl::Error::FAIL;
         }
     }

daemon/mcbp_executors.cc

@@ -559,17 +559,19 @@ static void update_user_permissions_executor(Cookie& cookie) {
     } catch (const nlohmann::json::exception& error) {
         cookie.setErrorContext(error.what());
         status = cb::mcbp::Status::Einval;
-        LOG_WARNING(
-                R"({}: update_user_permissions_executor: Failed to parse provided JSON: {})",
-                cookie.getConnectionId(),
-                error.what());
+        LOG_WARNING_CTX(
+                "update_user_permissions_executor: Failed to parse provided "
+                "JSON",
+                {"conn_id", cookie.getConnectionId()},
+                {"error", error.what()});
     } catch (const std::runtime_error& error) {
         cookie.setErrorContext(error.what());
         status = cb::mcbp::Status::Einval;
-        LOG_WARNING(
-                R"({}: update_user_permissions_executor: An error occurred while updating user: {})",
-                cookie.getConnectionId(),
-                error.what());
+        LOG_WARNING_CTX(
+                "update_user_permissions_executor: An error occurred while "
+                "updating user permissions",
+                {"conn_id", cookie.getConnectionId()},
+                {"error", error.what()});
     }
 
     cookie.sendResponse(status);

daemon/settings.cc

@@ -390,7 +390,7 @@ void Settings::reconfigure(const nlohmann::json& json) {
             setSlowPrometheusScrapeDuration(
                     std::chrono::duration<float>(value.get<float>()));
         } else {
-            LOG_WARNING(R"(Unknown key "{}" in config ignored.)", key);
+            LOG_WARNING_CTX("Ignoring unknown key in config", {"key", key});
         }
     }
 }

engines/ewouldblock_engine/ewouldblock_engine.cc

@@ -1242,10 +1242,10 @@ cb::engine_errc EWB_Engine::unknown_command(CookieIface& cookie,
         }
 
         if (new_mode == nullptr) {
-            LOG_WARNING(
+            LOG_WARNING_CTX(
                     "EWB_Engine::unknown_command(): "
-                    "Got unexpected mode={} for EWOULDBLOCK_CTL, ",
-                    (unsigned int)mode);
+                    "Unexpected mode for EWOULDBLOCK_CTL, ",
+                    {"mode", (unsigned int)mode});
             response({},
                      {},
                      {},
@@ -1843,10 +1843,9 @@ cb::engine_errc EWB_Engine::handleBlockMonitorFile(
     }
 
     if (!suspendConn(cookie, id)) {
-        LOG_WARNING(
-                "EWB_Engine::handleBlockMonitorFile(): "
-                "Id {} already registered",
-                id);
+        LOG_WARNING_CTX(
+                "EWB_Engine::handleBlockMonitorFile(): Id already registered",
+                {"conn_id", id});
         return cb::engine_errc::key_already_exists;
     }
 
@@ -1895,10 +1894,10 @@ cb::engine_errc EWB_Engine::handleBlockMonitorFile(
         thread->start();
         threads.lock()->emplace_back(thread.release());
     } catch (std::exception& e) {
-        LOG_WARNING(
+        LOG_WARNING_CTX(
                 "EWB_Engine::handleBlockMonitorFile(): Failed to create "
-                "block monitor thread: {}",
-                e.what());
+                "block monitor thread",
+                {"error", e.what()});
         return cb::engine_errc::failed;
     }
 
@@ -1925,7 +1924,8 @@ cb::engine_errc EWB_Engine::handleSuspend(CookieIface* cookie,
                  *cookie);
         return cb::engine_errc::success;
     }
-    LOG_WARNING("EWB_Engine::handleSuspend(): Id {} already registered", id);
+    LOG_WARNING_CTX("EWB_Engine::handleSuspend(): Id already registered",
+                    {"conn_id", id});
     return cb::engine_errc::key_already_exists;
 }
 
@@ -1942,10 +1942,10 @@ cb::engine_errc EWB_Engine::handleResume(CookieIface* cookie,
                  *cookie);
         return cb::engine_errc::success;
     }
-    LOG_WARNING(
-            "EWB_Engine::unknown_command(): No connection registered with id "
-            "{}",
-            id);
+    LOG_WARNING_CTX(
+            "EWB_Engine::unknown_command(): No connection registered with "
+            "requested id",
+            {"conn_id", id});
     return cb::engine_errc::invalid_arguments;
 }
 

executor/cb3_executorpool.cc

@@ -300,8 +300,8 @@ TaskQueue* CB3ExecutorPool::_getTaskQueue(const Taskable& t, TaskType qType) {
     curNumThreads = threadQ.size();
 
     if (!bucketPriority) {
-        LOG_WARNING("Trying to schedule task for unregistered bucket {}",
-                    t.getName());
+        LOG_WARNING_CTX("Trying to schedule task for unregistered bucket",
+                        {"bucket", t.getName()});
         return q;
     }
 
@@ -673,8 +673,8 @@ void CB3ExecutorPool::doTaskQStat(Taskable& taskable,
             }
         }
     } catch (std::exception& error) {
-        LOG_WARNING("CB3ExecutorPool::doTaskQStat: Failed to build stats: {}",
-                    error.what());
+        LOG_WARNING_CTX("CB3ExecutorPool::doTaskQStat: Failed to build stats",
+                        {"error", error.what()});
     }
 }
 
@@ -719,7 +719,8 @@ static void addWorkerStats(const char* prefix,
                         add_stat,
                         cookie);
     } catch (std::exception& error) {
-        LOG_WARNING("addWorkerStats: Failed to build stats: {}", error.what());
+        LOG_WARNING_CTX("addWorkerStats: Failed to build stats",
+                        {"error", error.what()});
     }
 }