Supporting minSdk v21 & updated the dependencies

.github/workflows/publish.yml

@@ -48,13 +48,13 @@ jobs:
         env:
           TAG: ${{ github.event.inputs.versionName }}
 
-      - name: Create Release on GitHub
-        id: create_release
-        uses: actions/create-release@v1
+      - name: Build Changelog
+        id: github_release
+        uses: mikepenz/release-changelog-builder-action@v3
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create Release
+        uses: mikepenz/[email protected]
         with:
-          tag_name: ${{ github.event.inputs.versionName }}
-          release_name: ${{ github.event.inputs.versionName }}
-          draft: false
-          prerelease: false
+          body: ${{steps.github_release.outputs.changelog}}

README.md

@@ -27,7 +27,7 @@
 
 ## Requirements
 
-- Android Minimum SDK Version : 26
+- Android Minimum SDK Version : 21
 
 ## Pre-requisites
 

sdk/build.gradle

@@ -37,18 +37,22 @@ android {
     compileSdk 34
 
     defaultConfig {
-        minSdk 26
+        minSdk 21
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         consumerProguardFiles "consumer-rules.pro"
     }
 
     buildTypes {
+        configureEach {
+            resValue("string", "rum.version", "${project.version}")
+        }
         release {
             minifyEnabled false
             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
         }
     }
     compileOptions {
+        coreLibraryDesugaringEnabled true
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
     }
@@ -61,29 +65,29 @@ android {
 }
 
 dependencies {
-    implementation platform("io.opentelemetry:opentelemetry-bom:1.31.0")
+    api platform('io.opentelemetry:opentelemetry-bom:1.32.0')
     implementation('io.opentelemetry:opentelemetry-api')
     implementation('io.opentelemetry:opentelemetry-exporter-logging')
     implementation 'io.opentelemetry.android:instrumentation:0.3.0-alpha-SNAPSHOT'
     implementation "io.opentelemetry:opentelemetry-sdk"
     implementation 'androidx.appcompat:appcompat:1.6.1'
     implementation 'com.google.android.material:material:1.10.0'
-    implementation 'io.opentelemetry:opentelemetry-exporter-otlp:1.31.0'
+    implementation 'io.opentelemetry:opentelemetry-exporter-otlp:1.32.0'
     implementation 'com.google.code.gson:gson:2.10.1'
     implementation 'io.opentelemetry:opentelemetry-contrib-trace-propagators:0.5.0'
-    implementation 'io.opentelemetry:opentelemetry-extension-trace-propagators:1.31.0'
+    implementation 'io.opentelemetry:opentelemetry-extension-trace-propagators:1.32.0'
     api "com.squareup.okhttp3:okhttp:4.12.0"
     implementation "io.opentelemetry.instrumentation:opentelemetry-okhttp-3.0"
     implementation 'androidx.work:work-runtime:2.8.1'
 
-    testImplementation("org.mockito:mockito-core:5.6.0")
-    testImplementation("org.mockito:mockito-junit-jupiter:5.6.0")
-    testImplementation(platform("org.junit:junit-bom:5.10.0"))
+    testImplementation('org.mockito:mockito-core:5.7.0')
+    testImplementation('org.mockito:mockito-junit-jupiter:5.7.0')
+    testImplementation(platform('org.junit:junit-bom:5.10.1'))
     testImplementation("org.junit.jupiter:junit-jupiter-api")
     testImplementation("org.junit.jupiter:junit-jupiter-engine")
     testImplementation("org.junit.vintage:junit-vintage-engine")
     testImplementation("io.opentelemetry:opentelemetry-sdk-testing")
-    testImplementation("org.robolectric:robolectric:4.10.3")
+    testImplementation('org.robolectric:robolectric:4.11.1')
     testImplementation("androidx.test:core:1.5.0")
     testImplementation("org.assertj:assertj-core:3.24.2")
 }

sdk/src/main/java/io/middleware/android/sdk/builders/MiddlewareBuilder.java

@@ -4,7 +4,6 @@
 import static io.middleware.android.sdk.utils.Constants.LOG_TAG;
 
 import android.app.Application;
-import android.os.Looper;
 import android.util.Log;
 
 import androidx.annotation.Nullable;
@@ -203,7 +202,15 @@ public boolean isCrashReportingEnabled() {
         return configFlags.isCrashReportingEnabled();
     }
 
+    public boolean isActivityLifecycleEnabled() {
+        return configFlags.isActivityLifecycleEnabled();
+    }
+
     public boolean isDebugEnabled() {
         return configFlags.isDebugEnabled();
     }
+
+    public ConfigFlags getConfigFlags() {
+        return configFlags;
+    }
 }

sdk/src/main/java/io/middleware/android/sdk/core/RumInitializer.java

@@ -2,6 +2,7 @@
 
 import static java.util.Objects.requireNonNull;
 import static io.middleware.android.sdk.utils.Constants.APP_NAME_KEY;
+import static io.middleware.android.sdk.utils.Constants.RUM_TRACER_NAME;
 import static io.opentelemetry.semconv.ResourceAttributes.BROWSER_MOBILE;
 import static io.opentelemetry.semconv.ResourceAttributes.DEPLOYMENT_ENVIRONMENT;
 import static io.opentelemetry.semconv.ResourceAttributes.SERVICE_NAME;
@@ -24,6 +25,7 @@
 
 import io.middleware.android.sdk.Middleware;
 import io.middleware.android.sdk.builders.MiddlewareBuilder;
+import io.middleware.android.sdk.core.models.InitializationEvents;
 import io.middleware.android.sdk.core.models.RumData;
 import io.middleware.android.sdk.core.services.RumServiceManager;
 import io.middleware.android.sdk.interfaces.IRum;
@@ -44,49 +46,73 @@ public class RumInitializer implements IRum {
     private final MiddlewareBuilder builder;
     private final Application application;
     private final AppStartupTimer appStartupTimer;
+    private final InitializationEvents initializerEvent;
 
     public RumInitializer(MiddlewareBuilder builder, Application application, AppStartupTimer appStartupTimer) {
         this.builder = builder;
         this.application = application;
         this.appStartupTimer = appStartupTimer;
+        this.initializerEvent = new InitializationEvents(appStartupTimer);
     }
 
     @Override
     public Middleware initialize(Function<Application, CurrentNetworkProvider> currentNetworkProviderFactory, Looper mainLooper) {
+        initializerEvent.begin();
         VisibleScreenTracker visibleScreenTracker = new VisibleScreenTracker();
         GlobalAttributesSpanAppender globalAttributesSpanAppender = GlobalAttributesSpanAppender.create(builder.globalAttributes);
         final CurrentNetworkProvider currentNetworkProvider = currentNetworkProviderFactory.apply(application);
         final RumSetup rumSetup = new RumSetup(application);
         Resource middlewareResource = createMiddlewareResource();
         rumSetup.mergeResource(middlewareResource);
+        initializerEvent.emit("resourceInitialized");
         rumSetup.setGlobalAttributes(globalAttributesSpanAppender);
+        initializerEvent.emit("globalAttributesInitialized");
         rumSetup.setNetworkAttributes(currentNetworkProvider);
+        initializerEvent.emit("networkAttributesInitialized");
         rumSetup.setScreenAttributes(visibleScreenTracker);
+        initializerEvent.emit("screenAttributesInitialized");
         rumSetup.setMetrics(builder.target, middlewareResource);
+        initializerEvent.emit("metricsInitialized");
         rumSetup.setTraces(builder.target, middlewareResource);
+        initializerEvent.emit("tracesInitialized");
         rumSetup.setLogs(builder.target, middlewareResource);
+        initializerEvent.emit("logsInitialized");
         if (builder.isDebugEnabled()) {
             rumSetup.setLoggingSpanExporter();
+            initializerEvent.emit("loggingSpanExporterInitialized");
         }
         rumSetup.setPropagators();
+        initializerEvent.emit("propagatorsInitialized");
 
         if (builder.isSlowRenderingDetectionEnabled()) {
             rumSetup.setSlowRenderingDetector(builder.slowRenderingDetectionPollInterval);
+            initializerEvent.emit("slowRenderingInitialized");
         }
 
         if (builder.isNetworkMonitorEnabled()) {
             rumSetup.setNetworkMonitor(currentNetworkProvider);
+            initializerEvent.emit("networkChangeInitialized");
         }
 
         if (builder.isAnrDetectionEnabled()) {
             rumSetup.setAnrDetector(mainLooper);
+            initializerEvent.emit("anrDetectionInitialized");
         }
 
         if (builder.isCrashReportingEnabled()) {
             rumSetup.setCrashReporter();
+            initializerEvent.emit("crashReportingInitialized");
         }
-        rumSetup.setLifecycleInstrumentations(visibleScreenTracker, appStartupTimer);
+
+        if (builder.isActivityLifecycleEnabled()) {
+            rumSetup.setLifecycleInstrumentations(visibleScreenTracker, appStartupTimer);
+            initializerEvent.emit("activityLifecycleInitialized");
+        }
+
         final OpenTelemetryRum openTelemetryRum = rumSetup.build();
+        initializerEvent.recordInitializationSpans(
+                builder.getConfigFlags(),
+                openTelemetryRum.getOpenTelemetry().getTracer(RUM_TRACER_NAME));
         return new Middleware(openTelemetryRum, rumSetup, globalAttributesSpanAppender);
     }
 

sdk/src/main/java/io/middleware/android/sdk/core/models/ConfigFlags.java

@@ -4,23 +4,17 @@
 
 public class ConfigFlags {
     private boolean debugEnabled = false;
-    private boolean diskBufferingEnabled = false;
+    private boolean activityLifecycleEnabled = true;
     private boolean reactNativeSupportEnabled = false;
     private boolean crashReportingEnabled = true;
     private boolean networkMonitorEnabled = true;
     private boolean anrDetectionEnabled = true;
     private boolean slowRenderingDetectionEnabled = true;
-    private boolean subprocessInstrumentationEnabled = true;
-    private boolean backgroundInstrumentationDeferredUntilForeground = false;
 
     public void enableDebug() {
         debugEnabled = true;
     }
 
-    public void enableDiskBuffering() {
-        diskBufferingEnabled = true;
-    }
-
     public void enableReactNativeSupport() {
         reactNativeSupportEnabled = true;
     }
@@ -41,24 +35,12 @@ public void disableSlowRenderingDetection() {
         slowRenderingDetectionEnabled = false;
     }
 
-    public void disableSubprocessInstrumentation() {
-        subprocessInstrumentationEnabled = false;
-    }
-
-    public void enableBackgroundInstrumentationDeferredUntilForeground() {
-        backgroundInstrumentationDeferredUntilForeground = true;
-    }
-
     public boolean isDebugEnabled() {
         return debugEnabled;
     }
 
-    public boolean isSubprocessInstrumentationEnabled() {
-        return subprocessInstrumentationEnabled;
-    }
-
-    public boolean isBackgroundInstrumentationDeferredUntilForeground() {
-        return backgroundInstrumentationDeferredUntilForeground;
+    public boolean isActivityLifecycleEnabled() {
+        return activityLifecycleEnabled;
     }
 
     public boolean isAnrDetectionEnabled() {
@@ -77,10 +59,6 @@ public boolean isCrashReportingEnabled() {
         return crashReportingEnabled;
     }
 
-    public boolean isDiskBufferingEnabled() {
-        return diskBufferingEnabled;
-    }
-
     public boolean isReactNativeSupportEnabled() {
         return reactNativeSupportEnabled;
     }
@@ -91,6 +69,9 @@ public String toString() {
         return "[debug:"
                 + debugEnabled
                 + ","
+                + "activityLifecycle:"
+                + activityLifecycleEnabled
+                + ","
                 + "crashReporting:"
                 + crashReportingEnabled
                 + ","

sdk/src/main/java/io/middleware/android/sdk/core/models/InitializationEvents.java

@@ -0,0 +1,64 @@
+package io.middleware.android.sdk.core.models;
+
+import static io.middleware.android.sdk.utils.Constants.COMPONENT_APPSTART;
+import static io.middleware.android.sdk.utils.Constants.COMPONENT_KEY;
+
+import io.opentelemetry.android.instrumentation.startup.AppStartupTimer;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.Tracer;
+import io.opentelemetry.context.Context;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+public class InitializationEvents {
+    private final AppStartupTimer startupTimer;
+    private final List<Event> events = new ArrayList<>();
+    private long startTimeNanos = -1;
+
+    public InitializationEvents(AppStartupTimer startupTimer) {
+        this.startupTimer = startupTimer;
+    }
+
+    public void begin() {
+        startTimeNanos = startupTimer.clockNow();
+    }
+
+    public void emit(String eventName) {
+        events.add(new Event(eventName, startupTimer.clockNow()));
+    }
+
+    public void recordInitializationSpans(ConfigFlags flags, Tracer delegateTracer) {
+        Tracer tracer =
+                spanName ->
+                        delegateTracer
+                                .spanBuilder(spanName)
+                                .setAttribute(COMPONENT_KEY, COMPONENT_APPSTART);
+
+        Span overallAppStart = startupTimer.start(tracer);
+        Span span =
+                tracer.spanBuilder("Middleware.initialize")
+                        .setParent(Context.current().with(overallAppStart))
+                        .setStartTimestamp(startTimeNanos, TimeUnit.NANOSECONDS)
+                        .startSpan();
+
+        span.setAttribute("config_settings", flags.toString());
+
+        for (Event initializationEvent : events) {
+            span.addEvent(initializationEvent.name, initializationEvent.time, TimeUnit.NANOSECONDS);
+        }
+        long spanEndTime = startupTimer.clockNow();
+        startupTimer.setCompletionCallback(() -> span.end(spanEndTime, TimeUnit.NANOSECONDS));
+    }
+
+    private static class Event {
+        private final String name;
+        private final long time;
+
+        private Event(String name, long time) {
+            this.name = name;
+            this.time = time;
+        }
+    }
+}