Logs the provided data.

@param   level
The log level
@param   message
The message parts (may be null)
@param   throwable
The error (may be null)
9976
@Override
    protected void logImpl(LogLevel level,Object[] message,Throwable throwable)
    {
        //format log message
        String text=this.formatLogMessage(level,message,throwable);
        
        //print text to system out
        System.out.println(text);
    }
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);
        }
    }
6057
public void log (int level, String message, Throwable t)
    {
        if (isLevelEnabled(level)) {
            _sctx.log(message, t);
        }
    }
689240
public void debug(Object message, Throwable t)
    {
        if (IS12)
        {
            getLogger().log(FQCN, Level.DEBUG, message, t);
        }
        else
        {
            getLogger().log(FQCN, Level.DEBUG, message, t);
        }
    }
889315
@Override
  public void log(Level level, Object message, Throwable e) {
    java.util.logging.Level sLevel = java.util.logging.Level.SEVERE;

    switch (level == null ? Level.FATAL : level) {
    case TRACE:
      sLevel = java.util.logging.Level.FINEST;
      break;
    case DEBUG:
      sLevel = java.util.logging.Level.FINE;
      break;
    case INFO:
      sLevel = java.util.logging.Level.INFO;
      break;
    case WARN:
      sLevel = java.util.logging.Level.WARNING;
      break;
    case ERROR:
      sLevel = java.util.logging.Level.SEVERE;
      break;
    case FATAL:
      sLevel = java.util.logging.Level.SEVERE;
      break;
    default:
      // I don't know what this is, so consider it fatal
      sLevel = java.util.logging.Level.SEVERE;
      sunLogger.log(sLevel, "Unhandled log level:  " + level
          + " for the following message");
    }

    // Figure out who was logging.
    Throwable t = new Throwable();
    StackTraceElement[] ste = t.getStackTrace();
    StackTraceElement logRequestor = null;
    String alclass = AbstractLogger.class.getName();
    for (int i = 0; i < ste.length && logRequestor == null; i++) {
      if (ste[i].getClassName().equals(alclass)) {
        // Make sure there's another stack frame.
        if (i + 1 < ste.length) {
          logRequestor = ste[i + 1];
          if (logRequestor.getClassName().equals(alclass)) {
            logRequestor = null;
          } // Also AbstractLogger
        } // Found something that wasn't abstract logger
      } // check for abstract logger
    }

    // See if we could figure out who was doing the original logging,
    // if we could, we want to include a useful class and method name
    if (logRequestor != null) {
      if (e != null) {
        sunLogger.logp(sLevel, logRequestor.getClassName(),
            logRequestor.getMethodName(), message.toString(), e);
      } else {
        sunLogger.logp(sLevel, logRequestor.getClassName(),
            logRequestor.getMethodName(), message.toString());
      }
    } else {
      if (e != null) {
        sunLogger.log(sLevel, message.toString(), e);
      } else {
        sunLogger.log(sLevel, message.toString());
      }
    }
  }
1326150
public void log(final String _message,
                    final int _level)
    {
        switch (_level)  {
            case 4:
                if (IvyOverSLF4JLogger.LOG.isDebugEnabled())  {
                    IvyOverSLF4JLogger.LOG.debug(_message);
                }
                break;
            case 3:
                if (IvyOverSLF4JLogger.LOG.isWarnEnabled())  {
                    IvyOverSLF4JLogger.LOG.warn(_message);
                }
                break;
            case 2:
                if (IvyOverSLF4JLogger.LOG.isInfoEnabled())  {
                    IvyOverSLF4JLogger.LOG.info(_message);
                }
                break;
            case 1:
                if (IvyOverSLF4JLogger.LOG.isErrorEnabled())  {
                    IvyOverSLF4JLogger.LOG.error(_message);
                }
                break;
            default:
                IvyOverSLF4JLogger.LOG.error("unknown log level " + _level);
                IvyOverSLF4JLogger.LOG.error(_message);
        }
    }
922622
public void log(Throwable error, Level level) {
    log(error, null, null, level);
  }
593722
public void log(LogLevel level, String msg, Throwable t)
	{
		if (level != LogLevel.OFF && level.level <= logLevel.level)
			logger.add(writers, name, level, msg, t);
	}
457720
private void log(Level level, String content, Throwable throwable) {
        String dateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date());
        String log = String.format("[%s] %s [] - %s", level, dateStr, content);
        if(level.isLessSpecificThan(Level.ERROR)
                && level.isMoreSpecificThan(Level.OFF)) {
            System.err.println(log);
        } else {
            System.out.println(log);
        }

        if (throwable != null) {
            throwable.printStackTrace(System.err);
        }
    }
1077728
@Override
	public void log(Level level, String msg, Throwable thrown) {
		
		super.log(level, maskPassword(msg), thrown);
	}
341300
public void log(java.util.logging.Level level, CharSequence message) {
    LogRecord rec = new ELKILogRecord(level, message);
    logger.log(rec);
  }
1226094
public void log(final Level level, final String msg, final Throwable throwable) {
        switch (level) {
            case ERROR:
                if (proxy.isErrorEnabled()) {
                    if (proxy instanceof LocationAwareLogger) {
                        ((LocationAwareLogger) proxy).log(null, FQCN, LocationAwareLogger.ERROR_INT, msg, null, throwable);
                    } else {
                        proxy.error(msg, throwable);
                    }
                }

                break;
            case WARN:
                if (proxy.isWarnEnabled()) {
                    if (proxy instanceof LocationAwareLogger) {
                        ((LocationAwareLogger) proxy).log(null, FQCN, LocationAwareLogger.WARN_INT, msg, null, throwable);
                    } else {
                        proxy.warn(msg, throwable);
                    }
                }

                break;
            case INFO:
                if (proxy.isInfoEnabled()) {
                    if (proxy instanceof LocationAwareLogger) {
                        ((LocationAwareLogger) proxy).log(null, FQCN, LocationAwareLogger.INFO_INT, msg, null, throwable);
                    } else {
                        proxy.info(msg, throwable);
                    }
                }

                break;
            case DEBUG:
                if (proxy.isDebugEnabled()) {
                    if (proxy instanceof LocationAwareLogger) {
                        ((LocationAwareLogger) proxy).log(null, FQCN, LocationAwareLogger.DEBUG_INT, msg, null, throwable);
                    } else {
                        proxy.debug(msg, throwable);
                    }
                }

                break;
            case TRACE:
                if (proxy.isTraceEnabled()) {
                    if (proxy instanceof LocationAwareLogger) {
                        ((LocationAwareLogger) proxy).log(null, FQCN, LocationAwareLogger.TRACE_INT, msg, null, throwable);
                    } else {
                        proxy.trace(msg, throwable);
                    }
                }

                break;
            default:
                throw new IllegalStateException("Logging level [" + level + "] is invalid");
        }
    }
822811
private static final void log(final String Message, final int level) {
		if ((level == CClassLoader.INFO)
				&& CClassLoader.log.isLoggable(Level.INFO)) {
			CClassLoader.log.info(Message);
		} else if ((level == CClassLoader.DEBUG)
				&& CClassLoader.log.isLoggable(Level.FINE)) {
			CClassLoader.log.fine(Message);
		} else if ((level == CClassLoader.FATAL)
				&& CClassLoader.log.isLoggable(Level.SEVERE)) {
			CClassLoader.log.severe(Message);
		}
	}
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;
        }
    }
1264291
public function log($message, $level = LogLevel::DEBUG)
    {
        if ($this->logger instanceof LoggerInterface) {
            $this->logger->log($level, $message);
        }
    }
227287
private synchronized void logEvent( int level, String string, Throwable throwable )
    {
        // Check if the event should be logged
        if ( level > _loggingLevel )
        {
            return;
        }

        if ( _logFile != null )
        {
            // No logfile specified, log using servlet context
            PrintWriter pw = null;
            try
            {
                pw = new PrintWriter( new FileWriter( _logFile, true ) );
                pw.println( _servletName + "(" + level + "): " + string );
                if ( throwable != null )
                {
                    throwable.printStackTrace( pw );
                }
                pw.close();
                // Do a return here. An exception will cause a fall through to
                // do _servletContex logging API
                return;
            }
            catch ( IOException ioe )
            {
                /* just ignore */
            }
        }

        // Otherwise, write to servlet context log
        if ( throwable == null )
        {
            _servletContext.log( string );
        }
        else
        {
            _servletContext.log( string, throwable );
        }
    }
48620
private static function log(string $level, string $message, array $context = [])
    {
        if (static::$logger !== null) {
            static::$logger->$level($message, $context);
        }
    }