Early AccessNur auf Einladung, und die SDKs sind noch nicht veröffentlicht.Einladung anfragen
Zum Inhalt springen
Docs

Flutter

Strukturierte Logs aus deiner Flutter-App unter iOS und Android, über die nativen Lyrelog-SDKs.

iOS- und Android-Apps, auf Basis der nativen SDKs

Das Flutter-SDK ist das Dart-Paket lyrelog, ein Plugin für iOS 16 und Android 7.0 (API 24) oder neuer, gebaut mit Flutter 3.50. Es ist eine schlanke Dart-Schicht über den nativen SDKs, dem Swift-SDK unter iOS und dem Android-SDK unter Android, sodass die Warteschlange auf der Festplatte, native Abstürze, das Senden im Hintergrund, Sessions, Einwilligung und verifizierte Events so funktionieren wie dort. Zusätzlich meldet es Dart-Fehler, die niemand abgefangen hat, und benennt Screens anhand deines Navigators.

Interne Vorschau: Dieses Paket ist noch nicht veröffentlicht. Bis dahin findet flutter pub add lyrelog nichts: Es ist nicht auf pub.dev, und das Repository ist privat und hat noch kein Release.

Installation

flutter pub add lyrelog

Oder in pubspec.yaml:

dependencies:
  lyrelog: ^0.1.0

Einrichtung für iOS

  • Das Plugin ist ein Swift-Paket, deine App baut es also mit Swift Package Manager, den Flutter standardmäßig nutzt. Eine CocoaPods-Version gibt es nicht.
  • Setze das Minimum der App auf iOS 16: in Xcode im Target Runner, General, Minimum Deployments (IPHONEOS_DEPLOYMENT_TARGET = 16.0). Der Standard von Flutter ist niedriger, und der Build bricht mit einer entsprechenden Meldung ab.

Einrichtung für Android

  • Die Standardwerte von Flutter funktionieren: compileSdk 36 und Kotlin 2.2 oder neuer. minSdk kann auf 24 bleiben.

Die Bibliothek fügt dem Manifest deiner App die Berechtigung INTERNET hinzu.

Starten

Starte einmal, so früh wie möglich: in main, vor runApp. Ein zweiter Aufruf, während es läuft, wird ignoriert. start ruft WidgetsFlutterBinding.ensureInitialized() selbst auf, kann also ganz am Anfang stehen, und nichts muss darauf warten: Was du nach start loggst, erreicht das native SDK danach. Events, die vor start geloggt werden, werden ignoriert, aber setUser und setConsent, vor start aufgerufen, bleiben erhalten und werden angewendet, sobald es läuft.

import 'package:flutter/widgets.dart';
import 'package:lyrelog/lyrelog.dart';

void main() {
  Lyrelog.start(const LyrelogConfiguration(
    apiKey: 'lyr_ing_...', // ingest-only: it can append events, never read them
  ));
  runApp(const MyApp());
}

Events gehen an https://ingest.lyrelog.com. Übergib endpoint nur, um sie woanders hinzuschicken. Das ist die Basis-URL (ein eingefügter Pfad .../v1/events:batch wird entfernt) und muss https sein; unverschlüsseltes http geht nur für localhost, 127.0.0.1 oder ::1 und im Android-Emulator für 10.0.2.2 (siehe In Entwicklung und Tests). Mit jedem anderen Endpoint wird nichts gesendet, und die Events bleiben auf dem Gerät.

Events loggen

Eine Funktion pro Level: trace, debug, info, notice, warning, error, critical, oder log(level, message, ...) mit einem LogLevel.

Lyrelog.info('checkout_done', attrs: {'items': 3, 'latency_ms': ms});
Lyrelog.error('payment_declined', category: 'checkout',
    attrs: {'code': 51}, payload: {'response': raw});

Attribute sind eine Map<String, Object?>: Strings, Zahlen, Booleans, null, Listen und verschachtelte Maps bis 4 Ebenen. Ein DateTime wird als ISO-8601-Text gesendet, eine Duration in Millisekunden, ein Enum als sein Name und alles andere als sein toString(). Die Payload ist ein beliebiger Wert dieser Arten, für die Details, die du nur liest, wenn du ein einzelnes Event öffnest.

Logger für jeden Bereich

Ein Logger versieht jedes Event mit seiner category, wie ein Log-Tag. Er hat jedes Level, dazu log und captureError. Er ist günstig zu erzeugen und aufzubewahren und loggt in das SDK, das gerade läuft, wenn er aufgerufen wird.

final sync = Lyrelog.logger('sync');
sync.warning('sync_conflict', attrs: {'records': 2});

Nutzer

Lyrelog.setUser(account.id); // attached to every following event
Lyrelog.setUser(null);       // on sign-out

await Lyrelog.sessionId() liefert die ID der aktuellen Session, zum Beispiel zum Anzeigen in einem Support-Screen.

Die Nutzer-ID wird zwischen Starts nicht gespeichert: Rufe setUser bei jedem Start erneut auf, sobald du weißt, wer die Person ist.

Screens

Sag, wo die Person gerade ist. Lyrelog loggt screen_viewed (Bereich navigation) mit dem vorherigen Screen und den darauf verbrachten Sekunden und versieht jedes folgende Event mit einem Attribut screen.

Füge dem Navigator deiner App LyrelogNavigatorObserver hinzu, und jede Page Route, die nach oben kommt, ist ein Screen, benannt nach ihrem Routennamen:

MaterialApp(
  navigatorObservers: [LyrelogNavigatorObserver()],
  routes: {
    '/': (_) => const HomePage(),
    '/settings': (_) => const SettingsPage(),
  },
)

Das funktioniert mit jedem Navigator, also auch mit einem Router, der Observer annimmt (mit go_router: GoRouter(observers: [LyrelogNavigatorObserver()], ...)). Die Rückkehr zu einer Seite loggt sie erneut, da sie wieder der Screen ist. Dialoge, Bottom Sheets und Menüs ändern den Screen nicht, und Routen ohne Namen werden übersprungen. Beides lässt sich ändern:

LyrelogNavigatorObserver(
  nameExtractor: (settings) => settings.name?.replaceFirst('/', ''), // null or '' skips the route
  routeFilter: (route) => route is PageRoute,                         // which routes are screens
)

Oder rufe es selbst auf:

Lyrelog.screen('Settings');

Das Event trägt screen, previous_screen und seconds_on_previous. Ein erneuter Aufruf von screen mit demselben Namen loggt nichts. screen nimmt zusätzliche attrs für das Event screen_viewed. Schalte das Taggen mit attachScreen: false ab.

Abgefangene Fehler

try {
  await store.purchase(product);
} catch (e, s) {
  Lyrelog.captureError(e, stackTrace: s, category: 'store');
}

Es sendet das Event exception, das jedes SDK sendet: Level error, die Attribute error_type (der Laufzeittyp) und error_message (sein toString()) und eine Payload mit der Beschreibung und bis zu 60 Frames des Stacks. Ohne stackTrace sind die Frames der eigene Stack eines Error, falls er einen hat. attrs fügt eigene hinzu; level ändert das Level. Jeder Logger hat ebenfalls captureError.

Fehler und Abstürze

Dart-Fehler, die niemand abfängt

start meldet sie von selbst (captureErrors, standardmäßig an), als Events exception mit handled: false und einem mechanism, der sagt, wo Flutter sie übergeben hat:

mechanismVonDie Payload enthält außerdem
flutter_errorFlutterError.onError: Fehler beim Bauen, Layouten oder Zeichnen von Widgets und in Gesten-Callbackslibrary (widgets library) und context (building MyWidget)
platform_dispatcherPlatformDispatcher.instance.onError: Fehler in asynchronem Code, Timern und Futures, auf die niemand gewartet hat

Die zuvor installierten Handler laufen weiter, nach denen von Lyrelog, und PlatformDispatcher.onError gibt zurück, was der frühere zurückgegeben hat (ohne einen gibt Flutter den Fehler trotzdem aus). Wenn du eigene Handler setzt, setze sie vor start oder rufe aus ihnen captureError auf.

Höchstens 10 davon werden pro Minute gesendet, und derselbe Fehler (Typ, Nachricht und oberster Frame) nur einmal alle 10 Sekunden, sodass ein Layoutfehler, der sich in jedem Frame wiederholt, ein einziges Event sendet. Fehler, die Flutter als still markiert und auch in Release-Builds nicht meldet (zum Beispiel ein Bild, das nicht geladen werden konnte), werden ausgelassen.

Ein Dart-Fehler beendet eine Flutter-App nicht, also sind das Events exception, nie app_crashed.

Wenn deine App in einer eigenen Zone läuft, melde die Fehler der Zone auf dieselbe Weise:

runZonedGuarded(() => runApp(const MyApp()), (error, stack) {
  Lyrelog.captureError(error, stackTrace: stack, handled: false, mechanism: 'zone');
});

Native Abstürze

Abstürze der App selbst kommen von den nativen SDKs (captureNativeCrashes, standardmäßig an). Sie werden beim nächsten Start gesendet, mit dem Zeitstempel des Vorfalls im Bereich diagnostics:

PlattformEventsVon
iOSapp_crashed (critical), app_hung (error), cpu_overuse, disk_write_overuse, slow_launch (Warnungen)MetricKit, wie auf der Swift-Seite
Androidapp_crashed (critical) mit handled: false und mechanism: uncaught_exceptionNicht abgefangene JVM-Exceptions, wie auf der Android-Seite

Unter Android werden native Abstürze (C oder C++) und ANRs nicht gemeldet.

Obfuskierte Builds

Mit flutter build --obfuscate --split-debug-info=<dir> sind die Typnamen in error_type und die Frames obfuskiert. Bewahre die Symbole auf, die der Build schreibt, und führe damit flutter symbolize auf den Frames aus, um sie zu lesen.

Umgebungen und Plattform

Das native SDK wählt beim Start die Umgebung:

  • iOS: development für einen Debug-Build, jeden Build im Simulator oder einen Build mit eingebettetem Provisioning Profile (Development- und Ad-hoc-Signierung); testflight für einen TestFlight-Build; sonst production. Danach die Antwort von StoreKit, wie auf der Swift-Seite.
  • Android: development, wenn die App debuggable ist (jeder Debug-Build), sonst production.

Deine eigenen Builds mit flutter run senden development, während das Dashboard mit production öffnet: Wähle development in der oberen Leiste, um sie zu sehen.

Die Plattform ist das Betriebssystem, ios oder android, sodass ein Projekt beide enthält und das Dashboard nach jeder filtern kann. Beides lässt sich in der Konfiguration überschreiben:

LyrelogConfiguration(
  apiKey: key,
  environment: isInternalTester ? 'internal' : null, // null = detected
  platform: null,
)

Jeder Name geht: Kleinbuchstaben, Ziffern, - und _, bis zu 32 Zeichen. Anderer Text wird in einen gültigen Namen umgewandelt (Staging EU wird zu staging-eu).

Lyrelog.start(LyrelogConfiguration(apiKey: key, consent: Consent.pending));
// later, when the person chooses:
Lyrelog.setConsent(Consent.granted); // sends, including what was kept while pending
Lyrelog.setConsent(Consent.denied);  // deletes everything and stops recording

Consent.pending behält Events auf dem Gerät, ohne sie zu senden. Ohne erteilte Einwilligung wird nichts hochgeladen, auch nicht, was ein früherer Start hinterlassen hat. Ein Start mit Consent.denied löscht die Installations-ID und alles, was von einem früheren Start noch in der Warteschlange liegt, und zeichnet nichts auf. Ein setConsent vor start hat Vorrang vor dem consent der Konfiguration.

Die Einwilligung wird zwischen Starts nicht gespeichert: Speichere die Entscheidung der Person selbst und übergib sie jedes Mal an start.

Eine vollständige App

Starte mit der gespeicherten Einwilligung, setze die Person beim Anmelden und benenne Screens anhand des Navigators:

import 'package:flutter/material.dart';
import 'package:lyrelog/lyrelog.dart';
import 'package:shared_preferences/shared_preferences.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  final prefs = await SharedPreferences.getInstance();
  final consent = switch (prefs.getString('diagnostics')) {
    'granted' => Consent.granted,
    'denied' => Consent.denied,
    _ => Consent.pending,
  };
  Lyrelog.start(LyrelogConfiguration(apiKey: 'lyr_ing_...', consent: consent));
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) => MaterialApp(
        navigatorObservers: [LyrelogNavigatorObserver()],
        routes: {
          '/': (_) => const HomePage(),
          '/sign-in': (_) => SignInPage(onSignedIn: signedIn),
        },
      );
}

void signedIn(Account account) {
  Lyrelog.setUser(account.id);
  Lyrelog.info('signed_in', category: 'auth');
}

Future<void> choose(bool allowed) async {
  final prefs = await SharedPreferences.getInstance();
  await prefs.setString('diagnostics', allowed ? 'granted' : 'denied');
  Lyrelog.setConsent(allowed ? Consent.granted : Consent.denied);
}

Flush und Stopp

Der Wechsel in den Hintergrund sendet bereits: unter iOS in einem Background Task, unter Android, wenn die Activity der App stoppt. Du brauchst es also selten.

await Lyrelog.flush(); // write everything to disk and send, waiting up to 5 seconds
await Lyrelog.stop();  // send what's queued (up to 2 seconds), then stop

flush gibt true zurück, wenn es rechtzeitig fertig wurde (timeout: ändert die Wartezeit), und respektiert ein Retry-After, das der Server verlangt hat: Es sendet nicht früher. Nach stop kann start erneut aufgerufen werden.

In Entwicklung und Tests

Rufe in Widget- und Unit-Tests Lyrelog.start nicht auf: Alles, was vor start geloggt wird, wird ignoriert, also läuft der Rest deines Codes unverändert. Auf einer Plattform, die das Plugin nicht unterstützt (Web, Desktop), tut jeder Aufruf nichts und wirft nie.

mirrorToConsole: true gibt jedes Event während der Arbeit zusätzlich ins native Log aus: unter iOS in die Konsole von Xcode, unter Android in logcat (Tag Lyrelog).

Debug-Builds senden die Umgebung development. Um an einen Endpoint auf deinem Rechner zu senden:

  • iOS-Simulator: Nutze http://127.0.0.1 mit dessen Port. Der Simulator teilt das Netzwerk deines Rechners, und dafür ist keine Ausnahme für App Transport Security nötig.
  • Android-Emulator: Nutze http://10.0.2.2 mit dessen Port (10.0.2.2 ist dein Rechner aus Sicht des Emulators), nur im Debug-Build:
    • Erlaube unverschlüsseltes http zu 10.0.2.2. Android blockiert es, sofern die App es nicht erlaubt: Füge dem Debug-Build (android/app/src/debug) eine Network Security Config hinzu, die Cleartext für genau diese Adresse zulässt.
    • Unter Android 17 braucht eine App mit Target API 37 außerdem ACCESS_LOCAL_NETWORK, um eine private Adresse wie 10.0.2.2 zu erreichen; ohne sie läuft die Verbindung einfach in ein Timeout. Deklariere die Berechtigung im Debug-Manifest (android/app/src/debug/AndroidManifest.xml) und erteile sie: adb shell pm grant <your.app> android.permission.ACCESS_LOCAL_NETWORK.

Halte den Schlüssel mit --dart-define-from-file aus deinem Quellcode heraus, zum Beispiel mit flutter run --dart-define-from-file=lyrelog.local.json und String.fromEnvironment('LYRELOG_KEY'), wobei die Datei von git ignoriert wird.

Das ist nur für die lokale Entwicklung. Der gehostete Ingest ist eine öffentliche https-Adresse und braucht nichts davon.

Verifizierte Events

Ein verifiziertes Event ist eines, das nicht von jemandem gesendet worden sein kann, der den öffentlichen Ingest-Schlüssel aus einer App oder einer Webseite kopiert hat. Was das beweist und was nicht, steht unter Verifizierte Events.

Die nativen SDKs verifizieren die App auf echten Geräten (attest, standardmäßig an), und an deinem Dart-Code ändert sich nichts. Richte jede Plattform ein, auf der die App erscheint:

  • iOS, mit App Attest von Apple (verified_by ist app_attest):
    • Füge in Xcode dem Target Runner die Capability App Attest hinzu (Signing & Capabilities), das Entitlement com.apple.developer.devicecheck.appattest-environment. Setze es für App-Store- und TestFlight-Builds auf production; ohne diesen Wert nutzt Apple die Development-Umgebung.
    • Trage deine App ID, also Team ID, ein Punkt und die Bundle-ID (ABCDE12345.com.example.app), in den Projekteinstellungen unter Verified events from your Apple apps ein.
  • Android, mit Key Attestation (verified_by ist key_attestation): Füge in den Projekteinstellungen unter Verified events from your Android apps dein Package und den SHA-256-Fingerabdruck jedes Zertifikats hinzu, das Builds signiert, die Events senden: den App-Signaturschlüssel von Play (Play Console, Test and release, App integrity) und, für Builds, die du selbst signierst, den, den ./gradlew signingReport anzeigt (führe den Befehl im Ordner android deiner App aus).

Zum Abschalten auf beiden:

Lyrelog.start(const LyrelogConfiguration(apiKey: 'lyr_ing_...', attest: false));

Das Senden wartet nie auf die Verifizierung: Bis die App ein Token hat, und sobald etwas fehlschlägt, werden Events unverifiziert gesendet. Solange eine Plattform im Projekt nicht eingerichtet ist, hört das SDK für diesen Start auf, es zu versuchen.

  • Der iOS-Simulator und Android-Emulatoren verifizieren nie.
  • Ein Gerät, das der Server ablehnt (ein gerootetes Telefon, ein entsperrter Bootloader, ein Zertifikat, das das Projekt nicht kennt), sendet unverifizierte Events; Android versucht es einen Tag später erneut.
  • Eine verweigerte Einwilligung löscht auf beiden Plattformen den Eintrag des attestierten Schlüssels.

Bevor du das Projekt nur noch verifizierte Events von ios oder android annehmen lässt, prüfe im Explorer, dass die Events deiner echten Nutzer verifiziert ankommen: Events von älteren Versionen, Simulatoren, Emulatoren und abgelehnten Geräten würden mit einem 425 zurückgehalten. Packe nie einen Server-Schlüssel (lyr_srv_...) in eine App: Alles, was in einer App ausgeliefert wird, lässt sich auslesen.

Zum Prüfen öffne den Explorer: Ein geöffnetes Event zeigt die Verifizierung unter Context in seiner Zeile Sender: Verified, App Attest, Verified, Key Attestation oder Not verified, public key.

Konfiguration

OptionStandardBedeutung
apiKeyPflichtDer Ingest-Schlüssel des Projekts
endpointhttps://ingest.lyrelog.comDie Basis-URL; ein eingefügter Pfad /v1/... wird entfernt. Nur https, http nur für localhost und 10.0.2.2 im Android-Emulator
consentConsent.grantedpending, granted oder denied
minimumLevelLogLevel.debugEvents darunter werden verworfen, bevor sie die Warteschlange auf dem Gerät erreichen
flushInterval15 sWie oft der Uploader im Vordergrund läuft
maxBatchBytes512 KiBEin Batch schließt bei dem Limit, das zuerst erreicht wird (höchstens 4 MiB)
maxBatchEvents500Höchstens 2.000
maxDiskBytes20 MBObergrenze für die Warteschlange auf der Festplatte, älteste zuerst
maxEventAge7 TageÄltere Events in der Warteschlange werden verworfen
sessionTimeout30 minInaktive Zeit, nach der eine neue Session beginnt
environmenterkanntJeder gültige Name oder null
platformdas BetriebssystemJeder gültige Name oder null
redactedKeysnull: defaultRedactedKeysZu schwärzende Schlüsselnamen; deine Liste ersetzt die Standardwerte, eine leere Liste schaltet es ab
captureErrorstrueDart-Fehler melden, die niemand abgefangen hat
captureNativeCrashestrueiOS: MetricKit-Berichte zu Abstürzen, Hängern und Übernutzung. Android: nicht abgefangene JVM-Exceptions. Beim nächsten Start gesendet
attachScreentrueEvents mit dem aktuellen Screen taggen
attesttrueEvents mit App Attest oder Key Attestation verifizieren, sobald das Projekt eingerichtet ist
mirrorToConsolefalseJedes Event zusätzlich ins native Log ausgeben (Konsole von Xcode, logcat)
pauseUploadsInLowPowerModetrueNur iOS: Regelmäßige Uploads pausieren; der Wechsel in den Hintergrund sendet trotzdem

Zustellung und Limits

Die Zustellung ist die des nativen SDKs, genau wie in einer Swift- oder Kotlin-App:

iOSAndroid
Blockiert nieEin Aufruf übergibt das Event an das native SDK und kehrt zurück; ein einzelner Writer im Hintergrund schreibt es auf die Festplatte und wartet nie auf das Netzwerk.Genauso.
Übersteht Beenden und OfflineEine Warteschlange in Library/Caches, begrenzt auf 20 MB und 7 Tage. Das System kann Caches leeren, wenn auf dem Gerät der Platz knapp wird, und die wartenden Events gehen mit.Eine Warteschlange in noBackupFilesDir/lyrelog, begrenzt auf 20 MB und 7 Tage, nie in einem Backup, sodass ein wiederhergestelltes Telefon nicht die Events eines anderen Geräts erneut sendet.
Wann es sendetAlle 15 s im Vordergrund (pausiert im Stromsparmodus) und wenn die App in den Hintergrund geht, in einem Background Task.Alle 15 s, solange die Activity der App gestartet ist, und wenn sie in den Hintergrund geht. Im Hintergrund läuft kein Timer: Der Rest geht beim nächsten Start raus oder wenn die App das nächste Mal in den Vordergrund kommt.
BatchesBis zu 500 Events oder 512 KiB pro Request, mit gzip. Ein Event, das kodiert größer als 1 MiB ist, wird verworfen und gezählt.Genauso.
Wiederholungen1 s, verdoppelt bis 5 min, mit Full Jitter, unter Beachtung von Retry-After. Jeder andere 4xx-Status verwirft den Batch, ein 3xx (eine Weiterleitung, nie verfolgt) verwirft ihn, und ein widerrufener Schlüssel (401, 403) stoppt das Senden bis zum nächsten Start und behält die Events. Ein Batch, an dem der Server immer wieder scheitert, während andere durchgehen, wandert nach hinten und wird dann verworfen.Genauso.
MonatskontingentWenn eine Free-Organisation die Events ihres Monats verbraucht hat, antwortet der Server mit 429. Die Events bleiben in der Warteschlange auf der Festplatte und gehen raus, sobald der Server sie wieder annimmt, innerhalb der Obergrenzen von 20 MB und 7 Tagen. Eine Warnung im Unified Log (Subsystem com.lyrelog.sdk).Genauso, die Warnung in logcat (Tag Lyrelog).
Verluste sind sichtbarEvents, die durch die Obergrenzen verloren gehen, werden zu einer Warnung lyrelog_events_dropped (Bereich lyrelog) mit der Anzahl.Genauso.
Eigene ProblemeEin falscher Endpoint, ein abgelehnter Schlüssel oder abgelehnte Zeilen gehen einmal pro Start ins Unified Log, Subsystem com.lyrelog.sdk, auf Debug-Level.Genauso in logcat, Tag Lyrelog, auf Debug-Level.
KontextApp-ID, Version, Build, Betriebssystem, Gerätemodell (iPhone18,1), Locale, Plattform ios, Session-ID (neu nach 30 min Inaktivität) und Installations-ID. sdk ist lyrelog-flutter/0.1.0 lyrelog-swift/0.1.0.App-ID (der Package-Name), Version Name, Version Code, die Android-Version, das Gerät (Google Pixel 9), Locale, Plattform android, Session-ID und Installations-ID. sdk ist lyrelog-flutter/0.1.0 lyrelog-android/0.1.0.
SecretsWerte unter Schlüsseln, deren Name authorization, cookie, password, token, secret, apikey oder ein anderer Eintrag der gemeinsamen Liste ist oder darauf endet, werden zu "[redacted]", auf jeder Ebene, bevor etwas gekürzt wird.Genauso.
LimitsLange Strings werden an einer Zeichengrenze gekürzt, überzählige Attribute in lyrelog_dropped_attrs gezählt, Payloads über 64 KiB zusammengefasst als {"lyrelog_truncated": true, "bytes": N, "preview": "..."}.Genauso.

Ändere die Liste zum Schwärzen mit redactedKeys: Deine Liste ersetzt die Standardwerte, und eine leere Liste schaltet das Schwärzen ab. Um etwas hinzuzufügen:

Lyrelog.start(const LyrelogConfiguration(
  apiKey: 'lyr_ing_...',
  redactedKeys: [...LyrelogConfiguration.defaultRedactedKeys, 'pin'],
));

App-Store-Datenschutz und Datensicherheit bei Play

Das Privacy Manifest des Swift-SDKs (PrivacyInfo.xcprivacy) wird in der App mitgeliefert, und Xcode übernimmt es in den Datenschutzbericht der App, wie auf der Swift-Seite.

Gib für das Datenschutz-Label im App Store an, was deine App über Lyrelog sendet:

  • Diagnostics: Crash Data, Performance Data, Other Diagnostic Data (App Functionality).
  • Identifiers > Device ID: die Installations-ID, eine zufällige UUID, die nicht die Werbe-ID ist, nicht gesichert wird und bei einer Verweigerung gelöscht wird (App Functionality). Nicht mit der Person verknüpft, es sei denn, du rufst auch setUser auf.
  • Identifiers > User ID, mit der Person verknüpft: nur, wenn du setUser aufrufst.
  • Usage Data > Product Interaction: wenn du Screens (screen_viewed) oder Taps loggst.

Für das Formular zur Datensicherheit in der Play Console:

  • App info and performance: Crash logs, Diagnostics (App functionality, und Analytics, wenn du es so nutzt). Erhoben, nicht weitergegeben.
  • Device or other IDs: die Installations-ID, wie oben.
  • App activity > App interactions: wenn du Screens oder Taps loggst.

Bei beiden kommt alles andere, was deine attrs oder payload enthalten (E-Mails, Käufe...), unter die jeweils passende Kategorie. Die Daten werden bei der Übertragung verschlüsselt (https). Der Server ergänzt das Land der sendenden Adresse; die Adresse selbst wird nicht gespeichert.