/// <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 internal override void Write(LogEventInfo[] logEvents) { using (DoImpersonate()) { WrappedTarget.Write(logEvents); } }
/// <summary> /// Flush any pending log messages (in case of asynchronous targets). /// </summary> /// <param name="asyncContinuation">The asynchronous continuation.</param> protected override void FlushAsync(AsyncContinuation asyncContinuation) { using (DoImpersonate()) { WrappedTarget.Flush(asyncContinuation); } }
/// <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="logEvent">The log event.</param> protected override void Write(AsyncLogEventInfo logEvent) { using (DoImpersonate()) { WrappedTarget.WriteAsyncLogEvent(logEvent); } }
/// <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> public override void Write(LogEventInfo logEvent) { for (int i = 0; i < RepeatCount; ++i) { WrappedTarget.Write(logEvent); } }
private void LazyWriterTimerCallback(object state) { lock (_inLazyWriterMonitor) { try { do { // Console.WriteLine("q: {0}", RequestQueue.RequestCount); List <LogEventInfo> pendingRequests = RequestQueue.DequeueBatch(BatchSize); try { if (pendingRequests.Count == 0) { break; } LogEventInfo[] events = pendingRequests.ToArray(); WrappedTarget.Write(events); } finally { RequestQueue.BatchProcessed(pendingRequests); } } while (_flushAll); } catch (Exception ex) { InternalLogger.Error("Error in lazy writer timer procedure: {0}", ex); } } }
/// <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> public override void Write(LogEventInfo logEvent) { for (int i = 0; i < RetryCount; ++i) { try { if (i > 0) { InternalLogger.Warn("Retry #{0}", i); } WrappedTarget.Write(logEvent); // success, return return; } catch (Exception ex) { InternalLogger.Warn("Error while writing to '{0}': {1}", WrappedTarget, ex); if (i == RetryCount - 1) { throw ex; } System.Threading.Thread.Sleep(RetryDelayMilliseconds); } } }
/// <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> /// 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="logEvents">Log events.</param> public override void Write(LogEventInfo[] logEvents) { using (DoImpersonate()) { WrappedTarget.Write(logEvents); } }
/// <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 internal override void Write(LogEventInfo logEvent) { for (int i = 0; i < RepeatCount; ++i) { WrappedTarget.Write(logEvent); } }
/// <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); }
/// <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 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."); }
/// <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> public override void Write(LogEventInfo logEvent) { object v = _condition.Evaluate(logEvent); if (v != null && v is bool && (bool)v) { WrappedTarget.Write(logEvent); } }
/// <summary> /// Adds the specified log event to the buffer. /// </summary> /// <param name="logEvent">The log event.</param> public override void Write(LogEventInfo logEvent) { WrappedTarget.PrecalculateVolatileLayouts(logEvent); LogEventInfoBuffer buffer = GetRequestBuffer(); if (buffer != null) { buffer.Append(logEvent); } }
protected override void FlushAsync(AsyncContinuation asyncContinuation) { foreach (var log in logs) { WrappedTarget.WriteAsyncLogEvent(log); } logs.Clear(); base.FlushAsync(asyncContinuation); }
void FlushCallback(object state) { lock (this) { LogEventInfo[] events = _buffer.GetEventsAndClear(); if (events.Length > 0) { WrappedTarget.Write(events); } } }
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 OnEndRequest(object sender, EventArgs args) { LogEventInfoBuffer buffer = GetRequestBuffer(); if (buffer != null) { LogEventInfo[] events = buffer.GetEventsAndClear(); if (events.Length > 0) { WrappedTarget.Write(events); } } }
/// <summary> /// Flushes pending events in the buffer (if any). /// </summary> public override void Flush(TimeSpan timeout) { base.Flush(timeout); lock (this) { LogEventInfo[] events = _buffer.GetEventsAndClear(); if (events.Length > 0) { WrappedTarget.Write(events); } } }
/// <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> /// Forwards the array of log events to the <see cref="WrapperTargetBase.WrappedTarget"/> by calling the <see cref="Target.Write(LogEventInfo[])"/> method <see cref="RepeatCount"/> times. /// </summary> /// <param name="logEvents">The array of log events.</param> protected internal override void Write(LogEventInfo[] logEvents) { LogEventInfo[] newEvents = new LogEventInfo[logEvents.Length * RepeatCount]; int pos = 0; for (int i = 0; i < logEvents.Length; ++i) { for (int j = 0; j < RepeatCount; ++j) { newEvents[pos++] = logEvents[i]; } } WrappedTarget.Write(newEvents); }
// <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 FlushCallback(object state) { lock (SyncRoot) { if (IsInitialized) { var events = buffer.GetEventsAndClear(); if (events.Length > 0) { WrappedTarget.WriteAsyncLogEvents(events); } } } }
/// <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!"); } } }