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

Dans un cycle de vie typique, une fonction déclenchée par un événement d'alerte effectue 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. 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.

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 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).