I currently have a “LocalLogger” Class that handles all my logging stuff. I can make a new Object of that class in my other classes, to maintain the same logging all over.

Currently the LocalLogger Class, makes 2 Log Files. InfoLog and ErrorLog.
My Problem is, that the Logger is writing every Log from different Classes in 1 Log File. That is in general not a problem, and it is the way i want it. BUT he is writing it in the wrong File.

This is my Logger Class:

public class LocalLogger {

    private final Logger logger;
    private final Logger elogger;
    private final Logger ilogger;

    private final Class<?> logClass;

    private Configuration config;
    private final Date startTime;


    public LocalLogger(Configuration config, Class<?> logClass) {
        this.config = config;
        this.logClass = logClass;
        this.startTime = new Date();

        configureLogger();
        logger = LogManager.getLogger(logClass);
        elogger = LogManager.getLogger("errorLogger");
        ilogger = LogManager.getLogger("infoLogger");

        logInfo("Starting Time: " + new SimpleDateFormat("dd.MM.yyyy - hh:mm:ss").format(startTime));
        logInfo("ErrorLogFile set to -> " + config.getErrorLogFile());
    }


    public LocalLogger(Class<?> logClass) {
        this.logClass = logClass;
        this.startTime = new Date();

        configureLogger();
        logger = LogManager.getLogger(logClass);
        elogger = LogManager.getLogger("errorLogger");
        ilogger = LogManager.getLogger("infoLogger");

        logInfo("Starting Time: " + new SimpleDateFormat("dd.MM.yyyy - hh:mm:ss").format(startTime));
    }

    private void configureLogger() {
        String infoLog = config != null && config.getLogFile() != null && !config.getLogFile().isEmpty() ? config.getLogFile() : logClass.getSimpleName() + "-INFO.log";
        String errorLog = config != null && config.getErrorLogFile() != null && !config.getLogFile().isEmpty() ? config.getErrorLogFile() : logClass.getSimpleName() + "-ERROR.log";
        String logLevel = config != null && config.getLogLevel() != null && !config.getLogLevel().isEmpty() ? config.getLogLevel() : "INFO";


        ConfigurationBuilder<BuiltConfiguration> builder = ConfigurationBuilderFactory.newConfigurationBuilder();

        builder.setStatusLevel(org.apache.logging.log4j.Level.WARN);
        builder.setConfigurationName("DynamicConfig");

        LayoutComponentBuilder standard
                = builder.newLayout("PatternLayout");
        standard.addAttribute("pattern", "%d [%t] %-5level: %msg%n%throwable");


        AppenderComponentBuilder consoleAppender = builder.newAppender("Console", "Console")
                .addAttribute("target", ConsoleAppender.Target.SYSTEM_OUT);
        consoleAppender.add(standard);
        builder.add(consoleAppender);


        AppenderComponentBuilder fileInfoAppender = builder.newAppender("InfoFile", "File")
                .addAttribute("fileName", infoLog)
                .addAttribute("append", "true");
        fileInfoAppender.add(standard);
        fileInfoAppender.add(builder.newFilter("ThresholdFilter", Filter.Result.ACCEPT, Filter.Result.DENY)
                .addAttribute("level", org.apache.logging.log4j.Level.TRACE));
        builder.add(fileInfoAppender);


        AppenderComponentBuilder fileErrorAppender = builder.newAppender("ErrorFile", "File")
                .addAttribute("fileName", errorLog)
                .addAttribute("append", "true");
        fileErrorAppender.add(standard);
        fileErrorAppender.add(builder.newFilter("ThresholdFilter", Filter.Result.ACCEPT, Filter.Result.DENY)
                .addAttribute("level", org.apache.logging.log4j.Level.WARN));
        builder.add(fileErrorAppender);


        RootLoggerComponentBuilder rootLogger = builder.newRootLogger(Level.ERROR);
        rootLogger.add(builder.newAppenderRef("Console"));
        builder.add(rootLogger);

        LoggerComponentBuilder errorLogger = builder.newLogger("errorLogger", Level.WARN);
        errorLogger.add(builder.newAppenderRef("ErrorFile"));
        builder.add(errorLogger);

        LoggerComponentBuilder infoLogger = builder.newLogger("infoLogger", Level.TRACE);
        infoLogger.add(builder.newAppenderRef("InfoFile"));
        builder.add(infoLogger);

        LoggerContext ctx = Configurator.initialize(builder.build());
    }

    /**
     * Redirection to Log4j Logger.
     *
     * @param message message to log
     */
    public void logTrace(String message) {
        ilogger.trace(message);
    } // trace

    /**
     * Redirection to Log4j Logger.
     *
     * @param message message to log
     */
    public void logDebug(String message) {
        ilogger.debug(message);
    } // debug

    /**
     * Redirection to Log4j Logger.
     *
     * @param message message to log
     */
    public void logInfo(String message) {
        ilogger.info(message);
    } // info

    /**
     * Redirection to Log4j Logger.
     *
     * @param message message to log
     */
    public void logWarning(String message) {
        elogger.warn(message);
    } // warn



    /**
     * Redirection to Log4j Logger.
     *
     * @param message message to log
     */
    public void logError(String message) {
        elogger.error(message);
    } // error

    /**
     * Handles truncated stack trace logging via Log4j Logging
     *
     * @param key unique String value (e.g. file path)
     * @param message individual log message
     * @param exception the exception to log with max stack trace length
     *
     */
    public void logSevere(String key, String message, Exception exception) {
        //TODO special exception Handling?

        String msg = key + ":" + message;

        elogger.fatal(msg);
    } // fatal
}

This is a Constructor of one of my other classes:

public Exporter(File adminConfig, String jsonString, Date startTime) {
        this.startTime = startTime;

        JSONToConfigXML configBuilder = new JSONToConfigXML(jsonString, adminConfig);
        File completeConfig = configBuilder.parse();

        XMLParser parser = new XMLParser();
        Map<String, Object> configMap = parser.parse(completeConfig);
        ExportConfiguration cfg = new ExportConfiguration();
        cfg.setConfigFile(completeConfig.getAbsolutePath());

        initConfig(cfg, configMap);
        this.config = cfg;
        this.logger = new LocalLogger(this.config, Exporter.class);
    }

This is just the simple execute main class:

private static final LocalLogger logger = new LocalLogger(ExporterMain.class);
    private static final Date startTime = new Date();
    
    /**
     * @param args - Config File
     */
    public static void main(String[] args) {
        try {
            if (args.length < 1) {
                System.out.println("Usage: java ExporterMain <filename>");
                System.exit(1);
            } else {
                
                File config = new File(args[0]);

                Exporter exp = new Exporter(config, startTime);
                exp.execute();

                System.out.println("SuccessCounter: "+ exp.getSuccessCounter());
                System.out.println("ErrorCounter: "+ exp.getErrorCounter());
                System.out.println("LastItem: "+ exp.getLastItem());
            }
        } catch (Exception e) {
            logger.logSevere("exec", e.getMessage(), e);
            System.exit(1);
        }
    }

Currently he writes 6 Log Files: 2 for ExporterMain, 2 for XMLParser and 2 for Exporter.

Atm he is writing every log in the ExporterMain Log Files. But in this case i want to have all Logs written to the Exporter Log, because there is a log-path in the config which i want to use.
He is creating the File in the right directory from the path in the config, but the files are empty.