It looks like you have needlessly created a local val customLogStrategyForTimber, which is only accessible within the Timber.plant() method. In effect, you're not really using the lateinit var that you have declared at the top of your class. If you just removed val from object declaration inside the Timber.plant() method, your code would work as you intend it to.

As it is now, the object that you have declared stays inside the Timber.plant() method and isn't accessible on the outside.

The code where you initialize your lateinit var is in the log() of the DebugTree implementation you created on the spot. It is not executed when calling Timber.plant() here, you're just registering an instance of DebugTree with some implementation.

So when you reach the println with "OUTSIDE", that log method has never been called yet, so the customLogStrategyForTimber was not initialized.

Let me explain to you. Timber.plant is a thread which will take some time to complete its work. Your code where you are getting false in log it suddenly run after Timber.plan and print false meanwhile Timper.plan thread is executing parallel and initialized variable and then print where you are getting true.

You should do like this:

     class App : Application() {
 
    lateinit var customLogStrategyForTimber: LogStrategy
 
    override fun onCreate() {
        super.onCreate()
 
        Timber.plant(object : Timber.DebugTree() {
 
            override fun log(
                priorityTimber: Int, tagTimber: String?, message: String, t: Throwable?
            ) {
                customLogStrategyForTimber = object : LogcatLogStrategy() {
                    override fun log(priority: Int, tag: String?, message: String) {
                        super.log(priorityTimber, "global_tag_$tagTimber", message)
                    }
                }
                    Logger.d(message)
            }
        })
 
 
        thread {
            val formatStrategy: FormatStrategy = PrettyFormatStrategy.newBuilder()
                .showThreadInfo(false)
                .methodCount(1)
                .methodOffset(5)
                .logStrategy(customLogStrategyForTimber)
                .build()
 
            Logger.addLogAdapter(AndroidLogAdapter(formatStrategy))
 
            println("global_tag INSIDE thread: ${::customLogStrategyForTimber.isInitialized}")
 
        }
 
        Timber.d("Initialize Timber")
    }
}

Based on your comments on other answers, I think I understand what you're trying to do.

It looks like this would be less fragile code if you had a concrete implementation of LogcatLogStrategy where you have properties you can set.

class MyLogcatLogStrategy: LogcatLogStrategy() {

    var timberTag: String? = null
    var timberPriority: Int = -1

    override fun log(priority: Int, tag: String?, message: String) {
        super.log(timberPriority, timberTag, message)
    }
}

Then you can have a single instance and can update it safely from anywhere.

class App : Application() {
    val customLogStrategyForTimber = MyLogcatLogStrategy()
    
    override fun onCreate() {
        super.onCreate()
        Timber.plant(object : Timber.DebugTree() {
            override fun log(
                priority: Int, tag: String?, message: String, t: Throwable?
            ) {
                  customLogStrategyForTimber.apply {
                      timberTag = tag
                      timberPriority = priority
                  }
            }
        }
        val formatStrategy1 = PrettyFormatStrategy.newBuilder()
            .logStrategy(customLogStrategyForTimber)
            .build()
        Logger.addLogAdapter(AndroidLogAdapter(formatStrategy1))
    }
}

What I don't know is if this updates your tag value on the correct thread or in the correct order for the tag to show up in your log correctly.

It would probably be easier to eliminate Timber entirely and just copy its method of determining the tag out of its source code into your LogcatLogStrategy, but I'm not familiar with this other logging library you're using. Maybe something like this:

class MyLogcatLogStrategy: LogcatLogStrategy() {
    private val ignoredClassNames = listOf(
        MyLogcatLogStrategy::class.java.name,
        /* The names of all the classes in your logging library */
    )

    //Adapted from Timber:
    private val tag: String?
      get() = Throwable().stackTrace
          .first { it.className !in ignoredClassNames }
          .let(::createStackElementTag)

    override fun log(priority: Int, ignoredTag: String?, message: String) {
        super.log(priority, this.tag, message)
    }

    // From Timber: (https://github.com/JakeWharton/timber/blob/master/timber/src/main/java/timber/log/Timber.kt#L216)
    private fun createStackElementTag(element: StackTraceElement): String? {
      var tag = element.className.substringAfterLast('.')
      val m = ANONYMOUS_CLASS.matcher(tag)
      if (m.find()) {
        tag = m.replaceAll("")
      }
      // Tag length limit was removed in API 24.
      return if (tag.length <= MAX_TAG_LENGTH || Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        tag
      } else {
        tag.substring(0, MAX_TAG_LENGTH)
      }
    }

    companion object {
      private val ANONYMOUS_CLASS = Pattern.compile("(\\$\\d+)+$")
    }
}