org.slf4j.helpers.MessageFormatter Java Examples

/**
 * Stop a timer based upon a provided key.
 *
 * @param key key for timer
 * @return time elapsed in millis
 */
long stop(final String key) {
    if (key == null || key.isEmpty()) {
        throw new IllegalArgumentException(
            "Timer key cannot be null or empty."
        );
    }
    if (!startValuesMs.containsKey(key)) {
        throw new IllegalStateException(
            MessageFormatter.format("The timer key {} does not exist in this instance of {}", key, getClass().toString()).getMessage()
        );
    }

    // This gets the value and then removes it, so we could in theory start this key again with a fresh timer
    final long startTimeMs = startValuesMs.remove(key);
    final long stopTimeMs = getClock().millis();

    return stopTimeMs - startTimeMs;
}
 

private static void doReportIssue(Logger logger, Object subject, String format, Object[] arguments) {

        FormattingTuple formattingTuple = MessageFormatter.arrayFormat(format, arguments);
        StackTraceElement[] stackTrace = new Exception().getStackTrace();
        Throwable throwable = formattingTuple.getThrowable();

        if (throwable == null) {
            logger.error("Report this {} issue to ensure it is addressed:\n[{}]\n[{}]\n[{}]",
                codeSource, subject, stackTrace[2], formattingTuple.getMessage()
            );
        } else {
            logger.error("Report this {} issue to ensure it is addressed:\n[{}]\n[{}]\n[{}{}]",
                codeSource, subject, stackTrace[2], formattingTuple.getMessage(),
                ExceptionUtils.getStackTrace(throwable)
            );
        }
    }
 

private LogRecord eventToRecord(LoggingEvent event, Level julLevel) {
    String format = event.getMessage();
    Object[] arguments = event.getArgumentArray();
    FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
    if (ft.getThrowable() != null && event.getThrowable() != null) {
        throw new IllegalArgumentException("both last element in argument array and last argument are of type Throwable");
    }

    Throwable t = event.getThrowable();
    if (ft.getThrowable() != null) {
        t = ft.getThrowable();
        throw new IllegalStateException("fix above code");
    }

    LogRecord record = new LogRecord(julLevel, ft.getMessage());
    record.setLoggerName(event.getLoggerName());
    record.setMillis(event.getTimeStamp());
    record.setSourceClassName(EventConstants.NA_SUBST);
    record.setSourceMethodName(EventConstants.NA_SUBST);

    record.setThrown(t);
    return record;
}
 

@Override
public void trace(String format, Object... args) {
    if (isTraceEnabled()) {
        FormattingTuple ft = MessageFormatter.arrayFormat(format, args);
        log.log(null, callerFQCN, LocationAwareLogger.TRACE_INT, ft.getMessage(), NULL_ARGS, ft.getThrowable());
    }
}
 

/**
 * append log with pattern
 *
 * @param appendLogPattern   like "aaa {} bbb {} ccc"
 * @param appendLogArguments like "111, true"
 */
public static void log(String appendLogPattern, Object... appendLogArguments) {

    FormattingTuple ft = MessageFormatter.arrayFormat(appendLogPattern, appendLogArguments);
    String appendLog = ft.getMessage();

    /*appendLog = appendLogPattern;
    if (appendLogArguments!=null && appendLogArguments.length>0) {
        appendLog = MessageFormat.format(appendLogPattern, appendLogArguments);
    }*/

    StackTraceElement callInfo = new Throwable().getStackTrace()[1];
    logDetail(callInfo, appendLog);
}
 

private void logWarn(StringBuilder errorMessageReceiver, String format, Object... args) {
    if (LOG.isWarnEnabled()) {
        final String message = MessageFormatter.arrayFormat(format, args).getMessage();
        LOG.warn(message, args);
        if (errorMessageReceiver != null) {
            errorMessageReceiver.append(message).append('\n');
        }
    }
}
 

/**
 * append log with pattern
 *
 * @param appendLogPattern  like "aaa {} bbb {} ccc"
 * @param appendLogArguments    like "111, true"
 */
public static void log(String appendLogPattern, Object ... appendLogArguments) {

	FormattingTuple ft = MessageFormatter.arrayFormat(appendLogPattern, appendLogArguments);
    String appendLog = ft.getMessage();

    /*appendLog = appendLogPattern;
    if (appendLogArguments!=null && appendLogArguments.length>0) {
        appendLog = MessageFormat.format(appendLogPattern, appendLogArguments);
    }*/

    StackTraceElement callInfo = new Throwable().getStackTrace()[1];
    logDetail(callInfo, appendLog);
}
 

/**
 * append log with pattern
 *
 * @param appendLogPattern   like "aaa {} bbb {} ccc"
 * @param appendLogArguments like "111, true"
 */
public static void log(String appendLogPattern, Object... appendLogArguments) {

    FormattingTuple ft = MessageFormatter.arrayFormat(appendLogPattern, appendLogArguments);
    String appendLog = ft.getMessage();

    /*appendLog = appendLogPattern;
    if (appendLogArguments!=null && appendLogArguments.length>0) {
        appendLog = MessageFormat.format(appendLogPattern, appendLogArguments);
    }*/

    StackTraceElement callInfo = new Throwable().getStackTrace()[1];
    logDetail(callInfo, appendLog);
}
 

@Override
public void error(final String format, final Object arg) {
    if (!error) {
        return;
    }
    log("ERROR", MessageFormatter.format(format, arg).getMessage(), null, System.err);
}
 

@Override
public void warn(final String format, final Object... arguments) {
    if (!warn) {
        return;
    }
    log("WARN", MessageFormatter.arrayFormat(format, arguments).getMessage(), null, System.out);
}
 

@Override
public void info(final String format, final Object arg1, final Object arg2) {
    if (!info) {
        return;
    }
    log("INFO", MessageFormatter.format(format, arg1, arg1).getMessage(), null, System.out);
}
 

public static String getText(String key,Object... args){
    String localization = threadLocalization.get();
    if(localization == null){
        log.warn("localization is not in threadLocalization,check it !");
        localization = DefaultLocalization;
    }
    Properties properties = messages.get(localization);
    if(properties == null){
        properties = messages.get(DefaultLocalization);
    }
    FormattingTuple formattingTuple = MessageFormatter.arrayFormat(properties.getProperty(key),args);
    return formattingTuple.getMessage();
}
 

@Override
public void debug(final String format, final Object... arguments) {
    if (!debug) {
        return;
    }
    log("DEBUG", MessageFormatter.arrayFormat(format, arguments).getMessage(), null, System.out);
}
 

public void error(String msg, Object... arguments)
{
  if (isErrorEnabled())
  {
    FormattingTuple ft = MessageFormatter.arrayFormat(
        msg, evaluateLambdaArgs(arguments));
    this.error(SecretDetector.maskSecrets(ft.getMessage()));
  }
}
 

/**
 * append log with pattern
 *
 * @param appendLogPattern  like "aaa {} bbb {} ccc"
 * @param appendLogArguments    like "111, true"
 */
public static void log(String appendLogPattern, Object ... appendLogArguments) {

	FormattingTuple ft = MessageFormatter.arrayFormat(appendLogPattern, appendLogArguments);
    String appendLog = ft.getMessage();

    /**appendLog = appendLogPattern;
    if (appendLogArguments!=null && appendLogArguments.length>0) {
        appendLog = MessageFormat.format(appendLogPattern, appendLogArguments);
    }*/

    StackTraceElement callInfo = new Throwable().getStackTrace()[1];
    logDetail(callInfo, appendLog);
}
 

@Override
public void debug(final String format, final Object arg1, final Object arg2) {
    if (!debug) {
        return;
    }
    log("DEBUG", MessageFormatter.format(format, arg1, arg1).getMessage(), null, System.out);
}
 

@Override
public void trace(final String format, final Object arg1, final Object arg2) {
    if (!trace) {
        return;
    }
    log("TRACE", MessageFormatter.format(format, arg1, arg1).getMessage(), null, System.out);
}
 

private void formatAndAppend(String format, Object... arguments) {
    if (appender == null) {
        return;
    }
    FormattingTuple tp = MessageFormatter.arrayFormat(format, arguments);
    append(tp.getMessage());
}
 

@Override
public void error(String format, Object... args) {
    if (isErrorEnabled()) {
        FormattingTuple ft = MessageFormatter.arrayFormat(format, args);
        JbootExceptionHolder.hold(ft.getMessage(), ft.getThrowable());
        log.log(null, callerFQCN, LocationAwareLogger.ERROR_INT, ft.getMessage(), NULL_ARGS, ft.getThrowable());
    }
}
 

public void debug(String msg, Object... arguments)
{
  // use this as format example for JDK14Logger.
  if (isDebugEnabled())
  {
    FormattingTuple ft = MessageFormatter.arrayFormat(
        msg, evaluateLambdaArgs(arguments));
    this.debug(SecretDetector.maskSecrets(ft.getMessage()));
  }
}
 

@Override
public void doLog(Marker marker, Level level, String format, Supplier<?>[] argSuppliers, Throwable t) {
    if (!LambdaLoggerUtils.isLogLevelEnabled(underlyingLogger, level, marker)) {
        return;
    }

    if (argSuppliers == null) {
        logFormatted(marker, level, format, t);
    } else {
        FormattingTuple formattingTuple = MessageFormatter.arrayFormat(format, argSuppliersToArgs(argSuppliers), t);
        logFormatted(marker, level, formattingTuple.getMessage(), formattingTuple.getThrowable());
    }
}
 

/**
 * 审计日志
 * @param message
 * @param os
 * @throws Exception
 */
public void log1(String message, Object... os){
	try {
		if (Config.logLevel().audit().enable()) {
			Date end = new Date();
			long elapsed = end.getTime() - start.getTime();
			PrintStream stream = (PrintStream) Config.resource(Config.RESOURCE_AUDITLOGPRINTSTREAM);
			stream.printf("%tF %tT,,,%d,,,%s,,,%s,,,%s,,,%s,,,%s,,,%s%n", end, end, elapsed, this.person,
					this.remoteAddress, this.uri, this.userAgent, this.className,
					MessageFormatter.arrayFormat(Objects.toString(message, ""), os).getMessage());
		}
	} catch (Exception e) {
		System.out.println("审计日志打印异常"+e.getMessage());
	}
}
 

@Override
public void debug ( final String message, final Object... arguments )
{
    if ( Boolean.getBoolean ( PROP_ENABLE_DEBUG ) )
    {
        log ( Severity.INFORMATION, MessageFormatter.arrayFormat ( message, arguments ).getMessage (), null );
    }
}
 

Object getValue(Widget widget)
{
	Object value = getter.apply(widget);
	// These types are handled by the JTable automatically
	if (value instanceof Boolean || value instanceof Number || value instanceof String)
	{
		return value;
	}
	return MessageFormatter.format("{}", value).getMessage();
}
 

private static String format(String message, Object... os) {
	return MessageFormatter.arrayFormat(message, os).getMessage();
}
 

public boolean fail(String message, Object... args) {
  final String s = message == null
      ? null : MessageFormatter.arrayFormat(message, args).getMessage();
  throw new AssertionError(s);
}
 

private String format(String field, Object... args) {
    return MessageFormatter.arrayFormat(field, args).getMessage();
}
 

public boolean fail(String message, Object... args) {
  final String s = message == null
      ? null : MessageFormatter.arrayFormat(message, args).getMessage();
  throw new AssertionError(s);
}
 

private void log(Message.Level level, String format, Object... arguments) {
    level = relevel(level);
    if (level.compareTo(logLevel.get()) >= 0) {
        add(level, MessageFormatter.arrayFormat(format, arguments));
    }
}
 

public static List<DatasetSplit> getDatasetSplits(TableMetadata tableMetadata,
                                                  MetadataAccumulator metadataAccumulator,
                                                  PartitionMetadata partitionMetadata,
                                                  StatsEstimationParameters statsParams) {

  // This should be checked prior to entry.
  if (!partitionMetadata.getInputSplitBatchIterator().hasNext()) {
    throw UserException
      .dataReadError()
      .message("Splits expected but not available for table: '{}', partition: '{}'",
        tableMetadata.getTable().getTableName(),
        getPartitionValueLogString(partitionMetadata.getPartition()))
      .build(logger);
  }

  final List<InputSplit> inputSplits = partitionMetadata.getInputSplitBatchIterator().next();

  if (logger.isTraceEnabled()) {
    if (partitionMetadata.getPartitionValues().isEmpty()) {
      logger.trace("Getting {} datasetSplits for default partition",
        inputSplits.size());
    } else {
      logger.trace("Getting {} datasetSplits for hive partition '{}'",
        inputSplits.size(),
        getPartitionValueLogString(partitionMetadata.getPartition()));
    }
  }

  if (inputSplits.isEmpty()) {
    /**
     * Not possible.
     * currentHivePartitionMetadata.getInputSplitBatchIterator().hasNext() means inputSplits
     * exist.
     */
    throw new RuntimeException(
      MessageFormatter.format("Table '{}', partition '{}', Splits expected but not available for table.",
        tableMetadata.getTable().getTableName(),
        getPartitionValueLogString(partitionMetadata.getPartition()))
        .getMessage());
  }

  final List<DatasetSplit> datasetSplits = new ArrayList<>(inputSplits.size());

  final List<Long> inputSplitSizes = getInputSplitSizes(
    partitionMetadata.getDatasetSplitBuildConf().getJob(),
    tableMetadata.getTable().getTableName(),
    inputSplits);

  final long totalSizeOfInputSplits = inputSplitSizes.stream().mapToLong(Long::longValue).sum();
  final int estimatedRecordSize = tableMetadata.getBatchSchema().estimateRecordSize(statsParams.getListSizeEstimate(), statsParams.getVarFieldSizeEstimate());

  metadataAccumulator.accumulateTotalBytesToScanFactor(totalSizeOfInputSplits);

  for (int i = 0; i < inputSplits.size(); i++) {
    final InputSplit inputSplit = inputSplits.get(i);
    final long inputSplitLength = inputSplitSizes.get(i);

    final long splitEstimatedRecords = findRowCountInSplit(
      statsParams,
      partitionMetadata.getDatasetSplitBuildConf().getMetastoreStats(),
      inputSplitLength / (double) totalSizeOfInputSplits,
      inputSplitLength,
      partitionMetadata.getDatasetSplitBuildConf().getFormat(),
      estimatedRecordSize);

    metadataAccumulator.accumulateTotalEstimatedRecords(splitEstimatedRecords);

    try {
      datasetSplits.add(
        DatasetSplit.of(
          Arrays.stream(inputSplit.getLocations())
            .map((input) -> DatasetSplitAffinity.of(input, inputSplitLength))
            .collect(ImmutableList.toImmutableList()),
          inputSplitSizes.get(i),
          splitEstimatedRecords,
          os -> os.write(buildHiveSplitXAttr(partitionMetadata.getPartitionId(), inputSplit).toByteArray())));
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

  return datasetSplits;
}