Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Configurazione e utilizzo della registrazione nell' AWS SDK for C\$1\$1
<a name="logging"></a>

 AWS SDK per C\$1\$1 Include una registrazione configurabile che genera un record delle azioni eseguite dall'SDK durante l'esecuzione. Per abilitare la registrazione, imposta `LogLevel` of sulla verbosità appropriata `SDKOptions` per la tua applicazione.

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

Sono disponibili sette livelli di verbosità tra cui scegliere. Il valore predefinito è `Off` e non verrà generato alcun registro. `Trace`genererà il massimo livello di dettaglio e `Fatal` genererà il minor numero di messaggi che riportano solo condizioni di errore irreversibili.

Una volta abilitata la registrazione nell'applicazione, l'SDK genererà i file di registro nella directory eseguibile seguendo lo schema di denominazione predefinito di. `aws_sdk_<date>.log` Il file di registro generato dall'opzione di denominazione del prefisso si ripete una volta all'ora per consentire l'archiviazione o l'eliminazione dei file di registro.

Le versioni successive dell'SDK dipendono sempre più dalle librerie Common Runtime (CRT) sottostanti AWS . Queste librerie forniscono funzionalità comuni e operazioni di base tra. SDKs Per impostazione predefinita, tutti i messaggi di registro delle librerie CRT verranno reindirizzati all'SDK for C\$1\$1. Il livello di registro e il sistema di registrazione specificati per l'SDK for C\$1\$1 si applicano anche al CRT. 

Nell'esempio precedente, il CRT erediterà `LogLevel::Info` e registrerà anche i messaggi a livello dello `Info` stesso file.

È possibile controllare in modo indipendente la registrazione per le librerie CRT, reindirizzandone l'output in un file di registro separato o impostando un livello di registro diverso per i messaggi dal CRT. Spesso può essere utile ridurre la verbosità delle librerie CRT in modo che non sovraccarichino i log. Ad esempio, il livello di registro per il *solo* output CRT può essere impostato come segue: `Warn`

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

Utilizzando facoltativamente il metodo`InitializeAWSLogging`, è possibile controllare il livello di verbosità e l'output del registro di. `DefaultLogSystem` È possibile configurare il prefisso del nome del file di registro o reindirizzare l'output su uno stream anziché su un file. 

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

In alternativa, invece di utilizzare il`DefaultLogSystem`, è possibile utilizzare questo metodo anche per fornire un'implementazione di registrazione personalizzata.

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

Se chiami method`InitializeAWSLogging`, libera risorse alla fine del programma `ShutdownAWSLogging` chiamando.

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

 **Esempio di test di integrazione con registrazione** 

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

 **Esempio di sottoclasse di registrazione `Aws::Utils::Logging::DefaultLogSystem` personalizzata** 

 Il codice seguente mostra come sottoclassare la `Aws::Utils::Logging::DefaultLogSystem` classe, che fa parte di. AWS SDK per C\$1\$1 Questo esempio sostituisce la funzione `ProcessFormattedStatement` virtuale per personalizzare la registrazione. 

 `Aws::Utils::Logging::DefaultLogSystem`è una delle numerose classi di AWS SDK per C\$1\$1 quella `Aws::Utils::Logging::LogSystemInterface` sottoclasse per la registrazione personalizzata. 

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

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sdk-customization/override_default_logger.cpp) su. GitHub