protected override void Write(LogEventInfo loggingEvent)
{
try
{
var renderedEvent = Layout.Render(loggingEvent);
var messageBuilder = new GelfMessageBuilder(renderedEvent, HostName, loggingEvent.TimeStamp, ToGelf(loggingEvent.Level))
.SetAdditionalField(GelfAdditionalFields.Facility, Facility)
.SetAdditionalField(GelfAdditionalFields.LoggerName, loggingEvent.LoggerName);
if (IncludeSource)
{
var userStackFrame = loggingEvent.UserStackFrame;
if (userStackFrame != null)
{
messageBuilder.SetAdditionalField(GelfAdditionalFields.SourceFileName, userStackFrame.GetFileName());
messageBuilder.SetAdditionalField(GelfAdditionalFields.SourceLineNumber, userStackFrame.GetFileLineNumber().ToString(CultureInfo.InvariantCulture));
}
}
if (IncludeStackTrace)
{
var exception = loggingEvent.Exception;
if (exception != null)
{
messageBuilder.SetAdditionalField(GelfAdditionalFields.ExceptionMessage, exception.Message);
messageBuilder.SetAdditionalField(GelfAdditionalFields.ExceptionStackTrace, exception.StackTrace);
}
}
transport.Send(messageBuilder.ToMessage());
}
catch (Exception exception)
{
logger.Error("Failed to send message", exception);
}
}
protected void CheckLogProperties(IReadOnlyDictionary <string, LogEventPropertyValue> logEventProperties, GelfMessageBuilder messageBuilder)
{
foreach (var property in logEventProperties)
{
var propCheckResult = _config.PropertyCatalog.CheckProperty(property.Key, property.Value);
switch (propCheckResult.CheckResult)
{
case GraylogPropertyCheckResultType.Ok:
messageBuilder.SetAdditionalField($"{_config.PropertyPrefix}{property.Key}", propCheckResult.PropertyValue);
break;
case GraylogPropertyCheckResultType.ErrorNameNotRegistered:
// property not registered as Graylog property - so do not append
continue;
default:
if (propCheckResult.ExpectedValueType == GraylogPropertyType.String &&
propCheckResult.CheckResult.HasFlag(GraylogPropertyCheckResultType.ErrorValueTypeNotMatching))
{
// try to correct by converting value into string
var conv = propCheckResult.PropertyValue as IConvertible;
var strValue = conv?.ToString(CultureInfo.InvariantCulture) ?? propCheckResult.PropertyValue.ToString();
// correct property value by converting to string
messageBuilder.SetAdditionalField($"{_config.PropertyPrefix}{property.Key}", strValue);
break;
}
// send value type mismatch event
messageBuilder.SetAdditionalField($"{_config.PropertyPrefix}isGelfPropertyError", 1);
var msg = CreatePropertyErrorMessage(propCheckResult);
SendErrorMessage(msg);
break;
}
}
}
protected override void Append(LoggingEvent loggingEvent)
{
try
{
var renderedEvent = RenderLoggingEvent(loggingEvent);
var messageBuilder = new GelfMessageBuilder(renderedEvent, HostName, loggingEvent.TimeStamp, loggingEvent.Level.ToGelf())
.SetAdditionalField("facility", Facility)
.SetAdditionalField("loggerName", loggingEvent.LoggerName)
.SetAdditionalField("threadName", loggingEvent.ThreadName)
.SetAdditionalField("userName", loggingEvent.UserName)
.SetAdditionalField("appDomain", loggingEvent.Domain);
if (IncludeSource)
{
var locationInformation = loggingEvent.LocationInformation;
if (locationInformation != null)
{
messageBuilder.SetAdditionalField("sourceFileName", locationInformation.FileName)
.SetAdditionalField("sourceClassName", locationInformation.ClassName)
.SetAdditionalField("sourceMethodName", locationInformation.MethodName)
.SetAdditionalField("sourceLineNumber", locationInformation.LineNumber);
}
}
if (IncludeStackTrace)
{
var exception = loggingEvent.ExceptionObject;
if (exception != null)
{
messageBuilder.SetAdditionalField("exceptionType", exception.GetType().FullName);
messageBuilder.SetAdditionalField("exceptionMessage", exception.Message);
messageBuilder.SetAdditionalField("exceptionStackTrace", exception.StackTrace);
}
}
if (IncludeEventProperties)
{
var properties = loggingEvent.Properties;
foreach (var propertyKey in properties.GetKeys())
{
messageBuilder.SetAdditionalField(propertyKey, properties[propertyKey]?.ToString());
}
}
transport.Send(messageBuilder.ToMessage());
}
catch (Exception exception)
{
logger.Error("Unable to send logging event to remote host", exception);
}
}
protected override void Append(LoggingEvent loggingEvent)
{
try
{
var renderedEvent = RenderLoggingEvent(loggingEvent);
var messageBuilder = new GelfMessageBuilder(renderedEvent, HostName, loggingEvent.TimeStamp, loggingEvent.Level.ToGelf())
.SetAdditionalField(GelfAdditionalFields.Facility, Facility)
.SetAdditionalField(GelfAdditionalFields.LoggerName, loggingEvent.LoggerName)
.SetAdditionalField(GelfAdditionalFields.ThreadName, loggingEvent.ThreadName);
foreach (var item in _staticOutFields)
{
messageBuilder.SetAdditionalField(item.Name, item.Value);
}
if (IncludeSource)
{
var locationInformation = loggingEvent.LocationInformation;
if (locationInformation != null)
{
messageBuilder.SetAdditionalField(GelfAdditionalFields.SourceFileName, locationInformation.FileName)
.SetAdditionalField(GelfAdditionalFields.SourceClassName, locationInformation.ClassName)
.SetAdditionalField(GelfAdditionalFields.SourceMethodName, locationInformation.MethodName)
.SetAdditionalField(GelfAdditionalFields.SourceLineNumber, locationInformation.LineNumber);
}
}
if (IncludeStackTrace)
{
var exception = loggingEvent.ExceptionObject;
if (exception != null)
{
messageBuilder.SetAdditionalField(GelfAdditionalFields.ExceptionMessage, exception.Message);
messageBuilder.SetAdditionalField(GelfAdditionalFields.ExceptionStackTrace, exception.StackTrace);
}
}
transport.Send(messageBuilder.ToMessage());
}
catch (Exception exception)
{
logger.Error("Unable to send logging event to remote host", exception);
}
}
protected override void Write(LogEventInfo loggingEvent)
{
try
{
var renderedEvent = Layout.Render(loggingEvent);
var messageBuilder = new GelfMessageBuilder(renderedEvent, HostName, loggingEvent.TimeStamp, ToGelf(loggingEvent.Level))
.SetAdditionalField("facility", Facility)
.SetAdditionalField("loggerName", loggingEvent.LoggerName)
.SetAdditionalField("sequenceId", loggingEvent.SequenceID.ToString());
if (IncludeSource)
{
var userStackFrame = loggingEvent.UserStackFrame;
if (userStackFrame != null)
{
messageBuilder.SetAdditionalField("sourceFileName", userStackFrame.GetFileName());
messageBuilder.SetAdditionalField("sourceLineNumber", userStackFrame.GetFileLineNumber().ToString(CultureInfo.InvariantCulture));
}
}
if (IncludeStackTrace)
{
var exception = loggingEvent.Exception;
if (exception != null)
{
messageBuilder.SetAdditionalField("exceptionType", exception.GetType().FullName);
messageBuilder.SetAdditionalField("exceptionMessage", exception.Message);
messageBuilder.SetAdditionalField("exceptionStackTrace", exception.StackTrace);
}
}
foreach (var parameter in Parameters)
{
var value = parameter.Layout.Render(loggingEvent);
if (string.IsNullOrWhiteSpace(value))
{
continue;
}
messageBuilder.SetAdditionalField(parameter.Name, value);
}
if (IncludeEventProperties)
{
foreach (var property in loggingEvent.Properties)
{
messageBuilder.SetAdditionalField(property.Key.ToString(), property.Value?.ToString());
}
}
transport.Send(messageBuilder.ToMessage());
}
catch (Exception exception)
{
logger.Error("Failed to send message", exception);
}
}
protected GelfMessageBuilder CreateGelfMessageBuilder(string message, DateTime timeStamp, GelfLevel logLevel)
{
var messageBuilder = new GelfMessageBuilder(message, Environment.MachineName.ToUpperInvariant(), timeStamp, logLevel);
if (_config.AdditionalProperties == null)
{
return(messageBuilder);
}
foreach (var kvp in _config.AdditionalProperties)
{
messageBuilder.SetAdditionalField($"{_config.PropertyPrefix}{kvp.Key}", kvp.Value);
}
return(messageBuilder);
}
public void Publish(LogMessage logMessage)
{
if (string.IsNullOrEmpty(_host))
{
return;
}
var str = _loggerFormatter.ApplyFormat(logMessage);
var builder = new GelfMessageBuilder(str, "Heroes Rage, " + Application.platform);
var level = GelfLevel.Debug;
if (logMessage.Level == SimpleLogger.Logger.Level.Error)
{
level = GelfLevel.Error;
}
else if (logMessage.Level == SimpleLogger.Logger.Level.Warning)
{
level = GelfLevel.Warning;
}
builder.SetLevel(level);
builder.SetTimestamp(DateTime.Now);
if (!string.IsNullOrEmpty(_username))
{
builder.SetAdditionalField("user_name", _username);
}
if (!string.IsNullOrEmpty(_buildVersion))
{
builder.SetAdditionalField("build", _buildVersion);
}
if (!string.IsNullOrEmpty(_deviceName))
{
builder.SetAdditionalField("device_name", _deviceName);
}
if (!string.IsNullOrEmpty(_deviceModel))
{
builder.SetAdditionalField("device_model", _deviceModel);
}
if (!string.IsNullOrEmpty(_deviceUniqueIdentifier))
{
builder.SetAdditionalField("device_id", _deviceUniqueIdentifier);
}
if (!string.IsNullOrEmpty(logMessage.CallingClass))
{
builder.SetAdditionalField("calling_class", logMessage.CallingClass);
}
if (!string.IsNullOrEmpty(logMessage.CallingMethod))
{
builder.SetAdditionalField("calling_method", logMessage.CallingMethod);
}
if (logMessage.LineNumber > 0)
{
builder.SetAdditionalField("line_number", logMessage.LineNumber.ToString());
}
var mes = _gelfSerializer.Serialize(builder.ToMessage());
Debug.Log("Mes = " + mes);
PushMessage(encoding.GetBytes(mes));
}
