Crashlytics Add Internal Keys feature for Unity Metadata

Author: samedson

firebase-crashlytics/src/androidTest/java/com/google/firebase/crashlytics/internal/common/MetaDataStoreTest.java

@@ -222,6 +222,32 @@ public void testWriteKeys_readDifferentSession() {
     assertEquals(0, readKeys.size());
   }
 
+  public void testWriteKeys_readSeparateFromUser() {
+    final Map<String, String> keys =
+            new HashMap<String, String>() {
+              {
+                put(KEY_1, VALUE_1);
+              }
+            };
+
+    final Map<String, String> internalKeys =
+            new HashMap<String, String>() {
+              {
+                put(KEY_2, VALUE_2);
+                put(KEY_3, VALUE_3);
+              }
+            };
+
+    storeUnderTest.writeKeyData(SESSION_ID_1, keys);
+    storeUnderTest.writeKeyData(SESSION_ID_1, internalKeys, /*isInternal=*/ true);
+
+    final Map<String, String> readKeys = storeUnderTest.readKeyData(SESSION_ID_1);
+    final Map<String, String> readInternalKeys = storeUnderTest.readKeyData(SESSION_ID_1, true);
+
+    assertEqualMaps(keys, readKeys);
+    assertEqualMaps(internalKeys, readInternalKeys);
+  }
+
   public void testReadKeys_noStoredData() {
     final Map<String, String> readKeys = storeUnderTest.readKeyData(SESSION_ID_1);
     assertEquals(0, readKeys.size());

firebase-crashlytics/src/main/java/com/google/firebase/crashlytics/internal/common/CrashlyticsController.java

@@ -67,6 +67,7 @@ class CrashlyticsController {
   private final DataCollectionArbiter dataCollectionArbiter;
   private final CrashlyticsFileMarker crashMarker;
   private final UserMetadata userMetadata;
+  private final InternalKeys internalKeys;
 
   private final CrashlyticsBackgroundWorker backgroundWorker;
 
@@ -109,6 +110,7 @@ class CrashlyticsController {
       CrashlyticsFileMarker crashMarker,
       AppData appData,
       UserMetadata userMetadata,
+      InternalKeys internalKeys,
       LogFileManager logFileManager,
       LogFileManager.DirectoryProvider logFileDirectoryProvider,
       SessionReportingCoordinator sessionReportingCoordinator,
@@ -122,6 +124,7 @@ class CrashlyticsController {
     this.crashMarker = crashMarker;
     this.appData = appData;
     this.userMetadata = userMetadata;
+    this.internalKeys = internalKeys;
     this.logFileManager = logFileManager;
     this.logFileDirectoryProvider = logFileDirectoryProvider;
     this.nativeComponent = nativeComponent;
@@ -434,14 +437,28 @@ void setCustomKey(String key, String value) {
         return;
       }
     }
-    cacheKeyData(userMetadata.getCustomKeys());
+    cacheKeyData(userMetadata.getCustomKeys(), false);
   }
 
   void setCustomKeys(Map<String, String> keysAndValues) {
     // Write all the key/value pairs before doing anything computationally expensive.
     userMetadata.setCustomKeys(keysAndValues);
     // Once all the key/value pairs are added, update the cache.
-    cacheKeyData(userMetadata.getCustomKeys());
+    cacheKeyData(userMetadata.getCustomKeys(), false);
+  }
+
+  void setInternalKey(String key, String value) {
+    try {
+      internalKeys.setInternalKey(key, value);
+    } catch (IllegalArgumentException ex) {
+      if (context != null && CommonUtils.isAppDebuggable(context)) {
+        throw ex;
+      } else {
+        Logger.getLogger().e("Attempting to set custom attribute with null key, ignoring.");
+        return;
+      }
+    }
+    cacheKeyData(internalKeys.getInternalKeys(), true);
   }
 
   /**
@@ -475,13 +492,13 @@ public Void call() throws Exception {
    * crash happens immediately after setting a value. If this becomes a problem, we can investigate
    * writing synchronously, or potentially add an explicit user-facing API for synchronous writes.
    */
-  private void cacheKeyData(final Map<String, String> keyData) {
+  private void cacheKeyData(final Map<String, String> keyData, boolean isInternal) {
     backgroundWorker.submit(
         new Callable<Void>() {
           @Override
           public Void call() throws Exception {
             final String currentSessionId = getCurrentSessionId();
-            new MetaDataStore(getFilesDir()).writeKeyData(currentSessionId, keyData);
+            new MetaDataStore(getFilesDir()).writeKeyData(currentSessionId, keyData, isInternal);
             return null;
           }
         });

firebase-crashlytics/src/main/java/com/google/firebase/crashlytics/internal/common/CrashlyticsCore.java

@@ -131,7 +131,7 @@ public boolean onPreExecute(AppData appData, SettingsDataProvider settingsProvid
       initializationMarker = new CrashlyticsFileMarker(INITIALIZATION_MARKER_FILE_NAME, fileStore);
 
       final UserMetadata userMetadata = new UserMetadata();
-
+      final InternalKeys internalKeys = new InternalKeys();
       final LogFileDirectoryProvider logFileDirectoryProvider =
           new LogFileDirectoryProvider(fileStore);
       final LogFileManager logFileManager = new LogFileManager(context, logFileDirectoryProvider);
@@ -160,6 +160,7 @@ public boolean onPreExecute(AppData appData, SettingsDataProvider settingsProvid
               crashMarker,
               appData,
               userMetadata,
+              internalKeys,
               logFileManager,
               logFileDirectoryProvider,
               sessionReportingCoordinator,

firebase-crashlytics/src/main/java/com/google/firebase/crashlytics/internal/common/InternalKeys.java

@@ -0,0 +1,100 @@
+// Copyright 2021 Google LLC
+//
+// 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.google.firebase.crashlytics.internal.common;
+
+import androidx.annotation.NonNull;
+
+import com.google.firebase.crashlytics.internal.Logger;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/** Handles custom attributes internal to the SDK, eg. for custom Unity metadata. */
+public class InternalKeys {
+    static final int MAX_INTERNAL_KEYS = 64;
+    static final int MAX_INTERNAL_KEY_SIZE = 8192;
+
+    private final Map<String, String> internal_keys = new HashMap<>();
+
+    public InternalKeys() {}
+
+    @NonNull
+    public Map<String, String> getInternalKeys() {
+        return Collections.unmodifiableMap(internal_keys);
+    }
+
+    public void setInternalKey(String key, String value) {
+        setSyncInternalKeys(
+                new HashMap<String, String>() {
+                    {
+                        put(sanitizeKey(key), sanitizeAttribute(value));
+                    }
+                });
+    }
+
+    /** Gatekeeper function for access to attributes */
+    private synchronized void setSyncInternalKeys(Map<String, String> keysAndValues) {
+        // We want all access to the attributes hashmap to be locked so that there is no way to create
+        // a race condition and add more than MAX_ATTRIBUTES keys.
+
+        // Update any existing keys first, then add any additional keys
+        Map<String, String> currentKeys = new HashMap<String, String>();
+        Map<String, String> newKeys = new HashMap<String, String>();
+
+        // Split into current and new keys
+        for (Map.Entry<String, String> entry : keysAndValues.entrySet()) {
+            String key = sanitizeKey(entry.getKey());
+            String value = (entry.getValue() == null) ? "" : sanitizeAttribute(entry.getValue());
+            if (internal_keys.containsKey(key)) {
+                currentKeys.put(key, value);
+            } else {
+                newKeys.put(key, value);
+            }
+        }
+
+        internal_keys.putAll(currentKeys);
+
+        // Add new keys if there is space
+        if (internal_keys.size() + newKeys.size() > MAX_INTERNAL_KEYS) {
+            int keySlotsLeft = MAX_INTERNAL_KEYS - internal_keys.size();
+            Logger.getLogger()
+                    .v("Exceeded maximum number of internal keys (" + MAX_INTERNAL_KEYS + ").");
+            List<String> newKeyList = new ArrayList<>(newKeys.keySet());
+            newKeys.keySet().retainAll(newKeyList.subList(0, keySlotsLeft));
+        }
+        internal_keys.putAll(newKeys);
+    }
+
+    /** Checks that the key is not null then sanitizes it. */
+    private static String sanitizeKey(String key) {
+        if (key == null) {
+            throw new IllegalArgumentException("Custom attribute key must not be null.");
+        }
+        return sanitizeAttribute(key);
+    }
+
+    /** Trims the string and truncates it to MAX_ATTRIBUTE_SIZE. */
+    private static String sanitizeAttribute(String input) {
+        if (input != null) {
+            input = input.trim();
+            if (input.length() > MAX_INTERNAL_KEY_SIZE) {
+                input = input.substring(0, MAX_INTERNAL_KEY_SIZE);
+            }
+        }
+        return input;
+    }
+}

firebase-crashlytics/src/main/java/com/google/firebase/crashlytics/internal/common/MetaDataStore.java

@@ -41,6 +41,7 @@ class MetaDataStore {
 
   private static final String USERDATA_SUFFIX = "user";
   private static final String KEYDATA_SUFFIX = "keys";
+  private static final String INTERNAL_KEYDATA_SUFFIX = "internal-keys";
   private static final String METADATA_EXT = ".meta";
 
   private static final String KEY_USER_ID = "userId";
@@ -83,9 +84,12 @@ public UserMetadata readUserData(String sessionId) {
     }
     return new UserMetadata();
   }
-
   public void writeKeyData(String sessionId, Map<String, String> keyData) {
-    final File f = getKeysFileForSession(sessionId);
+    writeKeyData(sessionId, keyData, false);
+  }
+
+  void writeKeyData(String sessionId, Map<String, String> keyData, boolean isInternal) {
+    final File f = isInternal ? getInternalKeysFileForSession(sessionId) : getKeysFileForSession(sessionId);
     Writer writer = null;
     try {
       final String keyDataString = keysDataToJson(keyData);
@@ -100,7 +104,11 @@ public void writeKeyData(String sessionId, Map<String, String> keyData) {
   }
 
   public Map<String, String> readKeyData(String sessionId) {
-    final File f = getKeysFileForSession(sessionId);
+    return readKeyData(sessionId, false);
+  }
+
+  Map<String, String> readKeyData(String sessionId, boolean isInternal) {
+    final File f = isInternal ? getInternalKeysFileForSession(sessionId) : getKeysFileForSession(sessionId);
     if (!f.exists()) {
       return Collections.emptyMap();
     }
@@ -127,6 +135,11 @@ public File getKeysFileForSession(String sessionId) {
     return new File(filesDir, sessionId + KEYDATA_SUFFIX + METADATA_EXT);
   }
 
+  @NonNull
+  public File getInternalKeysFileForSession(String sessionId) {
+    return new File(filesDir, sessionId + INTERNAL_KEYDATA_SUFFIX + METADATA_EXT);
+  }
+
   private static UserMetadata jsonToUserData(String json) throws JSONException {
     final JSONObject dataObj = new JSONObject(json);
     UserMetadata metadata = new UserMetadata();