feat: refactoring filters to middlewares

Author: MoeQuadrat

app/de/innfactory/bootstrapplay2/filters/MiddlewareRegistry.scala

@@ -0,0 +1,18 @@
+package de.innfactory.bootstrapplay2.filters
+
+import de.innfactory.bootstrapplay2.filters.access.RouteBlacklistFilter
+import de.innfactory.bootstrapplay2.filters.logging.AccessLoggingFilter
+import de.innfactory.bootstrapplay2.filters.tracing.TracingFilter
+import de.innfactory.smithy4play.middleware.{MiddlewareBase, MiddlewareRegistryBase, ValidateAuthMiddleware}
+
+import javax.inject.Inject
+
+class MiddlewareRegistry @Inject() (
+    routeBlacklistFilter: RouteBlacklistFilter,
+    accessLoggingFilter: AccessLoggingFilter,
+    tracingFilter: TracingFilter,
+    validateAuthMiddleware: ValidateAuthMiddleware
+) extends MiddlewareRegistryBase {
+  override val middlewares: Seq[MiddlewareBase] =
+    Seq(tracingFilter, routeBlacklistFilter, accessLoggingFilter, validateAuthMiddleware)
+}

app/de/innfactory/bootstrapplay2/filters/access/RouteBlacklistFilter.scala

@@ -3,6 +3,9 @@ package de.innfactory.bootstrapplay2.filters.access
 import javax.inject.Inject
 import akka.stream.Materializer
 import com.typesafe.config.Config
+import de.innfactory.smithy4play
+import de.innfactory.smithy4play.{RouteResult, RoutingContext}
+import de.innfactory.smithy4play.middleware.MiddlewareBase
 import play.api.mvc.Results.NotFound
 
 import scala.concurrent.ExecutionContext.Implicits.global
@@ -13,7 +16,7 @@ import play.api.mvc._
 import play.api._
 
 class RouteBlacklistFilter @Inject() (config: Config, implicit val mat: Materializer, environment: Environment)
-    extends Filter {
+    extends MiddlewareBase {
 
   case class BlackListEntry(route: String, environment: Mode, method: String)
 
@@ -23,22 +26,20 @@ class RouteBlacklistFilter @Inject() (config: Config, implicit val mat: Material
 
   /**
    * Check if route is contained in blacklistedRoutes and block request if true
-   * @param nextFilter
-   * @param request
-   * @return
    */
-  def apply(nextFilter: RequestHeader => Future[Result])(request: RequestHeader): Future[Result] =
-    if (shouldBeBlocked(request.path, request.method)) {
-      accessLogger.logger.warn(s"Illegal access to ${request.path} with ${request.method} in production")
-      Future(NotFound(""))
-    } else
-      nextFilter.apply(request)
-
-  def shouldBeBlocked(path: String, method: String): Boolean = {
+  override protected def skipMiddleware(r: RoutingContext): Boolean = {
+    val path = r.requestHeader.path
+    val method = r.requestHeader.method
     for (route <- blacklistedRoutes)
       if (environment.mode == route.environment && path.startsWith(route.route) && route.method == method)
-        return true
+        accessLogger.logger.warn(s"Illegal access to $path with $method in production")
+    return true
     false
   }
 
+  override protected def logic(
+      r: RoutingContext,
+      next: RoutingContext => RouteResult[smithy4play.EndpointResult]
+  ): RouteResult[smithy4play.EndpointResult] =
+    next.apply(r)
 }

app/de/innfactory/bootstrapplay2/filters/logging/AccessLoggingFilter.scala

@@ -3,47 +3,49 @@ package de.innfactory.bootstrapplay2.filters.logging
 import javax.inject.Inject
 import akka.stream.Materializer
 import com.typesafe.config.Config
+import de.innfactory.smithy4play
+import de.innfactory.smithy4play.{ContextRouteError, EndpointResult, RouteResult, RoutingContext}
+import de.innfactory.smithy4play.middleware.MiddlewareBase
 
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
 import play.api.Logger
 import play.api.mvc._
 import play.api._
 
-class AccessLoggingFilter @Inject() (config: Config, implicit val mat: Materializer) extends Filter {
+class AccessLoggingFilter @Inject() (config: Config, implicit val mat: Materializer) extends MiddlewareBase {
   val accessLogger = Logger("AccessFilterLog")
 
   /**
    * status list from application.conf
    */
   private val configAccessStatus =
-    config.getIntList("logging.access.statusList ")
+    config.getIntList("logging.access.statusList")
 
   /**
    * Logs requests if result header status is inclueded in logging.access.statusList as defined in application.conf
-   * @param next
-   * @param request
-   * @return
    */
-  def apply(next: RequestHeader => Future[Result])(request: RequestHeader): Future[Result] = {
-    val resultFuture = next(request)
-    resultFuture.foreach { result =>
-      if (shouldBeLogged(result)) {
+  override protected def logic(
+      r: RoutingContext,
+      next: RoutingContext => RouteResult[EndpointResult]
+  ): RouteResult[EndpointResult] = {
+    val request = r.requestHeader
+    val result = next(r)
+    result.leftMap { e =>
+      if (shouldBeLogged(e)) {
         val msg =
-          s"RequestID: status=${result.header.status} method=${request.method} uri=${request.uri} remote-address=${request.remoteAddress}" +
+          s"RequestID: status=${e.statusCode} method=${request.method} uri=${request.uri} remote-address=${request.remoteAddress}" +
             s" authorization-header=${request.headers.get("Authorization")}"
         accessLogger.warn(msg)
       }
+      e
     }
-    resultFuture
   }
 
   /**
    * check if request/result should be logged
-   * @param result
-   * @return
    */
-  def shouldBeLogged(result: Result): Boolean =
-    configAccessStatus.contains(result.header.status)
+  def shouldBeLogged(e: ContextRouteError): Boolean =
+    configAccessStatus.contains(e.statusCode)
 
 }

app/de/innfactory/bootstrapplay2/filters/TracingFilter.scala app/de/innfactory/bootstrapplay2/filters/tracing/TracingFilter.scala

@@ -1,4 +1,4 @@
-package de.innfactory.bootstrapplay2.filters
+package de.innfactory.bootstrapplay2.filters.tracing
 
 import akka.stream.Materializer
 import com.google.cloud.opentelemetry.shadow.semconv.trace.attributes.SemanticAttributes
@@ -11,6 +11,9 @@ import de.innfactory.play.tracing.GoogleTracingIdentifier.GoogleAttributes.{
 }
 import de.innfactory.play.tracing.GoogleTracingIdentifier.XTRACINGID
 import de.innfactory.play.tracing.{OpentelemetryProvider, TraceLogger}
+import de.innfactory.smithy4play
+import de.innfactory.smithy4play.middleware.MiddlewareBase
+import de.innfactory.smithy4play.{EndpointResult, RouteResult, RoutingContext}
 import io.opentelemetry.api.GlobalOpenTelemetry
 import io.opentelemetry.context.Context
 import org.joda.time.DateTime
@@ -19,21 +22,30 @@ import play.api.mvc._
 
 import javax.inject.Inject
 import scala.concurrent.ExecutionContext.Implicits.global
-import scala.concurrent.Future
 
-class TracingFilter @Inject() (config: Config, implicit val mat: Materializer) extends Filter with ImplicitLogContext {
+class TracingFilter @Inject() (config: Config, implicit val mat: Materializer)
+    extends MiddlewareBase
+    with ImplicitLogContext {
   private val healthEndpoints: Map[String, Seq[String]] = Map("GET" -> Seq("/", "/liveness", "/readiness"))
   private val healthLogger = Logger("health").logger
   private val configAccessStatus = config.getIntList("logging.access.statusList")
 
-  def apply(next: RequestHeader => Future[Result])(request: RequestHeader): Future[Result] =
-    if (!healthEndpoints.getOrElse(request.method, Seq.empty).contains(request.path))
-      handleLoggingAndTracing(next)(request)
-    else
-      handleHealthChecksLogging(next, request)
-
-  def handleLoggingAndTracing(next: RequestHeader => Future[Result])(request: RequestHeader): Future[Result] = {
+  override protected def logic(
+      r: RoutingContext,
+      next: RoutingContext => RouteResult[smithy4play.EndpointResult]
+  ): RouteResult[smithy4play.EndpointResult] = if (
+    !healthEndpoints.getOrElse(r.requestHeader.method, Seq.empty).contains(r.requestHeader.path)
+  )
+    handleLoggingAndTracing(next, r)
+  else
+    handleHealthChecksLogging(next, r)
+
+  def handleLoggingAndTracing(
+      next: RoutingContext => RouteResult[smithy4play.EndpointResult],
+      r: RoutingContext
+  ): RouteResult[smithy4play.EndpointResult] = {
     // Start Trace Span Root
+    val request = r.requestHeader
     val span = OpentelemetryProvider.getTracer().spanBuilder(request.path).startSpan()
     val latencyRecorder = OpentelemetryProvider
       .getMeter()
@@ -68,21 +80,25 @@ class TracingFilter @Inject() (config: Config, implicit val mat: Materializer) e
 
     map.addOne(xTracingId)
 
+    // Check Start Time
+    val start = DateTime.now
+
     // Call Next Filter with new Headers
-    val result = next(request.withHeaders(request.headers.add(map.toList: _*)))
+    val result = next(
+      r.copy(
+        requestHeader = request.withHeaders(request.headers.add(map.toList: _*))
+      )
+    )
 
     val logger = new TraceLogger(Some(span))
     val msg: String = logStart(request, xTracingId)(logger)
 
-    // Check Start Time
-    val start = DateTime.now
-
     // Process Result
     result.map { res =>
       // Add more Attributes to trace
-      span.setAttribute(HTTP_STATUS_CODE, res.header.status)
-      span.setAttribute(STATUS, res.header.status)
-      span.setAttribute(HTTP_RESPONSE_SIZE, res.body.contentLength.getOrElse(0L))
+      span.setAttribute(HTTP_STATUS_CODE, res.code)
+      span.setAttribute(STATUS, res.code)
+      span.setAttribute(HTTP_RESPONSE_SIZE, res.body.map(_.length).getOrElse(0))
 
       // Finish Root Span
       span.end()
@@ -96,17 +112,21 @@ class TracingFilter @Inject() (config: Config, implicit val mat: Materializer) e
       logResult(xTracingId, msg, res, request)(logger)
 
       // Add xTracingId to Result Header
-      res.withHeaders(xTracingId)
+      res.copy(
+        headers = res.headers + xTracingId
+      )
     }
 
   }
 
-  private def handleHealthChecksLogging(next: RequestHeader => Future[Result], request: RequestHeader) = {
-    // Handle Health Check Logging
-    val result = next(request)
-    result.map { res =>
-      if (res.header.status != 200) healthLogger.error(s"[HealthCheck] FAILED with ${res.header.status}")
-      res
+  private def handleHealthChecksLogging(
+      next: RoutingContext => RouteResult[smithy4play.EndpointResult],
+      r: RoutingContext
+  ): RouteResult[smithy4play.EndpointResult] = {
+    val result = next.apply(r)
+    result.leftMap { e =>
+      if (e.statusCode != 200) healthLogger.error(s"[HealthCheck] FAILED with ${e.statusCode}")
+      e
     }
   }
 
@@ -118,12 +138,11 @@ class TracingFilter @Inject() (config: Config, implicit val mat: Materializer) e
     msg
   }
 
-  private def logResult(xTracingId: (String, String), msg: String, res: Result, req: RequestHeader)(
+  private def logResult(xTracingId: (String, String), msg: String, res: EndpointResult, req: RequestHeader)(
       logger: TraceLogger
   ): Unit =
-    if (configAccessStatus.contains(res.header.status))
-      logger.warn(s"[Trace-${xTracingId._2}] $msg status=${res.header.status} END")
+    if (configAccessStatus.contains(res.code))
+      logger.warn(s"[Trace-${xTracingId._2}] $msg status=${res.code} END")
     else
-      logger.info(s"[Trace-${xTracingId._2}] $msg status=${res.header.status} END")
-
+      logger.info(s"[Trace-${xTracingId._2}] $msg status=${res.code} END")
 }

conf/application.conf

@@ -67,7 +67,7 @@ play.http.secret.key = ${?PLAY_HTTP_SECRET_KEY}
 
 // FILTERS
 
-play.filters.enabled = ["de.innfactory.bootstrapplay2.filters.TracingFilter", "de.innfactory.bootstrapplay2.filters.logging.AccessLoggingFilter", "play.filters.cors.CORSFilter", "de.innfactory.bootstrapplay2.filters.access.RouteBlacklistFilter" ]
+play.filters.enabled = [ "play.filters.cors.CORSFilter" ]
 
 play.filters.cors {
   pathPrefixes = ["/v1/"]

project/Dependencies.scala

@@ -25,7 +25,7 @@ object Dependencies {
 
   // innFactory Utils
   val scalaUtil = "de.innfactory.scala-utils" %% "scala-utils" % "2.0.1"
-  val smithy4play = "de.innfactory" %% "smithy4play" % "0.4.4-alpha"
+  val smithy4play = "de.innfactory" %% "smithy4play" % "0.4.4-beta"
 
   // Prod
   val slickPg = "com.github.tminglei" %% "slick-pg" % "0.20.4"