Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Configuration et utilisation de la journalisation dans le AWS SDK for C\$1\$1
<a name="logging"></a>

 AWS SDK pour C\$1\$1 Il inclut une journalisation configurable qui génère un enregistrement des actions effectuées par le SDK pendant l'exécution. Pour activer la journalisation, réglez le `LogLevel` paramètre `SDKOptions` de sur la verbosité appropriée à votre application.

```
    Aws::SDKOptions options;
    options.loggingOptions.logLevel = Aws::Utils::Logging::LogLevel::Info;
```

Vous avez le choix entre sept niveaux de verbosité. La valeur par défaut est `Off` et aucun journal ne sera généré. `Trace`générera le niveau de détail le plus élevé et `Fatal` générera le moins de messages signalant uniquement des erreurs fatales.

Une fois la journalisation activée dans votre application, le SDK génère des fichiers journaux dans votre répertoire exécutable en suivant le modèle de dénomination par défaut de`aws_sdk_<date>.log`. Le fichier journal généré par l'option de dénomination du préfixe est reporté une fois par heure pour permettre l'archivage ou la suppression des fichiers journaux.

Les versions ultérieures du SDK dépendent de plus en plus des bibliothèques AWS Common Runtime (CRT) sous-jacentes. Ces bibliothèques fournissent des fonctionnalités communes et des opérations de base entre SDKs. Tous les messages de journal provenant des bibliothèques CRT seront redirigés vers le SDK for C\$1\$1 par défaut. Le niveau de journalisation et le système de journalisation que vous spécifiez pour le SDK for C\$1\$1 s'appliquent également au CRT. 

Dans l'exemple précédent, le CRT héritera `LogLevel::Info` et enregistrera également les messages au `Info` niveau du même fichier.

Vous pouvez contrôler indépendamment la journalisation des bibliothèques CRT, soit en redirigeant leur sortie vers un fichier journal distinct, soit en définissant un niveau de journalisation différent pour les messages provenant du CRT. Il peut souvent être avantageux de réduire la verbosité des bibliothèques CRT afin qu'elles ne surchargent pas les journaux. Par exemple, le niveau de journalisation pour la sortie CRT *uniquement* peut être défini `Warn` comme suit :

```
options.loggingOptions.crt_logger_create_fn =
    [](){ return Aws::MakeShared<Aws::Utils::Logging::DefaultCRTLogSystem>("CRTLogSystem", Aws::Utils::Logging::LogLevel::Warn); };
```

En utilisant éventuellement cette méthode`InitializeAWSLogging`, vous pouvez contrôler le niveau de verbosité et la sortie du journal du. `DefaultLogSystem` Vous pouvez configurer le préfixe du nom du fichier journal ou rediriger la sortie vers un flux plutôt que vers un fichier. 

```
Aws::Utils::Logging::InitializeAWSLogging(
    Aws::MakeShared<Aws::Utils::Logging::DefaultLogSystem>(
        "RunUnitTests", Aws::Utils::Logging::LogLevel::Trace, "aws_sdk_"));
```

Au lieu d'utiliser le`DefaultLogSystem`, vous pouvez également utiliser cette méthode pour fournir votre propre implémentation de journalisation.

```
InitializeAWSLogging(Aws::MakeShared<CustomLoggingSystem>());
```

Si vous appelez Method`InitializeAWSLogging`, libérez des ressources à la fin de votre programme en appelant`ShutdownAWSLogging`.

```
Aws::Utils::Logging::ShutdownAWSLogging();
```

 **Exemple de test d'intégration avec journalisation** 

```
#include <aws/external/gtest.h>

#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/logging/DefaultLogSystem.h>
#include <aws/core/utils/logging/AWSLogging.h>

#include <iostream>

int main(int argc, char** argv)
{
    Aws::Utils::Logging::InitializeAWSLogging(
        Aws::MakeShared<Aws::Utils::Logging::DefaultLogSystem>(
            "RunUnitTests", Aws::Utils::Logging::LogLevel::Trace, "aws_sdk_"));
    ::testing::InitGoogleTest(&argc, argv);
    int exitCode = RUN_ALL_TESTS();
    Aws::Utils::Logging::ShutdownAWSLogging();
    return exitCode;
}
```

 **Exemple de sous-classe de `Aws::Utils::Logging::DefaultLogSystem` pour la journalisation personnalisée** 

 Le code suivant montre comment sous-classer la `Aws::Utils::Logging::DefaultLogSystem` classe, qui fait partie de AWS SDK pour C\$1\$1. Cet exemple remplace la fonction `ProcessFormattedStatement` virtuelle pour personnaliser la journalisation. 

 `Aws::Utils::Logging::DefaultLogSystem`est l'une des nombreuses classes de AWS SDK pour C\$1\$1 cette sous-classe `Aws::Utils::Logging::LogSystemInterface` pour la journalisation personnalisée. 

```
class LogSystemOverride : public Aws::Utils::Logging::DefaultLogSystem {
public:
    explicit LogSystemOverride(Aws::Utils::Logging::LogLevel logLevel,
                               const Aws::String &logPrefix)
            : DefaultLogSystem(logLevel, logPrefix), mLogToStreamBuf(false) {}

    const Aws::Utils::Stream::SimpleStreamBuf &GetStreamBuf() const {
        return mStreamBuf;
    }

    void setLogToStreamBuf(bool logToStreamBuf) {
        mLogToStreamBuf = logToStreamBuf;
    }

protected:

    void ProcessFormattedStatement(Aws::String &&statement) override {
        if (mLogToStreamBuf) {
            std::lock_guard<std::mutex> lock(mStreamMutex);
            mStreamBuf.sputn(statement.c_str(), statement.length());
        }

        DefaultLogSystem::ProcessFormattedStatement(std::move(statement));
    }

private:
    Aws::Utils::Stream::SimpleStreamBuf mStreamBuf;
    // Use a mutex when writing to the buffer because
    // ProcessFormattedStatement can be called from multiple threads.
    std::mutex mStreamMutex;
    std::atomic<bool> mLogToStreamBuf;
};
```

```
int main(int argc, char **argv) {
    Aws::SDKOptions options;
    options.loggingOptions.logLevel = Aws::Utils::Logging::LogLevel::Trace;
    auto logSystemOverride = Aws::MakeShared<LogSystemOverride>("AllocationTag",
                                                                options.loggingOptions.logLevel,
                                                                options.loggingOptions.defaultLogPrefix);
    options.loggingOptions.logger_create_fn = [logSystemOverride]() {
        return logSystemOverride;
    };

    Aws::InitAPI(options);  // Call Aws::InitAPI only once in an application.
    {
        Aws::Client::ClientConfiguration clientConfig;
        // Optional: Set to the AWS Region (overrides config file).
        // clientConfig.region = "us-east-1";

        Aws::S3::S3Client s3Client(clientConfig);

        logSystemOverride->setLogToStreamBuf(true);
        auto outcome = s3Client.ListBuckets();
        if (!outcome.IsSuccess()) {
            std::cerr << "ListBuckets error: " <<
                      outcome.GetError().GetExceptionName() << " " <<
                      outcome.GetError().GetMessage() << std::endl;
        }

        logSystemOverride->setLogToStreamBuf(false);

        std::cout << "Log for ListBuckets" << std::endl;
        std::cout << logSystemOverride->GetStreamBuf().str() << std::endl;
    }

    Aws::ShutdownAPI(options);

    return 0;
}
```

Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sdk-customization/override_default_logger.cpp) sur GitHub.