Example usage for org.apache.commons.logging Log isTraceEnabled

Introduction

In this page you can find the example usage for org.apache.commons.logging Log isTraceEnabled.

Prototype

boolean isTraceEnabled();

Source Link

Document

Is trace logging currently enabled?

Usage

From source file:fr.gouv.vitam.utils.logging.CommonsLoggerTest.java

@Test
public void testIsTraceEnabled() {
    final Log mock = createStrictMock(Log.class);

    expect(mock.isTraceEnabled()).andReturn(true);
    replay(mock);//  w  w w .  ja  va2  s .c om

    final VitamLogger logger = new CommonsLogger(mock, "foo");
    assertTrue(logger.isTraceEnabled());
    verify(mock);
}

From source file:com.sos.i18n.logging.commons.CommonsLogMsg.java

/**
 * Logs the given message to the log at the trace level. If the log level is not enabled, this method does
 * nothing and returns <code>null</code>. If a message was logged, its {@link Msg} will be returned.
 *
 * @param  log     the log where the messages will go
 * @param  key     the resource bundle key name
 * @param  varargs arguments to help fill in the resource bundle message
 *
 * @return if the message was logged, a non-<code>null</code> Msg object is returned
 *///w  w  w  . j  a  v a 2  s  .co m
public static Msg trace(Log log, String key, Object... varargs) {
    if (log.isTraceEnabled()) {
        Msg msg = Msg.createMsg(key, varargs);
        log.trace((Logger.getDumpLogKeys()) ? ('{' + key + '}' + msg) : msg);
        return msg;
    }

    return null;
}

From source file:de.ufinke.cubaja.sort.SortManager.java

public boolean isTrace() {

    final Log logger = this.logger;
    return logger != null && logger.isTraceEnabled();
}

From source file:com.sos.i18n.logging.commons.CommonsLogMsg.java

/**
 * Logs the given message to the log at the trace level. If the log level is not enabled, this method does
 * nothing and returns <code>null</code>. If a message was logged, its {@link Msg} will be returned.
 *
 * @param  log     the log where the messages will go
 * @param  locale  the locale to determine what bundle to use
 * @param  key     the resource bundle key name
 * @param  varargs arguments to help fill in the resource bundle message
 *
 * @return if the message was logged, a non-<code>null</code> Msg object is returned
 *//*from   ww w  .ja  v a2 s  .  co  m*/
public static Msg trace(Log log, Locale locale, String key, Object... varargs) {
    if (log.isTraceEnabled()) {
        Msg msg = Msg.createMsg(locale, key, varargs);
        log.trace((Logger.getDumpLogKeys()) ? ('{' + key + '}' + msg) : msg);
        return msg;
    }

    return null;
}

From source file:javadz.beanutils.MethodUtils.java

/**
 * <p>Find an accessible method that matches the given name and has compatible parameters.
 * Compatible parameters mean that every method parameter is assignable from 
 * the given parameters./*from  w ww.  j  a  va 2  s  .co  m*/
 * In other words, it finds a method with the given name 
 * that will take the parameters given.<p>
 *
 * <p>This method is slightly undeterminstic since it loops 
 * through methods names and return the first matching method.</p>
 * 
 * <p>This method is used by 
 * {@link 
 * #invokeMethod(Object object,String methodName,Object [] args,Class[] parameterTypes)}.
 *
 * <p>This method can match primitive parameter by passing in wrapper classes.
 * For example, a <code>Boolean</code> will match a primitive <code>boolean</code>
 * parameter.
 *
 * @param clazz find method in this class
 * @param methodName find method with this name
 * @param parameterTypes find method with compatible parameters 
 * @return The accessible method
 */
public static Method getMatchingAccessibleMethod(Class clazz, String methodName, Class[] parameterTypes) {
    // trace logging
    Log log = LogFactory.getLog(MethodUtils.class);
    if (log.isTraceEnabled()) {
        log.trace("Matching name=" + methodName + " on " + clazz);
    }
    MethodDescriptor md = new MethodDescriptor(clazz, methodName, parameterTypes, false);

    // see if we can find the method directly
    // most of the time this works and it's much faster
    try {
        // Check the cache first
        Method method = getCachedMethod(md);
        if (method != null) {
            return method;
        }

        method = clazz.getMethod(methodName, parameterTypes);
        if (log.isTraceEnabled()) {
            log.trace("Found straight match: " + method);
            log.trace("isPublic:" + Modifier.isPublic(method.getModifiers()));
        }

        setMethodAccessible(method); // Default access superclass workaround

        cacheMethod(md, method);
        return method;

    } catch (NoSuchMethodException e) {
        /* SWALLOW */ }

    // search through all methods 
    int paramSize = parameterTypes.length;
    Method bestMatch = null;
    Method[] methods = clazz.getMethods();
    float bestMatchCost = Float.MAX_VALUE;
    float myCost = Float.MAX_VALUE;
    for (int i = 0, size = methods.length; i < size; i++) {
        if (methods[i].getName().equals(methodName)) {
            // log some trace information
            if (log.isTraceEnabled()) {
                log.trace("Found matching name:");
                log.trace(methods[i]);
            }

            // compare parameters
            Class[] methodsParams = methods[i].getParameterTypes();
            int methodParamSize = methodsParams.length;
            if (methodParamSize == paramSize) {
                boolean match = true;
                for (int n = 0; n < methodParamSize; n++) {
                    if (log.isTraceEnabled()) {
                        log.trace("Param=" + parameterTypes[n].getName());
                        log.trace("Method=" + methodsParams[n].getName());
                    }
                    if (!isAssignmentCompatible(methodsParams[n], parameterTypes[n])) {
                        if (log.isTraceEnabled()) {
                            log.trace(methodsParams[n] + " is not assignable from " + parameterTypes[n]);
                        }
                        match = false;
                        break;
                    }
                }

                if (match) {
                    // get accessible version of method
                    Method method = getAccessibleMethod(clazz, methods[i]);
                    if (method != null) {
                        if (log.isTraceEnabled()) {
                            log.trace(method + " accessible version of " + methods[i]);
                        }
                        setMethodAccessible(method); // Default access superclass workaround
                        myCost = getTotalTransformationCost(parameterTypes, method.getParameterTypes());
                        if (myCost < bestMatchCost) {
                            bestMatch = method;
                            bestMatchCost = myCost;
                        }
                    }

                    log.trace("Couldn't find accessible method.");
                }
            }
        }
    }
    if (bestMatch != null) {
        cacheMethod(md, bestMatch);
    } else {
        // didn't find a match
        log.trace("No match found.");
    }

    return bestMatch;
}

From source file:com.sos.i18n.logging.commons.CommonsLogMsg.java

/**
 * Logs the given message to the log at the trace level. If the log level is not enabled, this method does
 * nothing and returns <code>null</code>. If a message was logged, its {@link Msg} will be returned.
 *
 * <p>The given Throwable will be passed to the logger so its stack can be dumped when appropriate.</p>
 *
 * @param  log       the log where the messages will go
 * @param  throwable the throwable associated with the log message
 * @param  key       the resource bundle key name
 * @param  varargs   arguments to help fill in the resource bundle message
 *
 * @return if the message was logged, a non-<code>null</code> Msg object is returned
 *//*  w ww.jav  a  2  s  .c  o m*/
public static Msg trace(Log log, Throwable throwable, String key, Object... varargs) {
    if (log.isTraceEnabled()) {
        Msg msg = Msg.createMsg(key, varargs);
        logTraceWithThrowable(log, key, msg, throwable);
        return msg;
    }

    return null;
}

From source file:com.sos.i18n.logging.commons.CommonsLogMsg.java

/**
 * Logs the given message to the log at the trace level. If the log level is not enabled, this method does
 * nothing and returns <code>null</code>. If a message was logged, its {@link Msg} will be returned.
 *
 * @param  log      the log where the messages will go
 * @param  basename the base name of the resource bundle
 * @param  key      the resource bundle key name
 * @param  varargs  arguments to help fill in the resource bundle message
 *
 * @return if the message was logged, a non-<code>null</code> Msg object is returned
 *//*ww  w .  j a va 2s.c o  m*/
public static Msg trace(Log log, BundleBaseName basename, String key, Object... varargs) {
    if (log.isTraceEnabled()) {
        Msg msg = Msg.createMsg(basename, key, varargs);
        log.trace((Logger.getDumpLogKeys()) ? ('{' + key + '}' + msg) : msg);
        return msg;
    }

    return null;
}

From source file:com.sos.i18n.logging.commons.CommonsLogMsg.java

/**
 * Logs the given message to the log at the trace level. If the log level is not enabled, this method does
 * nothing and returns <code>null</code>. If a message was logged, its {@link Msg} will be returned.
 *
 * <p>The given Throwable will be passed to the logger so its stack can be dumped when appropriate.</p>
 *
 * @param  log       the log where the messages will go
 * @param  throwable the throwable associated with the log message
 * @param  locale    the locale to determine what bundle to use
 * @param  key       the resource bundle key name
 * @param  varargs   arguments to help fill in the resource bundle message
 *
 * @return if the message was logged, a non-<code>null</code> Msg object is returned
 *///from   w  w w  . java  2  s  . c  om
public static Msg trace(Log log, Throwable throwable, Locale locale, String key, Object... varargs) {
    if (log.isTraceEnabled()) {
        Msg msg = Msg.createMsg(locale, key, varargs);
        logTraceWithThrowable(log, key, msg, throwable);
        return msg;
    }

    return null;
}

From source file:com.sos.i18n.logging.commons.CommonsLogMsg.java

/**
 * Logs the given message to the log at the trace level. If the log level is not enabled, this method does
 * nothing and returns <code>null</code>. If a message was logged, its {@link Msg} will be returned.
 *
 * @param  log      the log where the messages will go
 * @param  basename the base name of the resource bundle
 * @param  locale   the locale to determine what bundle to use
 * @param  key      the resource bundle key name
 * @param  varargs  arguments to help fill in the resource bundle message
 *
 * @return if the message was logged, a non-<code>null</code> Msg object is returned
 *//*from   w w  w.j  av  a 2  s . com*/
public static Msg trace(Log log, BundleBaseName basename, Locale locale, String key, Object... varargs) {
    if (log.isTraceEnabled()) {
        Msg msg = Msg.createMsg(basename, locale, key, varargs);
        log.trace((Logger.getDumpLogKeys()) ? ('{' + key + '}' + msg) : msg);
        return msg;
    }

    return null;
}

From source file:com.sos.i18n.logging.commons.CommonsLogMsg.java

/**
 * Logs the given message to the log at the trace level. If the log level is not enabled, this method does
 * nothing and returns <code>null</code>. If a message was logged, its {@link Msg} will be returned.
 *
 * <p>The given Throwable will be passed to the logger so its stack can be dumped when appropriate.</p>
 *
 * @param  log       the log where the messages will go
 * @param  throwable the throwable associated with the log message
 * @param  basename  the base name of the resource bundle
 * @param  key       the resource bundle key name
 * @param  varargs   arguments to help fill in the resource bundle message
 *
 * @return if the message was logged, a non-<code>null</code> Msg object is returned
 *///from   ww  w . ja  va  2s  .  c  om
public static Msg trace(Log log, Throwable throwable, BundleBaseName basename, String key, Object... varargs) {
    if (log.isTraceEnabled()) {
        Msg msg = Msg.createMsg(basename, key, varargs);
        logTraceWithThrowable(log, key, msg, throwable);
        return msg;
    }

    return null;
}