accesslog.scala

def accessLogger[R, E](
      next: Http[R, E, Request, HttpResponse[R, E]]
  ): HttpApp[R with clock.Clock with Logging, E] = {
    Http.flatten {
      Http.fromEffectFunction[Request] { req =>
        val path = req.url.path
        val method = req.method

        clock.instant.flatMap(start => {
          val logSuccess = (resp: HttpResponse[R, E]) => {
            Http.fromEffect(zio.clock.instant.flatMap(end => {
              val duration = end.toEpochMilli - start.toEpochMilli
              Logging
                .locally(LogAnnotation.Name("access-log" :: Nil)) {
                  Logging.info(
                    s"path: $path, method: $method, status: ${resp.status},timeMillis: $duration"
                  )
                }

            })) *> Http.succeed(resp)
          }

          val logError = (err: E) => {
            Http.fromEffect(clock.instant.flatMap(end => {
              val duration = end.toEpochMilli - start.toEpochMilli
              Logging
                .locally(LogAnnotation.Name("access-log" :: Nil)) {
                  Logging.info(
                    s"path: $path, method: $method, failed: ${err},timeMillis: $duration"
                  )
                }
            })) *> Http.fail(err)
          }

          val logNotFound = Http.fromEffect {
            clock.instant.flatMap(end => {
              val duration = end.toEpochMilli - start.toEpochMilli
              Logging
                .locally(LogAnnotation.Name("access-log" :: Nil)) {
                  Logging.info(
                    s"path: $path, method: $method, not found,timeMillis: $duration"
                  )
                }
            })
          } *> Http.empty

          ZIO.succeed(
            next.foldM(
              e => logError(e),
              v => logSuccess(v),
              logNotFound
            )
          )
        })
      }
    }
  }