Preserve event timestamp across harvests for session attributes

diegomtz5 · claude · diegomtz5 · commit d1d985ce63af · 2026-02-18T09:28:15.000-08:00
- Remove timestamp reset from empty() method in both event systems
- Add resetTimestamp() method for explicit session clear
- Update tests for new behavior
- Ensures session attributes sent on every harvest after first 60s

Co-Authored-By: Claude Sonnet 4.5 &lt;noreply@anthropic.com&gt;
diff --git a/Agent/Analytics/NRMAAnalytics.mm b/Agent/Analytics/NRMAAnalytics.mm
@@ -1127,10 +1127,12 @@ - (void) clearLastSessionsAnalytics {
     if([NRMAFlags shouldEnableNewEventSystem]){
         [_sessionAttributeManager removeAllSessionAttributes];
         [_eventManager empty];
+        [_eventManager resetTimestamp];
     } else {
         try {
             _analyticsController->clearAttributesDuplicationStore();
             _analyticsController->clearEventsDuplicationStore();
+            _analyticsController->resetEventTimestamp();
         } catch (std::exception& e) {
             NRLOG_AGENT_VERBOSE(@"Failed to clear last sessions' analytcs, %s",e.what());
         } catch (...) {
diff --git a/Agent/Analytics/NRMAEventManager.h b/Agent/Analytics/NRMAEventManager.h
@@ -26,6 +26,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (BOOL)didReachMaxQueueTime:(NSTimeInterval)currentTimeMilliseconds;
 - (BOOL)addEvent:(id<NRMAAnalyticEventProtocol>)event;
 - (void)empty;
+- (void)resetTimestamp;
 - (nullable NSString *)getEventJSONStringWithError:(NSError *__autoreleasing *)error clearEvents:(BOOL)clearEvents;
 
 + (nullable NSString *)getLastSessionEventsFromFilename:(NSString *)filename;
diff --git a/Agent/Analytics/NRMAEventManager.m b/Agent/Analytics/NRMAEventManager.m
@@ -122,11 +122,14 @@ - (void)empty {
     @synchronized (events) {
         [events removeAllObjects];
         [_persistentStore clearAll];
-        oldestEventTimestamp = 0;
         totalAttemptedInserts = 0;
     }
 }
 
+- (void)resetTimestamp {
+    oldestEventTimestamp = 0;
+}
+
 - (nullable NSString *)getEventJSONStringWithError:(NSError *__autoreleasing *)error clearEvents:(BOOL)clearEvents {
     NSString *eventJsonString = nil;
     @synchronized (events) {
diff --git a/Agent/Utilities/NRLogger.m b/Agent/Utilities/NRLogger.m
@@ -335,7 +335,7 @@ - (NSMutableDictionary*) commonBlockDict {
     if (NRSessionId) [commonAttributes setObject:NRSessionId forKey:NRLogMessageSessionIdKey];
     [commonAttributes setObject:NRLogMessageMobileValue forKey:NRLogMessageInstrumentationProviderKey];
     if (name) [commonAttributes setObject:name forKey:NRLogMessageInstrumentationNameKey];
-    [commonAttributes setObject:[NRMAAgentConfiguration connectionInformation].deviceInformation.agentVersion forKey:NRLogMessageInstrumentationVersionKey];
+    [commonAttributes setObject:[NRMAAgentConfiguration connectionInformation].deviceInformation.platformVersion ?: [NRMAAgentConfiguration connectionInformation].deviceInformation.agentVersion forKey:NRLogMessageInstrumentationVersionKey];
     if (nativePlatform) [commonAttributes setObject:nativePlatform forKey:NRLogMessageInstrumentationCollectorKey];
     if (nrAppId) [commonAttributes setObject:nrAppId forKey:NRLogMessageAppIdKey];
 
diff --git a/Tests/Unit-Tests/NewRelicAgentTests/Analytics-Tests/TestIntegratedEventManager.m b/Tests/Unit-Tests/NewRelicAgentTests/Analytics-Tests/TestIntegratedEventManager.m
@@ -187,32 +187,65 @@ - (void)testEmptyEvents {
     XCTAssertEqual(emptyDecode.count, 0);
 }
 
-- (void)testEmptyEventsResetOldestEventTime {
+- (void)testEmptyEventsDoesNotResetOldestEventTime {
     // Given
     NRMACustomEvent *customEventOne = [[NRMACustomEvent alloc] initWithEventType:@"Custom Event 1"
                                                                        timestamp:1000
                                                      sessionElapsedTimeInSeconds:20
                                                           withAttributeValidator:agreeableAttributeValidator];
-    
+
     NRMACustomEvent *customEventTwo = [[NRMACustomEvent alloc] initWithEventType:@"Custom Event 2"
                                                                        timestamp:1000
                                                      sessionElapsedTimeInSeconds:20
                                                           withAttributeValidator:agreeableAttributeValidator];
-    
+
     NRMACustomEvent *customEventThree = [[NRMACustomEvent alloc] initWithEventType:@"Custom Event 3"
                                                                        timestamp:1000
                                                      sessionElapsedTimeInSeconds:20
                                                           withAttributeValidator:agreeableAttributeValidator];
     [sut setMaxEventBufferTimeInSeconds:1];
-    
+
     [sut addEvent:customEventOne];
     [sut addEvent:customEventTwo];
     [sut addEvent:customEventThree];
-    
+
     XCTAssertTrue([sut didReachMaxQueueTime:2000]);
 
+    // When - empty() is called (during normal harvest)
     [sut empty];
 
+    // Then - timestamp should persist (matching Android behavior)
+    XCTAssertTrue([sut didReachMaxQueueTime:2000]);
+}
+
+- (void)testResetTimestampResetsOldestEventTime {
+    // Given
+    NRMACustomEvent *customEventOne = [[NRMACustomEvent alloc] initWithEventType:@"Custom Event 1"
+                                                                       timestamp:1000
+                                                     sessionElapsedTimeInSeconds:20
+                                                          withAttributeValidator:agreeableAttributeValidator];
+
+    NRMACustomEvent *customEventTwo = [[NRMACustomEvent alloc] initWithEventType:@"Custom Event 2"
+                                                                       timestamp:1000
+                                                     sessionElapsedTimeInSeconds:20
+                                                          withAttributeValidator:agreeableAttributeValidator];
+
+    NRMACustomEvent *customEventThree = [[NRMACustomEvent alloc] initWithEventType:@"Custom Event 3"
+                                                                       timestamp:1000
+                                                     sessionElapsedTimeInSeconds:20
+                                                          withAttributeValidator:agreeableAttributeValidator];
+    [sut setMaxEventBufferTimeInSeconds:1];
+
+    [sut addEvent:customEventOne];
+    [sut addEvent:customEventTwo];
+    [sut addEvent:customEventThree];
+
+    XCTAssertTrue([sut didReachMaxQueueTime:2000]);
+
+    // When - resetTimestamp() is explicitly called (during session clear)
+    [sut resetTimestamp];
+
+    // Then - timestamp should be reset
     XCTAssertFalse([sut didReachMaxQueueTime:2000]);
 }
 
diff --git a/libMobileAgent/src/Analytics/include/Analytics/AnalyticsController.hpp b/libMobileAgent/src/Analytics/include/Analytics/AnalyticsController.hpp
@@ -218,6 +218,8 @@ namespace NewRelic {
 
         void clearAttributesDuplicationStore();
 
+        void resetEventTimestamp();
+
         static std::shared_ptr <NRJSON::JsonArray> fetchDuplicatedEvents(
                 PersistentStore<std::string, AnalyticEvent> &eventStore,
                 bool shouldClearStore);
diff --git a/libMobileAgent/src/Analytics/include/Analytics/EventManager.hpp b/libMobileAgent/src/Analytics/include/Analytics/EventManager.hpp
@@ -102,6 +102,7 @@ namespace NewRelic {
         void setMaxBufferSize(unsigned int size); //sets max buffer size
         bool didReachMaxQueueTime(unsigned long long currentTimestamp_ms); //checks if oldest event timestamp exceededs max queue time
         void empty(); //removes all events in _events;
+        void resetTimestamp(); //resets _oldest_event_timestamp_ms to 0 (for session clear)
     };
 }
 #endif
diff --git a/libMobileAgent/src/Analytics/src/AnalyticsController.cxx b/libMobileAgent/src/Analytics/src/AnalyticsController.cxx
@@ -1002,6 +1002,10 @@ namespace NewRelic {
         _attributeDuplicationStore.clear();
     }
 
+    void AnalyticsController::resetEventTimestamp() {
+        _eventManager.resetTimestamp();
+    }
+
     const char *AnalyticsController::getPersistentAttributeStoreName() {
         return ATTRIBUTE_STORE_DB_FILENAME;
     }
diff --git a/libMobileAgent/src/Analytics/src/EventManager.cxx b/libMobileAgent/src/Analytics/src/EventManager.cxx
@@ -41,11 +41,14 @@ void EventManager::empty() {
     lock1.lock();
     _events.clear();
     _eventDuplicationStore.clear();
-    _oldest_event_timestamp_ms = 0;
     //we're empty so let's reset the total number of attempted inserts.
     _total_attempted_inserts = 0;
 }
 
+void EventManager::resetTimestamp() {
+    _oldest_event_timestamp_ms = 0;
+}
+
     std::string EventManager::createKey(std::shared_ptr<AnalyticEvent> event) {
         std::stringstream ss;
         ss << *event;
diff --git a/libMobileAgent/test/AnalyticsTest/EventManager_test.cxx b/libMobileAgent/test/AnalyticsTest/EventManager_test.cxx
@@ -286,5 +286,55 @@ TEST_F(EventManagerTest, testBadSerializedEvent) {
 
     ASSERT_THROW(manager.newEvent(strs2), std::runtime_error);
 }
+
+TEST_F(EventManagerTest, testEmptyDoesNotResetTimestamp) {
+    EventManager manager{store};
+
+    // Set max buffer time to 1 second
+    manager.setMaxBufferTime(1);
+
+    // Add events at timestamp 1000ms
+    auto event1 = manager.newCustomMobileEvent("custom1", 1000, 1, validator);
+    auto event2 = manager.newCustomMobileEvent("custom2", 1000, 1, validator);
+    auto event3 = manager.newCustomMobileEvent("custom3", 1000, 1, validator);
+
+    manager.addEvent(event1);
+    manager.addEvent(event2);
+    manager.addEvent(event3);
+
+    // Check at 2000ms - should have reached max queue time (1 second elapsed)
+    ASSERT_TRUE(manager.didReachMaxQueueTime(2000));
+
+    // Call empty() (simulating normal harvest)
+    manager.empty();
+
+    // Timestamp should persist (matching Android behavior)
+    ASSERT_TRUE(manager.didReachMaxQueueTime(2000));
+}
+
+TEST_F(EventManagerTest, testResetTimestampResetsTimestamp) {
+    EventManager manager{store};
+
+    // Set max buffer time to 1 second
+    manager.setMaxBufferTime(1);
+
+    // Add events at timestamp 1000ms
+    auto event1 = manager.newCustomMobileEvent("custom1", 1000, 1, validator);
+    auto event2 = manager.newCustomMobileEvent("custom2", 1000, 1, validator);
+    auto event3 = manager.newCustomMobileEvent("custom3", 1000, 1, validator);
+
+    manager.addEvent(event1);
+    manager.addEvent(event2);
+    manager.addEvent(event3);
+
+    // Check at 2000ms - should have reached max queue time (1 second elapsed)
+    ASSERT_TRUE(manager.didReachMaxQueueTime(2000));
+
+    // Call resetTimestamp() (simulating session clear)
+    manager.resetTimestamp();
+
+    // Timestamp should be reset
+    ASSERT_FALSE(manager.didReachMaxQueueTime(2000));
+}
 } // namespace NewRelic
 

Original file line number	Diff line number	Diff line change
`@@ -102,6 +102,7 @@ namespace NewRelic {`
`102`	`102`	`void setMaxBufferSize(unsigned int size); //sets max buffer size`
`103`	`103`	`bool didReachMaxQueueTime(unsigned long long currentTimestamp_ms); //checks if oldest event timestamp exceededs max queue time`
`104`	`104`	`void empty(); //removes all events in _events;`
	`105`	`+ void resetTimestamp(); //resets _oldest_event_timestamp_ms to 0 (for session clear)`
`105`	`106`	`};`
`106`	`107`	`}`
`107`	`108`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -1002,6 +1002,10 @@ namespace NewRelic {`
`1002`	`1002`	`_attributeDuplicationStore.clear();`
`1003`	`1003`	`}`
`1004`	`1004`
	`1005`	`+ void AnalyticsController::resetEventTimestamp() {`
	`1006`	`+ _eventManager.resetTimestamp();`
	`1007`	`+ }`
	`1008`	`+`
`1005`	`1009`	`const char *AnalyticsController::getPersistentAttributeStoreName() {`
`1006`	`1010`	`return ATTRIBUTE_STORE_DB_FILENAME;`
`1007`	`1011`	`}`