Writes an explanatory message and a stack trace for a given
{@code Throwable} to the servlet log file, prepended by the
filter's name.

@param pMessage the log message
@param pThrowable the exception
@see ServletContext#log(String,Throwable)
355409
protected void log(final String pMessage, final Throwable pThrowable) {
        getServletContext().log(getFilterName() + ": " + pMessage, pThrowable);
    }
304781
public static void logError(String pMessage, Throwable pThrowable) {
        final BundleContext bundleContext = FrameworkUtil
            .getBundle(ServiceAuthenticationHttpContext.class)
            .getBundleContext();
        logError(bundleContext, pMessage, pThrowable);
    }
1121708
public void logDebug(Object[] message,Throwable throwable)
    {
        this.log(LogLevel.DEBUG,message,throwable);
    }
1295761
public void debug(Throwable throwable, String msg, Object arg0) {
		logIfEnabled(Level.DEBUG, throwable, msg, arg0, UNKNOWN_ARG, UNKNOWN_ARG, null);
	}
880808
@Override
    protected void logImpl(LogLevel level,Object[] message,Throwable throwable)
    {
        //format log message (without exception)
        String text=this.formatLogMessage(level,message,null);

        //get log level
        int levelValue=level.getValue();
        switch(levelValue)
        {
            case LogLevel.DEBUG_LOG_LEVEL_VALUE:
                this.APACHE_LOGGER.debug(text);
                break;
            case LogLevel.ERROR_LOG_LEVEL_VALUE:
                this.APACHE_LOGGER.error(text,throwable);
                break;
            case LogLevel.INFO_LOG_LEVEL_VALUE:
            default:
                this.APACHE_LOGGER.info(text);
                break;
        }
    }
525045
public static void printFatal(Object message)
	{

		if (message instanceof Throwable)
		{
			Throwable e = (Throwable) message;
			e.printStackTrace();
		}

		Log log = getLog(Debugger.class);
		if(log != null)
			log.fatal(message);
		else
			System.err.println(message);
		
	}
1152528
void log(SessionLogEntry entry, String formattedMessage) {
        int level = entry.getLevel();
        Throwable loggedException = entry.getException();

        String msgParm;
        if ((formattedMessage == null || formattedMessage.equals("")) && loggedException != null) {
            msgParm = loggedException.toString();
        } else {
            msgParm = formattedMessage;
        }

        switch (level) {
            case 8:
                return;
            case 7: // SEVERE
                // With the persistence service, only errors will be logged.  The rest will be debug.
                String errMsg = Tr.formatMessage(_stc, "PROVIDER_ERROR_CWWKD0292E", msgParm);
                Tr.error(_tc, errMsg);
                break;
            case 6:// WARN
                String wrnMsg = Tr.formatMessage(_stc, "PROVIDER_WARNING_CWWKD0291W", msgParm);
                Tr.debug(_tc, wrnMsg); // 170432 - move warnings to debug
                break;
            case 3: // FINE
            case 2: // FINER
            case 1: // FINEST
            case 0: // TRACE
                Tr.debug(_tc, formattedMessage);
                break;
        }// end switch

        // if there is an exception - only log it to trace
        if (_tc.isDebugEnabled() && loggedException != null) {
            Tr.debug(_tc, "throwable", loggedException);
        }
    }
63020
public void info(final String message, final Throwable throwable) {
        log.info(sanitize(message), throwable);
    }
413126
protected void trace(Throwable t, String msgFormat, Object... args)
    {
        m_logger.trace(String.format(msgFormat, args), t);
    }
199594
protected static void log(Level level, Object message, Throwable throwable, Object... args) {
		Message payload = payload(message, args, throwable);
		payload.getFormattedMessage(); // preformat message (cached), so formating has processed and added fields to MetaContext
		if (MetaContext.hasMeta()) {
			// serialize metacontext map to json, which is put into a designated threadcontext field
			ThreadContext.put(JSON_FIELD, MetaContext.toJson());
			MetaContext.clear();
		}
		determineLogger().log(level, payload, payload.getThrowable());
		if (ThreadContext.getContext() != null && ThreadContext.containsKey(JSON_FIELD)) {
			ThreadContext.remove(JSON_FIELD);
		}
	}
242905
public void trace(Object message, Throwable exception) {
        log(Level.FINEST, String.valueOf(message), exception);
    }
380571
public static void v(String tag, String msg, Throwable throwable) {
        if (sLevel > LEVEL_VERBOSE) {
            return;
        }
        Log.v(tag, msg, throwable);
    }
1108381
public static void handleException(Logger log, Throwable throwable,
            String methodName, Object... params) {
        if (params.length > 0)
            JMLog.errorForException(log, throwable, methodName, params);
        else
            JMLog.errorForException(log, throwable, methodName);
        increaseErrorCount();
        recordErrorMessageHistory(throwable);
    }
487402
public void info(Object message, Throwable exception) {
        log(Level.INFO, String.valueOf(message), exception);
    }
807586
public void log(final String tag, final int logLevel, final String msg, final Throwable exception) {
        if (aConsole != null) {
            aConsole.appendLog(tag, logLevel, msg, exception);
        }
        if (aFile != null) {
            aFile.appendLog(tag, logLevel, msg, exception);
        }
    }
1077728
@Override
	public void log(Level level, String msg, Throwable thrown) {
		
		super.log(level, maskPassword(msg), thrown);
	}
529081
@SuppressWarnings({"static-method", "checkstyle:regexp"})
	public void logDebugMessage(String message, Throwable cause) {
		Debug.println(message);
		if (cause != null) {
			Debug.printStackTrace(cause);
		}
	}