diff --git a/src/main/java/org/spongepowered/asm/logging/LoggerAdapterAbstract.java b/src/main/java/org/spongepowered/asm/logging/LoggerAdapterAbstract.java index 9e767976..496a60e0 100644 --- a/src/main/java/org/spongepowered/asm/logging/LoggerAdapterAbstract.java +++ b/src/main/java/org/spongepowered/asm/logging/LoggerAdapterAbstract.java @@ -25,11 +25,77 @@ package org.spongepowered.asm.logging; /** - * Abstract base adapter which contains convenience methods for formatting + * Abstract base adapter which contains a convenience class for formatting * log4j2-style messages and also routes all level-specific overloads to calls * to log, which can simplify some implementations. */ public abstract class LoggerAdapterAbstract implements ILogger { + + /** + * This is a very naive implementation of log4j2's ParameterizedMessage + * which is less efficient and less defensive because it doesn't need + * to handle all the cases that the log4j2 formatter does. All we're really + * doing here is substituting in the values for {} placeholders + * because I know that in mixin there aren't any cases where we need to + * handle anything else, such as escaped { characters or whatever. + * It also handles the case where the last param of the varargs is a + * Throwable, and makes it available to consumers. + */ + public static class FormattedMessage { + + private String message; + + private Throwable t; + + /** + * Create a new formatted message + * + * @param message Message patterm + * @param params Message parameters + */ + public FormattedMessage(String message, Object... params) { + if (params.length == 0) { + this.message = message; + return; + } + StringBuilder sb = new StringBuilder(); + int pos = 0, param = 0; + for (; pos < message.length() && param < params.length; param++) { + int delimPos = message.indexOf("{}", pos); + if (delimPos < 0) { + break; + } + sb.append(message.substring(pos, delimPos)).append(params[param]); + pos = delimPos + 2; + } + if (pos < message.length()) { + sb.append(message.substring(pos)); + } + // If last arg is throwable and not consumed by the message, store it + if (param < params.length && params[params.length - 1] instanceof Throwable) { + this.t = (Throwable)params[params.length - 1]; + } + this.message = sb.toString(); + } + + @Override + public String toString() { + return this.message; + } + + public String getMessage() { + return this.message; + } + + public boolean hasThrowable() { + return this.t != null; + } + + public Throwable getThrowable() { + return this.t; + } + + } /** * Logger id @@ -51,39 +117,6 @@ public abstract class LoggerAdapterAbstract implements ILogger { return this.id; } - /** - * This is a very naive implementation of log4j2's - * ParameterizedMessage::format method which is less efficient and less - * defensive because it doesn't need to handle all the cases that the log4j2 - * formatter does. All we're really doing here is substituting in the values - * for {} placeholders because I know that in mixin there aren't - * any cases where we need to handle anything else, such as escaped { - * characters or whatever. - * - * @param message Message patterm - * @param params Message parameters - * @return Message with {} placeholders filled in - */ - protected static String getFormattedMessage(String message, Object... params) { - if (params.length == 0) { - return message; - } - StringBuilder sb = new StringBuilder(); - int pos = 0; - for (int param = 0; pos < message.length() && param < params.length; param++) { - int delimPos = message.indexOf("{}", pos); - if (delimPos < 0) { - return sb.append(message.substring(pos)).toString(); - } - sb.append(message.substring(pos, delimPos)).append(params[param]); - pos = delimPos + 2; - } - if (pos < message.length()) { - sb.append(message.substring(pos)); - } - return sb.toString(); - } - @Override public void catching(Throwable t) { this.catching(Level.WARN, t); diff --git a/src/main/java/org/spongepowered/asm/logging/LoggerAdapterConsole.java b/src/main/java/org/spongepowered/asm/logging/LoggerAdapterConsole.java index c074bd0a..fa67e9e3 100644 --- a/src/main/java/org/spongepowered/asm/logging/LoggerAdapterConsole.java +++ b/src/main/java/org/spongepowered/asm/logging/LoggerAdapterConsole.java @@ -71,15 +71,18 @@ public class LoggerAdapterConsole extends LoggerAdapterAbstract { @Override public void catching(Level level, Throwable t) { - this.log(Level.WARN, "Catching", t); + this.log(Level.WARN, "Catching {}: {}", t.getClass().getName(), t.getMessage(), t); } @Override public void log(Level level, String message, Object... params) { PrintStream out = this.getOutputStream(level); if (out != null) { - String formatted = LoggerAdapterAbstract.getFormattedMessage(message, params); + FormattedMessage formatted = new FormattedMessage(message, params); out.println(String.format("[%s] [%s/%s] %s", LoggerAdapterConsole.DATE_FORMAT.format(new Date()), this.getId(), level, formatted)); + if (formatted.hasThrowable()) { + formatted.getThrowable().printStackTrace(out); + } } } @@ -88,13 +91,13 @@ public class LoggerAdapterConsole extends LoggerAdapterAbstract { PrintStream out = this.getOutputStream(level); if (out != null) { out.println(String.format("[%s] [%s/%s] %s", LoggerAdapterConsole.DATE_FORMAT.format(new Date()), this.getId(), level, message)); - t.printStackTrace(); + t.printStackTrace(out); } } @Override public T throwing(T t) { - this.log(Level.WARN, "Throwing", t); + this.log(Level.WARN, "Throwing {}: {}", t.getClass().getName(), t.getMessage(), t); return t; } diff --git a/src/main/java/org/spongepowered/asm/logging/LoggerAdapterJava.java b/src/main/java/org/spongepowered/asm/logging/LoggerAdapterJava.java index b390515b..bc6aecbf 100644 --- a/src/main/java/org/spongepowered/asm/logging/LoggerAdapterJava.java +++ b/src/main/java/org/spongepowered/asm/logging/LoggerAdapterJava.java @@ -28,7 +28,8 @@ import java.util.logging.LogManager; import java.util.logging.Logger; /** - * Logger adapter which uses the + * Logger adapter which uses the built-in Java logging functionality to emit + * logging messages. */ public class LoggerAdapterJava extends LoggerAdapterAbstract { @@ -50,17 +51,21 @@ public class LoggerAdapterJava extends LoggerAdapterAbstract { @Override public String getType() { - return "Default Console Logger"; + return "java.util.logging Log Adapter"; } @Override public void catching(Level level, Throwable t) { - this.warn("Catching", t); + this.warn("Catching {}: {}", t.getClass().getName(), t.getMessage(), t); } @Override public void debug(String message, Object... params) { - this.logger.fine(LoggerAdapterAbstract.getFormattedMessage(message, params)); + FormattedMessage formatted = new FormattedMessage(message, params); + this.logger.fine(formatted.getMessage()); + if (formatted.hasThrowable()) { + this.logger.fine(formatted.getThrowable().toString()); + } } @Override @@ -71,7 +76,11 @@ public class LoggerAdapterJava extends LoggerAdapterAbstract { @Override public void error(String message, Object... params) { - this.logger.severe(LoggerAdapterAbstract.getFormattedMessage(message, params)); + FormattedMessage formatted = new FormattedMessage(message, params); + this.logger.severe(formatted.getMessage()); + if (formatted.hasThrowable()) { + this.logger.severe(formatted.getThrowable().toString()); + } } @Override @@ -82,7 +91,11 @@ public class LoggerAdapterJava extends LoggerAdapterAbstract { @Override public void fatal(String message, Object... params) { - this.logger.severe(LoggerAdapterAbstract.getFormattedMessage(message, params)); + FormattedMessage formatted = new FormattedMessage(message, params); + this.logger.severe(formatted.getMessage()); + if (formatted.hasThrowable()) { + this.logger.severe(formatted.getThrowable().toString()); + } } @Override @@ -93,7 +106,11 @@ public class LoggerAdapterJava extends LoggerAdapterAbstract { @Override public void info(String message, Object... params) { - this.logger.info(LoggerAdapterAbstract.getFormattedMessage(message, params)); + FormattedMessage formatted = new FormattedMessage(message, params); + this.logger.info(formatted.getMessage()); + if (formatted.hasThrowable()) { + this.logger.info(formatted.getThrowable().toString()); + } } @Override @@ -104,7 +121,12 @@ public class LoggerAdapterJava extends LoggerAdapterAbstract { @Override public void log(Level level, String message, Object... params) { - this.logger.log(LoggerAdapterJava.LEVELS[level.ordinal()], LoggerAdapterAbstract.getFormattedMessage(message, params)); + java.util.logging.Level logLevel = LoggerAdapterJava.LEVELS[level.ordinal()]; + FormattedMessage formatted = new FormattedMessage(message, params); + this.logger.log(logLevel, formatted.getMessage()); + if (formatted.hasThrowable()) { + this.logger.log(LoggerAdapterJava.LEVELS[level.ordinal()], formatted.getThrowable().toString()); + } } @Override @@ -116,13 +138,17 @@ public class LoggerAdapterJava extends LoggerAdapterAbstract { @Override public T throwing(T t) { - this.warn("Throwing", t); + this.warn("Throwing {}: {}", t.getClass().getName(), t.getMessage(), t); return t; } @Override public void trace(String message, Object... params) { - this.logger.finer(LoggerAdapterAbstract.getFormattedMessage(message, params)); + FormattedMessage formatted = new FormattedMessage(message, params); + this.logger.finer(formatted.getMessage()); + if (formatted.hasThrowable()) { + this.logger.finer(formatted.getThrowable().toString()); + } } @Override @@ -133,7 +159,11 @@ public class LoggerAdapterJava extends LoggerAdapterAbstract { @Override public void warn(String message, Object... params) { - this.logger.warning(LoggerAdapterAbstract.getFormattedMessage(message, params)); + FormattedMessage formatted = new FormattedMessage(message, params); + this.logger.warning(formatted.getMessage()); + if (formatted.hasThrowable()) { + this.logger.warning(formatted.getThrowable().toString()); + } } @Override