Remove static logger.

src/main/scala/com/rawlabs/utils/core/RawMBeansManager.scala

@@ -12,8 +12,6 @@
 
 package com.rawlabs.utils.core
 
-import com.typesafe.scalalogging.StrictLogging
-
 import java.lang.management.ManagementFactory
 import javax.management.ObjectName
 import scala.util.control.NonFatal
@@ -31,7 +29,7 @@ trait RawMBean {
   def getMBeanName: String
 }
 
-object RawMBeansManager extends StrictLogging {
+object RawMBeansManager {
 
   private val mbs = ManagementFactory.getPlatformMBeanServer
   private var mbeanMap = Map.empty[String, RawMBean]
@@ -46,9 +44,7 @@ object RawMBeansManager extends StrictLogging {
     require(mbean != null, "MBean cannot be null")
     require(mbean.getMBeanName != null, "MBean name cannot be null")
     mbeanLock.synchronized {
-      if (mbs.isRegistered(new ObjectName(mbean.getMBeanName))) {
-        logger.warn(s"MBean ${mbean.getMBeanName} already registered")
-      } else {
+      if (!mbs.isRegistered(new ObjectName(mbean.getMBeanName))) {
         val objectName = new ObjectName(mbean.getMBeanName)
         mbs.registerMBean(mbean, objectName)
         mbeanMap += (mbean.getMBeanName -> mbean)
@@ -68,8 +64,6 @@ object RawMBeansManager extends StrictLogging {
       if (mbs.isRegistered(objectName)) {
         mbs.unregisterMBean(objectName)
         mbeanMap -= name
-      } else {
-        logger.warn(s"MBean $name is not registered")
       }
     }
   }

src/main/scala/com/rawlabs/utils/core/RawService.scala

@@ -12,7 +12,7 @@
 
 package com.rawlabs.utils.core
 
-import com.typesafe.scalalogging.StrictLogging
+import com.typesafe.scalalogging.Logger
 
 import java.util.concurrent.LinkedBlockingQueue
 import java.util.concurrent.atomic.AtomicBoolean
@@ -39,11 +39,13 @@ object RawService {
  *
  * Used for services (aka. components/modules) that may require centralized stopping.
  */
-trait RawService extends StrictLogging {
+trait RawService {
 
   import RawService._
   protected val stopped = new AtomicBoolean(false)
 
+  protected def logger: Logger
+
   logger.debug(s"Adding service: $this")
   services.add(this)
 

src/main/scala/com/rawlabs/utils/core/RawSettings.scala

@@ -13,7 +13,7 @@
 package com.rawlabs.utils.core
 
 import com.typesafe.config._
-import com.typesafe.scalalogging.StrictLogging
+import com.typesafe.scalalogging.Logger
 
 import java.time.Duration
 import java.util.concurrent.TimeUnit
@@ -30,9 +30,10 @@ object RawSettings {
 }
 
 class RawSettings(
+    logger: Logger,
     protected val lowPriorityConfig: Config = ConfigFactory.load(),
     protected val highPriorityConfig: Config = ConfigFactory.empty()
-) extends StrictLogging {
+) {
 
   import RawSettings._
 
@@ -54,8 +55,9 @@ class RawSettings(
     }
   }
 
-  def this(renderAsString: String) = {
+  def this(logger: Logger, renderAsString: String) = {
     this(
+      logger,
       try {
         ConfigFactory.parseString(renderAsString)
       } catch {
@@ -105,22 +107,23 @@ class RawSettings(
       .withFallback(moduleConfig)
       .withFallback(ConfigFactory.defaultReference())
       .resolve()
-    new RawSettings(config, highPriorityConfig)
+    new RawSettings(logger, config, highPriorityConfig)
   }
 
   def withFallback(settings: RawSettings): RawSettings = {
     new RawSettings(
+      logger,
       lowPriorityConfig.withFallback(settings.lowPriorityConfig),
       highPriorityConfig.withFallback(settings.highPriorityConfig)
     )
   }
 
   def cloneWith(settings: Map[String, Any]): RawSettings = {
-    new RawSettings(lowPriorityConfig, ConfigFactory.parseMap(settings.asJava).withFallback(highPriorityConfig))
+    new RawSettings(logger, lowPriorityConfig, ConfigFactory.parseMap(settings.asJava).withFallback(highPriorityConfig))
   }
 
   def cloneWith(settings: String): RawSettings = {
-    new RawSettings(lowPriorityConfig, ConfigFactory.parseString(settings).withFallback(highPriorityConfig))
+    new RawSettings(logger, lowPriorityConfig, ConfigFactory.parseString(settings).withFallback(highPriorityConfig))
   }
 
   def cloneWith(settings: (String, Any)*): RawSettings = {

src/main/scala/com/rawlabs/utils/core/RawUtils.scala

@@ -14,7 +14,7 @@ package com.rawlabs.utils.core
 
 import com.google.common.io.Resources
 import com.google.common.util.concurrent.ThreadFactoryBuilder
-import com.typesafe.scalalogging.StrictLogging
+import com.typesafe.scalalogging.Logger
 import org.apache.commons.io.FileUtils
 
 import java.io.{ByteArrayOutputStream, InputStream}
@@ -31,11 +31,8 @@ import org.apache.commons.text.StringEscapeUtils
 
 /**
  * "Random" collection of utility methods.
- *
- * NOTE that this classes uses the `StrictLogging` trait from the `com.typesafe.scalalogging` package.
- * TODO (msb): Remove StrictLogging and make logger a parameter where needed.
  */
-object RawUtils extends StrictLogging {
+object RawUtils {
 
   /**
    * Convert a user string back to its original "intended" representation.
@@ -71,12 +68,14 @@ object RawUtils extends StrictLogging {
     )
   }
 
-  def newThreadFactory(name: String, daemon: Boolean = true): ThreadFactory = {
+  def newThreadFactory(name: String, maybeLogger: Option[Logger] = None, daemon: Boolean = true): ThreadFactory = {
     new ThreadFactoryBuilder()
       .setNameFormat(s"$name-%d")
-      .setUncaughtExceptionHandler((t: Thread, e: Throwable) => {
-        logger.warn(s"Uncaught exception on thread: ${t.getName}", e)
-      })
+      .setUncaughtExceptionHandler {
+        case (t: Thread, e: Throwable) => {
+          maybeLogger.foreach(_.warn(s"Uncaught exception on thread: ${t.getName}", e))
+        }
+      }
       .setDaemon(daemon)
       .build()
   }
@@ -105,26 +104,22 @@ object RawUtils extends StrictLogging {
     System.getProperty("os.name").toLowerCase().contains("mac os x")
   }
 
-  def withSuppressNonFatalException(f: => Unit, silent: Boolean = false): Unit = {
+  def withSuppressNonFatalException(f: => Unit, maybeLogger: Option[Logger] = None): Unit = {
     if (Thread.interrupted()) {
       throw new InterruptedException()
     }
     try {
       f
     } catch {
-      case NonFatal(t) => if (!silent) {
-          logger.warn("Suppressing uncaught exception: ", t)
-        }
+      case NonFatal(t) => maybeLogger.foreach(_.warn("Suppressing uncaught exception: ", t))
     }
   }
 
-  def withSuppressNonFatalExceptionUninterruptible(f: => Unit, silent: Boolean = false): Unit = {
+  def withSuppressNonFatalExceptionUninterruptible(f: => Unit, maybeLogger: Option[Logger] = None): Unit = {
     try {
       f
     } catch {
-      case NonFatal(t) => if (!silent) {
-          logger.warn("Suppressing uncaught exception: ", t)
-        }
+      case NonFatal(t) => maybeLogger.foreach(_.warn("Suppressing uncaught exception: ", t))
     }
   }
 
@@ -144,10 +139,7 @@ object RawUtils extends StrictLogging {
 
   def deleteTestFile(file: Path): Unit = {
     withSuppressNonFatalException {
-      val deleted = Files.deleteIfExists(file)
-      if (!deleted) {
-        logger.warn(s"Could not delete test file: $file")
-      }
+      Files.deleteIfExists(file)
     }
   }
 

src/main/scala/com/rawlabs/utils/core/RawVerboseRunnable.scala

@@ -12,7 +12,7 @@
 
 package com.rawlabs.utils.core
 
-import com.typesafe.scalalogging.StrictLogging
+import com.typesafe.scalalogging.Logger
 
 /**
  * Wraps a Runnable to log any uncaught exceptions.
@@ -28,7 +28,7 @@ import com.typesafe.scalalogging.StrictLogging
  * @param delegate The runnable to wrap.
  * @param propagate Whether to rethrow the exception.
  */
-class RawVerboseRunnable(delegate: Runnable, propagate: Boolean = false) extends Runnable with StrictLogging {
+class RawVerboseRunnable(logger: Logger, delegate: Runnable, propagate: Boolean = false) extends Runnable {
   override def run(): Unit = {
     try {
       delegate.run()

src/test/scala/com/rawlabs/utils/core/SettingsTestContext.scala

@@ -13,14 +13,16 @@
 package com.rawlabs.utils.core
 
 import com.typesafe.config.ConfigFactory
+import com.typesafe.scalalogging.StrictLogging
 
 import scala.collection.JavaConverters._
 import scala.collection.mutable
 
-trait SettingsTestContext {
+trait SettingsTestContext extends StrictLogging {
   protected var properties: mutable.Map[String, Any] = mutable.Map[String, Any]()
 
   implicit def settings: RawSettings = new RawSettings(
+    logger,
     ConfigFactory.load(),
     ConfigFactory.parseMap(properties.asJava)
   )