}
    }

    @Override
    public void warn(CharSequence content) {
        if (isWarnEnabled()) {
            logger.warn(toString(content));
        }
    }

    @Override
    public void warn(CharSequence content, Throwable error) {
        if (isWarnEnabled()) {
            logger.warn(toString(content), error);
        }
    }

    @Override

    public void info(Marker marker, String format, Object... arguments) {}

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

    public boolean isWarnEnabled() {
        return false;
    }

    public void warn(String msg) {}

    public void warn(String format, Object arg) {}

    public void warn(String format, Object... arguments) {}

    }

    @Override
    public void error(final String message, final Throwable t) {
        logger.error(message, t);
    }

    @Override
    public boolean isWarnEnabled() {
        return logger.isWarnEnabled();
    }

    @Override
    public void warn(final String message) {
        logger.warn(message);
    }

    @Override
    public void warn(final String message, final Throwable t) {

                // The first definition wins.
                Lifecycle original = phaseToLifecycleMap.put(phase, lifecycle);
                if (original != null && logger.isWarnEnabled()) {
                    logger.warn(
                            "Duplicated lifecycle phase {}. Defined in {} but also in {}",
                            phase,
                            original.getId(),

     */
    public boolean isInfoEnabled() {
        return true;
    }

    /**
     * @see org.apache.maven.plugin.logging.Log#isWarnEnabled()
     */
    public boolean isWarnEnabled() {
        return true;
    }

    /**
     * @see org.apache.maven.plugin.logging.Log#isErrorEnabled()
     */
    public boolean isErrorEnabled() {
        return true;

        logger.warn(message);
    }

    public void warn(String message, Throwable throwable) {
        setMdc();
        logger.warn(message, throwable);
    }

    public boolean isWarnEnabled() {
        return logger.isWarnEnabled();
    }

    public void error(String message) {
        setMdc();
        logger.error(message);
    }

    public void error(String message, Throwable throwable) {
        setMdc();

    void fatal(String message);

    void fatal(String message, Throwable t);

    boolean isErrorEnabled();

    void error(String message);

    void error(String message, Throwable t);

    boolean isWarnEnabled();

    void warn(String message);

    void warn(String message, Throwable t);

    boolean isInfoEnabled();

    void info(String message);

    void info(String message, Throwable t);

     */
    @Override
    public void addExclude(final String urlPattern) {
        try {
            Pattern.compile(urlPattern);
        } catch (final Exception e) {
            if (logger.isWarnEnabled()) {
                logger.warn("Invalid exclude pattern: {}", urlPattern);
            }
            return;
        }
        if (sessionId == null) {
            cachedExcludeSet.add(urlPattern);

    }

    public boolean isDebugEnabled() {
        return DEBUG.equals(logLevel);
    }

    public boolean isInfoEnabled() {
        return INFO.equals(logLevel);
    }

    public boolean isWarnEnabled() {
        return WARN.equals(logLevel);
    }

    public boolean isErrorEnabled() {
        return ERROR.equals(logLevel);
    }

    }

    @Override
    public void error(final String message, final Throwable t) {
        logger.logp(Level.SEVERE, sourceClass, null, message, t);
    }

    @Override
    public boolean isWarnEnabled() {
        return logger.isLoggable(Level.WARNING);
    }

    @Override
    public void warn(final String message) {
        logger.logp(Level.WARNING, sourceClass, null, message);
    }

    @Override