private bool RecordVerdict(Redwood.Record r, bool isRepeat, bool shouldPrint, IList <Redwood.Record> willReturn) { if (r.Force()) { FlushParents(willReturn); if (isRepeat) { Flush(current, willReturn); } //if not repeat, will flush below shouldPrint = true; } if (!isRepeat) { Flush(current, willReturn); current.lastRecord = r; } if (shouldPrint) { current.timeOfLastPrintedRecord = r.timesstamp; current.timesPrinted += 1; } current.timesSeen += 1; current.somethingPrinted = true; //(return) return(shouldPrint); }
private void Flush(RepeatedRecordHandler.RepeatedRecordInfo info, IList <Redwood.Record> willReturn) { //(suppress all printing) if (info.suppressRecord) { return; } //(get time) int repeatedRecordCount = info.timesSeen - info.timesPrinted; if (repeatedRecordCount > 0) { //(send message record) //((add force tag)) object[] newTags = new object[info.lastRecord.Channels().Length + 1]; System.Array.Copy(info.lastRecord.Channels(), 0, newTags, 1, info.lastRecord.Channels().Length); newTags[0] = Redwood.Force; //((create record)) Redwood.Record newRecord = new Redwood.Record(repeatSemantics.Message(repeatedRecordCount), newTags, info.lastRecord.depth, info.lastRecord.timesstamp); //((pass record)) willReturn.Add(newRecord); info.timesSeen = 0; info.timesPrinted = 0; } }
/// <summary> /// <inheritDoc/> /// /// </summary> public override IList <Redwood.Record> SignalStartTrack(Redwood.Record signal) { //(handle record) IList <Redwood.Record> willReturn = new List <Redwood.Record>(); bool isPrinting = InternalHandle(signal, willReturn); //(adjust state for track) if (!signal.Force()) { if (isPrinting) { current.trackCountPending = RepeatedRecordHandler.PendingType.Printing; current.timesPrinted -= 1; } else { current.trackCountPending = RepeatedRecordHandler.PendingType.Seen; } current.timesSeen -= 1; } //(push stack) stack.Push(current); current = new RepeatedRecordHandler.RepeatedRecordInfo(); if (!isPrinting) { current.suppressRecord = true; } return(willReturn); }
/// <summary> /// <inheritDoc/> /// /// </summary> public override IList <Redwood.Record> Handle(Redwood.Record record) { IList <Redwood.Record> willReturn = new List <Redwood.Record>(); if (InternalHandle(record, willReturn)) { willReturn.Add(record); } return(willReturn); }
public virtual bool Matches(Redwood.Record record) { foreach (object tag in record.Channels()) { if (tag.Equals(matchingChannel)) { return(true); } } return(false); }
public bool Matches(Redwood.Record message) { foreach (object channel in message.Channels()) { if (this.matchAgainst.Contains(channel)) { return(true); } } return(false); }
/// <summary> /// Override the raw handle method, as potentially we are dropping log levels in SLF4J /// and we do not want to render the resulting message. /// </summary> /// <param name="record">The record to handle.</param> /// <returns>Nothing -- this is the leaf of a tree.</returns> public override IList <Redwood.Record> Handle(Redwood.Record record) { // Get the implementing SLF4J logger Pair <ILogger, Redwood.Flag> loggerAndLevel = GetLoggerAndLevel(record.Channels()); switch (loggerAndLevel.second) { case Redwood.Flag.Force: { // Potentially short-circuit break; } case Redwood.Flag.Error: { // Always pass it on if explicitly forced if (!loggerAndLevel.first.IsErrorEnabled()) { return(Java.Util.Collections.EmptyList()); } break; } case Redwood.Flag.Warn: { if (!loggerAndLevel.first.IsWarnEnabled()) { return(Java.Util.Collections.EmptyList()); } break; } case Redwood.Flag.Debug: { if (!loggerAndLevel.first.IsDebugEnabled()) { return(Java.Util.Collections.EmptyList()); } break; } default: { if (!loggerAndLevel.first.IsInfoEnabled()) { return(Java.Util.Collections.EmptyList()); } break; } } return(base.Handle(record)); }
/// <summary>For BooleanLogRecordHandler, you should leave this alone and implement propagateRecord instead.</summary> public override IList <Redwood.Record> Handle(Redwood.Record record) { bool keep = PropagateRecord(record); if (keep) { List <Redwood.Record> records = new List <Redwood.Record>(); records.Add(record); return(records); } else { return(LogRecordHandler.Empty); } }
public override bool PropagateRecord(Redwood.Record record) { foreach (ILogFilter filter in filters) { bool match = filter.Matches(record); if (match && disjunctiveMode) { return(true); } if (!match && !disjunctiveMode) { return(false); } } return(!disjunctiveMode); }
/// <summary> /// <inheritDoc/> /// /// </summary> public override IList <Redwood.Record> SignalStartTrack(Redwood.Record signal) { //(queue track) this.queuedTracks.AddLast(signal); //(push info) if (info != null) { this.trackStack.Push(info); } info = new OutputHandler.TrackInfo(signal.content.ToString(), signal.timesstamp); //(force print) if (signal.Force()) { UpdateTracks(signal.depth + 1); } //(return) return(Empty); }
private bool InternalHandle(Redwood.Record record, IList <Redwood.Record> willReturn) { // We are passing the record through a number of filters, // ordered by priority, to determine whether or not // to continue passing it on //--Special Cases //--Regular Cases //(ckeck squashing) if (this.current.suppressRecord) { return(RecordVerdict(record, false, false, willReturn)); } //arg 2 is irrelevant here //(check first record printed) if (this.current.lastRecord == null) { return(RecordVerdict(record, false, true, willReturn)); } //(check equality) if (this.repeatSemantics.Equals(current.lastRecord, record)) { //(check time) long currentTime = record.timesstamp; if (currentTime - this.current.timeOfLastPrintedRecord > this.repeatSemantics.MaxWaitTimeInMillis()) { return(RecordVerdict(record, true, true, willReturn)); } //(check num printed) if (this.current.timesSeen < this.repeatSemantics.NumToForcePrint()) { return(RecordVerdict(record, true, true, willReturn)); } else { return(RecordVerdict(record, true, false, willReturn)); } } else { //(different record) return(RecordVerdict(record, false, true, willReturn)); } }
public override IList <Redwood.Record> Handle(Redwood.Record record) { IList <Redwood.Record> results = new List <Redwood.Record>(); object[] channels = record.Channels(); for (int i = 0; i < channels.Length; i++) { object channel = channels[i]; if (oldChannelName.Equals(channel)) { // make a new version of the Record with a different channel name channels[i] = newChannelName; Redwood.Record reroutedRecord = new Redwood.Record(record.content, channels, record.depth, record.timesstamp); results.Add(reroutedRecord); return(results); } } // didn't find any matching records, so just return the original one results.Add(record); return(results); }
private void UpdateTracks(int untilDepth) { while (!queuedTracks.IsEmpty()) { //(get record to update) Redwood.Record signal = queuedTracks.RemoveFirst(); if (signal.depth >= untilDepth) { queuedTracks.Add(signal); return; } //(begin record message) StringBuilder b = new StringBuilder(); if (missingOpenBracket) { b.Append("{\n"); } //(write margin) for (int i = 0; i < leftMargin; i++) { b.Append(" "); } //(write name) WriteContent(signal.depth, signal.content, b); if (signal.content.ToString().Length > 0) { b.Append(" "); } //(print) Print(null, this.Style(new StringBuilder(), b.ToString(), trackColor, trackStyle).ToString()); this.missingOpenBracket = true; //only set to false if actually updated track state //(update lines printed) if (info != null) { info.numElementsPrinted += 1; } } }
public virtual bool Matches(Redwood.Record record) { return(record.content.Equals(message)); }
public virtual bool Matches(Redwood.Record record) { string content = record.content.ToString(); return(content.Contains(this.substring)); }
public virtual bool Equals(Redwood.Record lastRecord, Redwood.Record record) { return(Arrays.Equals(record.Channels(), lastRecord.Channels()) && SameMessage(lastRecord.content == null ? "null" : lastRecord.content.ToString(), record.content == null ? "null" : record.content.ToString())); }
public virtual bool Equals(Redwood.Record lastRecord, Redwood.Record record) { return(Arrays.Equals(record.Channels(), lastRecord.Channels()) && ((record.content == null && lastRecord.content == null) || (record.content != null && record.content.Equals(lastRecord.content)))); }
/// <summary> /// <inheritDoc/> /// /// </summary> public override IList <Redwood.Record> Handle(Redwood.Record record) { StringBuilder b = new StringBuilder(1024); //--Special case for Exceptions string[] content; if (record.content is Exception) { //(vars) IList <string> lines = new List <string>(); //(root message) Exception exception = (Exception)record.content; lines.Add(record.content.ToString()); StackTraceElement[] trace = exception.GetStackTrace(); StackTraceElement topTraceElement = trace.Length > 0 ? trace[0] : null; foreach (StackTraceElement e in exception.GetStackTrace()) { lines.Add(tab + e.ToString()); } //(causes) while (exception.InnerException != null) { System.Console.Out.WriteLine("TOP ELEMENT: " + topTraceElement); //((variables)) exception = exception.InnerException; trace = exception.GetStackTrace(); lines.Add("Caused by: " + exception.GetType() + ": " + exception.Message); for (int i = 0; i < trace.Length; i++) { //((add trace element)) StackTraceElement e_1 = trace[i]; lines.Add(tab + e_1.ToString()); //((don't print redundant elements)) if (topTraceElement != null && e_1.GetClassName().Equals(topTraceElement.GetClassName()) && e_1.GetMethodName().Equals(topTraceElement.GetMethodName())) { lines.Add(tab + "..." + (trace.Length - i - 1) + " more"); break; } } //((update top element)) topTraceElement = trace.Length > 0 ? trace[0] : null; } //(set content array) content = new string[lines.Count]; content = Sharpen.Collections.ToArray(lines, content); } else { if (record.content == null) { content = new string[] { "null" }; } else { string toStr; if (record.content is ISupplier) { //noinspection unchecked toStr = ((ISupplier <object>)record.content).Get().ToString(); } else { toStr = record.content.ToString(); } if (toStr == null) { content = new string[] { "<null toString()>" }; } else { content = toStr.Split("\n"); } } } //would be nice to get rid of this 'split()' call at some point //--Handle Tracks UpdateTracks(record.depth); if (this.missingOpenBracket) { this.Style(b, "{\n", trackColor, trackStyle); this.missingOpenBracket = false; } //--Process Record //(variables) int cursorPos = 0; int contentLinesPrinted = 0; //(loop) Color color = Color.None; Edu.Stanford.Nlp.Util.Logging.Style style = Edu.Stanford.Nlp.Util.Logging.Style.None; //(get channels) List <object> printableChannels = new List <object>(); foreach (object chan in record.Channels()) { if (chan is Color) { color = (Color)chan; } else { if (chan is Edu.Stanford.Nlp.Util.Logging.Style) { style = (Edu.Stanford.Nlp.Util.Logging.Style)chan; } else { if (chan != Redwood.Force) { printableChannels.Add(chan); } } } } //--Write Channels if (leftMargin > 2) { //don't print if not enough space //((print channels) b.Append("["); cursorPos += 1; object lastChan = null; bool wasAnyChannelPrinted = false; for (int i = 0; i < printableChannels.Count; i++) { object chan_1 = printableChannels[i]; if (chan_1.Equals(lastChan)) { continue; } //skip duplicate channels lastChan = chan_1; //(get channel) string toPrint = chan_1.ToString(); if (toPrint.Length > leftMargin - 1) { toPrint = Sharpen.Runtime.Substring(toPrint, 0, leftMargin - 2); } if (cursorPos + toPrint.Length >= leftMargin) { //(case: doesn't fit) while (cursorPos < leftMargin) { b.Append(" "); cursorPos += 1; } if (contentLinesPrinted < content.Length) { WriteContent(record.depth, Style(new StringBuilder(), content[contentLinesPrinted], color, style).ToString(), b); contentLinesPrinted += 1; } b.Append("\n "); cursorPos = 1; } //(print flag) bool wasChannelPrinted = FormatChannel(b, toPrint, chan_1); wasAnyChannelPrinted = wasAnyChannelPrinted || wasChannelPrinted; if (wasChannelPrinted && i < printableChannels.Count - 1) { b.Append(channelSeparatorChar); cursorPos += 1; } cursorPos += toPrint.Length; } if (wasAnyChannelPrinted) { b.Append("]"); cursorPos += 1; } else { b.Length = b.Length - 1; // remove leading "[" cursorPos -= 1; } } //--Content //(write content) while (contentLinesPrinted < content.Length) { while (cursorPos < leftMargin) { b.Append(" "); cursorPos += 1; } WriteContent(record.depth, Style(new StringBuilder(), content[contentLinesPrinted], color, style).ToString(), b); contentLinesPrinted += 1; if (contentLinesPrinted < content.Length) { b.Append("\n"); cursorPos = 0; } } //(print) if (b.Length == 0 || b[b.Length - 1] != '\n') { b.Append("\n"); } Print(record.Channels(), b.ToString()); //--Continue if (info != null) { info.numElementsPrinted += 1; } List <Redwood.Record> rtn = new List <Redwood.Record>(); rtn.Add(record); return(rtn); }
/// <summary> /// <inheritDoc/> /// /// </summary> public override IList <Redwood.Record> SignalStartTrack(Redwood.Record signal) { return(Empty); }
/// <summary> /// <inheritDoc/> /// /// </summary> public override IList <Redwood.Record> Handle(Redwood.Record record) { bool isPrinting = false; if (record.Force()) { //--Case: Force Printing isPrinting = true; } else { switch (this.defaultState) { case VisibilityHandler.State.HideAll: { //--Case: Filter //--Default False foreach (object tag in record.Channels()) { if (this.deltaPool.Contains(tag)) { isPrinting = true; break; } } break; } case VisibilityHandler.State.ShowAll: { //--Default True if (!this.deltaPool.IsEmpty()) { // Short-circuit for efficiency bool somethingSeen = false; foreach (object tag_1 in record.Channels()) { if (this.deltaPool.Contains(tag_1)) { somethingSeen = true; break; } } isPrinting = !somethingSeen; } else { isPrinting = true; } break; } default: { throw new InvalidOperationException("Unknown default state setting: " + this.defaultState); } } } //--Return if (isPrinting) { return(Java.Util.Collections.SingletonList(record)); } else { return(Empty); } }
/// <summary>Signal the start of a track, i.e.</summary> /// <remarks>Signal the start of a track, i.e. that we have descended a level deeper.</remarks> /// <param name="signal"> /// A record corresponding to the information in the track header. /// The depth in this object is the old log depth. /// </param> /// <returns> /// A list of records to pass down the pipeline, not including the startTrack() signal. /// The returned records are passed to handle(), not startTrack(), /// and are sent before the startTrack() signal. /// </returns> public virtual IList <Redwood.Record> SignalStartTrack(Redwood.Record signal) { return(Empty); }
/// <summary>Given a record, return true if it should be propagated to later handlers.</summary> public abstract bool PropagateRecord(Redwood.Record record);
/// <summary>Handle a log Record, either as a filter or by producing a side effect.</summary> /// <param name="record">The log record to handle</param> /// <returns>a (possibly empty) list of records to be sent on in the pipeline</returns> public abstract IList <Redwood.Record> Handle(Redwood.Record record);