Just-MR: Improve logging messages

... by reporting unsupported config values explicitly and fixing
inconsistencies.

3 files changed, 162 insertions, 149 deletions

diff --git a/src/other_tools/just_mr/main.cpp b/src/other_tools/just_mr/main.cpp
index 787483ba..70eaee3c 100644
--- a/src/other_tools/just_mr/main.cpp
+++ b/src/other_tools/just_mr/main.cpp
@@ -114,7 +114,7 @@ void SetupSetupCommandArguments(
     for (auto const& known_subcmd : kKnownJustSubcommands) {
         auto* subcmd = app.add_subcommand(
             known_subcmd.first,
-            "Run setup and call \'just " + known_subcmd.first + "\'.");
+            "Run setup and call \"just " + known_subcmd.first + "\".");
         subcmd->set_help_flag();  // disable help flag
         cmd_just_subcmds.emplace_back(subcmd);
     }
@@ -606,7 +606,7 @@ void DefaultReachableRepositories(
     auto repos = (*config)["repositories"];
     if (not repos.IsNotNull()) {
         Logger::Log(LogLevel::Error,
-                    "Config: mandatory key \"repositories\" "
+                    "Config: Mandatory key \"repositories\" "
                     "missing");
         return kExitFetchError;
     }
@@ -658,8 +658,8 @@ void DefaultReachableRepositories(
                         "Writing distribution files to workspace location {}, "
                         "which is different to the workspace of the requested "
                         "main repository {}.",
-                        fetch_dir->string(),
-                        repo_path_as_path.string());
+                        nlohmann::json(fetch_dir->string()).dump(),
+                        nlohmann::json(repo_path_as_path.string()).dump());
                 }
             }
         }
@@ -675,8 +675,8 @@ void DefaultReachableRepositories(
         auto repo_desc = repos->At(repo_name);
         if (not repo_desc) {
             Logger::Log(LogLevel::Error,
-                        "Config: missing config entry for repository {}",
-                        repo_name);
+                        "Config: Missing config entry for repository {}",
+                        nlohmann::json(repo_name).dump());
             return kExitFetchError;
         }
         auto repo = repo_desc->get()->At("repository");
@@ -685,33 +685,34 @@ void DefaultReachableRepositories(
                 JustMR::Utils::ResolveRepo(repo->get(), repos);
             if (not resolved_repo_desc) {
                 Logger::Log(LogLevel::Error,
-                            "Config: found cyclic dependency for "
+                            "Config: Found cyclic dependency for "
                             "repository {}",
-                            repo_name);
+                            nlohmann::json(repo_name).dump());
                 return kExitFetchError;
             }
             // get repo_type
             auto repo_type = (*resolved_repo_desc)->At("type");
             if (not repo_type) {
                 Logger::Log(LogLevel::Error,
-                            "Config: mandatory key \"type\" missing "
+                            "Config: Mandatory key \"type\" missing "
                             "for repository {}",
-                            repo_name);
+                            nlohmann::json(repo_name).dump());
                 return kExitFetchError;
             }
             if (not repo_type->get()->IsString()) {
                 Logger::Log(LogLevel::Error,
-                            "Config: unsupported value for key \'type\' for "
+                            "Config: Unsupported value {} for key \"type\" for "
                             "repository {}",
-                            repo_name);
+                            repo_type->get()->ToString(),
+                            nlohmann::json(repo_name).dump());
                 return kExitFetchError;
             }
             auto repo_type_str = repo_type->get()->String();
             if (not kCheckoutTypeMap.contains(repo_type_str)) {
                 Logger::Log(LogLevel::Error,
                             "Unknown repository type {} for {}",
-                            repo_type_str,
-                            repo_name);
+                            nlohmann::json(repo_type_str).dump(),
+                            nlohmann::json(repo_name).dump());
                 return kExitFetchError;
             }
             // only do work if repo is archive type
@@ -726,7 +727,8 @@ void DefaultReachableRepositories(
                 if (not repo_desc_content->get()->IsString()) {
                     Logger::Log(
                         LogLevel::Error,
-                        "Unsupported value for mandatory field \'content\'");
+                        "Unsupported value {} for mandatory field \"content\"",
+                        repo_desc_content->get()->ToString());
                     return kExitFetchError;
                 }
                 auto repo_desc_fetch = (*resolved_repo_desc)->At("fetch");
@@ -737,8 +739,9 @@ void DefaultReachableRepositories(
                 }
                 if (not repo_desc_fetch->get()->IsString()) {
                     Logger::Log(LogLevel::Error,
-                                "ArchiveCheckout: Unsupported value for "
-                                "mandatory field \'fetch\'");
+                                "ArchiveCheckout: Unsupported value {} for "
+                                "mandatory field \"fetch\"",
+                                repo_desc_fetch->get()->ToString());
                     return kExitFetchError;
                 }
                 auto repo_desc_subdir =
@@ -779,8 +782,8 @@ void DefaultReachableRepositories(
         }
         else {
             Logger::Log(LogLevel::Error,
-                        "Config: missing repository description for {}",
-                        repo_name);
+                        "Config: Missing repository description for {}",
+                        nlohmann::json(repo_name).dump());
             return kExitFetchError;
         }
     }
@@ -872,7 +875,7 @@ void DefaultReachableRepositories(
     auto repos = (*config)["repositories"];
     if (not repos.IsNotNull()) {
         Logger::Log(LogLevel::Error,
-                    "Config: mandatory key \"repositories\" "
+                    "Config: Mandatory key \"repositories\" "
                     "missing");
         return kExitUpdateError;
     }
@@ -883,8 +886,8 @@ void DefaultReachableRepositories(
         auto repo_desc_parent = repos->At(repo_name);
         if (not repo_desc_parent) {
             Logger::Log(LogLevel::Error,
-                        "Config: missing config entry for repository {}",
-                        repo_name);
+                        "Config: Missing config entry for repository {}",
+                        nlohmann::json(repo_name).dump());
             return kExitUpdateError;
         }
         auto repo_desc = repo_desc_parent->get()->At("repository");
@@ -893,33 +896,34 @@ void DefaultReachableRepositories(
                 JustMR::Utils::ResolveRepo(repo_desc->get(), repos);
             if (not resolved_repo_desc) {
                 Logger::Log(LogLevel::Error,
-                            fmt::format("Config: found cyclic dependency for "
+                            fmt::format("Config: Found cyclic dependency for "
                                         "repository {}",
-                                        repo_name));
+                                        nlohmann::json(repo_name).dump()));
                 return kExitUpdateError;
             }
             // get repo_type
             auto repo_type = (*resolved_repo_desc)->At("type");
             if (not repo_type) {
                 Logger::Log(LogLevel::Error,
-                            "Config: mandatory key \"type\" missing "
+                            "Config: Mandatory key \"type\" missing "
                             "for repository {}",
-                            repo_name);
+                            nlohmann::json(repo_name).dump());
                 return kExitUpdateError;
             }
             if (not repo_type->get()->IsString()) {
                 Logger::Log(LogLevel::Error,
-                            "Config: unsupported value for key \'type\' for "
+                            "Config: Unsupported value {} for key \"type\" for "
                             "repository {}",
-                            repo_name);
+                            repo_type->get()->ToString(),
+                            nlohmann::json(repo_name).dump());
                 return kExitUpdateError;
             }
             auto repo_type_str = repo_type->get()->String();
             if (not kCheckoutTypeMap.contains(repo_type_str)) {
                 Logger::Log(LogLevel::Error,
                             "Unknown repository type {} for {}",
-                            repo_type_str,
-                            repo_name);
+                            nlohmann::json(repo_type_str).dump(),
+                            nlohmann::json(repo_name).dump());
                 return kExitUpdateError;
             }
             // only do work if repo is git type
@@ -927,30 +931,32 @@ void DefaultReachableRepositories(
                 auto repo_desc_repository =
                     (*resolved_repo_desc)->At("repository");
                 if (not repo_desc_repository) {
-                    Logger::Log(LogLevel::Error,
-                                "Mandatory field \"repository\" is missing");
+                    Logger::Log(
+                        LogLevel::Error,
+                        "Config: Mandatory field \"repository\" is missing");
                     return kExitUpdateError;
                 }
                 if (not repo_desc_repository->get()->IsString()) {
-                    Logger::Log(
-                        LogLevel::Error,
-                        "Config: unsupported value for key \'repository\' for "
-                        "repository {}",
-                        repo_name);
+                    Logger::Log(LogLevel::Error,
+                                "Config: Unsupported value {} for key "
+                                "\"repository\" for repository {}",
+                                repo_desc_repository->get()->ToString(),
+                                nlohmann::json(repo_name).dump());
                     return kExitUpdateError;
                 }
                 auto repo_desc_branch = (*resolved_repo_desc)->At("branch");
                 if (not repo_desc_branch) {
-                    Logger::Log(LogLevel::Error,
-                                "Mandatory field \"branch\" is missing");
+                    Logger::Log(
+                        LogLevel::Error,
+                        "Config: Mandatory field \"branch\" is missing");
                     return kExitUpdateError;
                 }
                 if (not repo_desc_branch->get()->IsString()) {
-                    Logger::Log(
-                        LogLevel::Error,
-                        "Config: unsupported value for key \'branch\' for "
-                        "repository {}",
-                        repo_name);
+                    Logger::Log(LogLevel::Error,
+                                "Config: Unsupported value {} for key "
+                                "\"branch\" for repository {}",
+                                repo_desc_branch->get()->ToString(),
+                                nlohmann::json(repo_name).dump());
                     return kExitUpdateError;
                 }
                 repos_to_update.emplace_back(
@@ -959,16 +965,16 @@ void DefaultReachableRepositories(
             }
             else {
                 Logger::Log(LogLevel::Error,
-                            "Config: argument {} is not the name of a git type "
-                            "repository",
-                            repo_name);
+                            "Config: Argument {} is not the name of a \"git\" "
+                            "type repository",
+                            nlohmann::json(repo_name).dump());
                 return kExitUpdateError;
             }
         }
         else {
             Logger::Log(LogLevel::Error,
-                        "Config: missing repository description for {}",
-                        repo_name);
+                        "Config: Missing repository description for {}",
+                        nlohmann::json(repo_name).dump());
             return kExitUpdateError;
         }
     }
@@ -1087,7 +1093,8 @@ void DefaultReachableRepositories(
             else {
                 Logger::Log(
                     LogLevel::Error,
-                    "Unsupported value for field 'main' in configuration.");
+                    "Unsupported value {} for field \"main\" in configuration.",
+                    main_from_config->ToString());
             }
         }
     }
@@ -1257,7 +1264,7 @@ void DefaultReachableRepositories(
                 MultiRepoSetup(config, arguments, /*interactive=*/false);
             if (not mr_config_path) {
                 Logger::Log(LogLevel::Error,
-                            "Failed to setup config while calling \'just {}\'",
+                            "Failed to setup config while calling \"just {}\"",
                             *subcommand);
                 return kExitSetupError;
             }
@@ -1315,7 +1322,7 @@ void DefaultReachableRepositories(
     }
 
     Logger::Log(LogLevel::Info,
-                "Setup finished, exec \'{}\'",
+                "Setup finished, exec \"{}\"",
                 nlohmann::json(cmd).dump());
 
     // create argv
diff --git a/src/other_tools/just_mr/utils.cpp b/src/other_tools/just_mr/utils.cpp
index f2272053..24511742 100644
--- a/src/other_tools/just_mr/utils.cpp
+++ b/src/other_tools/just_mr/utils.cpp
@@ -125,7 +125,7 @@ auto ResolveRepo(ExpressionPtr const& repo_desc,
         return ResolveRepo(repo_desc, repos, &seen);
     } catch (std::exception const& e) {
         Logger::Log(LogLevel::Error,
-                    "Config: while resolving dependencies: {}",
+                    "Config: While resolving dependencies: {}",
                     e.what());
         return std::nullopt;
     }
diff --git a/src/other_tools/repo_map/repos_to_setup_map.cpp b/src/other_tools/repo_map/repos_to_setup_map.cpp
index cbdcf6d9..5a8dcb80 100644
--- a/src/other_tools/repo_map/repos_to_setup_map.cpp
+++ b/src/other_tools/repo_map/repos_to_setup_map.cpp
@@ -48,39 +48,41 @@ void GitCheckout(ExpressionPtr const& repo_desc,
     // enforce mandatory fields
     auto repo_desc_commit = repo_desc->At("commit");
     if (not repo_desc_commit) {
-        (*logger)("GitCheckout: Mandatory field \'commit\' is missing",
+        (*logger)("GitCheckout: Mandatory field \"commit\" is missing",
                   /*fatal=*/true);
         return;
     }
     if (not repo_desc_commit->get()->IsString()) {
-        (*logger)(
-            "GitCheckout: Unsupported value for mandatory field \'commit\'",
-            /*fatal=*/true);
+        (*logger)(fmt::format("GitCheckout: Unsupported value {} for mandatory "
+                              "field \"commit\"",
+                              repo_desc_commit->get()->ToString()),
+                  /*fatal=*/true);
         return;
     }
     auto repo_desc_repository = repo_desc->At("repository");
     if (not repo_desc_repository) {
-        (*logger)("GitCheckout: Mandatory field \'repository\' is missing",
+        (*logger)("GitCheckout: Mandatory field \"repository\" is missing",
                   /*fatal=*/true);
         return;
     }
     if (not repo_desc_repository->get()->IsString()) {
-        (*logger)(
-            "GitCheckout: Unsupported value for mandatory field "
-            "\'repository\'",
-            /*fatal=*/true);
+        (*logger)(fmt::format("GitCheckout: Unsupported value {} for mandatory "
+                              "field \"repository\"",
+                              repo_desc_repository->get()->ToString()),
+                  /*fatal=*/true);
         return;
     }
     auto repo_desc_branch = repo_desc->At("branch");
     if (not repo_desc_branch) {
-        (*logger)("GitCheckout: Mandatory field \'branch\' is missing",
+        (*logger)("GitCheckout: Mandatory field \"branch\" is missing",
                   /*fatal=*/true);
         return;
     }
     if (not repo_desc_branch->get()->IsString()) {
-        (*logger)(
-            "GitCheckout: Unsupported value for mandatory field \'branch\'",
-            /*fatal=*/true);
+        (*logger)(fmt::format("GitCheckout: Unsupported value {} for mandatory "
+                              "field \"branch\"",
+                              repo_desc_branch->get()->ToString()),
+                  /*fatal=*/true);
         return;
     }
     auto repo_desc_subdir = repo_desc->Get("subdir", Expression::none_t{});
@@ -109,8 +111,8 @@ void GitCheckout(ExpressionPtr const& repo_desc,
         },
         [logger, repo_name](auto const& msg, bool fatal) {
             (*logger)(fmt::format("While setting the workspace root for "
-                                  "repository {} of type git:\n{}",
-                                  repo_name,
+                                  "repository {} of type \"git\":\n{}",
+                                  nlohmann::json(repo_name).dump(),
                                   msg),
                       fatal);
         });
@@ -129,28 +131,28 @@ void ArchiveCheckout(ExpressionPtr const& repo_desc,
     // enforce mandatory fields
     auto repo_desc_content = repo_desc->At("content");
     if (not repo_desc_content) {
-        (*logger)("ArchiveCheckout: Mandatory field \'content\' is missing",
+        (*logger)("ArchiveCheckout: Mandatory field \"content\" is missing",
                   /*fatal=*/true);
         return;
     }
     if (not repo_desc_content->get()->IsString()) {
-        (*logger)(
-            "ArchiveCheckout: Unsupported value for mandatory field "
-            "\'content\'",
-            /*fatal=*/true);
+        (*logger)(fmt::format("ArchiveCheckout: Unsupported value {} for "
+                              "mandatory field \"content\"",
+                              repo_desc_content->get()->ToString()),
+                  /*fatal=*/true);
         return;
     }
     auto repo_desc_fetch = repo_desc->At("fetch");
     if (not repo_desc_fetch) {
-        (*logger)("ArchiveCheckout: Mandatory field \'fetch\' is missing",
+        (*logger)("ArchiveCheckout: Mandatory field \"fetch\" is missing",
                   /*fatal=*/true);
         return;
     }
     if (not repo_desc_fetch->get()->IsString()) {
-        (*logger)(
-            "ArchiveCheckout: Unsupported value for mandatory field "
-            "\'fetch\'",
-            /*fatal=*/true);
+        (*logger)(fmt::format("ArchiveCheckout: Unsupported value {} for "
+                              "mandatory field \"fetch\"",
+                              repo_desc_fetch->get()->ToString()),
+                  /*fatal=*/true);
         return;
     }
     auto repo_desc_subdir = repo_desc->Get("subdir", Expression::none_t{});
@@ -195,8 +197,8 @@ void ArchiveCheckout(ExpressionPtr const& repo_desc,
         [logger, repo_name, repo_type](auto const& msg, bool fatal) {
             (*logger)(fmt::format("While setting the workspace root for "
                                   "repository {} of type {}:\n{}",
-                                  repo_name,
-                                  repo_type,
+                                  nlohmann::json(repo_name).dump(),
+                                  nlohmann::json(repo_type).dump(),
                                   msg),
                       fatal);
         });
@@ -214,14 +216,15 @@ void FileCheckout(ExpressionPtr const& repo_desc,
     // enforce mandatory fields
     auto repo_desc_path = repo_desc->At("path");
     if (not repo_desc_path) {
-        (*logger)("FileCheckout: Mandatory field \'path\' is missing",
+        (*logger)("FileCheckout: Mandatory field \"path\" is missing",
                   /*fatal=*/true);
         return;
     }
     if (not repo_desc_path->get()->IsString()) {
-        (*logger)(
-            "FileCheckout: Unsupported value for mandatory field \'path\'",
-            /*fatal=*/true);
+        (*logger)(fmt::format("FileCheckout: Unsupported value {} for "
+                              "mandatory field \"path\"",
+                              repo_desc_path->get()->ToString()),
+                  /*fatal=*/true);
         return;
     }
     // get absolute path
@@ -252,8 +255,8 @@ void FileCheckout(ExpressionPtr const& repo_desc,
             },
             [logger, repo_name](auto const& msg, bool fatal) {
                 (*logger)(fmt::format("While setting the workspace root for "
-                                      "repository {} of type file:\n{}",
-                                      repo_name,
+                                      "repository {} of type \"file\":\n{}",
+                                      nlohmann::json(repo_name).dump(),
                                       msg),
                           fatal);
             });
@@ -283,15 +286,15 @@ void DistdirCheckout(ExpressionPtr const& repo_desc,
     auto repo_desc_repositories = repo_desc->At("repositories");
     if (not repo_desc_repositories) {
         (*logger)(
-            "DistdirCheckout: Mandatory field \'repositories\' is missing",
+            "DistdirCheckout: Mandatory field \"repositories\" is missing",
             /*fatal=*/true);
         return;
     }
     if (not repo_desc_repositories->get()->IsList()) {
-        (*logger)(
-            "DistdirCheckout: Unsupported value for mandatory field "
-            "\'repositories\'",
-            /*fatal=*/true);
+        (*logger)(fmt::format("DistdirCheckout: Unsupported value {} for "
+                              "mandatory field \"repositories\"",
+                              repo_desc_repositories->get()->ToString()),
+                  /*fatal=*/true);
         return;
     }
     // map of distfile to content
@@ -307,17 +310,17 @@ void DistdirCheckout(ExpressionPtr const& repo_desc,
         // check that repo name exists
         auto repos_dist_repo_name = repos->At(dist_repo_name);
         if (not repos_dist_repo_name) {
-            (*logger)(fmt::format("DistdirCheckout: no repository named {}",
-                                  dist_repo_name),
+            (*logger)(fmt::format("DistdirCheckout: No repository named {}",
+                                  nlohmann::json(dist_repo_name).dump()),
                       /*fatal=*/true);
             return;
         }
         auto repo_desc = repos_dist_repo_name->get()->At("repository");
         if (not repo_desc) {
             (*logger)(
-                fmt::format("DistdirCheckout: mandatory key \'repository\' "
+                fmt::format("DistdirCheckout: Mandatory key \"repository\" "
                             "missing for repository {}",
-                            dist_repo_name),
+                            nlohmann::json(dist_repo_name).dump()),
                 /*fatal=*/true);
             return;
         }
@@ -325,35 +328,36 @@ void DistdirCheckout(ExpressionPtr const& repo_desc,
             JustMR::Utils::ResolveRepo(repo_desc->get(), repos);
         if (not resolved_repo_desc) {
             (*logger)(
-                fmt::format("DistdirCheckout: found cyclic dependency for "
+                fmt::format("DistdirCheckout: Found cyclic dependency for "
                             "repository {}",
-                            dist_repo_name),
+                            nlohmann::json(dist_repo_name).dump()),
                 /*fatal=*/true);
             return;
         }
         auto repo_type = (*resolved_repo_desc)->At("type");
         if (not repo_type) {
             (*logger)(
-                fmt::format("DistdirCheckout: mandatory key \'type\' missing "
+                fmt::format("DistdirCheckout: Mandatory key \"type\" missing "
                             "for repository {}",
-                            dist_repo_name),
+                            nlohmann::json(dist_repo_name).dump()),
                 /*fatal=*/true);
             return;
         }
         if (not repo_type->get()->IsString()) {
-            (*logger)(fmt::format("DistdirCheckout: unsupported value for key "
-                                  "\'type\' for repository {}",
-                                  dist_repo_name),
+            (*logger)(fmt::format("DistdirCheckout: Unsupported value {} for "
+                                  "key \"type\" for repository {}",
+                                  repo_type->get()->ToString(),
+                                  nlohmann::json(dist_repo_name).dump()),
                       /*fatal=*/true);
             return;
         }
         // get repo_type
         auto repo_type_str = repo_type->get()->String();
         if (not kCheckoutTypeMap.contains(repo_type_str)) {
-            (*logger)(fmt::format("DistdirCheckout: unknown type {} for "
+            (*logger)(fmt::format("DistdirCheckout: Unknown type {} for "
                                   "repository {}",
-                                  repo_type_str,
-                                  dist_repo_name),
+                                  nlohmann::json(repo_type_str).dump(),
+                                  nlohmann::json(dist_repo_name).dump()),
                       /*fatal=*/true);
             return;
         }
@@ -363,30 +367,30 @@ void DistdirCheckout(ExpressionPtr const& repo_desc,
             auto repo_desc_content = (*resolved_repo_desc)->At("content");
             if (not repo_desc_content) {
                 (*logger)(
-                    "DistdirCheckout: Mandatory field \'content\' is "
+                    "DistdirCheckout: Mandatory field \"content\" is "
                     "missing",
                     /*fatal=*/true);
                 return;
             }
             if (not repo_desc_content->get()->IsString()) {
-                (*logger)(
-                    "DistdirCheckout: Unsupported value for mandatory "
-                    "field \'content\'",
-                    /*fatal=*/true);
+                (*logger)(fmt::format("DistdirCheckout: Unsupported value {} "
+                                      "for mandatory field \"content\"",
+                                      repo_desc_content->get()->ToString()),
+                          /*fatal=*/true);
                 return;
             }
             auto repo_desc_fetch = (*resolved_repo_desc)->At("fetch");
             if (not repo_desc_fetch) {
                 (*logger)(
-                    "DistdirCheckout: Mandatory field \'fetch\' is missing",
+                    "DistdirCheckout: Mandatory field \"fetch\" is missing",
                     /*fatal=*/true);
                 return;
             }
             if (not repo_desc_fetch->get()->IsString()) {
-                (*logger)(
-                    "DistdirCheckout: Unsupported value for mandatory "
-                    "field \'fetch\'",
-                    /*fatal=*/true);
+                (*logger)(fmt::format("DistdirCheckout: Unsupported value {} "
+                                      "for mandatory field \"fetch\"",
+                                      repo_desc_fetch->get()->ToString()),
+                          /*fatal=*/true);
                 return;
             }
             auto repo_desc_distfile =
@@ -442,8 +446,8 @@ void DistdirCheckout(ExpressionPtr const& repo_desc,
         },
         [logger, repo_name](auto const& msg, bool fatal) {
             (*logger)(fmt::format("While setting the workspace root for "
-                                  "repository {} of type distdir:\n{}",
-                                  repo_name,
+                                  "repository {} of type \"distdir\":\n{}",
+                                  nlohmann::json(repo_name).dump(),
                                   msg),
                       fatal);
         });
@@ -461,26 +465,28 @@ void GitTreeCheckout(ExpressionPtr const& repo_desc,
     // enforce mandatory fields
     auto repo_desc_hash = repo_desc->At("id");
     if (not repo_desc_hash) {
-        (*logger)("GitTreeCheckout: Mandatory field \'id\' is missing",
+        (*logger)("GitTreeCheckout: Mandatory field \"id\" is missing",
                   /*fatal=*/true);
         return;
     }
     if (not repo_desc_hash->get()->IsString()) {
-        (*logger)(
-            "GitTreeCheckout: Unsupported value for mandatory field \'id\'",
-            /*fatal=*/true);
+        (*logger)(fmt::format("GitTreeCheckout: Unsupported value {} for "
+                              "mandatory field \"id\"",
+                              repo_desc_hash->get()->ToString()),
+                  /*fatal=*/true);
         return;
     }
     auto repo_desc_cmd = repo_desc->At("cmd");
     if (not repo_desc_cmd) {
-        (*logger)("GitTreeCheckout: Mandatory field \'cmd\' is missing",
+        (*logger)("GitTreeCheckout: Mandatory field \"cmd\" is missing",
                   /*fatal=*/true);
         return;
     }
     if (not repo_desc_cmd->get()->IsList()) {
-        (*logger)(
-            "GitTreeCheckout: Unsupported value for mandatory field \'cmd\'",
-            /*fatal=*/true);
+        (*logger)(fmt::format("GitTreeCheckout: Unsupported value {} for "
+                              "mandatory field \"cmd\"",
+                              repo_desc_cmd->get()->ToString()),
+                  /*fatal=*/true);
         return;
     }
     std::vector<std::string> cmd{};
@@ -490,7 +496,7 @@ void GitTreeCheckout(ExpressionPtr const& repo_desc,
         }
         else {
             (*logger)(fmt::format("GitTreeCheckout: Unsupported entry {} in "
-                                  "mandatory field \'cmd\'",
+                                  "mandatory field \"cmd\"",
                                   token->ToString()),
                       /*fatal=*/true);
             return;
@@ -505,7 +511,7 @@ void GitTreeCheckout(ExpressionPtr const& repo_desc,
             }
             else {
                 (*logger)(fmt::format("GitTreeCheckout: Unsupported value {} "
-                                      "for key {} in optional field \'envs\'",
+                                      "for key {} in optional field \"envs\"",
                                       envar.second->ToString(),
                                       nlohmann::json(envar.first).dump()),
                           /*fatal=*/true);
@@ -532,8 +538,8 @@ void GitTreeCheckout(ExpressionPtr const& repo_desc,
         },
         [logger, repo_name](auto const& msg, bool fatal) {
             (*logger)(fmt::format("While setting the workspace root for "
-                                  "repository {} of type git tree:\n{}",
-                                  repo_name,
+                                  "repository {} of type \"git tree\":\n{}",
+                                  nlohmann::json(repo_name).dump(),
                                   msg),
                       fatal);
         });
@@ -575,41 +581,42 @@ auto CreateReposToSetupMap(std::shared_ptr<Configuration> const& config,
             // repository requires checkout
             auto repo_desc_key = repos->At(key);
             if (not repo_desc_key) {
-                (*logger)(fmt::format("Config: missing config entry "
-                                      "for repository {}",
-                                      key),
+                (*logger)(fmt::format(
+                              "Config: Missing config entry for repository {}",
+                              nlohmann::json(key).dump()),
                           /*fatal=*/true);
                 return;
             }
             auto repo_desc = repo_desc_key->get()->At("repository");
             if (not repo_desc) {
-                (*logger)(fmt::format("Config: mandatory key \'repository\' "
+                (*logger)(fmt::format("Config: Mandatory key \"repository\" "
                                       "missing for repository {}",
-                                      key),
+                                      nlohmann::json(key).dump()),
                           /*fatal=*/true);
                 return;
             }
             auto resolved_repo_desc =
                 JustMR::Utils::ResolveRepo(repo_desc->get(), repos);
             if (not resolved_repo_desc) {
-                (*logger)(fmt::format("Config: found cyclic dependency for "
+                (*logger)(fmt::format("Config: Found cyclic dependency for "
                                       "repository {}",
-                                      key),
+                                      nlohmann::json(key).dump()),
                           /*fatal=*/true);
                 return;
             }
             auto repo_type = (*resolved_repo_desc)->At("type");
             if (not repo_type) {
-                (*logger)(fmt::format("Config: mandatory key \'type\' missing "
+                (*logger)(fmt::format("Config: Mandatory key \"type\" missing "
                                       "for repository {}",
-                                      key),
+                                      nlohmann::json(key).dump()),
                           /*fatal=*/true);
                 return;
             }
             if (not repo_type->get()->IsString()) {
-                (*logger)(fmt::format("Config: unsupported value for key "
-                                      "\'type\' for repository {}",
-                                      key),
+                (*logger)(fmt::format("Config: Unsupported value {} for key "
+                                      "\"type\" for repository {}",
+                                      repo_type->get()->ToString(),
+                                      nlohmann::json(key).dump()),
                           /*fatal=*/true);
                 return;
             }
@@ -617,20 +624,19 @@ auto CreateReposToSetupMap(std::shared_ptr<Configuration> const& config,
             auto repo_type_str = repo_type->get()->String();
             if (not kCheckoutTypeMap.contains(repo_type_str)) {
                 (*logger)(
-                    fmt::format("Config: unknown type {} for repository {}",
-                                repo_type_str,
-                                key),
+                    fmt::format("Config: Unknown type {} for repository {}",
+                                nlohmann::json(repo_type_str).dump(),
+                                nlohmann::json(key).dump()),
                     /*fatal=*/true);
                 return;
             }
             // setup a wrapped_logger
             auto wrapped_logger = std::make_shared<AsyncMapConsumerLogger>(
                 [logger, repo_name = key](auto const& msg, bool fatal) {
-                    (*logger)(
-                        fmt::format("While checking out repository {}:\n{}",
-                                    repo_name,
-                                    msg),
-                        fatal);
+                    (*logger)(fmt::format("While setting up repository {}:\n{}",
+                                          nlohmann::json(repo_name).dump(),
+                                          msg),
+                              fatal);
                 });
             // do checkout
             switch (kCheckoutTypeMap.at(repo_type_str)) {