Upstream/Yatopia
1
0
Fork 0
mirror of https://github.com/YatopiaMC/Yatopia.git synced 2024-11-29 22:23:50 +01:00
Code Issues Projects Releases Wiki Activity
4c9897d1b4
Yatopia/patches/server/0067-Fix-Log4j-Warning.patch
Simon Gardling 6e5e95f492 drop cadmium
2021-05-12 11:32:44 -04:00

263 lines
11 KiB
Diff
Raw Blame History

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: snoopdoooggyttv <snoopdoooggyttv@users.noreply.github.com>
Date: Wed, 5 May 2021 20:32:22 +0200
Subject: [PATCH] Fix Log4j Warning
diff --git a/src/main/java/org/apache/logging/log4j/util/StackLocator.java b/src/main/java/org/apache/logging/log4j/util/StackLocator.java
new file mode 100644
index 0000000000000000000000000000000000000000..44161840e64946b4b6ce0483495304809d15ade8
--- /dev/null
+++ b/src/main/java/org/apache/logging/log4j/util/StackLocator.java
@@ -0,0 +1,250 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.util;
+
+import java.lang.reflect.Method;
+import java.util.Stack;
+
+/**
+ * <em>Consider this class private.</em> Provides various methods to determine the caller class. <h3>Background</h3>
+ * <p>
+ * This method, available only in the Oracle/Sun/OpenJDK implementations of the Java Virtual Machine, is a much more
+ * efficient mechanism for determining the {@link Class} of the caller of a particular method. When it is not available,
+ * a {@link SecurityManager} is the second-best option. When this is also not possible, the {@code StackTraceElement[]}
+ * returned by {@link Throwable#getStackTrace()} must be used, and its {@code String} class name converted to a
+ * {@code Class} using the slow {@link Class#forName} (which can add an extra microsecond or more for each invocation
+ * depending on the runtime ClassLoader hierarchy).
+ * </p>
+ * <p>
+ * During Java 8 development, the {@code sun.reflect.Reflection.getCallerClass(int)} was removed from OpenJDK, and this
+ * change was back-ported to Java 7 in version 1.7.0_25 which changed the behavior of the call and caused it to be off
+ * by one stack frame. This turned out to be beneficial for the survival of this API as the change broke hundreds of
+ * libraries and frameworks relying on the API which brought much more attention to the intended API removal.
+ * </p>
+ * <p>
+ * After much community backlash, the JDK team agreed to restore {@code getCallerClass(int)} and keep its existing
+ * behavior for the rest of Java 7. However, the method is deprecated in Java 8, and current Java 9 development has not
+ * addressed this API. Therefore, the functionality of this class cannot be relied upon for all future versions of Java.
+ * It does, however, work just fine in Sun JDK 1.6, OpenJDK 1.6, Oracle/OpenJDK 1.7, and Oracle/OpenJDK 1.8. Other Java
+ * environments may fall back to using {@link Throwable#getStackTrace()} which is significantly slower due to
+ * examination of every virtual frame of execution.
+ * </p>
+ */
+public final class StackLocator {
+
+ // Checkstyle Suppress: the lower-case 'u' ticks off CheckStyle...
+ // CHECKSTYLE:OFF
+ static final int JDK_7u25_OFFSET;
+ // CHECKSTYLE:OFF
+
+ private static final Method GET_CALLER_CLASS;
+
+ private static final StackLocator INSTANCE;
+
+ static {
+ Method getCallerClass;
+ int java7u25CompensationOffset = 0;
+ try {
+ final Class<?> sunReflectionClass = LoaderUtil.loadClass("sun.reflect.Reflection");
+ getCallerClass = sunReflectionClass.getDeclaredMethod("getCallerClass", int.class);
+ Object o = getCallerClass.invoke(null, 0);
+ getCallerClass.invoke(null, 0);
+ if (o == null || o != sunReflectionClass) {
+ getCallerClass = null;
+ java7u25CompensationOffset = -1;
+ } else {
+ o = getCallerClass.invoke(null, 1);
+ if (o == sunReflectionClass) {
+ System.out.println("WARNING: Java 1.7.0_25 is in use which has a broken implementation of Reflection.getCallerClass(). " +
+ " Please consider upgrading to Java 1.7.0_40 or later.");
+ java7u25CompensationOffset = 1;
+ }
+ }
+ } catch (final Exception | LinkageError e) {
+ //System.out.println("WARNING: sun.reflect.Reflection.getCallerClass is not supported. This will impact performance."); // Yatopia - Fix Error Message
+ getCallerClass = null;
+ java7u25CompensationOffset = -1;
+ }
+
+ GET_CALLER_CLASS = getCallerClass;
+ JDK_7u25_OFFSET = java7u25CompensationOffset;
+
+ INSTANCE = new StackLocator();
+ }
+
+ public static StackLocator getInstance() {
+ return INSTANCE;
+ }
+
+ private StackLocator() {
+ }
+
+ // TODO: return Object.class instead of null (though it will have a null ClassLoader)
+ // (MS) I believe this would work without any modifications elsewhere, but I could be wrong
+
+ // migrated from ReflectiveCallerClassUtility
+ @PerformanceSensitive
+ public Class<?> getCallerClass(final int depth) {
+ if (depth < 0) {
+ throw new IndexOutOfBoundsException(Integer.toString(depth));
+ }
+ if (GET_CALLER_CLASS == null) {
+ return null;
+ }
+ // note that we need to add 1 to the depth value to compensate for this method, but not for the Method.invoke
+ // since Reflection.getCallerClass ignores the call to Method.invoke()
+ try {
+ return (Class<?>) GET_CALLER_CLASS.invoke(null, depth + 1 + JDK_7u25_OFFSET);
+ } catch (final Exception e) {
+ // theoretically this could happen if the caller class were native code
+ // TODO: return Object.class
+ return null;
+ }
+ }
+
+ // migrated from Log4jLoggerFactory
+ @PerformanceSensitive
+ public Class<?> getCallerClass(final String fqcn, final String pkg) {
+ return getCallerClass(fqcn, pkg, 0);
+ }
+
+ @PerformanceSensitive
+ public Class<?> getCallerClass(final String fqcn, final String pkg, final int skipDepth) {
+ if (skipDepth < 0) {
+ throw new IllegalArgumentException("skipDepth cannot be negative");
+ }
+ boolean next = false;
+ Class<?> clazz;
+ for (int i = 2; null != (clazz = getCallerClass(i)); i++) {
+ if (fqcn.equals(clazz.getName())) {
+ next = true;
+ continue;
+ }
+ if (next && clazz.getName().startsWith(pkg)) {
+ return skipDepth == 0
+ ? clazz
+ : getCallerClass(i + skipDepth);
+ }
+ }
+ // TODO: return Object.class
+ return null;
+ }
+
+ // added for use in LoggerAdapter implementations mainly
+ @PerformanceSensitive
+ public Class<?> getCallerClass(final Class<?> anchor) {
+ boolean next = false;
+ Class<?> clazz;
+ for (int i = 2; null != (clazz = getCallerClass(i)); i++) {
+ if (anchor.equals(clazz)) {
+ next = true;
+ continue;
+ }
+ if (next) {
+ return clazz;
+ }
+ }
+ return Object.class;
+ }
+
+ // migrated from ThrowableProxy
+ @PerformanceSensitive
+ public Stack<Class<?>> getCurrentStackTrace() {
+ // benchmarks show that using the SecurityManager is much faster than looping through getCallerClass(int)
+ if (PrivateSecurityManagerStackTraceUtil.isEnabled()) {
+ return PrivateSecurityManagerStackTraceUtil.getCurrentStackTrace();
+ }
+ // slower version using getCallerClass where we cannot use a SecurityManager
+ final Stack<Class<?>> classes = new Stack<>();
+ Class<?> clazz;
+ for (int i = 1; null != (clazz = getCallerClass(i)); i++) {
+ classes.push(clazz);
+ }
+ return classes;
+ }
+
+ public StackTraceElement calcLocation(final String fqcnOfLogger) {
+ if (fqcnOfLogger == null) {
+ return null;
+ }
+ // LOG4J2-1029 new Throwable().getStackTrace is faster than Thread.currentThread().getStackTrace().
+ final StackTraceElement[] stackTrace = new Throwable().getStackTrace();
+ boolean found = false;
+ for (int i = 0; i < stackTrace.length; i++) {
+ final String className = stackTrace[i].getClassName();
+ if (fqcnOfLogger.equals(className)) {
+
+ found = true;
+ continue;
+ }
+ if (found && !fqcnOfLogger.equals(className)) {
+ return stackTrace[i];
+ }
+ }
+ return null;
+ }
+
+ public StackTraceElement getStackTraceElement(final int depth) {
+ // (MS) I tested the difference between using Throwable.getStackTrace() and Thread.getStackTrace(), and
+ // the version using Throwable was surprisingly faster! at least on Java 1.8. See ReflectionBenchmark.
+ final StackTraceElement[] elements = new Throwable().getStackTrace();
+ int i = 0;
+ for (final StackTraceElement element : elements) {
+ if (isValid(element)) {
+ if (i == depth) {
+ return element;
+ }
+ ++i;
+ }
+ }
+ throw new IndexOutOfBoundsException(Integer.toString(depth));
+ }
+
+ private boolean isValid(final StackTraceElement element) {
+ // ignore native methods (oftentimes are repeated frames)
+ if (element.isNativeMethod()) {
+ return false;
+ }
+ final String cn = element.getClassName();
+ // ignore OpenJDK internal classes involved with reflective invocation
+ if (cn.startsWith("sun.reflect.")) {
+ return false;
+ }
+ final String mn = element.getMethodName();
+ // ignore use of reflection including:
+ // Method.invoke
+ // InvocationHandler.invoke
+ // Constructor.newInstance
+ if (cn.startsWith("java.lang.reflect.") && (mn.equals("invoke") || mn.equals("newInstance"))) {
+ return false;
+ }
+ // ignore use of Java 1.9+ reflection classes
+ if (cn.startsWith("jdk.internal.reflect.")) {
+ return false;
+ }
+ // ignore Class.newInstance
+ if (cn.equals("java.lang.Class") && mn.equals("newInstance")) {
+ return false;
+ }
+ // ignore use of Java 1.7+ MethodHandle.invokeFoo() methods
+ if (cn.equals("java.lang.invoke.MethodHandle") && mn.startsWith("invoke")) {
+ return false;
+ }
+ // any others?
+ return true;
+ }
+}
Reference in New Issue View Git Blame Copy Permalink