Instrumentation context change (#763)

* Adding publish conventions

* Rename .java to .kt

* Rename .java to .kt

* Renaming services

* Making services testable

* Removing Service interface

* Adding tests

* Updating rum builder tests

* Removing Services from InstallationContext

* Fix tests

* Fix tests

* Using services in instrumentations

* Adding comment

Author: LikeTheSalad

core/src/main/java/io/opentelemetry/android/OpenTelemetryRum.java

@@ -7,7 +7,7 @@
 
 import android.app.Application;
 import io.opentelemetry.android.config.OtelRumConfig;
-import io.opentelemetry.android.internal.services.ServiceManager;
+import io.opentelemetry.android.internal.services.Services;
 import io.opentelemetry.api.OpenTelemetry;
 import io.opentelemetry.sdk.OpenTelemetrySdk;
 import io.opentelemetry.sdk.logs.SdkLoggerProvider;
@@ -61,16 +61,14 @@ static OpenTelemetryRumBuilder builder(Application application, OtelRumConfig co
      * @param openTelemetrySdk The {@link OpenTelemetrySdk} that the user has already created.
      * @param discoverInstrumentations TRUE to look for instrumentations in the classpath and
      *     applying them automatically.
-     * @param serviceManager The ServiceManager instance
      */
     static SdkPreconfiguredRumBuilder builder(
             Application application,
             OpenTelemetrySdk openTelemetrySdk,
-            boolean discoverInstrumentations,
-            ServiceManager serviceManager) {
+            boolean discoverInstrumentations) {
 
         return new SdkPreconfiguredRumBuilder(
-                application, openTelemetrySdk, discoverInstrumentations, serviceManager);
+                application, openTelemetrySdk, discoverInstrumentations, Services.get(application));
     }
 
     /** Returns a no-op implementation of {@link OpenTelemetryRum}. */

core/src/main/java/io/opentelemetry/android/OpenTelemetryRumBuilder.java

@@ -31,9 +31,8 @@
 import io.opentelemetry.android.internal.processors.SessionIdLogRecordAppender;
 import io.opentelemetry.android.internal.services.CacheStorage;
 import io.opentelemetry.android.internal.services.Preferences;
-import io.opentelemetry.android.internal.services.ServiceManager;
-import io.opentelemetry.android.internal.services.ServiceManagerImpl;
-import io.opentelemetry.android.internal.services.periodicwork.PeriodicWorkService;
+import io.opentelemetry.android.internal.services.Services;
+import io.opentelemetry.android.internal.services.periodicwork.PeriodicWork;
 import io.opentelemetry.android.internal.session.SessionIdTimeoutHandler;
 import io.opentelemetry.android.internal.session.SessionManagerImpl;
 import io.opentelemetry.android.session.SessionManager;
@@ -101,8 +100,6 @@ public final class OpenTelemetryRumBuilder {
 
     private boolean isBuilt = false;
 
-    @Nullable private ServiceManager serviceManager;
-
     @Nullable private ExportScheduleHandler exportScheduleHandler;
     @Nullable private SessionManager sessionManager;
 
@@ -297,8 +294,9 @@ public OpenTelemetryRum build() {
             throw new IllegalStateException("You cannot call build multiple times");
         }
         isBuilt = true;
+        Services services = Services.get(application);
         InitializationEvents initializationEvents = InitializationEvents.get();
-        applyConfiguration(initializationEvents);
+        applyConfiguration(services, initializationEvents);
 
         BufferDelegatingLogExporter bufferDelegatingLogExporter = new BufferDelegatingLogExporter();
 
@@ -317,7 +315,10 @@ public OpenTelemetryRum build() {
                                         sessionManager, application, bufferDelegatingSpanExporter))
                         .setLoggerProvider(
                                 buildLoggerProvider(
-                                        sessionManager, application, bufferDelegatingLogExporter))
+                                        services,
+                                        sessionManager,
+                                        application,
+                                        bufferDelegatingLogExporter))
                         .setMeterProvider(buildMeterProvider(application))
                         .setPropagators(buildFinalPropagators())
                         .build();
@@ -331,13 +332,14 @@ public OpenTelemetryRum build() {
                         timeoutHandler,
                         sessionManager,
                         config.shouldDiscoverInstrumentations(),
-                        getServiceManager());
+                        services);
 
         // AsyncTask is deprecated but the thread pool is still used all over the Android SDK
         // and it provides a way to get a background thread without having to create a new one.
         android.os.AsyncTask.THREAD_POOL_EXECUTOR.execute(
                 () ->
                         initializeExporters(
+                                services,
                                 initializationEvents,
                                 bufferDelegatingSpanExporter,
                                 bufferDelegatingLogExporter));
@@ -348,6 +350,7 @@ public OpenTelemetryRum build() {
     }
 
     private void initializeExporters(
+            Services services,
             InitializationEvents initializationEvents,
             BufferDelegatingSpanExporter bufferDelegatingSpanExporter,
             BufferDelegatingLogExporter bufferedDelegatingLogExporter) {
@@ -358,7 +361,7 @@ private void initializeExporters(
         SignalFromDiskExporter signalFromDiskExporter = null;
         if (diskBufferingConfig.getEnabled()) {
             try {
-                StorageConfiguration storageConfiguration = createStorageConfiguration();
+                StorageConfiguration storageConfiguration = createStorageConfiguration(services);
                 final SpanExporter originalSpanExporter = spanExporter;
                 spanExporter =
                         SpanToDiskExporter.create(originalSpanExporter, storageConfiguration);
@@ -379,23 +382,7 @@ private void initializeExporters(
         initializationEvents.spanExporterInitialized(spanExporter);
         bufferedDelegatingLogExporter.setDelegate(logsExporter);
         bufferDelegatingSpanExporter.setDelegate(spanExporter);
-        scheduleDiskTelemetryReader(signalFromDiskExporter);
-    }
-
-    @NonNull
-    private ServiceManager getServiceManager() {
-        if (serviceManager == null) {
-            serviceManager = ServiceManagerImpl.Companion.create(application);
-        }
-        // This can never be null since we never write `null` to it
-        return requireNonNull(serviceManager);
-    }
-
-    public OpenTelemetryRumBuilder setServiceManager(@NonNull ServiceManager serviceManager) {
-        requireNonNull(serviceManager, "serviceManager cannot be null");
-        checkNotBuilt();
-        this.serviceManager = serviceManager;
-        return this;
+        scheduleDiskTelemetryReader(services, signalFromDiskExporter);
     }
 
     @VisibleForTesting
@@ -416,9 +403,9 @@ public OpenTelemetryRumBuilder setExportScheduleHandler(
         return this;
     }
 
-    private StorageConfiguration createStorageConfiguration() throws IOException {
-        Preferences preferences = getServiceManager().getPreferences();
-        CacheStorage storage = getServiceManager().getCacheStorage();
+    private StorageConfiguration createStorageConfiguration(Services services) throws IOException {
+        Preferences preferences = services.getPreferences();
+        CacheStorage storage = services.getCacheStorage();
         DiskBufferingConfig config = this.config.getDiskBufferingConfig();
         DiskManager diskManager = new DiskManager(storage, preferences, config);
         return StorageConfiguration.builder()
@@ -434,12 +421,12 @@ private StorageConfiguration createStorageConfiguration() throws IOException {
                 .build();
     }
 
-    private void scheduleDiskTelemetryReader(@Nullable SignalFromDiskExporter signalExporter) {
+    private void scheduleDiskTelemetryReader(
+            Services services, @Nullable SignalFromDiskExporter signalExporter) {
         if (exportScheduleHandler == null) {
-            ServiceManager serviceManager = getServiceManager();
             // TODO: Is it safe to get the work service yet here? If so, we can
             // avoid all this lazy supplier stuff....
-            Function0<PeriodicWorkService> getWorkService = serviceManager::getPeriodicWorkService;
+            Function0<PeriodicWork> getWorkService = services::getPeriodicWork;
             exportScheduleHandler =
                     new DefaultExportScheduleHandler(
                             new DefaultExportScheduler(getWorkService), getWorkService);
@@ -475,7 +462,7 @@ public OpenTelemetryRumBuilder addOtelSdkReadyListener(Consumer<OpenTelemetrySdk
     }
 
     /** Leverage the configuration to wire up various instrumentation components. */
-    private void applyConfiguration(InitializationEvents initializationEvents) {
+    private void applyConfiguration(Services services, InitializationEvents initializationEvents) {
         if (config.shouldGenerateSdkInitializationEvents()) {
             initializationEvents.recordConfiguration(config);
         }
@@ -498,7 +485,7 @@ private void applyConfiguration(InitializationEvents initializationEvents) {
                     (tracerProviderBuilder, app) -> {
                         SpanProcessor networkAttributesSpanAppender =
                                 NetworkAttributesSpanAppender.create(
-                                        getServiceManager().getCurrentNetworkProvider());
+                                        services.getCurrentNetworkProvider());
                         return tracerProviderBuilder.addSpanProcessor(
                                 networkAttributesSpanAppender);
                     });
@@ -511,7 +498,7 @@ private void applyConfiguration(InitializationEvents initializationEvents) {
                     (tracerProviderBuilder, app) -> {
                         SpanProcessor screenAttributesAppender =
                                 new ScreenAttributesSpanProcessor(
-                                        getServiceManager().getVisibleScreenService());
+                                        services.getVisibleScreenTracker());
                         return tracerProviderBuilder.addSpanProcessor(screenAttributesAppender);
                     });
         }
@@ -535,6 +522,7 @@ private SdkTracerProvider buildTracerProvider(
     }
 
     private SdkLoggerProvider buildLoggerProvider(
+            Services services,
             SessionProvider sessionProvider,
             Application application,
             LogRecordExporter logsExporter) {
@@ -544,7 +532,7 @@ private SdkLoggerProvider buildLoggerProvider(
                         .addLogRecordProcessor(new SessionIdLogRecordAppender(sessionProvider))
                         .addLogRecordProcessor(
                                 new ScreenAttributesLogRecordProcessor(
-                                        getServiceManager().getVisibleScreenService()))
+                                        services.getVisibleScreenTracker()))
                         .addLogRecordProcessor(
                                 new GlobalAttributesLogRecordAppender(
                                         config.getGlobalAttributesSupplier()));

core/src/main/java/io/opentelemetry/android/ScreenAttributesSpanProcessor.java

@@ -7,23 +7,23 @@
 
 import static io.opentelemetry.android.common.RumConstants.SCREEN_NAME_KEY;
 
-import io.opentelemetry.android.internal.services.visiblescreen.VisibleScreenService;
+import io.opentelemetry.android.internal.services.visiblescreen.VisibleScreenTracker;
 import io.opentelemetry.context.Context;
 import io.opentelemetry.sdk.trace.ReadWriteSpan;
 import io.opentelemetry.sdk.trace.ReadableSpan;
 import io.opentelemetry.sdk.trace.SpanProcessor;
 
 public final class ScreenAttributesSpanProcessor implements SpanProcessor {
 
-    private final VisibleScreenService visibleScreenService;
+    private final VisibleScreenTracker visibleScreenTracker;
 
-    public ScreenAttributesSpanProcessor(VisibleScreenService visibleScreenService) {
-        this.visibleScreenService = visibleScreenService;
+    public ScreenAttributesSpanProcessor(VisibleScreenTracker visibleScreenTracker) {
+        this.visibleScreenTracker = visibleScreenTracker;
     }
 
     @Override
     public void onStart(Context parentContext, ReadWriteSpan span) {
-        String currentScreen = visibleScreenService.getCurrentlyVisibleScreen();
+        String currentScreen = visibleScreenTracker.getCurrentlyVisibleScreen();
         span.setAttribute(SCREEN_NAME_KEY, currentScreen);
     }
 

core/src/main/java/io/opentelemetry/android/SdkPreconfiguredRumBuilder.kt

@@ -9,7 +9,7 @@ import android.app.Application
 import io.opentelemetry.android.instrumentation.AndroidInstrumentation
 import io.opentelemetry.android.instrumentation.AndroidInstrumentationLoader
 import io.opentelemetry.android.instrumentation.InstallationContext
-import io.opentelemetry.android.internal.services.ServiceManager
+import io.opentelemetry.android.internal.services.Services
 import io.opentelemetry.android.internal.session.SessionIdTimeoutHandler
 import io.opentelemetry.android.internal.session.SessionManagerImpl
 import io.opentelemetry.android.session.SessionManager
@@ -23,10 +23,10 @@ class SdkPreconfiguredRumBuilder
         private val timeoutHandler: SessionIdTimeoutHandler = SessionIdTimeoutHandler(),
         private val sessionManager: SessionManager = SessionManagerImpl(timeoutHandler = timeoutHandler),
         private val discoverInstrumentations: Boolean,
-        private val serviceManager: ServiceManager,
+        private val services: Services,
     ) {
         private val instrumentations = mutableListOf<AndroidInstrumentation>()
-        private val appLifecycleService by lazy { serviceManager.getAppLifecycleService() }
+        private val appLifecycleService by lazy { services.appLifecycle }
 
         /**
          * Adds an instrumentation to be applied as a part of the [build] method call.
@@ -48,15 +48,14 @@ class SdkPreconfiguredRumBuilder
          * @return A new [OpenTelemetryRum] instance.
          */
         fun build(): OpenTelemetryRum {
-            serviceManager.start()
             // the app state listeners need to be run in the first ActivityLifecycleCallbacks since they
             // might turn off/on additional telemetry depending on whether the app is active or not
             appLifecycleService.registerListener(timeoutHandler)
 
             val openTelemetryRum = OpenTelemetryRumImpl(sdk, sessionManager)
 
             // Install instrumentations
-            val ctx = InstallationContext(application, openTelemetryRum.openTelemetry, sessionManager, serviceManager)
+            val ctx = InstallationContext(application, openTelemetryRum.openTelemetry, sessionManager)
             for (instrumentation in getInstrumentations()) {
                 instrumentation.install(ctx)
             }

core/src/main/java/io/opentelemetry/android/features/diskbuffering/scheduler/DefaultExportScheduleHandler.kt

@@ -5,14 +5,14 @@
 
 package io.opentelemetry.android.features.diskbuffering.scheduler
 
-import io.opentelemetry.android.internal.services.periodicwork.PeriodicWorkService
+import io.opentelemetry.android.internal.services.periodicwork.PeriodicWork
 import java.util.concurrent.atomic.AtomicBoolean
 
 class DefaultExportScheduleHandler(
     private val exportScheduler: DefaultExportScheduler,
-    private val periodicWorkServiceProvider: () -> PeriodicWorkService,
+    private val periodicWorkProvider: () -> PeriodicWork,
 ) : ExportScheduleHandler {
-    private val periodicWorkService by lazy { periodicWorkServiceProvider() }
+    private val periodicWorkService by lazy { periodicWorkProvider() }
     private val enabled = AtomicBoolean(false)
 
     override fun enable() {

core/src/main/java/io/opentelemetry/android/features/diskbuffering/scheduler/DefaultExportScheduler.kt

@@ -9,13 +9,13 @@ import android.util.Log
 import io.opentelemetry.android.common.RumConstants.OTEL_RUM_LOG_TAG
 import io.opentelemetry.android.features.diskbuffering.SignalFromDiskExporter
 import io.opentelemetry.android.internal.services.periodicwork.PeriodicRunnable
-import io.opentelemetry.android.internal.services.periodicwork.PeriodicWorkService
+import io.opentelemetry.android.internal.services.periodicwork.PeriodicWork
 import java.io.IOException
 import java.util.concurrent.TimeUnit
 
 class DefaultExportScheduler(
-    periodicWorkServiceProvider: () -> PeriodicWorkService,
-) : PeriodicRunnable(periodicWorkServiceProvider) {
+    periodicWorkProvider: () -> PeriodicWork,
+) : PeriodicRunnable(periodicWorkProvider) {
     companion object {
         private val DELAY_BEFORE_NEXT_EXPORT_IN_MILLIS = TimeUnit.SECONDS.toMillis(10)
     }

core/src/main/java/io/opentelemetry/android/internal/processors/ScreenAttributesLogRecordProcessor.kt

@@ -6,19 +6,19 @@
 package io.opentelemetry.android.internal.processors
 
 import io.opentelemetry.android.common.RumConstants
-import io.opentelemetry.android.internal.services.visiblescreen.VisibleScreenService
+import io.opentelemetry.android.internal.services.visiblescreen.VisibleScreenTracker
 import io.opentelemetry.context.Context
 import io.opentelemetry.sdk.logs.LogRecordProcessor
 import io.opentelemetry.sdk.logs.ReadWriteLogRecord
 
 class ScreenAttributesLogRecordProcessor(
-    val visibleScreenService: VisibleScreenService,
+    val visibleScreenTracker: VisibleScreenTracker,
 ) : LogRecordProcessor {
     override fun onEmit(
         context: Context,
         logRecord: ReadWriteLogRecord,
     ) {
-        val currentScreen = visibleScreenService.currentlyVisibleScreen
+        val currentScreen = visibleScreenTracker.currentlyVisibleScreen
         logRecord.setAttribute(RumConstants.SCREEN_NAME_KEY, currentScreen)
     }
 }