feat: Re-add obfuscation and make nice pretty print

kirre-bylund · kirre-bylund · commit a4246a8783a1 · 2025-11-14T13:09:44.000+01:00
diff --git a/Runtime/Client/LootLockerJson.cs b/Runtime/Client/LootLockerJson.cs
@@ -23,6 +23,7 @@ public static class LootLockerJsonSettings
     };
 #else
         public static readonly JsonOptions Default = new JsonOptions((JsonSerializationOptions.Default | JsonSerializationOptions.EnumAsText) & ~JsonSerializationOptions.SkipGetOnly);
+        public static readonly JsonOptions Indented = new JsonOptions((JsonSerializationOptions.Default | JsonSerializationOptions.EnumAsText) & ~JsonSerializationOptions.SkipGetOnly);
 #endif
     }
 
@@ -91,8 +92,12 @@ public static string PrettifyJsonString(string json)
             try
             {
                 var parsedJson = DeserializeObject<object>(json);
-                var tempSettings = LootLockerJsonSettings.Default;
-                tempSettings.Formatting = Formatting.Indented;
+                var tempSettings = new JsonSerializerSettings
+                {
+                    ContractResolver = LootLockerJsonSettings.Default.ContractResolver,
+                    Converters = LootLockerJsonSettings.Default.Converters,
+                    Formatting = Formatting.Indented
+                };
                 return SerializeObject(parsedJson, tempSettings);
             }
             catch (Exception)
@@ -163,7 +168,9 @@ public static string PrettifyJsonString(string json)
             try
             {
                 var parsedJson = DeserializeObject<object>(json);
-                return Json.SerializeFormatted(parsedJson, LootLockerJsonSettings.Default);
+                var indentedOptions = LootLockerJsonSettings.Default.Clone();
+                indentedOptions.FormattingTab = "  ";
+                return Json.SerializeFormatted(parsedJson, indentedOptions);
             }
             catch (Exception)
             {
diff --git a/Runtime/Client/LootLockerResponse.cs b/Runtime/Client/LootLockerResponse.cs
@@ -102,7 +102,7 @@ public class LootLockerResponseFactory
             return new T()
             {
                 success = true,
-                text = LootLockerConfig.current.prettifyJson ? LootLockerJson.PrettifyJsonString(responseBody) : responseBody,
+                text = responseBody,
                 statusCode = statusCode,
                 errorData = null,
                 requestContext = new LootLockerRequestContext(forPlayerWithUlid, requestTime)
@@ -117,7 +117,7 @@ public class LootLockerResponseFactory
             return new T()
             {
                 success = false,
-                text = LootLockerConfig.current.prettifyJson ? LootLockerJson.PrettifyJsonString(responseBody) : responseBody,
+                text = responseBody,
                 statusCode = statusCode,
                 errorData = null,
                 requestContext = new LootLockerRequestContext(forPlayerWithUlid, requestTime)
@@ -132,7 +132,7 @@ public class LootLockerResponseFactory
             return new T()
             {
                 success = failureResponse.success,
-                text = LootLockerConfig.current.prettifyJson ? LootLockerJson.PrettifyJsonString(failureResponse.text) : failureResponse.text,
+                text = failureResponse.text,
                 statusCode = failureResponse.statusCode,
                 errorData = failureResponse.errorData,
                 requestContext = failureResponse.requestContext
diff --git a/Runtime/Editor/LogViewer/LootLockerLogViewerUI.cs b/Runtime/Editor/LogViewer/LootLockerLogViewerUI.cs
@@ -216,15 +216,23 @@ private void ExportLogs()
                             if (!string.IsNullOrEmpty(http.RequestBody))
                             {
                                 sb.AppendLine("Request Body:");
-                                sb.AppendLine(http.RequestBody);
+                                sb.AppendLine(
+                                    LootLockerConfig.current.obfuscateLogs ?
+                                        LootLockerObfuscator.ObfuscateJsonStringForLogging(http.RequestBody) :
+                                        http.RequestBody
+                                );
                             }
                             sb.AppendLine("Response Headers:");
                             foreach (var h in http.ResponseHeaders ?? new Dictionary<string, string>())
                                 sb.AppendLine($"  {h.Key}: {h.Value}");
                             if (!string.IsNullOrEmpty(http.Response?.text))
                             {
                                 sb.AppendLine("Response Body:");
-                                sb.AppendLine(http.Response.text);
+                                sb.AppendLine(
+                                    LootLockerConfig.current.obfuscateLogs ?
+                                        LootLockerObfuscator.ObfuscateJsonStringForLogging(http.Response.text) :
+                                        http.Response.text
+                                );
                             }
                             writer.Write(sb.ToString());
                         }
@@ -401,25 +409,55 @@ private void AddHttpLogEntryToUI(LootLockerLogger.LootLockerHttpLogEntry entry)
             var reqHeaders = new TextField { value = $"Request Headers: {FormatHeaders(entry.RequestHeaders)}", isReadOnly = true };
             reqHeaders.AddToClassList("log-message-field");
             details.Add(reqHeaders);
+            
             if (!string.IsNullOrEmpty(entry.RequestBody))
             {
-                var reqBody = new TextField { value = $"Request Body: {entry.RequestBody}", isReadOnly = true };
-                reqBody.AddToClassList("log-message-field");
-                details.Add(reqBody);
+                var requestBodyFoldout = CreateJsonFoldout("Request Body", entry.RequestBody);
+                details.Add(requestBodyFoldout);
             }
+            
             var respHeaders = new TextField { value = $"Response Headers: {FormatHeaders(entry.ResponseHeaders)}", isReadOnly = true };
             respHeaders.AddToClassList("log-message-field");
             details.Add(respHeaders);
+            
             if (!string.IsNullOrEmpty(entry.Response?.text))
             {
-                var respBody = new TextField { value = $"Response Body: {entry.Response.text}", isReadOnly = true };
-                respBody.AddToClassList("log-message-field");
-                details.Add(respBody);
+                var responseBodyFoldout = CreateJsonFoldout("Response Body", entry.Response.text);
+                details.Add(responseBodyFoldout);
             }
+            
             foldout.Add(details);
             logContainer.Add(foldout);
         }
 
+        private Foldout CreateJsonFoldout(string title, string jsonContent)
+        {
+            // Initially show minified JSON (obfuscated if configured)
+            var obfuscatedJson = LootLockerConfig.current.obfuscateLogs
+                ? LootLockerObfuscator.ObfuscateJsonStringForLogging(jsonContent)
+                : jsonContent;
+            var prettifiedJson = LootLockerJson.PrettifyJsonString(obfuscatedJson);
+            var collapsedTitle = $"{title}: {obfuscatedJson}";
+
+            var foldout = new Foldout { text = collapsedTitle, value = false };
+
+            // Create a container for the JSON content
+            var jsonContainer = new VisualElement();
+
+            var jsonField = new TextField { value = prettifiedJson, isReadOnly = true, multiline = true };
+            jsonField.AddToClassList("log-message-field");
+            jsonField.style.whiteSpace = WhiteSpace.PreWrap;
+            jsonContainer.Add(jsonField);
+            
+            foldout.RegisterValueChangedCallback(evt =>
+            {
+                foldout.text = evt.newValue ? title : collapsedTitle;
+            });
+            
+            foldout.Add(jsonContainer);
+            return foldout;
+        }
+
         private string FormatHeaders(Dictionary<string, string> headers)
         {
             if (headers == null) return "";
diff --git a/Runtime/Editor/ProjectSettings.cs b/Runtime/Editor/ProjectSettings.cs
@@ -159,6 +159,15 @@ private void DrawGameSettings()
             }
             EditorGUILayout.Space();
 
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(m_CustomSettings.FindProperty("prettifyJson"), new GUIContent("Log JSON Formatted"));
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                gameSettings.prettifyJson = m_CustomSettings.FindProperty("prettifyJson").boolValue;
+            }
+            EditorGUILayout.Space();
+
             EditorGUI.BeginChangeCheck();
             EditorGUILayout.PropertyField(m_CustomSettings.FindProperty("allowTokenRefresh"));
 
diff --git a/Runtime/Game/LootLockerLogger.cs b/Runtime/Game/LootLockerLogger.cs
@@ -245,15 +245,15 @@ public static void LogHttpRequestResponse(LootLockerHttpLogEntry entry)
             if (!string.IsNullOrEmpty(entry.RequestBody))
             {
                 sb.AppendLine("Request Body:");
-                sb.AppendLine(entry.RequestBody);
+                sb.AppendLine(ObfuscateAndPrettifyJsonIfConfigured(entry.RequestBody));
             }
             sb.AppendLine("Response Headers:");
             foreach (var h in entry.ResponseHeaders ?? new Dictionary<string, string>())
                 sb.AppendLine($"  {h.Key}: {h.Value}");
             if (!string.IsNullOrEmpty(entry.Response?.text))
             {
                 sb.AppendLine("Response Body:");
-                sb.AppendLine(entry.Response.text);
+                sb.AppendLine(ObfuscateAndPrettifyJsonIfConfigured(entry.Response.text));
             }
 
             LogLevel level = entry.Response?.success ?? false ? LogLevel.Verbose : LogLevel.Error;
@@ -302,6 +302,19 @@ private void ReplayHttpLogRecord(ILootLockerHttpLogListener listener)
                 }
             }
         }
+
+        private static string ObfuscateAndPrettifyJsonIfConfigured(string json)
+        {
+            if (LootLockerConfig.current.obfuscateLogs)
+            {
+                json = LootLockerObfuscator.ObfuscateJsonStringForLogging(json);
+            }
+            if (LootLockerConfig.current.prettifyJson)
+            {
+                json = LootLockerJson.PrettifyJsonString(json);
+            }
+            return json;
+        }
     }
 
     public interface LootLockerLogListener
diff --git a/Runtime/Game/Resources/LootLockerConfig.cs b/Runtime/Game/Resources/LootLockerConfig.cs
@@ -173,13 +173,14 @@ static void ListInstalledPackagesRequestProgress()
         }
 #endif
 
-        public static bool CreateNewSettings(string apiKey, string gameVersion, string domainKey, LootLockerLogger.LogLevel logLevel = LootLockerLogger.LogLevel.Info, bool logInBuilds = false, bool errorsAsWarnings = false, bool allowTokenRefresh = false)
+        public static bool CreateNewSettings(string apiKey, string gameVersion, string domainKey, LootLockerLogger.LogLevel logLevel = LootLockerLogger.LogLevel.Info, bool logInBuilds = false, bool errorsAsWarnings = false, bool allowTokenRefresh = false, bool prettifyJson = false)
         {
             _current = Get();
 
             _current.apiKey = apiKey;
             _current.game_version = gameVersion;
             _current.logLevel = logLevel;
+            _current.prettifyJson = prettifyJson;
             _current.logInBuilds = logInBuilds;
             _current.logErrorsAsWarnings = errorsAsWarnings;
             _current.allowTokenRefresh = allowTokenRefresh;
@@ -199,6 +200,10 @@ public static bool ClearSettings()
             _current.apiKey = null;
             _current.game_version = null;
             _current.logLevel = LootLockerLogger.LogLevel.Info;
+            _current.prettifyJson = false;
+            _current.logInBuilds = false;
+            _current.logErrorsAsWarnings = false;
+            _current.obfuscateLogs = true;
             _current.allowTokenRefresh = true;
             _current.domainKey = null;
 #if UNITY_EDITOR
@@ -274,7 +279,9 @@ public static bool IsTargetingProductionEnvironment()
         [HideInInspector] public string baseUrl = UrlProtocol + GetUrlCore();
         [HideInInspector] public float clientSideRequestTimeOut = 180f;
         public LootLockerLogger.LogLevel logLevel = LootLockerLogger.LogLevel.Info;
+        // Write JSON in a pretty and indented format when logging
         public bool prettifyJson = true;
+        [HideInInspector] public bool obfuscateLogs = true;
         public bool logErrorsAsWarnings = false;
         public bool logInBuilds = false;
         public bool allowTokenRefresh = true;

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ public static class LootLockerJsonSettings`
`23`	`23`	`};`
`24`	`24`	`#else`
`25`	`25`	`public static readonly JsonOptions Default = new JsonOptions((JsonSerializationOptions.Default \| JsonSerializationOptions.EnumAsText) & ~JsonSerializationOptions.SkipGetOnly);`
	`26`	`+ public static readonly JsonOptions Indented = new JsonOptions((JsonSerializationOptions.Default \| JsonSerializationOptions.EnumAsText) & ~JsonSerializationOptions.SkipGetOnly);`
`26`	`27`	`#endif`
`27`	`28`	`}`
`28`	`29`
`@@ -91,8 +92,12 @@ public static string PrettifyJsonString(string json)`
`91`	`92`	`try`
`92`	`93`	`{`
`93`	`94`	`var parsedJson = DeserializeObject<object>(json);`
`94`		`- var tempSettings = LootLockerJsonSettings.Default;`
`95`		`- tempSettings.Formatting = Formatting.Indented;`
	`95`	`+ var tempSettings = new JsonSerializerSettings`
	`96`	`+ {`
	`97`	`+ ContractResolver = LootLockerJsonSettings.Default.ContractResolver,`
	`98`	`+ Converters = LootLockerJsonSettings.Default.Converters,`
	`99`	`+ Formatting = Formatting.Indented`
	`100`	`+ };`
`96`	`101`	`return SerializeObject(parsedJson, tempSettings);`
`97`	`102`	`}`
`98`	`103`	`catch (Exception)`
`@@ -163,7 +168,9 @@ public static string PrettifyJsonString(string json)`
`163`	`168`	`try`
`164`	`169`	`{`
`165`	`170`	`var parsedJson = DeserializeObject<object>(json);`
`166`		`- return Json.SerializeFormatted(parsedJson, LootLockerJsonSettings.Default);`
	`171`	`+ var indentedOptions = LootLockerJsonSettings.Default.Clone();`
	`172`	`+ indentedOptions.FormattingTab = " ";`
	`173`	`+ return Json.SerializeFormatted(parsedJson, indentedOptions);`
`167`	`174`	`}`
`168`	`175`	`catch (Exception)`
`169`	`176`	`{`
Original file line number	Diff line number	Diff line change
`@@ -245,15 +245,15 @@ public static void LogHttpRequestResponse(LootLockerHttpLogEntry entry)`
`245`	`245`	`if (!string.IsNullOrEmpty(entry.RequestBody))`
`246`	`246`	`{`
`247`	`247`	`sb.AppendLine("Request Body:");`
`248`		`- sb.AppendLine(entry.RequestBody);`
	`248`	`+ sb.AppendLine(ObfuscateAndPrettifyJsonIfConfigured(entry.RequestBody));`
`249`	`249`	`}`
`250`	`250`	`sb.AppendLine("Response Headers:");`
`251`	`251`	`foreach (var h in entry.ResponseHeaders ?? new Dictionary<string, string>())`
`252`	`252`	`sb.AppendLine($" {h.Key}: {h.Value}");`
`253`	`253`	`if (!string.IsNullOrEmpty(entry.Response?.text))`
`254`	`254`	`{`
`255`	`255`	`sb.AppendLine("Response Body:");`
`256`		`- sb.AppendLine(entry.Response.text);`
	`256`	`+ sb.AppendLine(ObfuscateAndPrettifyJsonIfConfigured(entry.Response.text));`
`257`	`257`	`}`
`258`	`258`
`259`	`259`	`LogLevel level = entry.Response?.success ?? false ? LogLevel.Verbose : LogLevel.Error;`
`@@ -302,6 +302,19 @@ private void ReplayHttpLogRecord(ILootLockerHttpLogListener listener)`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`	`}`
	`305`	`+`
	`306`	`+ private static string ObfuscateAndPrettifyJsonIfConfigured(string json)`
	`307`	`+ {`
	`308`	`+ if (LootLockerConfig.current.obfuscateLogs)`
	`309`	`+ {`
	`310`	`+ json = LootLockerObfuscator.ObfuscateJsonStringForLogging(json);`
	`311`	`+ }`
	`312`	`+ if (LootLockerConfig.current.prettifyJson)`
	`313`	`+ {`
	`314`	`+ json = LootLockerJson.PrettifyJsonString(json);`
	`315`	`+ }`
	`316`	`+ return json;`
	`317`	`+ }`
`305`	`318`	`}`
`306`	`319`
`307`	`320`	`public interface LootLockerLogListener`