remove spdlog as dep

Author: stephen-derosa

CMakeLists.txt

@@ -45,12 +45,6 @@ else()
   message(FATAL_ERROR "Could not find a LiveKit core target (expected LiveKit::livekit or livekit).")
 endif()
 
-if(DEFINED _SPDLOG_ACTIVE_LEVEL AND NOT "${_SPDLOG_ACTIVE_LEVEL}" STREQUAL "")
-  add_compile_definitions(SPDLOG_ACTIVE_LEVEL=${_SPDLOG_ACTIVE_LEVEL})
-else()
-  add_compile_definitions(SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_INFO)
-endif()
-
 set(LIVEKIT_DATA_DIR "")
 if(DEFINED LIVEKIT_ROOT_DIR AND EXISTS "${LIVEKIT_ROOT_DIR}/data")
   set(LIVEKIT_DATA_DIR "${LIVEKIT_ROOT_DIR}/data")

hello_livekit_receiver/main.cpp

@@ -30,6 +30,7 @@
 #include <chrono>
 #include <csignal>
 #include <cstdlib>
+#include <iostream>
 #include <thread>
 
 using namespace livekit;
@@ -58,10 +59,7 @@ int main(int argc, char *argv[]) {
   }
 
   if (url.empty() || receiver_token.empty() || sender_identity.empty()) {
-    LK_LOG_ERROR("Usage: HelloLivekitReceiver <ws-url> <receiver-token> "
-                 "<sender-identity>\n"
-                 "  or set LIVEKIT_URL, LIVEKIT_RECEIVER_TOKEN, "
-                 "LIVEKIT_SENDER_IDENTITY");
+    std::cerr << "[error] Usage: HelloLivekitReceiver <ws-url> <receiver-token> <sender-identity>\n  or set LIVEKIT_URL, LIVEKIT_RECEIVER_TOKEN, LIVEKIT_SENDER_IDENTITY\n";
     return 1;
   }
 
@@ -78,17 +76,15 @@ int main(int argc, char *argv[]) {
   options.dynacast = false;
 
   if (!room->Connect(url, receiver_token, options)) {
-    LK_LOG_ERROR("[receiver] Failed to connect");
+    std::cerr << "[error] [receiver] Failed to connect\n";
     livekit::shutdown();
     return 1;
   }
 
   LocalParticipant *lp = room->localParticipant();
   assert(lp);
 
-  LK_LOG_INFO("[receiver] Connected as identity='{}' room='{}'; subscribing "
-              "to sender identity='{}'",
-              lp->identity(), room->room_info().name, sender_identity);
+  std::cout << "[info] [receiver] Connected as identity='" << lp->identity() << "' room='" << room->room_info().name << "'; subscribing to sender identity='" << sender_identity << "'\n";
 
   int video_frame_count = 0;
   room->setOnVideoFrameCallback(
@@ -98,8 +94,7 @@ int main(int argc, char *argv[]) {
             std::chrono::duration<double, std::milli>(timestamp_us).count();
         const int n = video_frame_count++;
         if (n % 10 == 0) {
-          LK_LOG_INFO("[receiver] Video frame #{} {}x{} ts_ms={}", n,
-                      frame.width(), frame.height(), ts_ms);
+          std::cout << "[info] [receiver] Video frame #" << n << " " << frame.width() << "x" << frame.height() << " ts_ms=" << ts_ms << "\n";
         }
       });
 
@@ -110,19 +105,17 @@ int main(int argc, char *argv[]) {
                           std::optional<std::uint64_t> user_ts) {
         const int n = data_frame_count++;
         if (n % 10 == 0) {
-          LK_LOG_INFO("[receiver] Data frame #{}", n);
+          std::cout << "[info] [receiver] Data frame #" << n << "\n";
         }
       });
 
-  LK_LOG_INFO("[receiver] Listening for video track '{}' + data track '{}'; "
-              "Ctrl-C to exit",
-              kVideoTrackName, kDataTrackName);
+  std::cout << "[info] [receiver] Listening for video track '" << kVideoTrackName << "' + data track '" << kDataTrackName << "'; Ctrl-C to exit\n";
 
   while (g_running.load()) {
     std::this_thread::sleep_for(std::chrono::milliseconds(50));
   }
 
-  LK_LOG_INFO("[receiver] Shutting down");
+  std::cout << "[info] [receiver] Shutting down\n";
   room.reset();
 
   livekit::shutdown();

hello_livekit_sender/main.cpp

@@ -32,6 +32,7 @@
 #include <iomanip>
 #include <sstream>
 #include <thread>
+#include <iostream>
 
 using namespace livekit;
 
@@ -59,8 +60,7 @@ int main(int argc, char *argv[]) {
   }
 
   if (url.empty() || sender_token.empty()) {
-    LK_LOG_ERROR("Usage: HelloLivekitSender <ws-url> <sender-token>\n"
-                 "  or set LIVEKIT_URL, LIVEKIT_SENDER_TOKEN");
+    std::cerr << "[error] Usage: HelloLivekitSender <ws-url> <sender-token>\n  or set LIVEKIT_URL, LIVEKIT_SENDER_TOKEN\n";
     return 1;
   }
 
@@ -77,17 +77,15 @@ int main(int argc, char *argv[]) {
   options.dynacast = false;
 
   if (!room->Connect(url, sender_token, options)) {
-    LK_LOG_ERROR("[sender] Failed to connect");
+    std::cerr << "[error] [sender] Failed to connect\n";
     livekit::shutdown();
     return 1;
   }
 
   LocalParticipant *lp = room->localParticipant();
   assert(lp);
 
-  LK_LOG_INFO("[sender] Connected as identity='{}' room='{}' — pass this "
-              "identity to HelloLivekitReceiver",
-              lp->identity(), room->room_info().name);
+  std::cout << "[info] [sender] Connected as identity='" << lp->identity() << "' room='" << room->room_info().name << "' — pass this identity to HelloLivekitReceiver\n";
 
   auto video_source = std::make_shared<VideoSource>(kWidth, kHeight);
 
@@ -97,8 +95,7 @@ int main(int argc, char *argv[]) {
   auto publish_result = lp->publishDataTrack(kDataTrackName);
   if (!publish_result) {
     const auto &error = publish_result.error();
-    LK_LOG_ERROR("Failed to publish data track: code={} message={}",
-                 static_cast<std::uint32_t>(error.code), error.message);
+    std::cerr << "[error] Failed to publish data track: code=" << static_cast<std::uint32_t>(error.code) << " message=" << error.message << "\n";
     room.reset();
     livekit::shutdown();
     return 1;
@@ -108,9 +105,7 @@ int main(int argc, char *argv[]) {
   const auto t0 = std::chrono::steady_clock::now();
   std::uint64_t count = 0;
 
-  LK_LOG_INFO(
-      "[sender] Publishing synthetic video + data on '{}'; Ctrl-C to exit",
-      kDataTrackName);
+  std::cout << "[info] [sender] Publishing synthetic video + data on '" << kDataTrackName << "'; Ctrl-C to exit\n";
 
   while (g_running.load()) {
     VideoFrame vf = VideoFrame::create(kWidth, kHeight, VideoBufferType::RGBA);
@@ -126,15 +121,14 @@ int main(int argc, char *argv[]) {
         data_track->tryPush(std::vector<std::uint8_t>(msg.begin(), msg.end()));
     if (!push_result) {
       const auto &error = push_result.error();
-      LK_LOG_WARN("Failed to push data frame: code={} message={}",
-                  static_cast<std::uint32_t>(error.code), error.message);
+      std::cerr << "[warn] Failed to push data frame: code=" << static_cast<std::uint32_t>(error.code) << " message=" << error.message << "\n";
     }
 
     ++count;
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
   }
 
-  LK_LOG_INFO("[sender] Disconnecting");
+  std::cout << "[info] [sender] Disconnecting\n";
   room.reset();
 
   livekit::shutdown();

logging_levels_basic_usage/main.cpp

@@ -14,33 +14,26 @@
  * limitations under the License.
  */
 
-/// @file main.cpp
+/// @file basic_usage.cpp
 /// @brief Demonstrates LiveKit SDK log-level control and custom log callbacks.
 ///
-/// Logging has two tiers of filtering:
+/// The SDK internally uses spdlog for its own logging. Client applications
+/// control SDK log output through two public APIs:
 ///
-///   1. **Compile-time** (LIVEKIT_LOG_LEVEL, set via CMake):
-///      Calls below this level are stripped from the binary entirely.
-///      Default is TRACE (nothing stripped). For a lean release build:
-///        cmake -DLIVEKIT_LOG_LEVEL=WARN ...
-///
-///   2. **Runtime** (setLogLevel()):
-///      Among the levels that survived compilation, setLogLevel() controls
-///      which ones actually produce output. This is what this example demos.
+///   - livekit::setLogLevel()    — filter SDK messages by severity.
+///   - livekit::setLogCallback() — redirect SDK log output to your own handler.
 ///
 /// Usage:
-///   LoggingLevels [trace|debug|info|warn|error|critical|off]
+///   LoggingLevelsBasicUsage [trace|debug|info|warn|error|critical|off]
 ///
-/// If no argument is given, the example cycles through every level so you can
-/// see which messages are filtered at each setting.
+/// If no argument is given, the example cycles through every level and then
+/// demonstrates the custom callback API.
 
 #include "livekit/livekit.h"
-#include "livekit/lk_log.h"
 
 #include <cstring>
 #include <iostream>
 #include <string>
-#include <thread>
 
 namespace {
 
@@ -84,16 +77,6 @@ livekit::LogLevel parseLevel(const char *arg) {
   return livekit::LogLevel::Info;
 }
 
-/// Emit one message at every severity level using the LK_LOG_* macros.
-void emitAllLevels() {
-  LK_LOG_TRACE("This is a TRACE message (very verbose internals)");
-  LK_LOG_DEBUG("This is a DEBUG message (diagnostic detail)");
-  LK_LOG_INFO("This is an INFO message (normal operation)");
-  LK_LOG_WARN("This is a WARN message (something unexpected)");
-  LK_LOG_ERROR("This is an ERROR message (something failed)");
-  LK_LOG_CRITICAL("This is a CRITICAL message (unrecoverable)");
-}
-
 /// Demonstrate cycling through every log level.
 void runLevelCycleDemo() {
   const livekit::LogLevel levels[] = {
@@ -108,7 +91,8 @@ void runLevelCycleDemo() {
               << " Setting log level to: " << levelName(level) << "\n"
               << "========================================\n";
     livekit::setLogLevel(level);
-    emitAllLevels();
+    std::cout << "  Current SDK log level: "
+              << levelName(livekit::getLogLevel()) << "\n";
   }
 }
 
@@ -120,40 +104,41 @@ void runCallbackDemo() {
 
   livekit::setLogLevel(livekit::LogLevel::Trace);
 
-  // Install a user-defined callback that captures all log output.
-  // In a real ROS2 node you would replace this with RCLCPP_* macros.
   livekit::setLogCallback([](livekit::LogLevel level,
                              const std::string &logger_name,
                              const std::string &message) {
     std::cout << "[CALLBACK] [" << levelName(level) << "] [" << logger_name
               << "] " << message << "\n";
   });
 
-  LK_LOG_INFO("This message is routed through the custom callback");
-  LK_LOG_WARN("Warnings also go through the callback");
-  LK_LOG_ERROR("Errors too -- the callback sees everything >= the level");
+  std::cout << "Installed custom callback. SDK log messages will now be "
+               "routed through it.\n";
 
   // Restore default stderr sink by passing an empty callback.
   livekit::setLogCallback(nullptr);
 
-  std::cout << "\n(Restored default stderr sink)\n";
-  LK_LOG_INFO("This message goes to stderr again (default sink)");
+  std::cout << "(Restored default stderr sink)\n";
 }
 
 } // namespace
 
 int main(int argc, char *argv[]) {
-  // Initialize the LiveKit SDK (creates the spdlog logger).
   livekit::initialize();
 
   if (argc > 1) {
-    // Single-level mode: set the requested level and emit all messages.
+    if (std::strcmp(argv[1], "-h") == 0 ||
+        std::strcmp(argv[1], "--help") == 0) {
+      std::cout << "Usage: LoggingLevelsBasicUsage "
+                   "[trace|debug|info|warn|error|critical|off]\n";
+      livekit::shutdown();
+      return 0;
+    }
     livekit::LogLevel level = parseLevel(argv[1]);
     std::cout << "Setting log level to: " << levelName(level) << "\n\n";
     livekit::setLogLevel(level);
-    emitAllLevels();
+    std::cout << "Current SDK log level: "
+              << levelName(livekit::getLogLevel()) << "\n";
   } else {
-    // Full demo: cycle through levels, then show the callback API.
     runLevelCycleDemo();
     runCallbackDemo();
   }