Disable the noise

[497e0bdf29873]

Dolfinx uses spdlog for logging. When building a Rust binary, which uses both C++ and Python Dolfinx, with cargo in the default debug (as opposed to release) build mode, I get a lot of INFO noise from spdlog::info calls in Dolfinx. Dolfinx provides wrappers to set and get the spdlog level, but the default is already WARNING, and even setting it to ERROR does not remove the INFO noise.

How does spdlog figure out that cargo is building in the default (fast) debug mode? Why does it not respect the set log levels? Is there any way to disable the noise that does not involve waiting decades for the release mode to build?

This only happens on my Armbian (Ubuntu) box. On macOS there's no noise.

[tt4g]

Your question sounds like an issue of Rust and C++ compatibility.
If Rust does not respect the C++ specification, that behavior is not guaranteed. Therefore, spdlog, which assumes the C++ specification, is unlikely to work as intended.

If you can call the spdlog API to set the log level to WARNING, it is likely that the default log level was not set during the build.
If you cannot do this, the spdlog API is not working correctly, so nothing can be done with spdlog.
Ask the Rust developers about compatibility with C++ code.

[497e0bdf29873]

That's a very hostile response.

I don't use spdlog from Rust; Rust itself nothing to do with spdlog. Dolfinx (C++ + Python) uses spdlog. And the spdlog is a pre-compiled Armbian/Ubuntu library; Cargo does nothing to it. Somehow, when it's linked to in debug compilation mode, it goes absolutely bonkers, disrespecting the log level setting from C++ (via the Python wrappers of Dolfinx). The only thing I can think of that could be happening is that something in the environment changes in debug mode. Are there some hidden generically-named environment variables that spdlog might be reading? Setting SPDLOG_LEVEL does absolute nothing. (I'm not sure if that's a real supported environment variable, there are some references to it around the internet, but I have not found any real documentation.)

If you vouch that it doesn't do anything crazy, then more likely is that Ubuntu has ruined it, or Dolfinx, which wouldn't be the first time. (One of the reasons, besides all the hostility and Gnomification, why I left Linux as my principal environment decades ago, distributions—the evil and powerful middle men—maiming my software, and not taking responsibility for it by renaming the software.) On macOS I don't get the noise.

[tt4g]

In C++, mixing debug and release builds is considered a bad practice.
This is because debug builds add debug data to structures, resulting in incompatible memory layouts with release builds.
When the memory layout of a structure differs, the positions of symbols (data, functions, etc.) allocated in memory also differ.
It is likely that Rust is calling something that is not a function (an incorrect address) as if it were a function, so undefined behavior is expected.

The fact that the issue hasn't been reproduced on MacOS is probably just a matter of luck (other problems may still be occurring).

Since built libraries cannot alter their memory layout, you should consider preparing libraries that match Rust's build modes.

[tt4g]

BTW: SPDLOG_LEVEL is an environment variable used to change the log level. you can call spdlog::cfg::load_env_levels() parses the environment variable and loads it as the log level.

See:

• https://github.com/gabime/spdlog/blob/v1.16.0/README.md#load-log-levels-from-the-env-variable-or-argv
• https://github.com/gabime/spdlog/blob/v1.16.0/include/spdlog/cfg/env.h

[497e0bdf29873]

Nothing is being called from Rust. Things are just linked to the Rust binary, but spdlog is only called from the C++ dolfinx. Setting SPDLOG_LEVEL does nothing.

On macOS the log levels can even be controlled through the Python API of Dolfinx, which just wraps the spdlog calls using nanobind. On the Armbian system this does nothing.

So there's two problems on the Armbian system:

1. somehow things get very noisy if the Rust part of the binary is built with debug symbols. The system does not have two different versions of libspdlog. But it's not even about the log levels: even on a release mode build, I get some INFO noise, but much less.
2. The log levels cannot be controlled in any way.

[tt4g]

Nothing is being called from Rust. Things are just linked to the Rust binary, but spdlog is only called from the C++ dolfinx. Setting SPDLOG_LEVEL does nothing.

I'm not entirely sure what this means.
You're linking the library to use it from Rust, right?
Isn't the log being output because Rust is calling the C API in some way?
Since the symbols for spdlog, dolfinx, and Python are loaded in memory, they won't work properly unless called correctly.

If the logs are output correctly in C/C++ applications, it doesn't sound like it's an spdlog issue.

[497e0bdf29873]

No, I don't want to use spdlog at all.

I have some computational, mathematical, Rust codes. I want to provide some additional PDE capabilities, and this is best done using Fenicsx-Dolfinx, which is Python and C++ (neither my languages of choice). The main user-facing API is Python, the C++ API is very limited. The C++ side of Dolfinx uses spdlog (https://github.com/search?q=repo%3AFEniCS%2Fdolfinx%20spdlog%3A%3Ainfo&type=code).

My Rust code accesses Dolfinx through the Python API (to provide the extensibility) and the C++ API (for some performance-critical parts). Hence, it links to the Dolfinx library, and through that, to spdlog. But it never uses spdlog directly. It does not even know about it. But somehow, when built with debug symbols, I get all the Dolfinx spdlog::info calls as noise, and cannot control it at all.

[tt4g]

Whether your Rust code calls the Python API or any C/C++ API other than spdlog doesn't matter. Since it internally calls the spdlog API, it is affected by the C/C++ specification.

Are you not very familiar with C/C++?
If so, I recommend asking whether Rust is supported in the Dolfinx repository.
If you're encountering issues with a usage method not supported by Dolfinx, we won't be able to resolve the problem.

[497e0bdf29873]

This is not going anywhere. Bye.

[tt4g]

Yes. This question relates to Rust and Dolfinx, so it cannot be resolved in this repository.
As far as I know, you need to use the cxx crate to call C++ APIs from Rust. However, since the Dolfinx repository does not explicitly state Rust support, I'm not sure if it will work.

[tt4g]

I did some research, but neither Rust nor the cxx crate seem to fully support C++ templates.
Since spdlog uses C++ template features, the inability to call it from Rust is an issue with the Rust language itself.

• How to use autocxx with C++ function and class templates? - help - The Rust Programming Language Forum
• Extern type with generic type parameter  dtolnay/cxx#683
• Is there a way to auto generate Rust code from C++ code which uses templates? - Stack Overflow