Develop merge into main

.github/workflows/android.yml

@@ -17,6 +17,7 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
+    timeout-minutes: 30
     steps:
       - uses: actions/checkout@v3
       - name: set up JDK 11

.github/workflows/workflowCleanup.yml

@@ -46,7 +46,7 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - run: |
-          echo n | .github/bin/trimWorkflowRuns
+          echo y | .github/bin/trimWorkflowRuns
         shell: bash
         env:
           GH_TOKEN: ${{ github.token }}

agent-core/src/main/java/com/newrelic/agent/android/AgentConfiguration.java

@@ -5,6 +5,7 @@
 
 package com.newrelic.agent.android;
 
+import com.newrelic.agent.android.aei.ApplicationExitConfiguration;
 import com.newrelic.agent.android.analytics.AnalyticsAttributeStore;
 import com.newrelic.agent.android.analytics.AnalyticsEventStore;
 import com.newrelic.agent.android.crash.CrashStore;
@@ -206,7 +207,7 @@ public void setApplicationFrameworkVersion(String applicationFrameworkVersion) {
         this.applicationFrameworkVersion = applicationFrameworkVersion;
     }
 
-    protected String provideSessionId() {
+    public String provideSessionId() {
         sessionID = UUID.randomUUID().toString();
         return sessionID;
     }

agent-core/src/main/java/com/newrelic/agent/android/RemoteConfiguration.java

@@ -6,9 +6,8 @@
 package com.newrelic.agent.android;
 
 import com.google.gson.annotations.SerializedName;
-import com.newrelic.agent.android.harvest.Harvest;
+import com.newrelic.agent.android.aei.ApplicationExitConfiguration;
 import com.newrelic.agent.android.harvest.HarvestConfigurable;
-import com.newrelic.agent.android.harvest.HarvestConfiguration;
 import com.newrelic.agent.android.harvest.HarvestLifecycleAware;
 import com.newrelic.agent.android.logging.LogLevel;
 import com.newrelic.agent.android.logging.LogReportingConfiguration;

agent-core/src/main/java/com/newrelic/agent/android/aei/AEISessionMapper.java

@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2024. New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package com.newrelic.agent.android.aei;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.reflect.TypeToken;
+import com.newrelic.agent.android.logging.AgentLogManager;
+import com.newrelic.agent.android.util.Streams;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class AEISessionMapper {
+
+    static final Gson gson = new GsonBuilder().create();
+
+    final File mapStore;
+    final Map<Integer, AEISessionMeta> mapper;
+
+    public AEISessionMapper(File mapStore) {
+        this.mapStore = mapStore;
+        this.mapper = new HashMap<>();
+        if (mapStore.exists()) {
+            load();
+        }
+    }
+
+    public AEISessionMapper put(int pid, AEISessionMeta model) {
+        if (model != null && !(model.sessionId == null || model.sessionId.isEmpty())) {
+            mapper.putIfAbsent(pid, model);
+        } else {
+            AgentLogManager.getAgentLog().debug("Refusing to store null or empty session model for pid[" + pid + "]");
+        }
+
+        return this;
+    }
+
+    public AEISessionMeta get(int pid) {
+        return mapper.getOrDefault(pid, null);
+    }
+
+    public String getSessionId(int pid) {
+        AEISessionMeta model = get(pid);
+        return model == null ? "" : model.sessionId;
+    }
+
+    public int getRealAgentID(int pid) {
+        AEISessionMeta model = get(pid);
+        return model == null ? 0 : model.realAgentId;
+    }
+
+    public String getOrDefault(int pid, String defaultSessionId) {
+        AEISessionMeta model = get(pid);
+        return (model == null || model.sessionId == null || model.sessionId.isEmpty())
+                ? defaultSessionId : model.sessionId;
+    }
+
+    @SuppressWarnings("unchecked")
+    public AEISessionMapper load() {
+        if (mapStore.exists() && mapStore.canRead()) {
+            try {
+                String storeData = Streams.slurpString(mapStore, StandardCharsets.UTF_8.toString());
+                final Type gtype = new TypeToken<Map<Integer, AEISessionMeta>>(){}.getType();
+                Map map = gson.fromJson(storeData, gtype);
+
+                map.forEach((key, val) -> mapper.putIfAbsent((Integer) key, (AEISessionMeta) val));
+
+            } catch (Exception e) {
+                AgentLogManager.getAgentLog().error("Cannot read session ID mapper: " + e);
+            }
+        } else {
+            AgentLogManager.getAgentLog().debug("Cannot read session ID mapper: file does not exist or is unreadable");
+        }
+
+        return this;
+    }
+
+    public boolean flush() {
+        if (mapper.isEmpty()) {
+            mapStore.delete();
+        } else {
+            try (BufferedWriter os = Streams.newBufferedFileWriter(mapStore)) {
+                os.write(gson.toJson(mapper));
+                os.flush();
+
+            } catch (IOException e) {
+                AgentLogManager.getAgentLog().error("Cannot write session ID mapping file: " + e);
+            }
+        }
+        return mapStore.exists() && mapStore.canRead();
+    }
+
+    public void clear() {
+        mapper.clear();
+    }
+
+    public void delete() {
+        if (mapStore.exists()) {
+            mapStore.delete();
+        }
+    }
+
+    public void erase(int pid) {
+        mapper.remove(pid);
+    }
+
+    public int size() {
+        return mapper.size();
+    }
+
+    /**
+     * Remove any elements whose key's are *not* in the passed set
+     */
+    synchronized public void erase(Set<Integer> pidSet) {
+        Set<Integer> currentKeySet = mapper.keySet();
+        currentKeySet.stream()
+                .filter(pid -> !pidSet.contains(pid))
+                .collect(Collectors.toSet())
+                .forEach(pid -> mapper.remove(pid));
+    }
+
+    public static class AEISessionMeta {
+        final String sessionId;
+        final int realAgentId;
+
+        public AEISessionMeta(String sessionId, int realAgentId) {
+            this.sessionId = sessionId == null ? "" : sessionId;
+            this.realAgentId = realAgentId;
+        }
+
+        public boolean isValid() {
+            return !(sessionId == null || sessionId.isEmpty() || realAgentId == 0);
+        }
+    }
+}

agent-core/src/main/java/com/newrelic/agent/android/aei/AEITrace.java

@@ -0,0 +1,106 @@
+package com.newrelic.agent.android.aei;
+
+import com.newrelic.agent.android.logging.AgentLogManager;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+/**
+ * Model for the collected AEI trace data.
+ *
+ * The AEI trace filters and reduces the system trace returned
+ * by ApplicationExitInfo.getTraceInputStream() to just the data expected at ingest.
+ */
+public class AEITrace {
+    final static Pattern TRACE_HEADER_REGEXP = Pattern.compile(".*----- pid (?<pid>.\\d+) at (?<timeCreated>\\d{4}-\\d{2}-\\d{2}[T ]{0,}[0-9:.-]+) -----(?<body>.*$)");
+    final static Pattern TRACE_THREADS_REGEXP = Pattern.compile(".*DALVIK THREADS \\((?<threadCnt>\\d+)\\):\\s(.*)----- end (\\d+) -----", Pattern.MULTILINE);
+    final static Pattern TRACE_THREAD_ID_REGEXP = Pattern.compile("^\"(?<threadName>.*)\" (.*)prio=(\\d+).*$");
+
+    final ArrayList<String> threads;
+    String pid;
+    String createTime;
+
+    public AEITrace() {
+        threads = new ArrayList<String>();
+    }
+
+    public AEITrace(File filePath) {
+        this();
+    }
+
+    public AEITrace(int pid, File artifact) {
+        this(artifact);
+        this.pid = String.valueOf(pid);
+    }
+
+    public AEITrace decomposeFromSystemTrace(String sysTrace) {
+
+        // replace newlines with tabs to parse the entire trace as a tab delimited string
+        sysTrace = sysTrace.strip().replace('\n', '\t');
+
+        // ----- pid 4473 at 2024-02-15 23:37:45.593138790-0800 -----
+        Matcher headerMatcher = TRACE_HEADER_REGEXP.matcher(sysTrace);
+        if (headerMatcher.matches()) {
+            if (null == pid || pid.isBlank()) {
+                pid = headerMatcher.group(1);
+            }
+            createTime = headerMatcher.group(2).strip();
+        } else {
+            AgentLogManager.getAgentLog().debug("The trace file does not contain the expected file header.");
+        }
+
+        // DALVIK THREADS (<nThreads>):\n<thread 0>\n<thread 1>...\n<thread n>\n----- end (<pid>) -----
+        Matcher threadsMatcher = TRACE_THREADS_REGEXP.matcher(sysTrace);
+        if (threadsMatcher.matches()) {
+            String threadData = threadsMatcher.group(2).strip();
+            parseThreadsData(threadData);
+        } else {
+            AgentLogManager.getAgentLog().error("The trace file does not contain the expected threads data.");
+            // TODO try to parse the file anyway?
+            // parseThreadsData(sysTrace);
+        }
+
+        return this;
+    }
+
+    private ArrayList<String> parseThreadsData(String threadData) {
+        if (!(threadData == null || threadData.isEmpty())) {
+            threads.addAll(List.of(threadData.split("\t\t")));
+            threads.removeIf(s -> !TRACE_THREAD_ID_REGEXP.matcher(s).matches());
+            threads.replaceAll(s -> {
+                String[] frames = s.split("\t");
+                return Arrays.stream(frames)
+                        .filter(s1 -> !s1.trim().matches("[(|-].*"))
+                        .collect(Collectors.joining("\n"));
+            });
+        }
+
+        return threads;
+    }
+
+    public ArrayList<String> getThreads() {
+        return threads;
+    }
+
+    public String getPid() {
+        return pid;
+    }
+
+    public String getCreateTime() {
+        return createTime;
+    }
+
+    @Override
+    public String toString() {
+        // transform trace data per DEM spec
+        String flattenedThreads = threads.stream()
+                .collect(Collectors.joining("\n\n"));
+
+        return flattenedThreads;
+    }
+}