How Logback Works in EzyPlatform

• The root logger still handles logs as usual.
• In logback.xml, besides standard appenders such as console or file, EzyPlatform adds one more appender named composite.
• The composite appender points to org.youngmonkeys.ezyplatform.logback.CompositeLogbackAppender.
• Whenever Logback produces an ILoggingEvent, the composite appender forwards that event to all Java appenders registered in LogbackAppenderManager.

Logger -> Root Logger -> console / file / composite
                                   |
                                   v
                     CompositeLogbackAppender
                                   |
                                   v
                      LogbackAppenderManager
                                   |
                    +--------------+--------------+
                    |                             |
                    v                             v
             CustomAppenderA               CustomAppenderB

The Three Important Classes

• This is the base class for custom appenders.
• It extends AppenderBase<ILoggingEvent>.
• Its constructor sets started = true, so the appender is considered ready to receive log events immediately after instantiation.
• You only need to override append(ILoggingEvent event).

• This is the appender declared in logback.xml.
• Its job is to receive each ILoggingEvent from Logback and dispatch it to all appenders registered in the manager.

• This is the registry that holds custom appenders.
• It uses a ConcurrentHashMap, so basic concurrent access is safe.
• Appenders are stored by Class<?>, which means only one instance per appender type is registered.
• If you call addAppender multiple times with the same class, the manager keeps the first one.

What Your Custom Appender Needs to Work

1. logback.xml must include CompositeLogbackAppender in the root logger.
2. Your custom appender must be added to LogbackAppenderManager.

Configuring logback.xml

<appender name="composite"
          class="org.youngmonkeys.ezyplatform.logback.CompositeLogbackAppender" />

<root level="info">
    <appender-ref ref="console"/>
    <appender-ref ref="file"/>
    <appender-ref ref="composite"/>
</root>

Creating a LogbackAppender

import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.spi.ILoggingEvent;
import org.youngmonkeys.ezyplatform.logback.LogbackAppender;

public class ErrorNotifyLogbackAppender extends LogbackAppender {

    @Override
    protected void append(ILoggingEvent event) {
        if (!Level.ERROR.equals(event.getLevel())) {
            return;
        }

        String loggerName = event.getLoggerName();
        String message = event.getFormattedMessage();
        String threadName = event.getThreadName();

        // Example: send to Slack, Telegram, webhook, queue, etc.
        System.out.println(
            "[ERROR-NOTIFY] [" + threadName + "] " +
            loggerName + " - " + message
        );
    }
}

• log level
• logger name
• thread name
• formatted message
• exception
• timestamp
• MDC values if present

if (event.getThrowableProxy() != null) {
    String exceptionClass = event.getThrowableProxy().getClassName();
    String exceptionMessage = event.getThrowableProxy().getMessage();
}

Registering the Appender in EzyPlatform

import com.tvd12.ezyfox.bean.annotation.EzyPostInit;
import com.tvd12.ezyfox.bean.annotation.EzySingleton;
import lombok.AllArgsConstructor;
import org.youngmonkeys.ezyplatform.logback.LogbackAppenderManager;

@EzySingleton
@AllArgsConstructor
public class LogbackAppenderBootstrap {

    private final ErrorNotifyLogbackAppender errorNotifyLogbackAppender;

    @EzyPostInit
    public void postInit() {
        LogbackAppenderManager
            .getInstance()
            .addAppender(errorNotifyLogbackAppender);
    }
}

import com.tvd12.ezyfox.bean.annotation.EzySingleton;

@EzySingleton
public class ErrorNotifyLogbackAppender extends LogbackAppender {

    @Override
    protected void append(ILoggingEvent event) {
        // handle the log event here
    }
}

• Logback sends events to CompositeLogbackAppender
• CompositeLogbackAppender calls LogbackAppenderManager
• the manager invokes ErrorNotifyLogbackAppender
• your appender receives the log event

When This Mechanism Is Useful

• sending error logs to a webhook or chat system
• counting logs by level
• extracting specific log groups and forwarding them elsewhere
• adding alerting logic without heavily modifying logback.xml

Important Notes

• CompositeLogbackAppender is attached directly to the root logger.
• That means your custom appender usually runs on the same thread that produced the log event.
• If you make HTTP calls, write to a database, or do heavy processing there, the current request may slow down.

• If append(...) writes logs back into the same logging system, you can easily create a recursive logging loop.
• It is better to keep internal logging minimal or add loop protection.

• LogbackAppenderManager uses putIfAbsent.
• This prevents duplicate registration, but it also means that if you want to replace an instance at runtime, you need to design for that explicitly.

• console and file appenders continue to work independently.
• composite is only an additional branch that allows EzyPlatform to dispatch log events to custom Java appenders.

Quick Installation Steps

1. Create a class that extends LogbackAppender.
2. Override append(ILoggingEvent event).
3. Declare the class as a singleton bean in your application.
4. In a startup bean, call LogbackAppenderManager.getInstance().addAppender(...).
5. Make sure logback.xml includes CompositeLogbackAppender in the root logger.

Conclusion