Message Logging
For logging, the SDKs define an
ILogger interface that provides a common API for their logging purposes.Each SDK comes with a built-in
Logger class that implements the ILogger interface. These loggers offer basic functionality that allow us to jump into using logging features without dedicating too much time to develop our own implementation first.For logging, the SDKs define six levels that messages may be logged on. These log levels are:
DEBUGTRACEINFOWARNERRORSEVERE
Some SDKs may not support all message levels for their built-in
Logger class. Check the class documentation to see which log levels the logger may utilize.The
LoggerProvider is the highest level class that we interact with when utilizing logging functions in the SDKs. The logger provider allows components within the SDKs to share log settings and resources and helps us save resources as well.To use
LoggerProvider we must pass an instance of a class implementing the ILogger interface, such as the Logger class built into the SDKs as shown in the example below:Java
C# | Unity
C++
Unreal
import com.enjin.sdk.utils.Logger;
import com.enjin.sdk.utils.LoggerProvider;
Logger logger = new Logger();
LoggerProvider provider = new LoggerProvider(logger);
using Enjin.SDK.Utils;
Logger logger = new Logger();
LoggerProvider provider = new LoggerProvider(logger);
#include "enjinsdk/Logger.hpp"
#include "enjinsdk/LoggerProvider.hpp"
#include <memory>
using namespace enjin::sdk::utils;
std::shared_ptr<Logger> logger = std::make_shared<Logger>();
std::shared_ptr<LoggerProvider> provider = std::make_shared<LoggerProvider>(logger);
#include "Logger.h"
#include "LoggerProvider.h"
using namespace Enjin::Sdk::Util;
TSharedRef<FLogger> Logger = MakeShared<FLogger>();
FLoggerProviderPtr Provider = MakeShared<FLoggerProvider>(Logger);
When creating the
LoggerProvider we may also choose to define the default message level and the default debug level it calls the logger on as shown in the example below:Java
C# | Unity
C++
Unreal
import com.enjin.sdk.utils.LogLevel;
import com.enjin.sdk.utils.LoggerProvider;
LogLevel message = LogLevel.WARN;
LogLevel debug = LogLevel.ERROR;
// With a defined ILogger instance
new LoggerProvider(logger, message, debug);
using Enjin.SDK.Utils;
LogLevel message = LogLevel.WARN;
LogLevel debug = LogLevel.ERROR;
// With a defined ILogger instance
new LoggerProvider(logger, message, debug);
#include "enjinsdk/LogLevel.hpp"
#include "enjinsdk/LoggerProvider.hpp"
#include <memory>
using namespace enjin::sdk::utils;
LogLevel message = LogLevel::Warn;
LogLevel debug = LogLevel::Error;
// With a defined ILogger instance
std::make_shared<LoggerProvider>(logger, message, debug);
#include "LogLevel.h"
#include "LoggerProvider.h"
using namespace Enjin::Sdk::Util;
ELogLevel Message = ELogLevel::Warn;
ELogLevel Debug = ELogLevel::Error;
// With a defined ILogger instance
MakeShared<FLoggerProvider>(Logger, Message, Debug);
By default,
LoggerProvider sets the message level to INFO and the debug level to DEBUG if we do not define them ourselves.Platform clients may be configured to log the traffic of the requests and responses they send to and receive from the platform. We use an enum,
HttpLogLevel to define the log levels we may use for HTTP traffic. These log levels are:NONEBASICHEADERSBODY
The default log level for HTTP traffic is
NONE making this an opt-in feature, which will require us to declare the log level we will want to use. BASIC enables logging of the request method (e.g. GET, POST, etc...), the URI, the content-length as well as the response's status, URI, and round-trip time. HEADERS is similar to BASIC, but also includes the request and response headers. And finally, BODY logs similar information as HEADERS but also includes the entire content body of out going requests and incoming responses.CAUTION: When using the
BODY log level, any AuthProject request will be logged as well as the project's secret key which is sent as a parameter of the request.To configure the client, we call a method on its builder to set the HTTP log level and we must also provide an instance of
LoggerProvider that log messages will be sent to as shown in the example below:Java
C# | Unity
C++
Unreal
import com.enjin.sdk.http.HttpLogLevel;
HttpLogLevel basic = HttpLogLevel.BASIC;
HttpLogLevel headers = HttpLogLevel.HEADERS;
HttpLogLevel body = HttpLogLevel.BODY;
// Builder from either ProjectClient or PlayerClient
builder.httpLogLevel(/* HTTP log level here */)
.loggerProvider(/* LoggerProvider here */);
using Enjin.SDK.Http;
HttpLogLevel basic = HttpLogLevel.BASIC;
HttpLogLevel headers = HttpLogLevel.HEADERS;
HttpLogLevel body = HttpLogLevel.BODY;
// Builder from either ProjectClient or PlayerClient
builder.HttpLogLevel(/* HTTP log level here */)
.LoggerProvider(/* LoggerProvider here */);
#include "enjinsdk/HttpLogLevel.hpp"
using namespace enjin::sdk::http;
HttpLogLevel basic = HttpLogLevel::Basic;
HttpLogLevel headers = HttpLogLevel::Headers;
HttpLogLevel body = HttpLogLevel::Body;
// Builder from either ProjectClient or PlayerClient
builder.http_log_level(/* HTTP log level here */)
.logger_provider(/* LoggerProvider shared-pointer here */);
#include "HttpLogLevel.h"
using namespace Enjin::Sdk::Http;
EHttpLogLevel Basic = EHttpLogLevel::Basic;
EHttpLogLevel Headers = EHttpLogLevel::Headers;
EHttpLogLevel Body = EHttpLogLevel::Body;
// Builder from either FProjectClient or FPlayerClient
Builder.HttpLogLevel(/* HTTP log level here */)
.LoggerProvider(/* FLoggerProviderPtr here */)
The
PusherEventService may be configured to log incoming cloud events or any errors it encounters by providing its builder with a logger provider as shown below:Java
C# | Unity
C++
Unreal
// Builder from PusherEventService
builder.loggerProvider(/* LoggerProvider here */);
// Builder from PusherEventService
builder.LoggerProvider(/* LoggerProvider here */);
// Builder from PusherEventService
builder.logger_provider(/* LoggerProvider shared-pointer here */);
// Builder from FPusherEventService
Builder.LoggerProvider(/* FLoggerProviderPtr here */);