com.amanotes.gdk 0.2.50 → 0.2.52

package/Runtime/AmaGDK.Analytics.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -21,37 +22,52 @@ namespace Amanotes.Core
 
             public class EventParams : IEventParamsBuilder
             {
-                public readonly string eventName;
-                public Dictionary<string, object> parameters = new Dictionary<string, object>();
+                public string eventName { get; private set; }
+                public readonly Dictionary<string, object> parameters = new Dictionary<string, object>();
                 public string funnelSignature;
                 public bool accumulated;
                 public bool withinSession;
                 public bool doNotIncreaseCounter;
 
                 public bool overrideConfig;
-                public HashSet<string> ignoreAdapterIds = new HashSet<string>();
-                public HashSet<string> allowAdapterIds = new HashSet<string>();
+                public HashSet<string> ignoreAdapterIds = null;
+                public HashSet<string> allowAdapterIds = null;
 
-                public EventDetail EventDetail => localData.GetEventDetail(eventName, true);
-
-                public EventParams(string eventName)
+                private EventDetail _detail;
+                public EventDetail EventDetail
                 {
-                    this.eventName = eventName;
+                    get
+                    {
+                        if (_detail != null) return _detail;
+                        return _detail = localData.GetEventDetail(eventName, true);
+                    }
                 }
 
-                public bool IsFunnelEvent
+                internal EventParams Init(string eventName)
                 {
-                    get { return !string.IsNullOrEmpty(funnelSignature); }
+                    this.eventName = eventName;
+                    parameters.Clear();
+                    funnelSignature = "";
+                    accumulated = false;
+                    withinSession = false;
+                    doNotIncreaseCounter = false;
+                    overrideConfig = false;
+                    ignoreAdapterIds = null;
+                    allowAdapterIds = null;
+                    _detail = null;
+                    return this;
                 }
 
+                public bool IsFunnelEvent => !string.IsNullOrEmpty(funnelSignature);
+
                 public bool IsAdapterForbidden(string adapterId)
                 {
-                    if (ignoreAdapterIds.Count > 0)
+                    if (ignoreAdapterIds != null && ignoreAdapterIds.Count > 0)
                     {
                         return ignoreAdapterIds.Contains(adapterId);
                     }
 
-                    if (allowAdapterIds.Count > 0)
+                    if (allowAdapterIds != null && allowAdapterIds.Count > 0)
                     {
                         return !allowAdapterIds.Contains(adapterId);
                     }
@@ -71,31 +87,22 @@ namespace Amanotes.Core
 
             public static IEventParamsBuilder LogEvent(string eventName)
             {
-                NormalizeEventName(ref eventName, true);
-                if (localData.GetEventDetail(eventName) == null && localData.eventDetails.Count >= 500)
-                {
-                    LogWarning($" - You have reported 500 types of events. New event <{eventName}> will be ignored.");
-                    return null;
-                }
-                var result = new EventParams(eventName);
+                var result = PrepareEvent(eventName);
                 eventQueue.Enqueue(result);
                 return result;
             }
 
             public static IEventParamsBuilder LogEvent(string eventName, Dictionary<string, object> parameters)
             {
-                if (parameters == null) return LogEvent(eventName);
-                return LogEvent(eventName).AddParam(parameters);
+                var result = PrepareEvent(eventName, parameters);
+                eventQueue.Enqueue(result);
+                return result;
             }
 
             public static IEventParamsBuilder LogEvent(string eventName, params (string, object)[] parameters)
             {
-                IEventParamsBuilder result = LogEvent(eventName);
-                if (parameters == null) return result;
-                for (var i = 0; i < parameters.Length; i++)
-                {
-                    result.AddParam(parameters[i].Item1, parameters[i].Item2);
-                }
+                var result = PrepareEvent(eventName, parameters);
+                eventQueue.Enqueue(result);
                 return result;
             }
 
@@ -113,6 +120,24 @@ namespace Amanotes.Core
             {
                 return LogEvent(eventName, parameters).SetAsFunnel(signature);
             }
+            
+            public static void LogEventImmediately(string eventName)
+            {
+                var eventParams = PrepareEvent(eventName);
+                LogEventImmediately(eventParams);
+            }
+
+            public static void LogEventImmediately(string eventName, Dictionary<string, object> parameters)
+            {
+                var eventParams = PrepareEvent(eventName, parameters);
+                LogEventImmediately(eventParams);
+            }
+
+            public static void LogEventImmediately(string eventName, params (string, object)[] parameters)
+            {
+                var eventParams = PrepareEvent(eventName, parameters);
+                LogEventImmediately(eventParams);
+            }
 
             public static int GetAccumulatedCount(string eventName, bool withinSession = false)
             {
@@ -128,12 +153,18 @@ namespace Amanotes.Core
 
             public static void SetUserId(string userId)
             {
-                actionQueue.Enqueue(() => InternalSetUserId(userId));
+                foreach (AnalyticsAdapter s in listAdapters)
+                {
+                    s.SetUserId(userId);
+                }
             }
 
             public static void SetUserProperty(string key, string value)
             {
-                actionQueue.Enqueue(() => InternalSetUserProperty(key, value));
+                foreach (AnalyticsAdapter s in listAdapters)
+                {
+                    s.SetUserProperty(key, value);
+                }
             }
 
             private static IntegrityFlag MergeData(List<string> funnelEvents, Dictionary<string, int> eventCountMap, bool sumEventCount)
@@ -151,12 +182,13 @@ namespace Amanotes.Core
                     }
 
                 if (eventCountMap != null)
+                {
                     foreach (KeyValuePair<string, int> e in eventCountMap)
                     {
                         EventDetail eventDetail = localData.GetEventDetail(e.Key);
                         if (eventDetail == null)
                         {
-                            localData.eventDetails.Add(new EventDetail
+                            localData.AddEventDetail(new EventDetail
                             {
                                 eventName = e.Key,
                                 totalCount = e.Value
@@ -175,6 +207,8 @@ namespace Amanotes.Core
                             eventDetail.totalCount += e.Value;
                         }
                     }
+                }
+                    
                 
                 Profiler.EndSample();
                 return flag;
@@ -237,11 +271,12 @@ namespace Amanotes.Core
 
             internal static readonly Dictionary<string, EventConfig> sendAtCount = new Dictionary<string, EventConfig>();
             internal static Predicate<EventParams> logEventHook;
-            internal static readonly Queue<EventParams> eventQueue = new Queue<EventParams>();
-            internal static readonly Queue<Action> actionQueue = new Queue<Action>();
+            internal static readonly ConcurrentQueue<EventParams> eventQueue = new ConcurrentQueue<EventParams>();
             internal static readonly List<AnalyticsAdapter> listAdapters = new List<AnalyticsAdapter>();
-            internal static readonly AnalyticsData localData = new AnalyticsData().LoadJsonFromFile();
-            internal static readonly SessionStat sessionStat = new SessionStat();
+            internal static readonly AnalyticsData localData = new AnalyticsData().LoadJsonFromFile().BuildCache();
+            internal static readonly SessionStat sessionStat = _config.analytics.enableEventStat ? new SessionStat() : null;
+            internal static readonly Pool<StringBuilder> sbPool = new Pool<StringBuilder>(3);
+            internal static readonly Pool<EventParams> epPool = new Pool<EventParams>(1);
 
             internal static readonly Dictionary<string, string> reservedPrefixes = new Dictionary<string, string>()
             {
@@ -298,68 +333,109 @@ namespace Amanotes.Core
                 // TODO: Refactor Resolve Early Calls
                 onFrameUpdate -= ProcessEventQueue;
                 onFrameUpdate += ProcessEventQueue;
-                
-                onFrameUpdate -= ProcessActionQueue;
-                onFrameUpdate += ProcessActionQueue;
             }
-    
+            
+            internal static EventParams PrepareEvent(string eventName)
+            {
+                PrepareEventCheck(eventName);
+                var result = epPool.Get().Init(eventName);
+                PostPrepareEventProcess(result);
+                return result;
+            }
+
+            internal static EventParams PrepareEvent(string eventName, Dictionary<string, object> parameters)
+            {
+                if (parameters == null) return PrepareEvent(eventName);
+                PrepareEventCheck(eventName);
+                var result = epPool.Get().Init(eventName);
+                result.AddParam(parameters);
+                PostPrepareEventProcess(result);
+                return result;
+            }
+
+            internal static EventParams PrepareEvent(string eventName, params (string, object)[] parameters)
+            {
+                if (parameters == null) return PrepareEvent(eventName);
+                PrepareEventCheck(eventName);
+                var result = epPool.Get().Init(eventName);
+                for (var i = 0; i < parameters.Length; i++)
+                {
+                    result.AddParam(parameters[i].Item1, parameters[i].Item2);
+                }
+                PostPrepareEventProcess(result);
+                return result;
+            }
+
             internal static void ProcessEventQueue()
             {
                 if (eventQueue.Count <= 0) return;
 
                 Profiler.BeginSample("AmaGDK.Analytics.ProcessEventQueue()");
-                AnalyticsConfig config = Config.analytics;
-                bool showAnalyticsLog = config.showAnalyticsLog;
-                sessionStat.ClearLastFrameEventInfo();
 
-                while (eventQueue.Count > 0)
+                sessionStat?.Clear();
+                
+                while (eventQueue.TryDequeue(out var eventData))
                 {
-                    var eventData = eventQueue.Dequeue();
-                    if (!ShouldSendEvent(eventData)) continue;
-                    
-                    var (countInSession, totalCount) = localData.IncreaseCounter(eventData);
-                    if (eventData.accumulated || eventData.parameters.ContainsKey("accumulated_count"))
-                    {
-                        UpdateAccumulatedCount(eventData, countInSession, totalCount);
-                    }
+                    var (eventNameToSend, inUseAdapterIDs) = LogEventActually(eventData);
+                    sessionStat?.Add(eventNameToSend, eventData, inUseAdapterIDs);
+                    epPool.Return(eventData);
+                }
 
-                    if (!eventData.parameters.ContainsKey("ama_device_id"))
-                        eventData.AddParam("ama_device_id", User.AmaDeviceId);
+                localData.SaveIfDirty();
+                sessionStat?.Save();
+				Profiler.EndSample();
+            }
+
+            internal static (string eventNameToSend, List<string> inUseAdapterIDs) LogEventActually(EventParams eventParams)
+            {
+                if (eventParams == null) return ("", null);
+                if (!ShouldSendEvent(eventParams)) return ("", null);
+                var (countInSession, totalCount) = localData.IncreaseCounter(eventParams);
+                if (eventParams.accumulated || eventParams.parameters.ContainsKey("accumulated_count"))
+                {
+                    UpdateAccumulatedCount(eventParams, countInSession, totalCount);
+                }
+
+                string eventNameToSend = GetEventNameToSend(eventParams.eventName, countInSession, totalCount);
+                AnalyticsConfig config = Config.analytics;
+                if (config.normalizeEventName) NormalizeEventName(ref eventNameToSend);
+
+                if (config.showAnalyticsLog)
+                {
+                    Debug.Log($"AmaGDK [Analytics] Event <{eventNameToSend}> (in session: {countInSession}, total: {totalCount})\n{JsonUtils.DictionaryToJson(eventParams.parameters, true)}");
+                }
                     
-                    string eventNameToSend = GetEventNameToSend(eventData.eventName, countInSession, totalCount);
-                    if (config.normalizeEventName) NormalizeEventName(ref eventNameToSend);
+                config.quality.CheckEventQuality(eventParams.eventName, eventParams.parameters);
 
-                    if (showAnalyticsLog)
+                var inUseAdapterIDs = config.enableEventStat ? new List<string>(listAdapters.Count) : null;
+                foreach (AnalyticsAdapter m in listAdapters)
+                {
+                    if (eventParams.overrideConfig)
                     {
-                        Debug.Log($"AmaGDK [Analytics] Event <{eventNameToSend}> (in session: {countInSession}, total: {totalCount})\n{JsonUtils.DictionaryToJson(eventData.parameters, true)}");
+                        // IMPORTANT NOTE:
+                        //
+                        // Once set overrideConfig, we should skip the adapter config completely!!!
+                        //
+                        if (eventParams.IsAdapterForbidden(m.adapterId)) continue;
                     }
-                    
-                    config.quality.CheckEventQuality(eventData.eventName, eventData.parameters);
-
-                    var inUseAdapterIDs = new List<string>();
-                    foreach (AnalyticsAdapter m in listAdapters)
+                    else // Do not remove else
                     {
-                        if (eventData.overrideConfig)
-                        {
-                            // IMPORTANT NOTE:
-                            //
-                            // Once set overrideConfig, we should skip the adapter config completely!!!
-                            //
-                            if (eventData.IsAdapterForbidden(m.adapterId)) continue;
-                        }
-                        else // Do not remove else
-                        {
-                            if (m.IsForbidden(eventData.eventName)) continue;
-                        }
-                        m.LogEvent(eventNameToSend, eventData.parameters);
-                        inUseAdapterIDs.Add(m.adapterId);
+                        if (m.IsForbidden(eventParams.eventName)) continue;
                     }
-                    sessionStat.Add(eventNameToSend, eventData, inUseAdapterIDs);
+                    m.LogEvent(eventNameToSend, eventParams.parameters);
+                    inUseAdapterIDs?.Add(m.adapterId);
                 }
 
+                return (eventNameToSend, inUseAdapterIDs);
+            }
+
+            internal static void LogEventImmediately(EventParams eventParams)
+            {
+                var (eventNameToSend, inUseAdapterIDs) = LogEventActually(eventParams);
+                sessionStat?.Add(eventNameToSend, eventParams, inUseAdapterIDs);
+                epPool.Return(eventParams);
+                sessionStat?.Save();
                 localData.SaveIfDirty();
-                sessionStat.Save();
-				Profiler.EndSample();
             }
 
             internal static void UpdateAccumulatedCount(EventParams eventData, int countInSession, int totalCount)
@@ -399,19 +475,20 @@ namespace Amanotes.Core
             {
                 Profiler.BeginSample("AmaGDK.Analytics.NormalizeEventName()");
                 {
-                    StringBuilder sb = tmpWarningSB;
+                    StringBuilder sb = sbPool.Get();
                     sb.Clear();
                     NormalizeKeyString(ref eventName, sb, dryRun);
                     if (reservedEvents.Contains(eventName))
                         sb.AppendLine($" - EventName <{eventName}> is reserved and should not be used");
-                    if (sb.Length > 0 && dryRun) LogWarningOnce($"Warning for event name <{eventName}>:\n{sb}", $"NormalizeEventName<{eventName}>");    
+                    if (sb.Length > 0 && dryRun) LogWarningOnce($"Warning for event name <{eventName}>:\n{sb}", $"NormalizeEventName<{eventName}>");
+                    sbPool.Return(sb);
                 }
                 Profiler.EndSample();
             }
 
             internal static void NormalizeKeyString(ref string key, StringBuilder warningLog, bool dryRun)
             {
-                Profiler.BeginSample("AmaGDK.Analytics.NormalizeEventName()");
+                Profiler.BeginSample("AmaGDK.Analytics.NormalizeKeyString()");
                 {
                     if (string.IsNullOrWhiteSpace(key))
                     {
@@ -420,52 +497,114 @@ namespace Amanotes.Core
                         return;
                     }
 
-                    var sb = new StringBuilder();
+                    var tempLog = Config.common.logLevel == LogLevel.None ? null : sbPool.Get();
+                    tempLog?.Clear();
+                    
+                    var tempKey = sbPool.Get();
+                    tempKey.Clear();
+                    
+                    var hasChanged = false;
+                    var trimKey = key.Trim();
                     
-                    string normalizedString = key.Trim()
-                        .Replace(' ', '_')
-                        .Replace('-', '_');
-                    if (key != normalizedString)
+                    foreach (var c in trimKey)
                     {
-                        sb.Append($" - Malformed name (should not contains <space> or <dash>): <{key}>");    
+                        var isLetter = IsAlphabet(c);
+                        var isNumber = char.IsDigit(c);
+
+                        if (c == '_' || isLetter || isNumber)
+                        {
+                            tempKey.Append(c);
+                            continue;
+                        }
+                        
+                        hasChanged = true;
+                        if (c == ' ' || c == '-')
+                        {
+                            tempKey.Append('_');
+                        }
                     }
 
-                    var r = new Regex("^[a-zA-Z0-9_]*$");
-                    if (!r.IsMatch(normalizedString))
+                    if (hasChanged)
                     {
-                        normalizedString = Regex.Replace(normalizedString, "[^a-zA-Z0-9_]", "");
-                        sb.Append(" - Name may only contain alphanumeric characters and underscores");
+                        tempLog?.Append(" - Name may only contain alphanumeric characters and underscores");
                     }
-
-                    if (!char.IsLetter(normalizedString[0]))
+                    
+                    if (tempKey.Length > 0 && !IsAlphabet(tempKey[0]))
                     {
-                        normalizedString = "E" + normalizedString;
-                        sb.Append($" - Name must start with a letter: <{key}> ");
+                        hasChanged = true;
+                        tempKey.Insert(0, 'E');
+                        tempLog?.Append($" - Name must start with a letter: <{key}>");
                     }
-
+                    
                     foreach (var prefix in reservedPrefixes)
                     {
-                        if (!normalizedString.StartsWith(prefix.Key)) continue;
-                        normalizedString = prefix.Value + normalizedString.Remove(0, prefix.Key.Length);
-                        sb.AppendLine($" - <{key}> starts with reserved prefix <{prefix}>");
+                        if (tempKey.Length < prefix.Key.Length || !StringStartsWith(tempKey, prefix.Key)) continue;
+                        hasChanged = true;
+                        tempKey.Remove(0, prefix.Key.Length);
+                        tempKey.Insert(0, prefix.Value);
+                        tempLog?.AppendLine($" - <{key}> starts with reserved prefix <{prefix}>");
                     }
 
-                    if (normalizedString.Length > 40)
+                    if (trimKey.Length > 40)
                     {
-                        sb.AppendLine($" - Name is too long ({key.Length} > 40): <{key}> ");
-                        normalizedString = normalizedString.Substring(0, 40);
+                        hasChanged = true;
+                        tempLog?.AppendLine($" - Name is too long ({key.Length} > 40): <{key}> ");
+                        tempKey.Length = 40;
                     }
                     
                     if (dryRun)
                     {
-                        warningLog.Append(sb);
+                        warningLog.Append(tempLog);
                     } else {
-                        key = normalizedString;
+                        if (hasChanged) key = tempKey.ToString();
                     }
+                    
+                    if (tempLog != null) sbPool.Return(tempLog);
+                    sbPool.Return(tempKey);
                 }
                 Profiler.EndSample();
             }
             
+            private static bool StringStartsWith(StringBuilder stringBuilder, string prefix)
+            {
+                if (stringBuilder == null || prefix == null)
+                    return false;
+
+                if (stringBuilder.Length < prefix.Length)
+                    return false;
+
+                for (int i = 0; i < prefix.Length; i++)
+                {
+                    if (stringBuilder[i] != prefix[i])
+                        return false;
+                }
+
+                return true;
+            }
+
+            private static bool IsAlphabet(char c)
+            {
+                if (c >= 'A' && c <= 'Z') return true;
+                if (c >= 'a' && c <= 'z') return true;
+                return false;
+            }
+
+            internal static void PrepareEventCheck(string eventName)
+            {
+                NormalizeEventName(ref eventName, true);
+                
+                if (localData.GetEventDetail(eventName) == null && localData.totalEventDetailCount >= 500)
+                {
+                    LogWarning($" - You have reported 500 types of events. New event <{eventName}> will be ignored.");
+                }
+            }
+
+            internal static void PostPrepareEventProcess(EventParams eventData)
+            {
+                if (!eventData.parameters.ContainsKey("ama_device_id"))
+                    eventData.AddParam("ama_device_id", User.AmaDeviceId);
+            }
+            
             internal static bool ShouldSendEvent(EventParams eventData)
             {
                 //Funnel event
@@ -489,33 +628,6 @@ namespace Amanotes.Core
 
                 return true;
             }
-            
-            
-            internal static void ProcessActionQueue()
-            {
-                if (actionQueue.Count <= 0) return;
-                while (actionQueue.Count > 0)
-                {
-                    var action = actionQueue.Dequeue();
-                    action.Invoke();
-                }
-            }
-            
-            internal static void InternalSetUserId(string userId)
-            {
-                foreach (AnalyticsAdapter s in listAdapters)
-                {
-                    s.SetUserId(userId);
-                }
-            }
-
-            internal static void InternalSetUserProperty(string key, string value)
-            {
-                foreach (AnalyticsAdapter s in listAdapters)
-                {
-                    s.SetUserProperty(key, value);
-                }
-            }
         }
 
         //PERSISTENT DATA
@@ -583,23 +695,63 @@ namespace Amanotes.Core
             internal class AnalyticsData : IJsonFile
             {
                 public List<string> funnelSignatures = new List<string>();
-                public List<EventDetail> eventDetails = new List<EventDetail>();
+                
                 public MigrationLog migrationLog = new MigrationLog();
                 [NonSerialized] internal bool _dirty;
-
+                
+                [SerializeField] internal List<EventDetail> eventDetails = new List<EventDetail>();
+                internal readonly Dictionary<string, EventDetail> cachedEventDetails = new Dictionary<string, EventDetail>();
+                
+                public int totalEventDetailCount => eventDetails.Count;
+                public bool AddEventDetail(EventDetail ed)
+                {
+                    if (cachedEventDetails.ContainsKey(ed.eventName))
+                    {
+                        Debug.LogWarning($"EventName <{ed.eventName}> existed!");
+                        return false;
+                    }
+                    
+                    eventDetails.Add(ed);
+                    cachedEventDetails.Add(ed.eventName, ed);
+                    return true;
+                }
+                
+                internal AnalyticsData BuildCache()
+                {
+                    if (cachedEventDetails.Count > 0)
+                    {
+                        LogWarning("BuildCache should be called once!");
+                        cachedEventDetails.Clear();
+                    }
+                    
+                    for (var i = 0; i < eventDetails.Count; i++)
+                    {
+                        var item = eventDetails[i];
+                        if (cachedEventDetails.ContainsKey(item.eventName))
+                        {
+                            LogWarning($"Duplicated eventName <{item.eventName}> entry found in AnalyticData!");
+                            continue;
+                        }
+                        cachedEventDetails.Add(item.eventName, item);
+                    }
+                    return this;
+                }
+                
                 internal EventDetail GetEventDetail(string eventName, bool autoNew = false)
                 {
                     if (string.IsNullOrEmpty(eventName)) return null;
 
-                    EventDetail result = eventDetails.Find(e => e.eventName == eventName);
-                    if (result != null) return result;
+                    if (cachedEventDetails.TryGetValue(eventName, out var result))
+                    {
+                        return result;
+                    }
                     if (autoNew == false) return null;
 
                     result = new EventDetail
                     {
                         eventName = eventName
                     };
-                    eventDetails.Add(result);
+                    AddEventDetail(result);
                     _dirty = true;
                     return result;
                 }
@@ -645,7 +797,7 @@ namespace Amanotes.Core
                         migrationLog.count++;
                         Log($"Analytics data was migrated {migrationLog.count} times");
 
-                        if (migrationLog.count == 2) LogEvent("migration_error").AddParam(migrationLog.ToDictionary());
+                        if (migrationLog.count == 2) LogEvent("migration_error", migrationLog.ToDictionary());
                     }
 
                     _dirty = true;
@@ -659,36 +811,44 @@ namespace Amanotes.Core
                 private readonly string fileName = nameof(SessionStat) + DateTime.Now.ToString("_yyMMdd_HHmmss") + ".tsv";
                 private StringBuilder contents = new StringBuilder();
                 private bool isFirstSave = true;
-                public List<EventStat> lastFrameEventStats = new List<EventStat>();
+                private readonly ConcurrentQueue<EventStat> lastFrameEventStats = new ConcurrentQueue<EventStat>();
+                internal readonly ConcurrentQueue<EventStat> savedEventStatsInLastFrame = new ConcurrentQueue<EventStat>();
 
                 internal void Add(string eventNameToSend, EventParams eventParams, List<string> adapterIDs)
                 {
+                    if (string.IsNullOrEmpty(eventNameToSend) || adapterIDs == null) return;
                     var eventStat = new EventStat(eventNameToSend, eventParams, adapterIDs);
-                    lastFrameEventStats.Add(eventStat);
-                }
-
-                internal void ClearLastFrameEventInfo()
-                {
-                    lastFrameEventStats.Clear();
+                    lastFrameEventStats.Enqueue(eventStat);
                 }
 
                 internal void Save()
                 {
-                    if (!Config.analytics.enableEventStat || lastFrameEventStats.Count == 0) return;
-
                     contents.Clear();
                     if (isFirstSave)
                     {
                         contents = contents.AppendLine(TSV_HEADER_ROW);
                         isFirstSave = false;
                     }
-                    foreach (EventStat stat in lastFrameEventStats)
+                    while (lastFrameEventStats.TryDequeue(out var stat))
                     {
                         contents.AppendLine(stat.ToTsv());
+                        savedEventStatsInLastFrame.Enqueue(stat);
                     }
 
                     GDKFileUtils.SaveAppend(fileName, contents.ToString());
                 }
+
+                internal void Clear()
+                {
+                    //Clear() is supported from .Net Standard 2.1
+#if UNITY_2021_3_OR_NEWER
+                    sessionStat?.savedEventStatsInLastFrame.Clear();
+#else
+                    while (savedEventStatsInLastFrame.TryDequeue(out var stat))
+                    {
+                    }
+#endif
+                }
             }
         }
     }
@@ -740,6 +900,8 @@ namespace Amanotes.Core
             }
 
             eventData.overrideConfig = true;
+            eventData.ignoreAdapterIds ??= new HashSet<string>();
+            
             foreach (string mId in analyticIds)
             {
                 eventData.ignoreAdapterIds.Add(mId);
@@ -764,6 +926,8 @@ namespace Amanotes.Core
             }
 
             eventData.overrideConfig = true;
+            eventData.allowAdapterIds ??= new HashSet<string>();
+            
             foreach (string mId in analyticIds)
             {
                 eventData.allowAdapterIds.Add(mId);
@@ -771,7 +935,7 @@ namespace Amanotes.Core
             return ap;
         }
 
-        public static IEventParamsBuilder AddParam(this IEventParamsBuilder ap, string key, object value)
+        internal static IEventParamsBuilder AddParam(this IEventParamsBuilder ap, string key, object value)
         {
             if (ap == null) return null;
             if (!IsValidKeyValue(ap, ref key, ref value)) return ap;
@@ -795,7 +959,7 @@ namespace Amanotes.Core
             return ap;
         }
 
-        public static IEventParamsBuilder AddParam(this IEventParamsBuilder ap, Dictionary<string, object> dictParams)
+        internal static IEventParamsBuilder AddParam(this IEventParamsBuilder ap, Dictionary<string, object> dictParams)
         {
             if (ap == null) return null;
             if (dictParams == null)
@@ -814,7 +978,7 @@ namespace Amanotes.Core
             return ap;
         }
 
-        public static IEventParamsBuilder AddParam(this IEventParamsBuilder ap, params (string key, object value)[] parameters)
+        internal static IEventParamsBuilder AddParam(this IEventParamsBuilder ap, params (string key, object value)[] parameters)
         {
             if (ap == null) return null;
             if (parameters.Length == 0)
@@ -838,11 +1002,12 @@ namespace Amanotes.Core
         {
             string eventName = (ap as EventParams)?.eventName;
             
-            StringBuilder sb = tmpWarningSB;
+            StringBuilder sb = sbPool.Get();
             sb.Clear();
             NormalizeKeyString(ref key, sb, AmaGDK.Config.analytics.normalizeEventName);
             
             if (sb.Length > 0) LogWarningOnce($"Warning for event <{eventName}>, param <{key}>:\n{sb}", $"NormalizeParamKey <{eventName}>");
+            sbPool.Return(sb);
             
             if (string.IsNullOrWhiteSpace(key))
             {