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 votre application connaît une augmentation spectaculaire des crashs.
• Pour la surveillance des performances, nous pouvons vous alerter si l'heure de démarrage de votre application dépasse votre seuil configuré.
• Pour la distribution d'applications, 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 décrit comment écrire des fonctions dans Cloud Functions pour Firebase (2e génération) qui gèrent les événements d'alerte.

Comment ça marche?

Vous pouvez déclencher des fonctions en réponse aux événements d'alerte émis par ces sources :

• Gérer un événement d’alerte App Distribution
• Gérer un événement d'alerte Crashlytics
• Gérer un événement d’alerte de surveillance des performances

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. 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-paquet firebase-functions/v2/alerts pour écrire une fonction qui gère les événements d'alerte. Les exemples spécifiques au produit suivants illustrent un flux de travail 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

Pour l'exemple Crashlytics suivant, vous utilisez Cloud Functions pour Firebase pour gérer un événement d'alerte concernant un nouveau problème de crash fatal. Cette fonction publie les informations d'alerte dans un message sur une chaîne Discord.

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

exports.postfatalissuetodiscord = onNewFatalIssuePublished(async (event) => {
index.js

@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 événement renvoyé, analysant les informations utiles de la charge utile de l'événement et construisant un message à publier sur le canal Discord :

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

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

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

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, accédez à la documentation de référence pour les alertes Crashlytics .

Gérer un événement d’alerte de surveillance des performances

Cet exemple exporte une fonction qui écoute les événements d'alerte de seuil de performances :

exports.postperformancealerttodiscord = onThresholdAlertPublished(
    async (event) => {
index.js

@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 événement renvoyé, analysant les informations utiles de la charge utile de l'événement et construisant un message à publier sur le canal Discord :

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

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

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

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, accédez à la documentation de référence pour les alertes de surveillance des performances .

Gérer un événement d’alerte App Distribution

L'exemple de cette section vous montre comment écrire une fonction pour les alertes des nouveaux appareils iOS 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 d'approvisionnement avec l'UDID de cet appareil, puis redistribuer l'application.

exports.postnewduuidtodiscord = onNewTesterIosDevicePublished(async (event) => {
index.js

@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é, analysant les informations utiles de la charge utile de l'événement et construisant un message à publier sur le canal Discord :

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

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

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

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, accédez à la documentation de référence pour les alertes App Distribution .

Pour savoir comment utiliser une fonction déclenchée par une alerte Firebase de commentaires dans l'application provenant d'App Distribution , consultez Envoyer des commentaires dans l'application à Jira .