public void ShouldSerializeMessageWithAdditionalFields()
{
var dateTime = new DateTime(2015, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
var message = new GelfMessageBuilder("Backtrace here\n\nmore stuff", "example.org", dateTime, GelfLevel.Alert)
.SetAdditionalField(GelfAdditionalFields.Facility, "facility")
.SetAdditionalField(GelfAdditionalFields.LoggerName, "loggerName")
.SetAdditionalField(GelfAdditionalFields.ThreadName, "threadName")
.SetAdditionalField(GelfAdditionalFields.SourceFileName, "sourceFileName")
.SetAdditionalField(GelfAdditionalFields.SourceLineNumber, "sourceLineNumber")
.SetAdditionalField(GelfAdditionalFields.SourceClassName, "sourceClassName")
.SetAdditionalField(GelfAdditionalFields.SourceMethodName, "sourceMethodName")
.ToMessage();
var serializedMessage = Encoding.UTF8.GetString(serializer.Serialize(message));
Assert.AreEqual("{\"version\":\"1.1\"," +
"\"host\":\"example.org\"," +
"\"short_message\":\"Backtrace here\\n\\nmore stuff\"," +
"\"full_message\":\"Backtrace here\\n\\nmore stuff\"," +
"\"timestamp\":1420070400," +
"\"level\":1," +
"\"_facility\":\"facility\"," +
"\"_loggerName\":\"loggerName\"," +
"\"_threadName\":\"threadName\"," +
"\"_sourceFileName\":\"sourceFileName\"," +
"\"_sourceLineNumber\":\"sourceLineNumber\"," +
"\"_sourceClassName\":\"sourceClassName\"," +
"\"_sourceMethodName\":\"sourceMethodName\"}", serializedMessage);
}
public void WhenMessageBuilding_ShouldIgnorePropertyNames()
{
var sut = new GelfMessageBuilder("localhost", new GraylogSinkOptions
{
PropertyNamingStrategy = new NoOpPropertyNamingStrategy()
});
var @event = new LogEvent(DateTimeOffset.Now, LogEventLevel.Information, null,
new MessageTemplate("abcdef{TestProp}", new List <MessageTemplateToken>
{
new TextToken("abcdef", 0),
new PropertyToken("LongPropertyName", "zxc", alignment: new Alignment(AlignmentDirection.Left, 3)),
new PropertyToken("Short", "zxc", alignment: new Alignment(AlignmentDirection.Left, 3))
}), new List <LogEventProperty>
{
new LogEventProperty("LongPropertyName", new ScalarValue("zxc")),
new LogEventProperty("Short", new ScalarValue("zxc")),
new LogEventProperty("id", new ScalarValue("asd"))
});
var actual = sut.Build(@event);
Assert.Null(actual.Property("_longPropertyName"));
Assert.Null(actual.Property("_short"));
Assert.NotNull(actual.Property("_LongPropertyName"));
Assert.NotNull(actual.Property("_Short"));
}
public void WhenGetSimpleEvent_ThenResult_ShouldBeExpected()
{
var options = new GraylogSinkOptions();
var target = new GelfMessageBuilder("localhost", options);
var date = DateTimeOffset.Now;
var expected = new
{
facility = "GELF",
full_message = "abcdef\"zxc\"",
host = "localhost",
level = 2,
short_message = "abcdef\"zxc\"",
timestamp = date.DateTime,
version = "1.1",
_stringLevel = "Information",
_TestProp = "\"zxc\"",
_id_ = "\"asd\""
};
LogEvent logEvent = LogEventSource.GetSimpleLogEvent(date);
string expectedString = JsonConvert.SerializeObject(expected, Newtonsoft.Json.Formatting.None);
string actual = target.Build(logEvent).ToString(Newtonsoft.Json.Formatting.None);
//actual.ShouldBeEquivalentTo(expectedString);
}
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 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);
}
}
public void TryComplexEvent()
{
var options = new GraylogSinkOptions();
var target = new GelfMessageBuilder("localhost", options);
DateTimeOffset date = DateTimeOffset.Now;
LogEvent logEvent = LogEventSource.GetComplexEvent(date);
string actual = target.Build(logEvent).ToString(Newtonsoft.Json.Formatting.None);
}
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);
}
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);
}
}
public void GetSimpleLogEvent_GraylogSinkOptionsContainsHost_ReturnsOptionsHost()
{
//arrange
GraylogSinkOptions options = new GraylogSinkOptions()
{
Host = "my_host"
};
GelfMessageBuilder messageBuilder = new GelfMessageBuilder("localhost", options);
DateTime date = DateTime.UtcNow;
string expectedHost = "my_host";
//act
LogEvent logEvent = LogEventSource.GetSimpleLogEvent(date);
JObject actual = messageBuilder.Build(logEvent);
string actualHost = actual.Value <string>("host");
//assert
Assert.Equal(expectedHost, actualHost);
}
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);
}
}
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));
}
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;
}
}
}
