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, 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" + } + } +} diff --git a/app/network/network-clients/build.gradle.kts b/app/network/network-clients/build.gradle.kts index b519a71b0b..873e9f7625 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/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..4498e9ab1d --- /dev/null +++ b/app/network/network-clients/src/commonMain/kotlin/com/hedvig/android/network/clients/NetworkLogPolicy.kt @@ -0,0 +1,16 @@ +package com.hedvig.android.network.clients + +/** + * 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 the response data and operation variables 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 cf133732ac..551ccc5e99 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 @@ -18,6 +18,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 @@ -29,13 +30,13 @@ import kotlinx.coroutines.flow.onEach */ internal fun ApolloClient.Builder.addHedvigInterceptors( platformInterceptors: List, - logMemberData: Boolean, + networkLogPolicy: NetworkLogPolicy, ): ApolloClient.Builder = this .apply { platformInterceptors.forEach(::addInterceptor) } - .addInterceptor(LoggingInterceptor(logMemberData)) + .addInterceptor(LoggingInterceptor(networkLogPolicy)) internal class LoggingInterceptor( - private val logMemberData: Boolean, + private val networkLogPolicy: NetworkLogPolicy, ) : ApolloInterceptor { override fun intercept( request: ApolloRequest, @@ -44,8 +45,11 @@ internal class LoggingInterceptor( logcat(LogPriority.DEBUG) { "GraphQL request for ${request.operation.name()} START." } return chain.proceed(request).onEach { response -> logcat(LogPriority.DEBUG) { - val responseData = if (logMemberData) " Response data: ${response.data}" else "" - "GraphQL request for ${request.operation.name()} EMISSION.$responseData" + 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() } @@ -54,7 +58,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 { @@ -68,16 +77,23 @@ 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 (logMemberData) { + if (networkLogPolicy.logsGraphqlData) { put("data", response.data) put("variables", request.variablesForLog()) } - 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) { @@ -87,7 +103,7 @@ internal class LoggingInterceptor( append(errorAttributes) if (data != null) { append(" There was data and errors at the same time!") - if (logMemberData) { + 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 aa0cec2d29..9eb434feaa 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,21 +82,23 @@ 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, logMemberData = !hedvigBuildConstants.isProduction) + .addHedvigInterceptors(platformInterceptors, networkLogPolicy) .build() } internal fun buildKtorClient( + engineFactory: HttpClientEngineFactory<*>, hedvigBuildConstants: HedvigBuildConstants, languageService: LanguageService, deviceIdFetcher: DeviceIdFetcher, extraKtorClientConfiguration: ExtraKtorClientConfiguration, - engineFactory: HttpClientEngineFactory<*> = httpClientEngineFactory(), + networkLogPolicy: NetworkLogPolicy, ): HttpClient { return HttpClient(engineFactory) { installDatadogKtorPlugin(hedvigBuildConstants) @@ -98,7 +109,7 @@ internal 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..fdeee8554a --- /dev/null +++ b/app/network/network-clients/src/commonTest/kotlin/com/hedvig/android/network/clients/NetworkLogPolicyTest.kt @@ -0,0 +1,174 @@ +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, 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, logsGraphqlErrors = true)) + + 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, logsGraphqlErrors = true)) + + 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, logsGraphqlErrors = true)) + + assertEquals( + listOf(DATA_SENTINEL, ERROR_EXTENSION_SENTINEL, RESPONSE_EXTENSION_SENTINEL), + loggedSentinels(), + ) + 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( + 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/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/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..adab7e4745 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,21 @@ interface ApolloClientMetroProviders { normalizedCacheFactory: NormalizedCacheFactory, httpClient: HttpClient, hedvigBuildConstants: HedvigBuildConstants, + networkLogPolicy: NetworkLogPolicy, ): ApolloClient = buildHedvigApolloClient( normalizedCacheFactory, httpClient, hedvigBuildConstants, apolloPlatformInterceptors(authTokenService, demoManager), + networkLogPolicy, + ) + + /** HTTP bodies and GraphQL data are logged outside production builds, GraphQL errors in every build. */ + @Provides + fun provideNetworkLogPolicy(hedvigBuildConstants: HedvigBuildConstants): NetworkLogPolicy = NetworkLogPolicy( + logsHttpBodies = !hedvigBuildConstants.isProduction, + logsGraphqlData = !hedvigBuildConstants.isProduction, + 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 0772b5e132..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 @@ -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 @@ -92,7 +93,7 @@ internal class ApolloInterceptorsTest { .networkTransport(QueueTestNetworkTransport()) .addHedvigInterceptors( apolloPlatformInterceptors(authTokenService, FakeDemoManager(isDemoMode)), - logMemberData = false, + NetworkLogPolicy(logsHttpBodies = true, logsGraphqlData = true, logsGraphqlErrors = 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 new file mode 100644 index 0000000000..6c3e96efe5 --- /dev/null +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptorOutputTest.kt @@ -0,0 +1,148 @@ +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.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, with the policy those platforms provide for + * a non-production and a production build. + */ +@OptIn(ApolloExperimental::class) +class LoggingInterceptorOutputTest { + @Test + fun `a success response logs its data at DEBUG outside production`() { + val runs = runForEachProvidedPolicy { apolloClient -> + apolloClient.enqueueTestResponse(SentinelQuery, SentinelQuery.Data("data-sentinel")) + apolloClient.query(SentinelQuery).execute() + } + + for ((isProduction, run) in runs) { + val emission = if (isProduction) "" else " Response data: Data(value=data-sentinel)" + assertThat(run.logs).containsExactly( + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel START."), + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel EMISSION.$emission"), + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel END."), + ) + assertThat(run.rumErrors).isEmpty() + } + } + + @Test + fun `a GraphQL error logs errors and extensions at ERROR and to RUM, and data and variables outside production`() { + 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}))]" + for ((isProduction, run) in runs) { + val attributes = if (isProduction) { + "{errors=$errors, extensions=[(trace, response-extension-sentinel)]}" + } else { + "{data=Data(value=data-sentinel), variables={}, errors=$errors, extensions=[(trace, response-extension-sentinel)]}" + } + val emission = if (isProduction) "" else " Response data: Data(value=data-sentinel)" + val dataSuffix = if (isProduction) "" else " Data:Data(value=data-sentinel)" + assertThat(run.logs).containsExactly( + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel START."), + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel EMISSION.$emission"), + CapturedLog( + LogPriority.ERROR, + null, + "GraphQL errors for Sentinel: [Something failed] attributes: $attributes" + + " There was data and errors at the same time!$dataSuffix", + ), + 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 ((isProduction, run) in runs) { + val emission = if (isProduction) "" else " Response data: null" + assertThat(run.logs).containsExactly( + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel START."), + CapturedLog(LogPriority.DEBUG, null, "GraphQL request for Sentinel EMISSION.$emission"), + 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 once per provided policy, for a non-production and a production build, keyed by + * whether the build is a production one. + */ +private fun runForEachProvidedPolicy(block: suspend (ApolloClient) -> Unit): Map { + return listOf(false, true).associateWith { 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/apollo/LoggingInterceptorTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptorTest.kt index c47c1085d9..2ed93b7272 100644 --- a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptorTest.kt +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/apollo/LoggingInterceptorTest.kt @@ -19,6 +19,7 @@ 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.NetworkLogPolicy import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.flowOf import kotlinx.coroutines.flow.toList @@ -115,7 +116,12 @@ class LoggingInterceptorTest { return flowOf(response as ApolloResponse) } } - LoggingInterceptor(logMemberData).intercept(request, chain).toList() + val networkLogPolicy = NetworkLogPolicy( + logsHttpBodies = logMemberData, + logsGraphqlData = logMemberData, + logsGraphqlErrors = true, + ) + LoggingInterceptor(networkLogPolicy).intercept(request, chain).toList() } private object FakeQuery : Operation { 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..7b22f39c20 --- /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 and GraphQL data are logged outside production builds and GraphQL errors in every build`() { + val provided = buildConfigs.mapValues { (_, appBuildConfig) -> + val dataDirectory = createTempDirectory("network-log-policy-test").toFile() + try { + createGraphFactory().create(dataDirectory, appBuildConfig).networkLogPolicy + .let { listOf(it.logsHttpBodies, it.logsGraphqlData, it.logsGraphqlErrors) } + } finally { + dataDirectory.deleteRecursively() + } + } + + assertEquals( + mapOf( + "Android debug" to listOf(true, true, true), + "Android staging" to listOf(true, true, true), + "Android release" to listOf(false, false, true), + "desktop staging" to listOf(true, true, true), + "desktop production" to listOf(false, false, 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/jvmTest/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProvidersTest.kt b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProvidersTest.kt index c95ae44ae4..f06fb61798 100644 --- a/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProvidersTest.kt +++ b/app/network/network-clients/src/jvmTest/kotlin/com/hedvig/android/network/clients/di/NetworkMetroProvidersTest.kt @@ -8,6 +8,7 @@ import com.hedvig.android.core.datastore.DeviceIdFetcher import com.hedvig.android.language.Language import com.hedvig.android.language.LanguageService import com.hedvig.android.network.clients.AccessTokenFetcher +import com.hedvig.android.network.clients.NetworkLogPolicy import com.hedvig.android.network.clients.NoopExtraKtorClientConfiguration import io.ktor.client.HttpClient import io.ktor.client.engine.HttpClientEngine @@ -63,6 +64,7 @@ class NetworkMetroProvidersTest { engineFactory = object : HttpClientEngineFactory { override fun create(block: HttpClientEngineConfig.() -> Unit): HttpClientEngine = engine }, + networkLogPolicy = NetworkLogPolicy(logsHttpBodies = false, logsGraphqlData = false, logsGraphqlErrors = true), ) return object : NetworkMetroProviders {}.provideHttpClient(baseHttpClient, accessTokenFetcher) } 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..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 @@ -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, logsGraphqlErrors = true), ) assertEquals(listOf("LoggingInterceptor"), apolloClient.interceptors.map { it::class.simpleName })