Firebase bietet Benachrichtigungen für eine Vielzahl von Ereignissen bei der Projekt- und App-Verwaltung. Hier sind einige Beispielereignisse, die zeigen, wann Firebase Ihnen diese Art der Benachrichtigung:
- Ab dem Crashlytics können wir Sie benachrichtigen, wenn die Anzahl der Abstürze Ihrer App stark zunimmt.
- Bei Performance Monitoring können wir Sie benachrichtigen, wenn die Startzeit Ihrer App den konfigurierten Grenzwert überschreitet.
- Wir können Sie für App Distribution benachrichtigen, wenn einer Ihrer Tester ein neues iOS-Gerät .
Je nach Benachrichtigung und den vom Projektmitglied festgelegten Einstellungen werden diese Benachrichtigungstypen in der Firebase Console angezeigt oder per E-Mail gesendet.
Auf dieser Seite wird beschrieben, wie Funktionen in Cloud Functions for Firebase (2. Generation) geschrieben werden. die Benachrichtigungsereignisse verarbeiten.
Funktionsweise
Sie können Funktionen als Reaktion auf Benachrichtigungsereignisse auslösen, die von diesen Quellen ausgegeben werden:
- Umgang mit einem App Distribution-Benachrichtigungsereignis
- Crashlytics-Benachrichtigungsereignis verarbeiten
- Performance Monitoring-Benachrichtigungsereignisse verarbeiten
In einem typischen Lebenszyklus führt eine Funktion, die durch ein Benachrichtigungsereignis ausgelöst wird, Folgendes:
- Wartet auf einen bestimmten Benachrichtigungstyp, der von Firebase ausgegeben wird.
- Wird ausgelöst, wenn die Benachrichtigung ausgegeben wird, und empfängt die Ereignisnutzlast, bestimmte Informationen über das Ereignis enthält.
- Ruft den Code Ihrer Funktion auf, um die Ereignisnutzlast zu verarbeiten.
Funktion für Benachrichtigungsereignisse auslösen
Verwenden Sie das Teilpaket firebase-functions/v2/alerts, um eine Funktion zu schreiben, die
Benachrichtigungsereignisse verarbeitet. Die folgenden produktspezifischen Beispiele zeigen eine
Workflow, bei dem eine Funktion einen Webhook verwendet, um eine Nachricht in einem Discord-Kanal zu posten
Eine Benachrichtigung für dieses Produkt wird von Firebase ausgegeben.
Crashlytics-Benachrichtigungsereignis verarbeiten
Im folgenden Crashlytics-Beispiel verwenden Sie Cloud Functions for Firebase, um bei einem neuen schwerwiegenden Absturzproblem behandelt. Diese Funktion sendet die Benachrichtigung in einer Nachricht an einen Discord-Kanal.
Die Funktion wartet auf das Ereignis, das Firebase entspricht. Veröffentlichung eines neuen schwerwiegenden Problems:
Node.js
exports.postfatalissuetodiscord = onNewFatalIssuePublished(async (event) => {
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."""
Die Funktion parst dann das zurückgegebene Ereignisobjekt. nutzbringende Informationen aus der Ereignisnutzlast geparst und eine Nachricht an die auf dem Discord-Kanal posten:
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}\`
`;
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()
Schließlich sendet die Funktion die konstruierte Nachricht über einer HTTP-Anfrage:
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(response.error);
}
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()
Informationen zu allen Crashlytics-Benachrichtigungsereignissen, die erfasst werden können, finden Sie unter der Referenzdokumentation für Crashlytics Benachrichtigungen.
Performance Monitoring-Benachrichtigungsereignis verarbeiten
In diesem Beispiel wird eine Funktion exportiert, die auf Ereignisse für Benachrichtigungen zu Leistungsgrenzwerten wartet:
Node.js
exports.postperformancealerttodiscord = onThresholdAlertPublished(
async (event) => {
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."""
Die Funktion analysiert dann das zurückgegebene Ereignisobjekt und parst nützliche Informationen. aus der Ereignisnutzlast und erstellen eine Nachricht, die in Discord gepostet wird. Kanal:
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}
`;
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()
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(response.error);
}
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()
Informationen zu allen Ereignissen für Leistungsbenachrichtigungen, die Sie erfassen können, finden Sie in der Referenzdokumentation für Performance Monitoring-Benachrichtigungen.
App Distribution-Benachrichtigungsereignis verarbeiten
Das Beispiel in diesem Abschnitt zeigt, wie Sie eine Funktion für den neuen Tester iOS schreiben. Gerätebenachrichtigungen.
In diesem Beispiel wartet die Funktion auf Ereignisse, die jedes Mal gesendet werden, wenn ein Der Tester registriert ein neues iOS-Gerät. Wenn ein neues iOS-Gerät registriert wird, müssen Sie Folgendes tun: um Ihr Bereitstellungsprofil mit der UDID des Geräts zu aktualisieren. um die App weiterzuvertreiben.
Node.js
exports.postnewduuidtodiscord = onNewTesterIosDevicePublished(async (event) => {
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."""
Die Funktion analysiert dann das zurückgegebene Objekt und parst nützliche Informationen aus dem Ereignis. und eine Nachricht für die Veröffentlichung im Discord-Kanal zu erstellen:
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}
`;
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()
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(response.error);
}
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()
Informationen zu allen App Distribution-Benachrichtigungsereignissen, die erfasst werden können, finden Sie unter der Referenzdokumentation für App Distribution Benachrichtigungen.
Informationen zur Verwendung einer Funktion, die durch eine Firebase-Benachrichtigung zu In-App-Feedback von App Distribution ausgelöst wird, finden Sie unter In-App-Feedback an Jira senden.