Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Konfiguration und Verwendung der Protokollierung im AWS SDK for C\$1\$1
<a name="logging"></a>

 AWS SDK für C\$1\$1 Dazu gehört eine konfigurierbare Protokollierung, die eine Aufzeichnung der Aktionen generiert, die das SDK während der Ausführung ausführt. Um die Protokollierung zu aktivieren, setzen Sie für `LogLevel` of `SDKOptions` die für Ihre Anwendung passende Ausführlichkeit.

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

Es stehen sieben Ausführlichkeitsstufen zur Auswahl. Der Standardwert ist `Off` und es werden keine Protokolle generiert. `Trace`generiert die meisten Details und generiert die wenigsten Meldungen, in denen nur schwerwiegende Fehler gemeldet `Fatal` werden.

Sobald die Protokollierung in Ihrer Anwendung aktiviert ist, generiert das SDK Protokolldateien in Ihrem ausführbaren Verzeichnis nach dem Standardbenennungsmuster von`aws_sdk_<date>.log`. Die mit der Präfixbenennungsoption generierte Protokolldatei wird einmal pro Stunde aktualisiert, um das Archivieren oder Löschen von Protokolldateien zu ermöglichen.

Die späteren Versionen des SDK hängen zunehmend von den zugrunde liegenden AWS Common Runtime (CRT) -Bibliotheken ab. Diese Bibliotheken bieten gemeinsame Funktionen und grundlegende Operationen unter SDKs. Alle Protokollnachrichten aus den CRT-Bibliotheken werden standardmäßig an das SDK for C\$1\$1 umgeleitet. Die Protokollebene und das Protokollierungssystem, die Sie für das SDK for C\$1\$1 angeben, gelten auch für das CRT. 

Im vorherigen Beispiel erbt das CRT Nachrichten auf derselben `Info` Ebene `LogLevel::Info` und protokolliert sie auch in derselben Datei.

Sie können die Protokollierung für die CRT-Bibliotheken unabhängig steuern, indem Sie entweder die Ausgabe in eine separate Protokolldatei umleiten oder indem Sie eine andere Protokollebene für Nachrichten aus der CRT festlegen. Oft kann es von Vorteil sein, die Ausführlichkeit der CRT-Bibliotheken zu reduzieren, damit sie die Logs nicht überfordern. Beispielsweise kann die Protokollebene *nur* für die CRT-Ausgabe wie folgt festgelegt werden: `Warn`

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

Durch die optionale Verwendung der Methode `InitializeAWSLogging` können Sie den Ausführlichkeitsgrad und die Protokollausgabe von steuern. `DefaultLogSystem` Sie können das Präfix für den Protokolldateinamen konfigurieren oder die Ausgabe in einen Stream statt in eine Datei umleiten. 

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

Anstatt die zu verwenden, können Sie auch diese Methode verwenden`DefaultLogSystem`, um Ihre eigene Protokollierungsimplementierung bereitzustellen.

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

Wenn Sie die Methode aufrufen`InitializeAWSLogging`, geben Sie am Ende Ihres Programms Ressourcen frei, indem Sie sie aufrufen`ShutdownAWSLogging`.

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

 **Beispiel für einen Integrationstest mit Protokollierung** 

```
#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;
}
```

 **Beispiel für eine Unterklasse von `Aws::Utils::Logging::DefaultLogSystem` für benutzerdefinierte Protokollierung** 

 Der folgende Code zeigt, wie Sie eine Unterklasse für die `Aws::Utils::Logging::DefaultLogSystem` Klasse erstellen, die Teil von ist. AWS SDK für C\$1\$1 In diesem Beispiel wird die `ProcessFormattedStatement` virtuelle Funktion überschrieben, um die Protokollierung anzupassen. 

 `Aws::Utils::Logging::DefaultLogSystem`ist eine von mehreren Klassen in der Unterklasse That `Aws::Utils::Logging::LogSystemInterface` für AWS SDK für C\$1\$1 die benutzerdefinierte Protokollierung. 

```
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;
}
```

Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sdk-customization/override_default_logger.cpp) finden Sie unter. GitHub