Log appender hardening

core/src/main/java/dev/vml/es/acm/core/code/log/LogInterceptorManager.java

@@ -7,15 +7,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-/**
- * Selects the best available {@link LogInterceptor} implementation.
- *
- * <p><strong>Why not OSGi Log Service 1.4?</strong> Its {@code LogReaderService} only captures
- * logs sent directly to OSGi Log Service. SLF4J/Logback logs are bridged one-way (SLF4J → OSGi),
- * so {@code LogReaderService} doesn't receive them. We use Sling AppenderTracker instead.</p>
- *
- * @see SlingLogInterceptor
- */
 @Component(service = LogInterceptorManager.class)
 public class LogInterceptorManager {
 
@@ -44,7 +35,7 @@ public LogInterceptor.Handle attach(Consumer<LogMessage> listener, String... log
                     return i.attach(listener, loggerNames);
                 })
                 .orElseGet(() -> {
-                    LOG.warn("No log interceptor available");
+                    LOG.debug("No log interceptor available");
                     return () -> {};
                 });
     }

core/src/main/java/dev/vml/es/acm/core/code/log/LogbackAppenderFactory.java

@@ -3,16 +3,18 @@
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-/**
- * Creates Logback Appender proxies via reflection, avoiding compile-time dependency on ch.qos.logback.*.
- */
 class LogbackAppenderFactory {
 
-    static final String LOGBACK_LOGGER_CONTEXT = "ch.qos.logback.classic.LoggerContext";
-    static final String LOGBACK_APPENDER = "ch.qos.logback.core.Appender";
+    private static final Logger LOG = LoggerFactory.getLogger(LogbackAppenderFactory.class);
+
+    private static final String LOGBACK_LOGGER_CONTEXT = "ch.qos.logback.classic.LoggerContext";
+    private static final String LOGBACK_APPENDER = "ch.qos.logback.core.Appender";
     private static final String LOGBACK_CONTEXT = "ch.qos.logback.core.Context";
     private static final String LOGBACK_LOGGING_EVENT = "ch.qos.logback.classic.spi.ILoggingEvent";
 
@@ -22,7 +24,57 @@ class LogbackAppenderFactory {
         this.classLoader = classLoader;
     }
 
-    Object createAppender(String name, Consumer<LogMessage> listener, List<String> loggerNames)
+    boolean isAvailable() {
+        try {
+            classLoader.loadClass(LOGBACK_LOGGER_CONTEXT);
+            classLoader.loadClass(LOGBACK_APPENDER);
+            return true;
+        } catch (ClassNotFoundException e) {
+            return false;
+        }
+    }
+
+    Object attach(String name, Consumer<LogMessage> listener, List<String> loggerNames)
+            throws ReflectiveOperationException {
+        Object appender = createAppender(name, listener, loggerNames);
+        List<String> attached = new ArrayList<>();
+        try {
+            initAppender(appender);
+            for (String loggerName : loggerNames) {
+                addAppenderToLogger(appender, loggerName);
+                attached.add(loggerName);
+            }
+            return appender;
+        } catch (ReflectiveOperationException e) {
+            detach(appender, attached);
+            throw e;
+        }
+    }
+
+    void detach(Object appender, List<String> loggerNames) {
+        if (appender == null) {
+            return;
+        }
+        try {
+            if (loggerNames != null) {
+                for (String loggerName : loggerNames) {
+                    try {
+                        detachAppenderFromLogger(appender, loggerName);
+                    } catch (Exception e) {
+                        LOG.warn("Failed to detach appender from logger '{}'", loggerName, e);
+                    }
+                }
+            }
+        } finally {
+            try {
+                stopAppender(appender);
+            } catch (Exception e) {
+                LOG.warn("Failed to stop appender", e);
+            }
+        }
+    }
+
+    private Object createAppender(String name, Consumer<LogMessage> listener, List<String> loggerNames)
             throws ClassNotFoundException {
         Class<?> appenderClass = classLoader.loadClass(LOGBACK_APPENDER);
         Class<?> eventClass = classLoader.loadClass(LOGBACK_LOGGING_EVENT);
@@ -32,7 +84,18 @@ Object createAppender(String name, Consumer<LogMessage> listener, List<String> l
                 new AppenderHandler(name, eventClass, listener, loggerNames));
     }
 
-    Object getLoggerContext() throws ClassNotFoundException {
+    private void initAppender(Object appender) throws ReflectiveOperationException {
+        Object loggerContext = getLoggerContext();
+        Class<?> ctxClass = classLoader.loadClass(LOGBACK_CONTEXT);
+        appender.getClass().getMethod("setContext", ctxClass).invoke(appender, loggerContext);
+        appender.getClass().getMethod("start").invoke(appender);
+    }
+
+    private void stopAppender(Object appender) throws ReflectiveOperationException {
+        appender.getClass().getMethod("stop").invoke(appender);
+    }
+
+    private Object getLoggerContext() throws ClassNotFoundException {
         Class<?> ctxClass = classLoader.loadClass(LOGBACK_LOGGER_CONTEXT);
         Object ctx = org.slf4j.LoggerFactory.getILoggerFactory();
         if (ctx == null || !ctxClass.isInstance(ctx)) {
@@ -41,17 +104,20 @@ Object getLoggerContext() throws ClassNotFoundException {
         return ctx;
     }
 
-    void setContext(Object appender, Object context) throws ReflectiveOperationException {
-        Class<?> ctxClass = classLoader.loadClass(LOGBACK_CONTEXT);
-        appender.getClass().getMethod("setContext", ctxClass).invoke(appender, context);
-    }
-
-    void start(Object appender) throws ReflectiveOperationException {
-        appender.getClass().getMethod("start").invoke(appender);
+    private void addAppenderToLogger(Object appender, String loggerName) throws ReflectiveOperationException {
+        Object loggerContext = getLoggerContext();
+        Class<?> loggerContextClass = classLoader.loadClass(LOGBACK_LOGGER_CONTEXT);
+        Object logger = loggerContextClass.getMethod("getLogger", String.class).invoke(loggerContext, loggerName);
+        Class<?> appenderClass = classLoader.loadClass(LOGBACK_APPENDER);
+        logger.getClass().getMethod("addAppender", appenderClass).invoke(logger, appender);
     }
 
-    void stop(Object appender) throws ReflectiveOperationException {
-        appender.getClass().getMethod("stop").invoke(appender);
+    private void detachAppenderFromLogger(Object appender, String loggerName) throws ReflectiveOperationException {
+        Object loggerContext = getLoggerContext();
+        Class<?> loggerContextClass = classLoader.loadClass(LOGBACK_LOGGER_CONTEXT);
+        Object logger = loggerContextClass.getMethod("getLogger", String.class).invoke(loggerContext, loggerName);
+        Class<?> appenderClass = classLoader.loadClass(LOGBACK_APPENDER);
+        logger.getClass().getMethod("detachAppender", appenderClass).invoke(logger, appender);
     }
 
     private static class AppenderHandler implements InvocationHandler {

core/src/main/java/dev/vml/es/acm/core/code/log/LogbackLogInterceptor.java

@@ -0,0 +1,63 @@
+package dev.vml.es.acm.core.code.log;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Consumer;
+import org.apache.sling.commons.classloader.DynamicClassLoaderManager;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Component(service = LogInterceptor.class)
+public class LogbackLogInterceptor implements LogInterceptor {
+
+    private static final Logger LOG = LoggerFactory.getLogger(LogbackLogInterceptor.class);
+
+    private static final String APPENDER_NAME = "ACM-LogbackLogInterceptor";
+
+    @Reference
+    private DynamicClassLoaderManager classLoaderManager;
+
+    @Override
+    public boolean isAvailable() {
+        return getFactory() != null;
+    }
+
+    @Override
+    public Handle attach(Consumer<LogMessage> listener, String... loggerNames) {
+        if (listener == null || loggerNames == null || loggerNames.length == 0) {
+            LOG.warn("Cannot attach - invalid parameters");
+            return () -> {};
+        }
+        LogbackAppenderFactory factory = getFactory();
+        if (factory == null) {
+            return () -> {};
+        }
+        try {
+            List<String> loggerList = Arrays.asList(loggerNames);
+            Object appender = factory.attach(APPENDER_NAME, listener, loggerList);
+            LOG.debug("Attached appender to loggers: {}", loggerList);
+            return () -> factory.detach(appender, loggerList);
+        } catch (Exception e) {
+            LOG.error("Failed to attach log interceptor", e);
+            return () -> {};
+        }
+    }
+
+    private LogbackAppenderFactory getFactory() {
+        if (classLoaderManager == null) {
+            return null;
+        }
+        try {
+            ClassLoader cl = classLoaderManager.getDynamicClassLoader();
+            if (cl == null) {
+                return null;
+            }
+            LogbackAppenderFactory factory = new LogbackAppenderFactory(cl);
+            return factory.isAvailable() ? factory : null;
+        } catch (Exception e) {
+            return null;
+        }
+    }
+}