From 5b6539a4f96efb3b803942f820575de704ff7986 Mon Sep 17 00:00:00 2001 From: stylianosgakis Date: Tue, 17 Nov 2026 17:46:02 +0100 Subject: [PATCH 1/5] Pin the GraphQL log lines Android and desktop write The network logging is about to read a policy so that iOS can keep response data out of the device log. Android and desktop must keep writing exactly what they write today, so the success, GraphQL error and exception lines, and the RUM error attributes, are pinned first. Adds shared test doubles (capturing loggers, a queued query and HTTP client fakes) to commonTest for the tests that follow. (cherry picked from commit 9f6e8cdce2355e2179edb482383b8c2c60d30bbb) --- app/network/network-clients/build.gradle.kts | 7 + .../network/clients/NetworkLogTestDoubles.kt | 121 ++++++++++++++++ .../apollo/LoggingInterceptorOutputTest.kt | 137 ++++++++++++++++++ 3 files changed, 265 insertions(+) create mode 100644 app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogTestDoubles.kt create mode 100644 app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptorOutputTest.kt diff --git a/app/network/network-clients/build.gradle.kts b/app/network/network-clients/build.gradle.kts index 0d2940bc19..d71b953e5f 100644 --- a/app/network/network-clients/build.gradle.kts +++ b/app/network/network-clients/build.gradle.kts @@ -28,6 +28,13 @@ kotlin { implementation(projects.languageCore) implementation(projects.trackingCore) } + commonTest.dependencies { + implementation(libs.apollo.testingSupport) + implementation(libs.atomicfu) + implementation(libs.coroutines.test) + implementation(libs.ktor.client.mock) + implementation(projects.coreLocale) + } androidMain.dependencies { implementation(libs.datadog.sdk.ktor) implementation(libs.ktor.client.okhttp) diff --git a/app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogTestDoubles.kt b/app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogTestDoubles.kt new file mode 100644 index 0000000000..a3ceda1e5d --- /dev/null +++ b/app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogTestDoubles.kt @@ -0,0 +1,121 @@ +package com.hedvig.android.network.clients + +import com.apollographql.apollo.api.Adapter +import com.apollographql.apollo.api.CompiledField +import com.apollographql.apollo.api.CustomScalarAdapters +import com.apollographql.apollo.api.Query +import com.apollographql.apollo.api.json.JsonWriter +import com.hedvig.android.core.buildconstants.HedvigBuildConstants +import com.hedvig.android.core.datastore.DeviceIdFetcher +import com.hedvig.android.core.locale.CommonLocale +import com.hedvig.android.core.tracking.ActionType +import com.hedvig.android.core.tracking.ErrorSource +import com.hedvig.android.core.tracking.RumLogger +import com.hedvig.android.language.Language +import com.hedvig.android.language.LanguageService +import com.hedvig.android.logger.LogPriority +import com.hedvig.android.logger.LogcatLogger +import io.ktor.client.engine.HttpClientEngine +import io.ktor.client.engine.HttpClientEngineFactory +import io.ktor.client.engine.mock.MockEngine +import io.ktor.client.engine.mock.MockEngineConfig +import io.ktor.client.engine.mock.MockRequestHandler +import kotlinx.atomicfu.locks.SynchronizedObject +import kotlinx.atomicfu.locks.synchronized +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow + +internal data class CapturedLog(val priority: LogPriority, val tag: String?, val message: String) + +/** Records every line with its throwable appended. Lines arrive from request threads too. */ +internal class CapturingLogcatLogger : LogcatLogger { + private val lock = SynchronizedObject() + private val captured = mutableListOf() + + fun entries(): List = synchronized(lock) { captured.toList() } + + override fun log(priority: LogPriority, throwable: Throwable?, tag: String?, message: () -> String) { + val text = message() + (throwable?.let { "\n" + it.stackTraceToString() } ?: "") + synchronized(lock) { captured += CapturedLog(priority, tag, text) } + } +} + +internal data class CapturedRumError(val message: String, val source: ErrorSource, val attributes: Map) + +internal class CapturingRumLogger : RumLogger { + private val lock = SynchronizedObject() + private val captured = mutableListOf() + + fun errors(): List = synchronized(lock) { captured.toList() } + + override fun logAction(type: ActionType, name: String, attributes: Map) {} + + override fun logError( + message: String, + source: ErrorSource, + attributes: Map, + throwable: Throwable?, + stacktrace: String?, + ) { + synchronized(lock) { captured += CapturedRumError(message, source, attributes) } + } +} + +/** A query whose responses are queued on a test transport, so nothing ever parses or caches it. */ +internal object SentinelQuery : Query { + data class Data(val value: String) : Query.Data + + override fun document(): String = "query Sentinel { __typename }" + + override fun name(): String = "Sentinel" + + override fun id(): String = "Sentinel" + + override fun adapter(): Adapter = error("Queued responses are never parsed") + + override fun serializeVariables( + writer: JsonWriter, + customScalarAdapters: CustomScalarAdapters, + withDefaultValues: Boolean, + ) {} + + override fun rootField(): CompiledField = error("The client has no cache") +} + +internal class FakeHedvigBuildConstants(override val isProduction: Boolean) : HedvigBuildConstants { + override val urlGraphqlOctopus: String = "https://example.test/graphql" + override val urlBaseWeb: String = "" + override val urlOdyssey: String = "" + override val urlHedvigGateway: String = "" + override val urlAuthService: String = "" + override val urlBotService: String = "" + override val urlClaimsService: String = "" + override val deepLinkHosts: List = emptyList() + override val appVersionName: String = "1.0.0" + override val appVersionCode: String = "1" + override val appPackageId: String = "com.hedvig.test" + override val isDebug: Boolean = true + override val buildApiVersion: Int = 1 + override val platformName: String = "test" + override val model: String = "model" + override val userAgent: String = "user-agent" +} + +internal object FakeLanguageService : LanguageService { + override val language: StateFlow = MutableStateFlow(Language.EN_SE) + + override fun setLanguage(language: Language) {} + + override fun getLocale(): CommonLocale = error("Not read by the HTTP client") +} + +internal object FakeDeviceIdFetcher : DeviceIdFetcher { + override suspend fun fetch(): String? = "device-id" +} + +/** A factory for a [MockEngine] answering every request with [handler]. */ +internal fun mockEngineFactory(handler: MockRequestHandler): HttpClientEngineFactory = + object : HttpClientEngineFactory { + override fun create(block: MockEngineConfig.() -> Unit): HttpClientEngine = + MockEngine(MockEngineConfig().apply(block).apply { addHandler(handler) }) + } diff --git a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptorOutputTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptorOutputTest.kt new file mode 100644 index 0000000000..f497ca7909 --- /dev/null +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptorOutputTest.kt @@ -0,0 +1,137 @@ +package com.hedvig.android.network.clients.apollo + +import assertk.assertThat +import assertk.assertions.containsExactly +import assertk.assertions.isEmpty +import com.apollographql.apollo.ApolloClient +import com.apollographql.apollo.annotations.ApolloExperimental +import com.apollographql.apollo.api.ApolloResponse +import com.apollographql.apollo.api.Error +import com.apollographql.apollo.testing.QueueTestNetworkTransport +import com.apollographql.apollo.testing.enqueueTestNetworkError +import com.apollographql.apollo.testing.enqueueTestResponse +import com.benasher44.uuid.uuid4 +import com.hedvig.android.core.tracking.ErrorSource +import com.hedvig.android.core.tracking.RumLogger +import com.hedvig.android.logger.LogPriority +import com.hedvig.android.logger.LogcatLogger +import com.hedvig.android.network.clients.CapturedLog +import com.hedvig.android.network.clients.CapturedRumError +import com.hedvig.android.network.clients.CapturingLogcatLogger +import com.hedvig.android.network.clients.CapturingRumLogger +import com.hedvig.android.network.clients.SentinelQuery +import kotlin.test.Test +import kotlinx.coroutines.test.runTest + +/** Pins the exact lines [LoggingInterceptor] writes on Android and desktop. */ +@OptIn(ApolloExperimental::class) +class LoggingInterceptorOutputTest { + @Test + fun `a success response logs its data at DEBUG`() { + val runs = runForEachProvidedPolicy { apolloClient -> + apolloClient.enqueueTestResponse(SentinelQuery, SentinelQuery.Data("data-sentinel")) + apolloClient.query(SentinelQuery).execute() + } + + for (run in runs) { + assertThat(run.logs).containsExactly( + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel START."), + CapturedLog( + LogPriority.DEBUG, + null, + "GraphQL request for Sentinel EMISSION. Response data: Data(value=data-sentinel)", + ), + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel END."), + ) + assertThat(run.rumErrors).isEmpty() + } + } + + @Test + fun `a GraphQL error logs data, errors and extensions at ERROR and to RUM`() { + val runs = runForEachProvidedPolicy { apolloClient -> + apolloClient.enqueueTestResponse( + ApolloResponse.Builder(SentinelQuery, uuid4()) + .data(SentinelQuery.Data("data-sentinel")) + .errors(listOf(Error.Builder("Something failed").putExtension("detail", "error-extension-sentinel").build())) + .extensions(mapOf("trace" to "response-extension-sentinel")) + .build(), + ) + apolloClient.query(SentinelQuery).execute() + } + + val errors = "[LoggableGraphqlError(message=Something failed, locations=null, paths=null, " + + "extensions=Extensions(errorType=null, uncategorizedExtensions={detail=error-extension-sentinel}))]" + val attributes = + "{data=Data(value=data-sentinel), errors=$errors, extensions=[(trace, response-extension-sentinel)]}" + for (run in runs) { + assertThat(run.logs).containsExactly( + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel START."), + CapturedLog( + LogPriority.DEBUG, + null, + "GraphQL request for Sentinel EMISSION. Response data: Data(value=data-sentinel)", + ), + CapturedLog( + LogPriority.ERROR, + null, + "GraphQL errors for Sentinel: [Something failed] attributes: $attributes" + + " There was data and errors at the same time! Data:Data(value=data-sentinel)", + ), + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel END."), + ) + assertThat(run.rumErrors.map { it.copy(attributes = mapOf("rendered" to it.attributes.toString())) }) + .containsExactly( + CapturedRumError( + "GraphQL errors for Sentinel: [Something failed]", + ErrorSource.NETWORK, + mapOf("rendered" to attributes), + ), + ) + } + } + + @Test + fun `an exception logs at WARN`() { + val runs = runForEachProvidedPolicy { apolloClient -> + apolloClient.enqueueTestNetworkError() + apolloClient.query(SentinelQuery).execute() + } + + for (run in runs) { + assertThat(run.logs).containsExactly( + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel START."), + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel EMISSION. Response data: null"), + CapturedLog( + LogPriority.WARN, + null, + "GraphQL exception for Sentinel: " + + "com.apollographql.apollo.exception.ApolloNetworkException: Network error queued in QueueTestNetworkTransport", + ), + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel END."), + ) + assertThat(run.rumErrors).isEmpty() + } + } +} + +private class Run(val logs: List, val rumErrors: List) + +/** Runs [block] against a fresh client. */ +private fun runForEachProvidedPolicy(block: suspend (ApolloClient) -> Unit): List { + val logs = CapturingLogcatLogger() + val rum = CapturingRumLogger() + LogcatLogger.install(logs) + RumLogger.install(rum) + try { + val apolloClient = ApolloClient.Builder() + .networkTransport(QueueTestNetworkTransport()) + .addHedvigInterceptors(emptyList()) + .build() + runTest { block(apolloClient) } + return listOf(Run(logs.entries(), rum.errors())) + } finally { + LogcatLogger.uninstall() + RumLogger.uninstall() + } +} From 78eb6efa13e66762fb4ae8856dec7097022d9aea Mon Sep 17 00:00:00 2001 From: stylianosgakis Date: Thu, 19 Nov 2026 15:02:01 +0100 Subject: [PATCH 2/5] Gate network body and GraphQL data logging on a NetworkLogPolicy Shared networking code runs inside iOS apps, where every Kotlin log line can leave the device through the app's logger. The Ktor client logged request and response bodies in any non-production build and LoggingInterceptor logged GraphQL response data in every build. NetworkLogPolicy now decides both. Android and desktop provide it from the build constants with exactly today's values (bodies when not production, GraphQL data always), so their output is unchanged. The native network providers take it from the graph, so the iOS app has to choose. With GraphQL data off, the emission line carries the operation name only, and the error line and RUM error keep the error messages, errors and extensions but not the data, which is what PR 3405 does for Android production. (cherry picked from commit 70206b77c7069a5f91cfdbaca794a1673ae29002 with edits: the umbrella graph, claim history test and test host hunks are dropped, and data off no longer drops error messages, errors and extensions) --- .../network/clients/NetworkLogPolicy.kt | 12 ++ .../clients/apollo/LoggingInterceptor.kt | 23 ++- .../clients/di/NetworkMetroProviders.kt | 22 ++- .../network/clients/NetworkLogPolicyTest.kt | 152 ++++++++++++++++++ .../clients/di/ApolloClientMetroProviders.kt | 10 ++ .../clients/apollo/ApolloInterceptorsTest.kt | 6 +- .../apollo/LoggingInterceptorOutputTest.kt | 41 +++-- .../clients/di/JvmNetworkBindingsTest.kt | 2 + .../clients/di/JvmNetworkLogPolicyTest.kt | 109 +++++++++++++ .../di/NetworkMetroProviders.native.kt | 10 +- .../clients/di/NativeApolloClientTest.kt | 2 + 11 files changed, 361 insertions(+), 28 deletions(-) create mode 100644 app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/NetworkLogPolicy.kt create mode 100644 app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogPolicyTest.kt create mode 100644 app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkLogPolicyTest.kt diff --git a/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/NetworkLogPolicy.kt b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/NetworkLogPolicy.kt new file mode 100644 index 0000000000..bc0d3c83ef --- /dev/null +++ b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/NetworkLogPolicy.kt @@ -0,0 +1,12 @@ +package com.hedvig.android.network.clients + +/** + * What the network clients log beyond GraphQL operation names, error messages, error extensions and exceptions. + * + * [logsHttpBodies] logs every HTTP request and response with its body. [logsGraphqlData] adds the GraphQL response + * data to the GraphQL log lines and to the attributes of the RUM error a GraphQL error reports. + */ +class NetworkLogPolicy( + val logsHttpBodies: Boolean, + val logsGraphqlData: Boolean, +) diff --git a/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptor.kt b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptor.kt index 8151e4470c..39c2bbfb58 100644 --- a/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptor.kt +++ b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptor.kt @@ -16,6 +16,7 @@ import com.hedvig.android.core.tracking.ErrorSource import com.hedvig.android.core.tracking.logError import com.hedvig.android.logger.LogPriority import com.hedvig.android.logger.logcat +import com.hedvig.android.network.clients.NetworkLogPolicy import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.first import kotlinx.coroutines.flow.onCompletion @@ -27,11 +28,14 @@ import kotlinx.coroutines.flow.onEach */ internal fun ApolloClient.Builder.addHedvigInterceptors( platformInterceptors: List, + networkLogPolicy: NetworkLogPolicy, ): ApolloClient.Builder = this .apply { platformInterceptors.forEach(::addInterceptor) } - .addInterceptor(LoggingInterceptor()) + .addInterceptor(LoggingInterceptor(networkLogPolicy)) -internal class LoggingInterceptor : ApolloInterceptor { +internal class LoggingInterceptor( + private val networkLogPolicy: NetworkLogPolicy, +) : ApolloInterceptor { override fun intercept( request: ApolloRequest, chain: ApolloInterceptorChain, @@ -39,7 +43,11 @@ internal class LoggingInterceptor : ApolloInterceptor { logcat(LogPriority.DEBUG) { "GraphQL request for ${request.operation.name()} START." } return chain.proceed(request).onEach { response -> logcat(LogPriority.DEBUG) { - "GraphQL request for ${request.operation.name()} EMISSION. Response data: ${response.data}" + if (networkLogPolicy.logsGraphqlData) { + "GraphQL request for ${request.operation.name()} EMISSION. Response data: ${response.data}" + } else { + "GraphQL request for ${request.operation.name()} EMISSION." + } } val data = response.data val errors = response.errors.orEmpty().map { it.toGraphqlError() } @@ -65,7 +73,9 @@ internal class LoggingInterceptor : ApolloInterceptor { val errorMessagesJoinedToString = errors.joinToString(", ", "[", "]") { it.message } val errorMessage = "GraphQL errors for ${request.operation.name()}: $errorMessagesJoinedToString" val errorAttributes = buildMap { - put("data", response.data) + if (networkLogPolicy.logsGraphqlData) { + put("data", response.data) + } put("errors", errors) if (response.extensions.isNotEmpty()) { put("extensions", response.extensions.toList().joinToString(", ", "[", "]") { it.toString() }) @@ -77,7 +87,10 @@ internal class LoggingInterceptor : ApolloInterceptor { append(" attributes: ") append(errorAttributes) if (data != null) { - append(" There was data and errors at the same time! Data:$data") + append(" There was data and errors at the same time!") + if (networkLogPolicy.logsGraphqlData) { + append(" Data:$data") + } } } } diff --git a/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProviders.kt b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProviders.kt index 1e400f2116..6db3f1f612 100644 --- a/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProviders.kt +++ b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProviders.kt @@ -15,6 +15,7 @@ import com.hedvig.android.network.clients.AccessTokenFetcher import com.hedvig.android.network.clients.DeviceIdInterceptor import com.hedvig.android.network.clients.ExtraKtorClientConfiguration import com.hedvig.android.network.clients.HedvigHttpLogger +import com.hedvig.android.network.clients.NetworkLogPolicy import com.hedvig.android.network.clients.apollo.addHedvigInterceptors import dev.zacsweers.metro.ContributesTo import dev.zacsweers.metro.Provides @@ -48,7 +49,15 @@ interface NetworkMetroProviders { languageService: LanguageService, deviceIdFetcher: DeviceIdFetcher, extraKtorClientConfiguration: ExtraKtorClientConfiguration, - ): HttpClient = buildKtorClient(hedvigBuildConstants, languageService, deviceIdFetcher, extraKtorClientConfiguration) + networkLogPolicy: NetworkLogPolicy, + ): HttpClient = buildKtorClient( + httpClientEngineFactory(), + hedvigBuildConstants, + languageService, + deviceIdFetcher, + extraKtorClientConfiguration, + networkLogPolicy, + ) @Provides @SingleIn(AppScope::class) @@ -73,22 +82,25 @@ internal fun buildHedvigApolloClient( httpClient: HttpClient, hedvigBuildConstants: HedvigBuildConstants, platformInterceptors: List, + networkLogPolicy: NetworkLogPolicy, ): ApolloClient = with(Cache) { ApolloClient.Builder() .cache(normalizedCacheFactory) .ktorClient(httpClient) .httpServerUrl(hedvigBuildConstants.urlGraphqlOctopus) - .addHedvigInterceptors(platformInterceptors) + .addHedvigInterceptors(platformInterceptors, networkLogPolicy) .build() } -private fun buildKtorClient( +internal fun buildKtorClient( + engineFactory: HttpClientEngineFactory<*>, hedvigBuildConstants: HedvigBuildConstants, languageService: LanguageService, deviceIdFetcher: DeviceIdFetcher, extraKtorClientConfiguration: ExtraKtorClientConfiguration, + networkLogPolicy: NetworkLogPolicy, ): HttpClient { - return HttpClient(httpClientEngineFactory()) { + return HttpClient(engineFactory) { installDatadogKtorPlugin(hedvigBuildConstants) install(HttpTimeout) { connectTimeoutMillis = CONNECT_TIMEOUT.inWholeMilliseconds @@ -97,7 +109,7 @@ private fun buildKtorClient( defaultRequest { commonHeaders(hedvigBuildConstants, languageService) } - if (!hedvigBuildConstants.isProduction) { + if (networkLogPolicy.logsHttpBodies) { Logging { level = LogLevel.BODY logger = HedvigHttpLogger() diff --git a/app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogPolicyTest.kt b/app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogPolicyTest.kt new file mode 100644 index 0000000000..23c9d6cf84 --- /dev/null +++ b/app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogPolicyTest.kt @@ -0,0 +1,152 @@ +package com.hedvig.android.network.clients + +import com.apollographql.apollo.ApolloClient +import com.apollographql.apollo.annotations.ApolloExperimental +import com.apollographql.apollo.api.ApolloResponse +import com.apollographql.apollo.api.Error +import com.apollographql.apollo.testing.QueueTestNetworkTransport +import com.apollographql.apollo.testing.enqueueTestNetworkError +import com.apollographql.apollo.testing.enqueueTestResponse +import com.benasher44.uuid.uuid4 +import com.hedvig.android.core.tracking.RumLogger +import com.hedvig.android.logger.LogcatLogger +import com.hedvig.android.network.clients.apollo.addHedvigInterceptors +import com.hedvig.android.network.clients.di.buildKtorClient +import io.ktor.client.engine.mock.respond +import io.ktor.client.request.post +import io.ktor.client.request.setBody +import io.ktor.client.statement.bodyAsText +import io.ktor.http.ContentType +import io.ktor.http.HttpHeaders +import io.ktor.http.HttpStatusCode +import io.ktor.http.contentType +import io.ktor.http.headersOf +import kotlin.test.AfterTest +import kotlin.test.BeforeTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue +import kotlinx.coroutines.test.runTest + +/** + * Runs the HTTP client and the GraphQL logging with values marked by [SENTINELS] and checks which logged line or RUM + * error carries one. + */ +@OptIn(ApolloExperimental::class) +class NetworkLogPolicyTest { + private val logs = CapturingLogcatLogger() + private val rum = CapturingRumLogger() + + @BeforeTest + fun install() { + LogcatLogger.install(logs) + RumLogger.install(rum) + } + + @AfterTest + fun uninstall() { + LogcatLogger.uninstall() + RumLogger.uninstall() + } + + @Test + fun `with HTTP bodies off no logged line carries a request or response body`() = runTest { + exchangeHttpBodies(NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = false)) + + assertEquals(emptyList(), loggedSentinels()) + } + + @Test + fun `with HTTP bodies on the request and response bodies are logged`() = runTest { + exchangeHttpBodies(NetworkLogPolicy(logsHttpBodies = true, logsGraphqlData = false)) + + assertEquals(listOf(REQUEST_BODY_SENTINEL, RESPONSE_BODY_SENTINEL), loggedSentinels()) + } + + @Test + fun `with GraphQL data off no logged line or RUM error carries response data and errors are still logged`() = + runTest { + exchangeGraphql(NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = false)) + + assertEquals(listOf(ERROR_EXTENSION_SENTINEL, RESPONSE_EXTENSION_SENTINEL), loggedSentinels()) + assertEquals(listOf(ERROR_EXTENSION_SENTINEL, RESPONSE_EXTENSION_SENTINEL), rumSentinels()) + val messages = logs.entries().map { it.message } + assertTrue("GraphQL request for Sentinel EMISSION." in messages, "$messages") + assertTrue(messages.any { it.startsWith("GraphQL errors for Sentinel: [Something failed] attributes: {errors=") }) + assertTrue(messages.any { it.endsWith("There was data and errors at the same time!") }) + } + + @Test + fun `with GraphQL data on the response data and extensions are logged and reported`() = runTest { + exchangeGraphql(NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = true)) + + assertEquals( + listOf(DATA_SENTINEL, ERROR_EXTENSION_SENTINEL, RESPONSE_EXTENSION_SENTINEL), + loggedSentinels(), + ) + assertEquals(listOf(DATA_SENTINEL, ERROR_EXTENSION_SENTINEL, RESPONSE_EXTENSION_SENTINEL), rumSentinels()) + } + + private suspend fun exchangeHttpBodies(networkLogPolicy: NetworkLogPolicy) { + val engine = mockEngineFactory { + respond( + content = """{"value":"$RESPONSE_BODY_SENTINEL"}""", + status = HttpStatusCode.OK, + headers = headersOf(HttpHeaders.ContentType, ContentType.Application.Json.toString()), + ) + } + val client = buildKtorClient( + engineFactory = engine, + hedvigBuildConstants = FakeHedvigBuildConstants(isProduction = false), + languageService = FakeLanguageService, + deviceIdFetcher = FakeDeviceIdFetcher, + extraKtorClientConfiguration = NoopExtraKtorClientConfiguration(), + networkLogPolicy = networkLogPolicy, + ) + val response = client.post("https://example.test/graphql") { + contentType(ContentType.Application.Json) + setBody("""{"value":"$REQUEST_BODY_SENTINEL"}""") + } + check(RESPONSE_BODY_SENTINEL in response.bodyAsText()) + client.close() + } + + private suspend fun exchangeGraphql(networkLogPolicy: NetworkLogPolicy) { + val apolloClient = ApolloClient.Builder() + .networkTransport(QueueTestNetworkTransport()) + .addHedvigInterceptors(emptyList(), networkLogPolicy) + .build() + apolloClient.enqueueTestResponse(SentinelQuery, SentinelQuery.Data(DATA_SENTINEL)) + apolloClient.enqueueTestResponse( + ApolloResponse.Builder(SentinelQuery, uuid4()) + .data(SentinelQuery.Data(DATA_SENTINEL)) + .errors(listOf(Error.Builder("Something failed").putExtension("detail", ERROR_EXTENSION_SENTINEL).build())) + .extensions(mapOf("trace" to RESPONSE_EXTENSION_SENTINEL)) + .build(), + ) + apolloClient.enqueueTestNetworkError() + repeat(3) { apolloClient.query(SentinelQuery).execute() } + apolloClient.close() + } + + private fun loggedSentinels(): List = SENTINELS.filter { sentinel -> + logs.entries().any { sentinel in it.message || sentinel in it.tag.orEmpty() } + } + + private fun rumSentinels(): List = SENTINELS.filter { sentinel -> + rum.errors().any { sentinel in it.message || sentinel in it.attributes.toString() } + } +} + +private const val REQUEST_BODY_SENTINEL = "request-body-sentinel-91c2" +private const val RESPONSE_BODY_SENTINEL = "response-body-sentinel-4e7a" +private const val DATA_SENTINEL = "data-sentinel-0b5d" +private const val ERROR_EXTENSION_SENTINEL = "error-extension-sentinel-c83f" +private const val RESPONSE_EXTENSION_SENTINEL = "response-extension-sentinel-26e1" +private val SENTINELS = listOf( + REQUEST_BODY_SENTINEL, + RESPONSE_BODY_SENTINEL, + DATA_SENTINEL, + ERROR_EXTENSION_SENTINEL, + RESPONSE_EXTENSION_SENTINEL, +) diff --git a/app/network/network-clients/src/jvmAndAndroidMain/kotlin/com/hedvig/android/network/clients/di/ApolloClientMetroProviders.kt b/app/network/network-clients/src/jvmAndAndroidMain/kotlin/com/hedvig/android/network/clients/di/ApolloClientMetroProviders.kt index cef0dfccc2..0947b61178 100644 --- a/app/network/network-clients/src/jvmAndAndroidMain/kotlin/com/hedvig/android/network/clients/di/ApolloClientMetroProviders.kt +++ b/app/network/network-clients/src/jvmAndAndroidMain/kotlin/com/hedvig/android/network/clients/di/ApolloClientMetroProviders.kt @@ -7,6 +7,7 @@ import com.hedvig.android.auth.AuthTokenService import com.hedvig.android.core.buildconstants.HedvigBuildConstants import com.hedvig.android.core.common.di.AppScope import com.hedvig.android.core.demomode.DemoManager +import com.hedvig.android.network.clients.NetworkLogPolicy import com.hedvig.android.network.clients.apollo.LogoutOnUnauthenticatedInterceptor import dev.zacsweers.metro.ContributesTo import dev.zacsweers.metro.Provides @@ -24,11 +25,20 @@ interface ApolloClientMetroProviders { normalizedCacheFactory: NormalizedCacheFactory, httpClient: HttpClient, hedvigBuildConstants: HedvigBuildConstants, + networkLogPolicy: NetworkLogPolicy, ): ApolloClient = buildHedvigApolloClient( normalizedCacheFactory, httpClient, hedvigBuildConstants, apolloPlatformInterceptors(authTokenService, demoManager), + networkLogPolicy, + ) + + /** HTTP bodies are logged outside production builds, GraphQL data in every build. */ + @Provides + fun provideNetworkLogPolicy(hedvigBuildConstants: HedvigBuildConstants): NetworkLogPolicy = NetworkLogPolicy( + logsHttpBodies = !hedvigBuildConstants.isProduction, + logsGraphqlData = true, ) } diff --git a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/ApolloInterceptorsTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/ApolloInterceptorsTest.kt index 9cbf933d86..66608da68a 100644 --- a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/ApolloInterceptorsTest.kt +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/ApolloInterceptorsTest.kt @@ -23,6 +23,7 @@ import com.hedvig.android.core.tracking.ActionType import com.hedvig.android.core.tracking.ErrorSource import com.hedvig.android.core.tracking.RumLogger import com.hedvig.android.logger.TestLogcatLoggingRule +import com.hedvig.android.network.clients.NetworkLogPolicy import com.hedvig.android.network.clients.di.apolloPlatformInterceptors import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.MutableStateFlow @@ -90,7 +91,10 @@ internal class ApolloInterceptorsTest { private fun apolloClient(isDemoMode: Boolean): ApolloClient { return ApolloClient.Builder() .networkTransport(QueueTestNetworkTransport()) - .addHedvigInterceptors(apolloPlatformInterceptors(authTokenService, FakeDemoManager(isDemoMode))) + .addHedvigInterceptors( + apolloPlatformInterceptors(authTokenService, FakeDemoManager(isDemoMode)), + NetworkLogPolicy(logsHttpBodies = true, logsGraphqlData = true), + ) .build() } diff --git a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptorOutputTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptorOutputTest.kt index f497ca7909..eb2f4449ad 100644 --- a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptorOutputTest.kt +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptorOutputTest.kt @@ -19,11 +19,16 @@ import com.hedvig.android.network.clients.CapturedLog import com.hedvig.android.network.clients.CapturedRumError import com.hedvig.android.network.clients.CapturingLogcatLogger import com.hedvig.android.network.clients.CapturingRumLogger +import com.hedvig.android.network.clients.FakeHedvigBuildConstants import com.hedvig.android.network.clients.SentinelQuery +import com.hedvig.android.network.clients.di.ApolloClientMetroProviders import kotlin.test.Test import kotlinx.coroutines.test.runTest -/** Pins the exact lines [LoggingInterceptor] writes on Android and desktop. */ +/** + * Pins the exact lines [LoggingInterceptor] writes on Android and desktop, with the policy those platforms provide for + * a non-production and a production build. + */ @OptIn(ApolloExperimental::class) class LoggingInterceptorOutputTest { @Test @@ -117,21 +122,25 @@ class LoggingInterceptorOutputTest { private class Run(val logs: List, val rumErrors: List) -/** Runs [block] against a fresh client. */ +/** Runs [block] against a fresh client once per provided policy, for a non-production and a production build. */ private fun runForEachProvidedPolicy(block: suspend (ApolloClient) -> Unit): List { - val logs = CapturingLogcatLogger() - val rum = CapturingRumLogger() - LogcatLogger.install(logs) - RumLogger.install(rum) - try { - val apolloClient = ApolloClient.Builder() - .networkTransport(QueueTestNetworkTransport()) - .addHedvigInterceptors(emptyList()) - .build() - runTest { block(apolloClient) } - return listOf(Run(logs.entries(), rum.errors())) - } finally { - LogcatLogger.uninstall() - RumLogger.uninstall() + return listOf(false, true).map { isProduction -> + val logs = CapturingLogcatLogger() + val rum = CapturingRumLogger() + LogcatLogger.install(logs) + RumLogger.install(rum) + try { + val networkLogPolicy = object : ApolloClientMetroProviders {} + .provideNetworkLogPolicy(FakeHedvigBuildConstants(isProduction)) + val apolloClient = ApolloClient.Builder() + .networkTransport(QueueTestNetworkTransport()) + .addHedvigInterceptors(emptyList(), networkLogPolicy) + .build() + runTest { block(apolloClient) } + Run(logs.entries(), rum.errors()) + } finally { + LogcatLogger.uninstall() + RumLogger.uninstall() + } } } diff --git a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt index ab0376ccf5..26410d242e 100644 --- a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkBindingsTest.kt @@ -8,6 +8,7 @@ import com.hedvig.android.core.common.di.AuthHttpClientEngine import com.hedvig.android.core.common.di.DesktopDataDirectory import com.hedvig.android.network.clients.AccessTokenFetcher import com.hedvig.android.network.clients.ExtraKtorClientConfiguration +import com.hedvig.android.network.clients.NetworkLogPolicy import com.hedvig.android.network.clients.NoopExtraKtorClientConfiguration import com.hedvig.android.network.clients.TlsDiagnostics import dev.zacsweers.metro.DependencyGraph @@ -30,6 +31,7 @@ internal interface NetworkTestGraph { val accessTokenFetcher: AccessTokenFetcher val extraKtorClientConfiguration: ExtraKtorClientConfiguration val tlsDiagnostics: TlsDiagnostics + val networkLogPolicy: NetworkLogPolicy @AuthHttpClientEngine val authHttpClientEngine: HttpClientEngine diff --git a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkLogPolicyTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkLogPolicyTest.kt new file mode 100644 index 0000000000..3a24d12e4e --- /dev/null +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkLogPolicyTest.kt @@ -0,0 +1,109 @@ +package com.hedvig.android.network.clients.di + +import com.hedvig.android.core.buildconstants.AppBuildConfig +import com.hedvig.android.core.buildconstants.Flavor +import com.hedvig.android.logger.LogPriority +import com.hedvig.android.logger.LogcatLogger +import com.hedvig.android.network.clients.CapturingLogcatLogger +import com.hedvig.android.network.clients.FakeDeviceIdFetcher +import com.hedvig.android.network.clients.FakeHedvigBuildConstants +import com.hedvig.android.network.clients.FakeLanguageService +import com.hedvig.android.network.clients.NoopExtraKtorClientConfiguration +import com.hedvig.android.network.clients.mockEngineFactory +import dev.zacsweers.metro.createGraphFactory +import io.ktor.client.engine.mock.respond +import io.ktor.client.request.post +import io.ktor.client.request.setBody +import io.ktor.client.statement.bodyAsText +import kotlin.io.path.createTempDirectory +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlinx.coroutines.test.runTest + +/** Pins the policy Android and desktop builds are given, and the HTTP logging it turns on. */ +class JvmNetworkLogPolicyTest { + @AfterTest + fun uninstall() { + LogcatLogger.uninstall() + } + + @Test + fun `HTTP bodies are logged outside production builds and GraphQL data in every build`() { + val provided = buildConfigs.mapValues { (_, appBuildConfig) -> + val dataDirectory = createTempDirectory("network-log-policy-test").toFile() + try { + createGraphFactory().create(dataDirectory, appBuildConfig).networkLogPolicy + .let { it.logsHttpBodies to it.logsGraphqlData } + } finally { + dataDirectory.deleteRecursively() + } + } + + assertEquals( + mapOf( + "Android debug" to (true to true), + "Android staging" to (true to true), + "Android release" to (false to true), + "desktop staging" to (true to true), + "desktop production" to (false to true), + ), + provided, + ) + } + + @Test + fun `the HTTP client logs bodies at VERBOSE outside production and nothing in production`() = runTest { + val ktorLines = listOf(false, true).associateWith { isProduction -> + val logs = CapturingLogcatLogger() + LogcatLogger.install(logs) + val client = buildKtorClient( + engineFactory = mockEngineFactory { respond("response-body-sentinel") }, + hedvigBuildConstants = FakeHedvigBuildConstants(isProduction), + languageService = FakeLanguageService, + deviceIdFetcher = FakeDeviceIdFetcher, + extraKtorClientConfiguration = NoopExtraKtorClientConfiguration(), + networkLogPolicy = object : ApolloClientMetroProviders {} + .provideNetworkLogPolicy(FakeHedvigBuildConstants(isProduction)), + ) + client.post("https://example.test") { setBody("request-body-sentinel") }.bodyAsText() + client.close() + LogcatLogger.uninstall() + logs.entries().filter { it.tag == "Ktor" } + } + + val nonProduction = ktorLines.getValue(false) + assertEquals(setOf(LogPriority.VERBOSE), nonProduction.map { it.priority }.toSet()) + assertEquals( + listOf(true, true), + listOf("request-body-sentinel", "response-body-sentinel").map { body -> + nonProduction.any { body in it.message } + }, + ) + assertEquals(emptyList(), ktorLines.getValue(true)) + } +} + +private val buildConfigs: Map = mapOf( + "Android debug" to TestBuildConfig("com.hedvig.dev.app", "debug", Flavor.Develop), + "Android staging" to TestBuildConfig("com.hedvig.app", "staging", Flavor.Staging), + "Android release" to TestBuildConfig("com.hedvig.app", "release", Flavor.Production), + "desktop staging" to TestBuildConfig("com.hedvig.dev.app", "debug", Flavor.Develop), + "desktop production" to TestBuildConfig("com.hedvig.app", "release", Flavor.Production), +) + +private class TestBuildConfig( + override val applicationId: String, + override val buildType: String, + override val appFlavor: Flavor, +) : AppBuildConfig { + override val debug: Boolean = buildType == "debug" + override val versionCode: Int = 1 + override val versionName: String = "1.0.0" + override val osReleaseVersion: String = "1" + override val osSdkVersion: Int = 1 + override val brand: String = "brand" + override val model: String = "model" + override val device: String = "device" + override val manufacturer: String = "manufacturer" +} diff --git a/app/network/network-clients/src/nativeMain/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProviders.native.kt b/app/network/network-clients/src/nativeMain/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProviders.native.kt index 38be0aeaee..ee8c1f8902 100644 --- a/app/network/network-clients/src/nativeMain/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProviders.native.kt +++ b/app/network/network-clients/src/nativeMain/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProviders.native.kt @@ -5,6 +5,7 @@ import com.apollographql.cache.normalized.api.NormalizedCacheFactory import com.hedvig.android.core.buildconstants.HedvigBuildConstants import com.hedvig.android.core.common.di.AppScope import com.hedvig.android.network.clients.ExtraKtorClientConfiguration +import com.hedvig.android.network.clients.NetworkLogPolicy import com.hedvig.android.network.clients.NoopExtraKtorClientConfiguration import dev.zacsweers.metro.ContributesTo import dev.zacsweers.metro.Provides @@ -29,7 +30,14 @@ interface NativeNetworkMetroProviders { normalizedCacheFactory: NormalizedCacheFactory, httpClient: HttpClient, hedvigBuildConstants: HedvigBuildConstants, - ): ApolloClient = buildHedvigApolloClient(normalizedCacheFactory, httpClient, hedvigBuildConstants, emptyList()) + networkLogPolicy: NetworkLogPolicy, + ): ApolloClient = buildHedvigApolloClient( + normalizedCacheFactory, + httpClient, + hedvigBuildConstants, + emptyList(), + networkLogPolicy, + ) } internal actual fun httpClientEngineFactory(): HttpClientEngineFactory<*> = Darwin diff --git a/app/network/network-clients/src/nativeTest/kotlin/com/hedvig/android/network/clients/di/NativeApolloClientTest.kt b/app/network/network-clients/src/nativeTest/kotlin/com/hedvig/android/network/clients/di/NativeApolloClientTest.kt index 0e3073037c..18fc1161ad 100644 --- a/app/network/network-clients/src/nativeTest/kotlin/com/hedvig/android/network/clients/di/NativeApolloClientTest.kt +++ b/app/network/network-clients/src/nativeTest/kotlin/com/hedvig/android/network/clients/di/NativeApolloClientTest.kt @@ -2,6 +2,7 @@ package com.hedvig.android.network.clients.di import com.apollographql.cache.normalized.memory.MemoryCacheFactory import com.hedvig.android.core.buildconstants.HedvigBuildConstants +import com.hedvig.android.network.clients.NetworkLogPolicy import io.ktor.client.HttpClient import io.ktor.client.engine.darwin.Darwin import kotlin.test.Test @@ -15,6 +16,7 @@ class NativeApolloClientTest { normalizedCacheFactory = MemoryCacheFactory(), httpClient = httpClient, hedvigBuildConstants = FakeHedvigBuildConstants, + networkLogPolicy = NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = false), ) assertEquals(listOf("LoggingInterceptor"), apolloClient.interceptors.map { it::class.simpleName }) From 1c65abf260144488ee4e5edc751b6c5dab2d90e6 Mon Sep 17 00:00:00 2001 From: stylianosgakis Date: Thu, 19 Nov 2026 16:52:38 +0100 Subject: [PATCH 3/5] Give GraphQL error text its own switch in the network log policy GraphQL error messages, the errors with their extensions, the response extensions and exception messages can quote what was sent, an email or an address, so they are not the same decision as the response data. With logsGraphqlErrors off, the error line and the RUM error carry the operation name, the error count and the error types, and the exception line the exception class. Android and desktop log both in every build, so their output is unchanged; the iOS app chooses. This keeps PR 3405's intent intact if it lands after this: it sets logsGraphqlData to !isProduction, and production keeps error messages. (after commit edee0223e5189f91e5406c6ed5afb5e75ec88b0e, which dropped the error text together with the data; rewritten as a separate switch) --- .../network/clients/NetworkLogPolicy.kt | 7 +++-- .../clients/apollo/LoggingInterceptor.kt | 24 +++++++++++---- .../network/clients/NetworkLogPolicyTest.kt | 30 ++++++++++++++++--- .../clients/di/ApolloClientMetroProviders.kt | 3 +- .../clients/apollo/ApolloInterceptorsTest.kt | 2 +- .../clients/di/JvmNetworkLogPolicyTest.kt | 14 ++++----- .../clients/di/NativeApolloClientTest.kt | 2 +- 7 files changed, 60 insertions(+), 22 deletions(-) diff --git a/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/NetworkLogPolicy.kt b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/NetworkLogPolicy.kt index bc0d3c83ef..18e3e1ca80 100644 --- a/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/NetworkLogPolicy.kt +++ b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/NetworkLogPolicy.kt @@ -1,12 +1,15 @@ package com.hedvig.android.network.clients /** - * What the network clients log beyond GraphQL operation names, error messages, error extensions and exceptions. + * What the network clients log beyond GraphQL operation names, error counts, error types and exception classes. * * [logsHttpBodies] logs every HTTP request and response with its body. [logsGraphqlData] adds the GraphQL response - * data to the GraphQL log lines and to the attributes of the RUM error a GraphQL error reports. + * data to the GraphQL log lines and to the attributes of the RUM error a GraphQL error reports. [logsGraphqlErrors] + * adds the GraphQL error messages, the errors with their extensions and the response extensions, and exception + * messages; they can quote what was sent, so they have their own switch. */ class NetworkLogPolicy( val logsHttpBodies: Boolean, val logsGraphqlData: Boolean, + val logsGraphqlErrors: Boolean, ) diff --git a/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptor.kt b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptor.kt index 39c2bbfb58..0eb12281fb 100644 --- a/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptor.kt +++ b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptor.kt @@ -56,7 +56,12 @@ internal class LoggingInterceptor( } if (response.exception != null && response.exception !is CacheMissException) { logcat(LogPriority.WARN) { - "GraphQL exception for ${request.operation.name()}: ${response.exception}" + val exception = response.exception!! + if (networkLogPolicy.logsGraphqlErrors) { + "GraphQL exception for ${request.operation.name()}: $exception" + } else { + "GraphQL exception for ${request.operation.name()}: ${exception::class.simpleName}" + } } } }.onCompletion { @@ -70,15 +75,22 @@ internal class LoggingInterceptor( request: ApolloRequest, response: ApolloResponse, ) { - val errorMessagesJoinedToString = errors.joinToString(", ", "[", "]") { it.message } - val errorMessage = "GraphQL errors for ${request.operation.name()}: $errorMessagesJoinedToString" + val errorMessage = if (networkLogPolicy.logsGraphqlErrors) { + val errorMessagesJoinedToString = errors.joinToString(", ", "[", "]") { it.message } + "GraphQL errors for ${request.operation.name()}: $errorMessagesJoinedToString" + } else { + val errorTypes = errors.map { it.extensions.errorType?.value } + "GraphQL errors for ${request.operation.name()}: ${errors.size} (error types $errorTypes)" + } val errorAttributes = buildMap { if (networkLogPolicy.logsGraphqlData) { put("data", response.data) } - put("errors", errors) - if (response.extensions.isNotEmpty()) { - put("extensions", response.extensions.toList().joinToString(", ", "[", "]") { it.toString() }) + if (networkLogPolicy.logsGraphqlErrors) { + put("errors", errors) + if (response.extensions.isNotEmpty()) { + put("extensions", response.extensions.toList().joinToString(", ", "[", "]") { it.toString() }) + } } } logcat(LogPriority.ERROR) { diff --git a/app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogPolicyTest.kt b/app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogPolicyTest.kt index 23c9d6cf84..fdeee8554a 100644 --- a/app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogPolicyTest.kt +++ b/app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogPolicyTest.kt @@ -51,14 +51,14 @@ class NetworkLogPolicyTest { @Test fun `with HTTP bodies off no logged line carries a request or response body`() = runTest { - exchangeHttpBodies(NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = false)) + exchangeHttpBodies(NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = false, logsGraphqlErrors = true)) assertEquals(emptyList(), loggedSentinels()) } @Test fun `with HTTP bodies on the request and response bodies are logged`() = runTest { - exchangeHttpBodies(NetworkLogPolicy(logsHttpBodies = true, logsGraphqlData = false)) + exchangeHttpBodies(NetworkLogPolicy(logsHttpBodies = true, logsGraphqlData = false, logsGraphqlErrors = true)) assertEquals(listOf(REQUEST_BODY_SENTINEL, RESPONSE_BODY_SENTINEL), loggedSentinels()) } @@ -66,7 +66,7 @@ class NetworkLogPolicyTest { @Test fun `with GraphQL data off no logged line or RUM error carries response data and errors are still logged`() = runTest { - exchangeGraphql(NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = false)) + exchangeGraphql(NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = false, logsGraphqlErrors = true)) assertEquals(listOf(ERROR_EXTENSION_SENTINEL, RESPONSE_EXTENSION_SENTINEL), loggedSentinels()) assertEquals(listOf(ERROR_EXTENSION_SENTINEL, RESPONSE_EXTENSION_SENTINEL), rumSentinels()) @@ -78,7 +78,7 @@ class NetworkLogPolicyTest { @Test fun `with GraphQL data on the response data and extensions are logged and reported`() = runTest { - exchangeGraphql(NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = true)) + exchangeGraphql(NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = true, logsGraphqlErrors = true)) assertEquals( listOf(DATA_SENTINEL, ERROR_EXTENSION_SENTINEL, RESPONSE_EXTENSION_SENTINEL), @@ -87,6 +87,28 @@ class NetworkLogPolicyTest { assertEquals(listOf(DATA_SENTINEL, ERROR_EXTENSION_SENTINEL, RESPONSE_EXTENSION_SENTINEL), rumSentinels()) } + @Test + fun `with GraphQL data and errors off no logged line or RUM error carries data or error text or extensions`() = + runTest { + exchangeGraphql(NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = false, logsGraphqlErrors = false)) + + assertEquals(emptyList(), loggedSentinels()) + assertEquals(emptyList(), rumSentinels()) + val messages = logs.entries().map { it.message } + assertTrue("GraphQL request for Sentinel EMISSION." in messages, "$messages") + assertTrue( + "GraphQL errors for Sentinel: 1 (error types [null]) attributes: {} There was data and errors at the same time!" + in messages, + "$messages", + ) + assertTrue("GraphQL exception for Sentinel: ApolloNetworkException" in messages, "$messages") + assertEquals(emptyList(), messages.filter { "Something failed" in it || "queued in" in it }) + assertEquals( + listOf("GraphQL errors for Sentinel: 1 (error types [null])" to emptyMap()), + rum.errors().map { it.message to it.attributes }, + ) + } + private suspend fun exchangeHttpBodies(networkLogPolicy: NetworkLogPolicy) { val engine = mockEngineFactory { respond( diff --git a/app/network/network-clients/src/jvmAndAndroidMain/kotlin/com/hedvig/android/network/clients/di/ApolloClientMetroProviders.kt b/app/network/network-clients/src/jvmAndAndroidMain/kotlin/com/hedvig/android/network/clients/di/ApolloClientMetroProviders.kt index 0947b61178..582d33a818 100644 --- a/app/network/network-clients/src/jvmAndAndroidMain/kotlin/com/hedvig/android/network/clients/di/ApolloClientMetroProviders.kt +++ b/app/network/network-clients/src/jvmAndAndroidMain/kotlin/com/hedvig/android/network/clients/di/ApolloClientMetroProviders.kt @@ -34,11 +34,12 @@ interface ApolloClientMetroProviders { networkLogPolicy, ) - /** HTTP bodies are logged outside production builds, GraphQL data in every build. */ + /** HTTP bodies are logged outside production builds, GraphQL data and errors in every build. */ @Provides fun provideNetworkLogPolicy(hedvigBuildConstants: HedvigBuildConstants): NetworkLogPolicy = NetworkLogPolicy( logsHttpBodies = !hedvigBuildConstants.isProduction, logsGraphqlData = true, + logsGraphqlErrors = true, ) } diff --git a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/ApolloInterceptorsTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/ApolloInterceptorsTest.kt index 66608da68a..8fb328a210 100644 --- a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/ApolloInterceptorsTest.kt +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/ApolloInterceptorsTest.kt @@ -93,7 +93,7 @@ internal class ApolloInterceptorsTest { .networkTransport(QueueTestNetworkTransport()) .addHedvigInterceptors( apolloPlatformInterceptors(authTokenService, FakeDemoManager(isDemoMode)), - NetworkLogPolicy(logsHttpBodies = true, logsGraphqlData = true), + NetworkLogPolicy(logsHttpBodies = true, logsGraphqlData = true, logsGraphqlErrors = true), ) .build() } diff --git a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkLogPolicyTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkLogPolicyTest.kt index 3a24d12e4e..96a40bfc23 100644 --- a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkLogPolicyTest.kt +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/JvmNetworkLogPolicyTest.kt @@ -29,12 +29,12 @@ class JvmNetworkLogPolicyTest { } @Test - fun `HTTP bodies are logged outside production builds and GraphQL data in every build`() { + fun `HTTP bodies are logged outside production builds and GraphQL data and errors in every build`() { val provided = buildConfigs.mapValues { (_, appBuildConfig) -> val dataDirectory = createTempDirectory("network-log-policy-test").toFile() try { createGraphFactory().create(dataDirectory, appBuildConfig).networkLogPolicy - .let { it.logsHttpBodies to it.logsGraphqlData } + .let { listOf(it.logsHttpBodies, it.logsGraphqlData, it.logsGraphqlErrors) } } finally { dataDirectory.deleteRecursively() } @@ -42,11 +42,11 @@ class JvmNetworkLogPolicyTest { assertEquals( mapOf( - "Android debug" to (true to true), - "Android staging" to (true to true), - "Android release" to (false to true), - "desktop staging" to (true to true), - "desktop production" to (false to true), + "Android debug" to listOf(true, true, true), + "Android staging" to listOf(true, true, true), + "Android release" to listOf(false, true, true), + "desktop staging" to listOf(true, true, true), + "desktop production" to listOf(false, true, true), ), provided, ) diff --git a/app/network/network-clients/src/nativeTest/kotlin/com/hedvig/android/network/clients/di/NativeApolloClientTest.kt b/app/network/network-clients/src/nativeTest/kotlin/com/hedvig/android/network/clients/di/NativeApolloClientTest.kt index 18fc1161ad..5ffa074c93 100644 --- a/app/network/network-clients/src/nativeTest/kotlin/com/hedvig/android/network/clients/di/NativeApolloClientTest.kt +++ b/app/network/network-clients/src/nativeTest/kotlin/com/hedvig/android/network/clients/di/NativeApolloClientTest.kt @@ -16,7 +16,7 @@ class NativeApolloClientTest { normalizedCacheFactory = MemoryCacheFactory(), httpClient = httpClient, hedvigBuildConstants = FakeHedvigBuildConstants, - networkLogPolicy = NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = false), + networkLogPolicy = NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = false, logsGraphqlErrors = true), ) assertEquals(listOf("LoggingInterceptor"), apolloClient.interceptors.map { it::class.simpleName }) From b5bb356538519c5fcce37b1f4747d25d6b1fa460 Mon Sep 17 00:00:00 2001 From: stylianosgakis Date: Thu, 19 Nov 2026 15:04:13 +0100 Subject: [PATCH 4/5] Let the iOS app take Kotlin's log lines through its own sink with a minimum priority On iOS every Kotlin log line went to NSLog, which the iOS app neither sees nor forwards. IosLogSink is a one-method interface the iOS app implements, for example by forwarding to its own logger, and IosLogcatLogger.install(sink:minimumPriority:) installs it: lines below the minimum are dropped without building their message, and a throwable is named by its class only, since its message can quote what was sent. The sink replaces a logger installed before it in one step through the new LogcatLogger.replace, so no line is lost and no warning is logged. install() keeps writing everything to NSLog for the app that calls it today. installFallback, hidden from Swift, installs NSLog at a minimum only when nothing is installed, so shared code never logs into the no-op logger, which throws. (the minimum priority and its tests are cherry-picked from commit 623dd1ca04deefaf01428663ac28e115402ceccb with edits: install() keeps its signature and the test host hunk is dropped) --- .../com/hedvig/android/logger/LogcatLogger.kt | 11 +++ .../hedvig/android/logger/IosLogcatLogger.kt | 83 ++++++++++++++--- .../android/logger/IosLogcatLoggerTest.kt | 90 +++++++++++++++++++ 3 files changed, 170 insertions(+), 14 deletions(-) create mode 100644 app/logging/logging-public/src/nativeTest/kotlin/com/hedvig/android/logger/IosLogcatLoggerTest.kt diff --git a/app/logging/logging-public/src/commonMain/kotlin/com/hedvig/android/logger/LogcatLogger.kt b/app/logging/logging-public/src/commonMain/kotlin/com/hedvig/android/logger/LogcatLogger.kt index 25b113083d..2579ca7ce9 100644 --- a/app/logging/logging-public/src/commonMain/kotlin/com/hedvig/android/logger/LogcatLogger.kt +++ b/app/logging/logging-public/src/commonMain/kotlin/com/hedvig/android/logger/LogcatLogger.kt @@ -44,6 +44,17 @@ interface LogcatLogger { } } + /** + * Installs [logger] in place of the current one, if any, in one step, so no line is lost or reaches the no-op + * logger in between. For a host that installs a better logger once it can. + */ + fun replace(logger: LogcatLogger) { + synchronized(this) { + installedThrowable = RuntimeException("Previous logger installed here") + this.logger = logger + } + } + /** * Replaces the current logger (if any) with a no-op logger. */ diff --git a/app/logging/logging-public/src/nativeMain/kotlin/com/hedvig/android/logger/IosLogcatLogger.kt b/app/logging/logging-public/src/nativeMain/kotlin/com/hedvig/android/logger/IosLogcatLogger.kt index 279252ac08..4589ac1ffd 100644 --- a/app/logging/logging-public/src/nativeMain/kotlin/com/hedvig/android/logger/IosLogcatLogger.kt +++ b/app/logging/logging-public/src/nativeMain/kotlin/com/hedvig/android/logger/IosLogcatLogger.kt @@ -1,28 +1,83 @@ +@file:OptIn(ExperimentalObjCRefinement::class) + package com.hedvig.android.logger +import kotlin.experimental.ExperimentalObjCRefinement +import kotlin.native.HiddenFromObjC import platform.Foundation.NSLog -class IosLogcatLogger : LogcatLogger { +/** + * Where the iOS app takes Kotlin's log lines, for example to forward them to its own logger. Implemented in Swift and + * installed with [IosLogcatLogger.Companion.install]. Called on whichever thread logged the line. + */ +interface IosLogSink { + /** + * One line at [priority] from [tag]. A throwable logged with the line is named by its class only, since its message + * can quote what was sent. + */ + fun log(priority: LogPriority, tag: String?, message: String) +} + +/** Writes every line at [minimumPriority] or above to [write], and drops the rest without building their message. */ +class IosLogcatLogger internal constructor( + private val minimumPriority: LogPriority, + private val write: (priority: LogPriority, tag: String?, message: String) -> Unit, +) : LogcatLogger { override fun log(priority: LogPriority, throwable: Throwable?, tag: String?, message: () -> String) { - val prefix = when (priority) { - LogPriority.VERBOSE -> "V" - LogPriority.DEBUG -> "D" - LogPriority.INFO -> "I" - LogPriority.WARN -> "W" - LogPriority.ERROR -> "E" - LogPriority.ASSERT -> "A" - } - val tagPart = if (tag != null) "[$tag] " else "" - val messagePart = message() - val throwablePart = if (throwable != null) "\n${throwable.stackTraceToString()}" else "" - NSLog("%s", "$prefix/$tagPart$messagePart$throwablePart") + if (priority < minimumPriority) return + val throwablePart = if (throwable != null) " (${throwable::class.simpleName})" else "" + write(priority, tag, message() + throwablePart) } companion object { + /** Installs a logger writing every line, with its stack trace, to `NSLog`, unless a logger is installed. */ fun install() { if (!LogcatLogger.isInstalled) { - LogcatLogger.install(IosLogcatLogger()) + LogcatLogger.install(NSLogLogger) } } + + /** + * Sends every line at [minimumPriority] or above to [sink], replacing the logger installed before, if any. Call it + * before anything else in Kotlin logs, so no line goes to `NSLog` instead. + */ + fun install(sink: IosLogSink, minimumPriority: LogPriority) { + LogcatLogger.replace(IosLogcatLogger(minimumPriority, sink::log)) + } + + /** + * Installs a logger writing lines at [minimumPriority] or above to `NSLog`, unless a logger is installed. For Kotlin + * code that must not log into the void when the iOS app installed nothing. + */ + @HiddenFromObjC + fun installFallback(minimumPriority: LogPriority) { + if (!LogcatLogger.isInstalled) { + LogcatLogger.install( + IosLogcatLogger(minimumPriority) { priority, tag, message -> + nsLog(priority, tag, message) + }, + ) + } + } + } +} + +private object NSLogLogger : LogcatLogger { + override fun log(priority: LogPriority, throwable: Throwable?, tag: String?, message: () -> String) { + val throwablePart = if (throwable != null) "\n${throwable.stackTraceToString()}" else "" + nsLog(priority, tag, message() + throwablePart) + } +} + +private fun nsLog(priority: LogPriority, tag: String?, message: String) { + val prefix = when (priority) { + LogPriority.VERBOSE -> "V" + LogPriority.DEBUG -> "D" + LogPriority.INFO -> "I" + LogPriority.WARN -> "W" + LogPriority.ERROR -> "E" + LogPriority.ASSERT -> "A" } + val tagPart = if (tag != null) "[$tag] " else "" + NSLog("%s", "$prefix/$tagPart$message") } diff --git a/app/logging/logging-public/src/nativeTest/kotlin/com/hedvig/android/logger/IosLogcatLoggerTest.kt b/app/logging/logging-public/src/nativeTest/kotlin/com/hedvig/android/logger/IosLogcatLoggerTest.kt new file mode 100644 index 0000000000..03eeb80d2e --- /dev/null +++ b/app/logging/logging-public/src/nativeTest/kotlin/com/hedvig/android/logger/IosLogcatLoggerTest.kt @@ -0,0 +1,90 @@ +package com.hedvig.android.logger + +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +class IosLogcatLoggerTest { + @AfterTest + fun uninstall() { + LogcatLogger.uninstall() + } + + @Test + fun `a WARN minimum drops lower priorities without building their message and keeps WARN and above`() { + val written = mutableListOf() + val built = mutableListOf() + val logger = IosLogcatLogger(LogPriority.WARN) { priority, tag, message -> written += "$priority $tag $message" } + + for (priority in LogPriority.entries) { + logger.log(priority, null, "Tag") { + built += priority + priority.name + } + } + + assertEquals(listOf(LogPriority.WARN, LogPriority.ERROR, LogPriority.ASSERT), built) + assertEquals(listOf("WARN Tag WARN", "ERROR Tag ERROR", "ASSERT Tag ASSERT"), written) + } + + @Test + fun `a VERBOSE minimum keeps every priority`() { + val written = mutableListOf() + val logger = IosLogcatLogger(LogPriority.VERBOSE) { priority, _, _ -> written += priority } + + for (priority in LogPriority.entries) { + logger.log(priority, null, null) { priority.name } + } + + assertEquals(LogPriority.entries.toList(), written.toList()) + } + + @Test + fun `a throwable reaches the sink as its class name only`() { + val sink = RecordingSink() + IosLogcatLogger.install(sink, LogPriority.VERBOSE) + + logcat(LogPriority.ERROR, IllegalStateException("member-sentinel-7a1d"), tag = "Tag") { "Failed" } + + assertEquals(listOf("ERROR Tag Failed (IllegalStateException)"), sink.lines) + } + + @Test + fun `the sink replaces a logger installed before it without a warning line`() { + IosLogcatLogger.install() + val sink = RecordingSink() + + IosLogcatLogger.install(sink, LogPriority.INFO) + logcat(LogPriority.INFO) { "After" } + logcat(LogPriority.DEBUG) { "Dropped" } + + assertEquals(listOf("INFO null After"), sink.lines) + } + + @Test + fun `the fallback does not replace the sink`() { + val sink = RecordingSink() + IosLogcatLogger.install(sink, LogPriority.VERBOSE) + + IosLogcatLogger.installFallback(LogPriority.WARN) + logcat(LogPriority.INFO) { "Still the sink" } + + assertEquals(listOf("INFO null Still the sink"), sink.lines) + } + + @Test + fun `the fallback installs a logger when there is none`() { + IosLogcatLogger.installFallback(LogPriority.WARN) + + assertTrue(LogcatLogger.isInstalled) + } + + private class RecordingSink : IosLogSink { + val lines = mutableListOf() + + override fun log(priority: LogPriority, tag: String?, message: String) { + lines += "$priority $tag $message" + } + } +} From ac6cabe9236d9903e2420f2f68930eda51fde76e Mon Sep 17 00:00:00 2001 From: stylianosgakis Date: Thu, 19 Nov 2026 19:11:49 +0100 Subject: [PATCH 5/5] Export LogPriority to Swift as an Objective-C enum The iOS app's log sink receives a LogPriority. With @ObjCEnum Swift gets an nsEnum it can switch over by case instead of comparing Kotlin enum objects. The annotation is an optional expectation, so the JVM and Android outputs are unchanged. --- .../kotlin/com/hedvig/android/logger/LogPriority.kt | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/app/logging/logging-public/src/commonMain/kotlin/com/hedvig/android/logger/LogPriority.kt b/app/logging/logging-public/src/commonMain/kotlin/com/hedvig/android/logger/LogPriority.kt index 84d99d28cb..d865fcc82d 100644 --- a/app/logging/logging-public/src/commonMain/kotlin/com/hedvig/android/logger/LogPriority.kt +++ b/app/logging/logging-public/src/commonMain/kotlin/com/hedvig/android/logger/LogPriority.kt @@ -1,9 +1,15 @@ +@file:OptIn(ExperimentalObjCEnum::class) + package com.hedvig.android.logger +import kotlin.experimental.ExperimentalObjCEnum +import kotlin.native.ObjCEnum + /** * An enum for log priorities that map to [android.util.Log] priority constants * without a direct import. */ +@ObjCEnum enum class LogPriority { VERBOSE, DEBUG,