Firebase umożliwia tworzenie alertów dotyczących szerokiej gamy zdarzeń związanych z zarządzaniem projektami i aplikacjami. Oto kilka przykładowych zdarzeń, kiedy Firebase może wysłać taki alert:
- W przypadku Crashlytics możemy Cię ostrzec, gdy w Twojej aplikacji nastąpi gwałtowny wzrost liczby awarii.
- W przypadku monitorowania wydajności możemy Cię ostrzec, jeśli czas uruchamiania aplikacji przekroczy skonfigurowany próg.
- W przypadku Rozpowszechniania aplikacji możemy Cię ostrzec, gdy jeden z Twoich testerów zarejestruje nowe urządzenie z iOS.
W zależności od alertu i ustawień wybranych przez uczestnika projektu Firebase wyświetla te typy alertów w konsoli Firebase lub wysyła je e-mailem.
Na tej stronie dowiesz się, jak pisać w Cloud Functions dla Firebase (2 generacji) funkcje, które obsługują zdarzenia alertów.
Jak to działa?
Możesz aktywować funkcje w odpowiedzi na zdarzenia alertu generowane przez te źródła:
- Obsługiwanie zdarzenia alertu Rozpowszechnianie aplikacji
- Obsługa zdarzenia alertu Crashlytics
- Obsługa zdarzenia alertu Monitorowania wydajności
W typowym cyklu życia funkcja aktywowana przez zdarzenie alertu wykonuje te czynności:
- Nasłuchuje lub czeka na wysłanie określonego typu alertu z Firebase.
- Aktywowany po wysłaniu alertu i odbiera ładunek zdarzenia zawierający określone informacje o zdarzeniu.
- Wywołuje kod funkcji do obsługi ładunku zdarzenia.
Aktywowanie funkcji w zdarzeniach alertów
W podpakietie firebase-functions/v2/alerts
napisz funkcję, która obsługuje zdarzenia związane z alertami. Poniższe przykłady w poszczególnych usługach demonstrują przepływ pracy, w którym funkcja wykorzystuje webhooka do publikowania wiadomości na kanale Discord, gdy alert dotyczący tej usługi jest wysyłany z Firebase.
Obsługa zdarzenia alertu Crashlytics
W poniższym przykładzie Crashlytics używasz Cloud Functions dla Firebase do obsługi zdarzenia alertu dotyczącego nowego problemu krytycznej awarii. Ta funkcja publikuje informacje o alercie w wiadomości na kanał na Discordzie.
Funkcja nasłuchuje zdarzenia odpowiadającego publikowaniu przez Firebase nowego problemu krytycznego:
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."""
Następnie funkcja analizuje zwracany obiekt zdarzenia, analizuje przydatne informacje z ładunku zdarzeń i tworzy wiadomość do opublikowania w kanale 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()
Na koniec funkcja wysyła utworzoną wiadomość do Discorda za pomocą żądania 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()
Więcej informacji o wszystkich zdarzeniach alertów Crashlytics, które możesz przechwycić, znajdziesz w dokumentacji referencyjnej dotyczącej alertów Crashlytics.
Obsługa zdarzenia alertu Monitorowania wydajności
Ten przykład eksportuje funkcję, która nasłuchuje zdarzeń związanych z alertem dotyczącym progu wydajności:
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."""
Następnie funkcja analizuje zwracany obiekt zdarzenia, analizuje przydatne informacje z ładunku zdarzeń i tworzy wiadomość do opublikowania w kanale 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}
`;
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()
Na koniec funkcja wysyła utworzoną wiadomość do Discorda za pomocą żądania 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()
Więcej informacji o wszystkich zdarzeniach z alertów dotyczących wydajności, które możesz przechwytywać, znajdziesz w dokumentacji referencyjnej dotyczącej alertów monitorowania wydajności.
Obsługa zdarzenia alertu w Rozpowszechnianiu aplikacji
Przykład w tej sekcji pokazuje, jak napisać funkcję dla alertów nowych testerów na urządzeniach z iOS.
W tym przykładzie funkcja nasłuchuje zdarzeń, które są wysyłane za każdym razem, gdy tester zarejestruje nowe urządzenie z iOS. Po zarejestrowaniu nowego urządzenia z iOS musisz zaktualizować swój profil obsługi administracyjnej o identyfikator UDID tego urządzenia, a następnie ponownie rozpowszechniać aplikację.
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."""
Następnie funkcja analizuje zwrócony obiekt, analizując przydatne informacje z ładunku zdarzeń i tworzą wiadomość, która zostanie opublikowany na kanale 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()
Na koniec funkcja wysyła utworzoną wiadomość do Discorda za pomocą żądania 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()
Więcej informacji o wszystkich zdarzeniach alertów usługi Rozpowszechniania aplikacji, które możesz przechwytywać, znajdziesz w dokumentacji referencyjnej dotyczącej alertów dotyczących Rozpowszechniania aplikacji.
Aby dowiedzieć się, jak korzystać z funkcji aktywowanej przez alert Firebase o opiniach w aplikacji z App Distribution, przeczytaj artykuł Wysyłanie opinii w aplikacji do Jira.