When is the appropriate time for code configuration initialization？

[whatisjava]

When configuring entirely through code as per the example, do I need to add the configureLogbackDirectly() method in the onCreate of each Activity? I tried calling the configureLogbackDirectly() method only in the onCreate of the application's Application class, but I noticed that sometimes no log information is generated. I'm not sure if this is related to my use of the @HiltAndroidApp annotation

object LogbackConfig {

fun configure(context: Context) {
    // reset the default context (which may already have been initialized)
    // since we want to reconfigure it
    val loggerContext = LoggerFactory.getILoggerFactory() as LoggerContext
    loggerContext.stop()

    val logDir = FileUtil.logDirFilePath(context, "logs", "app.log")
    Log.d("LogbackConfig", "logDir: $logDir")

    val rollingFileAppender = RollingFileAppender<ILoggingEvent>()
    rollingFileAppender.context = loggerContext
    rollingFileAppender.isAppend = true
    rollingFileAppender.name = "ROLLING_FILE"
    rollingFileAppender.file = "${logDir}/app.log"

    // setup RollingFileAppender
    val rollingFileEncoder = PatternLayoutEncoder()
    rollingFileEncoder.context = loggerContext

// rollingFileEncoder.pattern = "[%date{yyyy-MM-dd HH:mm:ss.SSS}] %-5level %logger{0}.%M\(%F:%L\): - %msg%n"
rollingFileEncoder.pattern = "[%date{yyyy-MM-dd HH:mm:ss.SSS}] %-5level %logger{0}: - %msg%n"
rollingFileEncoder.charset = Charset.forName("UTF-8")
rollingFileEncoder.start()

    val rollingPolicy = SizeAndTimeBasedRollingPolicy<ILoggingEvent>()
    rollingPolicy.context = loggerContext
    rollingPolicy.setParent(rollingFileAppender)
    rollingPolicy.fileNamePattern = "${logDir}/%d{yyyy-MM-dd}/app-%i.log"
    rollingPolicy.maxHistory = 100
    rollingPolicy.setMaxFileSize(FileSize.valueOf("100 kb"))
    rollingPolicy.setTotalSizeCap(FileSize.valueOf("5 gb"))
    rollingPolicy.isCleanHistoryOnStart = false
    rollingPolicy.start()

    rollingFileAppender.rollingPolicy = rollingPolicy

    rollingFileAppender.encoder = rollingFileEncoder

    rollingFileAppender.start()

    val asyncAppender = AsyncAppender()
    asyncAppender.context = loggerContext
    asyncAppender.name = "ASYNC"
    asyncAppender.addAppender(rollingFileAppender)
    asyncAppender.start()

    // setup LogcatAppender
    val logcatTagEncoder = PatternLayoutEncoder()
    logcatTagEncoder.context = loggerContext
    logcatTagEncoder.pattern = "APP-%logger{0}"
    logcatTagEncoder.charset = Charset.forName("UTF-8")
    logcatTagEncoder.start()

    val logcatEncoder = PatternLayoutEncoder()
    logcatEncoder.context = loggerContext
    logcatEncoder.pattern = "%M\\(%F:%L\\): - %msg%n"
    logcatEncoder.charset = Charset.forName("UTF-8")
    logcatEncoder.start()

    val logcatAppender = LogcatAppender()
    logcatAppender.context = loggerContext
    logcatAppender.name = "LOGCAT"
    logcatAppender.tagEncoder = logcatTagEncoder
    logcatAppender.encoder = logcatEncoder
    logcatAppender.start()

    BasicLogcatConfigurator.configureDefaultContext()

    // add the newly created appender to the root logger;
    // qualify Logger to disambiguate from org.slf4j.Logger
    val rootLogger = LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME) as Logger

    if (BuildConfig.DEBUG) {
        rootLogger.level = Level.TRACE
        rootLogger.addAppender(logcatAppender)
        rootLogger.addAppender(asyncAppender)
    } else {
        if (PrefUtil.isTestMode(context)) {
            rootLogger.level = Level.TRACE
            rootLogger.addAppender(logcatAppender)
        } else {
            rootLogger.level = Level.INFO
        }
        rootLogger.addAppender(asyncAppender)
    }

    // print any status messages (warnings, etc) encountered in logback config
    StatusPrinter.print(loggerContext)
}

fun stop(){
    val loggerContext: LoggerContext = LoggerFactory.getILoggerFactory() as LoggerContext
    loggerContext.stop()
}

}