Firebase fornisce avvisi per una vasta gamma di eventi di gestione di progetti e app. Ecco alcuni esempi di eventi per i quali Firebase può inviarti questo messaggio tipo di avviso:
- Per quanto riguarda Crashlytics, possiamo avvisarti se la tua app registra un aumento significativo delle in modo anomalo.
- Per quanto riguarda Performance Monitoring, possiamo avvisarti se il tempo di avvio della tua app supera i tuoi la soglia configurata.
- Per quanto riguarda App Distribution, possiamo avvisarti se uno dei tuoi tester registra un nuovo dispositivo iOS dispositivo.
A seconda dell'avviso e delle preferenze impostate dal 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?
Puoi attivare le funzioni in risposta agli eventi di avviso emessi da queste origini:
- Gestire un evento di avviso App Distribution
- Gestire un evento di avviso Crashlytics
- Gestire un evento di avviso Performance Monitoring
In un ciclo di vita tipico, una funzione attivata da un evento di avviso seguenti:
- Ascolta/attende l'emissione di un tipo di avviso specifico da Firebase.
- Si attiva quando viene emesso l'avviso e riceve il payload dell'evento che contiene informazioni specifiche sull'evento.
- 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 di 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 Crashlytics
Nell'esempio Crashlytics seguente, 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 sull'avviso in un messaggio in un canale Discord.
La funzione ascolta l'evento corrispondente alla pubblicazione di un nuovo problema irreversibile da parte di 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 funzione analizza quindi l'oggetto evento restituito, analizzare informazioni utili dal payload dell'evento e costruire un messaggio per pubblica 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}\`
`;
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()
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);
}
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()
Per scoprire di più su tutti gli eventi di avviso Crashlytics che puoi acquisire, vai a la documentazione di riferimento Crashlytics avvisi.
Gestire un evento di avviso Performance Monitoring
In questo esempio, viene esportata una funzione che rimane in ascolto degli eventi di avviso relativi alla soglia di rendimento:
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 funzione analizza quindi l'oggetto evento restituito, analizzando informazioni utili dal payload dell'evento, creando un messaggio da pubblicare su Discord canale:
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()
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);
}
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()
Per informazioni su tutti gli eventi degli avvisi sul rendimento che puoi acquisire, consulta l' documentazione di riferimento Performance Monitoring avvisi.
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 rimane in ascolto degli eventi inviati ogni volta che viene 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) => {
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 funzione analizza quindi l'oggetto restituito, analizzando informazioni utili dall'evento e creando 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}
`;
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()
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);
}
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()
Per scoprire di più su tutti gli eventi di avviso App Distribution che puoi acquisire, vai a la documentazione di riferimento App Distribution avvisi.
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.