[Playground] Change options and add metrics

modules/fbs-runner/checker/build.gradle

@@ -35,6 +35,13 @@ dependencies {
     implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.14.2'
     implementation 'mysql:mysql-connector-java:8.0.32'
     implementation 'org.postgresql:postgresql:42.5.3'
+    implementation platform("io.opentelemetry:opentelemetry-bom:1.31.0")
+    implementation platform('io.opentelemetry:opentelemetry-bom-alpha:1.31.0-alpha')
+    implementation("io.opentelemetry:opentelemetry-api");
+    implementation("io.opentelemetry:opentelemetry-sdk");
+    implementation("io.opentelemetry:opentelemetry-sdk-metrics");
+    implementation("io.opentelemetry:opentelemetry-exporter-logging");
+    implementation('io.opentelemetry:opentelemetry-exporter-prometheus')
     testImplementation 'junit:junit:4.13.2'
 }
 

modules/fbs-runner/checker/src/main/scala/de/thm/ii/fbs/services/db/PsqlOperationsService.scala

@@ -7,6 +7,7 @@
 
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
+import scala.util.{Failure, Success, Try}
 
 class PsqlOperationsService(override val dbName: String, override val username: String, override val queryTimeout: Int)
   extends DBOperationsService(dbName, username, queryTimeout) {
@@ -152,4 +153,19 @@
 
     client.queryFuture(s"$tables $constrains $views $routines $triggers")
   }
+
+  override def queryFutureWithTimeout(client: JDBCClient, sql: String): Future[ResultSet] = {
+    client.getConnectionFuture().flatMap(con => {
+      con.queryFuture(s"SET statement_timeout = ${queryTimeout*1000};").flatMap(_ => {
+        con.queryFuture(sql) transform {
+          case Success(result) =>
+            con.close()
+            Try(result)
+          case Failure(exception) =>
+            con.close()
+            Failure(throw exception)
+        }
+      })
+    })
+  }
 }

modules/fbs-runner/checker/src/main/scala/de/thm/ii/fbs/util/Metrics.scala

@@ -0,0 +1,20 @@
+package de.thm.ii.fbs.util
+
+import io.opentelemetry.exporter.prometheus.PrometheusHttpServer
+import io.opentelemetry.sdk.OpenTelemetrySdk
+import io.opentelemetry.sdk.metrics.SdkMeterProvider
+import io.opentelemetry.sdk.resources.Resource
+
+object Metrics {
+  private val prometheusHttpServer = PrometheusHttpServer.builder().build()
+  val openTelemetry: OpenTelemetrySdk = initOpenTelemetry()
+
+  private def initOpenTelemetry(): OpenTelemetrySdk = {
+    // Include required service.name resource attribute on all spans and metrics
+    val resource = Resource.getDefault.merge(Resource.builder.put("service-name", "fbs-runner").build)
+    val openTelemetrySdk = OpenTelemetrySdk.builder.setMeterProvider(
+      SdkMeterProvider.builder.setResource(resource).registerMetricReader(prometheusHttpServer).build
+    ).buildAndRegisterGlobal
+    openTelemetrySdk
+  }
+}

modules/fbs-runner/checker/src/main/scala/de/thm/ii/fbs/verticles/runner/SqlPlaygroundVerticle.scala

@@ -3,15 +3,17 @@
 import de.thm.ii.fbs.services.runner.SQLPlaygroundService
 import de.thm.ii.fbs.types._
 import de.thm.ii.fbs.util.DBTypes.PSQL_CONFIG_KEY
-import de.thm.ii.fbs.util.PlaygroundDBConnections
+import de.thm.ii.fbs.util.{Metrics, PlaygroundDBConnections}
 import de.thm.ii.fbs.verticles.HttpVerticle
 import de.thm.ii.fbs.verticles.runner.SqlPlaygroundVerticle.RUN_ADDRESS
 import io.vertx.core.json.JsonObject
 import io.vertx.lang.scala.{ScalaLogger, ScalaVerticle}
 import io.vertx.scala.core.eventbus.Message
 import io.vertx.scala.ext.jdbc.JDBCClient
+import io.vertx.scala.ext.sql.ResultSet
 
 import java.sql.{SQLException, SQLTimeoutException}
+import java.util.Date
 import scala.concurrent.Future
 import scala.util.{Failure, Success}
 
@@ -31,6 +33,10 @@
 class SqlPlaygroundVerticle extends ScalaVerticle {
   private val logger = ScalaLogger.getLogger(this.getClass.getName)
   private var sqlPools = Map[String, SqlPoolWithConfig]()
+  private val meter = Metrics.openTelemetry.meterBuilder("de.thm.mni.ii.fbs.verticles.runner.playground").build()
+  private val processingCounter = meter.upDownCounterBuilder("processingCount").setDescription("Processing Requests").build()
+  private val processingTimeCounter = meter.histogramBuilder("processingTime").ofLongs().setDescription("Time for processing").setUnit("ms").build()
+  private val errorCounter = meter.counterBuilder("errorCount").setDescription("Error Count").build()
 
   /**
     * start SqlRunnerVerticle
@@ -43,9 +49,9 @@
       .put("user", config.getString("SQL_PLAYGROUND_PSQL_SERVER_USERNAME", "root"))
       .put("password", config.getString("SQL_PLAYGROUND_PSQL_SERVER_PASSWORD", ""))
       .put("url", config.getString("SQL_PLAYGROUND_PSQL_SERVER_URL", "jdbc:postgresql://localhost:5432"))
-      .put("max_pool_size", config.getInteger("SQL_PLAYGROUND_INSTANCES", 15))
+      .put("max_pool_size", config.getInteger("SQL_PLAYGROUND_INSTANCES", 256))
       .put("driver_class", "org.postgresql.Driver")
-      .put("max_idle_time", config.getInteger("SQL_MAX_IDLE_TIME", 10))
+      .put("max_idle_time", config.getInteger("SQL_MAX_IDLE_TIME", 60))
       .put("dataSourceName", psqlDataSource)
     val psqlPool = JDBCClient.createShared(vertx, psqlConfig, psqlDataSource)
     sqlPools += (PSQL_CONFIG_KEY -> SqlPoolWithConfig(psqlPool, psqlConfig))
@@ -56,16 +62,34 @@
   private def startSqlPlayground(msg: Message[JsonObject]): Future[Unit] = Future {
     val runArgs = msg.body().mapTo(classOf[SqlPlaygroundRunArgs])
 
+    processingCounter.add(1)
+    val startTime = new Date().getTime
+    val end = (failure: Boolean) => {
+      val endTime = new Date().getTime
+      processingTimeCounter.record(endTime - startTime)
+      processingCounter.add(-1)
+      if (failure) errorCounter.add(1)
+    }
+
     try {
       logger.info(s"SqlPlayground received execution ${runArgs.executionId}")
 
       val con = getConnection(runArgs)
 
       if (con.isDefined) {
-        executeQueries(runArgs, con.get)
+        executeQueries(runArgs, con.get) onComplete {
+          case Success(_) =>
+            end(false)
+          case Failure(_) =>
+            end(true)
+        }
+      } else {
+        end(false)
       }
     } catch {
-      case e: Throwable => handleError(runArgs, e)
+      case e: Throwable =>
+        end(true)
+        handleError(runArgs, e)
     }
   }
 
@@ -80,10 +104,10 @@
     }
   }
 
-  private def executeQueries(runArgs: SqlPlaygroundRunArgs, con: PlaygroundDBConnections): Unit = {
-    val sqlPlayground = new SQLPlaygroundService(runArgs, con, config.getInteger("SQL_QUERY_TIMEOUT_S", 10))
+  private def executeQueries(runArgs: SqlPlaygroundRunArgs, con: PlaygroundDBConnections): Future[(ResultSet, ResultSet)] = {
+    val sqlPlayground = new SQLPlaygroundService(runArgs, con, config.getInteger("SQL_QUERY_TIMEOUT_S", 1))
 
-    sqlPlayground.executeStatement().onComplete({
+    sqlPlayground.executeStatement() andThen {
       case Success(value) =>
         try {
           logger.info(s"Execution-${runArgs.executionId} Finished")
@@ -99,7 +123,7 @@
         handleError(runArgs, ex, getSQLErrorMsg(runArgs, ex))
       case Failure(ex) =>
         handleError(runArgs, ex)
-    })
+    }
   }
 
   private def handleError(runArgs: SqlPlaygroundRunArgs, e: Throwable, msg: String = "Die Ausführung des Statements ist fehlgeschlagen."): Unit = {