Flutter
Strukturierte Logs aus deiner Flutter-App unter iOS und Android, über die nativen Lyrelog-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 lyrelogOder in pubspec.yaml:
dependencies:
lyrelog: ^0.1.0Einrichtung 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.
minSdkkann 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-outawait 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:
mechanism | Von | Die Payload enthält außerdem |
|---|---|---|
flutter_error | FlutterError.onError: Fehler beim Bauen, Layouten oder Zeichnen von Widgets und in Gesten-Callbacks | library (widgets library) und context (building MyWidget) |
platform_dispatcher | PlatformDispatcher.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:
| Plattform | Events | Von |
|---|---|---|
| iOS | app_crashed (critical), app_hung (error), cpu_overuse, disk_write_overuse, slow_launch (Warnungen) | MetricKit, wie auf der Swift-Seite |
| Android | app_crashed (critical) mit handled: false und mechanism: uncaught_exception | Nicht 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:
developmentfür einen Debug-Build, jeden Build im Simulator oder einen Build mit eingebettetem Provisioning Profile (Development- und Ad-hoc-Signierung);testflightfür einen TestFlight-Build; sonstproduction. Danach die Antwort von StoreKit, wie auf der Swift-Seite. - Android:
development, wenn die App debuggable ist (jeder Debug-Build), sonstproduction.
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).
Einwilligung
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 recordingConsent.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 stopflush 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.1mit 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.2mit dessen Port (10.0.2.2ist 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 wie10.0.2.2zu 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.
- Erlaube unverschlüsseltes http zu
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_byistapp_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 aufproduction; 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.
- Füge in Xcode dem Target Runner die Capability App Attest hinzu (Signing & Capabilities),
das Entitlement
- Android, mit Key Attestation
(
verified_byistkey_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 signingReportanzeigt (führe den Befehl im Ordnerandroiddeiner 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
| Option | Standard | Bedeutung |
|---|---|---|
apiKey | Pflicht | Der Ingest-Schlüssel des Projekts |
endpoint | https://ingest.lyrelog.com | Die Basis-URL; ein eingefügter Pfad /v1/... wird entfernt. Nur https, http nur für localhost und 10.0.2.2 im Android-Emulator |
consent | Consent.granted | pending, granted oder denied |
minimumLevel | LogLevel.debug | Events darunter werden verworfen, bevor sie die Warteschlange auf dem Gerät erreichen |
flushInterval | 15 s | Wie oft der Uploader im Vordergrund läuft |
maxBatchBytes | 512 KiB | Ein Batch schließt bei dem Limit, das zuerst erreicht wird (höchstens 4 MiB) |
maxBatchEvents | 500 | Höchstens 2.000 |
maxDiskBytes | 20 MB | Obergrenze für die Warteschlange auf der Festplatte, älteste zuerst |
maxEventAge | 7 Tage | Ältere Events in der Warteschlange werden verworfen |
sessionTimeout | 30 min | Inaktive Zeit, nach der eine neue Session beginnt |
environment | erkannt | Jeder gültige Name oder null |
platform | das Betriebssystem | Jeder gültige Name oder null |
redactedKeys | null: defaultRedactedKeys | Zu schwärzende Schlüsselnamen; deine Liste ersetzt die Standardwerte, eine leere Liste schaltet es ab |
captureErrors | true | Dart-Fehler melden, die niemand abgefangen hat |
captureNativeCrashes | true | iOS: MetricKit-Berichte zu Abstürzen, Hängern und Übernutzung. Android: nicht abgefangene JVM-Exceptions. Beim nächsten Start gesendet |
attachScreen | true | Events mit dem aktuellen Screen taggen |
attest | true | Events mit App Attest oder Key Attestation verifizieren, sobald das Projekt eingerichtet ist |
mirrorToConsole | false | Jedes Event zusätzlich ins native Log ausgeben (Konsole von Xcode, logcat) |
pauseUploadsInLowPowerMode | true | Nur 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:
| iOS | Android | |
|---|---|---|
| Blockiert nie | Ein 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 Offline | Eine 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 sendet | Alle 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. |
| Batches | Bis 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. |
| Wiederholungen | 1 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. |
| Monatskontingent | Wenn 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 sichtbar | Events, die durch die Obergrenzen verloren gehen, werden zu einer Warnung lyrelog_events_dropped (Bereich lyrelog) mit der Anzahl. | Genauso. |
| Eigene Probleme | Ein 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. |
| Kontext | App-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. |
| Secrets | Werte 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. |
| Limits | Lange 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
setUserauf. - Identifiers > User ID, mit der Person verknüpft: nur, wenn du
setUseraufrufst. - 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.