[#396] Read and set LogLevel from environment variable

.cargo/config.toml

@@ -4,6 +4,7 @@ rustdocflags = ["-D", "warnings"]
 [env]
 RUST_TEST_THREADS = "1"
 RUST_BACKTRACE = "1"
+IOX2_LOG_LEVEL = "Trace"
 
 [target.debug]
 rustflags = ["-Z", "sanitizer=address"]

FAQ.md

@@ -4,18 +4,18 @@
 
 iceoryx2 stores all data in shared memory, which imposes certain restrictions.
 Only data that is self-contained and does not use pointers to reference itself
-is allowed. This is because shared memory is mapped at different offsets in
-each process, rendering absolute pointers invalid. Additionally, if the data
+is allowed. This is because shared memory is mapped at different offsets in each
+process, rendering absolute pointers invalid. Additionally, if the data
 structure uses the heap, it is stored locally within a process and cannot be
-accessed by other processes. As a result, data types such as `String`, `Vec`,
-or `HashMap` cannot be used as payload types.
+accessed by other processes. As a result, data types such as `String`, `Vec`, or
+`HashMap` cannot be used as payload types.
 
 Additionally, every data type must be annotated with `#[repr(C)]`. The Rust
 compiler may reorder the members of a struct, which can lead to undefined
 behavior if another process expects a different ordering.
 
-To address this, iceoryx2 provides shared-memory-compatible data types. You
-can refer to the [complex data types example](examples/rust/complex_data_types),
+To address this, iceoryx2 provides shared-memory-compatible data types. You can
+refer to the [complex data types example](examples/rust/complex_data_types),
 which demonstrates the use of `FixedSizeByteString` and `FixedSizeVec`.
 
 ## How To Define Custom Data Types (Rust)
@@ -58,24 +58,22 @@ insufficient, a new publisher with a larger `max_slice_len` can be created.
 
 <!-- markdownlint-disable -->
 
-> [!IMPORTANT]
-> Be aware that the history of the old publisher is lost when it is
+> [!IMPORTANT] Be aware that the history of the old publisher is lost when it is
 > removed.
 
-> [!NOTE]
-> We are also working on an API that does not require the user to
+> [!NOTE] We are also working on an API that does not require the user to
 > explicitly create a new publisher whenever the memory is insufficient. It
 > would also solve the history issue.
 
 <!-- markdownlint-enable -->
 
 ## How To Make 32-bit and 64-bit iceoryx2 Applications Interoperatable
 
-This is currently not possible since we cannot guarantee to have the same
-layout of the data structures in the shared memory. On 32-bit architectures
-64-bit POD are aligned to a 4 byte boundary but to a 8 byte boundary on
-64-bit architectures. Some additional work is required to make 32-bit and
-64-bit applications interoperabel.
+This is currently not possible since we cannot guarantee to have the same layout
+of the data structures in the shared memory. On 32-bit architectures 64-bit POD
+are aligned to a 4 byte boundary but to a 8 byte boundary on 64-bit
+architectures. Some additional work is required to make 32-bit and 64-bit
+applications interoperabel.
 
 ## My Transmission Type Is Too Large, Encounter Stack Overflow On Initialization
 
@@ -89,8 +87,8 @@ than the available stack size.
 ## 100% CPU Load When Using The WaitSet
 
 The WaitSet wakes up whenever an attachment, such as a `Listener` or a `socket`,
-has something to read. If you do not handle all notifications, for example,
-with `Listener::try_wait_one()`, the WaitSet will wake up immediately again,
+has something to read. If you do not handle all notifications, for example, with
+`Listener::try_wait_one()`, the WaitSet will wake up immediately again,
 potentially causing an infinite loop and resulting in 100% CPU usage.
 
 ## Does iceoryx2 Offer an Async API?
@@ -123,17 +121,31 @@ But you can also use a crate like [ctrlc](https://docs.rs/ctrlc/latest/ctrlc/).
 ## How to use `log` or `tracing` as default log backend
 
 * **log**, add the feature flag `logger_log` to the dependency in `Cargo.toml`
-    ```toml
-    iceoryx2 = { version = "0.1.0", features = ["logger_log"]}
-    ```
+  ```toml
+  iceoryx2 = { version = "0.1.0", features = ["logger_log"]}
+  ```
 * **tracing**, add the feature flag `logger_tracing` to the dependency in
   `Cargo.toml`
-    ```toml
-     iceoryx2 = { version = "0.1.0", features = ["logger_tracing"]}
-    ```
+  ```toml
+   iceoryx2 = { version = "0.1.0", features = ["logger_tracing"]}
+  ```
+
+## Supported log levels
+
+iceoryx2 support different log levels
+`Trace, Debug, Info, Warning, Error, Fatal`
 
 ## How to set the log level
 
+iceoryx2 gets its default logging level from `.cargo/config.toml` , but this can
+be over ridden by environment variable `IOX2_LOG_LEVEL` the developer can set
+this environment variable with one of the supported levels.
+
+`export IOX2_LOG_LEVEL=Trace`
+
+Developers can also set the logging level from within the code which will take
+precedence over the environment variable:
+
 ```rust
 use iceoryx2::prelude::*
 
@@ -144,10 +156,10 @@ set_log_level(LogLevel::Trace);
 
 ## A crash leads to the failure `PublishSubscribeOpenError(UnableToOpenDynamicServiceInformation)`
 
-When an application crashes, some resources may remain in the system and need
-to be cleaned up. This issue is detected whenever a new iceoryx2 instance is
-created, removed, or when someone opens the service that the crashed process
-had previously opened. On the command line, you may see a message like this:
+When an application crashes, some resources may remain in the system and need to
+be cleaned up. This issue is detected whenever a new iceoryx2 instance is
+created, removed, or when someone opens the service that the crashed process had
+previously opened. On the command line, you may see a message like this:
 
 ```ascii
 6 [W] "Node::<iceoryx2::service::ipc::Service>::cleanup_dead_nodes()"
@@ -157,9 +169,9 @@ had previously opened. On the command line, you may see a message like this:
 ```
 
 However, for successful cleanup, the process attempting the cleanup must have
-sufficient permissions to remove the stale resources of the dead process. If
-the cleanup fails due to insufficient permissions, the process that attempted
-the cleanup will continue without removing the resources.
+sufficient permissions to remove the stale resources of the dead process. If the
+cleanup fails due to insufficient permissions, the process that attempted the
+cleanup will continue without removing the resources.
 
 Generally, it is not necessary to manually clean up these resources, as other
 processes should detect and handle the cleanup when creating or removing nodes,
@@ -169,6 +181,7 @@ Nevertheless, there are three different approaches to initiate stale resource
 cleanup:
 
 1. **Using the iceoryx2 API**:
+
    ```rust
    Node::<ipc::Service>::list(Config::global_config(), |node_state| {
      if let NodeState::<ipc::Service>::Dead(view) = node_state {
@@ -184,6 +197,6 @@ cleanup:
 2. **Using the command line tool**: `iox2 node -h` (NOT YET IMPLEMENTED)
 
 3. **Manual cleanup**: Stop all running services and remove all shared memory
-    files with the `iox2` prefix from:
+   files with the `iox2` prefix from:
    * POSIX: `/dev/shm/`, `/tmp/iceoryx2`
    * Windows: `c:\Temp\iceoryx2`

doc/release-notes/iceoryx2-unreleased.md

@@ -40,6 +40,7 @@
 * Bazel support for the Rust crates [#349](https://github.com/eclipse-iceoryx/iceoryx2/issues/349)
 * Remove ACL dependency [#457](https://github.com/eclipse-iceoryx/iceoryx2/issues/457)
 * Publish Subscribe Header contains number of elements contained in a `Sample` [#498](https://github.com/eclipse-iceoryx/iceoryx2/issues/498)
+* Read LogLevel from environment variable [#396](https://github.com/eclipse-iceoryx/iceoryx2/issues/396)
 
 ### Workflow
 

iceoryx2-bb/log/BUILD.bazel

@@ -37,5 +37,6 @@ rust_library(
     deps = [
         "//iceoryx2-pal/concurrency-sync:iceoryx2-pal-concurrency-sync",
         "@crate_index//:termsize",
+        "@crate_index//:once_cell",
     ],
 )

iceoryx2-bb/log/Cargo.toml

@@ -21,3 +21,4 @@ iceoryx2-pal-concurrency-sync = { workspace = true }
 termsize = { workspace = true }
 log = { workspace = true, optional = true }
 tracing = { workspace = true, optional = true }
+once_cell = { workspace = true }

iceoryx2-bb/log/src/lib.rs

@@ -150,6 +150,9 @@ use std::{
     sync::{atomic::Ordering, Once},
 };
 
+use once_cell::sync::Lazy;
+use std::env;
+
 #[cfg(feature = "logger_tracing")]
 static DEFAULT_LOGGER: logger::tracing::Logger = logger::tracing::Logger::new();
 
@@ -159,11 +162,17 @@ static DEFAULT_LOGGER: logger::log::Logger = logger::log::Logger::new();
 #[cfg(not(any(feature = "logger_log", feature = "logger_tracing")))]
 static DEFAULT_LOGGER: logger::console::Logger = logger::console::Logger::new();
 
-const DEFAULT_LOG_LEVEL: u8 = LogLevel::Info as u8;
+const DEFAULT_LOG_LEVEL: LogLevel = LogLevel::Info;
+pub static ENV_LOG_LEVEL: Lazy<LogLevel> = Lazy::new(|| {
+    env::var("IOX2_LOG_LEVEL")
+        .map(|log_level| LogLevel::from_str_fuzzy(&log_level))
+        .unwrap_or(LogLevel::Info)
+});
 
 static mut LOGGER: Option<&'static dyn Log> = None;
-static LOG_LEVEL: IoxAtomicU8 = IoxAtomicU8::new(DEFAULT_LOG_LEVEL);
-static INIT: Once = Once::new();
+static LOG_LEVEL: IoxAtomicU8 = IoxAtomicU8::new(DEFAULT_LOG_LEVEL as u8);
+static INIT_LOGGER: Once = Once::new();
+static INIT_LOG_LEVEL: Once = Once::new();
 
 pub trait Log: Send + Sync {
     /// logs a message
@@ -182,32 +191,55 @@ pub enum LogLevel {
     Fatal = 5,
 }
 
+impl LogLevel {
+    fn from_str_fuzzy(s: &str) -> LogLevel {
+        match s.to_lowercase().as_str() {
+            "trace" => LogLevel::Trace,
+            "debug" => LogLevel::Debug,
+            "info" => LogLevel::Info,
+            "warn" => LogLevel::Warn,
+            "error" => LogLevel::Error,
+            "fatal" => LogLevel::Fatal,
+            _ => {
+                println!("Error: you are using unknown logging level {:?}", s);
+                println!("Warning: setting log level as : Info");
+                DEFAULT_LOG_LEVEL
+            }
+        }
+    }
+}
+
 /// Sets the current log level. This is ignored for external frameworks like `log` or `tracing`.
 /// Here you have to use the log-level settings of that framework.
 pub fn set_log_level(v: LogLevel) {
+    INIT_LOG_LEVEL.call_once(|| {
+        LOG_LEVEL.store(*ENV_LOG_LEVEL as u8, Ordering::Relaxed);
+    });
     LOG_LEVEL.store(v as u8, Ordering::Relaxed);
 }
 
 /// Returns the current log level
 pub fn get_log_level() -> u8 {
+    INIT_LOG_LEVEL.call_once(|| {
+        LOG_LEVEL.store(*ENV_LOG_LEVEL as u8, Ordering::Relaxed);
+    });
     LOG_LEVEL.load(Ordering::Relaxed)
 }
 
 /// Sets the [`Log`]ger. Can be only called once at the beginning of the program. If the
 /// [`Log`]ger is already set it returns false and does not update it.
 pub fn set_logger<T: Log + 'static>(value: &'static T) -> bool {
     let mut set_logger_success = false;
-    INIT.call_once(|| {
+    INIT_LOGGER.call_once(|| {
         unsafe { LOGGER = Some(value) };
         set_logger_success = true;
     });
-
     set_logger_success
 }
 
 /// Returns a reference to the [`Log`]ger.
 pub fn get_logger() -> &'static dyn Log {
-    INIT.call_once(|| {
+    INIT_LOGGER.call_once(|| {
         unsafe { LOGGER = Some(&DEFAULT_LOGGER) };
     });