Add memory usage to contexts

CHANGELOG.md

@@ -6,6 +6,9 @@
 
 - Capture total frames, frames delay, slow & frozen frames and attach to spans ([#2106](https://github.com/getsentry/sentry-dart/pull/2106))
 - Support WebAssembly compilation (dart2wasm) ([#2113](https://github.com/getsentry/sentry-dart/pull/2113))
+- Add memory usage to contexts ([#2133](https://github.com/getsentry/sentry-dart/pull/2133))
+  - Only for Linux/Windows applications, as iOS/Android use native SDKs
+  - No web support, more info: https://developer.mozilla.org/en-US/docs/Web/API/Performance/memory#usedjsheapsize
 
 ### Deprecated
 

dart/lib/src/event_processor/enricher/io_enricher_event_processor.dart

@@ -2,6 +2,7 @@ import 'dart:io';
 
 import '../../../sentry.dart';
 import 'enricher_event_processor.dart';
+import 'io_platform_memory.dart';
 
 EnricherEventProcessor enricherEventProcessor(SentryOptions options) {
   return IoEnricherEventProcessor(options);
@@ -20,22 +21,27 @@ class IoEnricherEventProcessor implements EnricherEventProcessor {
     // If there's a native integration available, it probably has better
     // information available than Flutter.
 
+    final device = _options.platformChecker.hasNativeIntegration
+        ? null
+        : _getDevice(event.contexts.device);
+
     final os = _options.platformChecker.hasNativeIntegration
         ? null
         : _getOperatingSystem(event.contexts.operatingSystem);
 
-    final device = _options.platformChecker.hasNativeIntegration
+    final app = _options.platformChecker.hasNativeIntegration
         ? null
-        : _getDevice(event.contexts.device);
+        : _getApp(event.contexts.app);
 
     final culture = _options.platformChecker.hasNativeIntegration
         ? null
         : _getSentryCulture(event.contexts.culture);
 
     final contexts = event.contexts.copyWith(
-      operatingSystem: os,
       device: device,
+      operatingSystem: os,
       runtimes: _getRuntimes(event.contexts.runtimes),
+      app: app,
       culture: culture,
     );
 
@@ -97,9 +103,18 @@ class IoEnricherEventProcessor implements EnricherEventProcessor {
   }
 
   SentryDevice _getDevice(SentryDevice? device) {
+    final platformMemory = PlatformMemory(Platform.operatingSystem);
     return (device ?? SentryDevice()).copyWith(
       name: device?.name ?? Platform.localHostname,
       processorCount: device?.processorCount ?? Platform.numberOfProcessors,
+      memorySize: platformMemory.getTotalPhysicalMemory() ?? device?.memorySize,
+      freeMemory: platformMemory.getFreePhysicalMemory() ?? device?.freeMemory,
+    );
+  }
+
+  SentryApp _getApp(SentryApp? app) {
+    return (app ?? SentryApp()).copyWith(
+      appMemory: ProcessInfo.currentRss,
     );
   }
 

dart/lib/src/event_processor/enricher/io_platform_memory.dart

@@ -0,0 +1,107 @@
+import 'dart:io';
+
+// Get total & free platform memory (in bytes) for linux and windows operating systems.
+// Source: https://github.com/onepub-dev/system_info/blob/8a9bf6b8eb7c86a09b3c3df4bf6d7fa5a6b50732/lib/src/platform/memory.dart
+class PlatformMemory {
+  PlatformMemory(this.operatingSystem);
+
+  final String operatingSystem;
+
+  int? getTotalPhysicalMemory() {
+    switch (operatingSystem) {
+      case 'linux':
+        return _getLinuxMemInfoValue('MemTotal');
+      case 'windows':
+        return _getWindowsWmicValue('ComputerSystem', 'TotalPhysicalMemory');
+      default:
+        return null;
+    }
+  }
+
+  int? getFreePhysicalMemory() {
+    switch (operatingSystem) {
+      case 'linux':
+        return _getLinuxMemInfoValue('MemFree');
+      case 'windows':
+        return _getWindowsWmicValue('OS', 'FreePhysicalMemory');
+      default:
+        return null;
+    }
+  }
+
+  int? _getWindowsWmicValue(String section, String key) {
+    final os = _wmicGetValueAsMap(section, [key]);
+    final totalPhysicalMemoryValue = os?[key];
+    if (totalPhysicalMemoryValue == null) {
+      return null;
+    }
+    final size = int.tryParse(totalPhysicalMemoryValue);
+    if (size == null) {
+      return null;
+    }
+    return size;
+  }
+
+  int? _getLinuxMemInfoValue(String key) {
+    final meminfoList = _exec('cat', ['/proc/meminfo'])
+            ?.trim()
+            .replaceAll('\r\n', '\n')
+            .split('\n') ??
+        [];
+
+    final meminfoMap = _listToMap(meminfoList, ':');
+    final memsizeResults = meminfoMap[key]?.split(' ') ?? [];
+
+    if (memsizeResults.isEmpty) {
+      return null;
+    }
+    final memsizeResult = memsizeResults.first;
+
+    final memsize = int.tryParse(memsizeResult);
+    if (memsize == null) {
+      return null;
+    }
+    return memsize;
+  }
+
+  String? _exec(String executable, List<String> arguments,
+      {bool runInShell = false}) {
+    try {
+      final result =
+          Process.runSync(executable, arguments, runInShell: runInShell);
+      if (result.exitCode == 0) {
+        return result.stdout.toString();
+      }
+    } catch (e) {
+      //
+    }
+    return null;
+  }
+
+  Map<String, String>? _wmicGetValueAsMap(String section, List<String> fields) {
+    final arguments = <String>[section];
+    arguments
+      ..add('get')
+      ..addAll(fields.join(', ').split(' '))
+      ..add('/VALUE');
+
+    final list =
+        _exec('wmic', arguments)?.trim().replaceAll('\r\n', '\n').split('\n') ??
+            [];
+
+    return _listToMap(list, '=');
+  }
+
+  Map<String, String> _listToMap(List<String> list, String separator) {
+    final map = <String, String>{};
+    for (final string in list) {
+      final index = string.indexOf(separator);
+      if (index != -1) {
+        final key = string.substring(0, index).trim();
+        final value = string.substring(index + 1).trim();
+        map[key] = value;
+      }
+    }
+    return map;
+  }
+}

dart/test/event_processor/enricher/io_platform_memory_test.dart

@@ -0,0 +1,57 @@
+@TestOn('vm')
+library dart_test;
+
+import 'dart:io';
+
+import 'package:sentry/src/event_processor/enricher/io_platform_memory.dart';
+import 'package:test/test.dart';
+
+void main() {
+  late Fixture fixture;
+
+  setUp(() {
+    fixture = Fixture();
+  });
+
+  test('total physical memory', () {
+    final sut = fixture.getSut();
+    final totalPhysicalMemory = sut.getTotalPhysicalMemory();
+
+    switch (Platform.operatingSystem) {
+      case 'linux':
+        expect(totalPhysicalMemory, isNotNull);
+        expect(totalPhysicalMemory! > 0, true);
+        break;
+      case 'windows':
+        expect(totalPhysicalMemory, isNotNull);
+        expect(totalPhysicalMemory! > 0, true);
+        break;
+      default:
+        expect(totalPhysicalMemory, isNull);
+    }
+  });
+
+  test('free physical memory', () {
+    final sut = fixture.getSut();
+    final freePhysicalMemory = sut.getTotalPhysicalMemory();
+
+    switch (Platform.operatingSystem) {
+      case 'linux':
+        expect(freePhysicalMemory, isNotNull);
+        expect(freePhysicalMemory! > 0, true);
+        break;
+      case 'windows':
+        expect(freePhysicalMemory, isNotNull);
+        expect(freePhysicalMemory! > 0, true);
+        break;
+      default:
+        expect(freePhysicalMemory, isNull);
+    }
+  });
+}
+
+class Fixture {
+  PlatformMemory getSut() {
+    return PlatformMemory(Platform.operatingSystem);
+  }
+}