public void WriteEvent(string eventName, LogEventSeverity eventSeverity = LogEventSeverity.Information, LogEventType eventType = LogEventType.ApplicationEvent, IEnumerable <KeyValuePair <string, object> > properties = null, string source = "", string sourceMethod = "")
{
if (!IsEnabled)
{
return;
}
using (var pooledLogEvent = _EntryPool.Take())
{
var logEvent = pooledLogEvent.Value;
logEvent.DateTime = _LogClock?.Now ?? DateTimeOffset.Now;
logEvent.EventName = eventName ?? String.Empty;
logEvent.EventSeverity = eventSeverity;
logEvent.EventType = eventType;
if (Utils.Any <KeyValuePair <string, object> >(properties))
{
logEvent.Properties = new Dictionary <string, object>();
foreach (var property in properties)
{
logEvent.Properties[property.Key] = RenderProperty(property.Value);
}
}
WriteEvent(logEvent, source, sourceMethod);
}
}
/// <summary>
/// Queues the <paramref name="logEvent"/> for writing to the child log writers.
/// </summary>
/// <remarks>
/// <para>Queues the item and also notifies the write thread to start work if queue size is at least equal to the configured batch size, otherwise starts/resets a timer to kick off the write thread after the configured timeout.</para>
/// </remarks>
/// <param name="logEvent">A <see cref="LogEvent"/> instance to write.</param>
protected override void WriteEventInternal(LogEvent logEvent)
{
#if !CONTRACTS_ONLY
try
{
if (logEvent == null)
{
throw new ArgumentNullException(nameof(logEvent));
}
CheckIsDisposed();
var pooledEvent = _LogEventPool.Take();
logEvent.Clone(pooledEvent.Value);
_BufferedLogEvents.Enqueue(pooledEvent);
if (_BufferedLogEvents.Count >= _BatchSize)
{
SetWriteEventsSignal();
}
else
{
StartTimeoutTimer();
}
}
catch (LogException lex)
{
if (_ErrorHandler.ReportError(lex) == LoggingErrorPolicy.Rethrow)
{
throw;
}
}
catch (Exception ex) when(!ex.ShouldRethrowImmediately())
{
var wrappedException = new LogException(ex.Message, ex);
if (_ErrorHandler.ReportError(wrappedException) == LoggingErrorPolicy.Rethrow)
{
throw wrappedException;
}
}
#endif
}
public void WriteEventWithSource(LogEvent logEvent,
#if SUPPORTS_CALLERATTRIBUTES
[System.Runtime.CompilerServices.CallerFilePath]
#endif
string source = null,
#if SUPPORTS_CALLERATTRIBUTES
[System.Runtime.CompilerServices.CallerMemberName]
#endif
string sourceMethod = null,
#if SUPPORTS_CALLERATTRIBUTES
[System.Runtime.CompilerServices.CallerLineNumber]
#endif
int sourceLineNumber = -1,
bool cloneEvent = false)
{
if (logEvent == null)
{
throw new ArgumentNullException(nameof(logEvent));
}
try
{
if (!IsEnabled || !(_FirstChanceFilter?.ShouldLog(logEvent.EventName, logEvent.EventSeverity, logEvent.EventType, logEvent.Source, logEvent.SourceMethod) ?? true))
{
return;
}
LogEvent eventToWrite = logEvent;
PooledObject <LogEvent> pooledLogEvent = null;
try
{
if (cloneEvent)
{
pooledLogEvent = _EntryPool.Take();
logEvent.Clone(pooledLogEvent.Value);
eventToWrite = pooledLogEvent.Value;
}
if (eventToWrite.DateTime == DateTimeOffset.MinValue)
{
eventToWrite.DateTime = _LogClock.Now;
}
UnsafeWriteEvent(eventToWrite, source, sourceMethod, sourceLineNumber);
}
finally
{
if (cloneEvent && pooledLogEvent != null)
{
pooledLogEvent.Dispose();
}
}
}
catch (LogException lex)
{
if (_ErrorHandler.ReportError(lex) == LoggingErrorPolicy.Rethrow)
{
throw;
}
}
catch (Exception ex) when(!ex.ShouldRethrowImmediately())
{
var wrappedException = new LogException(ex.Message, ex);
if (_ErrorHandler.ReportError(wrappedException) == LoggingErrorPolicy.Rethrow)
{
throw wrappedException;
}
}
}
