Si attivano gli avvisi di Firebase

Firebase fornisce avvisi per un'ampia gamma di eventi di gestione di progetti e app. Ecco alcuni eventi di esempio in cui Firebase può inviarti questo tipo di avviso:

• Per Crashlytics, possiamo avvisarti se la tua app registra un aumento drammatico degli arresti anomali.
• Per il monitoraggio delle prestazioni, possiamo avvisarti se il tempo di avvio della tua app supera la soglia configurata.
• Per la distribuzione delle app, 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 (2a generazione) che gestiscono gli eventi di avviso.

Come funziona?

È possibile attivare funzioni in risposta a eventi di avviso emessi da queste fonti:

• Gestire un evento di avviso di distribuzione app
• Gestire un evento di avviso di Crashlytics
• Gestire un evento di avviso di monitoraggio delle prestazioni

In un ciclo di vita tipico, una funzione attivata da un evento di avviso esegue le seguenti operazioni:

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 tua funzione per gestire il payload dell'evento.

Attiva una funzione sugli eventi di avviso

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

Gestire un evento di avviso di Crashlytics

Per il seguente esempio di Crashlytics, utilizzi Cloud Functions for Firebase per gestire un evento di avviso relativo a un nuovo problema di arresto anomalo fatale. Questa funzione pubblica le informazioni sull'avviso in un messaggio su un canale Discord.

La funzione ascolta l'evento corrispondente alla pubblicazione di un nuovo problema irreversibile da parte di Firebase:

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

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

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

Gestire un evento di avviso di monitoraggio delle prestazioni

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

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

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

Per informazioni su tutti gli eventi di avviso sulle prestazioni che puoi acquisire, consulta la documentazione di riferimento per gli avvisi di monitoraggio delle prestazioni .

Gestire un evento di avviso di distribuzione app

L'esempio in questa sezione mostra come scrivere una funzione per gli avvisi del nuovo dispositivo iOS del tester.

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

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

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

Per conoscere tutti gli eventi di avviso di App Distribution che puoi acquisire, vai alla documentazione di riferimento per gli avvisi di App Distribution .

Per informazioni su come utilizzare una funzione attivata da un avviso Firebase di feedback in-app da App Distribution , consulta Inviare feedback in-app a Jira .