/// <summary> /// Writes the specified log event to the wrapped target, retrying and pausing in case of an error. /// </summary> /// <param name="logEvent">The log event.</param> protected override void Write(AsyncLogEventInfo logEvent) { AsyncContinuation continuation = null; var counter = 0; continuation = ex => { if (ex == null) { logEvent.Continuation(null); return; } var retryNumber = Interlocked.Increment(ref counter); InternalLogger.Warn("Error while writing to '{0}': {1}. Try {2}/{3}", WrappedTarget, ex, retryNumber, RetryCount); // exceeded retry count if (retryNumber >= RetryCount) { InternalLogger.Warn("Too many retries. Aborting."); logEvent.Continuation(ex); return; } // sleep and try again Thread.Sleep(RetryDelayMilliseconds); WrappedTarget.WriteAsyncLogEvent(logEvent.LogEvent.WithContinuation(continuation)); }; WrappedTarget.WriteAsyncLogEvent(logEvent.LogEvent.WithContinuation(continuation)); }
/// <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="logEvent">The log event.</param> protected override void Write(AsyncLogEventInfo logEvent) { using (DoImpersonate()) { WrappedTarget.WriteAsyncLogEvent(logEvent); } }
/// <summary> /// Forwards the call to the <see cref="WrapperTargetBase.WrappedTarget"/>.Write() /// and calls <see cref="Target.Flush(AsyncContinuation)"/> on it if LogEvent satisfies /// the flush condition or condition is null. /// </summary> /// <param name="logEvent">Logging event to be written out.</param> protected override void Write(AsyncLogEventInfo logEvent) { if (Condition == null || Condition.Evaluate(logEvent.LogEvent).Equals(true)) { if (AsyncFlush) { AsyncContinuation currentContinuation = logEvent.Continuation; AsyncContinuation wrappedContinuation = (ex) => { if (ex == null) { WrappedTarget.Flush((e) => { }); } _pendingManualFlushList.CompleteOperation(ex); currentContinuation(ex); }; _pendingManualFlushList.BeginOperation(); WrappedTarget.WriteAsyncLogEvent(logEvent.LogEvent.WithContinuation(wrappedContinuation)); } else { WrappedTarget.WriteAsyncLogEvent(logEvent); FlushAsync((e) => { }); } } else { WrappedTarget.WriteAsyncLogEvent(logEvent); } }
/// <summary> /// Writes the provided <see cref="AsyncLogEventInfo"/> to the underlying target. /// </summary> /// <param name="logEvent">The log event to write.</param> protected override void Write(AsyncLogEventInfo logEvent) { // check if current event is different from previous if (IsDifferentFromPrevious(logEvent.LogEvent)) { // current event is different - we need to write the count of same as previous messages if (_previousLogEvent != null && _previousCount > 0) { var e = LogEventInfo.Create(_previousLogEvent.Level, _previousLogEvent.LoggerName, CultureInfo.CurrentCulture, "{0} more of previous message.", new object[] { _previousCount }); WrappedTarget.WriteAsyncLogEvent(new AsyncLogEventInfo(e, ex => { })); } // reset counters _previousLogEvent = logEvent.LogEvent; _previousCount = 0; // write current event WrappedTarget.WriteAsyncLogEvent(logEvent); } else { // if current event is same as previous - simply increase the count and don't write it to the wrapped target _previousCount++; } }
/// <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="logEvent">The log event.</param> protected override void Write(AsyncLogEventInfo logEvent) { if (_writeLogEvent == null) { _writeLogEvent = (l) => WrappedTarget.WriteAsyncLogEvent(l); } RunImpersonated(_newIdentity, _writeLogEvent, logEvent); }
protected override void FlushAsync(AsyncContinuation asyncContinuation) { foreach (var log in logs) { WrappedTarget.WriteAsyncLogEvent(log); } logs.Clear(); base.FlushAsync(asyncContinuation); }
/// <summary> /// Checks the condition against the passed log event. /// If the condition is met, the log event is forwarded to /// the wrapped target. /// </summary> /// <param name="logEvent">Log event.</param> protected override void Write(AsyncLogEventInfo logEvent) { object v = Condition.Evaluate(logEvent.LogEvent); if (boxedBooleanTrue.Equals(v)) { WrappedTarget.WriteAsyncLogEvent(logEvent); } else { logEvent.Continuation(null); } }
/// <summary> /// Adds the specified log event to the buffer. /// </summary> /// <param name="logEvent">The log event.</param> protected override void Write(AsyncLogEventInfo logEvent) { LogEventInfoBuffer buffer = GetRequestBuffer(); if (buffer != null) { WrappedTarget.PrecalculateVolatileLayouts(logEvent.LogEvent); buffer.Append(logEvent); InternalLogger.Trace("Appending log event {0} to ASP.NET request buffer.", logEvent.LogEvent.SequenceID); } else { InternalLogger.Trace("ASP.NET request buffer does not exist. Passing to wrapped target."); WrappedTarget.WriteAsyncLogEvent(logEvent); } }
protected override void Write(AsyncLogEventInfo logEvent) { if ((DateTime.Now - _lastLogEvent).TotalMinutes >= MinLogInterval) { _lastLogEvent = DateTime.Now; WrappedTarget.WriteAsyncLogEvent(logEvent); } else { logEvent.Continuation(null); // EXPERIMENTAL: check if the level of the log event is higher than "WARN" (3) and // log a debug message about keeping back the email message: if (logEvent.LogEvent.Level.Ordinal > 3) { Log.Debug("RateLimitWrapper: not sending email, frequency too high!"); } } }
/// <summary> /// Writes the specified log event to the wrapped target, retrying and pausing in case of an error. /// </summary> /// <param name="logEvent">The log event.</param> protected override void Write(AsyncLogEventInfo logEvent) { AsyncContinuation continuation = null; int counter = 0; continuation = ex => { if (ex == null) { logEvent.Continuation(null); return; } int retryNumber = Interlocked.Increment(ref counter); InternalLogger.Warn("Error while writing to '{0}': {1}. Try {2}/{3}", WrappedTarget, ex, retryNumber, RetryCount); // exceeded retry count if (retryNumber >= RetryCount) { InternalLogger.Warn("Too many retries. Aborting."); logEvent.Continuation(ex); return; } // sleep and try again (Check every 100 ms if target have been closed) for (int i = 0; i < RetryDelayMilliseconds;) { int retryDelay = Math.Min(100, RetryDelayMilliseconds - i); Thread.Sleep(retryDelay); i += retryDelay; if (!IsInitialized) { InternalLogger.Warn("Target closed. Aborting."); logEvent.Continuation(ex); return; } } WrappedTarget.WriteAsyncLogEvent(logEvent.LogEvent.WithContinuation(continuation)); }; WrappedTarget.WriteAsyncLogEvent(logEvent.LogEvent.WithContinuation(continuation)); }
/// <summary> /// Writes log event to the wrapped target if the current <see cref="MessagesWrittenCount"/> is lower than <see cref="MessageLimit"/>. /// If the <see cref="MessageLimit"/> is already reached, no log event will be written to the wrapped target. /// <see cref="MessagesWrittenCount"/> resets when the current <see cref="Interval"/> is expired. /// </summary> /// <param name="logEvent">Log event to be written out.</param> protected override void Write(AsyncLogEventInfo logEvent) { if (IsIntervalExpired()) { ResetInterval(); InternalLogger.Debug("LimitingWrapper(Name={0}): New interval of '{1}' started.", Name, Interval); } if (MessagesWrittenCount < MessageLimit) { WrappedTarget.WriteAsyncLogEvent(logEvent); MessagesWrittenCount++; } else { logEvent.Continuation(null); InternalLogger.Trace("LimitingWrapper(Name={0}): Discarded event, because MessageLimit of '{1}' was reached.", Name, MessageLimit); } }
/// <summary> /// Forwards the log message to the <see cref="WrapperTargetBase.WrappedTarget"/> by calling the <see cref="Target.Write(LogEventInfo)"/> method <see cref="RepeatCount"/> times. /// </summary> /// <param name="logEvent">The log event.</param> protected override void Write(AsyncLogEventInfo logEvent) { AsyncHelpers.Repeat(RepeatCount, logEvent.Continuation, cont => WrappedTarget.WriteAsyncLogEvent(logEvent.LogEvent.WithContinuation(cont))); }
// <inheritdoc /> protected override void Write(AsyncLogEventInfo logEvent) { WrappedTarget.WriteAsyncLogEvent(logEvent); }
/// <summary> /// Forwards the call to the <see cref="WrapperTargetBase.WrappedTarget" />.Write() /// and calls <see cref="Target.Flush(AsyncContinuation)" /> on it. /// </summary> /// <param name="logEvent">Logging event to be written out.</param> protected override void Write(AsyncLogEventInfo logEvent) { WrappedTarget.WriteAsyncLogEvent(logEvent.LogEvent.WithContinuation(AsyncHelpers.PrecededBy(logEvent.Continuation, WrappedTarget.Flush))); }
protected override void Write(AsyncLogEventInfo logEvent) { Thread.Sleep(TimeSpan.FromSeconds(1)); WrappedTarget.WriteAsyncLogEvent(logEvent); }