The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
fix(mobile): an analytics event trimmed while on the wire no longer takes the next one with it
deee6807ebc1b6d
diff --git a/mobile/lib/analytics/analytics_service.dart b/mobile/lib/analytics/analytics_service.dartindex 2ad50bd19..b5cd69d55 100644--- a/mobile/lib/analytics/analytics_service.dart+++ b/mobile/lib/analytics/analytics_service.dart@@ -169,7 +169,7 @@ class QueuedAnalytics implements Analytics {} on Object catch (error) {// The client's contract says it never throws; if it ever does, the// queue must not be left spinning on the same event forever.- _queue.removeFirst();+ _queue.remove(queued);recorder.settled(queued.logId,AnalyticsEventStatus.dropped,@@ -179,13 +179,17 @@ class QueuedAnalytics implements Analytics {continue;}switch (result) {+ // ⚠️ `remove(queued)`, never `removeFirst()`: the send above is+ // awaited, and a queue that filled up meanwhile has already trimmed+ // this event off its head (see [_trim]). Removing whatever is first+ // NOW would drop the next event unsent, and without a row saying so.case AnalyticsSendResult.sent:- _queue.removeFirst();+ _queue.remove(queued);recorder.settled(queued.logId, AnalyticsEventStatus.sent);_retryDelay = AnalyticsLimits.retryDelay;_warnedFull = false;case AnalyticsSendResult.rejected:- _queue.removeFirst();+ _queue.remove(queued);recorder.settled(queued.logId,AnalyticsEventStatus.refused,diff --git a/mobile/test/analytics/analytics_queue_test.dart b/mobile/test/analytics/analytics_queue_test.dartnew file mode 100644index 000000000..e9e1a0da8--- /dev/null+++ b/mobile/test/analytics/analytics_queue_test.dart@@ -0,0 +1,328 @@+import 'dart:async';+import 'dart:io';++import 'package:fake_async/fake_async.dart';+import 'package:flutter_test/flutter_test.dart';+import 'package:harness_mobile/analytics/analytics_client.dart';+import 'package:harness_mobile/analytics/analytics_config.dart';+import 'package:harness_mobile/analytics/analytics_event.dart';+import 'package:harness_mobile/analytics/analytics_identity.dart';+import 'package:harness_mobile/analytics/analytics_log.dart';+import 'package:harness_mobile/analytics/analytics_service.dart';++/// A transport that answers from a script, one result per send, and remembers+/// every body it was handed. An empty script answers `sent`.+class _Client implements AnalyticsClient {+ final results = <Object>[];+ final bodies = <Map<String, Object?>>[];++ /// While set, a send waits on it instead of reading the script — an event+ /// held on the wire.+ Completer<AnalyticsSendResult>? hold;+ bool disposed = false;++ List<String> get names => [+ for (final body in bodies) '${body['event_name']}',+ ];++ @override+ Future<AnalyticsSendResult> send(Map<String, Object?> payload) async {+ bodies.add(payload);+ final held = hold;+ if (held != null) return held.future;+ if (results.isEmpty) return AnalyticsSendResult.sent;+ final next = results.removeAt(0);+ if (next is AnalyticsSendResult) return next;+ throw next;+ }++ @override+ void dispose() => disposed = true;+}++const _context = AnalyticsContext(+ platform: 'ios',+ appVersion: '1.0.0',+ appBuild: '45',+ osVersion: '26.0',+ arch: 'iosArm64',+ locale: 'en_US',+ release: false,+);++void main() {+ late Directory home;+ late _Client client;+ late AnalyticsLogStream log;+ late ({String? id, String? email}) account;++ setUp(() {+ home = Directory.systemTemp.createTempSync('analytics_queue_test');+ client = _Client();+ // Room for every row a full queue produces: the screen's own ring keeps+ // 200, and a row pushed out of it can no longer be read back here.+ log = AnalyticsLogStream(maxEntries: 2 * AnalyticsLimits.queueCap);+ account = (id: null, email: null);+ });++ tearDown(() => home.deleteSync(recursive: true));++ QueuedAnalytics queue({+ Future<AnalyticsContext>? context,+ DateTime Function()? clock,+ }) => QueuedAnalytics(+ client: client,+ identityStore: AnalyticsIdentityStore(+ file: File('${home.path}/analytics.json'),+ computerIdFile: File('${home.path}/computer-id'),+ ),+ contextFuture: context ?? Future.value(_context),+ userLookup: () => account,+ recorder: log,+ clock: clock ?? DateTime.now,+ );++ AnalyticsLogEntry row(String name) =>+ log.entries.firstWhere((entry) => entry.name == name);++ test('sends in order, one at a time, and settles each row', () async {+ final analytics = queue();+ analytics.track('app_opened', params: {'signed_in': true});+ analytics.track('signed_in');+ await analytics.flush();++ expect(client.names, ['app_opened', 'signed_in']);+ expect(analytics.pending, 0);+ expect(row('app_opened').status, AnalyticsEventStatus.sent);+ expect(row('app_opened').attempts, 1);+ expect(row('app_opened').payload, contains('"event_name": "app_opened"'));+ expect(row('app_opened').took, isNotNull);+ });++ test('a badly named event is recorded as dropped and never sent', () async {+ final analytics = queue();+ analytics.track('Opened the app');+ await analytics.flush();++ expect(client.bodies, isEmpty);+ expect(analytics.pending, 0);+ expect(row('Opened the app').status, AnalyticsEventStatus.dropped);+ expect(row('Opened the app').note, contains('snake_case'));+ });++ test(+ 'who is signed in is read when the event happens, not when it is sent',+ () async {+ final analytics = queue();+ analytics.track('app_opened');+ account = (id: 'u1', email: '[email protected]');+ analytics.track('signed_in');+ await analytics.flush();++ final data = [+ for (final body in client.bodies) body['data']! as Map<String, Object?>,+ ];+ expect(data[0].containsKey('user_id'), isFalse);+ expect(data[1]['user_id'], 'u1');+ // One device, one visit, across the sign-in.+ expect(data[0]['user_pseudo_id'], data[1]['user_pseudo_id']);+ expect(data[0]['session_id'], data[1]['session_id']);+ },+ );++ test('a refused event is dropped; the queue behind it carries on', () async {+ client.results.add(AnalyticsSendResult.rejected);+ final analytics = queue();+ analytics.track('app_opened');+ analytics.track('signed_in');+ await analytics.flush();++ expect(client.names, ['app_opened', 'signed_in']);+ expect(row('app_opened').status, AnalyticsEventStatus.refused);+ expect(row('signed_in').status, AnalyticsEventStatus.sent);+ });++ test('a client that throws costs that event, not the queue', () async {+ client.results.add(StateError('broken client'));+ final analytics = queue();+ analytics.track('app_opened');+ analytics.track('signed_in');+ await analytics.flush();++ expect(row('app_opened').status, AnalyticsEventStatus.dropped);+ expect(row('app_opened').note, contains('broken client'));+ expect(row('signed_in').status, AnalyticsEventStatus.sent);+ });++ test('a context that fails still lets the event go, anonymously', () async {+ final analytics = queue(context: Future.error(StateError('no bundle')));+ analytics.track('app_opened');+ await analytics.flush();++ final data = client.bodies.single['data']! as Map<String, Object?>;+ expect(data['platform'], '');+ expect(row('app_opened').status, AnalyticsEventStatus.sent);+ });++ test('a user lookup that throws drops the one event and says so', () async {+ final analytics = QueuedAnalytics(+ client: client,+ identityStore: AnalyticsIdentityStore(+ file: File('${home.path}/analytics.json'),+ computerIdFile: File('${home.path}/computer-id'),+ ),+ contextFuture: Future.value(_context),+ userLookup: () => throw StateError('no account'),+ );+ analytics.track('app_opened');+ await analytics.flush();++ expect(analytics.pending, 0);+ expect(client.bodies, isEmpty);+ });++ test('a transport failure keeps the event and retries, backing off', () {+ fakeAsync((async) {+ client.results.addAll([+ AnalyticsSendResult.retry,+ AnalyticsSendResult.retry,+ AnalyticsSendResult.retry,+ ]);+ final analytics = queue();+ analytics.track('app_opened');+ async.flushMicrotasks();+ expect(client.bodies, hasLength(1));+ expect(analytics.pending, 1);+ expect(row('app_opened').status, AnalyticsEventStatus.queued);++ // First retry after 2s, the next after 4s, the one after that after 8s.+ async.elapse(const Duration(milliseconds: 1999));+ expect(client.bodies, hasLength(1));+ async.elapse(const Duration(milliseconds: 1));+ expect(client.bodies, hasLength(2));+ async.elapse(const Duration(seconds: 3));+ expect(client.bodies, hasLength(2));+ async.elapse(const Duration(seconds: 1));+ expect(client.bodies, hasLength(3));+ async.elapse(const Duration(seconds: 8));+ expect(client.bodies, hasLength(4));+ expect(analytics.pending, 0);+ expect(row('app_opened').attempts, 4);+ expect(row('app_opened').status, AnalyticsEventStatus.sent);+ });+ });++ test('the backoff stops growing at its cap, and a success resets it', () {+ fakeAsync((async) {+ client.results.addAll(List.filled(12, AnalyticsSendResult.retry));+ final analytics = queue();+ analytics.track('app_opened');+ // 2+4+…+64 = 126s, then 120s apiece: all twelve failures are spent well+ // inside this, and the thirteenth attempt succeeds.+ async.elapse(const Duration(minutes: 20));+ expect(client.bodies, hasLength(13));+ expect(analytics.pending, 0);++ // Back to 2s after the success.+ client.results.add(AnalyticsSendResult.retry);+ analytics.track('signed_in');+ async.flushMicrotasks();+ expect(client.bodies, hasLength(14));+ async.elapse(const Duration(seconds: 2));+ expect(client.bodies, hasLength(15));+ });+ });++ test('flush sends now instead of waiting out the retry', () {+ fakeAsync((async) {+ client.results.add(AnalyticsSendResult.retry);+ final analytics = queue();+ analytics.track('app_opened');+ async.flushMicrotasks();+ expect(analytics.pending, 1);++ unawaited(analytics.flush());+ async.flushMicrotasks();+ expect(client.bodies, hasLength(2));+ expect(analytics.pending, 0);+ });+ });++ test('past the cap the oldest go, and the rows say why', () {+ fakeAsync((async) {+ client.results.add(AnalyticsSendResult.retry);+ final analytics = queue();+ for (var i = 0; i < AnalyticsLimits.queueCap + 3; i++) {+ analytics.track('event_$i');+ }+ async.flushMicrotasks();++ expect(analytics.pending, AnalyticsLimits.queueCap);+ final dropped = log.entries+ .where((entry) => entry.status == AnalyticsEventStatus.dropped)+ .toList();+ expect(dropped, hasLength(3));+ expect(dropped.every((e) => e.note == 'the queue was full'), isTrue);+ });+ });++ test('an event trimmed while it is on the wire does not take the next one with it', () {+ fakeAsync((async) {+ final analytics = queue();+ client.hold = Completer<AnalyticsSendResult>();+ analytics.track('first_event');+ async.flushMicrotasks();+ expect(client.names, ['first_event']);++ // An outage long enough to fill the queue while `first_event` waits on+ // the wire: the cap pushes it — the one in flight — out of the queue.+ for (var i = 0; i < AnalyticsLimits.queueCap; i++) {+ analytics.track('later_$i');+ }+ expect(analytics.pending, AnalyticsLimits.queueCap);++ final held = client.hold!;+ client.hold = null;+ held.complete(AnalyticsSendResult.sent);+ async.flushMicrotasks();++ // Every one of the later events reached the wire — none was removed in+ // place of the event that was already gone.+ expect(client.names.skip(1), [+ for (var i = 0; i < AnalyticsLimits.queueCap; i++) 'later_$i',+ ]);+ expect(analytics.pending, 0);+ expect(row('later_0').status, AnalyticsEventStatus.sent);+ });+ });++ test(+ 'close drains what it can, releases the client, and ends the queue',+ () async {+ final analytics = queue();+ analytics.track('app_opened');+ await analytics.close();++ expect(client.names, ['app_opened']);+ expect(client.disposed, isTrue);+ analytics.track('signed_in');+ await analytics.flush();+ expect(client.names, ['app_opened'], reason: 'the instance is spent');+ // A second close is nothing.+ await analytics.close();+ },+ );++ test('a wedged network cannot hold a close past its deadline', () {+ fakeAsync((async) {+ client.hold = Completer<AnalyticsSendResult>();+ final analytics = queue();+ analytics.track('app_opened');+ var closed = false;+ analytics.close().then((_) => closed = true);+ async.elapse(AnalyticsLimits.closeDeadline);+ expect(closed, isTrue);+ expect(client.disposed, isTrue);+ });+ });+}