Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals

1 files changed, 18 insertions, 24 deletions

diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala
index 9884dff..a2a059a 100644
--- a/src/main/scala/xyz/driver/core/app.scala
+++ b/src/main/scala/xyz/driver/core/app.scala
@@ -3,22 +3,19 @@ package xyz.driver.core
 import java.sql.SQLException
 
 import akka.actor.ActorSystem
-import akka.event.Logging.LogLevel
-import akka.event.{Logging, LoggingAdapter}
 import akka.http.scaladsl.Http
 import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
 import akka.http.scaladsl.model.StatusCodes._
 import akka.http.scaladsl.model.headers.RawHeader
-import akka.http.scaladsl.model.{HttpEntity, HttpRequest, HttpResponse, StatusCodes}
+import akka.http.scaladsl.model._
 import akka.http.scaladsl.server.Directives._
 import akka.http.scaladsl.server.RouteResult._
-import akka.http.scaladsl.server.directives.{LogEntry, LoggingMagnet}
 import akka.http.scaladsl.server.{ExceptionHandler, Route, RouteConcatenation}
 import akka.stream.scaladsl.Sink
 import akka.stream.{ActorMaterializer, Materializer}
 import com.typesafe.config.Config
 import io.swagger.models.Scheme
-import org.slf4j.{LoggerFactory, MDC}
+import org.slf4j.{LoggerFactory, MDC, MarkerFactory}
 import spray.json.DefaultJsonProtocol
 import xyz.driver.core
 import xyz.driver.core.logging.{Logger, TypesafeScalaLogger}
@@ -71,39 +68,36 @@ object app {
       val swaggerRoutes  = swaggerService.routes ~ swaggerService.swaggerUI
       val versionRt      = versionRoute(version, gitHash, time.currentTime())
 
+      def entityAsString(entity: HttpEntity)(implicit m: Materializer, ex: ExecutionContext): Future[String] =
+        entity.dataBytes
+          .map(_.decodeString(entity.contentType.charsetOption.fold("UTF-8")(_.value)))
+          .runWith(Sink.head)
+
       val _ = Future {
         http.bindAndHandle(route2HandlerFlow({ ctx =>
           val trackingId = rest.extractTrackingId(ctx.request)
           MDC.put("trackingId", trackingId)
-          log.audit(s"Received request ${ctx.request}")
+
+          def requestLogging: Future[Unit] = {
+            entityAsString(ctx.request.entity).map { data =>
+              s"""{"method":"${ctx.request.method}","url": "${ctx.request.uri}","entity":"$data"""".stripMargin
+            } map { requestJson =>
+              log.audit(MarkerFactory.getMarker("Received request"), requestJson)
+            }
+          }
 
           val contextWithTrackingId =
             ctx.withRequest(ctx.request.addHeader(RawHeader(ContextHeaders.TrackingIdHeader, trackingId)))
 
           handleExceptions(ExceptionHandler(exceptionHandler))({ c =>
-            logRequestResult(LoggingMagnet(log => myLoggingFunction(Logging.InfoLevel, log))) {
+            requestLogging.flatMap { _ =>
               respondWithHeaders(List(RawHeader(ContextHeaders.TrackingIdHeader, trackingId))) {
                 modules.map(_.route).foldLeft(versionRt ~ healthRoute ~ swaggerRoutes)(_ ~ _)
-              }
-            }(c)
+              }(c)
+            }
           })(contextWithTrackingId)
         }), interface, port)(materializer)
       }
-
-      def myLoggingFunction(level: LogLevel, logger: LoggingAdapter)(req: HttpRequest)(res: Any): Unit = {
-        val entry = res match {
-          case Complete(resp) =>
-            entityAsString(resp.entity).map { data =>
-              LogEntry(s"${req.method} ${req.uri}: ${resp.status} \n entity: $data", level)
-            }
-          case other =>
-            Future.successful(LogEntry(s"$other", level))
-        }
-        entry.map(_.logTo(logger))
-      }
-
-      def entityAsString(entity: HttpEntity)(implicit m: Materializer, ex: ExecutionContext): Future[String] =
-        entity.dataBytes.map(_.decodeString(entity.contentType.charsetOption.map(_.value).get)).runWith(Sink.head)
     }
 
     /**