Déclencheurs d'alertes Firebase

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 ce 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 alerter si le délai de démarrage de votre application dépasse le seuil que vous avez configuré.
  • Pour App Distribution, nous pouvons vous envoyer une alerte 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 à des événements d'alerte émis par ces sources:

Dans un cycle de vie typique, une fonction déclenchée par un événement d'alerte effectue les opérations suivantes:

  1. Écoute/attend qu'un type d'alerte spécifique soit émis par Firebase.
  2. 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.
  3. Invoque 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 spécifiques aux produits suivants illustrent un workflow dans lequel une fonction utilise un webhook pour publier un message sur un canal Discord lorsqu'une alerte pour ce produit est émise depuis 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 problème de plantage fatal. Cette fonction publie les informations d'alerte dans un message envoyé à une chaîne Discord.

Exemple de notification de plantage dans Discord

Exemple de notification pour un nouveau plantage fatal

La fonction écoute l'événement correspondant à la publication d'un nouveau problème fatal par Firebase:

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

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}\`
`;
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

Enfin, la fonction envoie le message créé à 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);
}
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

Pour en savoir plus sur tous les événements d'alerte Crashlytics que vous pouvez capturer, consultez la documentation de référence sur les alertes Crashlytics.

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) => {
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

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

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);
}
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

Pour en savoir plus sur tous les événements d'alerte de performances que vous pouvez capturer, consultez la documentation de référence sur les alertes Performance Monitoring.

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'un 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) => {
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

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}
`;
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

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);
}
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

Pour en savoir plus sur tous les événements d'alerte App Distribution que vous pouvez capturer, consultez la documentation de référence sur les alertes App Distribution.

Pour savoir comment utiliser une fonction déclenchée par une alerte Firebase de commentaires intégrés à partir de App Distribution, consultez Envoyer des commentaires intégrés à Jira.