diff --git a/pslogin/src/main/scala/MDCContextAware.scala b/pslogin/src/main/scala/MDCContextAware.scala
index eb5a27d4..203b6d07 100644
--- a/pslogin/src/main/scala/MDCContextAware.scala
+++ b/pslogin/src/main/scala/MDCContextAware.scala
@@ -1,65 +1,66 @@
-// Taken from http://code.hootsuite.com/logging-contextual-info-in-an-asynchronous-scala-application/
-package akka.actor
-
-import akka.util.Timeout
-import org.slf4j.MDC
-
-import scala.concurrent.Future
-
-trait MDCContextAware extends Actor with ActorLogging  {
-  import MDCContextAware._
-
-  // This is why this needs to be in package akka.actor
-  override protected[akka] def aroundReceive(receive: Actor.Receive, msg: Any): Unit = {
-    val orig = MDC.getCopyOfContextMap
-    try {
-      msg match {
-        case MdcMsg(mdc, origMsg) =>
-          if (mdc != null)
-            MDC.setContextMap(mdc)
-          else
-            MDC.clear()
-          super.aroundReceive(receive, origMsg)
-        case _ =>
-          super.aroundReceive(receive, msg)
-      }
-    } finally {
-      if (orig != null)
-        MDC.setContextMap(orig)
-      else
-        MDC.clear()
-    }
-  }
-}
-
-object MDCContextAware {
-  private case class MdcMsg(mdc: java.util.Map[String, String], msg: Any)
-
-  object Implicits {
-
-    /**
-      * Add two new methods that allow MDC info to be passed to MDCContextAware actors.
-      *
-      * Do NOT use these methods to send to actors that are not MDCContextAware.
-      */
-    implicit class ContextLocalAwareActorRef(val ref: ActorRef) extends AnyVal {
-
-      import akka.pattern.ask
-
-      /**
-        * Send a message to an actor that is MDCContextAware - it will propagate
-        * the current MDC values. Note: we MUST capture the ActorContext in order for senders
-        * to be correct! This was a bug from the original author.
-        */
-      def !>(msg: Any)(implicit context: ActorContext) : Unit =
-        ref.tell(MdcMsg(MDC.getCopyOfContextMap, msg), context.self)
-
-      /**
-        * "Ask" an actor that is MDCContextAware for something - it will propagate
-        * the current MDC values
-        */
-      def ?>(msg: Any)(implicit context: ActorContext, timeout: Timeout): Future[Any] =
-        ref.ask(MdcMsg(MDC.getCopyOfContextMap, msg), context.self)
-    }
-  }
+// Copyright (c) 2016 PSForever.net to present
+// Taken from http://code.hootsuite.com/logging-contextual-info-in-an-asynchronous-scala-application/
+package akka.actor
+
+import akka.util.Timeout
+import org.slf4j.MDC
+
+import scala.concurrent.Future
+
+trait MDCContextAware extends Actor with ActorLogging  {
+  import MDCContextAware._
+
+  // This is why this needs to be in package akka.actor
+  override protected[akka] def aroundReceive(receive: Actor.Receive, msg: Any): Unit = {
+    val orig = MDC.getCopyOfContextMap
+    try {
+      msg match {
+        case MdcMsg(mdc, origMsg) =>
+          if (mdc != null)
+            MDC.setContextMap(mdc)
+          else
+            MDC.clear()
+          super.aroundReceive(receive, origMsg)
+        case _ =>
+          super.aroundReceive(receive, msg)
+      }
+    } finally {
+      if (orig != null)
+        MDC.setContextMap(orig)
+      else
+        MDC.clear()
+    }
+  }
+}
+
+object MDCContextAware {
+  private case class MdcMsg(mdc: java.util.Map[String, String], msg: Any)
+
+  object Implicits {
+
+    /**
+      * Add two new methods that allow MDC info to be passed to MDCContextAware actors.
+      *
+      * Do NOT use these methods to send to actors that are not MDCContextAware.
+      */
+    implicit class ContextLocalAwareActorRef(val ref: ActorRef) extends AnyVal {
+
+      import akka.pattern.ask
+
+      /**
+        * Send a message to an actor that is MDCContextAware - it will propagate
+        * the current MDC values. Note: we MUST capture the ActorContext in order for senders
+        * to be correct! This was a bug from the original author.
+        */
+      def !>(msg: Any)(implicit context: ActorContext) : Unit =
+        ref.tell(MdcMsg(MDC.getCopyOfContextMap, msg), context.self)
+
+      /**
+        * "Ask" an actor that is MDCContextAware for something - it will propagate
+        * the current MDC values
+        */
+      def ?>(msg: Any)(implicit context: ActorContext, timeout: Timeout): Future[Any] =
+        ref.ask(MdcMsg(MDC.getCopyOfContextMap, msg), context.self)
+    }
+  }
 }
\ No newline at end of file
diff --git a/pslogin/src/main/scala/MDCPropagatingExecutionContext.scala b/pslogin/src/main/scala/MDCPropagatingExecutionContext.scala
index 8f2d28b1..ee33ddce 100644
--- a/pslogin/src/main/scala/MDCPropagatingExecutionContext.scala
+++ b/pslogin/src/main/scala/MDCPropagatingExecutionContext.scala
@@ -1,64 +1,65 @@
-// Taken from http://code.hootsuite.com/logging-contextual-info-in-an-asynchronous-scala-application/
-
-import org.slf4j.MDC
-
-import scala.concurrent.ExecutionContext
-
-trait MDCPropagatingExecutionContext extends ExecutionContext {
-  // name the self-type "self" so we can refer to it inside the nested class
-  self =>
-
-  override def prepare(): ExecutionContext = new ExecutionContext {
-    // Save the call-site MDC state
-    val context = MDC.getCopyOfContextMap
-
-    def execute(r: Runnable): Unit = self.execute(new Runnable {
-      def run(): Unit = {
-        // Save the existing execution-site MDC state
-        val oldContext = MDC.getCopyOfContextMap
-        try {
-          // Set the call-site MDC state into the execution-site MDC
-          if (context != null )
-            MDC.setContextMap(context)
-          else
-            MDC.clear()
-
-          r.run()
-        } finally {
-          // Restore the existing execution-site MDC state
-          if (oldContext != null)
-            MDC.setContextMap(oldContext)
-          else
-            MDC.clear()
-        }
-      }
-    })
-
-    def reportFailure(t: Throwable): Unit = self.reportFailure(t)
-  }
-}
-
-object MDCPropagatingExecutionContext {
-  object Implicits {
-    // Convenience wrapper around the Scala global ExecutionContext so you can just do:
-    // import MDCPropagatingExecutionContext.Implicits.global
-    implicit lazy val global = MDCPropagatingExecutionContextWrapper(ExecutionContext.Implicits.global)
-  }
-}
-
-/**
-  * Wrapper around an existing ExecutionContext that makes it propagate MDC information.
-  */
-class MDCPropagatingExecutionContextWrapper(wrapped: ExecutionContext)
-  extends ExecutionContext with MDCPropagatingExecutionContext {
-
-  override def execute(r: Runnable): Unit = wrapped.execute(r)
-
-  override def reportFailure(t: Throwable): Unit = wrapped.reportFailure(t)
-}
-
-object MDCPropagatingExecutionContextWrapper {
-  def apply(wrapped: ExecutionContext): MDCPropagatingExecutionContextWrapper = {
-    new MDCPropagatingExecutionContextWrapper(wrapped)
-  }
+// Copyright (c) 2016 PSForever.net to present
+// Taken from http://code.hootsuite.com/logging-contextual-info-in-an-asynchronous-scala-application/
+
+import org.slf4j.MDC
+
+import scala.concurrent.ExecutionContext
+
+trait MDCPropagatingExecutionContext extends ExecutionContext {
+  // name the self-type "self" so we can refer to it inside the nested class
+  self =>
+
+  override def prepare(): ExecutionContext = new ExecutionContext {
+    // Save the call-site MDC state
+    val context = MDC.getCopyOfContextMap
+
+    def execute(r: Runnable): Unit = self.execute(new Runnable {
+      def run(): Unit = {
+        // Save the existing execution-site MDC state
+        val oldContext = MDC.getCopyOfContextMap
+        try {
+          // Set the call-site MDC state into the execution-site MDC
+          if (context != null )
+            MDC.setContextMap(context)
+          else
+            MDC.clear()
+
+          r.run()
+        } finally {
+          // Restore the existing execution-site MDC state
+          if (oldContext != null)
+            MDC.setContextMap(oldContext)
+          else
+            MDC.clear()
+        }
+      }
+    })
+
+    def reportFailure(t: Throwable): Unit = self.reportFailure(t)
+  }
+}
+
+object MDCPropagatingExecutionContext {
+  object Implicits {
+    // Convenience wrapper around the Scala global ExecutionContext so you can just do:
+    // import MDCPropagatingExecutionContext.Implicits.global
+    implicit lazy val global = MDCPropagatingExecutionContextWrapper(ExecutionContext.Implicits.global)
+  }
+}
+
+/**
+  * Wrapper around an existing ExecutionContext that makes it propagate MDC information.
+  */
+class MDCPropagatingExecutionContextWrapper(wrapped: ExecutionContext)
+  extends ExecutionContext with MDCPropagatingExecutionContext {
+
+  override def execute(r: Runnable): Unit = wrapped.execute(r)
+
+  override def reportFailure(t: Throwable): Unit = wrapped.reportFailure(t)
+}
+
+object MDCPropagatingExecutionContextWrapper {
+  def apply(wrapped: ExecutionContext): MDCPropagatingExecutionContextWrapper = {
+    new MDCPropagatingExecutionContextWrapper(wrapped)
+  }
 }
\ No newline at end of file