/// <summary>
/// Changes the security context, forwards the call to the <see cref="WrapperTargetBase.WrappedTarget"/>.Write()
/// and switches the context back to original.
/// </summary>
/// <param name="logEvents">Log events.</param>
protected override void Write(IList <AsyncLogEventInfo> logEvents)
{
using (DoImpersonate())
{
WrappedTarget.WriteAsyncLogEvents(logEvents);
}
}
/// <summary>
/// Changes the security context, forwards the call to the <see cref="WrapperTargetBase.WrappedTarget"/>.Write()
/// and switches the context back to original.
/// </summary>
/// <param name="logEvents">Log events.</param>
protected override void Write(IList <AsyncLogEventInfo> logEvents)
{
if (_writeLogEvents == null)
{
_writeLogEvents = (l) => WrappedTarget.WriteAsyncLogEvents(l);
}
RunImpersonated(_newIdentity, _writeLogEvents, logEvents);
}
protected override void Write(IList <AsyncLogEventInfo> logEvents)
{
var timer = new Stopwatch();
timer.Start();
WrappedTarget.WriteAsyncLogEvents(logEvents);
timer.Stop();
InternalLogger.Trace($"Logging to target '{WrappedTarget.Name}' {logEvents.Count} logs took {timer.ElapsedMilliseconds} milliseconds.");
}
private void OnEndRequest(object sender, EventArgs args)
{
LogEventInfoBuffer buffer = GetRequestBuffer();
if (buffer != null)
{
InternalLogger.Trace("Sending buffered events to wrapped target: {0}.", WrappedTarget);
AsyncLogEventInfo[] events = buffer.GetEventsAndClear();
WrappedTarget.WriteAsyncLogEvents(events);
}
}
/// <inheritdoc />
/// <summary>
/// The first record is to log immediately, then accumulate for a time and flush by timer. Equivalence is taken into account.
/// </summary>
protected override void Write(AsyncLogEventInfo e)
{
Tuple <int, StringBuilder, AsyncLogEventInfo> count;
#if USECONCURRENT
count = _entriesCounts.AddOrUpdate(e,
/*do not store first - it is logged out immediately*/
new Tuple <int, StringBuilder, AsyncLogEventInfo>(0, NeedsStringBuilder(e.LogEvent)
? new StringBuilder()
: null, default(AsyncLogEventInfo)),
(k, v) =>
{
// but store all the others
if (NeedsStringBuilder(e.LogEvent))
{
v.Item2.Append(Escape(e.LogEvent.FormattedMessage));
v.Item2.Append(this.GroupByTemplateSeparator);
}
return(new Tuple <int, StringBuilder, AsyncLogEventInfo>(v.Item1 + 1, v.Item2,
e /*in flush it will be the last*/));
});
#else
lock (_lockObject)
{
if (_entriesCounts.TryGetValue(e, out count))
{
if (NeedsStringBuilder(e.LogEvent))
{
count.Item2.Append(Escape(e.LogEvent.FormattedMessage));
count.Item2.Append(this.GroupByTemplateSeparator);
}
count = new Tuple <int, StringBuilder, AsyncLogEventInfo>(count.Item1 + 1, count.Item2,
e /*in flush it will be the last*/);
}
else
{
count = new Tuple <int, StringBuilder, AsyncLogEventInfo>(0,
NeedsStringBuilder(e.LogEvent)
? new StringBuilder()
: null, default(AsyncLogEventInfo));
}
_entriesCounts[e] = count;
}
#endif
if (count.Item1 == 0)
{
e.LogEvent.Properties["IsFirst"] = "true";
WrappedTarget.WriteAsyncLogEvents(e);
TurnOnTimerIfOffline();
}
}
/// <summary>
/// Flushes pending events in the buffer (if any).
/// </summary>
/// <param name="asyncContinuation">The asynchronous continuation.</param>
protected override void FlushAsync(AsyncContinuation asyncContinuation)
{
var events = buffer.GetEventsAndClear();
if (events.Length == 0)
{
WrappedTarget.Flush(asyncContinuation);
}
else
{
WrappedTarget.WriteAsyncLogEvents(events, ex => WrappedTarget.Flush(asyncContinuation));
}
}
private void FlushCallback(object state)
{
lock (SyncRoot)
{
if (IsInitialized)
{
var events = buffer.GetEventsAndClear();
if (events.Length > 0)
{
WrappedTarget.WriteAsyncLogEvents(events);
}
}
}
}
// <inheritdoc />
protected override void Write(IList <AsyncLogEventInfo> logEvents)
{
if (_buildKeyStringDelegate == null)
{
_buildKeyStringDelegate = logEvent => RenderLogEvent(Key, logEvent.LogEvent);
}
var buckets = logEvents.BucketSort(_buildKeyStringDelegate);
foreach (var bucket in buckets)
{
WrappedTarget.WriteAsyncLogEvents(bucket.Value);
}
}
private void WriteEventsInBuffer(string reason)
{
if (WrappedTarget == null)
{
InternalLogger.Error("BufferingWrapper '{0}': WrappedTarget is NULL", Name);
return;
}
lock (_lockObject)
{
AsyncLogEventInfo[] logEvents = _buffer.GetEventsAndClear();
if (logEvents.Length > 0)
{
if (reason != null)
InternalLogger.Trace("BufferingWrapper '{0}': writing {1} events ({2})", Name, logEvents.Length, reason);
WrappedTarget.WriteAsyncLogEvents(logEvents);
}
}
}
private void WriteEventsInBuffer(string reason)
{
if (WrappedTarget == null)
{
InternalLogger.Error("{0}: WrappedTarget is NULL", this);
return;
}
lock (_lockObject)
{
AsyncLogEventInfo[] logEvents = _buffer.DequeueBatch(int.MaxValue);
if (logEvents.Length > 0)
{
if (reason != null)
{
InternalLogger.Trace("{0}: Writing {1} events ({2})", this, logEvents.Length, reason);
}
WrappedTarget.WriteAsyncLogEvents(logEvents);
}
}
}
/// <summary>
/// Evaluates all filtering rules to find the first one that matches.
/// The matching rule determines the filtering condition to be applied
/// to all items in a buffer. If no condition matches, default filter
/// is applied to the array of log events.
/// </summary>
/// <param name="logEvents">Array of log events to be post-filtered.</param>
protected override void Write(IList <AsyncLogEventInfo> logEvents)
{
InternalLogger.Trace("{0}: Running on {1} events", this, logEvents.Count);
var resultFilter = EvaluateAllRules(logEvents) ?? DefaultFilter;
if (resultFilter == null)
{
WrappedTarget.WriteAsyncLogEvents(logEvents);
}
else
{
InternalLogger.Trace("{0}: Filter to apply: {1}", this, resultFilter);
var resultBuffer = logEvents.Filter(resultFilter, (logEvent, filter) => ApplyFilter(logEvent, filter));
InternalLogger.Trace("{0}: After filtering: {1} events.", this, resultBuffer.Count);
if (resultBuffer.Count > 0)
{
InternalLogger.Trace("{0}: Sending to {1}", this, WrappedTarget);
WrappedTarget.WriteAsyncLogEvents(resultBuffer);
}
}
}
private void ProcessPendingEvents(object state)
{
try
{
var count = BatchSize;
var continuation = Interlocked.Exchange(ref flushAllContinuation, null);
if (continuation != null)
{
count = RequestQueue.RequestCount;
InternalLogger.Trace("Flushing {0} events.", count);
}
var logEventInfos = RequestQueue.DequeueBatch(count);
if (continuation != null)
{
// write all events, then flush, then call the continuation
WrappedTarget.WriteAsyncLogEvents(logEventInfos, ex => WrappedTarget.Flush(continuation));
}
else
{
// just write all events
WrappedTarget.WriteAsyncLogEvents(logEventInfos);
}
}
catch (Exception exception)
{
if (exception.MustBeRethrown())
{
throw;
}
InternalLogger.Error("Error in lazy writer timer procedure: {0}", exception);
}
finally
{
StartLazyWriterTimer();
}
}
/// <summary>
/// Adds the specified log event to the buffer and flushes
/// the buffer in case the buffer gets full.
/// </summary>
/// <param name="logEvent">The log event.</param>
protected override void Write(AsyncLogEventInfo logEvent)
{
WrappedTarget.PrecalculateVolatileLayouts(logEvent.LogEvent);
var count = buffer.Append(logEvent);
if (count >= BufferSize)
{
var events = buffer.GetEventsAndClear();
WrappedTarget.WriteAsyncLogEvents(events);
}
else
{
if (FlushTimeout > 0)
{
// reset the timer on first item added to the buffer or whenever SlidingTimeout is set to true
if (SlidingTimeout || count == 1)
{
flushTimer.Change(FlushTimeout, -1);
}
}
}
}
void Flush()
{
if (WrappedTarget == null)
{
InternalLogger.Error("BufferingWrapper(Name={0}): WrappedTarget is NULL", Name);
return;
}
lock (_lockObject)
{
#if USECONCURRENT
ICollection <AsyncLogEventInfo> keys = _entriesCounts.Keys;
#else
ICollection <AsyncLogEventInfo> keys = _entriesCounts.Keys.ToList();
#endif
foreach (AsyncLogEventInfo initialLog in keys)
{
Tuple <int, StringBuilder, AsyncLogEventInfo> count;
#if USECONCURRENT
if (_entriesCounts.TryRemove(initialLog, out count) && count.Item1 > 0)
#else
count = _entriesCounts[initialLog];
if (_entriesCounts.Remove(initialLog))
#endif
{
AsyncLogEventInfo lastLog = count.Item3;
// do not remove if count > 0 (insert it back) - on aggressive logs we should not send an extra log
#if USECONCURRENT
_entriesCounts.AddOrUpdate(initialLog,
new Tuple <int, StringBuilder, AsyncLogEventInfo>(0, NeedsStringBuilder(initialLog.LogEvent) ? new StringBuilder() : null, default(AsyncLogEventInfo)),
(k, v) => v /*do not change it if it is already there - situation is aggressive and first log is already sent*/);
#else
lock (_lockObject)
{
if (!_entriesCounts.ContainsKey(initialLog))
{
_entriesCounts[initialLog] =
new Tuple <int, StringBuilder, AsyncLogEventInfo>(0,
NeedsStringBuilder(initialLog.LogEvent)
? new StringBuilder()
: null, default(AsyncLogEventInfo));
}
}
#endif
if (count.Item1 > 1)
{
string sbString = null;
if (NeedsStringBuilder(lastLog.LogEvent))
{
lastLog.LogEvent.Properties["AccumulatedMessages"] =
sbString = count.Item2.ToString();
}
if (CorrectMessageForGroup && !string.IsNullOrEmpty(CountAppendFormat))
{
if (sbString != null)
{
lastLog.LogEvent.Message
= /*messages differ so log all of them*/
Escape(lastLog.LogEvent.Message) +
string.Format(CountAppendFormat, count.Item1) +
(this.GroupByTemplateSeparator == Environment.NewLine
? Environment.NewLine
: "") +
sbString;
}
else
{
lastLog.LogEvent.Message
+= /*all messages are the same, so just append count*/
string.Format(CountAppendFormat, count.Item1);
}
}
}
lastLog.LogEvent.Properties["AccumulatedCount"] = count.Item1;
lastLog.LogEvent.Properties["IsFirst"] = "false";
WrappedTarget.WriteAsyncLogEvents(lastLog);
}
}
}
}
/// <summary>
/// Evaluates all filtering rules to find the first one that matches.
/// The matching rule determines the filtering condition to be applied
/// to all items in a buffer. If no condition matches, default filter
/// is applied to the array of log events.
/// </summary>
/// <param name="logEvents">Array of log events to be post-filtered.</param>
protected override void Write(AsyncLogEventInfo[] logEvents)
{
ConditionExpression resultFilter = null;
InternalLogger.Trace("Running {0} on {1} events", this, logEvents.Length);
// evaluate all the rules to get the filtering condition
for (var i = 0; i < logEvents.Length; ++i)
{
foreach (var rule in Rules)
{
var v = rule.Exists.Evaluate(logEvents[i].LogEvent);
if (boxedTrue.Equals(v))
{
InternalLogger.Trace("Rule matched: {0}", rule.Exists);
resultFilter = rule.Filter;
break;
}
}
if (resultFilter != null)
{
break;
}
}
if (resultFilter == null)
{
resultFilter = DefaultFilter;
}
if (resultFilter == null)
{
WrappedTarget.WriteAsyncLogEvents(logEvents);
}
else
{
InternalLogger.Trace("Filter to apply: {0}", resultFilter);
// apply the condition to the buffer
var resultBuffer = new List <AsyncLogEventInfo>();
for (var i = 0; i < logEvents.Length; ++i)
{
var v = resultFilter.Evaluate(logEvents[i].LogEvent);
if (boxedTrue.Equals(v))
{
resultBuffer.Add(logEvents[i]);
}
else
{
// anything not passed down will be notified about successful completion
logEvents[i].Continuation(null);
}
}
InternalLogger.Trace("After filtering: {0} events.", resultBuffer.Count);
if (resultBuffer.Count > 0)
{
InternalLogger.Trace("Sending to {0}", WrappedTarget);
WrappedTarget.WriteAsyncLogEvents(resultBuffer.ToArray());
}
}
}
protected override void Write(AsyncLogEventInfo logEvent)
{
WrappedTarget.WriteAsyncLogEvents(logEvent);
}
/// <summary>
/// Evaluates all filtering rules to find the first one that matches.
/// The matching rule determines the filtering condition to be applied
/// to all items in a buffer. If no condition matches, default filter
/// is applied to the array of log events.
/// </summary>
/// <param name="logEvents">Array of log events to be post-filtered.</param>
protected override void Write(IList <AsyncLogEventInfo> logEvents)
{
ConditionExpression resultFilter = null;
InternalLogger.Trace("PostFilteringWrapper(Name={0}): Running on {1} events", Name, logEvents.Count);
// evaluate all the rules to get the filtering condition
for (int i = 0; i < logEvents.Count; ++i)
{
foreach (FilteringRule rule in Rules)
{
object v = rule.Exists.Evaluate(logEvents[i].LogEvent);
if (boxedTrue.Equals(v))
{
InternalLogger.Trace("PostFilteringWrapper(Name={0}): Rule matched: {1}", Name, rule.Exists);
resultFilter = rule.Filter;
break;
}
}
if (resultFilter != null)
{
break;
}
}
if (resultFilter == null)
{
resultFilter = DefaultFilter;
}
if (resultFilter == null)
{
WrappedTarget.WriteAsyncLogEvents(logEvents);
}
else
{
InternalLogger.Trace("PostFilteringWrapper(Name={0}): Filter to apply: {1}", Name, resultFilter);
// apply the condition to the buffer
var resultBuffer = new List <AsyncLogEventInfo>();
for (int i = 0; i < logEvents.Count; ++i)
{
object v = resultFilter.Evaluate(logEvents[i].LogEvent);
if (boxedTrue.Equals(v))
{
resultBuffer.Add(logEvents[i]);
}
else
{
// anything not passed down will be notified about successful completion
logEvents[i].Continuation(null);
}
}
InternalLogger.Trace("PostFilteringWrapper(Name={0}): After filtering: {1} events.", Name, resultBuffer.Count);
if (resultBuffer.Count > 0)
{
InternalLogger.Trace("PostFilteringWrapper(Name={0}): Sending to {1}", Name, WrappedTarget);
WrappedTarget.WriteAsyncLogEvents(resultBuffer);
}
}
}
