Auslöser für Firebase-Warnungen

Firebase bietet Benachrichtigungen für eine Vielzahl von Projekt- und App-Management-Ereignissen. Hier sind einige Beispielereignisse, bei denen Firebase Ihnen diese Art von Benachrichtigung senden kann:

• Für Crashlytics können wir Sie benachrichtigen, wenn Ihre App einen dramatischen Anstieg der Abstürze verzeichnet.
• Zur Leistungsüberwachung können wir Sie benachrichtigen, wenn die Startzeit Ihrer App Ihren konfigurierten Schwellenwert überschreitet.
• Bei der App-Verteilung können wir Sie benachrichtigen, wenn einer Ihrer Tester ein neues iOS-Gerät registriert.

Abhängig von der Warnung und den vom Projektmitglied festgelegten Einstellungen zeigt Firebase diese Art von Warnungen in der Firebase-Konsole an oder versendet sie per E-Mail.

Auf dieser Seite wird beschrieben, wie Sie in Cloud Functions für Firebase (2. Generation) Funktionen schreiben, die Warnereignisse verarbeiten.

Wie funktioniert es?

Sie können Funktionen als Reaktion auf Alarmereignisse auslösen, die von diesen Quellen ausgegeben werden:

• Behandeln Sie ein App Distribution-Warnungsereignis
• Behandeln Sie ein Crashlytics-Warnungsereignis
• Behandeln Sie ein Leistungsüberwachungswarnungsereignis

In einem typischen Lebenszyklus führt eine durch ein Alarmereignis ausgelöste Funktion Folgendes aus:

1. Hört/wartet darauf, dass ein bestimmter Alarmtyp von Firebase ausgegeben wird.
2. Wird ausgelöst, wenn die Warnung ausgegeben wird, und empfängt die Ereignisnutzlast, die spezifische Informationen über das Ereignis enthält.
3. Ruft den Code Ihrer Funktion auf, um die Ereignisnutzlast zu verarbeiten.

Lösen Sie eine Funktion bei Alarmereignissen aus

Verwenden Sie das Unterpaket firebase-functions/v2/alerts um eine Funktion zu schreiben, die Alarmereignisse verarbeitet. Die folgenden produktspezifischen Beispiele veranschaulichen einen Workflow, bei dem eine Funktion einen Webhook verwendet, um eine Nachricht an einen Discord-Kanal zu posten, wenn eine Warnung für dieses Produkt von Firebase ausgegeben wird.

Behandeln Sie ein Crashlytics-Warnungsereignis

Für das folgende Crashlytics-Beispiel verwenden Sie Cloud Functions für Firebase, um ein Warnereignis zu einem neuen schwerwiegenden Absturzproblem zu verarbeiten. Diese Funktion veröffentlicht die Warninformationen in einer Nachricht an einen Discord-Kanal.

Die Funktion wartet auf das Ereignis, das der Veröffentlichung eines neuen schwerwiegenden Problems durch Firebase entspricht:

exports.postfatalissuetodiscord = onNewFatalIssuePublished(async (event) => {
index.js

@crashlytics_fn.on_new_fatal_issue_published(secrets=["DISCORD_WEBHOOK_URL"])
def post_fatal_issue_to_discord(event: crashlytics_fn.CrashlyticsNewFatalIssueEvent) -> None:
    """Publishes a message to Discord whenever a new Crashlytics fatal issue occurs."""
main.py

Die Funktion analysiert dann das zurückgegebene Ereignisobjekt, analysiert nützliche Informationen aus der Ereignisnutzlast und erstellt eine Nachricht, die im Discord-Kanal gepostet werden soll:

  // construct a helpful message to send to Discord
  const appId = event.appId;
  const {id, title, subtitle, appVersion} = event.data.payload.issue;
  const message = `
🚨 New fatal issue for ${appId} in version ${appVersion} 🚨

**${title}**

${subtitle}

id: \`${id}\`
`;
index.js

    # Construct a helpful message to send to Discord.
    app_id = event.app_id
    issue = event.data.payload.issue
    message = f"""
🚨 New fatal issue for {app_id} in version {issue.app_version} 🚨

# {issue.title}

{issue.subtitle}

ID: `{issue.id}`
""".strip()
main.py

Schließlich sendet die Funktion die erstellte Nachricht über eine HTTP-Anfrage an Discord:

const response = await postMessageToDiscord("Crashlytics Bot", message);
if (response.ok) {
  logger.info(
      `Posted fatal Crashlytics alert ${id} for ${appId} to Discord`,
      event.data.payload,
  );
} else {
  throw new Error(response.error);
}
index.js

response = post_message_to_discord("Crashlytics Bot", message, DISCORD_WEBHOOK_URL.value)
if response.ok:
    print(f"Posted fatal Crashlytics alert {issue.id} for {app_id} to Discord.")
    pprint.pp(event.data.payload)
else:
    response.raise_for_status()
main.py

Weitere Informationen zu allen Crashlytics-Warnungsereignissen, die Sie erfassen können, finden Sie in der Referenzdokumentation für Crashlytics-Warnungen .

Behandeln Sie ein Leistungsüberwachungswarnungsereignis

In diesem Beispiel wird eine Funktion exportiert, die auf Warnereignisse bei Leistungsschwellenwerten wartet:

exports.postperformancealerttodiscord = onThresholdAlertPublished(
    async (event) => {
index.js

@performance_fn.on_threshold_alert_published(secrets=["DISCORD_WEBHOOK_URL"])
def post_performance_alert_to_discord(event: performance_fn.PerformanceThresholdAlertEvent) -> None:
    """Publishes a message to Discord whenever a performance threshold alert is fired."""
main.py

Die Funktion analysiert dann das zurückgegebene Ereignisobjekt, analysiert nützliche Informationen aus der Ereignisnutzlast und erstellt eine Nachricht, die im Discord-Kanal gepostet werden soll:

      // construct a helpful message to send to Discord
      const appId = event.appId;
      const {
        eventName,
        metricType,
        eventType,
        numSamples,
        thresholdValue,
        thresholdUnit,
        conditionPercentile,
        appVersion,
        violationValue,
        violationUnit,
        investigateUri,
      } = event.data.payload;
      const message = `
    ⚠️ Performance Alert for ${metricType} of ${eventType}: **${eventName}** ⚠️
    
    App id: ${appId}
    Alert condition: ${thresholdValue} ${thresholdUnit}
    Percentile (if applicable): ${conditionPercentile}
    App version (if applicable): ${appVersion}
    
    Violation: ${violationValue} ${violationUnit}
    Number of samples checked: ${numSamples}
    
    **Investigate more:** ${investigateUri}
    `;
index.js

    # Construct a helpful message to send to Discord.
    app_id = event.app_id
    perf = event.data.payload
    message = f"""
⚠️ Performance Alert for {perf.metric_type} of {perf.event_type}: **{perf.event_name}** ⚠️

App ID: {app_id}
Alert condition: {perf.threshold_value} {perf.threshold_unit}
Percentile (if applicable): {perf.condition_percentile}
App version (if applicable): {perf.app_version}

Violation: {perf.violation_value} {perf.violation_unit}
Number of samples checked: {perf.num_samples}

**Investigate more:** {perf.investigate_uri}
""".strip()
main.py

Schließlich sendet die Funktion die erstellte Nachricht über eine HTTP-Anfrage an Discord:

const response = await postMessageToDiscord(
    "Firebase Performance Bot", message);
if (response.ok) {
  logger.info(
      `Posted Firebase Performance alert ${eventName} to Discord`,
      event.data.payload,
  );
} else {
  throw new Error(response.error);
}
index.js

response = post_message_to_discord("App Performance Bot", message,
                                   DISCORD_WEBHOOK_URL.value)
if response.ok:
    print(f"Posted Firebase Performance alert {perf.event_name} to Discord.")
    pprint.pp(event.data.payload)
else:
    response.raise_for_status()
main.py

Weitere Informationen zu allen Leistungswarnungsereignissen, die Sie erfassen können, finden Sie in der Referenzdokumentation für Leistungsüberwachungswarnungen .

Behandeln Sie ein App Distribution-Warnungsereignis

Das Beispiel in diesem Abschnitt zeigt Ihnen, wie Sie eine Funktion für neue iOS-Gerätewarnungen für Tester schreiben.

In diesem Beispiel wartet die Funktion auf Ereignisse, die jedes Mal gesendet werden, wenn ein Tester ein neues iOS-Gerät registriert. Wenn ein neues iOS-Gerät registriert wird, müssen Sie Ihr Bereitstellungsprofil mit der UDID dieses Geräts aktualisieren und dann die App neu verteilen.

exports.postnewduuidtodiscord = onNewTesterIosDevicePublished(async (event) => {
index.js

@app_distribution_fn.on_new_tester_ios_device_published(secrets=["DISCORD_WEBHOOK_URL"])
def post_new_udid_to_discord(event: app_distribution_fn.NewTesterDeviceEvent) -> None:
    """Publishes a message to Discord whenever someone registers a new iOS test device."""
main.py

Die Funktion analysiert dann das zurückgegebene Objekt, analysiert nützliche Informationen aus der Ereignisnutzlast und erstellt eine Nachricht, die im Discord-Kanal gepostet werden soll:

  // construct a helpful message to send to Discord
  const appId = event.appId;
  const {
    testerDeviceIdentifier,
    testerDeviceModelName,
    testerEmail,
    testerName,
  } = event.data.payload;
  const message = `
📱 New iOS device registered by ${testerName} <${testerEmail}> for ${appId}

UDID **${testerDeviceIdentifier}** for ${testerDeviceModelName}
`;
index.js

    # Construct a helpful message to send to Discord.
    app_id = event.app_id
    app_dist = event.data.payload
    message = f"""
📱 New iOS device registered by {app_dist.tester_name} <{app_dist.tester_email}> for {app_id}

UDID **{app_dist.tester_device_identifier}** for {app_dist.tester_device_model_name}
""".strip()
main.py

Schließlich sendet die Funktion die erstellte Nachricht über eine HTTP-Anfrage an Discord:

const response = await postMessageToDiscord("AppDistribution Bot", message);
if (response.ok) {
  logger.info(
      `Posted iOS device registration alert for ${testerEmail} to Discord`,
  );
} else {
  throw new Error(response.error);
}
index.js

response = post_message_to_discord("App Distro Bot", message, DISCORD_WEBHOOK_URL.value)
if response.ok:
    print(f"Posted iOS device registration alert for {app_dist.tester_email} to Discord.")
    pprint.pp(event.data.payload)
else:
    response.raise_for_status()
main.py

Weitere Informationen zu allen App Distribution-Warnungsereignissen, die Sie erfassen können, finden Sie in der Referenzdokumentation für App Distribution-Warnungen .

Informationen zur Verwendung einer Funktion, die durch eine In-App-Feedback-Firebase-Benachrichtigung von App Distribution ausgelöst wird, finden Sie unter In-App-Feedback an Jira senden .