Merge pull request #587 from luxonis/fix_logging_level

Respect log level, even if higher than WARN

Author: moratom

cmake/Depthai/DepthaiDeviceSideConfig.cmake

@@ -2,7 +2,7 @@
 set(DEPTHAI_DEVICE_SIDE_MATURITY "snapshot")
 
 # "full commit hash of device side binary"
-set(DEPTHAI_DEVICE_SIDE_COMMIT "2470bb3fb3855de1808cf3cc94509ee771bae7d5")
+set(DEPTHAI_DEVICE_SIDE_COMMIT "1a59c80266cd7a30ba874aa8d4a8277e0bf161ec")
 
 # "version if applicable"
 set(DEPTHAI_DEVICE_SIDE_VERSION "")

src/device/DeviceBase.cpp

@@ -732,15 +732,9 @@ void DeviceBase::init2(Config cfg, const dai::Path& pathToMvcmd, tl::optional<co
 
     // Below can throw - make sure to gracefully exit threads
     try {
-        // Set logging level (if DEPTHAI_LEVEL lower than warning, then device is configured accordingly as well)
-        if(spdlog::get_level() < spdlog::level::warn) {
-            auto level = spdlogLevelToLogLevel(spdlog::get_level());
-            setLogLevel(level);
-            setLogOutputLevel(level);
-        } else {
-            setLogLevel(LogLevel::WARN);
-            setLogOutputLevel(LogLevel::WARN);
-        }
+        auto level = spdlogLevelToLogLevel(spdlog::get_level());
+        setLogLevel(level);
+        setLogOutputLevel(level);
 
         // Sets system inforation logging rate. By default 1s
         setSystemInformationLoggingRate(DEFAULT_SYSTEM_INFORMATION_LOGGING_RATE_HZ);

tests/CMakeLists.txt

@@ -197,6 +197,7 @@ hunter_private_data(
 dai_add_test(color_camera_node_test src/color_camera_node_test.cpp)
 dai_add_test(image_manip_node_test src/image_manip_node_test.cpp)
 dai_add_test(pipeline_test src/pipeline_test.cpp)
+dai_add_test(logging_test src/logging_test.cpp)
 
 dai_add_test(neural_network_test src/neural_network_test.cpp)
 dai_test_compile_definitions(neural_network_test PRIVATE BLOB_PATH="${mobilenet_blob}")

tests/src/logging_test.cpp

@@ -0,0 +1,111 @@
+#define CATCH_CONFIG_MAIN
+#include <spdlog/spdlog.h>
+
+#include <catch2/catch.hpp>
+#include <chrono>
+#include <thread>
+
+#include "depthai/depthai.hpp"
+
+int test(dai::LogLevel logLevel) {
+    // Create pipeline
+    dai::Pipeline pipeline;
+
+    auto xIn = pipeline.create<dai::node::XLinkIn>();
+    auto script = pipeline.create<dai::node::Script>();
+    auto xOut = pipeline.create<dai::node::XLinkOut>();
+
+    xIn->setStreamName("input");
+    xOut->setStreamName("output");
+
+    // Link xin node to script node
+    xIn->out.link(script->inputs["log"]);
+    script->outputs["out"].link(xOut->input);
+
+    script->setScript(R"(
+    while True:
+        _ = node.io["log"].get()
+        node.trace("TRACE")
+        node.debug("DEBUG")
+        node.info("INFO")
+        node.warn("WARN")
+        node.error("ERROR")
+        node.critical("CRITICAL")
+
+        message = Buffer(10)
+        node.io["out"].send(message)
+    )");
+
+    dai::Device device(pipeline);
+
+    auto in = device.getInputQueue("input");
+    auto out = device.getOutputQueue("output");
+    dai::Buffer message;  // Arbitrary message, used only to control flow
+
+    device.setLogLevel(logLevel);
+    device.setLogOutputLevel(logLevel);
+
+    // -1 below is for no_error, which cannot arrive
+    std::array<bool, spdlog::level::n_levels - 1> arrivedLogs;
+    for(auto& level : arrivedLogs) {
+        level = false;
+    }
+    bool testPassed = true;
+    auto logLevelConverted = static_cast<typename std::underlying_type<dai::LogLevel>::type>(logLevel);
+    auto callbackSink = [&testPassed, &arrivedLogs, logLevelConverted](dai::LogMessage message) {
+        // Convert message to spd for easier comparison
+        auto messageLevelConverted = static_cast<typename std::underlying_type<dai::LogLevel>::type>(message.level);
+        REQUIRE(messageLevelConverted >= logLevelConverted);
+        if(messageLevelConverted < arrivedLogs.size()) {
+            arrivedLogs[messageLevelConverted] = true;
+        } else {
+            FAIL();
+        }
+    };
+
+    device.addLogCallback(callbackSink);
+    in->send(message);
+    out->get();  // Wait for the device to send the log(s)
+    using namespace std::chrono;
+    std::this_thread::sleep_for(milliseconds(200));  // Wait for the logs to arrive
+
+    for(int i = 0; i < arrivedLogs.size(); i++) {
+        if(i < logLevelConverted) {
+            REQUIRE(!arrivedLogs[i]);
+        } else {
+            REQUIRE(arrivedLogs[i]);
+        }
+    }
+    device.setLogLevel(dai::LogLevel::WARN);
+    device.setLogOutputLevel(dai::LogLevel::WARN);
+    // Exit with success error code
+    return 0;
+}
+
+TEST_CASE("TRACE") {
+    test(dai::LogLevel::TRACE);
+}
+
+TEST_CASE("DEBUG") {
+    test(dai::LogLevel::DEBUG);
+}
+
+TEST_CASE("INFO") {
+    test(dai::LogLevel::INFO);
+}
+
+TEST_CASE("WARN") {
+    test(dai::LogLevel::WARN);
+}
+
+TEST_CASE("ERROR") {
+    test(dai::LogLevel::ERR);
+}
+
+TEST_CASE("CRITICAL") {
+    test(dai::LogLevel::CRITICAL);
+}
+
+TEST_CASE("OFF") {
+    test(dai::LogLevel::OFF);
+}