/** * This method computes whether a chain of converters handles exceptions or * not. * * @param head * The first element of the chain * @return true if can handle throwables contained in logging events */ public boolean chainHandlesThrowable(Converter<ILoggingEvent> head) { Converter<ILoggingEvent> c = head; while (c != null) { if (c instanceof ThrowableHandlingConverter) { return true; } c = c.getNext(); } return false; } }
private void appendEventToBuffer(StringBuilder buf, Converter<ILoggingEvent> c, ILoggingEvent event) { buf.append("<td class=\""); buf.append(computeConverterName(c)); buf.append("\">"); buf.append(Transform.escapeTags(c.convert(event))); buf.append("</td>"); buf.append(LINE_SEPARATOR); }
/** * Start converters in the chain of converters. * * @param head */ public static <E> void startConverters(Converter<E> head) { Converter<E> c = head; while (c != null) { // CompositeConverter is a subclass of DynamicConverter if (c instanceof CompositeConverter) { CompositeConverter<E> cc = (CompositeConverter<E>) c; Converter<E> childConverter = cc.childConverter; startConverters(childConverter); cc.start(); } else if (c instanceof DynamicConverter) { DynamicConverter<E> dc = (DynamicConverter<E>) c; dc.start(); } c = c.getNext(); } }
/** * * @param head * @deprecated Use {@link ConverterUtil#setContextForConverters} instead. This method will * be removed in future releases. */ protected void setContextForConverters(Converter<E> head) { ConverterUtil.setContextForConverters(getContext(), head); }
private void addToList(Converter<E> c) { if (head == null) { head = tail = c; } else { tail.setNext(c); tail = c; } }
@Override public void start() { PatternLayout patternLayout = new PatternLayout(); patternLayout.setContext(context); patternLayout.setPattern(getPattern()); patternLayout.setOutputPatternAsHeader(outputPatternAsHeader); patternLayout.start(); this.layout = patternLayout; super.start(); }
/** * @deprecated replaced by {@link #setOutputPatternAsHeader(boolean)} */ public void setOutputPatternAsPresentationHeader(boolean outputPatternAsHeader) { addWarn("[outputPatternAsPresentationHeader] property is deprecated. Please use [outputPatternAsHeader] option instead."); this.outputPatternAsHeader = outputPatternAsHeader; }
@Override public String getPresentationHeader() { if(outputPatternAsHeader) return getPresentationHeaderPrefix()+pattern; else return super.getPresentationHeader(); } }
protected LayoutBase<E> buildLayout(LoggerContext context, LayoutFactory<E> defaultLayoutFactory) { final LayoutBase<E> layoutBase; if (layout == null) { final PatternLayoutBase<E> patternLayoutBase = defaultLayoutFactory.build(context, timeZone); if (!Strings.isNullOrEmpty(logFormat)) { patternLayoutBase.setPattern(logFormat); } layoutBase = patternLayoutBase; } else { layoutBase = layout.build(context, timeZone); } layoutBase.start(); return layoutBase; } }
public String doLayout(ILoggingEvent event) { StringBuilder buf = new StringBuilder(); startNewTableIfLimitReached(buf); boolean odd = true; if (((counter++) & 1) == 0) { odd = false; } String level = event.getLevel().toString().toLowerCase(); buf.append(LINE_SEPARATOR); buf.append("<tr class=\""); buf.append(level); if (odd) { buf.append(" odd\">"); } else { buf.append(" even\">"); } buf.append(LINE_SEPARATOR); Converter<ILoggingEvent> c = head; while (c != null) { appendEventToBuffer(buf, c, event); c = c.getNext(); } buf.append("</tr>"); buf.append(LINE_SEPARATOR); if (event.getThrowableProxy() != null) { throwableRenderer.render(buf, event); } return buf.toString(); }
break; c = c.getNext();
public IntegerTokenConverter getIntegerTokenConverter() { Converter p = headTokenConverter; while (p != null) { if (p instanceof IntegerTokenConverter) { return (IntegerTokenConverter) p; } p = p.getNext(); } return null; }
public static <E> Converter<E> findTail(Converter<E> head) { Converter<E> p = head; while (p != null) { Converter<E> next = p.getNext(); if (next == null) { break; } else { p = next; } } return p; }
public static <E> void setContextForConverters(Context context, Converter<E> head) { Converter<E> c = head; while (c != null) { if (c instanceof ContextAware) { ((ContextAware) c).setContext(context); } c = c.getNext(); } } }