feat(logging): add Loggers registry (6/6)

Final block: configuration-driven backend selection, mirroring MetricsReporters.

- Loggers::Register(type, factory) registers a named backend; Loggers::Load(props)
  builds one, selecting the type from the "logger-impl" property key.
- Built-in factories: "noop", "cerr", and (only when built with ICEBERG_SPDLOG)
  "spdlog". With no logger-impl set, the default is spdlog when compiled in, else
  cerr -- logs by default, an intentional divergence from the metrics registry's
  noop default.
- Loggers::LoadAndSetDefault(props) loads a logger and installs it as the process
  default.

This completes the system end to end: levels -> Logger interface + default logger
-> CerrLogger/SpdLogger backends -> macros -> configuration-driven selection.
loggers_test covers load default/noop/cerr, unknown-type errors, empty-factory
rejection, custom Register, and LoadAndSetDefault.

Adds logging_end_to_end_test, which drives the public surface as an application
does -- now that every layer is present: configure a backend via the registry,
install it as the default, log through the LOG_* macros, and observe real output.
Covers registry -> default-slot -> macro -> backend -> std::cerr output, level
filtering through the full macro path, the compiled-backend identity of the
default (spdlog when ON, cerr when OFF), the "spdlog" factory by name, and a macro
statement reaching a real spdlog sink.

Co-authored-by: Isaac

Author: kamcheungting-db

src/iceberg/CMakeLists.txt

@@ -56,6 +56,7 @@ set(ICEBERG_SOURCES
     location_provider.cc
     logging/cerr_logger.cc
     logging/logger.cc
+    logging/loggers.cc
     logging/spdlog_logger.cc
     manifest/manifest_adapter.cc
     manifest/manifest_entry.cc

src/iceberg/logging/loggers.cc

@@ -0,0 +1,147 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/logging/loggers.h"
+
+#include <exception>
+#include <memory>
+#include <mutex>
+#include <shared_mutex>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+// Build-generated, .cc-only. Defines ICEBERG_HAS_SPDLOG; tested with #ifdef.
+#include "iceberg/logging/cerr_logger.h"
+#include "iceberg/logging/config.h"
+#include "iceberg/util/macros.h"
+#ifdef ICEBERG_HAS_SPDLOG
+#  include "iceberg/logging/spdlog_logger_internal.h"
+#endif
+
+namespace iceberg {
+
+namespace {
+
+/// \brief Registry-constructible no-op logger (Load returns unique_ptr).
+class NoopLogger final : public Logger {
+ public:
+  bool ShouldLog(LogLevel /*level*/) const noexcept override { return false; }
+  void Log(LogMessage&& /*message*/) noexcept override {}
+  void SetLevel(LogLevel /*level*/) noexcept override {}
+  LogLevel level() const noexcept override { return LogLevel::kOff; }
+  bool IsNoop() const override { return true; }
+};
+
+/// \brief Extract the logger type, defaulting to the compiled-in backend.
+std::string InferLoggerType(
+    const std::unordered_map<std::string, std::string>& properties) {
+  auto it = properties.find(std::string(kLoggerImpl));
+  if (it != properties.end() && !it->second.empty()) {
+    return it->second;
+  }
+#ifdef ICEBERG_HAS_SPDLOG
+  return std::string(kLoggerTypeSpdlog);
+#else
+  return std::string(kLoggerTypeCerr);
+#endif
+}
+
+struct LoggerRegistryState {
+  std::shared_mutex mtx;
+  std::unordered_map<std::string, LoggerFactory> map;
+};
+
+LoggerRegistryState& GetRegistry() {
+  static auto* state =
+      new LoggerRegistryState{.map = {
+                                  {std::string(kLoggerTypeNoop),
+                                   [](const std::unordered_map<std::string, std::string>&)
+                                       -> Result<std::unique_ptr<Logger>> {
+                                     return std::make_unique<NoopLogger>();
+                                   }},
+                                  {std::string(kLoggerTypeCerr),
+                                   [](const std::unordered_map<std::string, std::string>&)
+                                       -> Result<std::unique_ptr<Logger>> {
+                                     return std::make_unique<CerrLogger>();
+                                   }},
+#ifdef ICEBERG_HAS_SPDLOG
+                                  {std::string(kLoggerTypeSpdlog),
+                                   [](const std::unordered_map<std::string, std::string>&)
+                                       -> Result<std::unique_ptr<Logger>> {
+                                     return std::make_unique<internal::SpdLogger>();
+                                   }},
+#endif
+                              }};
+  return *state;
+}
+
+}  // namespace
+
+Status Loggers::Register(std::string_view logger_type, LoggerFactory factory) {
+  if (!factory) {
+    return InvalidArgument("Logger factory for '{}' must not be empty", logger_type);
+  }
+  auto& registry = GetRegistry();
+  std::unique_lock lock(registry.mtx);
+  registry.map[std::string(logger_type)] = std::move(factory);
+  return {};
+}
+
+Result<std::unique_ptr<Logger>> Loggers::Load(
+    const std::unordered_map<std::string, std::string>& properties) {
+  std::string logger_type = InferLoggerType(properties);
+
+  LoggerFactory factory;
+  {
+    auto& registry = GetRegistry();
+    std::shared_lock lock(registry.mtx);
+    auto it = registry.map.find(logger_type);
+    if (it == registry.map.end()) {
+      return InvalidArgument(
+          "Unknown logger type '{}'. Register a factory with Loggers::Register() "
+          "before using this type.",
+          logger_type);
+    }
+    factory = it->second;
+  }
+
+  try {
+    ICEBERG_ASSIGN_OR_RAISE(auto logger, factory(properties));
+    if (!logger) {
+      return InvalidArgument("Logger factory for '{}' returned null", logger_type);
+    }
+    ICEBERG_RETURN_UNEXPECTED(logger->Initialize(properties));
+    return logger;
+  } catch (const std::exception& ex) {
+    return InvalidArgument("Logger factory for '{}' failed: {}", logger_type, ex.what());
+  } catch (...) {
+    return InvalidArgument("Logger factory for '{}' failed with unknown exception",
+                           logger_type);
+  }
+}
+
+Status Loggers::LoadAndSetDefault(
+    const std::unordered_map<std::string, std::string>& properties) {
+  ICEBERG_ASSIGN_OR_RAISE(auto logger, Load(properties));
+  SetDefaultLogger(std::shared_ptr<Logger>(std::move(logger)));
+  return {};
+}
+
+}  // namespace iceberg

src/iceberg/logging/loggers.h

@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#pragma once
+
+/// \file iceberg/logging/loggers.h
+/// \brief Property-driven registry/factory for Logger backends.
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+#include "iceberg/iceberg_export.h"
+#include "iceberg/logging/logger.h"
+#include "iceberg/result.h"
+
+namespace iceberg {
+
+/// \brief Property key selecting the logger implementation.
+constexpr std::string_view kLoggerImpl = "logger-impl";
+/// \brief Built-in logger type identifiers.
+constexpr std::string_view kLoggerTypeNoop = "noop";
+constexpr std::string_view kLoggerTypeCerr = "cerr";
+constexpr std::string_view kLoggerTypeSpdlog = "spdlog";
+
+/// \brief Factory constructing a Logger from catalog-style properties.
+using LoggerFactory = std::function<Result<std::unique_ptr<Logger>>(
+    const std::unordered_map<std::string, std::string>& properties)>;
+
+/// \brief Registry of logger factories, mirroring MetricsReporters.
+///
+/// Built-in factories: "noop", "cerr", and (only when built with ICEBERG_SPDLOG)
+/// "spdlog". When the "logger-impl" property is absent, the default is "spdlog"
+/// if compiled in, otherwise "cerr" -- an intentional divergence from the metrics
+/// registry's noop default (we want logs by default).
+class ICEBERG_EXPORT Loggers {
+ public:
+  /// \brief Construct and initialize a logger from properties.
+  static Result<std::unique_ptr<Logger>> Load(
+      const std::unordered_map<std::string, std::string>& properties);
+
+  /// \brief Register a factory for \p logger_type (overwrites any existing).
+  static Status Register(std::string_view logger_type, LoggerFactory factory);
+
+  /// \brief Load a logger from properties and install it as the default.
+  static Status LoadAndSetDefault(
+      const std::unordered_map<std::string, std::string>& properties);
+};
+
+}  // namespace iceberg

src/iceberg/logging/meson.build

@@ -29,6 +29,7 @@ install_headers(
         'log_level.h',
         'log_macros.h',
         'logger.h',
+        'loggers.h',
         'short_log_macros.h',
     ],
     subdir: 'iceberg/logging',

src/iceberg/meson.build

@@ -108,6 +108,7 @@ iceberg_sources = files(
     'location_provider.cc',
     'logging/cerr_logger.cc',
     'logging/logger.cc',
+    'logging/loggers.cc',
     'logging/spdlog_logger.cc',
     'manifest/manifest_adapter.cc',
     'manifest/manifest_entry.cc',

src/iceberg/test/CMakeLists.txt

@@ -96,6 +96,8 @@ add_iceberg_test(logging_test
                  cerr_logger_test.cc
                  log_level_test.cc
                  logger_test.cc
+                 loggers_test.cc
+                 logging_end_to_end_test.cc
                  macros_active_level_test.cc
                  macros_test.cc
                  spdlog_logger_test.cc)