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);
}
}
public BufferedTransport(IEasyGelfLogger logger, ITransport transport)
{
new Thread(() =>
{
var cancellationToken = cancellationTokenSource.Token;
try
{
GelfMessage mesage;
while (buffer.TryTake(out mesage, -1, cancellationToken))
{
try
{
transport.Send(mesage);
}
catch (Exception exception)
{
logger.Error("Cannot send message", exception);
}
}
}
catch
{
GelfMessage message;
while (buffer.TryTake(out message))
{
try
{
transport.Send(message);
}
catch (Exception exception)
{
logger.Error("Cannot send message", exception);
}
}
}
transport.Close();
stopEvent.Set();
})
{
IsBackground = true, Name = "EasyGelf Buffered Transport Thread"
}.Start();
}
public BufferedTransport(IEasyGelfLogger logger, ITransport transport)
{
new Thread(() =>
{
var cancellationToken = cancellationTokenSource.Token;
try
{
GelfMessage mesage;
while (buffer.TryTake(out mesage, -1, cancellationToken))
{
try
{
transport.Send(mesage);
}
catch(Exception exception)
{
logger.Error("Cannot send message", exception);
}
}
}
catch
{
GelfMessage message;
while (buffer.TryTake(out message))
{
try
{
transport.Send(message);
}
catch (Exception exception)
{
logger.Error("Cannot send message", exception);
}
}
}
transport.Close();
stopEvent.Set();
}) {IsBackground = true, Name = "EasyGelf Buffered Transport Thread"}.Start();
}
public override void ActivateOptions()
{
base.ActivateOptions();
try
{
logger = Verbose ? (IEasyGelfLogger) new VerboseLogger() : new SilentLogger();
var mainTransport = InitializeTransport(logger);
transport = new BufferedTransport(logger, UseRetry ? new RetryingTransport(logger, mainTransport, RetryCount, RetryDelay) : mainTransport);
}
catch (Exception exception)
{
logger.Error("Failed to create Transport", exception);
}
}
public override void ActivateOptions()
{
base.ActivateOptions();
try
{
logger = Verbose ? (IEasyGelfLogger)new VerboseLogger() : new SilentLogger();
var mainTransport = InitializeTransport(logger);
transport = new BufferedTransport(logger, UseRetry ? new RetryingTransport(logger, mainTransport, RetryCount, RetryDelay) : mainTransport);
}
catch (Exception exception)
{
logger.Error("Failed to create Transport", exception);
}
}
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);
}
}
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 override void ActivateOptions()
{
base.ActivateOptions();
try
{
logger = Verbose ? (IEasyGelfLogger)new VerboseLogger() : new SilentLogger();
var mainTransport = InitializeTransport(logger);
transport = new BufferedTransport(logger, UseRetry ? new RetryingTransport(logger, mainTransport, RetryCount, RetryDelay) : mainTransport);
customParams = new Dictionary<string, string>();
if (!string.IsNullOrEmpty(AdditionalFields))
ParseAdditionalFields(AdditionalFields);
}
catch (Exception exception)
{
logger.Error("Failed to create Transport", exception);
}
}
