Java 类org.slf4j.Marker 实例源码

public Marker getLoggingMarker() {
    // If we get more optional header fields, we should probably exclude them if they are empty.
    Marker messageMarker =
            append("messageId", messageId)
                    .and(append("partitionId", partitionId))
                    .and(append("partitioningKey", partitioningKey))
                    .and(append("offset", offset))
                    .and(append("messageId", messageId))
                    .and(append("correlationId", correlationId))
                    .and(append("requestCorrelationId", requestCorrelationId));


    // Nota bene: without the toString the marker tries to convert the object into Json, which produces strange results
    if (topic != null) {
        messageMarker.add(append("topic", topic.toString()));
    }
    if (replyTo != null) {
        messageMarker.add(append("replyTo", replyTo.toString()));
    }
    if (type != null) {
        messageMarker.add(append("messageType", type.toString()));
    }

    return messageMarker;
}

@Override
public FilterReply decide(Marker marker, Logger logger, Level level, String format, Object[] params, Throwable t) {
    // cannot use logger.isEnabledFor(level), as it would cause a StackOverflowError by calling this filter again!
    if(level.isGreaterOrEqual(logger.getEffectiveLevel()) && format != null) {
        switch (level.toInt()) {
            case Level.ERROR_INT:
                errorCounter.increment();
                break;
            case Level.WARN_INT:
                warnCounter.increment();
                break;
            case Level.INFO_INT:
                infoCounter.increment();
                break;
            case Level.DEBUG_INT:
                debugCounter.increment();
                break;
            case Level.TRACE_INT:
                traceCounter.increment();
                break;
        }
    }

    return FilterReply.NEUTRAL;
}

public boolean matches(ILoggingEvent event) {
    Marker marker = event.getMarker();
    if(marker != null) {
        return matches(marker);
    }

    return false;
}

private void populate(Marker marker, List<DomainMarker> markers, boolean mdc) {
    if (marker instanceof DomainMarker) {
        DomainMarker domainMarker = (DomainMarker)marker;

        if(mdc) {
            DomainMarker parent = domainMarker.getParent(); // assume from mdc context
            if(parent != null) {
                markers.add(parent);
            }
        } else {
            markers.add(domainMarker);
        }
    } else if(marker instanceof DeferredMdcMarker) {
        DeferredMdcMarker deferredMdcMarker = (DeferredMdcMarker)marker;

        for(DomainMarker mdcMarker : deferredMdcMarker.getMarkers()) {
            markers.add(mdcMarker);
        }
    }

    if(marker.hasReferences()) {
        Iterator<Marker> iterator = marker.iterator();
        while(iterator.hasNext()) {
            populate(iterator.next(), markers, mdc);
        }
    }
}

public boolean isTraceEnabled(Marker marker) {
    return isTraceEnabled();
}

@Override
public boolean isDebugEnabled(Marker arg0) {
    return false;
}

@Override
public void debug(final Marker marker, final String format, final Object arg) {
    delegate.debug(marker, manipulateLogMessage(format), manipulateLogArguments(arg));
}

@Override
public void error(final Marker marker, final String format, final Object arg) {
    delegate.error(marker, manipulateLogMessage(format), manipulateLogArguments(arg));
}

public void trace(Marker marker, String msg) {
}

@Override
public void debug(Marker marker, String s, Object o, Object o1)
{
    underlying.debug(marker, s, o, o1);
}

@Override
public void warn(final Marker marker, final String format, final Object arg1, final Object arg2) {
    delegate.warn(marker, manipulateLogMessage(format), manipulateLogArguments(arg1, arg2));
}

@Override
public void debug(Marker arg0, String arg1, Throwable arg2) {
}

/**
 * {@link #warn(org.slf4j.Marker, java.lang.String, java.lang.Throwable)} with a lambda message supplier.
 */
default void warn(Marker marker, Supplier<String> msgSupplier, Throwable t) {
    doLog(marker, Level.WARN, msgSupplier, t);
}

@Override
public void debug(Marker marker, String format, Object arg) {
    if (shouldLog()) {
        delegate.debug(marker, format, arg);
    }
}

/**
 * {@link #info(org.slf4j.Marker, java.lang.String)} with a lambda message supplier.
 */
default void info(Marker marker, Supplier<String> msgSupplier) {
    doLog(marker, Level.INFO, msgSupplier, null);
}

@Override
public boolean isWarnEnabled(Marker marker) {
    return delegate.isWarnEnabled(marker);
}

@Override
public boolean isInfoEnabled(Marker marker) {
    return false;
}

@Override
public void error(final Marker marker, final String format, final Object arg1, final Object arg2) {
    delegate.error(marker, manipulateLogMessage(format), manipulateLogArguments(arg1, arg2));
}

@Override
public void trace(Marker arg0, String arg1, Object[] arg2) {
}

public void trace(Marker marker, String msg, Throwable t) {
    trace(msg, t);
}

private Marker getMarker(final String name) {
    final Marker marker = mock(Marker.class);
    when(marker.getName()).thenReturn(name);
    return marker;
}

@Override
public void trace(Marker marker, String s, Object o, Object o1)
{
    underlying.trace(marker, s, o, o1);
}

/**
 * {@link #warn(org.slf4j.Marker, java.lang.String, java.lang.Object...)} with 3 or more lambda argument suppliers.
 */
default void warn(Marker marker, String format, Supplier<?>... argSuppliers) {
    doLog(marker, Level.WARN, format, argSuppliers, null);
}

public boolean isTraceEnabled(Marker marker) {
    return isTraceEnabled();
}

public boolean isDebugEnabled(Marker marker) {
    return isDebugEnabled();
}

default void trace(Marker marker, String msg) {
    doLog(marker, Level.TRACE, msg, null, null);
}

@Override
public void info(final Marker marker, final String format, final Object arg) {
    delegate.info(marker, manipulateLogMessage(format), manipulateLogArguments(arg));
}

@Override
public void trace(Marker arg0, String arg1, Object arg2) {
}

public static void debug(Marker paramMarker,Class<?> clazz, String paramString, Throwable paramThrowable) {
    getLogger(clazz).debug(paramMarker, paramString, paramThrowable);
    if(verbose) System.out.println(paramString);
}

@Override
public void warn(final Marker marker, final String format, final Object... arguments) {
    delegate.warn(marker, manipulateLogMessage(format), manipulateLogArguments(arguments));
}

@Override
public void info(Marker arg0, String arg1, Object arg2, Object arg3) {
}

@Override
public void error(Marker marker, String s, Object... objects)
{
    underlying.error(marker, s, objects);
}

@Override
public void warn(Marker arg0, String arg1, Object arg2) {
}

@Override
public boolean isDebugEnabled(Marker marker) {
    return false;
}

@Override
public void error(Marker marker, String msg, Throwable t) {
}

@Override
public void info(Marker marker, String s, Object o)
{
    underlying.info(marker, s, o);
}

@Override
public void debug(Marker marker, String format, Object... arguments) {
}

public void info(Marker marker, String format, Object[] argArray) {
    if (print) {
        slf4jLogger.info(marker, format, argArray);
    }
}

/**
 * {@link #error(org.slf4j.Marker, java.lang.String, java.lang.Object)} with a lambda argument supplier.
 */
default void error(Marker marker, String format, Supplier<?> argSupplier1) {
    doLog(marker, Level.ERROR, format, new Supplier<?>[]{argSupplier1}, null);
}

public static void warn(Marker paramMarker,Class<?> clazz, String paramString) {
    getLogger(clazz).warn(paramMarker, paramString);
    if(verbose) System.out.println(paramString);
}