Passing User-Agent in outgoing HTTP requests, Returning services' dependencies in /version

3 files changed, 62 insertions, 16 deletions

diff --git a/src/main/scala/xyz/driver/core/app.scala b/src/main/scala/xyz/driver/core/app.scala
index e35c300..4603e5a 100644
--- a/src/main/scala/xyz/driver/core/app.scala
+++ b/src/main/scala/xyz/driver/core/app.scala
@@ -16,9 +16,8 @@ import com.typesafe.config.Config
 import com.typesafe.scalalogging.Logger
 import io.swagger.models.Scheme
 import org.slf4j.{LoggerFactory, MDC}
-import spray.json.DefaultJsonProtocol
 import xyz.driver.core
-import xyz.driver.core.rest.{ContextHeaders, Swagger}
+import xyz.driver.core.rest._
 import xyz.driver.core.stats.SystemStats
 import xyz.driver.core.time.Time
 import xyz.driver.core.time.provider.{SystemTimeProvider, TimeProvider}
@@ -26,6 +25,7 @@ import xyz.driver.core.time.provider.{SystemTimeProvider, TimeProvider}
 import scala.compat.Platform.ConcurrentModificationException
 import scala.concurrent.duration._
 import scala.concurrent.{Await, ExecutionContext, Future}
+import scala.util.Try
 import scalaz.Scalaz.stringInstance
 import scalaz.syntax.equal._
 
@@ -145,6 +145,7 @@ object app {
     }
 
     protected def versionRoute(version: String, gitHash: String, startupTime: Time): Route = {
+      import spray.json._
       import DefaultJsonProtocol._
       import SprayJsonSupport._
 
@@ -152,17 +153,27 @@ object app {
         val currentTime = time.currentTime().millis
         complete(
           Map(
-            "version"     -> version,
-            "gitHash"     -> gitHash,
-            "modules"     -> modules.map(_.name).mkString(", "),
-            "startupTime" -> startupTime.millis.toString,
-            "serverTime"  -> currentTime.toString,
-            "uptime"      -> (currentTime - startupTime.millis).toString
-          ))
+            "version"      -> version.toJson,
+            "gitHash"      -> gitHash.toJson,
+            "modules"      -> modules.map(_.name).toJson,
+            "dependencies" -> collectAppDependencies().toJson,
+            "startupTime"  -> startupTime.millis.toString.toJson,
+            "serverTime"   -> currentTime.toString.toJson,
+            "uptime"       -> (currentTime - startupTime.millis).toString.toJson
+          ).toJson)
       }
     }
 
+    protected def collectAppDependencies(): Map[String, String] = {
+
+      def serviceWithLocation(serviceName: String): (String, String) =
+        serviceName -> Try(config.getString(s"services.$serviceName.baseUrl")).getOrElse("not-detected")
+
+      modules.flatMap(module => module.serviceDiscovery.getUsedServices.map(serviceWithLocation).toSeq).toMap
+    }
+
     protected def healthRoute: Route = {
+      import spray.json._
       import DefaultJsonProtocol._
       import SprayJsonSupport._
       import spray.json._
@@ -240,6 +251,8 @@ object app {
     def route: Route
     def routeTypes: Seq[Type]
 
+    val serviceDiscovery: ServiceDiscovery with SavingUsedServiceDiscovery = new NoServiceDiscovery()
+
     def activate(): Unit   = {}
     def deactivate(): Unit = {}
   }
diff --git a/src/main/scala/xyz/driver/core/file/S3Storage.scala b/src/main/scala/xyz/driver/core/file/S3Storage.scala
index 50bfe85..933b01a 100644
--- a/src/main/scala/xyz/driver/core/file/S3Storage.scala
+++ b/src/main/scala/xyz/driver/core/file/S3Storage.scala
@@ -53,11 +53,13 @@ class S3Storage(s3: AmazonS3, bucket: Name[Bucket], executionContext: ExecutionC
         result.isTruncated
       } flatMap { result =>
         result.getObjectSummaries.asScala.toList.map { summary =>
-          FileLink(Name[File](summary.getKey),
-                   Paths.get(path.toString + "/" + summary.getKey),
-                   Revision[File](summary.getETag),
-                   Time(summary.getLastModified.getTime),
-                   summary.getSize)
+          FileLink(
+            Name[File](summary.getKey),
+            Paths.get(path.toString + "/" + summary.getKey),
+            Revision[File](summary.getETag),
+            Time(summary.getLastModified.getTime),
+            summary.getSize
+          )
         } filterNot isInSubFolder(path)
       } toList
     })
diff --git a/src/main/scala/xyz/driver/core/rest.scala b/src/main/scala/xyz/driver/core/rest.scala
index f1eab45..c13cce9 100644
--- a/src/main/scala/xyz/driver/core/rest.scala
+++ b/src/main/scala/xyz/driver/core/rest.scala
@@ -9,6 +9,9 @@ import akka.http.scaladsl.server.Directive0
 import com.typesafe.scalalogging.Logger
 import akka.http.scaladsl.unmarshalling.Unmarshal
 import akka.http.scaladsl.unmarshalling.Unmarshaller
+import akka.http.scaladsl.settings.ClientConnectionSettings
+import akka.http.scaladsl.settings.ConnectionPoolSettings
+import akka.http.scaladsl.model.headers.`User-Agent`
 import akka.stream.ActorMaterializer
 import akka.stream.scaladsl.Flow
 import akka.util.ByteString
@@ -251,7 +254,26 @@ package rest {
     def discover[T <: Service](serviceName: Name[Service]): T
   }
 
-  class HttpRestServiceTransport(actorSystem: ActorSystem,
+  class NoServiceDiscovery extends ServiceDiscovery with SavingUsedServiceDiscovery {
+
+    def discover[T <: Service](serviceName: Name[Service]): T =
+      throw new IllegalArgumentException(s"Service with name $serviceName is unknown")
+  }
+
+  trait SavingUsedServiceDiscovery {
+
+    private val usedServices = new scala.collection.mutable.HashSet[String]()
+
+    def saveServiceUsage(serviceName: Name[Service]): Unit = usedServices.synchronized {
+      usedServices += serviceName.value
+    }
+
+    def getUsedServices: Set[String] = usedServices.synchronized { usedServices.toSet }
+  }
+
+  class HttpRestServiceTransport(applicationName: Name[App],
+                                 applicationVersion: String,
+                                 actorSystem: ActorSystem,
                                  executionContext: ExecutionContext,
                                  log: Logger,
                                  time: TimeProvider)
@@ -260,6 +282,15 @@ package rest {
     protected implicit val materializer = ActorMaterializer()(actorSystem)
     protected implicit val execution    = executionContext
 
+    private val client = Http()(actorSystem)
+
+    private val clientConnectionSettings: ClientConnectionSettings =
+      ClientConnectionSettings(actorSystem).withUserAgentHeader(
+        Option(`User-Agent`(applicationName.value + "/" + applicationVersion)))
+
+    private val connectionPoolSettings: ConnectionPoolSettings = ConnectionPoolSettings(actorSystem)
+      .withConnectionSettings(clientConnectionSettings)
+
     def sendRequestGetResponse(context: ServiceRequestContext)(requestStub: HttpRequest): Future[HttpResponse] = {
 
       val requestTime = time.currentTime()
@@ -272,7 +303,7 @@ package rest {
 
       log.info(s"Sending request to ${request.method} ${request.uri}")
 
-      val response = Http()(actorSystem).singleRequest(request)(materializer)
+      val response = client.singleRequest(request, settings = connectionPoolSettings)(materializer)
 
       response.onComplete {
         case Success(r) =>