adjusted logback.xml to facilitate two populated logs for different purposes; brief pass over all instance of log calls

config/logback.xml

@@ -10,24 +10,77 @@
     </filter>
   </appender>
 
-  <appender name="FILE-DEBUG" class="ch.qos.logback.core.FileAppender">
+  <appender name="FILE-GENERAL" class="ch.qos.logback.core.rolling.RollingFileAppender">
-    <file>logs/pslogin-debug_${bySecond}.log</file>
+    <file>logs/psforever-general_${bySecond}.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>logs/psforever-general_%d{yyyy-MM-dd}.gz</fileNamePattern>
+      <maxHistory>40</maxHistory>
+      <totalSizeCap>10GB</totalSizeCap>
+    </rollingPolicy>
     <encoder>
       <pattern>%date{ISO8601} %5level "%X" %logger{35} - %msg%n</pattern>
     </encoder>
+    <filter class="net.psforever.filters.LoggerPrefixFilter">
+      <!--
+       c.g.j.s.d.p.c.PostgreSQLConnectionHandler
+      -->
+      <prefix>com.github.jasync.sql.db.postgresql.codec</prefix>
+    </filter>
+    <filter class="net.psforever.filters.LoggerPrefixFilter">
+      <!--
+       i.s.c.AbstractConnection.lockdown
+       i.sentry.connection.AsyncConnection
+      -->
+      <prefix>io.sentry.connection</prefix>
+    </filter>
+    <filter class="net.psforever.filters.LoggerPrefixFilter">
+      <!-- damage log -->
+      <prefix>DamageResolution</prefix>
+    </filter>
     <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-      <level>DEBUG</level>
+      <level>INFO</level>
     </filter>
   </appender>
 
-  <appender name="FILE-TRACE" class="ch.qos.logback.core.FileAppender">
+  <appender name="FILE-DEBUG" class="ch.qos.logback.core.rolling.RollingFileAppender">
-    <file>logs/pslogin-trace_${bySecond}.log</file>
+    <file>logs/psforever-debug_${bySecond}.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>logs/psforever-debug_%d{yyyy-MM-dd}.gz</fileNamePattern>
+      <maxHistory>40</maxHistory>
+      <totalSizeCap>10GB</totalSizeCap>
+    </rollingPolicy>
     <encoder>
       <pattern>%date{ISO8601} [%thread] %5level "%X" %logger{35} - %msg%n</pattern>
     </encoder>
-    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+    <filter class="net.psforever.filters.LoggerPrefixFilter">
-        <level>OFF</level>
+      <!--
-        <!--<level>TRACE</level>-->
+       c.g.j.s.d.p.e.CloseStatementEncoder
+       c.g.j.s.d.p.e.PreparedStatementEncoderHelper
+       c.g.j.s.d.p.e.PreparedStatementOpeningEncoder
+       c.g.j.s.d.p.e.QueryMessageEncoder
+       -->
+      <prefix>com.github.jasync.sql.db.postgresql.encoders</prefix>
+    </filter>
+    <filter class="net.psforever.filters.LoggerPrefixFilter">
+      <!--
+       c.g.j.s.d.p.PostgreSQLConnection?
+       c.g.j.s.d.p.c.PostgreSQLConnectionHandler
+      -->
+      <prefix>com.github.jasync.sql.db.postgresql.codec</prefix>
+    </filter>
+    <filter class="net.psforever.filters.LoggerPrefixFilter">
+      <!-- i.g.context.jasync.JAsyncContext -->
+      <prefix>io.getquill.context.jasync</prefix>
+    </filter>
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>TRACE</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
     </filter>
   </appender>
 
@@ -39,7 +92,7 @@
 
   <root level="TRACE">
     <appender-ref ref="STDOUT"/>
-    <appender-ref ref="FILE-TRACE"/>
+    <appender-ref ref="FILE-GENERAL"/>
     <appender-ref ref="FILE-DEBUG"/>
     <appender-ref ref="Sentry"/>
   </root>

server/src/main/java/net/psforever/filters/LoggerPrefixFilter.java

@@ -0,0 +1,35 @@
+// Copyright (c) 2021 PSForever
+package net.psforever.filters;
+
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.filter.Filter;
+import ch.qos.logback.core.spi.FilterReply;
+
+/**
+ * Disrupts a variety of logging messages that originate from specific loggers.
+ * A comparison of the prefix text of the logger handling the event is performed,
+ * with a positive match denying that event being appended.
+ * The full prefix must be provided, as the is occasionally appear in an abbreviated form.
+ */
+public class LoggerPrefixFilter extends Filter<ILoggingEvent> {
+    private String prefix;
+
+    @Override
+    public FilterReply decide(ILoggingEvent event) {
+        if (isStarted() && event.getLoggerName().startsWith(prefix)) {
+            return FilterReply.DENY;
+        } else {
+            return FilterReply.NEUTRAL;
+        }
+    }
+
+    public void setPrefix(String name) {
+        this.prefix = name;
+    }
+
+    public void start() {
+        if (this.prefix != null) {
+            super.start();
+        }
+    }
+}

src/main/scala/net/psforever/actors/net/LoginActor.scala

@@ -100,10 +100,9 @@ class LoginActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], conne
         val clientVersion = s"Client Version: $majorVersion.$minorVersion.$revision, $buildDate"
 
         if (token.isDefined)
-          log.info(s"New login UN:$username Token:${token.get}. $clientVersion")
+          log.trace(s"New login UN:$username Token:${token.get}. $clientVersion")
         else {
-//        log.info(s"New login UN:$username PW:$password. $clientVersion")
+          log.trace(s"New login UN:$username. $clientVersion")
-          log.info(s"New login UN:$username. $clientVersion")
         }
 
         accountLogin(username, password.get)
@@ -115,7 +114,7 @@ class LoginActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], conne
         middlewareActor ! MiddlewareActor.Close()
 
       case _ =>
-        log.debug(s"Unhandled GamePacket $pkt")
+        log.warn(s"Unhandled GamePacket $pkt")
     }
 
   def accountLogin(username: String, password: String): Unit = {
@@ -212,7 +211,7 @@ class LoginActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], conne
   }
 
   def loginFailureResponse(username: String, newToken: String) = {
-    log.info("DB problem")
+    log.warn("DB problem")
     middlewareActor ! MiddlewareActor.Send(
       LoginRespMessage(
         newToken,
@@ -227,7 +226,7 @@ class LoginActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], conne
   }
 
   def loginAccountFailureResponse(username: String, newToken: String) = {
-    log.info(s"Account $username inactive")
+    log.warn(s"Account $username inactive")
     middlewareActor ! MiddlewareActor.Send(
       LoginRespMessage(
         newToken,

src/main/scala/net/psforever/actors/net/SocketActor.scala

@@ -82,7 +82,7 @@ object SocketActor {
           socketActor ! toSocket(message)
         }
       } else {
-        log.info("Network simulator dropped packet")
+        log.trace("Network simulator dropped packet")
       }
     }
 

src/main/scala/net/psforever/actors/session/AvatarActor.scala

@@ -485,14 +485,20 @@ class AvatarActor(
               ItemTransactionResultMessage(terminalGuid, TransactionType.Learn, success = false)
             )
           } else {
-
+            var requiredByCert: Set[Certification] = Set(certification)
-            val deps   = Certification.values.filter(_.requires.contains(certification)).toSet
+            var removeThese: Set[Certification] = Set(certification)
-            val remove = deps ++ Certification.values.filter(_.replaces.intersect(deps).nonEmpty).toSet + certification
+            val allCerts: Set[Certification] = Certification.values.toSet
+            do {
+              removeThese = allCerts.filter { testingCert =>
+                testingCert.requires.intersect(removeThese).nonEmpty
+              }
+              requiredByCert = requiredByCert ++ removeThese
+            } while(removeThese.nonEmpty)
 
             Future
               .sequence(
                 avatar.certifications
-                  .intersect(remove)
+                  .intersect(requiredByCert)
                   .map(cert => {
                     ctx
                       .run(
@@ -511,7 +517,7 @@ class AvatarActor(
                     ItemTransactionResultMessage(terminalGuid, TransactionType.Sell, success = false)
                   )
                 case Success(certs) =>
-                  context.self ! ReplaceAvatar(avatar.copy(certifications = avatar.certifications.diff(remove)))
+                  context.self ! ReplaceAvatar(avatar.copy(certifications = avatar.certifications.diff(certs)))
                   certs.foreach { cert =>
                     sessionActor ! SessionActor.SendResponse(
                       PlanetsideAttributeMessage(session.get.player.GUID, 25, cert.value)

src/main/scala/net/psforever/actors/session/ChatActor.scala

@@ -121,8 +121,6 @@ class ChatActor(
           Behaviors.same
 
         case Message(message) =>
-          log.info("Chat: " + message)
-
           val gmCommandAllowed =
             session.account.gm || Config.app.development.unprivilegedGmCommands.contains(message.messageType)
 
@@ -916,7 +914,7 @@ class ChatActor(
               }
 
             case _ =>
-              log.info(s"unhandled chat message $message")
+              log.warn(s"Unhandled chat message $message")
           }
           Behaviors.same
 
@@ -945,7 +943,7 @@ class ChatActor(
               val args = message.contents.split(" ")
               val (name, time) = (args.lift(0), args.lift(1)) match {
                 case (Some(name), _) if name != session.player.Name =>
-                  log.error("received silence message for other player")
+                  log.error("Received silence message for other player")
                   (None, None)
                 case (Some(name), None)                                     => (Some(name), Some(5))
                 case (Some(name), Some(time)) if time.toIntOption.isDefined => (Some(name), Some(time.toInt))
@@ -976,11 +974,11 @@ class ChatActor(
                   }
 
                 case (name, time) =>
-                  log.error(s"bad silence args $name $time")
+                  log.warn(s"Bad silence args $name $time")
               }
 
             case _ =>
-              log.error(s"unexpected messageType $message")
+              log.warn(s"Unexpected messageType $message")
 
           }
           Behaviors.same

src/main/scala/net/psforever/login/TcpListener.scala

@@ -26,7 +26,7 @@ class TcpListener[T <: Actor](actorClass: Class[T], nextActorName: String, liste
 
   def receive = {
     case Tcp.Bound(local) =>
-      log.info(s"Now listening on TCP:$local")
+      log.debug(s"Now listening on TCP:$local")
 
       context.become(ready(sender()))
     case Tcp.CommandFailed(Tcp.Bind(_, address, _, _, _)) =>

src/main/scala/net/psforever/objects/Deployables.scala

@@ -128,7 +128,6 @@ object Deployables {
     * @param avatar the player's core
     */
   def InitializeDeployableQuantities(avatar: Avatar): Boolean = {
-    log.info("Setting up combat engineering ...")
     avatar.deployables.Initialize(avatar.certifications)
   }
 
@@ -137,7 +136,6 @@ object Deployables {
     * @param avatar the player's core
     */
   def InitializeDeployableUIElements(avatar: Avatar): List[(Int, Int, Int, Int)] = {
-    log.info("Setting up combat engineering UI ...")
     avatar.deployables.UpdateUI()
   }
 

src/main/scala/net/psforever/objects/Vehicles.scala

@@ -226,7 +226,7 @@ object Vehicles {
     * @param unk na; used by `HackMessage` as `unk5`
     */
   def FinishHackingVehicle(target: Vehicle, hacker: Player, unk: Long)(): Unit = {
-    log.info(s"Vehicle guid: ${target.GUID} has been jacked")
+    log.info(s"Vehicle ${target.Definition.Name}#${target.GUID.guid} has been jacked by ${hacker.Name}")
     val zone = target.Zone
     // Forcefully dismount any cargo
     target.CargoHolds.values.foreach(cargoHold => {

src/main/scala/net/psforever/objects/avatar/PlayerControl.scala

@@ -328,7 +328,7 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
               )
 
             case Terminal.InfantryLoadout(exosuit, subtype, holsters, inventory) =>
-              log.info(s"wants to change equipment loadout to their option #${msg.unk1 + 1}")
+              log.info(s"${player.Name} wants to change equipment loadout to their option #${msg.unk1 + 1}")
               val fallbackSubtype = 0
               val fallbackSuit    = ExoSuitType.Standard
               val originalSuit    = player.ExoSuit
@@ -371,7 +371,7 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
                   (exosuit, subtype)
                 } else {
                   log.warn(
-                    s"no longer has permission to wear the exo-suit type $exosuit; will wear $fallbackSuit instead"
+                    s"${player.Name} no longer has permission to wear the exo-suit type $exosuit; will wear $fallbackSuit instead"
                   )
                   (fallbackSuit, fallbackSubtype)
                 }
@@ -710,6 +710,12 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
     super.CancelJammeredStatus(target)
     //uninitialize implants
     avatarActor ! AvatarActor.DeinitializeImplants()
+    cause.adversarial match {
+      case Some(a) =>
+        damageLog.info(s"DisplayDestroy: ${a.defender} was killed by ${a.attacker}")
+      case _ =>
+        damageLog.info(s"DisplayDestroy: ${player.Name} killed ${if(player.Sex==CharacterGender.Male){"himself"}else{"herself"}}.")
+    }
     events ! AvatarServiceMessage(
       nameChannel,
       AvatarAction.Killed(player_guid, target.VehicleSeated)

src/main/scala/net/psforever/objects/guid/actor/NumberPoolActor.scala

@@ -44,7 +44,7 @@ class NumberPoolActor(pool: NumberPool) extends Actor {
       sender() ! NumberPoolActor.ReturnNumberResult(number, ex, id)
 
     case msg =>
-      log.info(s"received an unexpected message - ${msg.toString}")
+      log.warn(s"Received an unexpected message - ${msg.toString}")
   }
 }
 

src/main/scala/net/psforever/objects/guid/actor/UniqueNumberSystem.scala

@@ -103,7 +103,7 @@ class UniqueNumberSystem(private val guid: NumberPoolHub, private val poolActors
         }
       } catch {
         case _: Exception =>
-          log.info(s"$obj is already unregistered")
+          log.warn(s"$obj is already unregistered")
           callback ! Success(obj)
       }
 

src/main/scala/net/psforever/objects/serverobject/hackable/GenericHackables.scala

@@ -104,7 +104,7 @@ object GenericHackables {
   def FinishHacking(target: PlanetSideServerObject with Hackable, user: Player, unk: Long)(): Unit = {
     import akka.pattern.ask
     import scala.concurrent.duration._
-    log.info(s"Hacked a $target")
+    log.info(s"${user.Name} hacked a ${target.Definition.Name}")
     // Wait for the target actor to set the HackedBy property, otherwise LocalAction.HackTemporarily will not complete properly
     import scala.concurrent.ExecutionContext.Implicits.global
     val tplayer = user

src/main/scala/net/psforever/objects/serverobject/locks/IFFLockControl.scala

@@ -41,7 +41,7 @@ class IFFLockControl(lock: IFFLock)
             )
           } else {
             val log = org.log4s.getLogger
-            log.warn("IFF lock is being hacked, but don't know how to handle this state:")
+            log.warn(s"IFF lock is being hacked by ${player.Faction}, but don't know how to handle this state:")
             log.warn(s"Lock - Faction=${lock.Faction}, HackedBy=${lock.HackedBy}")
             log.warn(s"Player - Faction=${player.Faction}")
           }

src/main/scala/net/psforever/objects/serverobject/terminals/CaptureTerminals.scala

@@ -0,0 +1,57 @@
+// Copyright (c) 2020 PSForever
+package net.psforever.objects.serverobject.terminals
+
+import net.psforever.objects.Player
+import net.psforever.objects.serverobject.CommonMessages
+import net.psforever.objects.serverobject.terminals.capture.CaptureTerminal
+import net.psforever.services.local.{LocalAction, LocalServiceMessage}
+
+import scala.util.{Failure, Success}
+
+object CaptureTerminals {
+  private val log = org.log4s.getLogger("CaptureTerminals")
+
+  /**
+    * The process of hacking an object is completed.
+    * Pass the message onto the hackable object and onto the local events system.
+    * @param target the `Hackable` object that has been hacked
+    * @param unk na;
+    *            used by `HackMessage` as `unk5`
+    * @see `HackMessage`
+    */
+  //TODO add params here depending on which params in HackMessage are important
+  def FinishHackingCaptureConsole(target: CaptureTerminal, hackingPlayer: Player, unk: Long)(): Unit = {
+    import akka.pattern.ask
+    import scala.concurrent.duration._
+    log.info(s"${hackingPlayer.toString} Hacked a ${target.toString}")
+    // Wait for the target actor to set the HackedBy property
+    import scala.concurrent.ExecutionContext.Implicits.global
+    ask(target.Actor, CommonMessages.Hack(hackingPlayer, target))(1 second).mapTo[Boolean].onComplete {
+      case Success(_) =>
+        target.Zone.LocalEvents ! LocalServiceMessage(
+          target.Zone.id,
+          LocalAction.TriggerSound(hackingPlayer.GUID, target.HackSound, hackingPlayer.Position, 30, 0.49803925f)
+        )
+        val isResecured = hackingPlayer.Faction == target.Faction
+        if (isResecured) {
+          // Resecure the CC
+          target.Zone.LocalEvents ! LocalServiceMessage(
+            target.Zone.id,
+            LocalAction.ResecureCaptureTerminal(
+              target
+            )
+          )
+        }
+        else {
+          // Start the CC hack timer
+          target.Zone.LocalEvents ! LocalServiceMessage(
+            target.Zone.id,
+            LocalAction.StartCaptureTerminalHack(
+              target
+            )
+          )
+        }
+      case Failure(_) => log.warn(s"Hack message failed on target guid: ${target.GUID}")
+    }
+  }
+}

src/main/scala/net/psforever/objects/vehicles/CargoBehavior.scala

@@ -160,8 +160,6 @@ object CargoBehavior {
             VehicleAction.SendResponse(PlanetSideGUID(0), PlanetsideAttributeMessage(cargoGUID, 68, cargo.Shields))
           )
           val (attachMsg, mountPointMsg) = CargoMountBehaviorForAll(carrier, cargo, mountPoint)
-          log.info(s"HandleCheckCargoMounting: $attachMsg")
-          log.info(s"HandleCheckCargoMounting: $mountPointMsg")
           false
         } else if (distance > 625 || iteration >= 40) {
           //vehicles moved too far away or took too long to get into proper position; abort mounting

src/main/scala/net/psforever/services/account/AccountIntermediaryService.scala

@@ -33,29 +33,29 @@ class AccountIntermediaryService extends Actor {
     // Called by the LoginSessionActor
     case StoreAccountData(token, account) =>
       accountsByToken += (token -> account)
-      log.info(s"Storing intermediary account data for ${account.id}")
+      log.trace(s"Storing intermediary account data for ${account.id}")
 
     // Called by the WorldSessionActor
     case RetrieveAccountData(token) =>
       accountsByToken.remove(token) match {
         case Some(acc) =>
           sender() ! ReceiveAccountData(acc)
-          log.info(s"Retrieving intermediary account data for $acc")
+          log.trace(s"Retrieving intermediary account data for $acc")
         case None =>
           log.error(s"Unable to retrieve intermediary account data for $token")
       }
 
     case StoreIPAddress(sessionID, address) =>
       IPAddressBySessionID += (sessionID -> address)
-      log.info(s"Storing IP address (${address.Address}) for sessionID : $sessionID")
+      log.trace(s"Storing IP address (${address.Address}) for sessionID : $sessionID")
 
     case RetrieveIPAddress(sessionID) =>
       val address: Option[IPAddress] = IPAddressBySessionID.remove(sessionID)
       if (address.nonEmpty) {
         sender() ! ReceiveIPAddress(address.get)
-        log.info(s"Retrieving IP address data for sessionID : ${sessionID}")
+        log.trace(s"Retrieving IP address data for sessionID : $sessionID")
       } else {
-        log.error(s"Unable to retrieve IP address data for sessionID : ${sessionID}")
+        log.error(s"Unable to retrieve IP address data for sessionID : $sessionID")
       }
 
     case msg =>

src/main/scala/net/psforever/services/account/AccountPersistenceService.scala

@@ -410,7 +410,7 @@ class PersistenceMonitor(name: String, squadService: ActorRef) extends Actor {
     Deployables.Disown(inZone, avatar, context.parent)
     inZone.Population.tell(Zone.Population.Leave(avatar), context.parent)
     inZone.tasks.tell(GUIDTask.UnregisterObjectTask(avatar.locker)(inZone.GUID), context.parent)
-    log.info(s"logout of ${avatar.name}")
+    log.info(s"Logout of ${avatar.name}")
   }
 }
 

src/main/scala/net/psforever/services/avatar/AvatarService.scala

@@ -25,7 +25,6 @@ class AvatarService(zone: Zone) extends Actor {
     case Service.Join(channel) =>
       val path = s"/$channel/Avatar"
       val who  = sender()
-      log.info(s"$who has joined $path")
       AvatarEvents.subscribe(who, path)
 
     case Service.Leave(None) =>
@@ -33,8 +32,6 @@ class AvatarService(zone: Zone) extends Actor {
 
     case Service.Leave(Some(channel)) =>
       val path = s"/$channel/Avatar"
-      val who  = sender()
-      log.info(s"$who has left $path")
       AvatarEvents.unsubscribe(sender(), path)
 
     case Service.LeaveAll() =>

src/main/scala/net/psforever/services/chat/ChatService.scala

@@ -142,7 +142,7 @@ class ChatService(context: ActorContext[ChatService.Command]) extends AbstractBe
                 )
 
               case (None, _, _, _) =>
-                log.error("received message from non-subscribed actor")
+                log.warn("received message from non-subscribed actor")
 
             }
 

src/main/scala/net/psforever/services/galaxy/GalaxyService.scala

@@ -9,38 +9,26 @@ import net.psforever.services.{GenericEventBus, Service}
 class GalaxyService extends Actor {
   private[this] val log = org.log4s.getLogger
 
-  override def preStart() = {
-    log.info("Starting...")
-  }
-
   val GalaxyEvents = new GenericEventBus[GalaxyServiceResponse]
 
   def receive: Receive = {
     case Service.Join(faction) if "TRNCVS".containsSlice(faction) =>
       val path = s"/$faction/Galaxy"
-      val who  = sender()
+      GalaxyEvents.subscribe(sender(), path)
-      log.trace(s"$who has joined $path")
-      GalaxyEvents.subscribe(who, path)
 
     case Service.Join("galaxy") =>
       val path = s"/Galaxy"
-      val who  = sender()
+      GalaxyEvents.subscribe(sender(), path)
-      log.trace(s"$who has joined $path")
-      GalaxyEvents.subscribe(who, path)
 
     case Service.Join(channel) =>
       val path = s"/$channel/Galaxy"
-      val who  = sender()
+      GalaxyEvents.subscribe(sender(), path)
-      log.trace(s"$who has joined $path")
-      GalaxyEvents.subscribe(who, path)
 
     case Service.Leave(None) =>
       GalaxyEvents.unsubscribe(sender())
 
     case Service.Leave(Some(channel)) =>
       val path = s"/$channel/Galaxy"
-      val who  = sender()
-      log.trace(s"$who has left $path")
       GalaxyEvents.unsubscribe(sender(), path)
 
     case Service.LeaveAll() =>
@@ -53,7 +41,7 @@ class GalaxyService extends Actor {
             GalaxyServiceResponse(s"/Galaxy", GalaxyResponse.MapUpdate(msg))
           )
 
-        case GalaxyAction.TransferPassenger(player_guid, temp_channel, vehicle, vehicle_to_delete, manifest) =>
+        case GalaxyAction.TransferPassenger(_, temp_channel, vehicle, vehicle_to_delete, manifest) =>
           GalaxyEvents.publish(
             GalaxyServiceResponse(
               s"/$forChannel/Galaxy",
@@ -69,6 +57,6 @@ class GalaxyService extends Actor {
       )
 
     case msg =>
-      log.info(s"Unhandled message $msg from ${sender()}")
+      log.warn(s"Unhandled message $msg from ${sender()}")
   }
 }

src/main/scala/net/psforever/services/local/LocalService.scala

@@ -28,27 +28,19 @@ class LocalService(zone: Zone) extends Actor {
     context.actorOf(Props[RouterTelepadActivation](), s"${zone.id}-telepad-activate-agent")
   private[this] val log = org.log4s.getLogger
 
-  override def preStart() = {
-    log.trace(s"Awaiting ${zone.id} local events ...")
-  }
-
   val LocalEvents = new GenericEventBus[LocalServiceResponse]
 
   def receive: Receive = {
     case Service.Join(channel) =>
       val path = s"/$channel/Local"
-      val who  = sender()
+      LocalEvents.subscribe(sender(), path)
-      log.info(s"$who has joined $path")
-      LocalEvents.subscribe(who, path)
 
     case Service.Leave(None) =>
       LocalEvents.unsubscribe(sender())
 
     case Service.Leave(Some(channel)) =>
       val path = s"/$channel/Local"
-      val who  = sender()
+      LocalEvents.unsubscribe(sender(), path)
-      log.info(s"$who has left $path")
-      LocalEvents.unsubscribe(who, path)
 
     case Service.LeaveAll() =>
       LocalEvents.unsubscribe(sender())
@@ -229,13 +221,6 @@ class LocalService(zone: Zone) extends Actor {
     //response from HackClearActor
     case HackClearActor.SendHackMessageHackCleared(target_guid, _, unk1, unk2) =>
       log.info(s"Clearing hack for $target_guid")
-      LocalEvents.publish(
-        LocalServiceResponse(
-          s"/${zone.id}/Local",
-          Service.defaultPlayerGUID,
-          LocalResponse.SendHackMessageHackCleared(target_guid, unk1, unk2)
-        )
-      )
 
     //message from ProximityTerminalControl
     case Terminal.StartProximityEffect(terminal) =>
@@ -323,7 +308,7 @@ class LocalService(zone: Zone) extends Actor {
               //get rid of previous linked remote telepad (if any)
               zone.GUID(internalTelepad.Telepad) match {
                 case Some(old: TelepadDeployable) =>
-                  log.info(
+                  log.trace(
                     s"ActivateTeleportSystem: old remote telepad@${old.GUID.guid} linked to internal@${internalTelepad.GUID.guid} will be deconstructed"
                   )
                   old.Active = false
@@ -333,7 +318,7 @@ class LocalService(zone: Zone) extends Actor {
               }
               internalTelepad.Telepad = remoteTelepad.GUID
               if (internalTelepad.Active) {
-                log.info(
+                log.trace(
                   s"ActivateTeleportSystem: fully deployed router@${router.GUID.guid} in ${zone.id} will link internal@${internalTelepad.GUID.guid} and remote@${remoteTelepad.GUID.guid}"
                 )
                 LocalEvents.publish(

src/main/scala/net/psforever/services/local/support/DeployableRemover.scala

@@ -50,7 +50,7 @@ class DeployableRemover(taskResolver: ActorRef) extends RemoverActor(taskResolve
 
   override def SecondJob(entry: RemoverActor.Entry): Unit = {
     val obj = entry.obj.asInstanceOf[PlanetSideGameObject with Deployable]
-    info(s"Deleting a ${obj.Definition.Name} deployable")
+    trace(s"Deleting a ${obj.Definition.Name} deployable")
     context.parent ! DeployableRemover.EliminateDeployable(obj, obj.GUID, obj.Position, entry.zone)
     super.SecondJob(entry)
   }

src/main/scala/net/psforever/services/local/support/HackClearActor.scala

@@ -83,12 +83,12 @@ class HackClearActor() extends Actor {
         case Some(hackEntry) =>
           val short_timeout: FiniteDuration = math.max(1, hackEntry.duration - (now - hackEntry.time)) nanoseconds
 
-          log.info(
+          log.debug(
             s"HackClearActor: Still items left in hacked objects list. Checking again in ${short_timeout.toSeconds} seconds"
           )
           import scala.concurrent.ExecutionContext.Implicits.global
           clearTrigger = context.system.scheduler.scheduleOnce(short_timeout, self, HackClearActor.TryClearHacks())
-        case None => log.info("HackClearActor: No objects left in hacked objects list. Not rescheduling check.")
+        case None => log.debug("HackClearActor: No objects left in hacked objects list. Not rescheduling check.")
       }
 
     }

src/main/scala/net/psforever/services/teamwork/SquadService.scala

@@ -124,11 +124,7 @@ class SquadService extends Actor {
   private[this] val log = org.log4s.getLogger
 
   private def debug(msg: String): Unit = {
-    log.info(msg)
+    log.debug(msg)
-  }
-
-  override def preStart(): Unit = {
-    log.info("Starting...")
   }
 
   override def postStop(): Unit = {
@@ -321,7 +317,7 @@ class SquadService extends Actor {
       case str if str.matches("//d+") =>
         Publish(to.toLong, msg, excluded)
       case _ =>
-        log.error(s"Publish(String): subscriber information is an unhandled format - $to")
+        log.warn(s"Publish(String): subscriber information is an unhandled format - $to")
     }
   }
 
@@ -336,7 +332,7 @@ class SquadService extends Actor {
       case Some(user) =>
         user ! SquadServiceResponse("", msg)
       case None =>
-        log.error(s"Publish(Long): subscriber information can not be found - $to")
+        log.warn(s"Publish(Long): subscriber information can not be found - $to")
     }
   }
 
@@ -383,7 +379,6 @@ class SquadService extends Actor {
     case Service.Join(faction) if "TRNCVS".indexOf(faction) > -1 =>
       val path = s"/$faction/Squad"
       val who  = sender()
-      debug(s"$who has joined $path")
       SquadEvents.subscribe(who, path)
 
     //subscribe to the player's personal channel - necessary for future and previous squad information
@@ -392,7 +387,6 @@ class SquadService extends Actor {
         val longCharId = char_id.toLong
         val path       = s"/$char_id/Squad"
         val who        = sender()
-        debug(s"$who has joined $path")
         context.watch(who)
         UserEvents += longCharId -> who
         refused(longCharId) = Nil
@@ -407,7 +401,6 @@ class SquadService extends Actor {
     case Service.Leave(Some(faction)) if "TRNCVS".indexOf(faction) > -1 =>
       val path = s"/$faction/Squad"
       val who  = sender()
-      debug(s"$who has left $path")
       SquadEvents.unsubscribe(who, path)
 
     case Service.Leave(Some(char_id)) =>

src/main/scala/net/psforever/services/vehicle/VehicleService.scala

@@ -18,27 +18,19 @@ class VehicleService(zone: Zone) extends Actor {
   private val turretUpgrade: ActorRef = context.actorOf(Props[TurretUpgrader](), s"${zone.id}-turret-upgrade-agent")
   private[this] val log               = org.log4s.getLogger
 
-  override def preStart() = {
-    log.trace(s"Awaiting ${zone.id} vehicle events ...")
-  }
-
   val VehicleEvents = new GenericEventBus[VehicleServiceResponse]
 
   def receive = {
     case Service.Join(channel) =>
       val path = s"/$channel/Vehicle"
-      val who  = sender()
+      VehicleEvents.subscribe(sender(), path)
-      log.info(s"$who has joined $path")
-      VehicleEvents.subscribe(who, path)
 
     case Service.Leave(None) =>
       VehicleEvents.unsubscribe(sender())
 
     case Service.Leave(Some(channel)) =>
       val path = s"/$channel/Vehicle"
-      val who  = sender()
+      VehicleEvents.unsubscribe(sender(), path)
-      log.info(s"$who has left $path")
-      VehicleEvents.unsubscribe(who, path)
 
     case Service.LeaveAll() =>
       VehicleEvents.unsubscribe(sender())
@@ -387,7 +379,7 @@ class VehicleService(zone: Zone) extends Actor {
       }
 
     case msg =>
-      log.info(s"Unhandled message $msg from ${sender()}")
+      log.warn(s"Unhandled message $msg from ${sender()}")
   }
 
   import net.psforever.objects.serverobject.tube.SpawnTube

src/main/scala/net/psforever/services/vehicle/support/TurretUpgrader.scala

@@ -164,7 +164,7 @@ class TurretUpgrader extends SupportActor[TurretUpgrader.Entry] {
           )
         }
       })
-    info(s"Converting manned wall turret weapon to $upgrade")
+    debug(s"Converting manned wall turret weapon to $upgrade")
 
     val oldBoxes = AllMountedWeaponMagazines(target)
     target.Upgrade = upgrade //perform upgrade
@@ -228,7 +228,7 @@ class TurretUpgrader extends SupportActor[TurretUpgrader.Entry] {
   def FinishUpgradingTurret(entry: TurretUpgrader.Entry)(): Unit = {
     val target = entry.obj.asInstanceOf[FacilityTurret]
     val zone   = entry.zone
-    info(s"Wall turret finished ${target.Upgrade} upgrade")
+    trace(s"Wall turret finished ${target.Upgrade} upgrade")
     target.ConfirmUpgrade(entry.upgrade)
     val targetGUID = target.GUID
     if (target.Health > 0) {