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