reformat to trait

Author: remo87

app/controllers/api/v4/graphql/GraphQLController.scala

@@ -27,8 +27,9 @@ import javax.inject.*
 import scala.concurrent.*
 import scala.concurrent.duration.*
 import scala.util.{Failure, Success}
-import org.slf4j.{Logger, LoggerFactory, MDC}
-import net.logstash.logback.argument.StructuredArguments._
+import org.slf4j.MDC
+import net.logstash.logback.argument.StructuredArguments.*
+import utils.OTLogging
 
 import java.util.UUID
 
@@ -45,9 +46,8 @@ class GraphQLController @Inject() (implicit
     config: Configuration,
     appStart: ApplicationStart,
     prometheusMetricsMiddleware: PrometheusMetrics
-) extends AbstractController(cc) {
-
-  private val logger: Logger = LoggerFactory.getLogger(this.getClass)
+) extends AbstractController(cc)
+    with OTLogging {
 
   implicit val otSettings: OTSettings = loadConfigurationObject[OTSettings]("ot", config)
 
@@ -66,17 +66,18 @@ class GraphQLController @Inject() (implicit
     operation match {
       case None =>
         logger.info(s"request received",
-                    kv("request.method", request.method),
-                    kv("request.ip", request.connection.remoteAddressString),
-                    kv("isOT", isOT)
+                    keyValue("request.method", request.method),
+                    keyValue("request.ip", request.connection.remoteAddressString),
+                    keyValue("isOT", isOT)
         )
       case Some(op) =>
         if (op != "IntrospectionQuery")
-          logger.info(s"request received",
-                      kv("operation", op),
-                      kv("request.method", request.method),
-                      kv("request.ip", request.connection.remoteAddressString),
-                      kv("isOT", isOT)
+          logger.info(
+            s"request received",
+            keyValue("operation", op),
+            keyValue("request.method", request.method),
+            keyValue("request.ip", request.connection.remoteAddressString),
+            keyValue("isOT", isOT)
           )
     }
 
@@ -157,7 +158,9 @@ class GraphQLController @Inject() (implicit
       val cacheResult: Future[Result] = fromCache.flatMap {
         case Some(result) => Future.successful(result)
         case None =>
-          logger.debug(s"cache miss: ${gqlQuery.variables}", kv("operation", gqlQuery.operation))
+          logger.debug(s"cache miss: ${gqlQuery.variables}",
+                       keyValue("operation", gqlQuery.operation)
+          )
           appStart.CacheMissedCounter.labelValues(gqlQuery.operation.getOrElse("")).inc()
           val queryResult = executeQuery(gqlQuery)
           queryResult.andThen { case Success(s) =>
@@ -170,14 +173,14 @@ class GraphQLController @Inject() (implicit
                 case Success((hasErrors, errorMessagesOpt)) =>
                   if (hasErrors) {
                     logger.info(s"temporarily caching 200 response with errors",
-                                kv("operation", gqlQuery.operation)
+                                keyValue("operation", gqlQuery.operation)
                     )
                     errorMessagesOpt.foreach(errors => logger.error(s"errors in response: $errors"))
                     cache.set(gqlQuery.toString, s, non200CacheDuration)
                   } else {
                     logger.info(
                       s"Caching 200 response: ${gqlQuery.query.filter(_ >= ' ')}",
-                      kv("operation", gqlQuery.operation)
+                      keyValue("operation", gqlQuery.operation)
                     )
                     cache.set(gqlQuery.toString, s)
                     appStart.CacheRegistrationCounter

app/controllers/api/v4/graphql/MetadataAction.scala

@@ -3,14 +3,14 @@ package controllers.api.v4.graphql
 import QueryMetadataHeaders.{GQL_COMPLEXITY_HEADER, GQL_OP_HEADER, GQL_VAR_HEADER}
 import models.Helpers.loadConfigurationObject
 import models.entities.Configuration.{APIVersion, DataVersion, OTSettings}
-import org.slf4j.{Logger, LoggerFactory}
 import play.api.Configuration
 import play.api.mvc.{ActionBuilderImpl, BodyParsers, Request, Result}
 
 import java.sql.Timestamp
 import javax.inject.Inject
 import scala.concurrent.{ExecutionContext, Future}
 import play.api.libs.json.*
+import utils.OTLogging
 
 case class GqlRequestMetadata(
     isOT: Boolean,
@@ -50,9 +50,8 @@ case class GqlRequestMetadata(
 class MetadataAction @Inject() (parser: BodyParsers.Default)(implicit
     ec: ExecutionContext,
     config: Configuration
-) extends ActionBuilderImpl(parser) {
-
-  private val logger: Logger = LoggerFactory.getLogger(this.getClass)
+) extends ActionBuilderImpl(parser)
+    with OTLogging {
 
   implicit val otSettings: OTSettings = loadConfigurationObject[OTSettings]("ot", config)
 

app/controllers/api/v4/rest/CacheController.scala

@@ -2,12 +2,11 @@ package controllers.api.v4.rest
 
 import javax.inject.Inject
 import models.gql.Fetchers
-import net.logstash.logback.argument.StructuredArguments.kv
-import org.slf4j.{Logger, LoggerFactory}
-import play.api.Logging
+import net.logstash.logback.argument.StructuredArguments.keyValue
 import play.api.cache.AsyncCacheApi
 import play.api.mvc.*
 import services.ApplicationStart
+import utils.OTLogging
 
 import scala.concurrent.{ExecutionContext, Future}
 
@@ -17,17 +16,16 @@ class CacheController @Inject() (implicit
     restHelpers: RestHelpers,
     gqlQueryCache: AsyncCacheApi,
     appStart: ApplicationStart
-) extends AbstractController(cc) {
-
-  private val logger: Logger = LoggerFactory.getLogger(this.getClass)
+) extends AbstractController(cc)
+    with OTLogging {
 
   def clearCache(): Action[AnyContent] =
     restHelpers.checkCredentials(Action.async { request =>
       appStart.RequestCounter.labelValues("/api/v4/rest/cache/clear", "GET").inc()
       Future {
         logger.info("received request to clear cache",
-                    kv("request.method", request.method),
-                    kv("request.ip", request.connection.remoteAddressString)
+                    keyValue("request.method", request.method),
+                    keyValue("request.ip", request.connection.remoteAddressString)
         )
         Fetchers.resetCache()
         gqlQueryCache.removeAll()

app/controllers/api/v4/rest/MetaController.scala

@@ -4,8 +4,6 @@ import javax.inject.*
 import models.entities.TooComplexQueryError
 import models.entities.TooComplexQueryError.*
 import models.{Backend, GQLSchema}
-import org.slf4j.{Logger, LoggerFactory}
-import play.api.libs.json.*
 import play.api.mvc.*
 import sangria.macros.*
 import sangria.execution.{ErrorWithResolver, Executor, QueryAnalysisError, QueryReducer}
@@ -14,15 +12,15 @@ import sangria.marshalling.InputUnmarshaller
 
 import scala.concurrent.ExecutionContext
 import sangria.ast.Document
+import utils.OTLogging
 
 @Singleton
 class MetaController @Inject() (implicit
     ec: ExecutionContext,
     backend: Backend,
     cc: ControllerComponents
-) extends AbstractController(cc) {
-
-  private val logger: Logger = LoggerFactory.getLogger(this.getClass)
+) extends AbstractController(cc)
+    with OTLogging {
 
   val metaGQLQ: Document =
     gql"""

app/controllers/api/v4/rest/PrometheusController.scala

@@ -1,7 +1,6 @@
 package controllers.api.v4.rest
 
 import org.apache.pekko.stream.scaladsl.Source
-import org.slf4j.{Logger, LoggerFactory}
 import play.api.http.HttpEntity.Streamed
 import play.api.mvc.{
   AbstractController,
@@ -12,14 +11,14 @@ import play.api.mvc.{
   ResponseHeader,
   Result
 }
+import utils.OTLogging
 import utils.prometheus.{MetricsRequest, PrometheusScraper}
 
 import javax.inject.Inject
 
 class PrometheusController @Inject() (implicit cc: ControllerComponents)
-    extends AbstractController(cc) {
-
-  private val logger: Logger = LoggerFactory.getLogger(this.getClass)
+    extends AbstractController(cc)
+    with OTLogging {
 
   private val prometheusScraper = PrometheusScraper()
 

app/controllers/api/v4/rest/RestHelpers.scala

@@ -1,20 +1,19 @@
 package controllers.api.v4.rest
 
 import com.typesafe.config.Config
-import org.slf4j.{Logger, LoggerFactory}
 
 import javax.inject.Inject
 import play.api.mvc.{AbstractController, Action, ControllerComponents}
+import utils.OTLogging
 
 import scala.concurrent.{ExecutionContext, Future}
 
 class RestHelpers @Inject() (implicit
     ec: ExecutionContext,
     cc: ControllerComponents,
     config: Config
-) extends AbstractController(cc) {
-
-  private val logger: Logger = LoggerFactory.getLogger(this.getClass)
+) extends AbstractController(cc)
+    with OTLogging {
 
   def checkCredentials[A](action: Action[A]): Action[A] = Action.async(action.parser) { request =>
     logger.info(s"checking admin credentials")

app/models/Backend.scala

@@ -40,9 +40,9 @@ import java.time.LocalDate
 import scala.concurrent.*
 import com.sksamuel.elastic4s.requests.searches.queries.compound.BoolQuery
 import models.entities.Violations.{DateFilterError, InputParameterCheckError}
-import org.slf4j.{Logger, LoggerFactory}
 import services.ApplicationStart
 import utils.MetadataUtils.getIndexWithPrefixOrDefault
+import utils.OTLogging
 
 class Backend @Inject() (implicit
     ec: ExecutionContext,
@@ -51,9 +51,7 @@ class Backend @Inject() (implicit
     config: Configuration,
     env: Environment,
     cache: AsyncCacheApi
-) {
-
-  private val logger: Logger = LoggerFactory.getLogger(this.getClass)
+) extends OTLogging {
 
   implicit val defaultOTSettings: OTSettings = loadConfigurationObject[OTSettings]("ot", config)
   implicit val defaultESSettings: ElasticsearchSettings = defaultOTSettings.elasticsearch

app/models/ClickhouseRetriever.scala

@@ -8,11 +8,10 @@ import models.entities.Associations.*
 import models.entities.Configuration.{DatasourceSettings, OTSettings}
 import models.entities.*
 import net.logstash.logback.argument.StructuredArguments.keyValue
-import org.slf4j.{Logger, LoggerFactory}
-import play.api.Logging
 import services.ApplicationStart
 import slick.basic.DatabaseConfig
 import slick.jdbc.{GetResult, SQLActionBuilder}
+import utils.OTLogging
 
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
@@ -22,9 +21,7 @@ import scala.util.{Failure, Success}
 class ClickhouseRetriever(config: OTSettings)(implicit
     val dbConfig: DatabaseConfig[ClickHouseProfile],
     val appStart: ApplicationStart
-) {
-
-  private val logger: Logger = LoggerFactory.getLogger(this.getClass)
+) extends OTLogging {
 
   import dbConfig.profile.api._
 

app/models/ElasticRetriever.scala

@@ -23,8 +23,8 @@ import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
 import scala.util.Try
 import com.sksamuel.elastic4s.requests.searches.sort.FieldSort
-import org.slf4j.{Logger, LoggerFactory}
 import services.ApplicationStart
+import utils.OTLogging
 
 case class ResolverField(fieldname: Option[String], matched_queries: Boolean = false)
 object ResolverField {
@@ -154,11 +154,10 @@ class ElasticRetriever @Inject() (
     hlFields: Seq[String],
     searchEntities: Seq[String]
 )(implicit appStart: ApplicationStart)
-    extends QueryApi
+    extends OTLogging
+    with QueryApi
     with ElasticRetrieverQueryBuilders {
 
-  private val logger: Logger = LoggerFactory.getLogger(this.getClass)
-
   val db_name = "opensearch"
 
   val hlFieldSeq: Seq[HighlightField] = hlFields.map(HighlightField(_))
@@ -1030,9 +1029,7 @@ class ElasticRetriever @Inject() (
   }
 }
 
-object ElasticRetriever {
-
-  private val logger: Logger = LoggerFactory.getLogger(this.getClass)
+object ElasticRetriever extends OTLogging {
 
   /** * SortBy case class use the `fieldName` to sort by and asc if `desc` is false otherwise desc
     */

app/models/ElasticRetrieverQueryBuilders.scala

@@ -7,7 +7,7 @@ import com.sksamuel.elastic4s.requests.searches.queries.Query
 import com.sksamuel.elastic4s.requests.searches.{MultiSearchRequest, SearchRequest}
 import com.sksamuel.elastic4s.requests.searches.queries.compound.BoolQuery
 import models.entities.Pagination
-import org.slf4j.{Logger, LoggerFactory}
+import utils.OTLogging
 
 /** IndexQuery is a case class that represents a query to be executed on an Elasticsearch index.
   * @param esIndex
@@ -43,9 +43,7 @@ case class IndexBoolQuery(
     excludedFields: Seq[String] = Seq.empty
 )
 
-trait ElasticRetrieverQueryBuilders extends QueryApi {
-
-  private val logger: Logger = LoggerFactory.getLogger(this.getClass)
+trait ElasticRetrieverQueryBuilders extends OTLogging with QueryApi {
 
   def IndexQueryMust[V](indexQuery: IndexQuery[V]): SearchRequest =
     getByIndexQueryBuilder(indexQuery, must)