Attivatori di avvisi Firebase

Firebase fornisce avvisi per una vasta gamma di eventi di gestione di progetti e app. Ecco alcuni esempi di eventi in cui Firebase può inviarti questo tipo di avviso:

  • Per Crashlytics, possiamo avvisarti se la tua app presenta un aumento significativo degli arresti anomali.
  • Per Performance Monitoring, possiamo avvisarti se il tempo di avvio della tua app supera la soglia configurata.
  • Per quanto riguarda App Distribution, possiamo avvisarti se uno dei tuoi tester registra un nuovo dispositivo iOS.

A seconda dell'avviso e delle preferenze impostate dal membro del progetto, Firebase mostra questi tipi di avvisi nella console Firebase o li invia via email.

Questa pagina descrive come scrivere funzioni in Cloud Functions for Firebase (2ª gen.) che gestiscono gli eventi di avviso.

Come funziona?

Puoi attivare le funzioni in risposta agli eventi di avviso emessi da queste origini:

In un ciclo di vita tipico, una funzione attivata da un evento di avviso esegue quanto segue:

  1. Ascolta/attende l'emissione di un tipo di avviso specifico da Firebase.
  2. Si attiva quando viene emesso l'avviso e riceve il payload dell'evento che contiene informazioni specifiche sull'evento.
  3. Richiama il codice della funzione per gestire il payload dell'evento.

Attivare una funzione sugli eventi di avviso

Utilizza il sottopacchetto firebase-functions/v2/alerts per scrivere una funzione che gestisce gli eventi di avviso. I seguenti esempi specifici del prodotto mostrano un flusso di lavoro in cui una funzione utilizza un webhook per pubblicare un messaggio su un canale Discord quando viene emesso un avviso per quel prodotto da Firebase.

Gestire un evento di avviso Crashlytics

Nel seguente esempio di Crashlytics, utilizzi Cloud Functions for Firebase per gestire un evento di avviso relativo a un nuovo problema di arresto anomalo irreversibile. Questa funzione pubblica le informazioni di avviso in un messaggio a un canale Discord.

Esempio di notifica di arresto anomalo in Discord

Esempio di notifica per un nuovo problema di arresto anomalo irreversibile

La funzione ascolta l'evento corrispondente alla pubblicazione di un nuovo problema irreversibile da parte di 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 funzione analizza quindi l'oggetto evento restituito, analizza le informazioni utili dal payload dell'evento e crea un messaggio da pubblicare sul canale 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

Infine, la funzione invia il messaggio creato a Discord tramite una richiesta 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

Per scoprire di più su tutti gli eventi di avviso Crashlytics che puoi acquisire, consulta la documentazione di riferimento per gli avvisi Crashlytics.

Gestire un evento di avviso Performance Monitoring

Questo esempio esporta una funzione che ascolta gli eventi di avviso della soglia di rendimento:

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 funzione analizza quindi l'oggetto evento restituito, analizzando le informazioni utili dal payload dell'evento e costruendo un messaggio da pubblicare sul canale 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

Infine, la funzione invia il messaggio creato a Discord tramite una richiesta 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

Per informazioni su tutti gli eventi di avviso sul rendimento che puoi acquisire, consulta la documentazione di riferimento per gli avvisi Performance Monitoring.

Gestire un evento di avviso App Distribution

L'esempio in questa sezione mostra come scrivere una funzione per gli avvisi relativi ai nuovi dispositivi iOS dei tester.

In questo esempio, la funzione ascolta gli eventi inviati ogni volta che un tester registra un nuovo dispositivo iOS. Quando viene registrato un nuovo dispositivo iOS, devi aggiornare il profilo di provisioning con l'UDID del dispositivo e poi ridistribuire l'app.

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 funzione analizza quindi l'oggetto restituito, estrae informazioni utili dal payload dell'evento e crea un messaggio da pubblicare sul canale 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

Infine, la funzione invia il messaggio creato a Discord tramite una richiesta 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

Per informazioni su tutti gli eventi di avviso App Distribution che puoi acquisire, consulta la documentazione di riferimento per gli avvisi App Distribution.

Per scoprire come utilizzare una funzione attivata da un avviso Firebase relativo al feedback in-app da App Distribution, consulta Inviare feedback in-app a Jira.