Activadores de alertas de Firebase

Firebase proporciona alertas para una amplia gama de eventos de gestión de proyectos y aplicaciones. A continuación, se muestran algunos eventos de ejemplo en los que Firebase puede enviarle este tipo de alerta:

• Para Crashlytics, podemos alertarle si su aplicación tiene un aumento dramático en fallas.
• Para la supervisión del rendimiento, podemos alertarle si el tiempo de inicio de su aplicación supera el umbral configurado.
• Para la distribución de aplicaciones, podemos avisarle si uno de sus evaluadores registra un nuevo dispositivo iOS.

Dependiendo de la alerta y las preferencias establecidas por el miembro del proyecto , Firebase muestra este tipo de alertas en Firebase console o las envía por correo electrónico.

Esta página describe cómo escribir funciones en Cloud Functions para Firebase (segunda generación) que manejan eventos de alerta.

¿Como funciona?

Puede activar funciones en respuesta a eventos de alerta emitidos por estas fuentes:

• Manejar un evento de alerta de distribución de aplicaciones
• Manejar un evento de alerta de Crashlytics
• Manejar un evento de alerta de Monitoreo de rendimiento

En un ciclo de vida típico, una función desencadenada por un evento de alerta hace lo siguiente:

1. Escucha/espera a que se emita un tipo de alerta específico desde Firebase.
2. Se activa cuando se emite la alerta y recibe la carga útil del evento que contiene información específica sobre el evento.
3. Invoca el código de su función para manejar la carga útil del evento.

Activar una función en eventos de alerta

Utilice el subpaquete firebase-functions/v2/alerts para escribir una función que maneje eventos de alertas. Los siguientes ejemplos específicos de productos demuestran un flujo de trabajo en el que una función utiliza un webhook para publicar un mensaje en un canal de Discord cuando Firebase emite una alerta para ese producto.

Manejar un evento de alerta de Crashlytics

En el siguiente ejemplo de Crashlytics, utiliza Cloud Functions para Firebase para manejar un evento de alerta de un nuevo problema de falla fatal. Esta función publica la información de alerta en un mensaje en un canal de Discord.

La función escucha el evento correspondiente a que Firebase publique un nuevo problema 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

Luego, la función analiza el objeto de evento devuelto, analiza información útil de la carga útil del evento y construye un mensaje para publicar en el canal de 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

Finalmente, la función envía el mensaje construido a Discord a través de una solicitud 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

Para obtener información sobre todos los eventos de alerta de Crashlytics que puede capturar, consulte la documentación de referencia para alertas de Crashlytics .

Manejar un evento de alerta de Monitoreo de rendimiento

Este ejemplo exporta una función que escucha eventos de alerta de umbral de rendimiento:

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

Luego, la función analiza el objeto de evento devuelto, analiza información útil de la carga útil del evento y construye un mensaje para publicar en el canal de 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

Finalmente, la función envía el mensaje construido a Discord a través de una solicitud 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

Para obtener información sobre todos los eventos de alerta de rendimiento que puede capturar, vaya a la documentación de referencia para alertas de Monitoreo de rendimiento .

Manejar un evento de alerta de distribución de aplicaciones

El ejemplo de esta sección le muestra cómo escribir una función para alertas de nuevos dispositivos iOS de prueba.

En este ejemplo, la función escucha los eventos que se envían cada vez que un evaluador registra un nuevo dispositivo iOS. Cuando se registra un nuevo dispositivo iOS, debe actualizar su perfil de aprovisionamiento con el UDID de ese dispositivo y luego redistribuir la aplicación.

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

Luego, la función analiza el objeto devuelto, analiza información útil de la carga útil del evento y construye un mensaje para publicar en el canal de 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

Finalmente, la función envía el mensaje construido a Discord a través de una solicitud 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

Para obtener información sobre todos los eventos de alerta de distribución de aplicaciones que puede capturar, consulte la documentación de referencia para alertas de distribución de aplicaciones .

Para aprender a usar una función activada por una alerta de Firebase de comentarios en la aplicación desde App Distribution , consulte Enviar comentarios en la aplicación a Jira .