From e2e00c4cbc74339541872709c267ff2b09f160f5 Mon Sep 17 00:00:00 2001 From: danicheg Date: Mon, 16 Jan 2023 23:40:03 +0300 Subject: [PATCH 1/3] Utilize Entity model in client's Logger Middleware --- .../org/http4s/client/middleware/Logger.scala | 22 ++++++++++++--- .../client/middleware/RequestLogger.scala | 26 ++++++++++++++--- .../client/middleware/ResponseLogger.scala | 26 ++++++++++++++--- .../scala/org/http4s/internal/Logger.scala | 28 +++++++++++++++---- 4 files changed, 84 insertions(+), 18 deletions(-) diff --git a/client/shared/src/main/scala/org/http4s/client/middleware/Logger.scala b/client/shared/src/main/scala/org/http4s/client/middleware/Logger.scala index 862bfa7bf2f..ccdf11d34f1 100644 --- a/client/shared/src/main/scala/org/http4s/client/middleware/Logger.scala +++ b/client/shared/src/main/scala/org/http4s/client/middleware/Logger.scala @@ -40,18 +40,32 @@ object Logger { ) ) - def logBodyText[F[_]: Async]( + def logWithBody[F[_]: Async]( logHeaders: Boolean, - logBody: Stream[F, Byte] => Option[F[String]], + logBody: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, logAction: Option[String => F[Unit]] = None, )(client: Client[F]): Client[F] = - ResponseLogger.logBodyText(logHeaders, logBody, redactHeadersWhen, logAction)( - RequestLogger.logBodyText(logHeaders, logBody, redactHeadersWhen, logAction)( + ResponseLogger.logWithBody(logHeaders, logBody, redactHeadersWhen, logAction)( + RequestLogger.logWithBody(logHeaders, logBody, redactHeadersWhen, logAction)( client ) ) + @deprecated("Use Logger.logWithBody that utilizes Entity model for a Message body", "1.0.0-M39") + def logBodyText[F[_]: Async]( + logHeaders: Boolean, + logBody: Stream[F, Byte] => Option[F[String]], + redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, + logAction: Option[String => F[Unit]] = None, + )(client: Client[F]): Client[F] = + logWithBody( + logHeaders, + (entity: Entity[F]) => logBody(entity.body), + redactHeadersWhen, + logAction, + )(client) + def logMessage[F[_]](message: Message[F])( logHeaders: Boolean, logBody: Boolean, diff --git a/client/shared/src/main/scala/org/http4s/client/middleware/RequestLogger.scala b/client/shared/src/main/scala/org/http4s/client/middleware/RequestLogger.scala index b97ca771d82..01f216629af 100644 --- a/client/shared/src/main/scala/org/http4s/client/middleware/RequestLogger.scala +++ b/client/shared/src/main/scala/org/http4s/client/middleware/RequestLogger.scala @@ -45,20 +45,38 @@ object RequestLogger { )(logAction.getOrElse(defaultLogAction[F])) } - def logBodyText[F[_]: Async]( + def logWithBody[F[_]: Async]( logHeaders: Boolean, - logBody: Stream[F, Byte] => Option[F[String]], + logBody: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(client: Client[F]): Client[F] = impl(client, logBody = true) { request => - InternalLogger.logMessageWithBodyText(request)( + InternalLogger.logMessageWithBody(request)( logHeaders, logBody, + logAction.getOrElse(defaultLogAction[F]), redactHeadersWhen, - )(logAction.getOrElse(defaultLogAction[F])) + ) } + @deprecated( + "Use RequestLogger.logWithBody that utilizes Entity model for a Message body", + "1.0.0-M39", + ) + def logBodyText[F[_]: Async]( + logHeaders: Boolean, + logBody: Stream[F, Byte] => Option[F[String]], + redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, + logAction: Option[String => F[Unit]] = None, + )(client: Client[F]): Client[F] = + logWithBody( + logHeaders, + (entity: Entity[F]) => logBody(entity.body), + redactHeadersWhen, + logAction, + )(client) + def customized[F[_]: Async]( client: Client[F], logBody: Boolean = true, diff --git a/client/shared/src/main/scala/org/http4s/client/middleware/ResponseLogger.scala b/client/shared/src/main/scala/org/http4s/client/middleware/ResponseLogger.scala index 466887d5feb..2deb5d54944 100644 --- a/client/shared/src/main/scala/org/http4s/client/middleware/ResponseLogger.scala +++ b/client/shared/src/main/scala/org/http4s/client/middleware/ResponseLogger.scala @@ -48,20 +48,38 @@ object ResponseLogger { )(logAction.getOrElse(defaultLogAction[F])) } - def logBodyText[F[_]: Async]( + def logWithBody[F[_]: Async]( logHeaders: Boolean, - logBody: Stream[F, Byte] => Option[F[String]], + logBody: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(client: Client[F]): Client[F] = impl(client, logBody = true) { response => - InternalLogger.logMessageWithBodyText(response)( + InternalLogger.logMessageWithBody(response)( logHeaders, logBody, + logAction.getOrElse(defaultLogAction[F]), redactHeadersWhen, - )(logAction.getOrElse(defaultLogAction[F])) + ) } + @deprecated( + "Use ResponseLogger.logWithBody that utilizes Entity model for a Message body", + "1.0.0-M39", + ) + def logBodyText[F[_]: Async]( + logHeaders: Boolean, + logBody: Stream[F, Byte] => Option[F[String]], + redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, + logAction: Option[String => F[Unit]] = None, + )(client: Client[F]): Client[F] = + logWithBody( + logHeaders, + (entity: Entity[F]) => logBody(entity.body), + redactHeadersWhen, + logAction, + )(client) + def customized[F[_]: Async]( client: Client[F], logBody: Boolean = true, diff --git a/core/shared/src/main/scala/org/http4s/internal/Logger.scala b/core/shared/src/main/scala/org/http4s/internal/Logger.scala index 596dedd9594..d44f20ea140 100644 --- a/core/shared/src/main/scala/org/http4s/internal/Logger.scala +++ b/core/shared/src/main/scala/org/http4s/internal/Logger.scala @@ -74,16 +74,17 @@ object Logger { logBody: Boolean, redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, )(log: String => F[Unit])(implicit F: Concurrent[F]): F[Unit] = { - val logBodyText = (_: Stream[F, Byte]) => defaultLogBody(message)(logBody) + val logBodyText = (_: Entity[F]) => defaultLogBody(message)(logBody) - logMessageWithBodyText(message)(logHeaders, logBodyText, redactHeadersWhen)(log) + logMessageWithBody(message)(logHeaders, logBodyText, log, redactHeadersWhen) } - def logMessageWithBodyText[F[_]](message: Message[F])( + def logMessageWithBody[F[_]](message: Message[F])( logHeaders: Boolean, - logBodyText: Stream[F, Byte] => Option[F[String]], + logBodyText: Entity[F] => Option[F[String]], + log: String => F[Unit], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, - )(log: String => F[Unit])(implicit F: Monad[F]): F[Unit] = { + )(implicit F: Monad[F]): F[Unit] = { def prelude = message match { case req: Request[_] => s"${req.httpVersion} ${req.method} ${req.uri}" @@ -93,7 +94,7 @@ object Logger { val headers: String = defaultLogHeaders(message)(logHeaders, redactHeadersWhen) val bodyText: F[String] = - logBodyText(message.body) match { + logBodyText(message.entity) match { case Some(textF) => textF.map(text => s"""body="$text"""") case None => F.pure("") } @@ -105,4 +106,19 @@ object Logger { .flatMap(log) } + @deprecated( + "Use Logger.logMessageWithBody that utilizes Entity model for a Message body", + "1.0.0-M39", + ) + def logMessageWithBodyText[F[_]](message: Message[F])( + logHeaders: Boolean, + logBodyText: Stream[F, Byte] => Option[F[String]], + redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, + )(log: String => F[Unit])(implicit F: Monad[F]): F[Unit] = + logMessageWithBody(message)( + logHeaders, + (entity: Entity[F]) => logBodyText(entity.body), + log, + redactHeadersWhen, + ) } From 3f49b9e075ffb612d9f2302939d09384bc028a6c Mon Sep 17 00:00:00 2001 From: danicheg Date: Tue, 17 Jan 2023 23:18:45 +0300 Subject: [PATCH 2/3] Utilize Entity model in server's Logger Middleware --- .../org/http4s/server/middleware/Logger.scala | 61 +++++++++++++++++-- .../server/middleware/RequestLogger.scala | 44 +++++++++++-- .../server/middleware/ResponseLogger.scala | 46 ++++++++++++-- 3 files changed, 137 insertions(+), 14 deletions(-) diff --git a/server/shared/src/main/scala/org/http4s/server/middleware/Logger.scala b/server/shared/src/main/scala/org/http4s/server/middleware/Logger.scala index 59c0d7af061..8228c992b16 100644 --- a/server/shared/src/main/scala/org/http4s/server/middleware/Logger.scala +++ b/server/shared/src/main/scala/org/http4s/server/middleware/Logger.scala @@ -50,9 +50,9 @@ object Logger { ) } - def logBodyText[G[_], F[_]]( + def logWithBody[G[_], F[_]]( logHeaders: Boolean, - logBody: Stream[F, Byte] => Option[F[String]], + logBody: Entity[F] => Option[F[String]], fk: F ~> G, redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, logAction: Option[String => F[Unit]] = None, @@ -65,6 +65,25 @@ object Logger { ) } + @deprecated( + "Use Logger.logWithBody that utilizes Entity model for a Message body", + "1.0.0-M39", + ) + def logBodyText[G[_], F[_]]( + logHeaders: Boolean, + logBody: Stream[F, Byte] => Option[F[String]], + fk: F ~> G, + redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, + logAction: Option[String => F[Unit]] = None, + )(http: Http[G, F])(implicit G: MonadCancelThrow[G], F: Async[F]): Http[G, F] = + logWithBody[G, F]( + logHeaders, + (entity: Entity[F]) => logBody(entity.body), + fk, + redactHeadersWhen, + logAction, + )(http) + def httpApp[F[_]: Async]( logHeaders: Boolean, logBody: Boolean, @@ -73,13 +92,30 @@ object Logger { )(httpApp: HttpApp[F]): HttpApp[F] = apply(logHeaders, logBody, FunctionK.id[F], redactHeadersWhen, logAction)(httpApp) + def httpAppLogBody[F[_]: Async]( + logHeaders: Boolean, + logBody: Entity[F] => Option[F[String]], + redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, + logAction: Option[String => F[Unit]] = None, + )(httpApp: HttpApp[F]): HttpApp[F] = + logWithBody(logHeaders, logBody, FunctionK.id[F], redactHeadersWhen, logAction)(httpApp) + + @deprecated( + "Use Logger.httpAppLogBody that utilizes Entity model for a Message body", + "1.0.0-M39", + ) def httpAppLogBodyText[F[_]: Async]( logHeaders: Boolean, logBody: Stream[F, Byte] => Option[F[String]], redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, logAction: Option[String => F[Unit]] = None, )(httpApp: HttpApp[F]): HttpApp[F] = - logBodyText(logHeaders, logBody, FunctionK.id[F], redactHeadersWhen, logAction)(httpApp) + httpAppLogBody( + logHeaders, + (entity: Entity[F]) => logBody(entity.body), + redactHeadersWhen, + logAction, + )(httpApp) def httpRoutes[F[_]: Async]( logHeaders: Boolean, @@ -89,13 +125,30 @@ object Logger { )(httpRoutes: HttpRoutes[F]): HttpRoutes[F] = apply(logHeaders, logBody, OptionT.liftK[F], redactHeadersWhen, logAction)(httpRoutes) + def httpRoutesLogBody[F[_]: Async]( + logHeaders: Boolean, + logBody: Entity[F] => Option[F[String]], + redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, + logAction: Option[String => F[Unit]] = None, + )(httpRoutes: HttpRoutes[F]): HttpRoutes[F] = + logWithBody(logHeaders, logBody, OptionT.liftK[F], redactHeadersWhen, logAction)(httpRoutes) + + @deprecated( + "Use Logger.httpRoutesLogBody that utilizes Entity model for a Message body", + "1.0.0-M39", + ) def httpRoutesLogBodyText[F[_]: Async]( logHeaders: Boolean, logBody: Stream[F, Byte] => Option[F[String]], redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, logAction: Option[String => F[Unit]] = None, )(httpRoutes: HttpRoutes[F]): HttpRoutes[F] = - logBodyText(logHeaders, logBody, OptionT.liftK[F], redactHeadersWhen, logAction)(httpRoutes) + httpRoutesLogBody( + logHeaders, + (entity: Entity[F]) => logBody(entity.body), + redactHeadersWhen, + logAction, + )(httpRoutes) def logMessage[F[_], A <: Message[F]](message: A)( logHeaders: Boolean, diff --git a/server/shared/src/main/scala/org/http4s/server/middleware/RequestLogger.scala b/server/shared/src/main/scala/org/http4s/server/middleware/RequestLogger.scala index 4dcbbbf1826..56a544fd80f 100644 --- a/server/shared/src/main/scala/org/http4s/server/middleware/RequestLogger.scala +++ b/server/shared/src/main/scala/org/http4s/server/middleware/RequestLogger.scala @@ -51,7 +51,7 @@ object RequestLogger { private[server] def impl[G[_], F[_]]( logHeaders: Boolean, - logBodyText: Either[Boolean, Stream[F, Byte] => Option[F[String]]], + logBodyText: Either[Boolean, Entity[F] => Option[F[String]]], fk: F ~> G, redactHeadersWhen: CIString => Boolean, logAction: Option[String => F[Unit]], @@ -69,7 +69,7 @@ object RequestLogger { Logger.logMessage[F, Request[F]](r)(logHeaders, bool, redactHeadersWhen)(log(_)) case Right(f) => org.http4s.internal.Logger - .logMessageWithBodyText(r)(logHeaders, f, redactHeadersWhen)(log(_)) + .logMessageWithBody(r)(logHeaders, f, log(_), redactHeadersWhen) } val logBody: Boolean = logBodyText match { @@ -135,19 +135,36 @@ object RequestLogger { )(httpRoutes: HttpRoutes[F]): HttpRoutes[F] = apply(logHeaders, logBody, OptionT.liftK[F], redactHeadersWhen, logAction)(httpRoutes) - def httpAppLogBodyText[F[_]: Async]( + def httpAppLogBody[F[_]: Async]( logHeaders: Boolean, - logBody: Stream[F, Byte] => Option[F[String]], + logBody: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(httpApp: HttpApp[F]): HttpApp[F] = impl[F, F](logHeaders, Right(logBody), FunctionK.id[F], redactHeadersWhen, logAction)(httpApp) - def httpRoutesLogBodyText[F[_]: Async]( + @deprecated( + "Use RequestLogger.httpAppLogBody that utilizes Entity model for a Message body", + "1.0.0-M39", + ) + def httpAppLogBodyText[F[_]: Async]( logHeaders: Boolean, logBody: Stream[F, Byte] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, + )(httpApp: HttpApp[F]): HttpApp[F] = + httpAppLogBody[F]( + logHeaders, + (entity: Entity[F]) => logBody(entity.body), + redactHeadersWhen, + logAction, + )(httpApp) + + def httpRoutesLogBody[F[_]: Async]( + logHeaders: Boolean, + logBody: Entity[F] => Option[F[String]], + redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, + logAction: Option[String => F[Unit]] = None, )(httpRoutes: HttpRoutes[F]): HttpRoutes[F] = impl[OptionT[F, *], F]( logHeaders, @@ -156,4 +173,21 @@ object RequestLogger { redactHeadersWhen, logAction, )(httpRoutes) + + @deprecated( + "Use RequestLogger.httpRoutesLogBody that utilizes Entity model for a Message body", + "1.0.0-M39", + ) + def httpRoutesLogBodyText[F[_]: Async]( + logHeaders: Boolean, + logBody: Stream[F, Byte] => Option[F[String]], + redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, + logAction: Option[String => F[Unit]] = None, + )(httpRoutes: HttpRoutes[F]): HttpRoutes[F] = + httpRoutesLogBody[F]( + logHeaders, + (entity: Entity[F]) => logBody(entity.body), + redactHeadersWhen, + logAction, + )(httpRoutes) } diff --git a/server/shared/src/main/scala/org/http4s/server/middleware/ResponseLogger.scala b/server/shared/src/main/scala/org/http4s/server/middleware/ResponseLogger.scala index 616e8912a4a..099cf7420b4 100644 --- a/server/shared/src/main/scala/org/http4s/server/middleware/ResponseLogger.scala +++ b/server/shared/src/main/scala/org/http4s/server/middleware/ResponseLogger.scala @@ -50,7 +50,7 @@ object ResponseLogger { private[server] def impl[G[_], F[_], A]( logHeaders: Boolean, - logBodyText: Either[Boolean, Stream[F, Byte] => Option[F[String]]], + logBodyText: Either[Boolean, Entity[F] => Option[F[String]]], fk: F ~> G, redactHeadersWhen: CIString => Boolean, logAction: Option[String => F[Unit]], @@ -66,7 +66,7 @@ object ResponseLogger { Logger.logMessage[F, Response[F]](resp)(logHeaders, bool, redactHeadersWhen)(log(_)) case Right(f) => org.http4s.internal.Logger - .logMessageWithBodyText(resp)(logHeaders, f, redactHeadersWhen)(log(_)) + .logMessageWithBody(resp)(logHeaders, f, log(_), redactHeadersWhen) } val logBody: Boolean = logBodyText match { @@ -115,13 +115,32 @@ object ResponseLogger { )(httpApp: Kleisli[F, A, Response[F]]): Kleisli[F, A, Response[F]] = apply(logHeaders, logBody, FunctionK.id[F], redactHeadersWhen, logAction)(httpApp) + def httpAppLogBody[F[_]: Async, A]( + logHeaders: Boolean, + logBody: Entity[F] => Option[F[String]], + redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, + logAction: Option[String => F[Unit]] = None, + )(httpApp: Kleisli[F, A, Response[F]]): Kleisli[F, A, Response[F]] = + impl[F, F, A](logHeaders, Right(logBody), FunctionK.id[F], redactHeadersWhen, logAction)( + httpApp + ) + + @deprecated( + "Use ResponseLogger.httpAppLogBody that utilizes Entity model for a Message body", + "1.0.0-M39", + ) def httpAppLogBodyText[F[_]: Async, A]( logHeaders: Boolean, logBody: Stream[F, Byte] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(httpApp: Kleisli[F, A, Response[F]]): Kleisli[F, A, Response[F]] = - impl[F, F, A](logHeaders, Right(logBody), FunctionK.id[F], redactHeadersWhen, logAction)( + httpAppLogBody[F, A]( + logHeaders, + (entity: Entity[F]) => logBody(entity.body), + redactHeadersWhen, + logAction, + )( httpApp ) @@ -133,9 +152,9 @@ object ResponseLogger { )(httpRoutes: Kleisli[OptionT[F, *], A, Response[F]]): Kleisli[OptionT[F, *], A, Response[F]] = apply(logHeaders, logBody, OptionT.liftK[F], redactHeadersWhen, logAction)(httpRoutes) - def httpRoutesLogBodyText[F[_]: Async, A]( + def httpRoutesLogBody[F[_]: Async, A]( logHeaders: Boolean, - logBody: Stream[F, Byte] => Option[F[String]], + logBody: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(httpRoutes: Kleisli[OptionT[F, *], A, Response[F]]): Kleisli[OptionT[F, *], A, Response[F]] = @@ -146,4 +165,21 @@ object ResponseLogger { redactHeadersWhen, logAction, )(httpRoutes) + + @deprecated( + "Use ResponseLogger.httpRoutesLogBody that utilizes Entity model for a Message body", + "1.0.0-M39", + ) + def httpRoutesLogBodyText[F[_]: Async, A]( + logHeaders: Boolean, + logBody: Stream[F, Byte] => Option[F[String]], + redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, + logAction: Option[String => F[Unit]] = None, + )(httpRoutes: Kleisli[OptionT[F, *], A, Response[F]]): Kleisli[OptionT[F, *], A, Response[F]] = + httpRoutesLogBody[F, A]( + logHeaders, + (entity: Entity[F]) => logBody(entity.body), + redactHeadersWhen, + logAction, + )(httpRoutes) } From 8259255e7195c365f4ee50c2a00db534282cebb7 Mon Sep 17 00:00:00 2001 From: danicheg Date: Mon, 24 Apr 2023 07:57:31 +0300 Subject: [PATCH 3/3] Rename logger functions --- .../org/http4s/client/middleware/Logger.scala | 12 +++---- .../client/middleware/RequestLogger.scala | 12 +++---- .../client/middleware/ResponseLogger.scala | 12 +++---- .../scala/org/http4s/internal/Logger.scala | 12 +++---- .../org/http4s/server/middleware/Logger.scala | 34 ++++++++++--------- .../server/middleware/RequestLogger.scala | 22 ++++++------ .../server/middleware/ResponseLogger.scala | 22 ++++++------ 7 files changed, 64 insertions(+), 62 deletions(-) diff --git a/client/shared/src/main/scala/org/http4s/client/middleware/Logger.scala b/client/shared/src/main/scala/org/http4s/client/middleware/Logger.scala index ccdf11d34f1..59b4091ce05 100644 --- a/client/shared/src/main/scala/org/http4s/client/middleware/Logger.scala +++ b/client/shared/src/main/scala/org/http4s/client/middleware/Logger.scala @@ -40,26 +40,26 @@ object Logger { ) ) - def logWithBody[F[_]: Async]( + def logWithEntity[F[_]: Async]( logHeaders: Boolean, - logBody: Entity[F] => Option[F[String]], + logEntity: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, logAction: Option[String => F[Unit]] = None, )(client: Client[F]): Client[F] = - ResponseLogger.logWithBody(logHeaders, logBody, redactHeadersWhen, logAction)( - RequestLogger.logWithBody(logHeaders, logBody, redactHeadersWhen, logAction)( + ResponseLogger.logWithEntity(logHeaders, logEntity, redactHeadersWhen, logAction)( + RequestLogger.logWithEntity(logHeaders, logEntity, redactHeadersWhen, logAction)( client ) ) - @deprecated("Use Logger.logWithBody that utilizes Entity model for a Message body", "1.0.0-M39") + @deprecated("Use Logger.logWithEntity that utilizes Entity model for a Message body", "1.0.0-M39") def logBodyText[F[_]: Async]( logHeaders: Boolean, logBody: Stream[F, Byte] => Option[F[String]], redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, logAction: Option[String => F[Unit]] = None, )(client: Client[F]): Client[F] = - logWithBody( + logWithEntity( logHeaders, (entity: Entity[F]) => logBody(entity.body), redactHeadersWhen, diff --git a/client/shared/src/main/scala/org/http4s/client/middleware/RequestLogger.scala b/client/shared/src/main/scala/org/http4s/client/middleware/RequestLogger.scala index 01f216629af..8c458f52cd6 100644 --- a/client/shared/src/main/scala/org/http4s/client/middleware/RequestLogger.scala +++ b/client/shared/src/main/scala/org/http4s/client/middleware/RequestLogger.scala @@ -45,23 +45,23 @@ object RequestLogger { )(logAction.getOrElse(defaultLogAction[F])) } - def logWithBody[F[_]: Async]( + def logWithEntity[F[_]: Async]( logHeaders: Boolean, - logBody: Entity[F] => Option[F[String]], + logEntity: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(client: Client[F]): Client[F] = impl(client, logBody = true) { request => - InternalLogger.logMessageWithBody(request)( + InternalLogger.logMessageWithEntity(request)( logHeaders, - logBody, + logEntity, logAction.getOrElse(defaultLogAction[F]), redactHeadersWhen, ) } @deprecated( - "Use RequestLogger.logWithBody that utilizes Entity model for a Message body", + "Use RequestLogger.logWithEntity that utilizes Entity model for a Message body", "1.0.0-M39", ) def logBodyText[F[_]: Async]( @@ -70,7 +70,7 @@ object RequestLogger { redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(client: Client[F]): Client[F] = - logWithBody( + logWithEntity( logHeaders, (entity: Entity[F]) => logBody(entity.body), redactHeadersWhen, diff --git a/client/shared/src/main/scala/org/http4s/client/middleware/ResponseLogger.scala b/client/shared/src/main/scala/org/http4s/client/middleware/ResponseLogger.scala index 2deb5d54944..8d5ab1c9445 100644 --- a/client/shared/src/main/scala/org/http4s/client/middleware/ResponseLogger.scala +++ b/client/shared/src/main/scala/org/http4s/client/middleware/ResponseLogger.scala @@ -48,23 +48,23 @@ object ResponseLogger { )(logAction.getOrElse(defaultLogAction[F])) } - def logWithBody[F[_]: Async]( + def logWithEntity[F[_]: Async]( logHeaders: Boolean, - logBody: Entity[F] => Option[F[String]], + logEntity: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(client: Client[F]): Client[F] = impl(client, logBody = true) { response => - InternalLogger.logMessageWithBody(response)( + InternalLogger.logMessageWithEntity(response)( logHeaders, - logBody, + logEntity, logAction.getOrElse(defaultLogAction[F]), redactHeadersWhen, ) } @deprecated( - "Use ResponseLogger.logWithBody that utilizes Entity model for a Message body", + "Use ResponseLogger.logWithEntity that utilizes Entity model for a Message body", "1.0.0-M39", ) def logBodyText[F[_]: Async]( @@ -73,7 +73,7 @@ object ResponseLogger { redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(client: Client[F]): Client[F] = - logWithBody( + logWithEntity( logHeaders, (entity: Entity[F]) => logBody(entity.body), redactHeadersWhen, diff --git a/core/shared/src/main/scala/org/http4s/internal/Logger.scala b/core/shared/src/main/scala/org/http4s/internal/Logger.scala index d44f20ea140..efde75acb58 100644 --- a/core/shared/src/main/scala/org/http4s/internal/Logger.scala +++ b/core/shared/src/main/scala/org/http4s/internal/Logger.scala @@ -76,12 +76,12 @@ object Logger { )(log: String => F[Unit])(implicit F: Concurrent[F]): F[Unit] = { val logBodyText = (_: Entity[F]) => defaultLogBody(message)(logBody) - logMessageWithBody(message)(logHeaders, logBodyText, log, redactHeadersWhen) + logMessageWithEntity(message)(logHeaders, logBodyText, log, redactHeadersWhen) } - def logMessageWithBody[F[_]](message: Message[F])( + def logMessageWithEntity[F[_]](message: Message[F])( logHeaders: Boolean, - logBodyText: Entity[F] => Option[F[String]], + logEntity: Entity[F] => Option[F[String]], log: String => F[Unit], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, )(implicit F: Monad[F]): F[Unit] = { @@ -94,7 +94,7 @@ object Logger { val headers: String = defaultLogHeaders(message)(logHeaders, redactHeadersWhen) val bodyText: F[String] = - logBodyText(message.entity) match { + logEntity(message.entity) match { case Some(textF) => textF.map(text => s"""body="$text"""") case None => F.pure("") } @@ -107,7 +107,7 @@ object Logger { } @deprecated( - "Use Logger.logMessageWithBody that utilizes Entity model for a Message body", + "Use Logger.logMessageWithEntity that utilizes Entity model for a Message body", "1.0.0-M39", ) def logMessageWithBodyText[F[_]](message: Message[F])( @@ -115,7 +115,7 @@ object Logger { logBodyText: Stream[F, Byte] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, )(log: String => F[Unit])(implicit F: Monad[F]): F[Unit] = - logMessageWithBody(message)( + logMessageWithEntity(message)( logHeaders, (entity: Entity[F]) => logBodyText(entity.body), log, diff --git a/server/shared/src/main/scala/org/http4s/server/middleware/Logger.scala b/server/shared/src/main/scala/org/http4s/server/middleware/Logger.scala index 8228c992b16..37519f8c17e 100644 --- a/server/shared/src/main/scala/org/http4s/server/middleware/Logger.scala +++ b/server/shared/src/main/scala/org/http4s/server/middleware/Logger.scala @@ -50,9 +50,9 @@ object Logger { ) } - def logWithBody[G[_], F[_]]( + def logWithEntity[G[_], F[_]]( logHeaders: Boolean, - logBody: Entity[F] => Option[F[String]], + logEntity: Entity[F] => Option[F[String]], fk: F ~> G, redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, logAction: Option[String => F[Unit]] = None, @@ -60,13 +60,15 @@ object Logger { val log: String => F[Unit] = logAction.getOrElse { s => logger.info(s).to[F] } - ResponseLogger.impl(logHeaders, Right(logBody), fk, redactHeadersWhen, log.pure[Option])( - RequestLogger.impl(logHeaders, Right(logBody), fk, redactHeadersWhen, log.pure[Option])(http) + ResponseLogger.impl(logHeaders, Right(logEntity), fk, redactHeadersWhen, log.pure[Option])( + RequestLogger.impl(logHeaders, Right(logEntity), fk, redactHeadersWhen, log.pure[Option])( + http + ) ) } @deprecated( - "Use Logger.logWithBody that utilizes Entity model for a Message body", + "Use Logger.logWithEntity that utilizes Entity model for a Message body", "1.0.0-M39", ) def logBodyText[G[_], F[_]]( @@ -76,7 +78,7 @@ object Logger { redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, logAction: Option[String => F[Unit]] = None, )(http: Http[G, F])(implicit G: MonadCancelThrow[G], F: Async[F]): Http[G, F] = - logWithBody[G, F]( + logWithEntity[G, F]( logHeaders, (entity: Entity[F]) => logBody(entity.body), fk, @@ -92,16 +94,16 @@ object Logger { )(httpApp: HttpApp[F]): HttpApp[F] = apply(logHeaders, logBody, FunctionK.id[F], redactHeadersWhen, logAction)(httpApp) - def httpAppLogBody[F[_]: Async]( + def httpAppLogEntity[F[_]: Async]( logHeaders: Boolean, - logBody: Entity[F] => Option[F[String]], + logEntity: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, logAction: Option[String => F[Unit]] = None, )(httpApp: HttpApp[F]): HttpApp[F] = - logWithBody(logHeaders, logBody, FunctionK.id[F], redactHeadersWhen, logAction)(httpApp) + logWithEntity(logHeaders, logEntity, FunctionK.id[F], redactHeadersWhen, logAction)(httpApp) @deprecated( - "Use Logger.httpAppLogBody that utilizes Entity model for a Message body", + "Use Logger.httpAppLogEntity that utilizes Entity model for a Message body", "1.0.0-M39", ) def httpAppLogBodyText[F[_]: Async]( @@ -110,7 +112,7 @@ object Logger { redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, logAction: Option[String => F[Unit]] = None, )(httpApp: HttpApp[F]): HttpApp[F] = - httpAppLogBody( + httpAppLogEntity( logHeaders, (entity: Entity[F]) => logBody(entity.body), redactHeadersWhen, @@ -125,16 +127,16 @@ object Logger { )(httpRoutes: HttpRoutes[F]): HttpRoutes[F] = apply(logHeaders, logBody, OptionT.liftK[F], redactHeadersWhen, logAction)(httpRoutes) - def httpRoutesLogBody[F[_]: Async]( + def httpRoutesLogEntity[F[_]: Async]( logHeaders: Boolean, - logBody: Entity[F] => Option[F[String]], + logEntity: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, logAction: Option[String => F[Unit]] = None, )(httpRoutes: HttpRoutes[F]): HttpRoutes[F] = - logWithBody(logHeaders, logBody, OptionT.liftK[F], redactHeadersWhen, logAction)(httpRoutes) + logWithEntity(logHeaders, logEntity, OptionT.liftK[F], redactHeadersWhen, logAction)(httpRoutes) @deprecated( - "Use Logger.httpRoutesLogBody that utilizes Entity model for a Message body", + "Use Logger.httpRoutesLogEntity that utilizes Entity model for a Message body", "1.0.0-M39", ) def httpRoutesLogBodyText[F[_]: Async]( @@ -143,7 +145,7 @@ object Logger { redactHeadersWhen: CIString => Boolean = defaultRedactHeadersWhen, logAction: Option[String => F[Unit]] = None, )(httpRoutes: HttpRoutes[F]): HttpRoutes[F] = - httpRoutesLogBody( + httpRoutesLogEntity( logHeaders, (entity: Entity[F]) => logBody(entity.body), redactHeadersWhen, diff --git a/server/shared/src/main/scala/org/http4s/server/middleware/RequestLogger.scala b/server/shared/src/main/scala/org/http4s/server/middleware/RequestLogger.scala index 56a544fd80f..fa0a6ddbd64 100644 --- a/server/shared/src/main/scala/org/http4s/server/middleware/RequestLogger.scala +++ b/server/shared/src/main/scala/org/http4s/server/middleware/RequestLogger.scala @@ -69,7 +69,7 @@ object RequestLogger { Logger.logMessage[F, Request[F]](r)(logHeaders, bool, redactHeadersWhen)(log(_)) case Right(f) => org.http4s.internal.Logger - .logMessageWithBody(r)(logHeaders, f, log(_), redactHeadersWhen) + .logMessageWithEntity(r)(logHeaders, f, log(_), redactHeadersWhen) } val logBody: Boolean = logBodyText match { @@ -135,16 +135,16 @@ object RequestLogger { )(httpRoutes: HttpRoutes[F]): HttpRoutes[F] = apply(logHeaders, logBody, OptionT.liftK[F], redactHeadersWhen, logAction)(httpRoutes) - def httpAppLogBody[F[_]: Async]( + def httpAppLogEntity[F[_]: Async]( logHeaders: Boolean, - logBody: Entity[F] => Option[F[String]], + logEntity: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(httpApp: HttpApp[F]): HttpApp[F] = - impl[F, F](logHeaders, Right(logBody), FunctionK.id[F], redactHeadersWhen, logAction)(httpApp) + impl[F, F](logHeaders, Right(logEntity), FunctionK.id[F], redactHeadersWhen, logAction)(httpApp) @deprecated( - "Use RequestLogger.httpAppLogBody that utilizes Entity model for a Message body", + "Use RequestLogger.httpAppLogEntity that utilizes Entity model for a Message body", "1.0.0-M39", ) def httpAppLogBodyText[F[_]: Async]( @@ -153,29 +153,29 @@ object RequestLogger { redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(httpApp: HttpApp[F]): HttpApp[F] = - httpAppLogBody[F]( + httpAppLogEntity[F]( logHeaders, (entity: Entity[F]) => logBody(entity.body), redactHeadersWhen, logAction, )(httpApp) - def httpRoutesLogBody[F[_]: Async]( + def httpRoutesLogEntity[F[_]: Async]( logHeaders: Boolean, - logBody: Entity[F] => Option[F[String]], + logEntity: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(httpRoutes: HttpRoutes[F]): HttpRoutes[F] = impl[OptionT[F, *], F]( logHeaders, - Right(logBody), + Right(logEntity), OptionT.liftK[F], redactHeadersWhen, logAction, )(httpRoutes) @deprecated( - "Use RequestLogger.httpRoutesLogBody that utilizes Entity model for a Message body", + "Use RequestLogger.httpRoutesLogEntity that utilizes Entity model for a Message body", "1.0.0-M39", ) def httpRoutesLogBodyText[F[_]: Async]( @@ -184,7 +184,7 @@ object RequestLogger { redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(httpRoutes: HttpRoutes[F]): HttpRoutes[F] = - httpRoutesLogBody[F]( + httpRoutesLogEntity[F]( logHeaders, (entity: Entity[F]) => logBody(entity.body), redactHeadersWhen, diff --git a/server/shared/src/main/scala/org/http4s/server/middleware/ResponseLogger.scala b/server/shared/src/main/scala/org/http4s/server/middleware/ResponseLogger.scala index 099cf7420b4..0dcf8c78937 100644 --- a/server/shared/src/main/scala/org/http4s/server/middleware/ResponseLogger.scala +++ b/server/shared/src/main/scala/org/http4s/server/middleware/ResponseLogger.scala @@ -66,7 +66,7 @@ object ResponseLogger { Logger.logMessage[F, Response[F]](resp)(logHeaders, bool, redactHeadersWhen)(log(_)) case Right(f) => org.http4s.internal.Logger - .logMessageWithBody(resp)(logHeaders, f, log(_), redactHeadersWhen) + .logMessageWithEntity(resp)(logHeaders, f, log(_), redactHeadersWhen) } val logBody: Boolean = logBodyText match { @@ -115,18 +115,18 @@ object ResponseLogger { )(httpApp: Kleisli[F, A, Response[F]]): Kleisli[F, A, Response[F]] = apply(logHeaders, logBody, FunctionK.id[F], redactHeadersWhen, logAction)(httpApp) - def httpAppLogBody[F[_]: Async, A]( + def httpAppLogEntity[F[_]: Async, A]( logHeaders: Boolean, - logBody: Entity[F] => Option[F[String]], + logEntity: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(httpApp: Kleisli[F, A, Response[F]]): Kleisli[F, A, Response[F]] = - impl[F, F, A](logHeaders, Right(logBody), FunctionK.id[F], redactHeadersWhen, logAction)( + impl[F, F, A](logHeaders, Right(logEntity), FunctionK.id[F], redactHeadersWhen, logAction)( httpApp ) @deprecated( - "Use ResponseLogger.httpAppLogBody that utilizes Entity model for a Message body", + "Use ResponseLogger.httpAppLogEntity that utilizes Entity model for a Message body", "1.0.0-M39", ) def httpAppLogBodyText[F[_]: Async, A]( @@ -135,7 +135,7 @@ object ResponseLogger { redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(httpApp: Kleisli[F, A, Response[F]]): Kleisli[F, A, Response[F]] = - httpAppLogBody[F, A]( + httpAppLogEntity[F, A]( logHeaders, (entity: Entity[F]) => logBody(entity.body), redactHeadersWhen, @@ -152,22 +152,22 @@ object ResponseLogger { )(httpRoutes: Kleisli[OptionT[F, *], A, Response[F]]): Kleisli[OptionT[F, *], A, Response[F]] = apply(logHeaders, logBody, OptionT.liftK[F], redactHeadersWhen, logAction)(httpRoutes) - def httpRoutesLogBody[F[_]: Async, A]( + def httpRoutesLogEntity[F[_]: Async, A]( logHeaders: Boolean, - logBody: Entity[F] => Option[F[String]], + logEntity: Entity[F] => Option[F[String]], redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(httpRoutes: Kleisli[OptionT[F, *], A, Response[F]]): Kleisli[OptionT[F, *], A, Response[F]] = impl[OptionT[F, *], F, A]( logHeaders, - Right(logBody), + Right(logEntity), OptionT.liftK[F], redactHeadersWhen, logAction, )(httpRoutes) @deprecated( - "Use ResponseLogger.httpRoutesLogBody that utilizes Entity model for a Message body", + "Use ResponseLogger.httpRoutesLogEntity that utilizes Entity model for a Message body", "1.0.0-M39", ) def httpRoutesLogBodyText[F[_]: Async, A]( @@ -176,7 +176,7 @@ object ResponseLogger { redactHeadersWhen: CIString => Boolean = Headers.SensitiveHeaders.contains, logAction: Option[String => F[Unit]] = None, )(httpRoutes: Kleisli[OptionT[F, *], A, Response[F]]): Kleisli[OptionT[F, *], A, Response[F]] = - httpRoutesLogBody[F, A]( + httpRoutesLogEntity[F, A]( logHeaders, (entity: Entity[F]) => logBody(entity.body), redactHeadersWhen,