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> /// 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 internal override void Write(LogEventInfo[] logEvents) { using (DoImpersonate()) { WrappedTarget.Write(logEvents); } }
/// <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 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); } }
/// <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); } }
void FlushCallback(object state) { lock (this) { 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); } } }
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> /// 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); }
/// <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> public override void Write(LogEventInfo logEvent) { lock (this) { WrappedTarget.PrecalculateVolatileLayouts(logEvent); int count = _buffer.Append(logEvent); if (count >= BufferSize) { LogEventInfo[] events = _buffer.GetEventsAndClear(); WrappedTarget.Write(events); } else { if (FlushTimeout > 0 && _flushTimer != null) { _flushTimer.Change(FlushTimeout, -1); } } } }
/// <summary> /// Forwards the call to the <see cref="WrapperTargetBase.WrappedTarget"/>.Write() /// and calls <see cref="Target.Flush()"/> on it. /// </summary> /// <param name="logEvent"></param> protected internal override void Write(LogEventInfo logEvent) { WrappedTarget.Write(logEvent); WrappedTarget.Flush(); }
/// <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> public override void Write(LogEventInfo[] logEvents) { ConditionExpression resultFilter = null; if (InternalLogger.IsTraceEnabled) { InternalLogger.Trace("Input: {0} events", logEvents.Length); } // evaluate all the rules to get the filtering condition for (int i = 0; i < logEvents.Length; ++i) { for (int j = 0; j < _rules.Count; ++j) { object v = _rules[j].ExistsCondition.Evaluate(logEvents[i]); if (v is bool && (bool)v) { if (InternalLogger.IsTraceEnabled) { InternalLogger.Trace("Rule matched: {0}", _rules[j].ExistsCondition); } resultFilter = _rules[j].FilterCondition; break; } } if (resultFilter != null) { break; } } if (resultFilter == null) { resultFilter = _defaultFilter; } if (InternalLogger.IsTraceEnabled) { InternalLogger.Trace("Filter to apply: {0}", resultFilter); } // apply the condition to the buffer List <LogEventInfo> resultBuffer = new List <LogEventInfo>(); for (int i = 0; i < logEvents.Length; ++i) { object v = resultFilter.Evaluate(logEvents[i]); if (v is bool && (bool)v) { resultBuffer.Add(logEvents[i]); } } if (InternalLogger.IsTraceEnabled) { InternalLogger.Trace("After filtering: {0} events", resultBuffer.Count); } if (resultBuffer.Count > 0) { WrappedTarget.Write(resultBuffer.ToArray()); } }
/// <summary> /// Forwards the call to the <see cref="WrapperTargetBase.WrappedTarget"/>.Write() /// and calls <see cref="Target.Flush()"/> on it. /// </summary> /// <param name="logEvent"></param> public override void Write(LogEventInfo logEvent) { WrappedTarget.Write(logEvent); WrappedTarget.Flush(); }