How do I pass an array (or Set) of Classes as appender's property from log4j2.xml configuration to custom appender class?

[yvasyliev]

I'm thinking of the following log4j2.xml configuration:

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn">
    <Appenders>
        <CustomAppender name="customAppender">
            <IgnoredExceptions>
                <IgnoredException>org.apache.http.NoHttpResponseException</IgnoredException>
            </IgnoredExceptions>
        </CustomAppender>
    </Appenders>
    <Loggers>
        <Root level="ALL">
            <AppenderRef ref="customAppender"/>
        </Root>
    </Loggers>
</Configuration>

And wish I could get CustomAppender like this:

@Plugin(name = "CustomAppender", category = Core.CATEGORY_NAME, elementType = Appender.ELEMENT_TYPE)
public class CustomAppender extends AbstractAppender {
    private final Set<Class<? extends Throwable>> ignoredExceptions;

    protected CustomAppender(String name, Set<Class<? extends Throwable>> ignoredExceptions) {
        super(name, null, PatternLayout.createDefaultLayout(), true, Property.EMPTY_ARRAY);
        this.ignoredExceptions = ignoredExceptions;
    }

    @PluginFactory
    public static CustomAppender createAppender(
            @PluginAttribute("name") String name,
            @PluginElement("IgnoredExceptions") Set<Class<? extends Throwable>> ignoredExceptions) {
        return new CustomAppender(name, ignoredExceptions);
    }

    @Override
    public void append(LogEvent event) {
        var thrown = event.getThrown();
        if (thrown != null && ignoredExceptions.contains(thrown.getClass())) {
            //noop
            return;
        }
        //do stuff
    }
}

But this config will fail at runtime. I tried different combinations of @PluginElement/@PluginAttribute etc, but no luck.

Could someone please assist me with plugin setup?

[vy]

@yvasyliev, could you try @PluginElement("IgnoredExceptions") Class[] ignoredExceptions instead, please?

[yvasyliev]

Doesn't work - ignoredExceptions is empty in this case

[jvz]

You can create a wrapper class something like this:

@Plugin(name = "ExceptionType", category = "Core", elementType = "ExceptionType")
public class ExceptionType {
  private final Class<? extends Throwable> type;

  private ExceptionType(Class<? extends Throwable> type) { this.type = type; }

  public Class<? extends Throwable> getType() { return type; }

  @PluginFactory
  public static ExceptionType create(@PluginValue("type") String className) {
    Class<? extends Throwable> type = Class.forName(className).asSubclass(Throwable.class);
    return new ExceptionType(type);
  }
}

Then, you can use a @PluginElement("ExceptionType") ExceptionType[] types in another plugin. Then you'd use the config like:

<Appenders>
  <CustomAppender>
    <ExceptionType>com.example.FooException</ExceptionType>
    <ExceptionType>com.example.BarException</ExceptionType>
    <!-- ... -->
  </CustomAppender>
</Appenders>

[yvasyliev]

Yeah, I've just come up with something similar 😂

[jvz]

Also, one other option would be a generic plugin attribute that takes a comma-separated list of class names. Then you can split and parse them.

[yvasyliev]

After some tries, I found solution that solves my task.

1. IgnoredException.java

   @Plugin(name = "IgnoredException", category = Core.CATEGORY_NAME, elementType = Appender.ELEMENT_TYPE)
   public class IgnoredException {
       private final Class<? extends Throwable> exceptionClass;
   
       public IgnoredException(Class<? extends Throwable> exceptionClass) {
           this.exceptionClass = exceptionClass;
       }
   
       @PluginFactory
       public static IgnoredException createAppender(@PluginValue("value") String name) throws ClassNotFoundException {
           System.out.println("IgnoredException");
           return new IgnoredException(Class.forName(name).asSubclass(Throwable.class));
       }
   
       public Class<? extends Throwable> getExceptionClass() {
           return exceptionClass;
       }
   }

2. IgnoredExceptions.java

   @Plugin(name = "IgnoredExceptions", category = Core.CATEGORY_NAME, elementType = Appender.ELEMENT_TYPE)
   public class IgnoredExceptions {
       private final Set<Class<? extends Throwable>> exceptionClasses;
   
       public IgnoredExceptions(Set<Class<? extends Throwable>> exceptionClasses) {
           this.exceptionClasses = exceptionClasses;
       }
   
       @PluginFactory
       public static IgnoredExceptions createAppender(@PluginElement("IgnoredException") IgnoredException[] ignoredExceptions) {
           System.out.println("IgnoredExceptions");
           return new IgnoredExceptions(
                   Arrays
                           .stream(ignoredExceptions)
                           .map(IgnoredException::getExceptionClass)
                           .collect(Collectors.toSet())
           );
       }
   
       public Set<Class<? extends Throwable>> getExceptionClasses() {
           return exceptionClasses;
       }
   }

3. CustomAppender.java

   @Plugin(name = "CustomAppender", category = Core.CATEGORY_NAME, elementType = Appender.ELEMENT_TYPE)
   public class CustomAppender extends AbstractAppender {
       private final Set<Class<? extends Throwable>> exceptionClasses;
   
       protected CustomAppender(String name, Set<Class<? extends Throwable>> exceptionClasses) {
           super(name, null, PatternLayout.createDefaultLayout(), true, Property.EMPTY_ARRAY);
           this.exceptionClasses = exceptionClasses;
       }
   
       @PluginFactory
       public static CustomAppender createAppender(
               @PluginAttribute("name") String name,
               @PluginElement("IgnoredExceptions") IgnoredExceptions ignoredExceptions) {
           System.out.println("CustomAppender");
           return new CustomAppender(name, ignoredExceptions.getExceptionClasses());
       }
   
       @Override
       public void append(LogEvent event) {
           var thrown = event.getThrown();
           if (thrown != null && exceptionClasses.contains(thrown.getClass())) {
               //noop
               return;
           }
           //do stuff
       }
   }

The classes above will properly read a config like:

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn">
    <Appenders>
        <CustomAppender name="customAppender">
            <IgnoredExceptions>
                <IgnoredException>org.apache.http.NoHttpResponseException</IgnoredException>
            </IgnoredExceptions>
        </CustomAppender>
    </Appenders>
    <Loggers>
        <Root level="ALL">
            <AppenderRef ref="customAppender"/>
        </Root>
    </Loggers>
</Configuration>

But during the research I found a fantastic behavior:

• In CustomAppender.java, if CustomAppender#exceptionsToIgnore and @PluginElement("IgnoredExceptions") IgnoredExceptions ignoredExceptions variables have the same name, the code won't work (IgnoredExceptions ignoredExceptions will be null).

Also, Log4j2 doesn't support record plugins. IgnoredException and IgnoredExceptions could be perfect records.

[jvz]

For record plugins, can you file an issue for that? Since 3.0 is looking like it'll target Java 17 as a baseline, it'll be fairly easy to support.

[yvasyliev]

Sure, I'll do that