class ara::log::Logger

The member function LogDebug of class ara::log::Logger serves to create log messages with error severity Debug and returns a correspondingly configured LogStream object for this purpose [SWS_LOG_00068]. The declaration takes place via header file #include "ara/log/logger.h" [SWS_LOG_00068].

For usage and semantics, the following specification characteristics are defined:

• Call and return value: The method takes no input parameters and directly returns a LogStream object with Debug severity [SWS_LOG_00068]. The operational principle corresponds to method Logger::LogFatal() [SWS_LOG_00068].
• Error handling: The signature is declared as noexcept and specified as exception-safe [SWS_LOG_00068]. No error messages or error codes are reported in the event of an error [SWS_LOG_00068].
• Concurrency: The member function is classified as const (const) as well as explicitly as thread-safe [SWS_LOG_00068], so that parallel read accesses via the same logger instance are permissible.

The method LogError of class ara::log::Logger serves to initiate a log entry with severity Error [SWS_LOG_00065]. The function is declared via the header file ara/log/logger.h and takes no parameters [SWS_LOG_00065].

Usage and return value

The synchronous call returns an object of type LogStream with severity Error [SWS_LOG_00065]. The behavior functionally corresponds to that of Logger::LogFatal() [SWS_LOG_00065]. Because LogError is declared as const, the call does not modify the state of the logger object and can also be executed on const instances [SWS_LOG_00065].

Concurrency and Exception Safety

Defined guarantees apply to the call context [SWS_LOG_00065]:

• Thread Safety: The function is specified as thread-safe [SWS_LOG_00065]. Interpretation: Calls are thus likely to be permitted concurrently from multiple threads on the same instance without external synchronization. Question Q-e55d2b523c5cbcb3 (open)
• Exception Safety: The method is declared as noexcept as well as exception-safe [SWS_LOG_00065]; it does not throw any exceptions at runtime.

Error handling

Specific error codes or notifications to DET or DEM are not provided for LogError [SWS_LOG_00065]. Error states during the call are ruled out by the guaranteed exception safety and the parameterless interface [SWS_LOG_00065].

Usage and lifetime

The method LogFatal of class ara::log::Logger (provided via header ara/log/logger.h) creates a LogStream object with severity Fatal ([SWS_LOG_00064]). The function takes no arguments and returns the stream directly. The returned LogStream object accepts log messages and parameters sequentially via stream operator << ([SWS_LOG_00064]). In regular application scenarios, the lifetime of the created stream is limited to a single statement and ends with the concluding semicolon after the last passed parameter ([SWS_LOG_00064]). To extend the lifetime of the stream object beyond this, it can be assigned to a named variable ([SWS_LOG_00064]).

Error Handling and Concurrency

The function is declared as noexcept and specified as exception-safe (exception safe) ([SWS_LOG_00064]). It throws no exceptions at runtime and uses no specific error codes. Regarding concurrency, the method is specified as const as well as fully thread-safe (thread-safe), which permits parallel calls on the same logger instance ([SWS_LOG_00064]).

Interaction

In interface and behavior, the method corresponds to the related logging methods for other severity levels within ara::log::Logger: LogError ([SWS_LOG_00065]), LogWarn ([SWS_LOG_00066]), LogInfo ([SWS_LOG_00067]), LogDebug ([SWS_LOG_00068]), and LogVerbose ([SWS_LOG_00069]).

The member function LogInfo of class ara::log::Logger ([SWS_LOG_00067]) is declared via header ara/log/logger.h. It serves to create a log message with severity Info, requires no input parameters, and synchronously returns an object of type LogStream ([SWS_LOG_00067]). According to the specification, the behavior corresponds to that of Logger::LogFatal() ([SWS_LOG_00067]), with the interpretation being that the functionality operates analogously and merely the severity classification is set to Info.

Regarding concurrency and call context, the method is declared as const and explicitly specified as thread-safe (thread-safe) ([SWS_LOG_00067]). As a result, LogInfo may be called in parallel from multiple threads on the same logger instance at any time without application-side synchronization mechanisms or locks being required.

In error handling, the function is designated with the identifier noexcept and classified as exception-safe (exception safe) ([SWS_LOG_00067]). Neither specific error codes are returned nor are DEM or DET error messages triggered ([SWS_LOG_00067]); an error case is not defined for this call.

In the requirements structure, the interface is directly allocated to the upstream requirements [RS_LT_00003] and [RS_LT_00049] ([SWS_LOG_00067]), which define the overarching guidelines for the logging and tracing subsystem.

The method LogVerbose() of class ara::log::Logger from header file #include "ara/log/logger.h" serves to create log outputs with the most detailed severity Verbose [SWS_LOG_00069]. No parameters are passed upon the call. The function synchronously returns a LogStream object that is explicitly initialized with the severity Verbose and is used to forward message contents [SWS_LOG_00069].

The specification indicates the behavior as identical to Logger::LogFatal() [SWS_LOG_00069]; as an interpretation, this is likely to mean that the buffering and provisioning of the stream follow the general log mechanics and differ only in the assigned severity. Question Q-522523e7a845dc3a (open) For error handling, the method is specified as noexcept as well as exception safe [SWS_LOG_00069]. Consequently, no exceptions occur, and specific error codes do not exist in the call context [SWS_LOG_00069].

With respect to concurrency and interface contracts, the following properties apply:

• Thread Safety: The method is classified as thread-safe, so that concurrent calls via the same or different logger instances can be executed safely [SWS_LOG_00069].
• Constness: The declaration as const guarantees that the call does not modify the internal state of the logger object [SWS_LOG_00069].

use

The member function LogWarn of class ara::log::Logger is provided via the header ara/log/logger.h [SWS_LOG_00066]. The call is performed without parameters on a logger instance via the signature LogStream LogWarn () const noexcept; [SWS_LOG_00066]. As a return value, the function synchronously returns an object of type LogStream with the severity classification Warn (Warn severity) [SWS_LOG_00066]. The functional behavior corresponds to the description of Logger::LogFatal() [SWS_LOG_00066]. Interpretation: The provided LogStream object is likely intended to assemble log messages of the warning level for further output. Question Q-02b18df759926020 (open)

Concurrency and error safety

Regarding call context and concurrency, the method is specified as thread-safe [SWS_LOG_00066]. It can therefore safely be called from multiple concurrent threads on the same instance. The function guarantees full exception safety (exception-safe) and is declared with noexcept [SWS_LOG_00066]. Specific error codes, error values, or feedback signals for runtime errors are not defined for this operation [SWS_LOG_00066]; interpretation: a failure of the return is likely ruled out in regular operation. Question Q-44b264cd97ff8159 (open)

use

The template method LogWith of class ara::log::Logger serves for the structured logging of messages using an identifier as well as associated attributes and arguments [SWS_LOG_00133]. It is included via header #include "ara/log/logger.h" and executed synchronously without a return value [SWS_LOG_00133].

The function accepts the following parameters [SWS_LOG_00133]:

• attrs: a std::tuple with attributes of the message (types Attrs...),
• msgId: an implementation-defined instance of type MsgId for identifying the message object,
• params: variadic arguments (types Params...) that are added to the log entry.

Concurrency and Limitations

The function is specified as thread-safe and can be executed concurrently [SWS_LOG_00133]. It is declared with noexcept and classified as exception-safe (exception safe), which is why no C++ exceptions are thrown [SWS_LOG_00133]. Specific error codes or error messages are not defined.

For template instantiation, the following applies: The function does not participate in overload resolution if at least one of the types in Attrs... does not represent a permitted message attribute [SWS_LOG_00133]. Interpretation: Since the requirement for type Attr is marked with TBD in the specification, the concrete type check is likely to depend on the respective platform implementation. Question Q-30f5de483410d716 (open)