Firebase Alerts-Trigger

Firebase bietet Benachrichtigungen für eine Vielzahl von Ereignissen im Zusammenhang mit der Projekt- und App-Verwaltung events. Hier sind einige Beispiele für Ereignisse, bei denen Firebase Ihnen diese Art von Benachrichtigung senden kann:

  • Bei Crashlytics können wir Sie benachrichtigen, wenn die Anzahl der Abstürze Ihrer App drastisch zunimmt.
  • Bei Performance Monitoring können wir Sie benachrichtigen, wenn die Startzeit Ihrer App den konfigurierten Schwellenwert überschreitet.
  • Bei App Distribution können wir Sie benachrichtigen, wenn einer Ihrer Tester ein neues iOS Gerät registriert.

Je nach Benachrichtigung und den von den Projekt mitgliedern festgelegten Einstellungen, werden diese Arten von Benachrichtigungen in der Firebase Console angezeigt oder per E-Mail gesendet.

Auf dieser Seite wird beschrieben, wie Sie Funktionen in Cloud Functions for Firebase (2. Generation) schreiben, die Benachrichtigungsereignisse verarbeiten.

Funktionsweise

Sie können Funktionen als Reaktion auf Benachrichtigungsereignisse auslösen, die von den folgenden Quellen ausgegeben werden:

In einem typischen Lebenszyklus führt eine Funktion, die durch ein Benachrichtigungsereignis ausgelöst wird, Folgendes aus:

  1. Sie wartet darauf, dass ein bestimmter Benachrichtigungstyp von Firebase ausgegeben wird.
  2. Sie wird ausgelöst, wenn die Benachrichtigung ausgegeben wird, und empfängt die Ereignisnutzlast, die spezifische Informationen zum Ereignis enthält.
  3. Sie ruft den Code Ihrer Funktion auf, um die Ereignisnutzlast zu verarbeiten.

Funktion bei Benachrichtigungsereignissen auslösen

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

Benachrichtigungsereignis verarbeitenCrashlytics

Im folgenden Crashlytics Beispiel verwenden Sie Cloud Functions for Firebase, um ein Benachrichtigungsereignis für ein neues schwerwiegendes Absturzproblem zu verarbeiten. Diese Funktion postet die Benachrichtigungsinformationen in einer Nachricht an einen Discord-Kanal.

Beispiel für eine Absturzbenachrichtigung in Discord

Beispielbenachrichtigung für ein neues schwerwiegendes Absturzproblem

Die Funktion wartet auf das Ereignis, das auftritt, wenn Firebase ein neues schwerwiegendes Problem veröffentlicht:

Node.js

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

Python

@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 parst dann das zurückgegebene Ereignisobjekt, extrahiert nützliche Informationen aus der Ereignisnutzlast und erstellt eine Nachricht, die an den Discord-Kanal gesendet werden soll:

Node.js

  // 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

Python

    # 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:

Node.js

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(`Discord returned status code ${response.status}`);
}
index.js

Python

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

Informationen zu allen Crashlytics Benachrichtigungsereignissen, die Sie erfassen können, finden Sie unter der Referenzdokumentation zu Crashlytics Benachrichtigungen.

Benachrichtigungsereignis von Performance Monitoring verarbeiten

In diesem Beispiel wird eine Funktion exportiert, die auf Benachrichtigungsereignisse für Leistungsschwellenwerte wartet:

Node.js

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

Python

@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 parst dann das zurückgegebene Ereignisobjekt, extrahiert nützliche Informationen aus der Ereignisnutzlast und erstellt eine Nachricht, die an den Discord Kanal gesendet werden soll:

Node.js

      // 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

Python

    # 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:

Node.js

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(`Discord returned status code ${response.status}`);
}
index.js

Python

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

Informationen zu allen Leistungsbenachrichtigungsereignissen, die Sie erfassen können, finden Sie in der Referenzdokumentation zu Performance Monitoring Benachrichtigungen.

Benachrichtigungsereignis verarbeitenApp Distribution

Das Beispiel in diesem Abschnitt zeigt, wie Sie eine Funktion für Benachrichtigungen zu neuen iOS Geräten von Testern 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 Nutzerverwaltungsprofil mit der UDID dieses Geräts aktualisieren und die App dann neu verteilen.

Node.js

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

Python

@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 parst dann das zurückgegebene Objekt, extrahiert nützliche Informationen aus der Ereignis nutzlast und erstellt eine Nachricht, die an den Discord-Kanal gesendet werden soll:

Node.js

  // 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

Python

    # 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:

Node.js

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(`Discord returned status code ${response.status}`);
}
index.js

Python

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

Informationen zu allen App Distribution Benachrichtigungsereignissen, die Sie erfassen können, finden Sie in der Referenzdokumentation zu App Distribution Benachrichtigungen.

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