private void AddAdditionalFields(LoggingEvent loggingEvent, GelfMessage message)
{
Dictionary <string, string> additionalFields = innerAdditionalFields == null
? new Dictionary <string, string>()
: new Dictionary <string, string>(innerAdditionalFields);
foreach (DictionaryEntry item in loggingEvent.GetProperties())
{
var key = item.Key as string;
if (key != null && !key.StartsWith("log4net:") /*exclude log4net built-in properties */)
{
var val = item.Value == null ? null : item.Value.ToString();
additionalFields.Add(key, val);
}
}
foreach (var kvp in additionalFields)
{
var key = kvp.Key.StartsWith("_") ? kvp.Key : "_" + kvp.Key;
//If the value starts with a '%' then defer to the pattern layout
var value = kvp.Value.StartsWith("%") ? GetValueFromPattern(loggingEvent, kvp.Value) : kvp.Value;
message[key] = value;
}
}
public void Send(GelfMessage message)
{
lock (_sync)
{
buffer.Add(message, cancellationTokenSource.Token);
}
}
public void Format(GelfMessage gelfMessage, object messageObject)
{
var exception = (Exception)messageObject;
if (string.IsNullOrEmpty(gelfMessage.ShortMessage))
{
gelfMessage.ShortMessage = exception.Message;
}
else
{
gelfMessage["_ExceptionMessage"] = exception.Message;
}
if (string.IsNullOrEmpty(gelfMessage.FullMessage))
{
gelfMessage.FullMessage = exception.ToString();
}
else
{
gelfMessage["_ExceptionMessage"] = exception.Message;
}
gelfMessage["_Exception"] = exception.ToString();
gelfMessage["_ExceptionType"] = messageObject.GetType().FullName;
gelfMessage["_ExceptionStackTrace"] = exception.StackTrace;
if (exception.InnerException == null)
{
return;
}
gelfMessage["_InnerExceptionType"] = exception.InnerException.GetType().FullName;
gelfMessage["_InnerExceptionMessage"] = exception.InnerException.Message;
}
private void SendMessage(GelfMessage msg, CancellationToken cancelToken)
{
var sendRetryCount = _config.RetryCount ?? GraylogConstants.DefaultRetryCount;
var maxRetries = sendRetryCount;
while (!cancelToken.IsCancellationRequested)
{
try
{
GetTransport()?.Send(msg);
return;
}
catch (Exception ex)
{
sendRetryCount--;
if (sendRetryCount < 1)
{
throw new GraylogSendRetryFailedException(
$"Cannot send log message after {maxRetries} attempts, giving up. See inner Exceptions for details.",
ex);
}
var interval = TimeSpan.FromMilliseconds(_config.RetryIntervalMs ?? GraylogConstants.DefaultRetryIntervalInMs);
if (interval <= TimeSpan.Zero)
{
continue;
}
Thread.Sleep(_config.RetryIntervalMs ?? GraylogConstants.DefaultRetryIntervalInMs);
}
}
}
public void Send(GelfMessage message)
{
lock (_sync)
{
buffer.Add(message, cancellationTokenSource.Token);
}
}
public void ShouldContinueWhenSendSuceed()
{
var message = new GelfMessage();
mainTransport.Expect(x => x.Send(message)).TentativeReturn();
retryingTransport.Send(message);
}
public void Format(GelfMessage gelfMessage, object messageObject)
{
var exception = (Exception) messageObject;
if (string.IsNullOrEmpty(gelfMessage.ShortMessage))
{
gelfMessage.ShortMessage = exception.Message;
}
else
{
gelfMessage["_ExceptionMessage"] = exception.Message;
}
if (string.IsNullOrEmpty(gelfMessage.FullMessage))
{
gelfMessage.FullMessage = exception.ToString();
}
else
{
gelfMessage["_ExceptionMessage"] = exception.Message;
}
gelfMessage["_Exception"] = exception.ToString();
gelfMessage["_ExceptionType"] = messageObject.GetType().FullName;
gelfMessage["_ExceptionStackTrace"] = exception.StackTrace;
if (exception.InnerException == null) return;
gelfMessage["_InnerExceptionType"] = exception.InnerException.GetType().FullName;
gelfMessage["_InnerExceptionMessage"] = exception.InnerException.Message;
}
/// <summary>
/// Builds the specified log event.
/// </summary>
/// <param name="logEvent">The log event.</param>
/// <returns></returns>
public virtual JObject Build(LogEvent logEvent)
{
string message = logEvent.RenderMessage();
string shortMessage = message.Truncate(Options.ShortMessageMaxLength);
var gelfMessage = new GelfMessage
{
Version = DefaultGelfVersion,
Host = _hostName,
ShortMessage = shortMessage,
Timestamp = logEvent.Timestamp.ConvertToNix(),
Level = LogLevelMapper.GetMappedLevel(logEvent.Level),
StringLevel = logEvent.Level.ToString(),
Facility = Options.Facility
};
if (message.Length > Options.ShortMessageMaxLength)
{
gelfMessage.FullMessage = message;
}
JObject jsonObject = JObject.FromObject(gelfMessage);
foreach (KeyValuePair <string, LogEventPropertyValue> property in logEvent.Properties)
{
AddAdditionalField(jsonObject, property);
}
return(jsonObject);
}
private void AppendExceptionInformationIfExists(GelfMessage gelfMessage, Exception exceptionObject)
{
if (exceptionObject != null)
{
ExceptionMessageFormatter.Format(gelfMessage, exceptionObject);
}
}
/// <summary>
/// Builds the specified log event.
/// </summary>
/// <param name="logEvent">The log event.</param>
/// <returns></returns>
public virtual JObject Build(LogEvent logEvent)
{
var message = logEvent.RenderMessage();
var shortMessage = message.Truncate(Options.ShortMessageMaxLength);
var gelfMessage = new GelfMessage
{
Version = GelfVersion,
Host = hostName,
ShortMessage = shortMessage,
FullMessage = message,
Timestamp = logEvent.Timestamp.DateTime.ConvertToNix(),
Level = LogLevelMapper.GetMappedLevel(logEvent.Level),
StringLevel = logEvent.Level.ToString(),
Facility = Options.Facility
};
var jsonObject = JObject.FromObject(gelfMessage);
foreach (var property in logEvent.Properties)
{
AddAdditionalField(jsonObject, property);
}
return(jsonObject);
}
public virtual JObject Build(LogEvent logEvent)
{
string message = logEvent.RenderMessage();
string shortMessage = message.ShortMessage(Options.ShortMessageMaxLength);
var gelfMessage = new GelfMessage
{
Version = GelfVersion,
Host = _hostName,
ShortMessage = shortMessage,
FullMessage = message,
Timestamp = logEvent.Timestamp.DateTime,
Level = (int)logEvent.Level,
StringLevel = logEvent.Level.ToString(),
Facility = Options.Facility
};
JObject jsonObject = JObject.FromObject(gelfMessage);
foreach (KeyValuePair <string, LogEventPropertyValue> property in logEvent.Properties)
{
AddAdditionalField(jsonObject, property);
}
return(jsonObject);
}
public void Send(GelfMessage message)
{
using (var udpClient = new UdpClient())
foreach (var bytes in encoder.Encode(messageSerializer.Serialize(message)))
{
udpClient.Send(bytes, bytes.Length, configuration.GetHost());
}
}
public void ShouldSendAgainIfFirstAttempFailed()
{
var message = new GelfMessage();
mainTransport.Expect(x => x.Send(message)).Throw(new Exception());
mainTransport.Expect(x => x.Send(message)).TentativeReturn();
retryingTransport.Send(message);
}
public void Send(GelfMessage message)
{
using (var udpClient = new UdpClient())
foreach (var bytes in encoder.Encode(messageSerializer.Serialize(message)))
{
var result = udpClient.SendAsync(bytes, bytes.Length, configuration.Host).Result;
}
}
public virtual void Format(GelfMessage gelfMessage, object messageObject)
{
foreach (DictionaryEntry entry in (IDictionary)messageObject)
{
if (entry.Value == null) continue;
var key = FormatKey(entry.Key.ToString());
gelfMessage[key] = entry.Value.ToString();
}
}
public void ShouldFailIfAllAttemptsFailed()
{
var message = new GelfMessage();
for (var i = 0; i < retryCount; ++i)
{
mainTransport.Expect(x => x.Send(message)).Throw(new Exception());
}
retryingTransport.Send(message);
}
public void Send(GelfMessage message)
{
EstablishConnection();
using (var stream = client.GetStream())
{
var bytes = messageSerializer.Serialize(message);
stream.Write(bytes, 0, bytes.Length);
stream.WriteByte(0);
}
}
public void Send(GelfMessage message)
{
EstablishConnection();
using (var stream = client.GetStream())
{
var bytes = messageSerializer.Serialize(message);
stream.Write(bytes, 0, bytes.Length);
stream.WriteByte(0);
}
}
public void Send(GelfMessage message)
{
EstablishConnection();
var serialzed = messageSerializer.Serialize(message);
var encoded = encoder.Encode(serialzed);
foreach (var bytes in encoded)
{
udpClient.Send(bytes, bytes.Length);
}
}
private void FormatGelfMessage(GelfMessage gelfMessage, LoggingEvent loggingEvent)
{
var messageFormatter = messageObjectFormatters.First(x => x.CanApply(loggingEvent.MessageObject));
messageFormatter.Format(gelfMessage, loggingEvent.MessageObject);
AppendExceptionInformationIfExists(gelfMessage, loggingEvent.ExceptionObject);
if (string.IsNullOrWhiteSpace(gelfMessage.ShortMessage))
{
gelfMessage.ShortMessage = "Logged object of type: " + loggingEvent.MessageObject.GetType().FullName;
}
}
private void AddLoggingEventToMessage(LoggingEvent loggingEvent, GelfMessage gelfMessage)
{
//If conversion pattern is specified then defer to PatterLayout for building the message body
if (!string.IsNullOrWhiteSpace(ConversionPattern))
{
var message = GetValueFromPattern(loggingEvent, ConversionPattern);
gelfMessage.FullMessage = message;
gelfMessage.ShortMessage = message.TruncateMessage(SHORT_MESSAGE_LENGTH);
}
else //Otherwise do our custom message builder stuff
{
var messageObject = loggingEvent.MessageObject;
if (messageObject == null)
{
if (!string.IsNullOrEmpty(loggingEvent.RenderedMessage))
{
if (loggingEvent.RenderedMessage.ValidateJSON())
{
AddToMessage(gelfMessage, loggingEvent.RenderedMessage.ToJson().ToDictionary());
}
gelfMessage.FullMessage = !string.IsNullOrEmpty(gelfMessage.FullMessage) ? gelfMessage.FullMessage : loggingEvent.RenderedMessage;
gelfMessage.ShortMessage = !string.IsNullOrEmpty(gelfMessage.ShortMessage) ? gelfMessage.ShortMessage : gelfMessage.FullMessage.TruncateMessage(SHORT_MESSAGE_LENGTH);
return;
}
gelfMessage.FullMessage = SystemInfo.NullText;
gelfMessage.ShortMessage = SystemInfo.NullText;
}
if (messageObject is string || messageObject is SystemStringFormat)
{
var fullMessage = messageObject.ToString();
gelfMessage.FullMessage = fullMessage;
gelfMessage.ShortMessage = fullMessage.TruncateMessage(SHORT_MESSAGE_LENGTH);
}
else if (messageObject is IDictionary)
{
AddToMessage(gelfMessage, messageObject as IDictionary);
}
else
{
AddToMessage(gelfMessage, messageObject.ToDictionary());
}
gelfMessage.FullMessage = !string.IsNullOrEmpty(gelfMessage.FullMessage) ? gelfMessage.FullMessage : messageObject.ToString();
gelfMessage.ShortMessage = !string.IsNullOrEmpty(gelfMessage.ShortMessage) ? gelfMessage.ShortMessage : gelfMessage.FullMessage.TruncateMessage(SHORT_MESSAGE_LENGTH);
}
if (LogStackTraceFromMessage && loggingEvent.ExceptionObject != null)
{
gelfMessage.FullMessage = string.Format("{0} - {1}.", gelfMessage.FullMessage, loggingEvent.GetExceptionString());
}
}
public void Send(GelfMessage message)
{
EstablishConnection();
var bytes = _messageSerializer.SerializeToStringBytes(message);
_clientStream.Write(bytes, 0, bytes.Length);
if (_useNullByteDelimiter)
{
// write final NULL byte indicating that one complete GELF message has been written
_clientStream.WriteByte(0);
}
}
public void Send(GelfMessage message)
{
EstablishConnection();
foreach (var bytes in encoder.Encode(messageSerializer.Serialize(message)))
{
var basicProperties = new BasicProperties
{
DeliveryMode = configuration.Persistent ? (byte)2 : (byte)1
};
channel.BasicPublish(configuration.Exchange, configuration.RoutingKey, false, false, basicProperties, bytes);
}
}
public virtual void Format(GelfMessage gelfMessage, object messageObject)
{
foreach (DictionaryEntry entry in (IDictionary)messageObject)
{
if (entry.Value == null)
{
continue;
}
string key = this.FormatKey(entry.Key.ToString());
gelfMessage[key] = entry.Value.ToString();
}
}
public void Send(GelfMessage message)
{
EstablishConnection();
foreach (var bytes in encoder.Encode(messageSerializer.Serialize(message)))
{
var basicProperties = new BasicProperties
{
DeliveryMode = configuration.Persistent ? (byte)2 : (byte)1
};
channel.BasicPublish(configuration.Exchange, configuration.RoutingKey, false, false, basicProperties, bytes);
}
}
public void Send(GelfMessage message)
{
var msg = _messageSerializer.SerializeToString(message);
var stringContent = new StringContent(msg, System.Text.Encoding.UTF8);
stringContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
var response = _client.PostAsync(_uri, stringContent);
if (response.Result.StatusCode == HttpStatusCode.Accepted)
{
throw new GraylogHttpTransportException($"Received status code '{response.Result.StatusCode}' from GrayLog.");
}
}
public void Format(GelfMessage gelfMessage, object messageObject)
{
var message = messageObject.ToString();
if (message.Length > MaximumShortMessageLength)
{
gelfMessage.FullMessage = message;
gelfMessage.ShortMessage = message.TruncateString(MaximumShortMessageLength);
}
else
{
gelfMessage.ShortMessage = message;
}
}
public void ShouldSkipMessageIfSendFailed()
{
var countingTransport = new FailCountingTransport();
var bufferedTransport = new BufferedTransport(new SilentLogger(), countingTransport);
for (var i = 0; i < MessageCount; ++i)
{
var message = new GelfMessage();
bufferedTransport.Send(message);
}
bufferedTransport.Close();
Assert.AreEqual(MessageCount, countingTransport.Count);
}
public void Given_large_payload_that_exced_gelf_max_chunk_count_publish_should_throw_message_to_big_exception()
{
var bigPayload = new byte[130000];
var gelfMessageToSend = new GelfMessage();
var random = new Random();
random.NextBytes(bigPayload);
gelfMessageToSend["big_payload"] = bigPayload;
Assert.Throws <GelfMessageTooBigException>(() => gelfPublisher.Publish(gelfMessageToSend));
}
public void Format(GelfMessage gelfMessage, object messageObject)
{
var message = messageObject.ToString();
if (message.Length > MaximumShortMessageLength)
{
gelfMessage.FullMessage = message;
gelfMessage.ShortMessage = message.TruncateString(MaximumShortMessageLength);
}
else
{
gelfMessage.ShortMessage = message;
}
}
public void Serialises_to_JSON_string_with_correct_settings()
{
var message = new GelfMessage
{
Level = SyslogSeverity.Emergency,
AdditionalFields = new Dictionary <string, object>()
};
var messageJson = message.ToJson();
Assert.Contains("version", messageJson);
Assert.DoesNotContain("Emergency", messageJson);
Assert.DoesNotContain(Environment.NewLine, messageJson);
Assert.DoesNotContain("null", messageJson);
}
public void Send(GelfMessage message)
{
var request = (HttpWebRequest)WebRequest.Create(configuration.Uri);
using (var requestStream = request.GetRequestStream())
using (var messageStream = new MemoryStream(messageSerializer.Serialize(message)))
messageStream.CopyTo(requestStream);
request.Method = "POST";
request.AllowAutoRedirect = false;
request.ReadWriteTimeout = request.Timeout = configuration.Timeout;
using (var response = (HttpWebResponse)request.GetResponse())
{
if (response.StatusCode == HttpStatusCode.Accepted)
return;
throw new SendFailedException();
}
}
public void Send(GelfMessage message)
{
EstablishConnection();
var bytes = messageSerializer.Serialize(message);
try
{
connection.Stream.Write(bytes, 0, bytes.Length);
connection.Stream.WriteByte(0);
}
catch (Exception)
{
Close();
throw;
}
}
public void Send(GelfMessage message)
{
var request = (HttpWebRequest)WebRequest.Create(configuration.Uri);
using (var requestStream = request.GetRequestStream())
using (var messageStream = new MemoryStream(messageSerializer.Serialize(message)))
messageStream.CopyTo(requestStream);
request.Method = "POST";
request.AllowAutoRedirect = false;
request.ReadWriteTimeout = request.Timeout = configuration.Timeout;
using (var response = (HttpWebResponse)request.GetResponse())
{
if (response.StatusCode == HttpStatusCode.Accepted)
{
return;
}
throw new SendFailedException();
}
}
public void IntegrationTest()
{
// Arrange
var receiveEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), Port);
var manualResetEvent = new ManualResetEvent(false);
var gelfMessageToSend = new GelfMessage
{
Host = Environment.MachineName,
FullMessage = "Full message",
ShortMessage = "Short message",
};
gelfMessageToSend["correlationId"] = Guid.NewGuid().ToString();
string receivedMessage = null;
bool wasMessageReceived;
using (var udp = new UdpClient(Port, AddressFamily.InterNetworkV6))
{
var localUdpClient = udp; // Avoid Resharper access to Disposed closure warning
localUdpClient.BeginReceive(ar =>
{
var receiveBytes = localUdpClient.EndReceive(ar, ref receiveEndPoint);
receivedMessage = TestUtils.DecompressGzipMessage(receiveBytes, Constants.Encoding);
manualResetEvent.Set();
}, null);
// Act
gelfPublisher.Publish(gelfMessageToSend);
wasMessageReceived = manualResetEvent.WaitOne(TimeSpan.FromSeconds(2));
}
// Assert
Assert.That(wasMessageReceived, Is.True, "Message not received in time");
dynamic receivedObject = JObject.Parse(receivedMessage);
Assert.That(receivedObject.correlationId.ToString(), Is.EqualTo(gelfMessageToSend["correlationId"]));
Assert.That(receivedObject.host.ToString(), Is.EqualTo(gelfMessageToSend.Host));
Assert.That(receivedObject.full_message.ToString(), Is.EqualTo(gelfMessageToSend.FullMessage));
Assert.That(receivedObject.short_message.ToString(), Is.EqualTo(gelfMessageToSend.ShortMessage));
}
public void Send(GelfMessage message)
{
var sendRetryCount = retryCount;
while (true)
{
try
{
transport.Send(message);
break;
}
catch(Exception exception)
{
sendRetryCount--;
if(sendRetryCount <= 0)
throw;
Thread.Sleep(retryDelay);
logger.Error("Cannot send message. Retrying...", exception);
}
}
}
public void ShouldSerializerSimpleMessage()
{
var dateTime = new DateTime(2015, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
var message = new GelfMessage
{
Host = "example.org",
ShortMessage = "A short message that helps you identify what is going on",
FullMessage = "Backtrace here\n\nmore stuff",
Timestamp = dateTime,
Level = GelfLevel.Alert,
};
var serializedMessage = Encoding.UTF8.GetString(serializer.Serialize(message));
Assert.AreEqual("{\"version\":\"1.1\"," +
"\"host\":\"example.org\"," +
"\"short_message\":\"A short message that helps you identify what is going on\"," +
"\"full_message\":\"Backtrace here\\n\\nmore stuff\"," +
"\"timestamp\":1420070400," +
"\"level\":1}", serializedMessage);
}
private void AddToMessage(GelfMessage gelfMessage, IDictionary messageObject)
{
foreach (DictionaryEntry entry in messageObject as IDictionary)
{
var key = (entry.Key ?? string.Empty).ToString();
var value = (entry.Value ?? string.Empty).ToString();
if (FullMessageKeyValues.Contains(key, StringComparer.OrdinalIgnoreCase))
{
gelfMessage.FullMessage = value;
}
else if (ShortMessageKeyValues.Contains(key, StringComparer.OrdinalIgnoreCase))
{
gelfMessage.ShortMessage = value.TruncateMessage(SHORT_MESSAGE_LENGTH);
}
else
{
key = key.StartsWith("_") ? key : "_" + key;
gelfMessage[key] = value;
}
}
}
public void Serialises_to_JSON_string_with_correct_settings()
{
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
Converters =
{
new StringEnumConverter()
}
};
var message = new GelfMessage
{
Level = SyslogSeverity.Emergency,
AdditionalFields = new Dictionary <string, object>()
};
var messageJson = message.ToJson();
Assert.DoesNotContain("Emergency", messageJson);
Assert.DoesNotContain(Environment.NewLine, messageJson);
Assert.DoesNotContain("null", messageJson);
}
private GelfMessage GetBaseGelfMessage(LoggingEvent loggingEvent)
{
var message = new GelfMessage
{
Facility = Facility ?? "GELF",
File = string.Empty,
Host = Environment.MachineName,
Level = GetSyslogSeverity(loggingEvent.Level),
Line = string.Empty,
TimeStamp = loggingEvent.TimeStamp,
Version = GELF_VERSION,
};
message.Add("LoggerName", loggingEvent.LoggerName);
if (this.IncludeLocationInformation)
{
message.File = loggingEvent.LocationInformation.FileName;
message.Line = loggingEvent.LocationInformation.LineNumber;
}
return(message);
}
private void AddAdditionalFields(LoggingEvent loggingEvent, GelfMessage message)
{
Dictionary<string, string> additionalFields = innerAdditionalFields == null
? new Dictionary<string, string>()
: new Dictionary<string, string>(innerAdditionalFields);
foreach (DictionaryEntry item in loggingEvent.GetProperties())
{
var key = item.Key as string;
if (key != null && !key.StartsWith("log4net:") /*exclude log4net built-in properties */ )
{
var val = item.Value == null ? null : item.Value.ToString();
additionalFields.Add(key, val);
}
}
foreach (var kvp in additionalFields)
{
var key = kvp.Key.StartsWith("_") ? kvp.Key : "_" + kvp.Key;
message[key] = kvp.Value;
}
}
private void AddLocationInfo(LoggingEvent loggingEvent, GelfMessage gelfMessage)
{
if (loggingEvent.LocationInformation == null) return;
gelfMessage.File = loggingEvent.LocationInformation.FileName;
gelfMessage.Line = loggingEvent.LocationInformation.LineNumber;
}
public override void Format(GelfMessage gelfMessage, object messageObject)
{
base.Format(gelfMessage, CreateDictionaryFromObject(messageObject));
}
public void Send(GelfMessage message)
{
using (var udpClient = new UdpClient())
foreach (var bytes in encoder.Encode(messageSerializer.Serialize(message)))
udpClient.Send(bytes, bytes.Length, configuration.Host);
}
private void AddLoggingEventToMessage(LoggingEvent loggingEvent, GelfMessage gelfMessage)
{
var messageObject = loggingEvent.MessageObject;
if (messageObject == null)
{
gelfMessage.FullMessage = SystemInfo.NullText;
gelfMessage.ShortMessage = SystemInfo.NullText;
}
if (messageObject is string || messageObject is SystemStringFormat)
{
var fullMessage = messageObject.ToString();
gelfMessage.FullMessage = fullMessage;
gelfMessage.ShortMessage = fullMessage.TruncateMessage(SHORT_MESSAGE_LENGTH);
}
else if (messageObject is IDictionary)
{
AddToMessage(gelfMessage, messageObject as IDictionary);
}
else
{
AddToMessage(gelfMessage, messageObject.ToDictionary());
}
gelfMessage.FullMessage = gelfMessage.FullMessage ?? messageObject.ToString();
gelfMessage.ShortMessage = gelfMessage.ShortMessage ?? gelfMessage.FullMessage.TruncateMessage(SHORT_MESSAGE_LENGTH);
if (LogStackTraceFromMessage && loggingEvent.ExceptionObject != null)
{
gelfMessage.FullMessage = string.Format("{0} - {1}.", gelfMessage.FullMessage, loggingEvent.GetExceptionString());
}
}
private void AddAdditionalFields(LoggingEvent loggingEvent, GelfMessage message)
{
var additionalFields = ParseField(AdditionalFields) ?? new Dictionary<string, object>();
foreach (DictionaryEntry item in loggingEvent.GetProperties())
{
var key = item.Key as string;
if (key != null && !key.StartsWith("log4net:") /*exclude log4net built-in properties */ )
{
additionalFields.Add(key, FormatAdditionalField(item.Value));
}
}
foreach (var kvp in additionalFields)
{
var key = kvp.Key.StartsWith("_") ? kvp.Key : "_" + kvp.Key;
//If the value starts with a '%' then defer to the pattern layout
var patternValue = kvp.Value as string;
var value = patternValue != null && patternValue.StartsWith("%") ? GetValueFromPattern(loggingEvent, patternValue) : kvp.Value;
message[key] = value;
}
}
private static string BuildMessageJson(GelfMessage message, IDictionary<string, string> additionalFields)
{
JObject messageJObject = JObject.FromObject(message);
foreach (var field in additionalFields)
{
string key = field.Key;
if (string.IsNullOrWhiteSpace(key))
continue;
if (!key.StartsWith("_"))
key = string.Format("_{0}", key);
// prevent sending submitting a field with the key '_id' per GELF spec: https://github.com/Graylog2/graylog2-docs/wiki/GELF
if (key != "_id")
{
key = Regex.Replace(key, "[\\W]", "");
messageJObject.Add(key, field.Value);
}
}
return messageJObject.ToString();
}
private string GenerateMessage(LoggingEvent loggingEvent, string hostName, string facility, Dictionary<string, string> globalAdditionalFields)
{
string renderedMessage = (Layout != null) ? RenderLoggingEvent(loggingEvent) : loggingEvent.RenderedMessage ?? loggingEvent.MessageObject.ToString();
string shortMessage = GetCustomShortMessage(loggingEvent) ?? renderedMessage.Substring(0, Math.Min(renderedMessage.Length, c_maxShortMessageLength));
string fullMessage = loggingEvent.ExceptionObject != null
? string.Format("{0} - {1}. {2}. {3}.", renderedMessage, loggingEvent.ExceptionObject.Source, loggingEvent.ExceptionObject.Message, loggingEvent.ExceptionObject.StackTrace)
: renderedMessage;
GelfMessage gelfMessage = new GelfMessage
{
Facility = (facility ?? c_defaultFacility),
Host = hostName,
Level = GetSyslogSeverity(loggingEvent.Level),
ShortMessage = shortMessage,
FullMesage = fullMessage,
TimeStamp = loggingEvent.TimeStamp,
Version = c_gelfVersion,
};
if (loggingEvent.LocationInformation != null)
{
gelfMessage.File = loggingEvent.LocationInformation.FileName;
gelfMessage.Line = loggingEvent.LocationInformation.LineNumber;
}
List<IDictionary> fieldDictionaries = new List<IDictionary> { globalAdditionalFields, loggingEvent.GetProperties() };
fieldDictionaries.AddRange(GetMessageSpecificFields(loggingEvent));
string messageJson = BuildMessageJson(gelfMessage, AssembleAdditionalFields(fieldDictionaries));
return messageJson;
}
private void AddAdditionalFields(LoggingEvent loggingEvent, GelfMessage message)
{
Dictionary<string, string> additionalFields = ParseField(AdditionalFields)??new Dictionary<string, string>();
foreach (DictionaryEntry item in loggingEvent.GetProperties())
{
var key = item.Key as string;
if (key != null && !key.StartsWith("log4net:") /*exclude log4net built-in properties */ )
{
var val = item.Value == null ? null : item.Value.ToString();
additionalFields.Add(key, val);
}
}
foreach (var kvp in additionalFields)
{
var key = kvp.Key.StartsWith("_") ? kvp.Key : "_" + kvp.Key;
//If the value starts with a '%' then defer to the pattern layout
var value = kvp.Value == null ? String.Empty : (kvp.Value.StartsWith("%") ? GetValueFromPattern(loggingEvent, kvp.Value) : kvp.Value);
message[key] = value;
}
}
private void AddLoggingEventToMessage(LoggingEvent loggingEvent, GelfMessage gelfMessage)
{
//If conversion pattern is specified then defer to PatterLayout for building the message body
if (!string.IsNullOrWhiteSpace(ConversionPattern))
{
var message = GetValueFromPattern(loggingEvent, ConversionPattern);
gelfMessage.FullMessage = message;
gelfMessage.ShortMessage = message.TruncateMessage(SHORT_MESSAGE_LENGTH);
}
else //Otherwise do our custom message builder stuff
{
var messageObject = loggingEvent.MessageObject;
if (messageObject == null)
{
gelfMessage.FullMessage = SystemInfo.NullText;
gelfMessage.ShortMessage = SystemInfo.NullText;
}
if (messageObject is string || messageObject is SystemStringFormat)
{
var fullMessage = messageObject.ToString();
gelfMessage.FullMessage = fullMessage;
gelfMessage.ShortMessage = fullMessage.TruncateMessage(SHORT_MESSAGE_LENGTH);
}
else if (messageObject is IDictionary)
{
AddToMessage(gelfMessage, messageObject as IDictionary);
}
else
{
AddToMessage(gelfMessage, messageObject.ToDictionary());
}
gelfMessage.FullMessage = !string.IsNullOrEmpty(gelfMessage.FullMessage) ? gelfMessage.FullMessage : messageObject.ToString();
gelfMessage.ShortMessage = !string.IsNullOrEmpty(gelfMessage.ShortMessage) ? gelfMessage.ShortMessage : gelfMessage.FullMessage.TruncateMessage(SHORT_MESSAGE_LENGTH);
}
if (LogStackTraceFromMessage && loggingEvent.ExceptionObject != null)
{
gelfMessage.FullMessage = string.Format("{0} - {1}.", gelfMessage.FullMessage, loggingEvent.GetExceptionString());
}
}
private void AddToMessage(GelfMessage gelfMessage, IDictionary messageObject)
{
foreach (DictionaryEntry entry in messageObject as IDictionary)
{
var key = (entry.Key ?? string.Empty).ToString();
var value = (entry.Value ?? string.Empty).ToString();
if (FullMessageKeyValues.Contains(key, StringComparer.OrdinalIgnoreCase))
gelfMessage.FullMessage = value;
else if (ShortMessageKeyValues.Contains(key, StringComparer.OrdinalIgnoreCase))
gelfMessage.ShortMessage = value.TruncateMessage(SHORT_MESSAGE_LENGTH);
else
{
key = key.StartsWith("_") ? key : "_" + key;
gelfMessage[key] = value;
}
}
}
private GelfMessage GetBaseGelfMessage(LoggingEvent loggingEvent)
{
var message = new GelfMessage
{
Facility = Facility ?? "GELF",
File = string.Empty,
Host = HostName ?? Environment.MachineName,
Level = GetSyslogSeverity(loggingEvent.Level),
Line = string.Empty,
TimeStamp = loggingEvent.TimeStamp,
Version = GELF_VERSION,
};
message.Add("LoggerName", loggingEvent.LoggerName);
if (this.IncludeLocationInformation)
{
message.File = loggingEvent.LocationInformation.FileName;
message.Line = loggingEvent.LocationInformation.LineNumber;
}
return message;
}
