Move non-main thread check to JVM IOAppPlatform

Author: kapunga

core/js/src/main/scala/cats/effect/IOApp.scala

@@ -185,6 +185,8 @@ trait IOApp extends IOAppPlatform {
   def run(args: List[String]): IO[ExitCode]
 
   final def main(args: Array[String]): Unit = {
+    checkRunningOnNonMainThread()
+
     val installed = if (runtime == null) {
       import unsafe.IORuntime
 

core/jvm/src/main/scala/cats/effect/IOApp.scala

@@ -292,10 +292,7 @@ trait IOApp extends IOAppPlatform {
    */
   protected def logNonDaemonThreadsEnabled: Boolean =
     Option(System.getProperty("cats.effect.logNonDaemonThreadsOnExit"))
-      .map(_.toLowerCase()) match {
-      case Some(value) => value.equalsIgnoreCase("true")
-      case None => true // default to enabled
-    }
+      .forall(_.equalsIgnoreCase("true"))
 
   /**
    * Controls the interval used by the non-daemon thread detector. Defaults to `10.seconds`.
@@ -311,37 +308,6 @@ trait IOApp extends IOAppPlatform {
       .flatMap(time => Either.catchOnly[NumberFormatException](time.toLong.millis).toOption)
       .getOrElse(10.seconds)
 
-  /**
-   * Defines what to do when IOApp detects that `main` is being invoked on a `Thread` which
-   * isn't the main process thread. This condition can happen when we are running inside of an
-   * `sbt run` with `fork := false`
-   */
-  def warnOnNonMainThreadDetected: Boolean =
-    Option(System.getProperty("cats.effect.warnOnNonMainThreadDetected"))
-      .map(_.equalsIgnoreCase("true"))
-      .getOrElse(true)
-
-  private def onNonMainThreadDetected(): Unit = {
-    if (warnOnNonMainThreadDetected)
-      System
-        .err
-        .println(
-          """|[WARNING] IOApp `main` is running on a thread other than the main thread.
-             |This may prevent correct resource cleanup after `main` completes.
-             |This condition could be caused by executing `run` in an interactive sbt session with `fork := false`.
-             |To ensure proper cleanup, either
-             |  - set `Compile / run / fork := true` in this project
-             |  - use `fgRun` instead of `run`
-             |  - use 'bgStop` to terminate `run`
-             |  - update sbt to a version after 1.10.5
-             |
-             |To silence this warning set the system property:
-             |`-Dcats.effect.warnOnNonMainThreadDetected=false`.
-             |""".stripMargin
-        )
-    else ()
-  }
-
   /**
    * The entry point for your application. Will be called by the runtime when the process is
    * started. If the underlying runtime supports it, any arguments passed to the process will be
@@ -359,9 +325,7 @@ trait IOApp extends IOAppPlatform {
   def run(args: List[String]): IO[ExitCode]
 
   final def main(args: Array[String]): Unit = {
-    // checked in openjdk 8-17; this attempts to detect when we're running under artificial environments, like sbt
-    val isForked = Thread.currentThread().getId() == 1
-    if (!isForked) onNonMainThreadDetected()
+    checkRunningOnNonMainThread()
 
     val installed = if (runtime == null) {
       import unsafe.IORuntime

core/jvm/src/main/scala/cats/effect/IOAppPlatform.scala

@@ -1,5 +1,58 @@
+/*
+ * Copyright 2020-2025 Typelevel
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package cats.effect
 
 trait IOAppPlatform extends IOAppCommon with IOAppMultiThreaded {
 
+  /**
+   * Defines what to do when IOApp detects that `main` is being invoked on a `Thread` which
+   * isn't the main process thread. This condition can happen when we are running inside of an
+   * `sbt run` with `fork := false`
+   */
+  protected def warnOnNonMainThreadDetected: Boolean =
+    Option(System.getProperty("cats.effect.warnOnNonMainThreadDetected"))
+      .forall(_.equalsIgnoreCase("true"))
+
+  private def onNonMainThreadDetected(): Unit = {
+    if (warnOnNonMainThreadDetected)
+      System
+        .err
+        .println(
+          """|[WARNING] IOApp `main` is running on a thread other than the main thread.
+             |This may prevent correct resource cleanup after `main` completes.
+             |This condition could be caused by executing `run` in an interactive sbt session with `fork := false`.
+             |To ensure proper cleanup, either
+             |  - set `Compile / run / fork := true` in this project
+             |  - use `fgRun` instead of `run`
+             |  - use 'bgStop` to terminate `run`
+             |  - update sbt to a version after 1.10.5
+             |
+             |To silence this warning set the system property:
+             |`-Dcats.effect.warnOnNonMainThreadDetected=false`.
+             |""".stripMargin
+        )
+    else ()
+  }
+
+  // checked in openjdk 8-17; this attempts to detect when we're running under artificial environments, like sbt
+  protected lazy val isForked: Boolean = Thread.currentThread().getId == 1
+
+  override protected def checkRunningOnNonMainThread(): Unit = {
+    if (!isForked) onNonMainThreadDetected()
+    else ()
+  }
 }

core/native/src/main/scala/cats/effect/IOApp.scala

@@ -254,6 +254,8 @@ trait IOApp extends IOAppPlatform {
   def run(args: List[String]): IO[ExitCode]
 
   final def main(args: Array[String]): Unit = {
+    checkRunningOnNonMainThread()
+
     val installed = if (runtime == null) {
       import unsafe.IORuntime
 

core/shared/src/main/scala/cats/effect/IOAppCommon.scala

@@ -38,4 +38,10 @@ trait IOAppCommon {
    */
   protected def onCpuStarvationWarn(metrics: CpuStarvationWarningMetrics): IO[Unit] =
     CpuStarvationCheck.logWarning(metrics)
+
+  /**
+   * Check if running on a non-main thread. Only applicable to JVM where it could occur if run in
+   * `sbt` with `fork := false`.
+   */
+  protected def checkRunningOnNonMainThread(): Unit = ()
 }