classe ara::log::Logger

La fonction membre LogDebug de la classe ara::log::Logger sert à générer des messages de journalisation avec le niveau de gravité Debug et fournit à cet effet un objet LogStream configuré en conséquence [SWS_LOG_00068]. La déclaration s’effectue via le fichier d’en-tête #include "ara/log/logger.h" [SWS_LOG_00068].

Pour l’utilisation et la sémantique, les caractéristiques de spécification suivantes sont définies :

• Appel et valeur de retour : la méthode ne prend aucun paramètre d’entrée et renvoie directement un objet LogStream avec le niveau de gravité Debug [SWS_LOG_00068]. Le fonctionnement correspond à celui de la méthode Logger::LogFatal() [SWS_LOG_00068].
• Traitement des erreurs : la signature est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) [SWS_LOG_00068]. Aucun message d’erreur ni code d’erreur n’est désigné en cas d’erreur [SWS_LOG_00068].
• Concurrence : la fonction membre est classée comme constante (const) ainsi qu’explicitement comme thread-safe (thread-safe) [SWS_LOG_00068], de sorte que des accès en lecture parallèles via la même instance de logger sont autorisés.

La méthode LogError de la classe ara::log::Logger sert à initier une entrée de journalisation avec le niveau de gravité Error [SWS_LOG_00065]. La fonction est déclarée via le fichier d’en-tête ara/log/logger.h et n’accepte aucun paramètre [SWS_LOG_00065].

Utilisation et valeur de retour

L’appel synchrone renvoie un objet de type LogStream avec le niveau de gravité Error [SWS_LOG_00065]. Le comportement correspond fonctionnellement à celui de Logger::LogFatal() [SWS_LOG_00065]. Comme LogError est déclaré comme const, l’appel ne modifie pas l’état de l’objet logger et peut également être exécuté sur des instances constantes [SWS_LOG_00065].

Concurrence et sécurité vis-à-vis des exceptions

Des garanties définies s’appliquent au contexte d’appel [SWS_LOG_00065] :

• Sécurité des threads : la fonction est spécifiée comme thread-safe [SWS_LOG_00065]. Interprétation : les appels devraient donc pouvoir s’effectuer de manière concurrente depuis plusieurs threads sur la même instance sans synchronisation externe. Question Q-e55d2b523c5cbcb3 (ouverte)
• Sécurité vis-à-vis des exceptions : la méthode est déclarée comme noexcept ainsi que comme exception safe [SWS_LOG_00065] ; elle ne déclenche aucune exception lors de l’exécution.

Gestion des erreurs

Aucun code d’erreur spécifique ni notification à DET ou DEM n’est prévu pour LogError [SWS_LOG_00065]. Les états d’erreur lors de l’appel sont exclus par la sécurité garantie vis-à-vis des exceptions et l’interface sans paramètre [SWS_LOG_00065].

Utilisation et durée de vie

La méthode LogFatal de la classe ara::log::Logger (mise à disposition via l'en-tête ara/log/logger.h) crée un objet LogStream avec le niveau de gravité Fatal ([SWS_LOG_00064]). La fonction ne prend aucun argument et renvoie directement le flux. L'objet LogStream renvoyé reçoit séquentiellement les messages de journalisation et les paramètres via l'opérateur de flux << ([SWS_LOG_00064]). Dans un scénario d'utilisation standard, la durée de vie du flux créé est limitée à une seule instruction et se termine par le point-virgule final après le dernier paramètre transmis ([SWS_LOG_00064]). Pour prolonger la durée de vie de l'objet flux au-delà, il est possible de l'assigner à une variable nommée ([SWS_LOG_00064]).

Gestion des erreurs et concurrence

La fonction est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) ([SWS_LOG_00064]). Elle ne lève aucune exception à l'exécution et n'utilise aucun code d'erreur spécifique. En matière de concurrence, la méthode est spécifiée comme const et entièrement sûre pour les threads (thread-safe), autorisant ainsi des appels parallèles via la même instance de logger ([SWS_LOG_00064]).

Interaction

La méthode correspond en termes d'interface et de comportement aux méthodes de journalisation associées pour d'autres niveaux de gravité au sein de ara::log::Logger : LogError ([SWS_LOG_00065]), LogWarn ([SWS_LOG_00066]), LogInfo ([SWS_LOG_00067]), LogDebug ([SWS_LOG_00068]) ainsi que LogVerbose ([SWS_LOG_00069]).

La fonction membre LogInfo de la classe ara::log::Logger ([SWS_LOG_00067]) est déclarée via l’en-tête ara/log/logger.h. Elle sert à générer un message de journalisation avec le niveau de gravité Info, n’exige aucun paramètre d’entrée et renvoie de manière synchrone un objet de type LogStream ([SWS_LOG_00067]). D’après la spécification, le comportement correspond à celui de Logger::LogFatal() ([SWS_LOG_00067]), l’interprétation étant que la fonctionnalité opère de manière analogue et que seul le niveau de gravité est fixé à Info.

Concernant la concurrence et le contexte d’appel, la méthode est déclarée comme const et explicitement spécifiée comme thread-safe (thread-safe) ([SWS_LOG_00067]). Ainsi, LogInfo peut être appelée à tout moment en parallèle depuis plusieurs threads sur la même instance de logger, sans que des mécanismes de synchronisation ou des verrous sous la responsabilité de l’application soient nécessaires.

Dans la gestion des erreurs, la fonction est pourvue de l’identificateur noexcept et classée comme sûre vis-à-vis des exceptions (exception safe) ([SWS_LOG_00067]). Aucun code d’erreur spécifique n’est renvoyé et aucun message d’erreur DEM ou DET n’est déclenché ([SWS_LOG_00067]) ; aucun cas d’erreur n’est défini pour cet appel.

Dans la structure des exigences, l’interface est directement associée aux exigences amont [RS_LT_00003] et [RS_LT_00049] ([SWS_LOG_00067]), qui définissent les lignes directrices de niveau supérieur pour le sous-système de journalisation et de traçage.

La méthode LogVerbose() de la classe ara::log::Logger issue du fichier d’en-tête #include "ara/log/logger.h" sert à générer des sorties de journalisation avec le niveau de gravité le plus détaillé Verbose [SWS_LOG_00069]. Aucun paramètre n’est transmis lors de l’appel. La fonction fournit de manière synchrone un objet LogStream, qui est explicitement initialisé avec la sévérité Verbose et utilisé pour la transmission du contenu des messages [SWS_LOG_00069].

La spécification désigne le comportement comme identique à Logger::LogFatal() [SWS_LOG_00069] ; à titre d’interprétation, cela devrait signifier que la mise en mémoire tampon et la mise à disposition du flux suivent le mécanisme général de journalisation et ne diffèrent que par le niveau de gravité attribué. Question Q-522523e7a845dc3a (ouverte) Pour le traitement des erreurs, la méthode est spécifiée comme noexcept ainsi que exception safe [SWS_LOG_00069]. Par conséquent, aucune exception ne survient et aucun code d’erreur spécifique n’existe dans le contexte d’appel [SWS_LOG_00069].

Concernant la concurrence et les contrats d’interface, les propriétés suivantes s’appliquent :

• Sécurité des threads : la méthode est classée comme thread-safe, de sorte que des appels concurrents via une même instance de logger ou des instances différentes peuvent être exécutés en toute sécurité [SWS_LOG_00069].
• Constance : la déclaration comme const garantit que l’appel ne modifie pas l’état interne de l’objet logger [SWS_LOG_00069].

Utilisation

La fonction membre LogWarn de la classe ara::log::Logger est mise à disposition via l’en-tête ara/log/logger.h [SWS_LOG_00066]. L’appel s’effectue sans paramètre sur une instance de logger via la signature LogStream LogWarn () const noexcept; [SWS_LOG_00066]. Comme valeur de retour, la fonction renvoie de manière synchrone un objet de type LogStream avec le niveau de gravité Warn (Warn severity) [SWS_LOG_00066]. Le comportement fonctionnel correspond à la description de Logger::LogFatal() [SWS_LOG_00066]. Interprétation : l’objet LogStream fourni devrait servir à composer des messages de journalisation du niveau d’avertissement pour la sortie ultérieure. Question Q-02b18df759926020 (ouverte)

Concurrence et sécurité vis-à-vis des erreurs

En ce qui concerne le contexte d’appel et la concurrence, la méthode est spécifiée comme thread-safe [SWS_LOG_00066]. Elle peut donc être appelée en toute sécurité depuis plusieurs threads concurrents sur la même instance. La fonction garantit une sécurité totale vis-à-vis des exceptions (exception safe) et est déclarée avec noexcept [SWS_LOG_00066]. Aucun code d’erreur spécifique, valeur d’erreur ou signal de retour pour les erreurs d’exécution n’est défini pour cette opération [SWS_LOG_00066] ; Interprétation : un échec du retour devrait être exclu en fonctionnement normal. Question Q-44b264cd97ff8159 (ouverte)

Utilisation

La méthode template LogWith de la classe ara::log::Logger sert à la journalisation structurée de messages au moyen d'un identifiant ainsi que des attributs et des arguments associés [SWS_LOG_00133]. Elle est intégrée via l'en-tête #include "ara/log/logger.h" et exécutée de manière synchrone sans valeur de retour [SWS_LOG_00133].

La fonction accepte les paramètres suivants [SWS_LOG_00133] :

• attrs : un std::tuple contenant les attributs du message (types Attrs...),
• msgId : une instance définie par l'implémentation de type MsgId pour l'identification de l'objet de message,
• params : des arguments variadiques (types Params...) qui sont ajoutés à l'entrée de journalisation.

Concurrence et restrictions

La fonction est spécifiée comme thread-safe et peut être exécutée de manière concurrente [SWS_LOG_00133]. Elle est déclarée avec noexcept et classifiée comme sûre face aux exceptions (exception safe), raison pour laquelle aucune exception C++ n'est levée [SWS_LOG_00133]. Aucun code d'erreur ou message d'erreur spécifique n'est défini.

Pour l'instanciation de template : la fonction ne participe pas à la résolution de surcharge si au moins un des types dans Attrs... ne représente pas un attribut de message valide [SWS_LOG_00133]. Interprétation : étant donné que l'exigence envers le type Attr est désignée par TBD dans la spécification, le contrôle de type concret devrait dépendre de l'implémentation de plateforme respective. Question Q-30f5de483410d716 (ouverte)