api: idiomatic kotlin changes to session api (#1673)

fractalwrench · web-flow · commit bf63addeb903 · 2026-04-03T11:15:11.000-07:00
diff --git a/android-agent/src/main/kotlin/io/opentelemetry/android/agent/session/InMemorySessionStorage.kt b/android-agent/src/main/kotlin/io/opentelemetry/android/agent/session/InMemorySessionStorage.kt
@@ -8,7 +8,7 @@ package io.opentelemetry.android.agent.session
 import io.opentelemetry.android.session.Session
 
 internal class InMemorySessionStorage(
-    @Volatile var session: Session = Session.NONE,
+    @Volatile var session: Session = invalidSession,
 ) : SessionStorage {
     override fun get(): Session = session
 
diff --git a/android-agent/src/main/kotlin/io/opentelemetry/android/agent/session/SessionImpl.kt b/android-agent/src/main/kotlin/io/opentelemetry/android/agent/session/SessionImpl.kt
@@ -0,0 +1,10 @@
+package io.opentelemetry.android.agent.session
+
+import io.opentelemetry.android.session.Session
+
+internal class SessionImpl(
+    override val id: String,
+    override val startTimestamp: Long
+): Session
+
+internal val invalidSession = SessionImpl("", -1)
diff --git a/android-agent/src/main/kotlin/io/opentelemetry/android/agent/session/SessionManager.kt b/android-agent/src/main/kotlin/io/opentelemetry/android/agent/session/SessionManager.kt
@@ -24,7 +24,7 @@ internal class SessionManager(
     private val maxSessionLifetime: Duration,
 ) : SessionProvider,
     SessionPublisher {
-    private val session: AtomicReference<Session> = AtomicReference(Session.NONE)
+    private val session: AtomicReference<Session> = AtomicReference(invalidSession)
     private val observers = synchronizedList(ArrayList<SessionObserver>())
 
     init {
@@ -41,7 +41,7 @@ internal class SessionManager(
         // Check if we need to create a new session.
         return if (sessionHasExpired(currentSession) || timeoutHandler.hasTimedOut()) {
             val newId = idGenerator.generateSessionId()
-            val newSession = Session.DefaultSession(newId, clock.now())
+            val newSession = SessionImpl(newId, clock.now())
 
             // Atomically update the session only if it hasn't been changed by another thread.
             if (session.compareAndSet(currentSession, newSession)) {
@@ -50,17 +50,17 @@ internal class SessionManager(
                 // Observers need to be called after bumping the timer because it may create a new
                 // span.
                 notifyObserversOfSessionUpdate(currentSession, newSession)
-                newSession.getId()
+                newSession.id
             } else {
                 // Another thread accessed this function prior to creating a new session. Use the
                 // current session.
                 timeoutHandler.bump()
-                session.get().getId()
+                session.get().id
             }
         } else {
             // No new session needed, just bump the timeout and return current session ID
             timeoutHandler.bump()
-            currentSession.getId()
+            currentSession.id
         }
     }
 
@@ -75,7 +75,7 @@ internal class SessionManager(
     }
 
     private fun sessionHasExpired(session: Session): Boolean {
-        val elapsedTime = clock.now() - session.getStartTimestamp()
+        val elapsedTime = clock.now() - session.startTimestamp
         return elapsedTime >= maxSessionLifetime.inWholeNanoseconds
     }
 
@@ -93,4 +93,5 @@ internal class SessionManager(
                 clock = clock,
             )
     }
+
 }
diff --git a/android-agent/src/test/kotlin/io/opentelemetry/android/agent/session/SessionManagerTest.kt b/android-agent/src/test/kotlin/io/opentelemetry/android/agent/session/SessionManagerTest.kt
@@ -120,8 +120,8 @@ internal class SessionManagerTest {
         // Then
         verify(exactly = 1) { timeoutHandler.bump() }
         verify(exactly = 0) { timeoutHandler.hasTimedOut() }
-        verify(exactly = 1) { observer.onSessionStarted(any<Session>(), eq(Session.NONE)) }
-        verify(exactly = 1) { observer.onSessionEnded(eq(Session.NONE)) }
+        verify(exactly = 1) { observer.onSessionStarted(any<Session>(), eq(invalidSession)) }
+        verify(exactly = 1) { observer.onSessionEnded(eq(invalidSession)) }
 
         // When
         clock.advance(3, TimeUnit.HOURS)
@@ -144,10 +144,10 @@ internal class SessionManagerTest {
         assertThat(thirdSessionId).isNotEqualTo(secondSessionId)
         verifyOrder {
             timeoutHandler.bump()
-            observer.onSessionEnded(match { it.getId() == secondSessionId })
+            observer.onSessionEnded(match { it.id == secondSessionId })
             observer.onSessionStarted(
-                match { it.getId() == thirdSessionId },
-                match { it.getId() == secondSessionId },
+                match { it.id == thirdSessionId },
+                match { it.id == secondSessionId },
             )
         }
         confirmVerified(observer)
diff --git a/instrumentation/sessions/src/main/kotlin/io/opentelemetry/android/instrumentation/sessions/SessionIdEventSender.kt b/instrumentation/sessions/src/main/kotlin/io/opentelemetry/android/instrumentation/sessions/SessionIdEventSender.kt
@@ -28,22 +28,22 @@ internal class SessionIdEventSender(
             eventLogger
                 .logRecordBuilder()
                 .setEventName(EVENT_SESSION_START)
-                .setAttribute(SESSION_ID, newSession.getId())
-        val previousSessionId = previousSession.getId()
+                .setAttribute(SESSION_ID, newSession.id)
+        val previousSessionId = previousSession.id
         if (previousSessionId.isNotEmpty()) {
             eventBuilder.setAttribute(SESSION_PREVIOUS_ID, previousSessionId)
         }
         eventBuilder.emit()
     }
 
     override fun onSessionEnded(session: Session) {
-        if (session.getId().isEmpty()) {
+        if (session.id.isEmpty()) {
             return
         }
         eventLogger
             .logRecordBuilder()
             .setEventName(EVENT_SESSION_END)
-            .setAttribute(SESSION_ID, session.getId())
+            .setAttribute(SESSION_ID, session.id)
             .emit()
     }
 }
diff --git a/instrumentation/sessions/src/test/kotlin/io/opentelemetry/android/instrumentation/sessions/SessionIdEventSenderTest.kt b/instrumentation/sessions/src/test/kotlin/io/opentelemetry/android/instrumentation/sessions/SessionIdEventSenderTest.kt
@@ -39,46 +39,51 @@ class SessionIdEventSenderTest {
     @Test
     fun `starts first session`() {
         val sender = SessionIdEventSender(logger)
-        val newSession = Session.DefaultSession("123", 12L)
-        val previousSession = Session.NONE
+        val newSession = FakeSession("123", 12L)
+        val previousSession = FakeSession("", -1)
         sender.onSessionStarted(newSession, previousSession)
         assertThat(otelTesting.logRecords).hasSize(1)
         val event = otelTesting.logRecords[0]
         assertThat(event.eventName).isEqualTo(EVENT_SESSION_START)
-        assertThat(event.attributes.get(SESSION_ID)).isEqualTo(newSession.getId())
+        assertThat(event.attributes.get(SESSION_ID)).isEqualTo(newSession.id)
         assertThat(event.attributes.get(SESSION_PREVIOUS_ID)).isNull()
     }
 
     @Test
     fun `starts new second session`() {
         val sender = SessionIdEventSender(logger)
-        val previousSession = Session.DefaultSession("abc", 12L)
-        val newSession = Session.DefaultSession("124", 13L)
+        val previousSession = FakeSession("abc", 12L)
+        val newSession = FakeSession("124", 13L)
         sender.onSessionStarted(newSession, previousSession)
         assertThat(otelTesting.logRecords).hasSize(1)
         val event = otelTesting.logRecords[0]
         assertThat(event.eventName).isEqualTo(EVENT_SESSION_START)
-        assertThat(event.attributes.get(SESSION_ID)).isEqualTo(newSession.getId())
-        assertThat(event.attributes.get(SESSION_PREVIOUS_ID)).isEqualTo(previousSession.getId())
+        assertThat(event.attributes.get(SESSION_ID)).isEqualTo(newSession.id)
+        assertThat(event.attributes.get(SESSION_PREVIOUS_ID)).isEqualTo(previousSession.id)
     }
 
     @Test
     fun `ends a session`() {
         val sender = SessionIdEventSender(logger)
-        val session = Session.DefaultSession("booper", 99L)
+        val session = FakeSession("booper", 99L)
         sender.onSessionEnded(session)
         assertThat(otelTesting.logRecords).hasSize(1)
         val event = otelTesting.logRecords[0]
         assertThat(event.eventName).isEqualTo(EVENT_SESSION_END)
-        assertThat(event.attributes.get(SESSION_ID)).isEqualTo(session.getId())
+        assertThat(event.attributes.get(SESSION_ID)).isEqualTo(session.id)
         assertThat(event.attributes.get(SESSION_PREVIOUS_ID)).isNull()
     }
 
     @Test
     fun `ends an empty session`() {
         val sender = SessionIdEventSender(logger)
-        val session = Session.NONE
+        val session = FakeSession("", -1)
         sender.onSessionEnded(session)
         assertThat(otelTesting.logRecords).isEmpty()
     }
+
+    private class FakeSession(
+        override val id: String,
+        override val startTimestamp: Long,
+    ) : Session
 }
diff --git a/session/api/session.api b/session/api/session.api
@@ -1,24 +1,8 @@
 public abstract interface class io/opentelemetry/android/session/Session {
-	public static final field Companion Lio/opentelemetry/android/session/Session$Companion;
 	public abstract fun getId ()Ljava/lang/String;
 	public abstract fun getStartTimestamp ()J
 }
 
-public final class io/opentelemetry/android/session/Session$Companion {
-	public final fun getNONE ()Lio/opentelemetry/android/session/Session$DefaultSession;
-}
-
-public final class io/opentelemetry/android/session/Session$DefaultSession : io/opentelemetry/android/session/Session {
-	public fun <init> (Ljava/lang/String;J)V
-	public final fun copy (Ljava/lang/String;J)Lio/opentelemetry/android/session/Session$DefaultSession;
-	public static synthetic fun copy$default (Lio/opentelemetry/android/session/Session$DefaultSession;Ljava/lang/String;JILjava/lang/Object;)Lio/opentelemetry/android/session/Session$DefaultSession;
-	public fun equals (Ljava/lang/Object;)Z
-	public fun getId ()Ljava/lang/String;
-	public fun getStartTimestamp ()J
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
 public abstract interface class io/opentelemetry/android/session/SessionObserver {
 	public abstract fun onSessionEnded (Lio/opentelemetry/android/session/Session;)V
 	public abstract fun onSessionStarted (Lio/opentelemetry/android/session/Session;Lio/opentelemetry/android/session/Session;)V
diff --git a/session/src/main/kotlin/io/opentelemetry/android/session/Session.kt b/session/src/main/kotlin/io/opentelemetry/android/session/Session.kt
@@ -5,32 +5,18 @@
 
 package io.opentelemetry.android.session
 
+/**
+ * Provides information about the current session.
+ */
 interface Session {
-    fun getId(): String
-
-    fun getStartTimestamp(): Long
-
-    companion object {
-        val NONE = DefaultSession("", -1)
-    }
-
-    data class DefaultSession(
-        private val id: String,
-        private val timestamp: Long,
-    ) : Session {
-        override fun getId(): String = id
-
-        override fun getStartTimestamp(): Long = timestamp
-
-        override fun equals(other: Any?): Boolean {
-            if (this === other) return true
-            if (javaClass != other?.javaClass) return false
-
-            other as DefaultSession
 
-            return id == other.id
-        }
+    /**
+     * The session ID.
+     */
+    val id: String
 
-        override fun hashCode(): Int = id.hashCode()
-    }
+    /**
+     * The timestamp at which the session was started.
+     */
+    val startTimestamp: Long
 }
diff --git a/session/src/main/kotlin/io/opentelemetry/android/session/SessionObserver.kt b/session/src/main/kotlin/io/opentelemetry/android/session/SessionObserver.kt
@@ -5,11 +5,21 @@
 
 package io.opentelemetry.android.session
 
+/**
+ * Callback that is invoked at different points in the session lifecycle.
+ */
 interface SessionObserver {
+
+    /**
+     * Called after a session has started.
+     */
     fun onSessionStarted(
         newSession: Session,
         previousSession: Session,
     )
 
+    /**
+     * Called after a session has ended.
+     */
     fun onSessionEnded(session: Session)
 }
diff --git a/session/src/main/kotlin/io/opentelemetry/android/session/SessionProvider.kt b/session/src/main/kotlin/io/opentelemetry/android/session/SessionProvider.kt
@@ -5,17 +5,26 @@
 
 package io.opentelemetry.android.session
 
-interface SessionProvider {
+/**
+ * Provides information about the current session.
+ */
+fun interface SessionProvider {
+
+    /**
+     * Retrieves the current session ID.
+     */
     fun getSessionId(): String
 
     companion object {
+
+        /**
+         * A no-op implementation of [SessionProvider].
+         */
         @JvmStatic
         fun getNoop(): SessionProvider = NO_OP
 
         private val NO_OP: SessionProvider by lazy {
-            object : SessionProvider {
-                override fun getSessionId(): String = ""
-            }
+            SessionProvider { "" }
         }
     }
 }
diff --git a/session/src/main/kotlin/io/opentelemetry/android/session/SessionPublisher.kt b/session/src/main/kotlin/io/opentelemetry/android/session/SessionPublisher.kt
@@ -5,6 +5,13 @@
 
 package io.opentelemetry.android.session
 
-interface SessionPublisher {
+/**
+ * Allows registration of callbacks that are invoked when the session changes.
+ */
+fun interface SessionPublisher {
+
+    /**
+     * Adds an observer that is invoked when the session changes.
+     */
     fun addObserver(observer: SessionObserver)
 }

Original file line number	Diff line number	Diff line change
`@@ -28,22 +28,22 @@ internal class SessionIdEventSender(`
`28`	`28`	`eventLogger`
`29`	`29`	`.logRecordBuilder()`
`30`	`30`	`.setEventName(EVENT_SESSION_START)`
`31`		`- .setAttribute(SESSION_ID, newSession.getId())`
`32`		`- val previousSessionId = previousSession.getId()`
	`31`	`+ .setAttribute(SESSION_ID, newSession.id)`
	`32`	`+ val previousSessionId = previousSession.id`
`33`	`33`	`if (previousSessionId.isNotEmpty()) {`
`34`	`34`	`eventBuilder.setAttribute(SESSION_PREVIOUS_ID, previousSessionId)`
`35`	`35`	`}`
`36`	`36`	`eventBuilder.emit()`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`override fun onSessionEnded(session: Session) {`
`40`		`- if (session.getId().isEmpty()) {`
	`40`	`+ if (session.id.isEmpty()) {`
`41`	`41`	`return`
`42`	`42`	`}`
`43`	`43`	`eventLogger`
`44`	`44`	`.logRecordBuilder()`
`45`	`45`	`.setEventName(EVENT_SESSION_END)`
`46`		`- .setAttribute(SESSION_ID, session.getId())`
	`46`	`+ .setAttribute(SESSION_ID, session.id)`
`47`	`47`	`.emit()`
`48`	`48`	`}`
`49`	`49`	`}`