add metrics collection for API

- extract webclient call from getConfiguration and add metrics in DeviceConfigurationService
- extract webclient call from getMeasurement, addMeasurement and add metrics in DeviceDataService
- extract webclient call from getIdentityFromDevice and add metrics in DeviceRegistryService
- add MeterRegistry dependency
- fix test application.yml
- update kotlin logging dependency

src/main/kotlin/ltd/hlaeja/service/DeviceConfigurationService.kt

@@ -1,28 +1,47 @@
 package ltd.hlaeja.service
 
+import io.github.oshai.kotlinlogging.KotlinLogging
+import io.micrometer.core.instrument.Counter
+import io.micrometer.core.instrument.MeterRegistry
 import java.util.UUID
 import ltd.hlaeja.library.deviceConfiguration.Node
 import ltd.hlaeja.property.DeviceConfigurationProperty
-import ltd.hlaeja.util.logCall
-import org.springframework.http.HttpStatus.NOT_FOUND
-import org.springframework.http.HttpStatus.NO_CONTENT
-import org.springframework.http.HttpStatus.REQUEST_TIMEOUT
+import ltd.hlaeja.util.deviceConfigurationGetConfiguration
+import org.springframework.http.HttpStatus.SERVICE_UNAVAILABLE
 import org.springframework.stereotype.Service
+import org.springframework.web.ErrorResponseException
 import org.springframework.web.reactive.function.client.WebClient
-import org.springframework.web.reactive.function.client.awaitBodyOrNull
+import org.springframework.web.reactive.function.client.WebClientRequestException
 import org.springframework.web.server.ResponseStatusException
 
+private val log = KotlinLogging.logger {}
+
 @Service
 class DeviceConfigurationService(
+    meterRegistry: MeterRegistry,
     private val webClient: WebClient,
     private val deviceConfigurationProperty: DeviceConfigurationProperty,
 ) {
 
+    private val deviceConfigurationSuccess = Counter.builder("device.configuration.success")
+        .description("Number of successful device configuration calls")
+        .register(meterRegistry)
+
+    private val deviceConfigurationFailure = Counter.builder("device.configuration.failure")
+        .description("Number of failed device configuration calls")
+        .register(meterRegistry)
+
     suspend fun getConfiguration(
         node: UUID,
-    ): Node.Response = webClient.get()
-        .uri("${deviceConfigurationProperty.url}/node-$node".also(::logCall))
-        .retrieve()
-        .onStatus(NOT_FOUND::equals) { throw ResponseStatusException(NO_CONTENT) }
-        .awaitBodyOrNull<Node.Response>() ?: throw ResponseStatusException(REQUEST_TIMEOUT)
+    ): Node.Response = try {
+        webClient.deviceConfigurationGetConfiguration(node, deviceConfigurationProperty)
+            .also { deviceConfigurationSuccess.increment() }
+    } catch (e: ErrorResponseException) {
+        deviceConfigurationFailure.increment()
+        throw e
+    } catch (e: WebClientRequestException) {
+        deviceConfigurationFailure.increment()
+        log.error(e) { "Error device registry" }
+        throw ResponseStatusException(SERVICE_UNAVAILABLE)
+    }
 }

src/main/kotlin/ltd/hlaeja/service/DeviceDataService.kt

@@ -1,39 +1,65 @@
 package ltd.hlaeja.service
 
+import io.github.oshai.kotlinlogging.KotlinLogging
+import io.micrometer.core.instrument.Counter
+import io.micrometer.core.instrument.MeterRegistry
 import java.util.UUID
 import ltd.hlaeja.library.deviceData.MeasurementData
 import ltd.hlaeja.property.DeviceDataProperty
-import ltd.hlaeja.util.logCall
-import org.springframework.http.HttpStatus.NOT_FOUND
-import org.springframework.http.HttpStatus.NO_CONTENT
-import org.springframework.http.HttpStatus.REQUEST_TIMEOUT
+import ltd.hlaeja.util.deviceDataAddMeasurement
+import ltd.hlaeja.util.deviceDataGetMeasurement
+import org.springframework.http.HttpStatus.SERVICE_UNAVAILABLE
+import org.springframework.http.ResponseEntity
 import org.springframework.stereotype.Service
+import org.springframework.web.ErrorResponseException
 import org.springframework.web.reactive.function.client.WebClient
-import org.springframework.web.reactive.function.client.awaitBodilessEntity
-import org.springframework.web.reactive.function.client.awaitBodyOrNull
+import org.springframework.web.reactive.function.client.WebClientRequestException
 import org.springframework.web.server.ResponseStatusException
 
+private val log = KotlinLogging.logger {}
+
 @Service
 class DeviceDataService(
+    meterRegistry: MeterRegistry,
     private val webClient: WebClient,
     private val deviceDataProperty: DeviceDataProperty,
 ) {
 
+    private val deviceDataSuccess = Counter.builder("device.data.success")
+        .description("Number of successful device data calls")
+        .register(meterRegistry)
+
+    private val deviceDataFailure = Counter.builder("device.data.failure")
+        .description("Number of failed device data calls")
+        .register(meterRegistry)
+
     suspend fun getMeasurement(
         client: UUID,
         node: UUID,
-    ): MeasurementData.Response = webClient.get()
-        .uri("${deviceDataProperty.url}/client-$client/node-$node".also(::logCall))
-        .retrieve()
-        .onStatus(NOT_FOUND::equals) { throw ResponseStatusException(NO_CONTENT) }
-        .awaitBodyOrNull<MeasurementData.Response>() ?: throw ResponseStatusException(REQUEST_TIMEOUT)
+    ): MeasurementData.Response = try {
+        webClient.deviceDataGetMeasurement(client, node, deviceDataProperty)
+            .also { deviceDataSuccess.increment() }
+    } catch (e: ErrorResponseException) {
+        deviceDataFailure.increment()
+        throw e
+    } catch (e: WebClientRequestException) {
+        deviceDataFailure.increment()
+        log.error(e) { "Error device registry" }
+        throw ResponseStatusException(SERVICE_UNAVAILABLE)
+    }
 
     suspend fun addMeasurement(
         client: UUID,
         request: MeasurementData.Request,
-    ) = webClient.post()
-        .uri("${deviceDataProperty.url}/client-$client".also(::logCall))
-        .bodyValue(request)
-        .retrieve()
-        .awaitBodilessEntity()
+    ): ResponseEntity<Void> = try {
+        webClient.deviceDataAddMeasurement(client, request, deviceDataProperty)
+            .also { deviceDataSuccess.increment() }
+    } catch (e: ErrorResponseException) {
+        deviceDataFailure.increment()
+        throw e
+    } catch (e: WebClientRequestException) {
+        deviceDataFailure.increment()
+        log.error(e) { "Error device registry" }
+        throw ResponseStatusException(SERVICE_UNAVAILABLE)
+    }
 }

src/main/kotlin/ltd/hlaeja/service/DeviceRegistryService.kt

@@ -1,28 +1,47 @@
 package ltd.hlaeja.service
 
+import io.github.oshai.kotlinlogging.KotlinLogging
+import io.micrometer.core.instrument.Counter
+import io.micrometer.core.instrument.MeterRegistry
 import java.util.UUID
 import ltd.hlaeja.library.deviceRegistry.Identity
 import ltd.hlaeja.property.DeviceRegistryProperty
-import ltd.hlaeja.util.logCall
-import org.springframework.http.HttpStatus.NOT_ACCEPTABLE
-import org.springframework.http.HttpStatus.NOT_FOUND
-import org.springframework.http.HttpStatus.REQUEST_TIMEOUT
+import ltd.hlaeja.util.deviceRegistryIdentityDevice
+import org.springframework.http.HttpStatus.SERVICE_UNAVAILABLE
 import org.springframework.stereotype.Service
+import org.springframework.web.ErrorResponseException
 import org.springframework.web.reactive.function.client.WebClient
-import org.springframework.web.reactive.function.client.awaitBodyOrNull
+import org.springframework.web.reactive.function.client.WebClientRequestException
 import org.springframework.web.server.ResponseStatusException
 
+private val log = KotlinLogging.logger {}
+
 @Service
 class DeviceRegistryService(
+    meterRegistry: MeterRegistry,
     private val webClient: WebClient,
     private val deviceRegistryProperty: DeviceRegistryProperty,
 ) {
 
+    private val identityDeviceSuccess = Counter.builder("device.identity.success")
+        .description("Number of successful device identity calls")
+        .register(meterRegistry)
+
+    private val identityDeviceFailure = Counter.builder("device.identity.failure")
+        .description("Number of failed device identity calls")
+        .register(meterRegistry)
+
     suspend fun getIdentityFromDevice(
         device: UUID,
-    ): Identity.Response = webClient.get()
-        .uri("${deviceRegistryProperty.url}/identity/device-$device".also(::logCall))
-        .retrieve()
-        .onStatus(NOT_FOUND::equals) { throw ResponseStatusException(NOT_ACCEPTABLE) }
-        .awaitBodyOrNull<Identity.Response>() ?: throw ResponseStatusException(REQUEST_TIMEOUT)
+    ): Identity.Response = try {
+        webClient.deviceRegistryIdentityDevice(device, deviceRegistryProperty)
+            .also { identityDeviceSuccess.increment() }
+    } catch (e: ErrorResponseException) {
+        identityDeviceFailure.increment()
+        throw e
+    } catch (e: WebClientRequestException) {
+        identityDeviceFailure.increment()
+        log.error(e) { "Error device identity" }
+        throw ResponseStatusException(SERVICE_UNAVAILABLE)
+    }
 }

src/main/kotlin/ltd/hlaeja/service/JwtService.kt

@@ -1,12 +1,12 @@
 package ltd.hlaeja.service
 
+import io.github.oshai.kotlinlogging.KotlinLogging
 import io.jsonwebtoken.JwtParser
 import io.jsonwebtoken.Jwts
 import java.util.UUID
 import ltd.hlaeja.library.deviceRegistry.Identity
 import ltd.hlaeja.property.JwtProperty
 import ltd.hlaeja.util.PublicKeyProvider
-import mu.KotlinLogging
 import org.springframework.stereotype.Service
 
 private val log = KotlinLogging.logger {}
@@ -30,5 +30,5 @@ class JwtService(
         identity: String,
     ): UUID = parser.parseSignedClaims(identity)
         .let { UUID.fromString(it.payload["device"] as String) }
-        .also { log.debug("Identified client device: {}", it) }
+        .also { log.debug { "Identified client device: $it" } }
 }

src/main/kotlin/ltd/hlaeja/util/Helper.kt

@@ -1,9 +1,7 @@
 package ltd.hlaeja.util
 
-import mu.KotlinLogging
+import io.github.oshai.kotlinlogging.KotlinLogging
 
 private val log = KotlinLogging.logger {}
 
-fun logCall(url: String) {
-    log.debug("calling: {}", url)
-}
+fun logCall(url: String) = log.debug { "calling: $url" }

src/main/kotlin/ltd/hlaeja/util/WebClientCalls.kt

@@ -0,0 +1,56 @@
+package ltd.hlaeja.util
+
+import java.util.UUID
+import ltd.hlaeja.library.deviceConfiguration.Node
+import ltd.hlaeja.library.deviceData.MeasurementData
+import ltd.hlaeja.library.deviceRegistry.Identity
+import ltd.hlaeja.property.DeviceConfigurationProperty
+import ltd.hlaeja.property.DeviceDataProperty
+import ltd.hlaeja.property.DeviceRegistryProperty
+import org.springframework.http.HttpStatus.NOT_ACCEPTABLE
+import org.springframework.http.HttpStatus.NOT_FOUND
+import org.springframework.http.HttpStatus.NO_CONTENT
+import org.springframework.http.HttpStatus.REQUEST_TIMEOUT
+import org.springframework.http.ResponseEntity
+import org.springframework.web.reactive.function.client.WebClient
+import org.springframework.web.reactive.function.client.awaitBodilessEntity
+import org.springframework.web.reactive.function.client.awaitBodyOrNull
+import org.springframework.web.server.ResponseStatusException
+
+suspend fun WebClient.deviceRegistryIdentityDevice(
+    device: UUID,
+    property: DeviceRegistryProperty,
+): Identity.Response = get()
+    .uri("${property.url}/identity/device-$device".also(::logCall))
+    .retrieve()
+    .onStatus(NOT_FOUND::equals) { throw ResponseStatusException(NOT_ACCEPTABLE) }
+    .awaitBodyOrNull<Identity.Response>() ?: throw ResponseStatusException(REQUEST_TIMEOUT)
+
+suspend fun WebClient.deviceDataGetMeasurement(
+    client: UUID,
+    node: UUID,
+    property: DeviceDataProperty,
+): MeasurementData.Response = get()
+    .uri("${property.url}/client-$client/node-$node".also(::logCall))
+    .retrieve()
+    .onStatus(NOT_FOUND::equals) { throw ResponseStatusException(NO_CONTENT) }
+    .awaitBodyOrNull<MeasurementData.Response>() ?: throw ResponseStatusException(REQUEST_TIMEOUT)
+
+suspend fun WebClient.deviceDataAddMeasurement(
+    client: UUID,
+    request: MeasurementData.Request,
+    property: DeviceDataProperty,
+): ResponseEntity<Void> = post()
+    .uri("${property.url}/client-$client".also(::logCall))
+    .bodyValue(request)
+    .retrieve()
+    .awaitBodilessEntity()
+
+suspend fun WebClient.deviceConfigurationGetConfiguration(
+    node: UUID,
+    property: DeviceConfigurationProperty,
+): Node.Response = get()
+    .uri("${property.url}/node-$node".also(::logCall))
+    .retrieve()
+    .onStatus(NOT_FOUND::equals) { throw ResponseStatusException(NO_CONTENT) }
+    .awaitBodyOrNull<Node.Response>() ?: throw ResponseStatusException(REQUEST_TIMEOUT)