From 920c38d838a0f7cb98b66f9ef49da0066f1f4c63 Mon Sep 17 00:00:00 2001 From: Jamie Lynch Date: Tue, 12 Mar 2024 12:03:43 +0000 Subject: [PATCH] refactor: alter signatures on payload factory --- .../embracesdk/injection/SessionModule.kt | 2 +- .../session/message/PayloadFactory.kt | 46 +++----- .../session/message/PayloadFactoryImpl.kt | 109 +++++++++++++----- .../orchestrator/SessionOrchestratorImpl.kt | 46 +++----- .../android/embracesdk/FakePayloadFactory.kt | 70 +++++++++-- .../session/PayloadFactoryBaTest.kt | 16 ++- .../session/PayloadFactorySessionTest.kt | 5 +- .../embracesdk/session/SessionHandlerTest.kt | 37 ++++-- .../orchestrator/SessionOrchestratorTest.kt | 11 -- 9 files changed, 207 insertions(+), 135 deletions(-) diff --git a/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/injection/SessionModule.kt b/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/injection/SessionModule.kt index 5ccac7946..87288c99b 100644 --- a/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/injection/SessionModule.kt +++ b/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/injection/SessionModule.kt @@ -89,7 +89,7 @@ internal class SessionModuleImpl( } override val payloadFactory: PayloadFactory by singleton { - PayloadFactoryImpl(payloadMessageCollator) + PayloadFactoryImpl(payloadMessageCollator, essentialServiceModule.configService) } private val boundaryDelegate by singleton { diff --git a/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/message/PayloadFactory.kt b/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/message/PayloadFactory.kt index 547690361..90114bc42 100644 --- a/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/message/PayloadFactory.kt +++ b/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/message/PayloadFactory.kt @@ -2,6 +2,7 @@ package io.embrace.android.embracesdk.session.message import io.embrace.android.embracesdk.payload.Session import io.embrace.android.embracesdk.payload.SessionMessage +import io.embrace.android.embracesdk.session.lifecycle.ProcessState /** * Factory that creates session + background activity payloads. @@ -11,50 +12,35 @@ internal interface PayloadFactory { /** * Starts a session in response to a state event. */ - fun startSessionWithState(timestamp: Long, coldStart: Boolean): Session - - /** - * Starts a session manually. - */ - fun startSessionWithManual(timestamp: Long): Session - - /** - * Ends a background activity in response to a state event. - */ - fun startBackgroundActivityWithState(timestamp: Long, coldStart: Boolean): Session - - /** - * Handles an uncaught exception, ending the session and saving the activity to disk. - */ - fun endBackgroundActivityWithCrash(initial: Session, timestamp: Long, crashId: String): SessionMessage - - /** - * Starts a background activity in response to a state event. - */ - fun endBackgroundActivityWithState(initial: Session, timestamp: Long): SessionMessage + fun startPayloadWithState(state: ProcessState, timestamp: Long, coldStart: Boolean): Session? /** * Ends a session in response to a state event. */ - fun endSessionWithState(initial: Session, timestamp: Long): SessionMessage + fun endPayloadWithState(state: ProcessState, timestamp: Long, initial: Session): SessionMessage? /** - * Ends a session manually. + * Handles an uncaught exception, ending the session and saving the session to disk. */ - fun endSessionWithManual(initial: Session, timestamp: Long): SessionMessage + fun endPayloadWithCrash( + state: ProcessState, + timestamp: Long, + initial: Session, + crashId: String + ): SessionMessage? /** - * Handles an uncaught exception, ending the session and saving the session to disk. + * Provides a snapshot of the active session */ - fun endSessionWithCrash(initial: Session, timestamp: Long, crashId: String): SessionMessage + fun snapshotPayload(state: ProcessState, timestamp: Long, initial: Session): SessionMessage? /** - * Provides a snapshot of the active session + * Starts a session manually. */ - fun snapshotSession(initial: Session, timestamp: Long): SessionMessage? + fun startSessionWithManual(timestamp: Long): Session /** - * Provides a snapshot of the active background activity + * Ends a session manually. */ - fun snapshotBackgroundActivity(initial: Session, timestamp: Long): SessionMessage + fun endSessionWithManual(timestamp: Long, initial: Session): SessionMessage } diff --git a/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/message/PayloadFactoryImpl.kt b/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/message/PayloadFactoryImpl.kt index 4f4f0dfa2..a2b95d28a 100644 --- a/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/message/PayloadFactoryImpl.kt +++ b/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/message/PayloadFactoryImpl.kt @@ -1,35 +1,81 @@ package io.embrace.android.embracesdk.session.message +import io.embrace.android.embracesdk.config.ConfigService import io.embrace.android.embracesdk.payload.Session import io.embrace.android.embracesdk.payload.Session.LifeEventType import io.embrace.android.embracesdk.payload.SessionMessage +import io.embrace.android.embracesdk.session.lifecycle.ProcessState import io.embrace.android.embracesdk.session.orchestrator.SessionSnapshotType internal class PayloadFactoryImpl( - private val payloadMessageCollator: PayloadMessageCollator + private val payloadMessageCollator: PayloadMessageCollator, + private val configService: ConfigService ) : PayloadFactory { - override fun startSessionWithState(timestamp: Long, coldStart: Boolean): Session { + override fun startPayloadWithState(state: ProcessState, timestamp: Long, coldStart: Boolean) = + when (state) { + ProcessState.FOREGROUND -> startSessionWithState(timestamp, coldStart) + ProcessState.BACKGROUND -> startBackgroundActivityWithState(timestamp, coldStart) + } + + override fun endPayloadWithState(state: ProcessState, timestamp: Long, initial: Session) = + when (state) { + ProcessState.FOREGROUND -> endSessionWithState(initial, timestamp) + ProcessState.BACKGROUND -> endBackgroundActivityWithState(initial, timestamp) + } + + override fun endPayloadWithCrash( + state: ProcessState, + timestamp: Long, + initial: Session, + crashId: String + ) = when (state) { + ProcessState.FOREGROUND -> endSessionWithCrash(initial, timestamp, crashId) + ProcessState.BACKGROUND -> endBackgroundActivityWithCrash(initial, timestamp, crashId) + } + + override fun snapshotPayload(state: ProcessState, timestamp: Long, initial: Session) = + when (state) { + ProcessState.FOREGROUND -> snapshotSession(initial, timestamp) + ProcessState.BACKGROUND -> snapshotBackgroundActivity(initial, timestamp) + } + + override fun startSessionWithManual(timestamp: Long): Session { return payloadMessageCollator.buildInitialSession( InitialEnvelopeParams.SessionParams( - coldStart, - LifeEventType.STATE, + false, + LifeEventType.MANUAL, timestamp ) ) } - override fun startSessionWithManual(timestamp: Long): Session { + override fun endSessionWithManual(timestamp: Long, initial: Session): SessionMessage { + return payloadMessageCollator.buildFinalSessionMessage( + FinalEnvelopeParams.SessionParams( + initial = initial, + endTime = timestamp, + lifeEventType = LifeEventType.MANUAL, + endType = SessionSnapshotType.NORMAL_END + ) + ) + } + + private fun startSessionWithState(timestamp: Long, coldStart: Boolean): Session { return payloadMessageCollator.buildInitialSession( InitialEnvelopeParams.SessionParams( - false, - LifeEventType.MANUAL, + coldStart, + LifeEventType.STATE, timestamp ) ) } - override fun startBackgroundActivityWithState(timestamp: Long, coldStart: Boolean): Session { + private fun startBackgroundActivityWithState(timestamp: Long, coldStart: Boolean): Session? { + if (!configService.isBackgroundActivityCaptureEnabled()) { + return null + } + // kept for backwards compat. the backend expects the start time to be 1 ms greater // than the adjacent session, and manually adjusts. val time = when { @@ -45,7 +91,7 @@ internal class PayloadFactoryImpl( ) } - override fun endSessionWithState(initial: Session, timestamp: Long): SessionMessage { + private fun endSessionWithState(initial: Session, timestamp: Long): SessionMessage { return payloadMessageCollator.buildFinalSessionMessage( FinalEnvelopeParams.SessionParams( initial = initial, @@ -56,18 +102,23 @@ internal class PayloadFactoryImpl( ) } - override fun endSessionWithManual(initial: Session, timestamp: Long): SessionMessage { - return payloadMessageCollator.buildFinalSessionMessage( - FinalEnvelopeParams.SessionParams( + private fun endBackgroundActivityWithState(initial: Session, timestamp: Long): SessionMessage? { + if (!configService.isBackgroundActivityCaptureEnabled()) { + return null + } + + // kept for backwards compat. the backend expects the start time to be 1 ms greater + // than the adjacent session, and manually adjusts. + return payloadMessageCollator.buildFinalBackgroundActivityMessage( + FinalEnvelopeParams.BackgroundActivityParams( initial = initial, - endTime = timestamp, - lifeEventType = LifeEventType.MANUAL, - endType = SessionSnapshotType.NORMAL_END + endTime = timestamp - 1, + lifeEventType = LifeEventType.BKGND_STATE ) ) } - override fun endSessionWithCrash( + private fun endSessionWithCrash( initial: Session, timestamp: Long, crashId: String @@ -83,23 +134,14 @@ internal class PayloadFactoryImpl( ) } - override fun endBackgroundActivityWithState(initial: Session, timestamp: Long): SessionMessage { - // kept for backwards compat. the backend expects the start time to be 1 ms greater - // than the adjacent session, and manually adjusts. - return payloadMessageCollator.buildFinalBackgroundActivityMessage( - FinalEnvelopeParams.BackgroundActivityParams( - initial = initial, - endTime = timestamp - 1, - lifeEventType = LifeEventType.BKGND_STATE - ) - ) - } - - override fun endBackgroundActivityWithCrash( + private fun endBackgroundActivityWithCrash( initial: Session, timestamp: Long, crashId: String - ): SessionMessage { + ): SessionMessage? { + if (!configService.isBackgroundActivityCaptureEnabled()) { + return null + } return payloadMessageCollator.buildFinalBackgroundActivityMessage( FinalEnvelopeParams.BackgroundActivityParams( initial = initial, @@ -113,7 +155,7 @@ internal class PayloadFactoryImpl( /** * Called when the session is persisted every 2s to cache its state. */ - override fun snapshotSession(initial: Session, timestamp: Long): SessionMessage { + private fun snapshotSession(initial: Session, timestamp: Long): SessionMessage { return payloadMessageCollator.buildFinalSessionMessage( FinalEnvelopeParams.SessionParams( initial = initial, @@ -124,7 +166,10 @@ internal class PayloadFactoryImpl( ) } - override fun snapshotBackgroundActivity(initial: Session, timestamp: Long): SessionMessage { + private fun snapshotBackgroundActivity(initial: Session, timestamp: Long): SessionMessage? { + if (!configService.isBackgroundActivityCaptureEnabled()) { + return null + } return payloadMessageCollator.buildFinalBackgroundActivityMessage( FinalEnvelopeParams.BackgroundActivityParams( initial = initial, diff --git a/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/orchestrator/SessionOrchestratorImpl.kt b/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/orchestrator/SessionOrchestratorImpl.kt index 2ee1370e1..65ddc1857 100644 --- a/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/orchestrator/SessionOrchestratorImpl.kt +++ b/embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/orchestrator/SessionOrchestratorImpl.kt @@ -10,7 +10,6 @@ import io.embrace.android.embracesdk.logging.InternalEmbraceLogger import io.embrace.android.embracesdk.logging.InternalStaticEmbraceLogger import io.embrace.android.embracesdk.payload.Session import io.embrace.android.embracesdk.payload.SessionMessage -import io.embrace.android.embracesdk.session.ConfigGate import io.embrace.android.embracesdk.session.caching.PeriodicBackgroundActivityCacher import io.embrace.android.embracesdk.session.caching.PeriodicSessionCacher import io.embrace.android.embracesdk.session.id.SessionIdTracker @@ -19,7 +18,7 @@ import io.embrace.android.embracesdk.session.lifecycle.ProcessStateService import io.embrace.android.embracesdk.session.message.PayloadFactory internal class SessionOrchestratorImpl( - private val processStateService: ProcessStateService, + processStateService: ProcessStateService, private val payloadFactory: PayloadFactory, private val clock: Clock, private val configService: ConfigService, @@ -43,15 +42,8 @@ internal class SessionOrchestratorImpl( else -> ProcessState.FOREGROUND } - private val backgroundActivityGate = ConfigGate(payloadFactory) { - configService.isBackgroundActivityCaptureEnabled() - } - private val backgroundActivityFactory: PayloadFactory? - get() = backgroundActivityGate.getService() - init { processStateService.addListener(this) - configService.addListener(backgroundActivityGate) createInitialSession() } @@ -61,11 +53,7 @@ internal class SessionOrchestratorImpl( transitionType = TransitionType.INITIAL, timestamp = timestamp, newSessionAction = { - if (state == ProcessState.BACKGROUND) { - backgroundActivityFactory?.startBackgroundActivityWithState(timestamp, true) - } else { - payloadFactory.startSessionWithState(timestamp, true) - } + payloadFactory.startPayloadWithState(state, timestamp, true) } ) } @@ -75,10 +63,10 @@ internal class SessionOrchestratorImpl( transitionType = TransitionType.ON_FOREGROUND, timestamp = timestamp, oldSessionAction = { initial: Session -> - backgroundActivityFactory?.endBackgroundActivityWithState(initial, timestamp) + payloadFactory.endPayloadWithState(ProcessState.BACKGROUND, timestamp, initial) }, newSessionAction = { - payloadFactory.startSessionWithState(timestamp, coldStart) + payloadFactory.startPayloadWithState(ProcessState.FOREGROUND, timestamp, coldStart) }, earlyTerminationCondition = { return@transitionState shouldRunOnForeground(state) @@ -91,10 +79,10 @@ internal class SessionOrchestratorImpl( transitionType = TransitionType.ON_BACKGROUND, timestamp = timestamp, oldSessionAction = { initial: Session -> - payloadFactory.endSessionWithState(initial, timestamp) + payloadFactory.endPayloadWithState(ProcessState.FOREGROUND, timestamp, initial) }, newSessionAction = { - backgroundActivityFactory?.startBackgroundActivityWithState(timestamp, false) + payloadFactory.startPayloadWithState(ProcessState.BACKGROUND, timestamp, false) }, earlyTerminationCondition = { return@transitionState shouldRunOnBackground(state) @@ -109,7 +97,7 @@ internal class SessionOrchestratorImpl( timestamp = timestamp, clearUserInfo = clearUserInfo, oldSessionAction = { initial: Session -> - payloadFactory.endSessionWithManual(initial, timestamp) + payloadFactory.endSessionWithManual(timestamp, initial) }, newSessionAction = { payloadFactory.startSessionWithManual(timestamp) @@ -131,15 +119,7 @@ internal class SessionOrchestratorImpl( transitionType = TransitionType.CRASH, timestamp = timestamp, oldSessionAction = { initial: Session -> - if (processStateService.isInBackground) { - backgroundActivityFactory?.endBackgroundActivityWithCrash( - initial, - timestamp, - crashId - ) - } else { - payloadFactory.endSessionWithCrash(initial, timestamp, crashId) - } + payloadFactory.endPayloadWithCrash(state, timestamp, initial, crashId) } ) } @@ -147,7 +127,7 @@ internal class SessionOrchestratorImpl( override fun reportBackgroundActivityStateChange() { if (state == ProcessState.BACKGROUND) { val initial = activeSession ?: return - scheduleBackgroundActivitySave(initial) + scheduleBackgroundActivitySave(ProcessState.BACKGROUND, initial) } } @@ -254,20 +234,20 @@ internal class SessionOrchestratorImpl( ProcessState.FOREGROUND -> { periodicSessionCacher.start { synchronized(lock) { - payloadFactory.snapshotSession(newState, clock.now())?.apply { + payloadFactory.snapshotPayload(endProcessState, clock.now(), newState)?.apply { deliveryService.sendSession(this, SessionSnapshotType.PERIODIC_CACHE) } } } } - ProcessState.BACKGROUND -> scheduleBackgroundActivitySave(newState) + ProcessState.BACKGROUND -> scheduleBackgroundActivitySave(endProcessState, newState) } } - private fun scheduleBackgroundActivitySave(initial: Session) { + private fun scheduleBackgroundActivitySave(endProcessState: ProcessState, initial: Session) { periodicBackgroundActivityCacher.scheduleSave { synchronized(lock) { - backgroundActivityFactory?.snapshotBackgroundActivity(initial, clock.now())?.apply { + payloadFactory.snapshotPayload(endProcessState, clock.now(), initial)?.apply { deliveryService.sendSession(this, SessionSnapshotType.PERIODIC_CACHE) } } diff --git a/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/FakePayloadFactory.kt b/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/FakePayloadFactory.kt index 818a5ea05..7ff9c5aa4 100644 --- a/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/FakePayloadFactory.kt +++ b/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/FakePayloadFactory.kt @@ -4,6 +4,7 @@ import io.embrace.android.embracesdk.fakes.fakeSession import io.embrace.android.embracesdk.fakes.fakeSessionMessage import io.embrace.android.embracesdk.payload.Session import io.embrace.android.embracesdk.payload.SessionMessage +import io.embrace.android.embracesdk.session.lifecycle.ProcessState import io.embrace.android.embracesdk.session.message.PayloadFactory internal class FakePayloadFactory : PayloadFactory { @@ -13,33 +14,80 @@ internal class FakePayloadFactory : PayloadFactory { var manualSessionEndCount = 0 var manualSessionStartCount = 0 var snapshotSessionCount = 0 - var activeSession: Session? = null + private var activeSession: Session? = null val endBaTimestamps = mutableListOf() val startBaTimestamps = mutableListOf() var baCrashId: String? = null - var snapshotBaCount: Int = 0 + private var snapshotBaCount: Int = 0 - override fun startBackgroundActivityWithState(timestamp: Long, coldStart: Boolean): Session { + override fun startPayloadWithState( + state: ProcessState, + timestamp: Long, + coldStart: Boolean + ): Session { + return when (state) { + ProcessState.FOREGROUND -> startSessionWithState(timestamp) + ProcessState.BACKGROUND -> startBackgroundActivityWithState(timestamp) + } + } + + override fun endPayloadWithState( + state: ProcessState, + timestamp: Long, + initial: Session + ): SessionMessage { + return when (state) { + ProcessState.FOREGROUND -> endSessionWithState(timestamp) + ProcessState.BACKGROUND -> endBackgroundActivityWithState(timestamp) + } + } + + override fun endPayloadWithCrash( + state: ProcessState, + timestamp: Long, + initial: Session, + crashId: String + ): SessionMessage { + return when (state) { + ProcessState.FOREGROUND -> endSessionWithCrash(crashId) + ProcessState.BACKGROUND -> endBackgroundActivityWithCrash(crashId) + } + } + + override fun snapshotPayload( + state: ProcessState, + timestamp: Long, + initial: Session + ): SessionMessage? { + return when (state) { + ProcessState.FOREGROUND -> snapshotSession() + ProcessState.BACKGROUND -> snapshotBackgroundActivity() + } + } + + private fun startBackgroundActivityWithState(timestamp: Long): Session { startBaTimestamps.add(timestamp) return fakeBackgroundActivity() } - override fun endBackgroundActivityWithState(initial: Session, timestamp: Long): SessionMessage { + private fun endBackgroundActivityWithState(timestamp: Long): SessionMessage { endBaTimestamps.add(timestamp) return fakeBackgroundActivityMessage() } - override fun endBackgroundActivityWithCrash(initial: Session, timestamp: Long, crashId: String): SessionMessage { + private fun endBackgroundActivityWithCrash( + crashId: String + ): SessionMessage { this.baCrashId = crashId return fakeBackgroundActivityMessage() } - override fun snapshotBackgroundActivity(initial: Session, timestamp: Long): SessionMessage { + private fun snapshotBackgroundActivity(): SessionMessage { snapshotBaCount++ return fakeBackgroundActivityMessage() } - override fun startSessionWithState(timestamp: Long, coldStart: Boolean): Session { + private fun startSessionWithState(timestamp: Long): Session { startSessionTimestamps.add(timestamp) activeSession = fakeSession(startMs = timestamp) return checkNotNull(activeSession) @@ -51,7 +99,7 @@ internal class FakePayloadFactory : PayloadFactory { return checkNotNull(activeSession) } - override fun endSessionWithState(initial: Session, timestamp: Long): SessionMessage { + private fun endSessionWithState(timestamp: Long): SessionMessage { endSessionTimestamps.add(timestamp) activeSession = null return fakeSessionMessage() @@ -59,19 +107,19 @@ internal class FakePayloadFactory : PayloadFactory { var crashId: String? = null - override fun endSessionWithCrash(initial: Session, timestamp: Long, crashId: String): SessionMessage { + private fun endSessionWithCrash(crashId: String): SessionMessage { this.crashId = crashId activeSession = null return fakeSessionMessage() } - override fun endSessionWithManual(initial: Session, timestamp: Long): SessionMessage { + override fun endSessionWithManual(timestamp: Long, initial: Session): SessionMessage { manualSessionEndCount++ activeSession = null return fakeSessionMessage() } - override fun snapshotSession(initial: Session, timestamp: Long): SessionMessage? { + private fun snapshotSession(): SessionMessage? { snapshotSessionCount++ return null } diff --git a/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/PayloadFactoryBaTest.kt b/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/PayloadFactoryBaTest.kt index d4d789004..c59d77b32 100644 --- a/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/PayloadFactoryBaTest.kt +++ b/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/PayloadFactoryBaTest.kt @@ -32,6 +32,7 @@ import io.embrace.android.embracesdk.internal.spans.CurrentSessionSpan import io.embrace.android.embracesdk.internal.spans.SpanService import io.embrace.android.embracesdk.internal.spans.SpanSink import io.embrace.android.embracesdk.logging.InternalErrorService +import io.embrace.android.embracesdk.session.lifecycle.ProcessState import io.embrace.android.embracesdk.session.message.PayloadFactoryImpl import io.embrace.android.embracesdk.session.message.PayloadMessageCollator import org.junit.Assert.assertEquals @@ -110,9 +111,10 @@ internal class PayloadFactoryBaTest { service = createService() val now = clock.now() spanService.initializeService(now) - val msg = service.endBackgroundActivityWithCrash(initial, now, "crashId") + val msg = service.endPayloadWithCrash(ProcessState.BACKGROUND, now, initial, "crashId") // there should be 1 completed span: the session span + checkNotNull(msg) assertEquals(1, msg.spans?.size) assertEquals(0, spanSink.completedSpans().size) } @@ -121,9 +123,10 @@ internal class PayloadFactoryBaTest { fun `foregrounding will flush the current completed spans`() { service = createService() spanService.initializeService(clock.now()) - val msg = service.endBackgroundActivityWithState(initial, clock.now()) + val msg = service.endPayloadWithState(ProcessState.BACKGROUND, clock.now(), initial) // there should be 1 completed span: the session span + checkNotNull(msg) assertEquals(1, msg.spans?.size) assertEquals(0, spanSink.completedSpans().size) } @@ -133,9 +136,10 @@ internal class PayloadFactoryBaTest { service = createService() spanService.initializeService(clock.now()) clock.tick(1000L) - val msg = service.endBackgroundActivityWithState(initial, clock.now()) + val msg = service.endPayloadWithState(ProcessState.BACKGROUND, clock.now(), initial) // there should be 1 completed span: the session span + checkNotNull(msg) assertEquals(1, msg.spans?.size) assertEquals(0, spanSink.completedSpans().size) } @@ -144,7 +148,7 @@ internal class PayloadFactoryBaTest { fun `foregrounding background activity flushes breadcrumbs`() { service = createService() clock.tick(1000L) - service.endBackgroundActivityWithState(initial, clock.now()) + service.endPayloadWithState(ProcessState.BACKGROUND, clock.now(), initial) assertEquals(1, breadcrumbService.flushCount) } @@ -167,9 +171,9 @@ internal class PayloadFactoryBaTest { FakeSessionPropertiesService(), FakeStartupService() ) - return PayloadFactoryImpl(collator).apply { + return PayloadFactoryImpl(collator, configService).apply { if (createInitialSession) { - startBackgroundActivityWithState(clock.now(), true) + startPayloadWithState(ProcessState.BACKGROUND, clock.now(), true) } } } diff --git a/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/PayloadFactorySessionTest.kt b/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/PayloadFactorySessionTest.kt index 9c8d3e5dc..7c7e0a7cf 100644 --- a/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/PayloadFactorySessionTest.kt +++ b/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/PayloadFactorySessionTest.kt @@ -6,6 +6,7 @@ import io.embrace.android.embracesdk.fakes.FakeConfigService import io.embrace.android.embracesdk.fakes.FakeProcessStateService import io.embrace.android.embracesdk.fakes.injection.FakeInitModule import io.embrace.android.embracesdk.internal.spans.SpanSink +import io.embrace.android.embracesdk.session.lifecycle.ProcessState import io.embrace.android.embracesdk.session.message.PayloadFactory import io.embrace.android.embracesdk.session.message.PayloadFactoryImpl import io.mockk.clearAllMocks @@ -69,7 +70,7 @@ internal class PayloadFactorySessionTest { initializeSessionService() val coldStart = true - service.startSessionWithState(456, coldStart) + service.startPayloadWithState(ProcessState.FOREGROUND, 456, coldStart) assertNull(deliveryService.lastSentCachedSession) } @@ -83,6 +84,6 @@ internal class PayloadFactorySessionTest { isActivityInBackground: Boolean = true ) { processStateService.isInBackground = isActivityInBackground - service = PayloadFactoryImpl(mockk(relaxed = true)) + service = PayloadFactoryImpl(mockk(relaxed = true), FakeConfigService()) } } diff --git a/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/SessionHandlerTest.kt b/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/SessionHandlerTest.kt index 999c77f81..31b593484 100644 --- a/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/SessionHandlerTest.kt +++ b/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/SessionHandlerTest.kt @@ -39,6 +39,7 @@ import io.embrace.android.embracesdk.internal.spans.SpanSink import io.embrace.android.embracesdk.logging.EmbraceInternalErrorService import io.embrace.android.embracesdk.payload.Session import io.embrace.android.embracesdk.payload.SessionMessage +import io.embrace.android.embracesdk.session.lifecycle.ProcessState import io.embrace.android.embracesdk.session.message.PayloadFactory import io.embrace.android.embracesdk.session.message.PayloadFactoryImpl import io.embrace.android.embracesdk.session.message.PayloadMessageCollator @@ -152,7 +153,7 @@ internal class SessionHandlerTest { FakeSessionPropertiesService(), FakeStartupService() ) - payloadFactory = PayloadFactoryImpl(payloadMessageCollator) + payloadFactory = PayloadFactoryImpl(payloadMessageCollator, configService) } @After @@ -167,7 +168,7 @@ internal class SessionHandlerTest { sessionLocalConfig = SessionLocalConfig() // this is needed so session handler creates automatic session stopper - payloadFactory.startSessionWithState(now, true) + payloadFactory.startPayloadWithState(ProcessState.FOREGROUND, now, true) assertEquals(1, preferencesService.incrementAndGetSessionNumberCount) } @@ -184,7 +185,13 @@ internal class SessionHandlerTest { isColdStart = true ) - val session = payloadFactory.endSessionWithCrash(initial, clock.now(), crashId).session + val msg = payloadFactory.endPayloadWithCrash( + ProcessState.FOREGROUND, + clock.now(), + initial, + crashId + ) + val session = checkNotNull(msg).session // when crashing, the following calls should not be made, this is because since we're // about to crash we can save some time on not doing these // @@ -225,7 +232,7 @@ internal class SessionHandlerTest { // do nothing } clock.tick(30000) - val msg = payloadFactory.endSessionWithState(initial, 10L) + val msg = payloadFactory.endPayloadWithState(ProcessState.FOREGROUND, 10L, initial) assertSpanInSessionMessage(msg) } @@ -233,7 +240,7 @@ internal class SessionHandlerTest { fun `clearing user info disallowed for state sessions`() { startFakeSession() clock.tick(30000) - payloadFactory.endSessionWithState(initial, 10L) + payloadFactory.endPayloadWithState(ProcessState.FOREGROUND, 10L, initial) assertEquals(0, userService.clearedCount) } @@ -244,7 +251,12 @@ internal class SessionHandlerTest { spanService.recordSpan("test-span") { // do nothing } - val msg = payloadFactory.endSessionWithCrash(initial, clock.now(), "fakeCrashId") + val msg = payloadFactory.endPayloadWithCrash( + ProcessState.FOREGROUND, + clock.now(), + initial, + "fakeCrashId" + ) assertSpanInSessionMessage(msg) } @@ -261,7 +273,14 @@ internal class SessionHandlerTest { assertEquals(1, spanSink.completedSpans().size) clock.tick(15000L) - val sessionMessage = payloadFactory.endSessionWithState(initial, clock.now()) + val sessionMessage = + checkNotNull( + payloadFactory.endPayloadWithState( + ProcessState.FOREGROUND, + clock.now(), + initial + ) + ) val spans = checkNotNull(sessionMessage.spans) assertEquals(2, spans.size) assertEquals(0, spanSink.completedSpans().size) @@ -274,12 +293,12 @@ internal class SessionHandlerTest { spanService.recordSpan("test-span") {} assertEquals(1, spanSink.completedSpans().size) - payloadFactory.endSessionWithCrash(initial, clock.now(), "crashId") + payloadFactory.endPayloadWithCrash(ProcessState.FOREGROUND, clock.now(), initial, "crashId") assertEquals(0, spanSink.completedSpans().size) } private fun startFakeSession(): Session { - return payloadFactory.startSessionWithState(now, true) + return checkNotNull(payloadFactory.startPayloadWithState(ProcessState.FOREGROUND, now, true)) } private fun initializeServices(startTimeMillis: Long = clock.now()) { diff --git a/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/orchestrator/SessionOrchestratorTest.kt b/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/orchestrator/SessionOrchestratorTest.kt index 2d27202cc..e27018e62 100644 --- a/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/orchestrator/SessionOrchestratorTest.kt +++ b/embrace-android-sdk/src/test/java/io/embrace/android/embracesdk/session/orchestrator/SessionOrchestratorTest.kt @@ -26,7 +26,6 @@ import io.embrace.android.embracesdk.session.caching.PeriodicSessionCacher import io.embrace.android.embracesdk.session.properties.EmbraceSessionProperties import io.embrace.android.embracesdk.worker.ScheduledWorker import org.junit.Assert.assertEquals -import org.junit.Assert.assertTrue import org.junit.Before import org.junit.Test @@ -173,16 +172,6 @@ internal class SessionOrchestratorTest { assertEquals(0, deliveryService.lastSentSessions.size) } - @Test - fun `test background activity capture disabled`() { - configService = FakeConfigService(backgroundActivityCaptureEnabled = false) - createOrchestrator(false) - orchestrator.onBackground(TIMESTAMP) - assertEquals(2, memoryCleanerService.callCount) - assertTrue(payloadFactory.startBaTimestamps.isEmpty()) - assertEquals(1, deliveryService.lastSentSessions.size) - } - @Test fun `test manual session end disabled for session gating`() { configService = FakeConfigService(