Déclencheurs d'alertes Firebase

Firebase fournit des alertes pour de nombreux types de gestion des projets et des applications événements. Voici quelques exemples d'événements pour lesquels Firebase peut vous envoyer type d'alerte:

  • Pour Crashlytics, nous pouvons vous alerter si votre appli enregistre une augmentation spectaculaire des peut entraîner des plantages.
  • Pour Performance Monitoring, nous pouvons vous envoyer une alerte si le temps de démarrage de votre appli dépasse votre seuil configuré.
  • Pour App Distribution, nous pouvons vous envoyer une alerte si l'un de vos testeurs enregistre un nouvel appareil iOS appareil.

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, 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 suivants, spécifiques à un produit, illustrent workflow dans lequel une fonction utilise un webhook pour publier un message sur un canal Discord 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) => {
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é, analyser les informations utiles de la charge utile de l'événement et construire un message pour 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 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);
}
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 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) => {
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 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 montre comment écrire une fonction pour les nouveaux testeurs iOS. alertes relatives aux appareils.

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 : pour mettre à jour votre profil de provisionnement 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é, en analysant les informations utiles de l'événement. et en créant 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 enregistrer, accédez à la documentation de référence App Distribution alertes.

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.