Callid (#19)

Legger til callid på consumer-kall, interne kall og logginnslag

Author: kristianstorvoll

src/main/kotlin/no/nav/syfo/SyfooversiktApplication.kt

@@ -38,6 +38,8 @@ import no.nav.syfo.kafka.setupKafka
 import no.nav.syfo.personstatus.*
 import no.nav.syfo.tilgangskontroll.MidlertidigTilgangsSjekk
 import no.nav.syfo.tilgangskontroll.TilgangskontrollConsumer
+import no.nav.syfo.util.NAV_CALL_ID_HEADER
+import no.nav.syfo.util.getCallId
 import no.nav.syfo.vault.Vault
 import org.slf4j.LoggerFactory
 import java.net.URL
@@ -205,26 +207,23 @@ fun Application.serverModule() {
     }
 
     install(CallId) {
+        retrieve { it.request.headers["X-Nav-CallId"] }
+        retrieve { it.request.headers[HttpHeaders.XCorrelationId] }
         generate { UUID.randomUUID().toString() }
         verify { callId: String -> callId.isNotEmpty() }
-        header(HttpHeaders.XCorrelationId)
+        header(NAV_CALL_ID_HEADER)
     }
 
     install(StatusPages) {
         exception<Throwable> { cause ->
             call.respond(HttpStatusCode.InternalServerError, cause.message ?: "Unknown error")
-
-            log.error("Caught exception", cause)
+            log.error("Caught exception", cause, getCallId())
             throw cause
         }
     }
 
-    isDev {
-        LOG.info("Running in development mode")
-    }
 
     isProd {
-        LOG.info("Running in production mode")
         val tilgangsSjekk = MidlertidigTilgangsSjekk()
         intercept(ApplicationCallPipeline.Call) {
             if (call.request.uri.contains(Regex("is_alive|is_ready|prometheus"))) {
@@ -242,7 +241,6 @@ fun Application.serverModule() {
                 proceed()
             }
         }
-
     }
 
     val config: HttpClientConfig<ApacheEngineConfig>.() -> Unit = {

src/main/kotlin/no/nav/syfo/api/NaisRest.kt

@@ -9,7 +9,10 @@ import io.ktor.routing.Routing
 import io.ktor.routing.get
 import io.prometheus.client.CollectorRegistry
 import io.prometheus.client.exporter.common.TextFormat
+import net.logstash.logback.argument.StructuredArguments
 import no.nav.syfo.ApplicationState
+import no.nav.syfo.LOG
+import no.nav.syfo.util.kafkaCallId
 
 fun Routing.registerNaisApi(
         applicationState: ApplicationState,

src/main/kotlin/no/nav/syfo/auth/TokenAuth.kt

@@ -47,7 +47,6 @@ data class VeilederTokenPayload(
 
 fun getVeilederTokenPayload(token: String): VeilederTokenPayload {
     val decodedJWT = JWT.decode(token)
-
     val navIdent: String = decodedJWT.claims["NAVident"]?.asString() ?: throw Error("Missing NAVident in private claims")
     val navn: String = decodedJWT.claims["name"]?.asString() ?: throw Error("Missing name in private claims")
     val email = decodedJWT.claims["unique_name"]?.asString() ?: throw Error("Missing unique_name in private claims")

src/main/kotlin/no/nav/syfo/kafka/Kafka.kt

@@ -12,6 +12,8 @@ import net.logstash.logback.argument.StructuredArguments
 import no.nav.syfo.*
 import no.nav.syfo.personstatus.OversiktHendelseService
 import no.nav.syfo.personstatus.domain.KOversikthendelse
+import no.nav.syfo.util.CallIdArgument
+import no.nav.syfo.util.kafkaCallId
 import org.apache.kafka.clients.consumer.KafkaConsumer
 import org.apache.kafka.common.serialization.StringDeserializer
 import org.slf4j.Logger
@@ -63,6 +65,7 @@ suspend fun blockingApplicationLogic(
         }
 
         kafkaConsumer.poll(Duration.ofMillis(0)).forEach {
+            val callId = kafkaCallId()
             val oversiktHendelse: KOversikthendelse =
                     objectMapper.readValue(it.value())
             logValues = arrayOf(
@@ -71,9 +74,9 @@ suspend fun blockingApplicationLogic(
                     StructuredArguments.keyValue("enhetId", oversiktHendelse.enhetId),
                     StructuredArguments.keyValue("hendelseId", oversiktHendelse.hendelseId)
             )
-            LOG.info("Mottatt oversikthendelse, klar for oppdatering, $logKeys", *logValues)
+            LOG.info("Mottatt oversikthendelse, klar for oppdatering, $logKeys, {}", *logValues, CallIdArgument(callId))
 
-            oversiktHendelseService.oppdaterPersonMedHendelse(oversiktHendelse)
+            oversiktHendelseService.oppdaterPersonMedHendelse(oversiktHendelse, callId)
         }
         delay(100)
     }

src/main/kotlin/no/nav/syfo/personstatus/OversiktHendelseService.kt

@@ -3,47 +3,48 @@ package no.nav.syfo.personstatus
 import no.nav.syfo.db.DatabaseInterface
 import no.nav.syfo.metric.*
 import no.nav.syfo.personstatus.domain.*
+import no.nav.syfo.util.CallIdArgument
 import org.slf4j.LoggerFactory
 
 private val log: org.slf4j.Logger = LoggerFactory.getLogger("no.nav.syfo.personstatus")
 
 class OversiktHendelseService(private val database: DatabaseInterface) {
 
-    fun oppdaterPersonMedHendelse(oversiktHendelse: KOversikthendelse) {
+    fun oppdaterPersonMedHendelse(oversiktHendelse: KOversikthendelse, callId: String = "") {
         when (oversiktHendelse.hendelseId) {
-            OversikthendelseType.MOTEBEHOV_SVAR_MOTTATT.toString() -> oppdaterPersonMedHendelseMotebehovMottatt(oversiktHendelse)
-            OversikthendelseType.MOTEBEHOV_SVAR_BEHANDLET.toString() -> oppdaterPersonMedHendelseMotebehovBehandlet(oversiktHendelse)
-            OversikthendelseType.MOTEPLANLEGGER_ALLE_SVAR_MOTTATT.toString() -> oppdaterPersonMedHendelseMoteplanleggerSvarMottat(oversiktHendelse)
-            OversikthendelseType.MOTEPLANLEGGER_ALLE_SVAR_BEHANDLET.toString() -> oppdaterPersonMedHendelseMoteplanleggerSvarBehandlet(oversiktHendelse)
+            OversikthendelseType.MOTEBEHOV_SVAR_MOTTATT.toString() -> oppdaterPersonMedHendelseMotebehovMottatt(oversiktHendelse, callId)
+            OversikthendelseType.MOTEBEHOV_SVAR_BEHANDLET.toString() -> oppdaterPersonMedHendelseMotebehovBehandlet(oversiktHendelse, callId)
+            OversikthendelseType.MOTEPLANLEGGER_ALLE_SVAR_MOTTATT.toString() -> oppdaterPersonMedHendelseMoteplanleggerSvarMottat(oversiktHendelse, callId)
+            OversikthendelseType.MOTEPLANLEGGER_ALLE_SVAR_BEHANDLET.toString() -> oppdaterPersonMedHendelseMoteplanleggerSvarBehandlet(oversiktHendelse, callId)
             else -> {
-                log.error("Mottatt oversikthendelse med ukjent type, ${oversiktHendelse.hendelseId}")
+                log.error("Mottatt oversikthendelse med ukjent type, ${oversiktHendelse.hendelseId}, {}", CallIdArgument(callId))
                 COUNT_OVERSIKTHENDELSE_UKJENT_MOTTATT.inc()
             }
         }
     }
 
-    private fun oppdaterPersonMedHendelseMoteplanleggerSvarMottat(oversiktHendelse: KOversikthendelse) {
+    private fun oppdaterPersonMedHendelseMoteplanleggerSvarMottat(oversiktHendelse: KOversikthendelse, callId: String) {
         val person = database.hentPersonResultat(oversiktHendelse.fnr)
         when {
             person.isEmpty() -> {
                 database.opprettPersonMedMoteplanleggerAlleSvarMottatt(oversiktHendelse)
-                log.info("Opprettet person basert pa oversikthendelse med moteplanlegger alle svar mottatt")
+                log.info("Opprettet person basert pa oversikthendelse med moteplanlegger alle svar mottatt, {}", CallIdArgument(callId))
                 COUNT_OVERSIKTHENDELSE_MOTEPLANLEGGER_ALLE_SVAR_MOTTATT_OPPRETT.inc()
             }
             erPersonsEnhetOppdatert(person, oversiktHendelse) -> {
                 database.oppdaterPersonMedMoteplanleggerAlleSvarNyEnhet(oversiktHendelse)
-                log.info("Oppdatert person basert pa oversikthendelse med moteplanlegger alle svar mottatt med ny enhet")
+                log.info("Oppdatert person basert pa oversikthendelse med moteplanlegger alle svar mottatt med ny enhet, {}", CallIdArgument(callId))
                 COUNT_OVERSIKTHENDELSE_MOTEPLANLEGGER_ALLE_SVAR_MOTTATT_OPPDATER_ENHET.inc()
             }
             else -> {
                 database.oppdaterPersonMedMoteplanleggerAlleSvarMottatt(oversiktHendelse)
-                log.info("Oppdatert person basert pa oversikthendelse med moteplanlegger alle svar mottatt")
+                log.info("Oppdatert person basert pa oversikthendelse med moteplanlegger alle svar mottatt, {}", CallIdArgument(callId))
                 COUNT_OVERSIKTHENDELSE_MOTEPLANLEGGER_ALLE_SVAR_MOTTATT_OPPDATER.inc()
             }
         }
     }
 
-    private fun oppdaterPersonMedHendelseMoteplanleggerSvarBehandlet(oversiktHendelse: KOversikthendelse) {
+    private fun oppdaterPersonMedHendelseMoteplanleggerSvarBehandlet(oversiktHendelse: KOversikthendelse, callId: String) {
         val person = database.hentPersonResultat(oversiktHendelse.fnr)
         when {
             person.isEmpty() -> {
@@ -52,53 +53,53 @@ class OversiktHendelseService(private val database: DatabaseInterface) {
             }
             erPersonsEnhetOppdatert(person, oversiktHendelse) -> {
                 database.oppdaterPersonMedMoteplanleggerAlleSvarBehandletNyEnhet(oversiktHendelse)
-                log.info("Oppdatert person basert pa oversikthendelse med moteplanleggersvar behandlet med ny enhet")
+                log.info("Oppdatert person basert pa oversikthendelse med moteplanleggersvar behandlet med ny enhet, {}", CallIdArgument(callId))
                 COUNT_OVERSIKTHENDELSE_MOTEPLANLEGGER_ALLE_SVAR_BEHANDLET_OPPDATER_ENHET.inc()
             }
             else -> {
                 database.oppdaterPersonMedMoteplanleggerAlleSvarBehandlet(oversiktHendelse)
-                log.info("Oppdatert person basert pa oversikthendelse med moteplanleggersvar behandlet")
+                log.info("Oppdatert person basert pa oversikthendelse med moteplanleggersvar behandlet, {}", CallIdArgument(callId))
                 COUNT_OVERSIKTHENDELSE_MOTEPLANLEGGER_ALLE_SVAR_BEHANDLET_OPPDATER.inc()
             }
         }
     }
 
-    private fun oppdaterPersonMedHendelseMotebehovBehandlet(oversiktHendelse: KOversikthendelse) {
+    private fun oppdaterPersonMedHendelseMotebehovBehandlet(oversiktHendelse: KOversikthendelse, callId: String) {
         val person = database.hentPersonResultat(oversiktHendelse.fnr)
         when {
             person.isEmpty() -> {
-                log.error("Fant ikke person som skal oppdateres med hendelse {}, for enhet {}", oversiktHendelse.hendelseId, oversiktHendelse.enhetId)
+                log.error("Fant ikke person som skal oppdateres med hendelse {}, for enhet {}, {}", oversiktHendelse.hendelseId, oversiktHendelse.enhetId, CallIdArgument(callId))
                 COUNT_OVERSIKTHENDELSE_MOTEBEHOVSSVAR_BEHANDLET_FEILET.inc()
             }
             erPersonsEnhetOppdatert(person, oversiktHendelse) -> {
                 database.oppdaterPersonMedMotebehovBehandletNyEnhet(oversiktHendelse)
-                log.info("Oppdatert person basert pa oversikthendelse med motebehovsvar behandlet med ny enhet")
+                log.info("Oppdatert person basert pa oversikthendelse med motebehovsvar behandlet med ny enhet, {}", CallIdArgument(callId))
                 COUNT_OVERSIKTHENDELSE_MOTEBEHOVSSVAR_BEHANDLET_OPPDATER_ENHET.inc()
             }
             else -> {
                 database.oppdaterPersonMedMotebehovBehandlet(oversiktHendelse)
-                log.info("Oppdatert person basert pa oversikthendelse med motebehovsvar behandlet")
+                log.info("Oppdatert person basert pa oversikthendelse med motebehovsvar behandlet, {}", CallIdArgument(callId))
                 COUNT_OVERSIKTHENDELSE_MOTEBEHOVSSVAR_BEHANDLET.inc()
             }
         }
     }
 
-    private fun oppdaterPersonMedHendelseMotebehovMottatt(oversiktHendelse: KOversikthendelse) {
+    private fun oppdaterPersonMedHendelseMotebehovMottatt(oversiktHendelse: KOversikthendelse, callId: String) {
         val person = database.hentPersonResultat(oversiktHendelse.fnr)
         when {
             person.isEmpty() -> {
                 database.opprettPersonMedMotebehovMottatt(oversiktHendelse)
-                log.info("Opprettet person basert pa oversikthendelse med motebehovsvar mottatt")
+                log.info("Opprettet person basert pa oversikthendelse med motebehovsvar mottatt, {}", CallIdArgument(callId))
                 COUNT_OVERSIKTHENDELSE_MOTEBEHOV_SVAR_MOTTATT_OPPRETT.inc()
             }
             erPersonsEnhetOppdatert(person, oversiktHendelse) -> {
                 database.oppdaterPersonMedMotebehovMottattNyEnhet(oversiktHendelse)
-                log.info("Oppdatert person basert pa oversikthendelse med motebehovsvar mottatt med ny enhet")
+                log.info("Oppdatert person basert pa oversikthendelse med motebehovsvar mottatt med ny enhet, {}", CallIdArgument(callId))
                 COUNT_OVERSIKTHENDELSE_MOTEBEHOV_SVAR_MOTTATT_OPPDATER_ENHET.inc()
             }
             else -> {
                 database.oppdaterPersonMedMotebehovMottatt(oversiktHendelse)
-                log.info("Oppdatert person basert pa oversikthendelse med motebehovsvar mottatt")
+                log.info("Oppdatert person basert pa oversikthendelse med motebehovsvar mottatt, {}", CallIdArgument(callId))
                 COUNT_OVERSIKTHENDELSE_MOTEBEHOV_SVAR_MOTTATT_OPPDATER.inc()
             }
         }

src/main/kotlin/no/nav/syfo/personstatus/PersonOversiktStatusApi.kt

@@ -1,14 +1,15 @@
 package no.nav.syfo.personstatus
 
 import io.ktor.application.call
-import io.ktor.http.HttpStatusCode
+import io.ktor.http.*
 import io.ktor.response.respond
 import io.ktor.routing.*
 import no.nav.syfo.auth.getTokenFromCookie
 import no.nav.syfo.auth.isInvalidToken
 import no.nav.syfo.metric.COUNT_PERSONOVERSIKTSTATUS_ENHET_HENTET
 import no.nav.syfo.personstatus.domain.PersonOversiktStatus
 import no.nav.syfo.tilgangskontroll.TilgangskontrollConsumer
+import no.nav.syfo.util.getCallId
 import no.nav.syfo.util.validateEnhet
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -20,39 +21,34 @@ fun Route.registerPersonoversiktApi(
         personoversiktStatusService: PersonoversiktStatusService
 ) {
     route("/api/v1/personoversikt") {
-
         get("/enhet/{enhet}") {
-            if (isInvalidToken(call.request.cookies)) {
-                call.respond(HttpStatusCode.Unauthorized)
-            } else {
                 try {
                     val token = getTokenFromCookie(call.request.cookies)
 
                     val enhet: String = call.parameters["enhet"]?.takeIf { validateEnhet(it) }
                             ?: throw IllegalArgumentException("Enhet mangler")
 
-                    val harTilgangTilEnhet = tilgangskontrollConsumer.harVeilederTilgangTilEnhet(enhet, token)
 
-                    if (harTilgangTilEnhet) {
-                        val personListe: List<PersonOversiktStatus> = personoversiktStatusService
-                                .hentPersonoversiktStatusTilknyttetEnhet(enhet, token)
-                                .filter { tilgangskontrollConsumer.harVeilederTilgangTilPerson(it.fnr, token) }
+                    when (tilgangskontrollConsumer.harVeilederTilgangTilEnhet(enhet, token, getCallId())) {
+                        true -> {
+                            val personListe: List<PersonOversiktStatus> = personoversiktStatusService
+                                    .hentPersonoversiktStatusTilknyttetEnhet(enhet, token)
+                                    .filter { tilgangskontrollConsumer.harVeilederTilgangTilPerson(it.fnr, token, getCallId()) }
 
-                        when {
-                            personListe.isNotEmpty() -> call.respond(personListe)
-                            else -> call.respond(HttpStatusCode.NoContent)
-                        }
+                            when {
+                                personListe.isNotEmpty() -> call.respond(personListe)
+                                else -> call.respond(HttpStatusCode.NoContent)
+                            }
 
-                        COUNT_PERSONOVERSIKTSTATUS_ENHET_HENTET.inc()
-                    } else {
-                        call.respond(HttpStatusCode.Forbidden)
+                            COUNT_PERSONOVERSIKTSTATUS_ENHET_HENTET.inc()
+                        }
+                        else -> call.respond(HttpStatusCode.Forbidden)
                     }
                 } catch (e: IllegalArgumentException) {
-                    log.warn("Kan ikke hente personoversikt for enhet: {}", e.message)
+                    log.warn("Kan ikke hente personoversikt for enhet: {}", e.message, getCallId())
                     call.respond(HttpStatusCode.BadRequest, e.message ?: "Kan ikke hente personoversikt for enhet")
                 }
             }
-        }
 
     }
 }