Feature/background aware span export

sample-app/build.gradle.kts

@@ -71,6 +71,7 @@ dependencies {
     implementation(project(":splunk-otel-android"))
     implementation(project(":splunk-otel-android-volley"))
     implementation("com.android.volley:volley:1.2.1")
+    implementation("androidx.work:work-runtime:2.8.1")
     implementation("io.opentelemetry.instrumentation:opentelemetry-instrumentation-api")
     implementation("io.opentelemetry.instrumentation:opentelemetry-instrumentation-api-semconv")
 

sample-app/src/main/AndroidManifest.xml

@@ -25,6 +25,10 @@
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
+        <service
+            android:name=".SplunkBackgroundService"
+            android:exported="false"
+            android:process=":my_service_process"/>
     </application>
 
 </manifest>

sample-app/src/main/java/com/splunk/android/sample/DemoWorker.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright Splunk Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.splunk.android.sample;
+
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.work.Worker;
+import androidx.work.WorkerParameters;
+import com.splunk.rum.SplunkRum;
+import io.opentelemetry.api.common.Attributes;
+
+public class DemoWorker extends Worker {
+
+    private Context context;
+    public static final String TAG = "SplunkRum";
+
+    public DemoWorker(@NonNull Context context, @NonNull WorkerParameters params) {
+        super(context, params);
+        this.context = context;
+    }
+
+    @NonNull
+    @Override
+    public Result doWork() {
+        try {
+            SplunkRum.getInstance().addRumEvent("DemoWorker is doing work", Attributes.empty());
+            Log.d(TAG, "DemoWorker Starting background Service");
+            startBackgroundService();
+            return Result.success();
+        } catch (Exception e) {
+            return Result.failure();
+        }
+    }
+
+    private void startBackgroundService() {
+        Intent serviceIntent = new Intent(context, SplunkBackgroundService.class);
+        Log.d(TAG, "Starting background Service");
+        context.startService(serviceIntent);
+    }
+}

sample-app/src/main/java/com/splunk/android/sample/FirstFragment.java

@@ -110,6 +110,11 @@ public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
                 });
 
         sessionId.postValue(splunkRum.getRumSessionId());
+
+        binding.workManager.setOnClickListener(
+                v -> {
+                    WorkManagerHelper.startWorkManager(this.getContext());
+                });
     }
 
     private void multiThreadCrashing() {

sample-app/src/main/java/com/splunk/android/sample/MainActivity.java

@@ -38,6 +38,9 @@
 import androidx.navigation.Navigation;
 import androidx.navigation.ui.AppBarConfiguration;
 import androidx.navigation.ui.NavigationUI;
+import androidx.work.ExistingPeriodicWorkPolicy;
+import androidx.work.PeriodicWorkRequest;
+import androidx.work.WorkManager;
 import com.splunk.android.sample.databinding.ActivityMainBinding;
 import com.splunk.rum.SplunkRum;
 import io.opentelemetry.android.instrumentation.RumScreenName;
@@ -74,6 +77,18 @@ protected void onCreate(Bundle savedInstanceState) {
                 view -> {
                     new MailDialogFragment(this).show(getSupportFragmentManager(), "Mail");
                 });
+        setUpPeriodicWorker();
+    }
+
+    private void setUpPeriodicWorker() {
+        PeriodicWorkRequest workRequest =
+                new PeriodicWorkRequest.Builder(DemoWorker.class, 15, TimeUnit.MINUTES).build();
+
+        WorkManager.getInstance(this)
+                .enqueueUniquePeriodicWork(
+                        "backgroundsplunk",
+                        ExistingPeriodicWorkPolicy.CANCEL_AND_REENQUEUE,
+                        workRequest);
     }
 
     @Override

sample-app/src/main/java/com/splunk/android/sample/SampleApplication.java

@@ -42,7 +42,8 @@ public void onCreate() {
                 .setRumAccessToken(getResources().getString(R.string.rum_access_token))
                 .enableDebug()
                 .enableDiskBuffering()
-                .disableBackgroundTaskReporting(BuildConfig.APPLICATION_ID)
+                .disableSubprocessInstrumentation(BuildConfig.APPLICATION_ID)
+                .enableBackgroundInstrumentationDeferredUntilForeground()
                 .setSlowRenderingDetectionPollInterval(Duration.ofMillis(1000))
                 .setDeploymentEnvironment("demo")
                 .limitDiskUsageMegabytes(1)

sample-app/src/main/java/com/splunk/android/sample/SplunkBackgroundService.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright Splunk Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.splunk.android.sample;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+import android.util.Log;
+
+public class SplunkBackgroundService extends Service {
+    public static final String TAG = "SplunkRum";
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        if (intent != null) {
+            Log.d(TAG, "Service started on different thread");
+        }
+        stopSelf();
+        return START_STICKY;
+    }
+}

sample-app/src/main/java/com/splunk/android/sample/WorkManagerHelper.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright Splunk Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.splunk.android.sample;
+
+import android.content.Context;
+import androidx.work.OneTimeWorkRequest;
+import androidx.work.WorkManager;
+import androidx.work.WorkRequest;
+
+public class WorkManagerHelper {
+
+    public static void startWorkManager(Context context) {
+        WorkRequest demoWorkRequest = new OneTimeWorkRequest.Builder(DemoWorker.class).build();
+        WorkManager.getInstance(context).enqueue(demoWorkRequest);
+    }
+}

sample-app/src/main/res/layout/fragment_first.xml

@@ -77,6 +77,13 @@
                 android:layout_marginTop="8dp"
                 android:text="@string/volley_client" />
 
+            <Button
+                android:id="@+id/work_manager"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="8dp"
+                android:text="@string/worker" />
+
             <TextView
                 android:id="@+id/session_id"
                 android:layout_width="wrap_content"

sample-app/src/main/res/values/strings.xml

@@ -16,6 +16,7 @@
     <string name="http_me_up">HTTP me up!</string>
     <string name="http_me_bad">Http Error</string>
     <string name="volley_client">Volley HTTP</string>
+    <string name="worker">Worker</string>
     <string name="http_not_found">HTTP Not Found</string>
 
     <string name="local_web_view">Local WebView</string>

splunk-otel-android/src/main/java/com/splunk/rum/ConfigFlags.java

@@ -26,7 +26,8 @@ class ConfigFlags {
     private boolean networkMonitorEnabled = true;
     private boolean anrDetectionEnabled = true;
     private boolean slowRenderingDetectionEnabled = true;
-    private boolean backgroundTaskInstrumentationEnabled = true;
+    private boolean subprocessInstrumentationEnabled = true;
+    private boolean backgroundInstrumentationDeferredUntilForeground = false;
 
     void enableDebug() {
         debugEnabled = true;
@@ -56,16 +57,24 @@ void disableSlowRenderingDetection() {
         slowRenderingDetectionEnabled = false;
     }
 
-    public void disableBackgroundTaskDetection() {
-        backgroundTaskInstrumentationEnabled = false;
+    public void disableSubprocessInstrumentation() {
+        subprocessInstrumentationEnabled = false;
+    }
+
+    public void enableBackgroundInstrumentationDeferredUntilForeground() {
+        backgroundInstrumentationDeferredUntilForeground = true;
     }
 
     boolean isDebugEnabled() {
         return debugEnabled;
     }
 
-    boolean isBackgroundTaskInstrumentationEnabled() {
-        return backgroundTaskInstrumentationEnabled;
+    boolean isSubprocessInstrumentationEnabled() {
+        return subprocessInstrumentationEnabled;
+    }
+
+    boolean isBackgroundInstrumentationDeferredUntilForeground() {
+        return backgroundInstrumentationDeferredUntilForeground;
     }
 
     boolean isAnrDetectionEnabled() {

splunk-otel-android/src/main/java/com/splunk/rum/DefaultMemorySpanBuffer.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright Splunk Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.splunk.rum;
+
+import io.opentelemetry.sdk.trace.data.SpanData;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Queue;
+
+public class DefaultMemorySpanBuffer implements MemorySpanBuffer {
+
+    // note: no need to make this queue thread-safe since it will only ever be called from the
+    // BatchSpanProcessor worker thread.
+    private final Queue<SpanData> backlog = new ArrayDeque<>();
+
+    @Override
+    public void addAll(Collection<SpanData> spans) {
+        backlog.addAll(spans);
+    }
+
+    @Override
+    public void addFailedSpansToBacklog(SpanData spanData) {
+        backlog.add(spanData);
+    }
+
+    @Override
+    public List<SpanData> drain() {
+        List<SpanData> retries = new ArrayList<>(backlog);
+        backlog.clear();
+        return retries;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return backlog.isEmpty();
+    }
+
+    @Override
+    public void clear() {
+        backlog.clear();
+    }
+
+    @Override
+    public int size() {
+        return backlog.size();
+    }
+}

splunk-otel-android/src/main/java/com/splunk/rum/DefaultSpanStorage.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright Splunk Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.splunk.rum;
+
+import android.util.Log;
+import java.io.File;
+import java.util.stream.Stream;
+
+public class DefaultSpanStorage implements SpanStorage {
+
+    private final FileUtils fileUtils;
+    private final File rootDir;
+
+    public DefaultSpanStorage(FileUtils fileUtils, File rootDir) {
+        this.fileUtils = fileUtils;
+        this.rootDir = rootDir;
+    }
+
+    @Override
+    public File provideSpanFile() {
+        File spansPath = fileUtils.getSpansDirectory(rootDir);
+        if (spansPath.exists() || spansPath.mkdirs()) {
+            return spansPath;
+        }
+
+        Log.e(
+                SplunkRum.LOG_TAG,
+                "Error creating path " + spansPath + " for span buffer, defaulting to parent");
+        return rootDir;
+    }
+
+    @Override
+    public Stream<File> getAllSpanFiles() {
+        return fileUtils.listSpanFiles(provideSpanFile());
+    }
+
+    @Override
+    public long getTotalFileSizeInBytes() {
+        return fileUtils.getTotalFileSizeInBytes(provideSpanFile());
+    }
+
+    @Override
+    public Stream<File> getPendingFiles() {
+        return fileUtils.listSpanFiles(provideSpanFile());
+    }
+}