Force usage of System.out and System.err to go through the calling class's logger.

Combined with better-log4j-config, this will properly blame the class that logged to the wrong thing.

Note: if it is somewhere in Minecraft, this may fail to give enough information and need to be made more thorough.

We don't really consider raw System.out/System.err to be performance critical so a marginal hit can be taken if necessary.

Author: Ampflower

src/main/java/net/modfest/fireblanket/mixin/annoyances/stdio/MixinLoggedPrintStream.java

@@ -0,0 +1,20 @@
+package net.modfest.fireblanket.mixin.annoyances.stdio;
+
+import net.minecraft.server.LoggedPrintStream;
+import net.modfest.fireblanket.stacksmash.StackUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+/**
+ * @author Ampflower
+ **/
+@Mixin(LoggedPrintStream.class)
+public class MixinLoggedPrintStream {
+	@Redirect(method = "logLine", at = @At(value = "INVOKE", target = "Lorg/slf4j/Logger;info(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V"))
+	private static void onLog(final Logger instance, final String format, final Object name, final Object value) {
+		LoggerFactory.getLogger(StackUtil.getCallerAsProxy(1).getDeclaringClass()).info(format, name, value);
+	}
+}

src/main/java/net/modfest/fireblanket/stacksmash/StackTracer.java

@@ -34,7 +34,7 @@ public final class StackTracer implements Guard, Stack, Tracer {
 			return;
 		}
 
-		final StackFrame current = StackUtil.getCaller(stackDepth);
+		final StackFrame current = StackUtil.getCallerAsProxy(stackDepth);
 		this.frames.push(current);
 	}
 
@@ -43,15 +43,15 @@ public final class StackTracer implements Guard, Stack, Tracer {
 	public boolean fireblanket$pop(int stackDepth) {
 		if (this.fireblanket$guardCheck()) {
 			final StackFrame peek = this.frames.peek();
-			throw new StackSmashException(peek, StackUtil.getCaller(stackDepth));
+			throw new StackSmashException(peek, StackUtil.getCallerAsProxy(stackDepth));
 			//logger.warn("Guard check: attempted to pop {}", peek, );
 			//return false;
 		}
 
 		final StackFrame trace = this.frames.pop();
 
 		if (this.level != TraceLevel.NONE) {
-			final StackFrame current = StackUtil.getCaller(stackDepth);
+			final StackFrame current = StackUtil.getCallerAsProxy(stackDepth);
 
 			this.level.logIfMismatched(trace, current);
 		}
@@ -63,15 +63,15 @@ public final class StackTracer implements Guard, Stack, Tracer {
 	public void fireblanket$startTrace(final @NotNull TraceLevel level, final int depth) {
 		if (this.frames.size() != 0) {
 			this.frames.poll();
-			this.frames.push(StackUtil.getCaller(3));
+			this.frames.push(StackUtil.getCallerAsProxy(3));
 		}
 		this.level = level;
 		this.startingTraceDepth = this.frames.size();
 	}
 
 	@Override
 	public void fireblanket$stopTrace(final int depth) {
-		final StackFrame frame = StackUtil.getCaller(3);
+		final StackFrame frame = StackUtil.getCallerAsProxy(3);
 		final StackFrame trace = this.frames.peek();
 
 		this.level.logIfMismatched(trace, frame);

src/main/java/net/modfest/fireblanket/stacksmash/StackUtil.java

@@ -9,6 +9,7 @@
 import org.slf4j.Logger;
 
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.Objects;
 import java.util.Set;
 
@@ -70,6 +71,8 @@ public final class StackUtil {
 		}
 	}
 
+	// TODO: admittedly, this isn't exactly intuitive, as I had to make a mini-diagnostic to
+	//  figure out the depth I actually needed.
 	/**
 	 * Fetches the stack frame of the caller, skipping over
 	 * {@link #knownSkippableClasses known skippable classes}.
@@ -82,8 +85,8 @@ public final class StackUtil {
 	 * 	due to an optimization to avoid an expensive {@link String#startsWith(String)} call.
 	 */
 	@CheckReturnValue
-	static StackWalker.StackFrame getCaller(final int depth) {
-		// walker + self + caller to be skipped
+	public static StackWalker.StackFrame getCallerAsProxy(final int depth) {
+		// self + caller as proxy + caller to be skipped
 		final int lambdaDepth = depth + 3;
 		return walker.walk(stream -> stream
 			.skip(lambdaDepth)
@@ -92,6 +95,41 @@ static StackWalker.StackFrame getCaller(final int depth) {
 		).orElseThrow();
 	}
 
+	/**
+	 * Mini-diagnostic for aiding in what depth should be added to {@link #getCallerAsProxy(int)}
+	 * to get the desired result.
+	 *
+	 * @param depth The amount that you think you need to skip.
+	 * @return The caller, either yours or your proxy's.
+	 * @implSpec This function shall operate the same as {@link #getCallerAsProxy(int)} to allow drop-in debugging,
+	 * 	with the sole exception of returning {@link TraceElement#nullFrame an empty frame} when it would otherwise fail.
+	 *
+	 */
+	public static StackWalker.StackFrame printCallStackAsProxy(final int depth) {
+		final int lambdaDepth = depth + 3;
+		return walker.walk(stream -> {
+			StackWalker.StackFrame returnedFrame = null;
+			int i = 0;
+			final Iterator<StackWalker.StackFrame> itr = stream.iterator();
+			while (itr.hasNext()) {
+				final StackWalker.StackFrame frame = itr.next();
+				final int relativeDepth = i - lambdaDepth;
+				final boolean skipped = isSkippableClass(frame.getDeclaringClass());
+
+				logger.info("{} => {} ({})", relativeDepth, frame, skipped ? "skippable" : "retained");
+
+				if (relativeDepth >= 0 && !skipped && returnedFrame == null) {
+					logger.info("^-^ returned");
+					returnedFrame = frame;
+				}
+
+				i++;
+			}
+
+			return Objects.requireNonNullElse(returnedFrame, TraceElement.nullFrame);
+		});
+	}
+
 	static boolean isSkippableClass(final Class<?> clazz) {
 		// If it came from Java, we don't care about it.
 		// Usually, this means it was a reflection frame.

src/main/resources/fireblanket.mixins.json

@@ -31,6 +31,7 @@
 		"annoyances.MixinServerPlayNetworkHandler",
 		"annoyances.MixinUtil",
 		"annoyances.lightning.MixinServerChunkLoadingManager",
+		"annoyances.stdio.MixinLoggedPrintStream",
 		"be_sync.MixinBlockEntity",
 		"be_sync.MixinChunkHolder",
 		"block.AccessorUpdateCommandBlockMinecartC2SPacket",