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 {
 

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

@@ -6,13 +6,10 @@
 import java.util.List;
 import java.util.function.Consumer;
 
-/**
- * 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 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 +19,34 @@ 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);
+        initAppender(appender);
+        for (String loggerName : loggerNames) {
+            addAppenderToLogger(appender, loggerName);
+        }
+        return appender;
+    }
+
+    void detach(Object appender, List<String> loggerNames) throws ReflectiveOperationException {
+        for (String loggerName : loggerNames) {
+            detachAppenderFromLogger(appender, loggerName);
+        }
+        stopAppender(appender);
+    }
+
+    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 +56,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 +76,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,67 @@
+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() {
+        if (classLoaderManager == null) {
+            return false;
+        }
+        try {
+            ClassLoader cl = classLoaderManager.getDynamicClassLoader();
+            if (cl == null) {
+                return false;
+            }
+            return new LogbackAppenderFactory(cl).isAvailable();
+        } catch (Exception e) {
+            LOG.debug("Cannot check log interceptor availability", e);
+            return false;
+        }
+    }
+
+    @Override
+    public Handle attach(Consumer<LogMessage> listener, String... loggerNames) {
+        if (listener == null || loggerNames == null || loggerNames.length == 0) {
+            LOG.warn("Cannot attach - invalid parameters");
+            return () -> {};
+        }
+        if (!isAvailable()) {
+            LOG.warn("Log interceptor not available");
+            return () -> {};
+        }
+        try {
+            LogbackAppenderFactory factory = new LogbackAppenderFactory(classLoaderManager.getDynamicClassLoader());
+            List<String> loggerList = Arrays.asList(loggerNames);
+            Object appender = factory.attach(APPENDER_NAME, listener, loggerList);
+            LOG.debug("Attached appender to loggers: {}", loggerList);
+
+            return () -> {
+                try {
+                    factory.detach(appender, loggerList);
+                } catch (Exception e) {
+                    LOG.debug("Failed to detach appender", e);
+                }
+            };
+        } catch (Exception e) {
+            LOG.error("Failed to attach log interceptor", e);
+            return () -> {};
+        }
+    }
+}