From 871f8d7e4844890f920b960bc53ec0f99268d794 Mon Sep 17 00:00:00 2001 From: vlad Date: Mon, 13 Mar 2017 21:46:06 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 13 ++++++------- src/main/scala/xyz/driver/core/core.scala | 4 ++-- src/main/scala/xyz/driver/core/file.scala | 1 - src/main/scala/xyz/driver/core/generators.scala | 1 - src/main/scala/xyz/driver/core/json.scala | 1 - src/main/scala/xyz/driver/core/rest.scala | 1 - src/test/scala/xyz/driver/core/CoreTest.scala | 1 - src/test/scala/xyz/driver/core/JsonTest.scala | 1 - 8 files changed, 8 insertions(+), 15 deletions(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index deb0e6a..090be76 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -14,7 +14,7 @@ import akka.http.scaladsl.server.{ExceptionHandler, Route, RouteConcatenation} import akka.stream.ActorMaterializer import com.typesafe.config.Config import io.swagger.models.Scheme -import org.slf4j.LoggerFactory +import org.slf4j.{LoggerFactory, MDC} import spray.json.DefaultJsonProtocol import xyz.driver.core import xyz.driver.core.logging.{Logger, TypesafeScalaLogger} @@ -26,7 +26,7 @@ import xyz.driver.core.time.provider.{SystemTimeProvider, TimeProvider} import scala.compat.Platform.ConcurrentModificationException import scala.concurrent.duration._ -import scala.concurrent.{Await, Future} +import scala.concurrent.{Await, ExecutionContext, Future} object app { @@ -40,12 +40,10 @@ object app { interface: String = "::0", baseUrl: String = "localhost:8080", scheme: String = "http", - port: Int = 8080) { + port: Int = 8080)(implicit actorSystem: ActorSystem, executionContext: ExecutionContext) { - implicit private lazy val actorSystem = ActorSystem("spray-routing", config) - implicit private lazy val executionContext = actorSystem.dispatcher - implicit private lazy val materializer = ActorMaterializer()(actorSystem) - private lazy val http = Http()(actorSystem) + implicit private lazy val materializer = ActorMaterializer()(actorSystem) + private lazy val http = Http()(actorSystem) def run(): Unit = { activateServices(modules) @@ -73,6 +71,7 @@ object app { http.bindAndHandle(route2HandlerFlow(handleExceptions(ExceptionHandler(exceptionHandler)) { ctx => val trackingId = rest.extractTrackingId(ctx.request) log.audit(s"Received request ${ctx.request} with tracking id $trackingId") + MDC.put("trackingId", trackingId) val contextWithTrackingId = ctx.withRequest(ctx.request.addHeader(RawHeader(ContextHeaders.TrackingIdHeader, trackingId))) diff --git a/src/main/scala/xyz/driver/core/core.scala b/src/main/scala/xyz/driver/core/core.scala index 341d991..3e77c1f 100644 --- a/src/main/scala/xyz/driver/core/core.scala +++ b/src/main/scala/xyz/driver/core/core.scala @@ -60,9 +60,9 @@ package core { implicit def nameOrdering[T]: Ordering[Name[T]] = Ordering.by(_.value) } - object revision { - final case class Revision[T](id: String) + final case class Revision[T](id: String) + object Revision { implicit def revisionEqual[T]: Equal[Revision[T]] = Equal.equal[Revision[T]](_.id == _.id) } diff --git a/src/main/scala/xyz/driver/core/file.scala b/src/main/scala/xyz/driver/core/file.scala index 9cea9e5..42dc6b2 100644 --- a/src/main/scala/xyz/driver/core/file.scala +++ b/src/main/scala/xyz/driver/core/file.scala @@ -6,7 +6,6 @@ import java.util.UUID._ import com.amazonaws.services.s3.AmazonS3 import com.amazonaws.services.s3.model.{Bucket, GetObjectRequest, ListObjectsV2Request} -import xyz.driver.core.revision.Revision import xyz.driver.core.time.Time import scala.concurrent.{ExecutionContext, Future} diff --git a/src/main/scala/xyz/driver/core/generators.scala b/src/main/scala/xyz/driver/core/generators.scala index 55cc3b4..8f3ff13 100644 --- a/src/main/scala/xyz/driver/core/generators.scala +++ b/src/main/scala/xyz/driver/core/generators.scala @@ -2,7 +2,6 @@ package xyz.driver.core import java.math.MathContext -import xyz.driver.core.revision.Revision import xyz.driver.core.time.{Time, TimeRange} import xyz.driver.core.date.Date diff --git a/src/main/scala/xyz/driver/core/json.scala b/src/main/scala/xyz/driver/core/json.scala index b23a8e4..01efd57 100644 --- a/src/main/scala/xyz/driver/core/json.scala +++ b/src/main/scala/xyz/driver/core/json.scala @@ -6,7 +6,6 @@ import akka.http.scaladsl.server.{PathMatcher, _} import akka.http.scaladsl.unmarshalling.Unmarshaller import spray.json.{DeserializationException, JsNumber, _} import xyz.driver.core.auth.AuthCredentials -import xyz.driver.core.revision.Revision import xyz.driver.core.time.Time import xyz.driver.core.date.Date import xyz.driver.core.domain.{Email, PhoneNumber} diff --git a/src/main/scala/xyz/driver/core/rest.scala b/src/main/scala/xyz/driver/core/rest.scala index 33e0f97..ebdb1b9 100644 --- a/src/main/scala/xyz/driver/core/rest.scala +++ b/src/main/scala/xyz/driver/core/rest.scala @@ -56,7 +56,6 @@ object rest { def extractContextHeaders(request: HttpRequest): Map[String, String] = { request.headers.filter { h => h.name === ContextHeaders.AuthenticationTokenHeader || h.name === ContextHeaders.TrackingIdHeader - // || ContextHeaders.LinkerD.isLinkerD(h.lowercaseName) } map { header => if (header.name === ContextHeaders.AuthenticationTokenHeader) { header.name -> header.value.stripPrefix(ContextHeaders.AuthenticationHeaderPrefix).trim diff --git a/src/test/scala/xyz/driver/core/CoreTest.scala b/src/test/scala/xyz/driver/core/CoreTest.scala index bb4742a..0518652 100644 --- a/src/test/scala/xyz/driver/core/CoreTest.scala +++ b/src/test/scala/xyz/driver/core/CoreTest.scala @@ -5,7 +5,6 @@ import java.io.ByteArrayOutputStream import org.mockito.Mockito._ import org.scalatest.mock.MockitoSugar import org.scalatest.{FlatSpec, Matchers} -import xyz.driver.core.revision.Revision class CoreTest extends FlatSpec with Matchers with MockitoSugar { diff --git a/src/test/scala/xyz/driver/core/JsonTest.scala b/src/test/scala/xyz/driver/core/JsonTest.scala index 8697b7f..760559c 100644 --- a/src/test/scala/xyz/driver/core/JsonTest.scala +++ b/src/test/scala/xyz/driver/core/JsonTest.scala @@ -2,7 +2,6 @@ package xyz.driver.core import org.scalatest.{FlatSpec, Matchers} import xyz.driver.core.json.{EnumJsonFormat, GadtJsonFormat, ValueClassFormat} -import xyz.driver.core.revision.Revision import xyz.driver.core.time.provider.SystemTimeProvider import spray.json._ import xyz.driver.core.TestTypes.CustomGADT -- cgit v1.2.3 From 692192be92c97250fa2af2fa195feee677265537 Mon Sep 17 00:00:00 2001 From: vlad Date: Mon, 13 Mar 2017 22:23:17 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index 090be76..b53cc7b 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -70,8 +70,8 @@ object app { val _ = Future { http.bindAndHandle(route2HandlerFlow(handleExceptions(ExceptionHandler(exceptionHandler)) { ctx => val trackingId = rest.extractTrackingId(ctx.request) - log.audit(s"Received request ${ctx.request} with tracking id $trackingId") MDC.put("trackingId", trackingId) + log.audit(s"Received request ${ctx.request} with tracking id $trackingId") val contextWithTrackingId = ctx.withRequest(ctx.request.addHeader(RawHeader(ContextHeaders.TrackingIdHeader, trackingId))) -- cgit v1.2.3 From 810eca4d5f11d2d7a9d354c967f238403aebd2c0 Mon Sep 17 00:00:00 2001 From: vlad Date: Mon, 13 Mar 2017 23:07:05 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index b53cc7b..d300fa1 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -71,7 +71,7 @@ object app { http.bindAndHandle(route2HandlerFlow(handleExceptions(ExceptionHandler(exceptionHandler)) { ctx => val trackingId = rest.extractTrackingId(ctx.request) MDC.put("trackingId", trackingId) - log.audit(s"Received request ${ctx.request} with tracking id $trackingId") + log.audit(s"Received request ${ctx.request}") val contextWithTrackingId = ctx.withRequest(ctx.request.addHeader(RawHeader(ContextHeaders.TrackingIdHeader, trackingId))) @@ -92,26 +92,26 @@ object app { case is: IllegalStateException => ctx => - val trackingId = rest.extractTrackingId(ctx.request) + val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) log.debug(s"Request is not allowed to ${ctx.request.uri} ($trackingId)", is) complete(HttpResponse(BadRequest, entity = is.getMessage))(ctx) case cm: ConcurrentModificationException => ctx => - val trackingId = rest.extractTrackingId(ctx.request) + val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) log.audit(s"Concurrent modification of the resource ${ctx.request.uri} ($trackingId)", cm) complete( HttpResponse(Conflict, entity = "Resource was changed concurrently, try requesting a newer version"))(ctx) case sex: SQLException => ctx => - val trackingId = rest.extractTrackingId(ctx.request) + val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) log.audit(s"Database exception for the resource ${ctx.request.uri} ($trackingId)", sex) complete(HttpResponse(InternalServerError, entity = "Data access error"))(ctx) case t: Throwable => ctx => - val trackingId = rest.extractTrackingId(ctx.request) + val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) log.error(s"Request to ${ctx.request.uri} could not be handled normally ($trackingId)", t) complete(HttpResponse(InternalServerError, entity = t.getMessage))(ctx) } -- cgit v1.2.3 From 9f7eeff5b4186632dcc1c37cec09dd4be2516d22 Mon Sep 17 00:00:00 2001 From: vlad Date: Mon, 13 Mar 2017 23:13:01 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index d300fa1..1bcb358 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -92,27 +92,23 @@ object app { case is: IllegalStateException => ctx => - val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.debug(s"Request is not allowed to ${ctx.request.uri} ($trackingId)", is) + log.debug(s"Request is not allowed to ${ctx.request.uri}", is) complete(HttpResponse(BadRequest, entity = is.getMessage))(ctx) case cm: ConcurrentModificationException => ctx => - val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.audit(s"Concurrent modification of the resource ${ctx.request.uri} ($trackingId)", cm) + log.audit(s"Concurrent modification of the resource ${ctx.request.uri}", cm) complete( HttpResponse(Conflict, entity = "Resource was changed concurrently, try requesting a newer version"))(ctx) case sex: SQLException => ctx => - val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.audit(s"Database exception for the resource ${ctx.request.uri} ($trackingId)", sex) + log.audit(s"Database exception for the resource ${ctx.request.uri}", sex) complete(HttpResponse(InternalServerError, entity = "Data access error"))(ctx) case t: Throwable => ctx => - val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.error(s"Request to ${ctx.request.uri} could not be handled normally ($trackingId)", t) + log.error(s"Request to ${ctx.request.uri} could not be handled normally", t) complete(HttpResponse(InternalServerError, entity = t.getMessage))(ctx) } -- cgit v1.2.3 From 0ee83a407c6313d0bb1a6d62233fea1f831f0a18 Mon Sep 17 00:00:00 2001 From: vlad Date: Mon, 13 Mar 2017 23:18:11 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index 1bcb358..ab889dc 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -92,22 +92,26 @@ object app { case is: IllegalStateException => ctx => + val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) log.debug(s"Request is not allowed to ${ctx.request.uri}", is) complete(HttpResponse(BadRequest, entity = is.getMessage))(ctx) case cm: ConcurrentModificationException => ctx => + val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) log.audit(s"Concurrent modification of the resource ${ctx.request.uri}", cm) complete( HttpResponse(Conflict, entity = "Resource was changed concurrently, try requesting a newer version"))(ctx) case sex: SQLException => ctx => + val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) log.audit(s"Database exception for the resource ${ctx.request.uri}", sex) complete(HttpResponse(InternalServerError, entity = "Data access error"))(ctx) case t: Throwable => ctx => + val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) log.error(s"Request to ${ctx.request.uri} could not be handled normally", t) complete(HttpResponse(InternalServerError, entity = t.getMessage))(ctx) } -- cgit v1.2.3 From 1b2d2b39e18073ba83f59d1572269140ae9f4945 Mon Sep 17 00:00:00 2001 From: vlad Date: Mon, 13 Mar 2017 23:30:06 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index ab889dc..8edb427 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -93,26 +93,26 @@ object app { case is: IllegalStateException => ctx => val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.debug(s"Request is not allowed to ${ctx.request.uri}", is) + log.error(s"Request is not allowed to ${ctx.request.uri} ($trackingId)", is) complete(HttpResponse(BadRequest, entity = is.getMessage))(ctx) case cm: ConcurrentModificationException => ctx => val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.audit(s"Concurrent modification of the resource ${ctx.request.uri}", cm) + log.error(s"Concurrent modification of the resource ${ctx.request.uri} ($trackingId)", cm) complete( HttpResponse(Conflict, entity = "Resource was changed concurrently, try requesting a newer version"))(ctx) case sex: SQLException => ctx => val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.audit(s"Database exception for the resource ${ctx.request.uri}", sex) + log.error(s"Database exception for the resource ${ctx.request.uri} ($trackingId)", sex) complete(HttpResponse(InternalServerError, entity = "Data access error"))(ctx) case t: Throwable => ctx => val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.error(s"Request to ${ctx.request.uri} could not be handled normally", t) + log.error(s"Request to ${ctx.request.uri} could not be handled normally ($trackingId)", t) complete(HttpResponse(InternalServerError, entity = t.getMessage))(ctx) } -- cgit v1.2.3 From a999af6e8843785d00d4e636413f701308efbb5d Mon Sep 17 00:00:00 2001 From: vlad Date: Mon, 13 Mar 2017 23:38:05 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index 8edb427..5a1b803 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -68,7 +68,8 @@ object app { val versionRt = versionRoute(version, gitHash, time.currentTime()) val _ = Future { - http.bindAndHandle(route2HandlerFlow(handleExceptions(ExceptionHandler(exceptionHandler)) { ctx => + http.bindAndHandle(route2HandlerFlow({ ctx => + val trackingId = rest.extractTrackingId(ctx.request) MDC.put("trackingId", trackingId) log.audit(s"Received request ${ctx.request}") @@ -76,9 +77,11 @@ object app { val contextWithTrackingId = ctx.withRequest(ctx.request.addHeader(RawHeader(ContextHeaders.TrackingIdHeader, trackingId))) - respondWithHeaders(List(RawHeader(ContextHeaders.TrackingIdHeader, trackingId))) { - modules.map(_.route).foldLeft(versionRt ~ healthRoute ~ swaggerRoutes)(_ ~ _) - }(contextWithTrackingId) + handleExceptions(ExceptionHandler(exceptionHandler))({ _ => + respondWithHeaders(List(RawHeader(ContextHeaders.TrackingIdHeader, trackingId))) { + modules.map(_.route).foldLeft(versionRt ~ healthRoute ~ swaggerRoutes)(_ ~ _) + }(contextWithTrackingId) + })(contextWithTrackingId) }), interface, port)(materializer) } } -- cgit v1.2.3 From c71e402cee010d8cbc6e8119c8fb96367d085aa9 Mon Sep 17 00:00:00 2001 From: vlad Date: Mon, 13 Mar 2017 23:38:32 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index 5a1b803..ceaf772 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -95,27 +95,23 @@ object app { case is: IllegalStateException => ctx => - val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.error(s"Request is not allowed to ${ctx.request.uri} ($trackingId)", is) + log.error(s"Request is not allowed to ${ctx.request.uri}", is) complete(HttpResponse(BadRequest, entity = is.getMessage))(ctx) case cm: ConcurrentModificationException => ctx => - val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.error(s"Concurrent modification of the resource ${ctx.request.uri} ($trackingId)", cm) + log.error(s"Concurrent modification of the resource ${ctx.request.uri}", cm) complete( HttpResponse(Conflict, entity = "Resource was changed concurrently, try requesting a newer version"))(ctx) case sex: SQLException => ctx => - val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.error(s"Database exception for the resource ${ctx.request.uri} ($trackingId)", sex) + log.error(s"Database exception for the resource ${ctx.request.uri}", sex) complete(HttpResponse(InternalServerError, entity = "Data access error"))(ctx) case t: Throwable => ctx => - val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.error(s"Request to ${ctx.request.uri} could not be handled normally ($trackingId)", t) + log.error(s"Request to ${ctx.request.uri} could not be handled normally", t) complete(HttpResponse(InternalServerError, entity = t.getMessage))(ctx) } -- cgit v1.2.3 From bef521a16cfbc571cf9d5470735c2120454cfd18 Mon Sep 17 00:00:00 2001 From: vlad Date: Mon, 13 Mar 2017 23:38:54 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index ceaf772..5a1b803 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -95,23 +95,27 @@ object app { case is: IllegalStateException => ctx => - log.error(s"Request is not allowed to ${ctx.request.uri}", is) + val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) + log.error(s"Request is not allowed to ${ctx.request.uri} ($trackingId)", is) complete(HttpResponse(BadRequest, entity = is.getMessage))(ctx) case cm: ConcurrentModificationException => ctx => - log.error(s"Concurrent modification of the resource ${ctx.request.uri}", cm) + val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) + log.error(s"Concurrent modification of the resource ${ctx.request.uri} ($trackingId)", cm) complete( HttpResponse(Conflict, entity = "Resource was changed concurrently, try requesting a newer version"))(ctx) case sex: SQLException => ctx => - log.error(s"Database exception for the resource ${ctx.request.uri}", sex) + val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) + log.error(s"Database exception for the resource ${ctx.request.uri} ($trackingId)", sex) complete(HttpResponse(InternalServerError, entity = "Data access error"))(ctx) case t: Throwable => ctx => - log.error(s"Request to ${ctx.request.uri} could not be handled normally", t) + val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) + log.error(s"Request to ${ctx.request.uri} could not be handled normally ($trackingId)", t) complete(HttpResponse(InternalServerError, entity = t.getMessage))(ctx) } -- cgit v1.2.3 From 4251139b59bd95f8ceed7b09e95f588a14db2d7a Mon Sep 17 00:00:00 2001 From: vlad Date: Mon, 13 Mar 2017 23:44:53 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index 5a1b803..ca17c51 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -95,27 +95,27 @@ object app { case is: IllegalStateException => ctx => - val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.error(s"Request is not allowed to ${ctx.request.uri} ($trackingId)", is) + MDC.put("trackingId", rest.extractTrackingId(ctx.request)) + log.error(s"Request is not allowed to ${ctx.request.uri}", is) complete(HttpResponse(BadRequest, entity = is.getMessage))(ctx) case cm: ConcurrentModificationException => ctx => - val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.error(s"Concurrent modification of the resource ${ctx.request.uri} ($trackingId)", cm) + MDC.put("trackingId", rest.extractTrackingId(ctx.request)) + log.error(s"Concurrent modification of the resource ${ctx.request.uri}", cm) complete( HttpResponse(Conflict, entity = "Resource was changed concurrently, try requesting a newer version"))(ctx) case sex: SQLException => ctx => - val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.error(s"Database exception for the resource ${ctx.request.uri} ($trackingId)", sex) + MDC.put("trackingId", rest.extractTrackingId(ctx.request)) + log.error(s"Database exception for the resource ${ctx.request.uri}", sex) complete(HttpResponse(InternalServerError, entity = "Data access error"))(ctx) case t: Throwable => ctx => - val trackingId = Option(MDC.get("trackingId")).getOrElse(rest.extractTrackingId(ctx.request)) - log.error(s"Request to ${ctx.request.uri} could not be handled normally ($trackingId)", t) + MDC.put("trackingId", rest.extractTrackingId(ctx.request)) + log.error(s"Request to ${ctx.request.uri} could not be handled normally", t) complete(HttpResponse(InternalServerError, entity = t.getMessage))(ctx) } -- cgit v1.2.3 From 49bd394907b0894d10e718fba14caa116a027d7a Mon Sep 17 00:00:00 2001 From: vlad Date: Tue, 14 Mar 2017 00:03:28 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index ca17c51..c90a128 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -69,7 +69,6 @@ object app { val _ = Future { http.bindAndHandle(route2HandlerFlow({ ctx => - val trackingId = rest.extractTrackingId(ctx.request) MDC.put("trackingId", trackingId) log.audit(s"Received request ${ctx.request}") -- cgit v1.2.3 From a9653baf6113ea4e15fe61e283e5af47e2e4e0cf Mon Sep 17 00:00:00 2001 From: vlad Date: Tue, 14 Mar 2017 00:37:41 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 33 ++++++++++++++++++++++++++------ 1 file changed, 27 insertions(+), 6 deletions(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index c90a128..9884dff 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -3,15 +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.{HttpResponse, StatusCodes} +import akka.http.scaladsl.model.{HttpEntity, HttpRequest, HttpResponse, StatusCodes} 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.ActorMaterializer +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} @@ -76,13 +80,30 @@ object app { val contextWithTrackingId = ctx.withRequest(ctx.request.addHeader(RawHeader(ContextHeaders.TrackingIdHeader, trackingId))) - handleExceptions(ExceptionHandler(exceptionHandler))({ _ => - respondWithHeaders(List(RawHeader(ContextHeaders.TrackingIdHeader, trackingId))) { - modules.map(_.route).foldLeft(versionRt ~ healthRoute ~ swaggerRoutes)(_ ~ _) - }(contextWithTrackingId) + handleExceptions(ExceptionHandler(exceptionHandler))({ c => + logRequestResult(LoggingMagnet(log => myLoggingFunction(Logging.InfoLevel, log))) { + respondWithHeaders(List(RawHeader(ContextHeaders.TrackingIdHeader, trackingId))) { + modules.map(_.route).foldLeft(versionRt ~ healthRoute ~ swaggerRoutes)(_ ~ _) + } + }(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) } /** -- cgit v1.2.3 From a92c192ac006f6d1ab23fb2edb099dc2153aecd2 Mon Sep 17 00:00:00 2001 From: vlad Date: Tue, 14 Mar 2017 00:59:53 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 42 ++++++++++++++------------------ 1 file 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) } /** -- cgit v1.2.3 From 521b882674dc2ee6e95f27afd6ad226a4fdd8335 Mon Sep 17 00:00:00 2001 From: vlad Date: Tue, 14 Mar 2017 01:09:14 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index a2a059a..cbf61df 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -6,8 +6,8 @@ import akka.actor.ActorSystem 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._ +import akka.http.scaladsl.model.headers.RawHeader import akka.http.scaladsl.server.Directives._ import akka.http.scaladsl.server.RouteResult._ import akka.http.scaladsl.server.{ExceptionHandler, Route, RouteConcatenation} @@ -15,12 +15,11 @@ 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, MarkerFactory} +import org.slf4j.{LoggerFactory, MDC} import spray.json.DefaultJsonProtocol import xyz.driver.core import xyz.driver.core.logging.{Logger, TypesafeScalaLogger} -import xyz.driver.core.rest.ContextHeaders -import xyz.driver.core.rest.Swagger +import xyz.driver.core.rest.{ContextHeaders, Swagger} import xyz.driver.core.stats.SystemStats import xyz.driver.core.time.Time import xyz.driver.core.time.provider.{SystemTimeProvider, TimeProvider} @@ -80,9 +79,10 @@ object app { def requestLogging: Future[Unit] = { entityAsString(ctx.request.entity).map { data => - s"""{"method":"${ctx.request.method}","url": "${ctx.request.uri}","entity":"$data"""".stripMargin + s"""{"method":"${ctx.request.method.value}","url": "${ctx.request.uri}","entity":"$data"""".stripMargin } map { requestJson => - log.audit(MarkerFactory.getMarker("Received request"), requestJson) + MDC.put("message", "Received request") + log.audit(requestJson) } } -- cgit v1.2.3 From 8c4ccfbb428d236799a0178867906a6fee800a1d Mon Sep 17 00:00:00 2001 From: vlad Date: Tue, 14 Mar 2017 01:22:00 -0700 Subject: Added writing tracking Id to MDC so it can be logged for all messages, removed some linkerd legacy and refined Revision equals --- src/main/scala/xyz/driver/core/app.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala index cbf61df..12c6027 100644 --- a/src/main/scala/xyz/driver/core/app.scala +++ b/src/main/scala/xyz/driver/core/app.scala @@ -207,7 +207,7 @@ object app { Runtime.getRuntime.addShutdownHook(new Thread() { override def run(): Unit = { services.foreach { service => - Console.print(s"Service ${service.name} shutting down ...") + Console.print(s"Service ${service.name} shutting down ...\n") try { service.deactivate() } catch { @@ -215,7 +215,7 @@ object app { log.fatal(s"Service ${service.name} failed to deactivate", t) Console.print(" Failed! (check log)") } - Console.print(" Done\n") + Console.print(s"Service ${service.name} is shut down\n") } } }) -- cgit v1.2.3