diff --git a/api/src/main/scala/com/lbs/api/http/package.scala b/api/src/main/scala/com/lbs/api/http/package.scala
index 81258fe..96861e9 100644
--- a/api/src/main/scala/com/lbs/api/http/package.scala
+++ b/api/src/main/scala/com/lbs/api/http/package.scala
@@ -6,14 +6,13 @@ import cats.implicits._
 import com.lbs.api.exception._
 import com.lbs.api.json.JsonSerializer.extensions._
 import com.lbs.api.json.model._
-import com.lbs.common.Logger
+import com.typesafe.scalalogging.StrictLogging
 import scalaj.http.{HttpRequest, HttpResponse}
 
 import java.net.{HttpCookie, HttpURLConnection}
-import scala.language.higherKinds
 import scala.util.{Failure, Success, Try}
 
-package object http extends Logger {
+package object http extends StrictLogging {
 
   case class Session(accessToken: String, tokenType: String, cookies: Seq[HttpCookie])
 
@@ -37,9 +36,9 @@ package object http extends Logger {
   implicit class ExtendedHttpRequest[F[_] : ThrowableMonad](httpRequest: HttpRequest) {
     def invoke: F[HttpResponse[String]] = {
       val me = MonadError[F, Throwable]
-      debug(s"Sending request:\n${hideSensitive(httpRequest)}")
+      logger.debug(s"Sending request:\n${hideSensitive(httpRequest)}")
       val httpResponse = me.pure(httpRequest.asString)
-      debug(s"Received response:\n${hideSensitive(httpResponse)}")
+      logger.debug(s"Received response:\n${hideSensitive(httpResponse)}")
 
       httpResponse.flatMap { response =>
         val errorMaybe = extractLuxmedError(response)
diff --git a/api/src/main/scala/com/lbs/api/json/JsonSerializer.scala b/api/src/main/scala/com/lbs/api/json/JsonSerializer.scala
index 17fed21..6378c2f 100644
--- a/api/src/main/scala/com/lbs/api/json/JsonSerializer.scala
+++ b/api/src/main/scala/com/lbs/api/json/JsonSerializer.scala
@@ -2,7 +2,7 @@
 package com.lbs.api.json
 
 import com.lbs.api.json.model.{LuxmedFunnyDateTime, SerializableJsonObject}
-import com.lbs.common.Logger
+import com.typesafe.scalalogging.StrictLogging
 import org.json4s._
 import org.json4s.jackson.JsonMethods._
 
@@ -11,7 +11,7 @@ import java.time.{LocalDateTime, LocalTime, ZonedDateTime}
 import scala.util.Try
 
 
-object JsonSerializer extends Logger {
+object JsonSerializer extends StrictLogging {
 
   private val zonedDateTimeSerializer = new CustomSerializer[ZonedDateTime](_ => ( {
     case JString(str) => ZonedDateTime.parse(str, DateTimeFormatter.ISO_OFFSET_DATE_TIME)
@@ -54,7 +54,7 @@ object JsonSerializer extends Logger {
 
   def write[T](jsonObject: T): String = {
     val json = pretty(render(Extraction.decompose(jsonObject)))
-    info(json)
+    logger.info(json)
     json
   }
 
diff --git a/bot/src/main/scala/com/lbs/bot/Bot.scala b/bot/src/main/scala/com/lbs/bot/Bot.scala
index 154aacd..8caebef 100644
--- a/bot/src/main/scala/com/lbs/bot/Bot.scala
+++ b/bot/src/main/scala/com/lbs/bot/Bot.scala
@@ -3,9 +3,9 @@ package com.lbs.bot
 
 import com.lbs.bot.model._
 import com.lbs.bot.telegram.TelegramBot
-import com.lbs.common.Logger
+import com.typesafe.scalalogging.LazyLogging
 
-class Bot(telegram: TelegramBot /* other bots */) extends Logger {
+class Bot(telegram: TelegramBot /* other bots */) extends LazyLogging {
   def sendMessage(source: MessageSource, text: String): Unit =
     resolveAdapter(source).sendMessage(source.chatId, text)
 
diff --git a/bot/src/main/scala/com/lbs/bot/telegram/TelegramClient.scala b/bot/src/main/scala/com/lbs/bot/telegram/TelegramClient.scala
index e50a5d7..0e12ad1 100644
--- a/bot/src/main/scala/com/lbs/bot/telegram/TelegramClient.scala
+++ b/bot/src/main/scala/com/lbs/bot/telegram/TelegramClient.scala
@@ -8,11 +8,11 @@ import com.bot4s.telegram.clients.AkkaHttpClient
 import com.bot4s.telegram.future.{Polling, TelegramBot => TelegramBoT}
 import com.bot4s.telegram.methods._
 import com.bot4s.telegram.models.{InlineKeyboardMarkup, InputFile, Message}
-import com.lbs.common.Logger
+import com.typesafe.scalalogging.StrictLogging
 
 import scala.concurrent.Future
 
-class TelegramClient(onReceive: TelegramEvent => Unit, botToken: String) extends AkkaTelegramBot with TelegramBoT with Polling with Commands[Future] with Callbacks[Future] with Logger {
+class TelegramClient(onReceive: TelegramEvent => Unit, botToken: String) extends AkkaTelegramBot with TelegramBoT with Polling with Commands[Future] with Callbacks[Future] with StrictLogging {
 
   override val client: RequestHandler[Future] = new AkkaHttpClient(botToken)
 
@@ -32,18 +32,18 @@ class TelegramClient(onReceive: TelegramEvent => Unit, botToken: String) extends
     loggingRequest(SendDocument(chatId, InputFile(filename, contents), caption = caption))
 
   private def loggingRequest[R: Manifest](req: Request[R]): Future[R] = {
-    debug(s"Sending telegram request: $req")
+    logger.debug(s"Sending telegram request: $req")
     request(req)
   }
 
 
   override def receiveMessage(msg: Message): Future[Unit] = {
-    debug(s"Received telegram message: $msg")
+    logger.debug(s"Received telegram message: $msg")
     Future.successful(onReceive(TelegramEvent(msg, None)))
   }
 
   onCallbackWithTag(TagPrefix) { implicit cbq =>
-    debug(s"Received telegram callback: $cbq")
+    logger.debug(s"Received telegram callback: $cbq")
     val ack = ackCallback()
     val maybeOnReceive = for {
       data <- cbq.data.map(_.stripPrefix(TagPrefix))
diff --git a/common/build.gradle b/common/build.gradle
index 66d8a81..b664463 100644
--- a/common/build.gradle
+++ b/common/build.gradle
@@ -1,4 +1,5 @@
 dependencies {
     api "ch.qos.logback:logback-classic:1.2.11"
     api "org.typelevel:cats-core_$scala:2.8.0"
+    api "com.typesafe.scala-logging:scala-logging_$scala:3.9.5"
 }
diff --git a/common/src/main/scala/com/lbs/common/Logger.scala b/common/src/main/scala/com/lbs/common/Logger.scala
deleted file mode 100644
index 826a334..0000000
--- a/common/src/main/scala/com/lbs/common/Logger.scala
+++ /dev/null
@@ -1,45 +0,0 @@
-
-package com.lbs.common
-
-import org.slf4j
-import org.slf4j.LoggerFactory
-
-trait Logger {
-  private val log: slf4j.Logger = LoggerFactory.getLogger(this.getClass)
-
-  protected def debug(msg: => String): Unit = {
-    if (log.isDebugEnabled)
-      log.debug(msg)
-  }
-
-  protected def warn(msg: => String): Unit = {
-    if (log.isWarnEnabled)
-      log.warn(msg)
-  }
-
-  protected def warn(msg: => String, throwable: Throwable): Unit = {
-    if (log.isWarnEnabled)
-      log.warn(msg, throwable)
-  }
-
-  protected def error(msg: => String): Unit = {
-    if (log.isErrorEnabled)
-      log.error(msg)
-  }
-
-  protected def error(msg: => String, throwable: Throwable): Unit = {
-    if (log.isErrorEnabled)
-      log.error(msg, throwable)
-  }
-
-  protected def info(msg: => String): Unit = {
-    if (log.isInfoEnabled)
-      log.info(msg)
-  }
-
-  protected def trace(msg: => String): Unit = {
-    if (log.isTraceEnabled)
-      log.trace(msg)
-  }
-
-}
diff --git a/common/src/main/scala/com/lbs/common/Scheduler.scala b/common/src/main/scala/com/lbs/common/Scheduler.scala
index 9f3a409..bca6a98 100644
--- a/common/src/main/scala/com/lbs/common/Scheduler.scala
+++ b/common/src/main/scala/com/lbs/common/Scheduler.scala
@@ -1,10 +1,12 @@
 
 package com.lbs.common
 
+import com.typesafe.scalalogging.LazyLogging
+
 import java.util.concurrent.{Executors, ScheduledFuture}
 import scala.concurrent.duration.FiniteDuration
 
-class Scheduler(poolSize: Int) extends Logger {
+class Scheduler(poolSize: Int) extends LazyLogging {
   private val scheduledThreadPool = Executors.newScheduledThreadPool(poolSize)
 
   def schedule(fn: => Unit, period: FiniteDuration): ScheduledFuture[_] = {
@@ -22,7 +24,7 @@ class Scheduler(poolSize: Int) extends Logger {
         fn
       } catch {
         case ex: Exception =>
-          error(s"Unable to execute scheduler task", ex)
+          logger.error(s"Unable to execute scheduler task", ex)
       }
   }
 }
diff --git a/server/src/main/scala/com/lbs/server/Boot.scala b/server/src/main/scala/com/lbs/server/Boot.scala
index 1309c68..9cd9263 100644
--- a/server/src/main/scala/com/lbs/server/Boot.scala
+++ b/server/src/main/scala/com/lbs/server/Boot.scala
@@ -1,7 +1,7 @@
 
 package com.lbs.server
 
-import com.lbs.common.Logger
+import com.typesafe.scalalogging.StrictLogging
 import org.springframework.boot.SpringApplication
 import org.springframework.boot.autoconfigure.SpringBootApplication
 
@@ -9,10 +9,10 @@ import org.springframework.boot.autoconfigure.SpringBootApplication
 @SpringBootApplication
 class Boot
 
-object Boot extends App with Logger {
+object Boot extends App with StrictLogging {
 
   def printInfo(): Unit = {
-    info(s"Num processors: ${Runtime.getRuntime.availableProcessors}")
+    logger.info(s"Num processors: ${Runtime.getRuntime.availableProcessors}")
   }
 
   printInfo()
diff --git a/server/src/main/scala/com/lbs/server/conversation/Account.scala b/server/src/main/scala/com/lbs/server/conversation/Account.scala
index e9ae5f7..bf204fe 100644
--- a/server/src/main/scala/com/lbs/server/conversation/Account.scala
+++ b/server/src/main/scala/com/lbs/server/conversation/Account.scala
@@ -46,7 +46,7 @@ class Account(val userId: UserId, bot: Bot, dataService: DataService, val locali
           bot.sendMessage(userId.source, lang.accountSwitched(account.username))
         }
       case None =>
-        error(s"This is not user [#${userId.userId}] account [#$accountId]")
+        logger.error(s"This is not user [#${userId.userId}] account [#$accountId]")
     }
   }
 }
diff --git a/server/src/main/scala/com/lbs/server/conversation/Auth.scala b/server/src/main/scala/com/lbs/server/conversation/Auth.scala
index 6be2d7b..bfdfdc4 100644
--- a/server/src/main/scala/com/lbs/server/conversation/Auth.scala
+++ b/server/src/main/scala/com/lbs/server/conversation/Auth.scala
@@ -3,14 +3,14 @@ package com.lbs.server.conversation
 
 import akka.actor.ActorSystem
 import com.lbs.bot.model.{Command, MessageSource}
-import com.lbs.common.Logger
 import com.lbs.server.conversation.Login.{LoggedIn, UserId}
 import com.lbs.server.conversation.base.Conversation
 import com.lbs.server.service.DataService
 import com.lbs.server.util.MessageExtractors._
+import com.typesafe.scalalogging.StrictLogging
 
 class Auth(val source: MessageSource, dataService: DataService, unauthorizedHelpFactory: MessageSourceTo[UnauthorizedHelp],
-           loginFactory: MessageSourceWithOriginatorTo[Login], chatFactory: UserIdTo[Chat])(val actorSystem: ActorSystem) extends Conversation[Unit] with Logger {
+           loginFactory: MessageSourceWithOriginatorTo[Login], chatFactory: UserIdTo[Chat])(val actorSystem: ActorSystem) extends Conversation[Unit] with StrictLogging {
 
   private val login = loginFactory(source, self)
   private val unauthorizedHelp = unauthorizedHelpFactory(source)
diff --git a/server/src/main/scala/com/lbs/server/conversation/Book.scala b/server/src/main/scala/com/lbs/server/conversation/Book.scala
index f51cd4e..aa9bc0d 100644
--- a/server/src/main/scala/com/lbs/server/conversation/Book.scala
+++ b/server/src/main/scala/com/lbs/server/conversation/Book.scala
@@ -151,12 +151,12 @@ class Book(val userId: UserId, bot: Bot, apiService: ApiService, dataService: Da
         } yield (lockTermResponse, xsrfToken)
         response match {
           case Left(ex) =>
-            error("Can not lock term", ex)
+            logger.error("Can not lock term", ex)
             bot.sendMessage(userId.source, ex.getMessage)
             end()
           case Right((reservationLocktermResponse, xsrfToken)) =>
             if (reservationLocktermResponse.value.changeTermAvailable) {
-              warn(s"Service [${bookingData.serviceId.name}] is already booked. Ask to update term")
+              logger.warn(s"Service [${bookingData.serviceId.name}] is already booked. Ask to update term")
               bot.sendMessage(userId.source, lang.visitAlreadyExists,
                 inlineKeyboard = createInlineKeyboard(Seq(Button(lang.no, Tags.No), Button(lang.yes, Tags.Yes))))
               goto(awaitRebookDecision) using bookingData.copy(term = Some(term), xsrfToken = Some(xsrfToken), reservationLocktermResponse = Some(reservationLocktermResponse))
@@ -195,15 +195,15 @@ class Book(val userId: UserId, bot: Bot, apiService: ApiService, dataService: Da
         apiService.reservationChangeTerm(userId.accountId, bookingData.xsrfToken.get,
           (bookingData.reservationLocktermResponse.get, bookingData.term.get).mapTo[ReservationChangetermRequest]) match {
           case Right(success) =>
-            debug(s"Successfully confirmed: $success")
+            logger.debug(s"Successfully confirmed: $success")
             bot.sendMessage(userId.source, lang.appointmentIsConfirmed)
           case Left(ex) =>
-            error("Error during reservation", ex)
+            logger.error("Error during reservation", ex)
             bot.sendMessage(userId.source, ex.getMessage)
         }
         end()
       case Msg(CallbackCommand(Tags.No), _) =>
-        info("User doesn't want to change term")
+        logger.info("User doesn't want to change term")
         end()
     }
 
@@ -227,10 +227,10 @@ class Book(val userId: UserId, bot: Bot, apiService: ApiService, dataService: Da
       case Some(reservationRequest) =>
         apiService.reservationConfirm(userId.accountId, bookingData.xsrfToken.get, reservationRequest) match {
           case Left(ex) =>
-            error("Error during reservation", ex)
+            logger.error("Error during reservation", ex)
             bot.sendMessage(userId.source, ex.getMessage)
           case Right(success) =>
-            debug(s"Successfully confirmed: $success")
+            logger.debug(s"Successfully confirmed: $success")
             bot.sendMessage(userId.source, lang.appointmentIsConfirmed)
         }
       case _ => sys.error(s"Can not prepare reservation request using booking data $bookingData")
@@ -270,13 +270,13 @@ class Book(val userId: UserId, bot: Bot, apiService: ApiService, dataService: Da
 
   private def createMonitoring: Step =
     process { bookingData =>
-      debug(s"Creating monitoring for $bookingData")
+      logger.debug(s"Creating monitoring for $bookingData")
       try {
         monitoringService.createMonitoring((userId -> bookingData).mapTo[Monitoring])
         bot.sendMessage(userId.source, lang.monitoringHasBeenCreated)
       } catch {
         case ex: Exception =>
-          error("Unable to create monitoring", ex)
+          logger.error("Unable to create monitoring", ex)
           bot.sendMessage(userId.source, lang.unableToCreateMonitoring(ex.getMessage))
       }
       end()
diff --git a/server/src/main/scala/com/lbs/server/conversation/BookWithTemplate.scala b/server/src/main/scala/com/lbs/server/conversation/BookWithTemplate.scala
index 075a21e..633c227 100644
--- a/server/src/main/scala/com/lbs/server/conversation/BookWithTemplate.scala
+++ b/server/src/main/scala/com/lbs/server/conversation/BookWithTemplate.scala
@@ -130,7 +130,7 @@ class BookWithTemplate(val userId: UserId, bot: Bot, apiService: ApiService, dat
         } yield (lockTermResponse, xsrfToken)
         response match {
           case Left(ex) =>
-            warn(s"Service [${bookingData.serviceId.name}] is already booked. Ask to update term", ex)
+            logger.warn(s"Service [${bookingData.serviceId.name}] is already booked. Ask to update term", ex)
             bot.sendMessage(userId.source, lang.visitAlreadyExists,
               inlineKeyboard = createInlineKeyboard(Seq(Button(lang.no, Tags.No), Button(lang.yes, Tags.Yes))))
             goto(awaitRebookDecision) using bookingData.copy(term = Some(term))
@@ -167,15 +167,15 @@ class BookWithTemplate(val userId: UserId, bot: Bot, apiService: ApiService, dat
       case Msg(CallbackCommand(Tags.Yes), bookingData: BookingData) =>
         apiService.reservationChangeTerm(userId.accountId, bookingData.xsrfToken.get, (bookingData.reservationLocktermResponse.get, bookingData.term.get).mapTo[ReservationChangetermRequest]) match {
           case Right(success) =>
-            debug(s"Successfully confirmed: $success")
+            logger.debug(s"Successfully confirmed: $success")
             bot.sendMessage(userId.source, lang.appointmentIsConfirmed)
           case Left(ex) =>
-            error("Error during reservation", ex)
+            logger.error("Error during reservation", ex)
             bot.sendMessage(userId.source, ex.getMessage)
         }
         end()
       case Msg(CallbackCommand(Tags.No), _) =>
-        info("User doesn't want to change term")
+        logger.info("User doesn't want to change term")
         end()
     }
 
@@ -199,10 +199,10 @@ class BookWithTemplate(val userId: UserId, bot: Bot, apiService: ApiService, dat
       case Some(reservationRequest) =>
         apiService.reservationConfirm(userId.accountId, bookingData.xsrfToken.get, reservationRequest) match {
           case Left(ex) =>
-            error("Error during reservation", ex)
+            logger.error("Error during reservation", ex)
             bot.sendMessage(userId.source, ex.getMessage)
           case Right(success) =>
-            debug(s"Successfully confirmed: $success")
+            logger.debug(s"Successfully confirmed: $success")
             bot.sendMessage(userId.source, lang.appointmentIsConfirmed)
         }
       case _ => sys.error(s"Can not prepare reservation request using booking data $bookingData")
@@ -242,13 +242,13 @@ class BookWithTemplate(val userId: UserId, bot: Bot, apiService: ApiService, dat
 
   private def createMonitoring: Step =
     process { bookingData =>
-      debug(s"Creating monitoring for $bookingData")
+      logger.debug(s"Creating monitoring for $bookingData")
       try {
         monitoringService.createMonitoring((userId -> bookingData).mapTo[Monitoring])
         bot.sendMessage(userId.source, lang.monitoringHasBeenCreated)
       } catch {
         case ex: Exception =>
-          error("Unable to create monitoring", ex)
+          logger.error("Unable to create monitoring", ex)
           bot.sendMessage(userId.source, lang.unableToCreateMonitoring(ex.getMessage))
       }
       end()
diff --git a/server/src/main/scala/com/lbs/server/conversation/Chat.scala b/server/src/main/scala/com/lbs/server/conversation/Chat.scala
index 97d2871..05b55ab 100644
--- a/server/src/main/scala/com/lbs/server/conversation/Chat.scala
+++ b/server/src/main/scala/com/lbs/server/conversation/Chat.scala
@@ -3,18 +3,18 @@ package com.lbs.server.conversation
 
 import akka.actor.ActorSystem
 import com.lbs.bot.model.Command
-import com.lbs.common.Logger
 import com.lbs.server.conversation.Chat._
 import com.lbs.server.conversation.Login.UserId
 import com.lbs.server.conversation.base.{Conversation, Interactional}
 import com.lbs.server.service.{DataService, MonitoringService}
 import com.lbs.server.util.MessageExtractors._
+import com.typesafe.scalalogging.StrictLogging
 
 import scala.util.matching.Regex
 
 class Chat(val userId: UserId, dataService: DataService, monitoringService: MonitoringService, bookingFactory: UserIdTo[Book],
            helpFactory: UserIdTo[Help], monitoringsFactory: UserIdTo[Monitorings], monitoringsHistoryFactory: UserIdTo[MonitoringsHistory], historyFactory: UserIdTo[HistoryViewer],
-           visitsFactory: UserIdTo[ReservedVisitsViewer], settingsFactory: UserIdTo[Settings], accountFactory: UserIdTo[Account])(val actorSystem: ActorSystem) extends Conversation[Unit] with Logger {
+           visitsFactory: UserIdTo[ReservedVisitsViewer], settingsFactory: UserIdTo[Settings], accountFactory: UserIdTo[Account])(val actorSystem: ActorSystem) extends Conversation[Unit] with StrictLogging {
 
   private val book = bookingFactory(userId)
   private val help = helpFactory(userId)
diff --git a/server/src/main/scala/com/lbs/server/conversation/DatePicker.scala b/server/src/main/scala/com/lbs/server/conversation/DatePicker.scala
index 81e96b1..f181fb3 100644
--- a/server/src/main/scala/com/lbs/server/conversation/DatePicker.scala
+++ b/server/src/main/scala/com/lbs/server/conversation/DatePicker.scala
@@ -74,7 +74,7 @@ class DatePicker(val userId: UserId, val bot: Bot, val localization: Localizatio
           end()
         } catch {
           case NonFatal(ex) =>
-            error("Unable to parse date", ex)
+            logger.error("Unable to parse date", ex)
             bot.sendMessage(userId.source, "Incorrect date. Please use format dd-MM")
             goto(requestDate)
         }
diff --git a/server/src/main/scala/com/lbs/server/conversation/Pager.scala b/server/src/main/scala/com/lbs/server/conversation/Pager.scala
index 9e44f68..9246977 100644
--- a/server/src/main/scala/com/lbs/server/conversation/Pager.scala
+++ b/server/src/main/scala/com/lbs/server/conversation/Pager.scala
@@ -3,18 +3,18 @@ package com.lbs.server.conversation
 
 import akka.actor.ActorSystem
 import com.lbs.bot.model.{Button, Command}
-import com.lbs.bot.{Bot, _}
-import com.lbs.common.Logger
+import com.lbs.bot._
 import com.lbs.server.conversation.Login.UserId
-import com.lbs.server.conversation.Pager.{Tags, _}
+import com.lbs.server.conversation.Pager._
 import com.lbs.server.conversation.base.{Conversation, Interactional}
 import com.lbs.server.lang.{Localizable, Localization}
 import com.lbs.server.util.MessageExtractors
+import com.typesafe.scalalogging.StrictLogging
 
 class Pager[Data](val userId: UserId, bot: Bot, makeMessage: (Data, Int, Int) => String,
                   makeHeader: (Int, Int) => String, selectionPrefix: Option[String],
                   val localization: Localization, originator: Interactional)(val actorSystem: ActorSystem)
-  extends Conversation[(ItemsProvider[Data], Option[String])] with Localizable with Logger {
+  extends Conversation[(ItemsProvider[Data], Option[String])] with Localizable with StrictLogging {
 
   private val Selection = s"/${selectionPrefix.getOrElse("")}_(\\d+)".r
 
diff --git a/server/src/main/scala/com/lbs/server/conversation/Router.scala b/server/src/main/scala/com/lbs/server/conversation/Router.scala
index a8ec754..48915e6 100644
--- a/server/src/main/scala/com/lbs/server/conversation/Router.scala
+++ b/server/src/main/scala/com/lbs/server/conversation/Router.scala
@@ -3,15 +3,15 @@ package com.lbs.server.conversation
 
 import akka.actor.{ActorSystem, Cancellable}
 import com.lbs.bot.model.{Command, MessageSource}
-import com.lbs.common.Logger
 import com.lbs.server.conversation.Account.SwitchAccount
 import com.lbs.server.conversation.base.Conversation
+import com.typesafe.scalalogging.StrictLogging
 
 import scala.collection.mutable
 import scala.concurrent.ExecutionContextExecutor
 import scala.concurrent.duration.DurationLong
 
-class Router(authFactory: MessageSourceTo[Auth])(val actorSystem: ActorSystem) extends Conversation[Unit] with Logger {
+class Router(authFactory: MessageSourceTo[Auth])(val actorSystem: ActorSystem) extends Conversation[Unit] with StrictLogging {
 
   private case class DestroyChat(source: MessageSource)
 
@@ -32,14 +32,14 @@ class Router(authFactory: MessageSourceTo[Auth])(val actorSystem: ActorSystem) e
         chat ! cmd
         stay()
       case Msg(DestroyChat(source), _) =>
-        info(s"Destroying chat for $source due to $idleTimeout of inactivity")
+        logger.info(s"Destroying chat for $source due to $idleTimeout of inactivity")
         destroyChat(source)
         stay()
       case Msg(SwitchAccount(userId), _) =>
         switchAccount(userId)
         stay()
       case msg: Msg =>
-        info(s"Unknown message received: $msg")
+        logger.info(s"Unknown message received: $msg")
         stay()
     }
 
diff --git a/server/src/main/scala/com/lbs/server/conversation/TimePicker.scala b/server/src/main/scala/com/lbs/server/conversation/TimePicker.scala
index a825e27..b7caf91 100644
--- a/server/src/main/scala/com/lbs/server/conversation/TimePicker.scala
+++ b/server/src/main/scala/com/lbs/server/conversation/TimePicker.scala
@@ -69,7 +69,7 @@ class TimePicker(val userId: UserId, val bot: Bot, val localization: Localizatio
           end()
         } catch {
           case NonFatal(ex) =>
-            error("Unable to parse time", ex)
+            logger.error("Unable to parse time", ex)
             bot.sendMessage(userId.source, "Incorrect time. Please use format HH:mm")
             goto(requestTime)
         }
diff --git a/server/src/main/scala/com/lbs/server/conversation/base/Conversation.scala b/server/src/main/scala/com/lbs/server/conversation/base/Conversation.scala
index 9f81497..8644c5a 100644
--- a/server/src/main/scala/com/lbs/server/conversation/base/Conversation.scala
+++ b/server/src/main/scala/com/lbs/server/conversation/base/Conversation.scala
@@ -1,10 +1,10 @@
 package com.lbs.server.conversation.base
 
-import com.lbs.common.Logger
+import com.typesafe.scalalogging.StrictLogging
 
 import scala.util.control.NonFatal
 
-trait Conversation[D] extends Domain[D] with Interactional with Logger {
+trait Conversation[D] extends Domain[D] with Interactional with StrictLogging {
 
   private var currentData: D = _
 
@@ -16,7 +16,7 @@ trait Conversation[D] extends Domain[D] with Interactional with Logger {
 
   private val defaultMsgHandler: MessageProcessorFn = {
     case Msg(any, data) =>
-      warn(s"Unhandled message received in step '${currentStep.name}'. Message: [$any]. Data: [$data]")
+      logger.warn(s"Unhandled message received in step '${currentStep.name}'. Message: [$any]. Data: [$data]")
       NextStep(currentStep, Some(data))
   }
 
@@ -32,7 +32,7 @@ trait Conversation[D] extends Domain[D] with Interactional with Logger {
         case _ => //do nothing
       }
     } catch {
-      case NonFatal(ex) => error("Step execution failed", ex)
+      case NonFatal(ex) => logger.error("Step execution failed", ex)
     }
   }
 
@@ -42,7 +42,7 @@ trait Conversation[D] extends Domain[D] with Interactional with Logger {
         val nextStep = if (fn.isDefinedAt(unit)) fn(unit) else defaultFn(unit)
         moveToNextStep(nextStep)
       } catch {
-        case NonFatal(ex) => error("Step transition failed", ex)
+        case NonFatal(ex) => logger.error("Step transition failed", ex)
       }
     }
 
@@ -58,7 +58,7 @@ trait Conversation[D] extends Domain[D] with Interactional with Logger {
   }
 
   private def moveToNextStep(nextStep: NextStep): Unit = {
-    trace(s"Moving from step '${currentStep.name}' to step '${nextStep.step.name}'")
+    logger.trace(s"Moving from step '${currentStep.name}' to step '${nextStep.step.name}'")
     currentStep = nextStep.step
     nextStep.data.foreach { data =>
       currentData = data
diff --git a/server/src/main/scala/com/lbs/server/conversation/base/Interactional.scala b/server/src/main/scala/com/lbs/server/conversation/base/Interactional.scala
index 2cf7d90..d4c9ac6 100644
--- a/server/src/main/scala/com/lbs/server/conversation/base/Interactional.scala
+++ b/server/src/main/scala/com/lbs/server/conversation/base/Interactional.scala
@@ -1,11 +1,11 @@
 package com.lbs.server.conversation.base
 
 import akka.actor.{Actor, ActorRef, ActorSystem, PoisonPill, Props}
-import com.lbs.common.Logger
+import com.typesafe.scalalogging.StrictLogging
 
 import scala.concurrent.ExecutionContextExecutor
 
-trait Interactional extends Logger {
+trait Interactional extends StrictLogging {
 
   private[base] object StartConversation
 
diff --git a/server/src/main/scala/com/lbs/server/service/MonitoringService.scala b/server/src/main/scala/com/lbs/server/service/MonitoringService.scala
index 560b96b..f2bb361 100644
--- a/server/src/main/scala/com/lbs/server/service/MonitoringService.scala
+++ b/server/src/main/scala/com/lbs/server/service/MonitoringService.scala
@@ -5,11 +5,12 @@ import com.lbs.api.exception.InvalidLoginOrPasswordException
 import com.lbs.api.json.model._
 import com.lbs.bot.Bot
 import com.lbs.bot.model.{MessageSource, MessageSourceSystem}
-import com.lbs.common.{Logger, Scheduler}
+import com.lbs.common.Scheduler
 import com.lbs.server.lang.Localization
 import com.lbs.server.repository.model._
 import com.lbs.server.util.DateTimeUtil._
 import com.lbs.server.util.ServerModelConverters._
+import com.typesafe.scalalogging.StrictLogging
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.stereotype.Service
 
@@ -21,7 +22,7 @@ import scala.concurrent.duration._
 import scala.util.Random
 
 @Service
-class MonitoringService extends Logger {
+class MonitoringService extends StrictLogging {
 
   @Autowired
   private var bot: Bot = _
@@ -65,14 +66,14 @@ class MonitoringService extends Logger {
   }
 
   private def monitor(monitoring: Monitoring): Unit = {
-    debug(s"Looking for available terms. Monitoring [#${monitoring.recordId}]")
+    logger.debug(s"Looking for available terms. Monitoring [#${monitoring.recordId}]")
     val dateFrom = optimizeDateFrom(monitoring.dateFrom.toLocalDateTime, monitoring.offset)
     val termsEither = apiService.getAvailableTerms(monitoring.accountId, monitoring.cityId, monitoring.clinicId, monitoring.serviceId,
       monitoring.doctorId, dateFrom, monitoring.dateTo.toLocalDateTime, timeFrom = monitoring.timeFrom, timeTo = monitoring.timeTo)
     termsEither match {
       case Right(terms) =>
         if (terms.nonEmpty) {
-          debug(s"Found ${terms.length} terms by monitoring [#${monitoring.recordId}]")
+          logger.debug(s"Found ${terms.length} terms by monitoring [#${monitoring.recordId}]")
           if (monitoring.autobook) {
             val term = terms.head
             bookAppointment(term, monitoring, monitoring.rebookIfExists)
@@ -80,16 +81,16 @@ class MonitoringService extends Logger {
             notifyUserAboutTerms(terms, monitoring)
           }
         } else {
-          debug(s"No new terms found for monitoring [#${monitoring.recordId}]")
+          logger.debug(s"No new terms found for monitoring [#${monitoring.recordId}]")
         }
       case Left(ex: InvalidLoginOrPasswordException) =>
-        error(s"User entered invalid name or password. Monitoring will be disabled", ex)
+        logger.error(s"User entered invalid name or password. Monitoring will be disabled", ex)
         bot.sendMessage(monitoring.source, lang(monitoring.userId).invalidLoginOrPassword)
         val activeUserMonitorings = dataService.getActiveMonitorings(monitoring.accountId)
         activeUserMonitorings.foreach { m =>
           deactivateMonitoring(m.accountId, m.recordId)
         }
-      case Left(ex) => error(s"Unable to receive terms by monitoring [#${monitoring.recordId}]", ex)
+      case Left(ex) => logger.error(s"Unable to receive terms by monitoring [#${monitoring.recordId}]", ex)
     }
   }
 
@@ -104,18 +105,18 @@ class MonitoringService extends Logger {
         val delaySnapshot = delay
         val periodSnapshot = period
         val future = monitoringExecutor.schedule(monitor(monitoring), delaySnapshot, periodSnapshot)
-        debug(s"Scheduled monitoring: [#${monitoring.recordId}] with delay: $delaySnapshot and period: $periodSnapshot")
+        logger.debug(s"Scheduled monitoring: [#${monitoring.recordId}] with delay: $delaySnapshot and period: $periodSnapshot")
         activeMonitorings += (monitoring.recordId -> (monitoring -> future))
       }
     }
-    debug(s"Number of active monitorings: ${activeMonitorings.size}")
+    logger.debug(s"Number of active monitorings: ${activeMonitorings.size}")
   }
 
   private def initializeNewMonitorings(): Unit = {
-    debug(s"Looking for new monitorings created since $checkedOn")
+    logger.debug(s"Looking for new monitorings created since $checkedOn")
     val currentTime = ZonedDateTime.now()
     val monitorings = dataService.getActiveMonitoringsSince(checkedOn)
-    debug(s"New monitorings found: ${monitorings.length}")
+    logger.debug(s"New monitorings found: ${monitorings.length}")
     checkedOn = currentTime
     initializeMonitorings(monitorings)
   }
@@ -131,7 +132,7 @@ class MonitoringService extends Logger {
     }
 
     toDisable.foreach { case (id, monitoring) =>
-      debug(s"Monitoring [#$id] is going to be disable as outdated")
+      logger.debug(s"Monitoring [#$id] is going to be disable as outdated")
       notifyChatAboutDisabledMonitoring(monitoring)
       deactivateMonitoring(monitoring.accountId, id)
     }
@@ -152,7 +153,7 @@ class MonitoringService extends Logger {
       reservationLocktermResponse <- apiService.reservationLockterm(monitoring.accountId, xsrfToken, term.mapTo[ReservationLocktermRequest])
       temporaryReservationId = reservationLocktermResponse.value.temporaryReservationId
       response <- if (reservationLocktermResponse.value.changeTermAvailable && rebookIfExists) {
-        info(s"Service [${monitoring.serviceName}] is already booked. Trying to update term")
+        logger.info(s"Service [${monitoring.serviceName}] is already booked. Trying to update term")
         bookOrUnlockTerm(monitoring.accountId, xsrfToken, temporaryReservationId, apiService.reservationChangeTerm(_, xsrfToken, (reservationLocktermResponse, term).mapTo[ReservationChangetermRequest]))
       } else {
         bookOrUnlockTerm(monitoring.accountId, xsrfToken, temporaryReservationId, apiService.reservationConfirm(_, xsrfToken, (reservationLocktermResponse, term).mapTo[ReservationConfirmRequest]))
@@ -163,7 +164,7 @@ class MonitoringService extends Logger {
         bot.sendMessage(monitoring.source, lang(monitoring.userId).appointmentIsBooked(term, monitoring))
         deactivateMonitoring(monitoring.accountId, monitoring.recordId)
       case Left(ex) =>
-        error(s"Unable to book appointment by monitoring [${monitoring.recordId}]", ex)
+        logger.error(s"Unable to book appointment by monitoring [${monitoring.recordId}]", ex)
     }
   }
 
@@ -180,14 +181,14 @@ class MonitoringService extends Logger {
     val activeMonitoringMaybe = activeMonitorings.remove(monitoringId)
     activeMonitoringMaybe match {
       case Some((monitoring, future)) =>
-        debug(s"Deactivating scheduled monitoring [#$monitoringId]")
+        logger.debug(s"Deactivating scheduled monitoring [#$monitoringId]")
         if (!future.isCancelled) {
           future.cancel(true)
         }
         monitoring.active = false
         dataService.saveMonitoring(monitoring)
       case None =>
-        debug(s"Deactivating unscheduled monitoring [#$monitoringId]")
+        logger.debug(s"Deactivating unscheduled monitoring [#$monitoringId]")
         dataService.findMonitoring(accountId, monitoringId).foreach { monitoring =>
           monitoring.active = false
           dataService.saveMonitoring(monitoring)
@@ -229,12 +230,12 @@ class MonitoringService extends Logger {
                 bot.sendMessage(monitoring.source, lang(monitoring.userId).termIsOutdated)
             }
           case Left(ex: InvalidLoginOrPasswordException) =>
-            error(s"User entered invalid name or password. Monitoring will be disabled", ex)
+            logger.error(s"User entered invalid name or password. Monitoring will be disabled", ex)
             bot.sendMessage(monitoring.source, lang(monitoring.userId).loginHasChangedOrWrong)
-          case Left(ex) => error(s"Error occurred during receiving terms for monitoring [#${monitoring.recordId}]", ex)
+          case Left(ex) => logger.error(s"Error occurred during receiving terms for monitoring [#${monitoring.recordId}]", ex)
         }
       case None =>
-        debug(s"Monitoring [#$monitoringId] not found in db")
+        logger.debug(s"Monitoring [#$monitoringId] not found in db")
     }
   }
 
@@ -250,7 +251,7 @@ class MonitoringService extends Logger {
   private def initialize(): Unit = {
     checkedOn = ZonedDateTime.now()
     val monitorings = dataService.getActiveMonitorings
-    debug(s"Active monitorings found: ${monitorings.length}")
+    logger.debug(s"Active monitorings found: ${monitorings.length}")
     initializeMonitorings(monitorings)
     disableOutdated()
     initializeDbChecker()
diff --git a/server/src/main/scala/com/lbs/server/service/SessionSupport.scala b/server/src/main/scala/com/lbs/server/service/SessionSupport.scala
index 120ff77..c8d39db 100644
--- a/server/src/main/scala/com/lbs/server/service/SessionSupport.scala
+++ b/server/src/main/scala/com/lbs/server/service/SessionSupport.scala
@@ -3,13 +3,14 @@ package com.lbs.server.service
 
 import com.lbs.api.exception.SessionExpiredException
 import com.lbs.api.http.Session
-import com.lbs.common.{Logger, ParametrizedLock}
+import com.lbs.common.ParametrizedLock
 import com.lbs.server.ThrowableOr
 import com.lbs.server.exception.UserNotFoundException
+import com.typesafe.scalalogging.StrictLogging
 
 import scala.collection.mutable
 
-trait SessionSupport extends Logger {
+trait SessionSupport extends StrictLogging {
 
   def fullLogin(username: String, password: String): ThrowableOr[Session]
 
@@ -53,11 +54,11 @@ trait SessionSupport extends Logger {
       for {
         result <- doApiCall match {
           case Left(_: SessionExpiredException) =>
-            debug(s"The session for account [#$accountId] has expired. Try to relogin")
+            logger.debug(s"The session for account [#$accountId] has expired. Try to relogin")
             sessions.remove(accountId)
             doApiCall
           case another =>
-            debug(s"Call to remote api function has completed with result:\n$another")
+            logger.debug(s"Call to remote api function has completed with result:\n$another")
             another
         }
       } yield result