Firebase fournit des alertes pour un large éventail d'événements de gestion de projets et d'applications. Voici quelques exemples d'événements pour lesquels Firebase peut vous envoyer type d'alerte:
- Pour Crashlytics, nous pouvons vous alerter si le nombre de plantages de votre application augmente de manière significative.
- Pour Performance Monitoring, nous pouvons vous envoyer une alerte si le temps de démarrage de votre appli dépasse la seuil configuré.
- Pour App Distribution, nous pouvons vous alerter si l'un de vos testeurs enregistre un nouvel appareil iOS.
En fonction de l'alerte et des préférences définies par le membre du projet, Firebase affiche ces types d'alertes dans la console Firebase ou les envoie par e-mail.
Cette page explique comment écrire des fonctions dans Cloud Functions for Firebase (2e génération) qui gèrent les événements d'alerte.
Fonctionnement
Vous pouvez déclencher des fonctions en réponse aux événements d'alerte émis par les sources suivantes :
- Gérer un événement d'alerte App Distribution
- Gérer un événement d'alerte Crashlytics
- Gérer un événement d'alerte Performance Monitoring
Dans un cycle de vie typique, une fonction déclenchée par un événement d'alerte effectue suivantes:
- Écoute/attend qu'un type d'alerte spécifique soit émis par Firebase.
- Se déclenche lorsque l'alerte est émise et reçoit la charge utile de l'événement, qui contient des informations spécifiques sur l'événement.
- Appelle le code de votre fonction pour gérer la charge utile de l'événement.
Déclencher une fonction sur des événements d'alerte
Utilisez le sous-package firebase-functions/v2/alerts
pour écrire une fonction qui
gère les événements d'alerte. Les exemples suivants, spécifiques à un produit, illustrent
workflow dans lequel une fonction publie un message sur un canal Discord à l'aide d'un webhook
lorsqu'une alerte pour ce produit est émise par Firebase.
Gérer un événement d'alerte Crashlytics
Dans l'exemple Crashlytics suivant, vous utilisez Cloud Functions for Firebase pour : gérer un événement d'alerte d'un nouveau plantage fatal. Cette fonction publie les informations d'alerte dans un message envoyé à une chaîne Discord.
La fonction écoute l'événement correspondant à la publication d'un nouvel problème fatal par Firebase :
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."""
La fonction analyse ensuite l'objet d'événement renvoyé, analyse les informations utiles de la charge utile de l'événement et crée un message à publier sur le canal Discord :
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()
Enfin, la fonction envoie le message construit à Discord via une requête HTTP :
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()
Pour en savoir plus sur tous les événements d'alerte Crashlytics que vous pouvez enregistrer, accédez à la documentation de référence Crashlytics alertes.
Gérer un événement d'alerte Performance Monitoring
Cet exemple exporte une fonction qui écoute les événements d'alerte de seuil de performances:
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."""
La fonction analyse ensuite l'objet d'événement renvoyé, en analysant des informations utiles. à partir de la charge utile de l’événement et la construction d’un message à publier sur le Discord canal:
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()
Enfin, la fonction envoie le message construit à Discord via une requête HTTP :
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()
Pour en savoir plus sur tous les événements d'alerte de performances que vous pouvez enregistrer, accédez à la documentation de référence Performance Monitoring alertes.
Gérer un événement d'alerte App Distribution
L'exemple de cette section vous explique comment écrire une fonction pour les nouvelles alertes d'appareil iOS pour les testeurs.
Dans cet exemple, la fonction écoute les événements envoyés chaque fois qu'une le testeur enregistre un nouvel appareil iOS. Lorsqu'un nouvel appareil iOS est enregistré, vous devez mettre à jour votre profil de configuration avec l'UDID de cet appareil, puis redistribuer l'application.
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."""
La fonction analyse ensuite l'objet renvoyé, analyse les informations utiles de la charge utile de l'événement et crée un message à publier sur le canal Discord :
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()
Enfin, la fonction envoie le message construit à Discord via une requête HTTP :
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()
Pour en savoir plus sur tous les événements d'alerte App Distribution que vous pouvez enregistrer, accédez à la documentation de référence App Distribution alertes.
Pour apprendre à utiliser une fonction déclenchée par alerte Firebase de App Distribution en commentaires dans l'application, consultez la section Send in-app feedback to Jira (Envoyer des commentaires via l'application à Jira).