Activadores de Alertas de Firebase

Firebase proporciona alertas para una amplia variedad de eventos de administración de proyectos y apps. Estos son algunos ejemplos de eventos para los que Firebase puede enviarte este tipo de alerta:

  • En Crashlytics, podemos alertarte si tu app tiene un aumento notable de fallas.
  • En Performance Monitoring, podemos alertarte si el tiempo de inicio de tu app supera el límite configurado.
  • En el caso de App Distribution, podemos alertarte si uno de tus verificadores registra un dispositivo iOS nuevo.

Según la alerta y las preferencias establecidas por el miembro del proyecto, Firebase muestra estos tipos de alertas en Firebase console o las envía por correo electrónico.

En esta página, se describe cómo escribir funciones en Cloud Functions for Firebase (2ª gen.) que controlan eventos de alerta.

¿Cómo funciona?

Puedes activar funciones en respuesta a los eventos que emiten estas fuentes:

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

  1. Detecta y espera que se emita un tipo de alerta específico de 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 tu función para controlar la carga útil del evento.

Activa una función cuando ocurran eventos de alerta

Usa el subpaquete firebase-functions/v2/alerts para escribir una función que controle los eventos de alertas. En los siguientes ejemplos específicos de productos, se muestra un flujo de trabajo en el que una función usa un webhook para publicar un mensaje en un canal de Discord cuando se emite una alerta para ese producto desde Firebase.

Controla un evento de alerta de Crashlytics

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

Ejemplo de notificación de falla en Discord

Notificación de ejemplo para un nuevo problema grave de falla

La función detecta el evento correspondiente a Firebase y publica un problema irrecuperable nuevo:

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

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

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

Para obtener información sobre todos los eventos de alerta de Crashlytics que puedes capturar, consulta la documentación de referencia sobre las alertas de Crashlytics.

Controla un evento de alerta de Performance Monitoring

En este ejemplo, se exporta una función que escucha eventos de alerta del umbral de rendimiento:

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

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

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

Para obtener información sobre todos los eventos de alertas de rendimiento que puedes capturar, consulta la documentación de referencia sobre las alertas de Performance Monitoring.

Controla un evento de alerta de App Distribution

En el ejemplo de esta sección, se muestra cómo escribir una función para alertas de dispositivos iOS nuevos de verificadores.

En este ejemplo, la función detecta eventos que se envían cada vez que un verificador registra un dispositivo iOS nuevo. Cuando se registra un dispositivo iOS nuevo, debes actualizar tu perfil de aprovisionamiento con el UDID de ese dispositivo y, luego, redistribuir la 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

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

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

Para obtener información sobre todos los eventos de alerta de App Distribution que puedes capturar, consulta la documentación de referencia sobre las alertas de App Distribution.

Para obtener información sobre cómo usar una función activada por una alerta de comentarios de Firebase en App Distribution, consulta Enviar comentarios en la app a Jira.