path: root/src/main/patch/houston/fixidiots.patch

  Why is it so fucking hard to just keep out all those random annoying logger
  implementations?!?

  Who the heck wants to configure all of them, and if ONE is missed just have
  all important error reports concealed to the nirvana? Who the fuck wants such
  shit?

  Please: STOP THIS SHIT! Libraries solely have to depend on slf4j. As its name
  already says, it is a FACADE! NOT AN IMPLEMENTATION! STOP MESSING THIS UP ALL
  THE TIME WITH YET ANOTHER NEW SHITTY NERDY LOGGER IMPL!


--- /dev/null
+++ b/houston-process/src/main/java/org/apache/logging/slf4j/Log4jLogger.java
@@ -0,0 +1,109 @@
+package org.apache.logging.slf4j;
+
+import org.apache.logging.log4j.spi.ExtendedLogger;
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+import org.slf4j.event.Level;
+import org.slf4j.spi.LocationAwareLogger;
+import org.slf4j.spi.LoggingEventBuilder;
+
+import java.io.Serializable;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+
+/** <p>FU** this fu***** damn sh** code that still tries to use log4j, no matter
+ * how strong we tell it NOT to use it!</p>
+ * <p>This class only exists to prevent services from starting if IDEA still did miss
+ * the dependency changes in pom and still tries to use the wrong logger impl.</p> */
+public class Log4jLogger implements LocationAwareLogger, Serializable {
+
+    private final org.slf4j.Logger log;
+
+    Log4jLogger(final Log4jMarkerFactory markerFactory, final ExtendedLogger logger, final String name) {
+        try {
+            Class<?> logrFactClz = Class.forName("org.slf4j.simple.SimpleLoggerFactory");
+            Constructor<?> ctor = logrFactClz.getConstructor();
+            Method getLoggerFn = logrFactClz.getMethod("getLogger", String.class);
+            this.log = (Logger) getLoggerFn.invoke(ctor.newInstance(), name);
+        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException ex) {
+            throw new UnsupportedOperationException(ex);
+        }
+    }
+
+    @Override public void log(Marker marker, String s, int i, String s1, Object[] objects, Throwable throwable) {
+        throw new UnsupportedOperationException(/*TODO*/"Not impl yet");
+    }
+
+    @Override public String getName() { return log.getName(); }
+    @Override public LoggingEventBuilder makeLoggingEventBuilder(Level level) { return log.makeLoggingEventBuilder(level); }
+    @Override public LoggingEventBuilder atLevel(Level level) { return log.atLevel(level); }
+    @Override public boolean isEnabledForLevel(Level level) { return log.isEnabledForLevel(level); }
+    @Override public boolean isTraceEnabled() { return log.isTraceEnabled(); }
+    @Override public void trace(String s) { log.trace(s); }
+    @Override public void trace(String s, Object o) { log.trace(s, o); }
+    @Override public void trace(String s, Object o, Object o1) { log.trace(s, o, o1); }
+    @Override public void trace(String s, Object... objects) { log.trace(s, objects); }
+    @Override public void trace(String s, Throwable throwable) { log.trace(s, throwable); }
+    @Override public boolean isTraceEnabled(Marker marker) { return log.isTraceEnabled(marker); }
+    @Override public LoggingEventBuilder atTrace() { return log.atTrace(); }
+    @Override public void trace(Marker marker, String s) { log.trace(marker, s); }
+    @Override public void trace(Marker marker, String s, Object o) { log.trace(marker, s, o); }
+    @Override public void trace(Marker marker, String s, Object o, Object o1) { log.trace(marker, s, o, o1); }
+    @Override public void trace(Marker marker, String s, Object... objects) { log.trace(marker, s, objects); }
+    @Override public void trace(Marker marker, String s, Throwable throwable) { log.trace(marker, s, throwable); }
+    @Override public boolean isDebugEnabled() { return log.isDebugEnabled(); }
+    @Override public void debug(String s) { log.debug(s); }
+    @Override public void debug(String s, Object o) { log.debug(s, o); }
+    @Override public void debug(String s, Object o, Object o1) { log.debug(s, o, o1); }
+    @Override public void debug(String s, Object... objects) { log.debug(s, objects); }
+    @Override public void debug(String s, Throwable throwable) { log.debug(s, throwable); }
+    @Override public boolean isDebugEnabled(Marker marker) { return log.isDebugEnabled(marker); }
+    @Override public void debug(Marker marker, String s) { log.debug(marker, s); }
+    @Override public void debug(Marker marker, String s, Object o) { log.debug(marker, s, o); }
+    @Override public void debug(Marker marker, String s, Object o, Object o1) { log.debug(marker, s, o, o1); }
+    @Override public void debug(Marker marker, String s, Object... objects) { log.debug(marker, s, objects); }
+    @Override public void debug(Marker marker, String s, Throwable throwable) { log.debug(marker, s, throwable); }
+    @Override public LoggingEventBuilder atDebug() { return log.atDebug(); }
+    @Override public boolean isInfoEnabled() { return log.isInfoEnabled(); }
+    @Override public void info(String s) { log.info(s); }
+    @Override public void info(String s, Object o) { log.info(s, o); }
+    @Override public void info(String s, Object o, Object o1) { log.info(s, o, o1); }
+    @Override public void info(String s, Object... objects) { log.info(s, objects); }
+    @Override public void info(String s, Throwable throwable) { log.info(s, throwable); }
+    @Override public boolean isInfoEnabled(Marker marker) { return log.isInfoEnabled(marker); }
+    @Override public void info(Marker marker, String s) { log.info(marker, s); }
+    @Override public void info(Marker marker, String s, Object o) { log.info(marker, s, o); }
+    @Override public void info(Marker marker, String s, Object o, Object o1) { log.info(marker, s, o, o1); }
+    @Override public void info(Marker marker, String s, Object... objects) { log.info(marker, s, objects); }
+    @Override public void info(Marker marker, String s, Throwable throwable) { log.info(marker, s, throwable); }
+    @Override public LoggingEventBuilder atInfo() { return log.atInfo(); }
+    @Override public boolean isWarnEnabled() { return log.isWarnEnabled(); }
+    @Override public void warn(String s) { log.warn(s); }
+    @Override public void warn(String s, Object o) { log.warn(s, o); }
+    @Override public void warn(String s, Object... objects) { log.warn(s, objects); }
+    @Override public void warn(String s, Object o, Object o1) { log.warn(s, o, o1); }
+    @Override public void warn(String s, Throwable throwable) { log.warn(s, throwable); }
+    @Override public boolean isWarnEnabled(Marker marker) { return log.isWarnEnabled(marker); }
+    @Override public void warn(Marker marker, String s) { log.warn(marker, s); }
+    @Override public void warn(Marker marker, String s, Object o) { log.warn(marker, s, o); }
+    @Override public void warn(Marker marker, String s, Object o, Object o1) { log.warn(marker, s, o, o1); }
+    @Override public void warn(Marker marker, String s, Object... objects) { log.warn(marker, s, objects); }
+    @Override public void warn(Marker marker, String s, Throwable throwable) { log.warn(marker, s, throwable); }
+    @Override public LoggingEventBuilder atWarn() { return log.atWarn(); }
+    @Override public boolean isErrorEnabled() { return log.isErrorEnabled(); }
+    @Override public void error(String s) { log.error(s); }
+    @Override public void error(String s, Object o) { log.error(s, o); }
+    @Override public void error(String s, Object o, Object o1) { log.error(s, o, o1); }
+    @Override public void error(String s, Object... objects) { log.error(s, objects); }
+    @Override public void error(String s, Throwable throwable) { log.error(s, throwable); }
+    @Override public boolean isErrorEnabled(Marker marker) { return log.isErrorEnabled(marker); }
+    @Override public void error(Marker marker, String s) { log.error(marker, s); }
+    @Override public void error(Marker marker, String s, Object o) { log.error(marker, s, o); }
+    @Override public void error(Marker marker, String s, Object o, Object o1) { log.error(marker, s, o, o1); }
+    @Override public void error(Marker marker, String s, Object... objects) { log.error(marker, s, objects); }
+    @Override public void error(Marker marker, String s, Throwable throwable) { log.error(marker, s, throwable); }
+    @Override public LoggingEventBuilder atError() { return log.atError(); }
+
+}



--- /dev/null
+++ b/houston-process/src/main/java/org/slf4j/reload4j/Reload4jLoggerAdapter.java
@@ -0,0 +1,16 @@
+package org.slf4j.reload4j;
+
+/** <p>FU** this fu***** damn sh** code that still tries to use log4j, no matter
+ * how strong we tell it NOT to use it!</p>
+ * <p>This class only exists to prevent services from starting if IDEA still did miss
+ * the dependency changes in pom and still tries to use the wrong logger impl.</p> */
+public class Reload4jLoggerAdapter {
+
+    public Reload4jLoggerAdapter(org.apache.log4j.Logger l) {
+        throw new UnsupportedOperationException("Fuck those fucking script-kiddies!"
+                + " How fucking hard can it be to just properly setup logging?!?"
+                + " Please !STOP! intermixing interfaces with implementations all the time!"
+                + " This fucking shit just conceals erros all the time! STOP IT!");
+    }
+
+}


--- /dev/null
+++ b/houston-process/src/main/java/org/slf4j/reload4j/Reload4jServiceProvider.java
@@ -0,0 +1,64 @@
+package org.slf4j.reload4j;
+
+import org.slf4j.ILoggerFactory;
+import org.slf4j.IMarkerFactory;
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+import org.slf4j.spi.MDCAdapter;
+import org.slf4j.spi.SLF4JServiceProvider;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Deque;
+import java.util.Map;
+
+
+/** <p>How many of those fu**ing damn stupid idiots are still out there
+ * continuing to stubbornly include those stupid logger impls with their
+ * libraries?!?</p> */
+public class Reload4jServiceProvider implements SLF4JServiceProvider, ILoggerFactory, IMarkerFactory, MDCAdapter {
+
+    private final Object slf4jSimpleLoggerFactory;
+    private final Method getLoggerFn;
+
+    public Reload4jServiceProvider() {
+        try {
+            Class<?> logrFactClz = Class.forName("org.slf4j.simple.SimpleLoggerFactory");
+            slf4jSimpleLoggerFactory = logrFactClz.getConstructor().newInstance();
+            getLoggerFn = logrFactClz.getMethod("getLogger", String.class);
+        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException ex) {
+            throw new UnsupportedOperationException(ex);
+        }
+    }
+
+    @Override public ILoggerFactory getLoggerFactory() { return this; }
+    @Override public IMarkerFactory getMarkerFactory() { return this; }
+    @Override public MDCAdapter getMDCAdapter() { return this; }
+    @Override public String getRequestedApiVersion() { return "2.0"; }
+    @Override public void initialize() {}
+
+    @Override
+    public Logger getLogger(String name) {
+        try {
+            return (Logger) getLoggerFn.invoke(slf4jSimpleLoggerFactory, name);
+        } catch (IllegalAccessException | InvocationTargetException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    @Override public Marker getMarker(String s) { assert false : "TODO not impl yet"; return null; }
+    @Override public boolean exists(String s) { assert false : "TODO not impl yet"; return false; }
+    @Override public boolean detachMarker(String s) { assert false : "TODO not impl yet"; return false; }
+    @Override public Marker getDetachedMarker(String s) { assert false : "TODO not impl yet"; return null; }
+    @Override public void put(String s, String s1) { assert false : "TODO not impl yet"; }
+    @Override public String get(String s) { assert false : "TODO not impl yet"; return null; }
+    @Override public void remove(String s) { assert false : "TODO not impl yet"; }
+    @Override public void clear() { assert false : "TODO not impl yet"; }
+    @Override public Map<String, String> getCopyOfContextMap() { assert false : "TODO not impl yet"; return null; }
+    @Override public void setContextMap(Map<String, String> map) { assert false : "TODO not impl yet"; }
+    @Override public void pushByKey(String s, String s1) { assert false : "TODO not impl yet"; }
+    @Override public String popByKey(String s) { assert false : "TODO not impl yet"; return null; }
+    @Override public Deque<String> getCopyOfDequeByKey(String s) { assert false : "TODO not impl yet"; return null; }
+    @Override public void clearDequeByKey(String s) { assert false : "TODO not impl yet"; }
+
+}


--- /dev/null
+++ b/houston-process/src/main/java/org/apache/logging/slf4j/SLF4JServiceProvider.java
@@ -0,0 +1,62 @@
+package org.apache.logging.slf4j;
+
+import org.slf4j.ILoggerFactory;
+import org.slf4j.IMarkerFactory;
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+import org.slf4j.spi.MDCAdapter;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Deque;
+import java.util.Map;
+
+
+/** <p>How many of those fu**ing damn stupid idiotic libs are still out there
+ * continuing to stubbornly include those stupid logger impls?!?</p> */
+public class SLF4JServiceProvider implements org.slf4j.spi.SLF4JServiceProvider, ILoggerFactory, IMarkerFactory, MDCAdapter {
+
+    private final Object slf4jSimpleLoggerFactory;
+    private final Method getLoggerFn;
+
+    public SLF4JServiceProvider() {
+        try {
+            Class<?> logrFactClz = Class.forName("org.slf4j.simple.SimpleLoggerFactory");
+            slf4jSimpleLoggerFactory = logrFactClz.getConstructor().newInstance();
+            getLoggerFn = logrFactClz.getMethod("getLogger", String.class);
+        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException ex) {
+            throw new UnsupportedOperationException(ex);
+        }
+    }
+
+    @Override public ILoggerFactory getLoggerFactory() { return this; }
+    @Override public IMarkerFactory getMarkerFactory() { return this; }
+    @Override public MDCAdapter getMDCAdapter() { return this; }
+    @Override public String getRequestedApiVersion() { return "2.0"; }
+    @Override public void initialize() {}
+
+    @Override
+    public Logger getLogger(String name) {
+        try {
+            return (Logger) getLoggerFn.invoke(slf4jSimpleLoggerFactory, name);
+        } catch (IllegalAccessException | InvocationTargetException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    @Override public Marker getMarker(String s) { assert false : "TODO not impl yet"; return null; }
+    @Override public boolean exists(String s) { assert false : "TODO not impl yet"; return false; }
+    @Override public boolean detachMarker(String s) { assert false : "TODO not impl yet"; return false; }
+    @Override public Marker getDetachedMarker(String s) { assert false : "TODO not impl yet"; return null; }
+    @Override public void put(String s, String s1) { assert false : "TODO not impl yet"; }
+    @Override public String get(String s) { assert false : "TODO not impl yet"; return null; }
+    @Override public void remove(String s) { assert false : "TODO not impl yet"; }
+    @Override public void clear() { assert false : "TODO not impl yet"; }
+    @Override public Map<String, String> getCopyOfContextMap() { assert false : "TODO not impl yet"; return null; }
+    @Override public void setContextMap(Map<String, String> map) { assert false : "TODO not impl yet"; }
+    @Override public void pushByKey(String s, String s1) { assert false : "TODO not impl yet"; }
+    @Override public String popByKey(String s) { assert false : "TODO not impl yet"; return null; }
+    @Override public Deque<String> getCopyOfDequeByKey(String s) { assert false : "TODO not impl yet"; return null; }
+    @Override public void clearDequeByKey(String s) { assert false : "TODO not impl yet"; }
+
+}


--- /dev/null
+++ b/houston-process/src/main/java/net/bull/javamelody/internal/common/Log4J2Logger.java
@@ -0,0 +1,38 @@
+package net.bull.javamelody.internal.common;
+
+import org.slf4j.Logger;
+
+import javax.servlet.http.HttpServletRequest;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+
+/** <p>How many of those fu**ing damn stupid idiot libs are still out there
+ * continuing to stubbornly include those stupid logger impls?!?</p> */
+public class Log4J2Logger implements net.bull.javamelody.JavaMelodyLogger {
+
+    private final org.slf4j.Logger log;
+
+    public Log4J2Logger(){
+        try {
+            Class<?> logrFactClz = Class.forName("org.slf4j.simple.SimpleLoggerFactory");
+            Object slf4jSimpleLoggerFactory = logrFactClz.getConstructor().newInstance();
+            Method getLoggerFn = logrFactClz.getMethod("getLogger", String.class);
+            this.log = (Logger) getLoggerFn.invoke(slf4jSimpleLoggerFactory, "net.bull.javamelody");
+        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException ex) {
+            throw new UnsupportedOperationException(ex);
+        }
+    }
+
+    @Override public void debug(String s) { log.debug(s); }
+    @Override public void debug(String s, Throwable ex) { log.debug(s, ex); }
+    @Override public void info(String s) { log.info(s); }
+    @Override public void info(String s, Throwable ex) { log.info(s, ex);}
+    @Override public void warn(String s, Throwable ex) { log.warn(s, ex);}
+    @Override public void logHttpRequest(
+        HttpServletRequest httpRequest, String requestName, long duration, boolean systemError, int responseStatus, long responseSize, String loggerName
+    ){
+        if (log.isInfoEnabled()) log.info("{}", LOG.buildLogMessage(httpRequest, duration, systemError, responseStatus, responseSize));
+    }
+
+}


--- /dev/null
+++ b/houston-process/src/main/java/org/eclipse/jetty/util/log/Slf4jLog.java
@@ -0,0 +1,32 @@
+package org.eclipse.jetty.util.log;
+
+import org.slf4j.LoggerFactory;
+
+
+/** Yet another fu**ing bastard lib having its own shiny stupid loggers. */
+public class Slf4jLog {
+
+    private final org.slf4j.Logger log;
+
+    public Slf4jLog() {
+        this.log = LoggerFactory.getLogger("org.eclipse.jetty.util.log");
+    }
+
+    public Slf4jLog(String name) {
+        this.log = LoggerFactory.getLogger(name);
+    }
+
+    public String getName() { return log.getName(); }
+    public void warn(String msg, Object... args) { log.warn(msg, args); }
+    public void warn(Throwable thrown) { log.warn("", thrown); }
+    public void warn(String msg, Throwable thrown) { log.warn(msg, thrown); }
+    public void info(String msg, Object... args) { log.info(msg, args); }
+    public void info(Throwable thrown) { log.info("", thrown); }
+    public void info(String msg, Throwable thrown) { log.info(msg, thrown); }
+    public void debug(String msg, Object... args) { log.debug(msg, args); }
+    public void debug(String msg, long arg) { if (log.isDebugEnabled()) log.debug(msg, arg); }
+    public void debug(Throwable thrown) { this.debug("", thrown); }
+    public void debug(String msg, Throwable thrown) { log.debug(msg, thrown); }
+    public boolean isDebugEnabled() { return log.isDebugEnabled(); }
+    public void setDebugEnabled(boolean enabled) { log.warn("setDebugEnabled not implemented"); }
+
+}