/* (non-Javadoc)
@see java.util.logging.Logger#logrb(java.util.logging.Level, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.Throwable)
358288
@Override
	public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg,
			Throwable thrown) {
		
		super.logrb(level, sourceClass, sourceMethod, bundleName, maskPassword(msg), thrown);
	}
1259375
public void logStackTrace (int level, String moduleName, Throwable t)
    {
        getLogger(moduleName).log(getLevel(level), "", t);
    }
134641
@Override
  public void logException(LogLevel logLevel, Throwable throwable, Class clazz, String methodName) {
    Logger logger = Logger.getLogger(clazz.getName());
    logger.logp(convertToJDK14Level(logLevel), clazz.getName(), "-", throwable.getMessage(), throwable);
  }
653598
private void log(final String level,
                   final String message,
                   final Throwable t) {
    StringBuffer buf = new StringBuffer();

    long millis  = System.currentTimeMillis();
    buf.append(millis - startTime);

    buf.append(" [");
    buf.append(Thread.currentThread().getName());
    buf.append("] ");

    buf.append(level);
    buf.append(" ");

    buf.append(loggerName);
    buf.append(" - ");

    buf.append(message);

    buf.append(LINE_SEPARATOR);

    System.out.print(buf.toString());
    if (t != null) {
      t.printStackTrace(System.out);
    }
    System.out.flush();
  }
165550
private static int logger(int level, String message, Throwable throwable) {

        if (QuickUtils.shouldShowLogs()) {
            switch (level) {

                case QuickUtils.DEBUG:
                    return android.util.Log.d(QuickUtils.TAG, message, throwable);
                case QuickUtils.VERBOSE:
                    return android.util.Log.v(QuickUtils.TAG, message, throwable);
                case QuickUtils.INFO:
                    return android.util.Log.i(QuickUtils.TAG, message, throwable);
                case QuickUtils.WARN:
                    return android.util.Log.w(QuickUtils.TAG, message, throwable);
                case QuickUtils.ERROR:
                    return android.util.Log.e(QuickUtils.TAG, message, throwable);
                default:
                    break;
            }
        }

        return -1;
    }
373063
protected String formatLogMessage(LogLevel level,Object[] message,Throwable throwable)
    {
        //get text
        String messageText=this.format(message);
        String throwableText=this.format(throwable);
        
        //init buffer
        StringBuilder buffer=new StringBuilder();

        //append prefix
        buffer.append("[fax4j][");
        buffer.append(level.getName());
        buffer.append("] ");
        
        if(messageText!=null)
        {
            buffer.append(messageText);
            
            if(throwableText!=null)
            {
                buffer.append(Logger.SYSTEM_EOL);
                buffer.append(throwableText);
            }
        }
        else if(throwableText!=null)
        {
            buffer.append(throwableText);
        }
        
        //get text
        String text=buffer.toString();
    
        return text;
    }
1072049
protected void writePropertiesToLog(Logger logger, Level level) {
    writeToLog(logger, level, getMapAsString(this.properties, separator), null);

    if (this.exception != null) {
      writeToLog(this.logger, Level.ERROR, "Error:", this.exception);
    }
  }
968826
private static <T> void _logResult(T result, int level, int indentSize, StringBuilder info) {
        if(result instanceof Map) {
            level += 1;
            int finalLevel = level;
            ((Map)result).forEach((k, v) -> {
                info.append("\n");
                info.append(getTabBasedOnLevel(finalLevel, indentSize))
                        .append(k.toString())
                        .append(":");
                _logResult(v, finalLevel, indentSize, info);
            });
        } else if(result instanceof List) {
            int finalLevel = level;
            ((List)result).forEach(element -> _logResult(element, finalLevel, indentSize, info));
        } else if(result instanceof String) {
            info.append(" ").append(result);
        } else if(result != null) {
            try {
                logger.warn(getTabBasedOnLevel(level, indentSize) + "{}", result);
            } catch (Exception e) {
                logger.error("Cannot handle this type: {}", result.getClass().getTypeName());
            }
        }
    }
184150
@Nullable
    public String getLoggerLevel(@Nullable String loggerName) {
        try {
            loggerName = loggerName == null ? "" : loggerName;
            if (loggerName.isEmpty()) {
                return LogManager.getRootLogger().getLevel().toString();
            }

            Logger logger = LogManager.exists(loggerName);
            if (logger == null) {
                return null;
            } else {
                Level level = logger.getLevel();
                if (level == null) {
                    return null;
                }
                return level.toString();
            }
        } catch (RuntimeException e) {
            logger.warn("Exception getting effective logger level " + loggerName, e);
            throw e;
        }
    }
1053496
private void logIfEnabled(String callerFQCN, Level level, Throwable throwable, String format, Object[] arguments){
		if(logger.isLoggable(level)){
			LogRecord record = new LogRecord(level, StrUtil.format(format, arguments));
			record.setLoggerName(getName());
			record.setThrown(throwable);
			fillCallerData(callerFQCN, record);
			logger.log(record);
		}
	}
607941
public Level tango_to_log4j_level(String level)
  {
   level = level.toUpperCase();
   if (level.equals(LOGGING_LEVELS[LOGGING_OFF])) {
     return Level.OFF;
   }
   if (level.equals(LOGGING_LEVELS[LOGGING_FATAL])) {
     return Level.FATAL;
   }
   if (level.equals(LOGGING_LEVELS[LOGGING_ERROR])) {
     return Level.ERROR;
   }
   if (level.equals(LOGGING_LEVELS[LOGGING_INFO])) {
     return Level.INFO;
   }
   if (level.equals(LOGGING_LEVELS[LOGGING_DEBUG])) {
     return Level.DEBUG;
   }
   return Level.WARN;
  }
1374632
public void logv(Level level, Throwable t, String format, Object... params) {
        doLog(level, FQCN, format, params, t);
    }
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);
        }
    }
341300
public void log(java.util.logging.Level level, CharSequence message) {
    LogRecord rec = new ELKILogRecord(level, message);
    logger.log(rec);
  }
1098562
public void log(Level level, Object message) throws IllegalArgumentException {
        log(level, message, null);
    }
929833
void log(Level level, String msg, Exception e) {
        if (e != null)
            logger.log(level, msg, e);
    }
1284058
public static void i(String tag, String msg, Throwable throwable) {
        if (sLevel > LEVEL_INFO) {
            return;
        }
        Log.i(tag, msg, throwable);
    }