Log the current thread stacks at INFO level.
@param log the logger that logs the stack trace
@param title a descriptive title for the call stacks
@param minInterval the minimum time from the last
196110
public static void logThreadInfo(Log log,
                                   String title,
                                   long minInterval) {
    boolean dumpStack = false;
    if (log.isInfoEnabled()) {
      synchronized (ReflectionUtils.class) {
        long now = System.currentTimeMillis();
        if (now - previousLogTime >= minInterval * 1000) {
          previousLogTime = now;
          dumpStack = true;
        }
      }
      if (dumpStack) {
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        printThreadInfo(new PrintWriter(buffer), title);
        log.info(buffer.toString());
      }
    }
  }
103733
private void log( Level level, String msg, Throwable ex ) {
        if (logger.isLoggable(level)) {
            // Hack (?) to get the stack trace.
            Throwable dummyException=new Throwable();
            StackTraceElement locations[]=dummyException.getStackTrace();
            // Caller will be the third element
            String cname="unknown";
            String method="unknown";
            if( locations!=null && locations.length >2 ) {
                StackTraceElement caller=locations[2];
                cname=caller.getClassName();
                method=caller.getMethodName();
            }
            if( ex==null ) {
                logger.logp( level, cname, method, msg );
            } else {
                logger.logp( level, cname, method, msg, ex );
            }
        }
    }
1171830
function DebugLogger(loggerName, prefix) {
  SimpleLogger.call(this, loggerName);
  this.prefix = prefix;
  this.updatePrefix = false;
  this.stackTraceDepth = 7;
}
1025167
public void log()
	{
		System.out.println("Lemmatiser: " + (lemmatiser == null ? null : lemmatiser.getClass().getName()));
		System.out.println("POSTagger: " + (posTagger == null ? null : posTagger.getClass().getName()));
		System.out.println("Tokenizer: " + tokenizer.getClass().getName());
		System.out.println("Tag format: " + tagFormat.name());
		System.out.println("PostProcessor: " + (postProcessor == null ? null : postProcessor.getClass().getName()));
		System.out.println("Using numeric normalization: " + useNumericNormalization);
		System.out.println("CRF order is " + order);
		System.out.println("Using feature induction: " + useFeatureInduction);
		System.out.println("Text textDirection: " + textDirection);
	}
684527
private void setThreadLogger(PluginLogger logger, int loggingLevel) {
        pluginLogger.set(logger);
        logLevel.set(loggingLevel);
        JSch.setLogger(this);
    }
89996
public static void setLogStdOut(boolean log)
    {
        if (log)
        {
            if (!(System.out instanceof LogStream))
                System.setOut(new LogStream.STDOUT());
        }
        else
            System.setOut(STDOUT_STREAM);
    }
1355400
private void log(@NonNull Logger log, @NonNull Throwable t, String msg) {
        log.f(msg + ". Error calling services. " + t.getLocalizedMessage(), t);
    }
525979
public void log(final LogNode log) {
        if (log != null) {
            final LogNode scanSpecLog = log.log("ScanSpec:");
            for (final Field field : ScanSpec.class.getDeclaredFields()) {
                try {
                    scanSpecLog.log(field.getName() + ": " + field.get(this));
                } catch (final ReflectiveOperationException e) {
                    // Ignore
                }
            }
        }
    }
605480
public void messageLogged(final BuildEvent event) {
        int priority = event.getPriority();
        // Filter out messages based on priority
        if (priority <= msgOutputLevel) {

            final String msg = expandMessage(event, event.getMessage());

            if (priority != Project.MSG_ERR) {
                printMessage(msg, out, priority);
            } else {
                printMessage(msg, err, priority);
            }
            log(msg);
        }
    }
691649
public final void trace(Object message, Throwable t) {

        if (isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE)) {
            log(SimpleLog.LOG_LEVEL_TRACE, message, t);
        }
    }
365989
public void appendToLog(String logAppendMessage) {
		ProfilingTimerNode currentNode = current.get();
		if (currentNode != null) {
			currentNode.appendToLog(logAppendMessage);
		}
	}
907485
@Override
	public void log(Level level, String msg, Object param1) {
		
		super.log(level, maskPassword(msg), param1);
	}
527285
@Override
    public void logMessage(final String fqcn, final Level level, final Marker marker, final Message msg,
            final Throwable t) {
        StackTraceElement element = null;
        if (fqcn != null) {
            element = getStackTraceElement(fqcn, Thread.currentThread().getStackTrace());
        }
        final StatusData data = new StatusData(element, level, msg, t, null);
        msgLock.lock();
        try {
            messages.add(data);
        } finally {
            msgLock.unlock();
        }
        // LOG4J2-1813 if system property "log4j2.debug" is defined, all status logging is enabled
        if (isDebugPropertyEnabled()) {
            logger.logMessage(fqcn, level, marker, msg, t);
        } else {
            if (listeners.size() > 0) {
                for (final StatusListener listener : listeners) {
                    if (data.getLevel().isMoreSpecificThan(listener.getStatusLevel())) {
                        listener.log(data);
                    }
                }
            } else {
                logger.logMessage(fqcn, level, marker, msg, t);
            }
        }
    }
171274
public void log(String message) {
        switch (level) {
        case TRACE:
            LOGGER.trace(message);
            break;
        case DEBUG:
            LOGGER.debug(message);
            break;
        case INFO:
            LOGGER.info(message);
            break;
        case WARN:
            LOGGER.warn(message);
            break;
        case ERROR:
            LOGGER.error(message);
            break;
        default:
            throw new XOException("Unsupported log log level " + level);
        }
    }
470505
public void doPost(final LoggingEvent event) {
        // if event does not meet threshold, exit now
        if (!isAsSevereAsThreshold(event.getLevel())) {
            return;
        }

        // get the "local" logger for this event from the
        // configured repository.
        Logger localLogger =
                getLoggerRepository().getLogger(event.getLoggerName());

        // if the logger level is greater or equal to the level
        // of the event, use the logger to append the event.
        if (event.getLevel()
                .isGreaterOrEqual(localLogger.getEffectiveLevel())) {
            // call the loggers appenders to process the event
            localLogger.callAppenders(event);
        }
  }
874600
private void output(final LogEntry logEntry, final Iterable<Writer> writers) {
		if (writingThread == null) {
			for (Writer writer : writers) {
				try {
					writer.write(logEntry);
				} catch (Exception ex) {
					InternalLogger.log(Level.ERROR, ex, "Failed to write log entry '" + logEntry.getMessage() + "'");
				}
			}
		} else {
			for (Writer writer : writers) {
				writingThread.add(writer, logEntry);
			}
		}
	}
808479
private void log(boolean finalLog, String format, Object... args) {
		if (m_condition){
			if (format != null ){
				m_logger.debug(String.format(format, args));
			}
			ArrayList<String> timerNames = new ArrayList<String>(m_timers.keySet());
			Collections.sort(timerNames);
			for (String name : timerNames){
				TimerGroupItem timer = m_timers.get(name);
				if (finalLog || timer.changed()){
					m_logger.debug(timer.toString(finalLog));
				}
			}		
			m_logger.debug(m_total.toString(finalLog));
			ArrayList<String> counterNames = new ArrayList<String>(m_counters.keySet());
			Collections.sort(counterNames);
			for (String name : counterNames){
				Counter counter = m_counters.get(name);
				if (finalLog || counter.changed()){
					String text = String.format("%s: (%s)", name, counter.toString(finalLog));
					m_logger.debug(text);
				}
			}		
		}
	}