Acionadores de alertas do Firebase

O Firebase fornece alertas para uma ampla variedade de eventos de gerenciamento de projetos e aplicativos. Aqui estão alguns exemplos de eventos de quando o Firebase pode enviar esse tipo de alerta:

• Para o Crashlytics, podemos alertá-lo se seu aplicativo apresentar um aumento dramático no número de falhas.
• Para monitoramento de desempenho, podemos alertá-lo se o tempo de inicialização do seu aplicativo ultrapassar o limite configurado.
• Para o App Distribution, podemos alertá-lo se um de seus testadores registrar um novo dispositivo iOS.

Dependendo do alerta e das preferências definidas pelo membro do projeto , o Firebase mostra esses tipos de alertas no console do Firebase ou os envia por e-mail.

Esta página descreve como escrever funções no Cloud Functions para Firebase (2ª geração) que processam eventos de alerta.

Como funciona?

Você pode acionar funções em resposta a eventos de alerta emitidos por estas fontes:

• Lidar com um evento de alerta do App Distribution
• Lidar com um evento de alerta do Crashlytics
• Lidar com um evento de alerta do Monitoramento de Desempenho

Num ciclo de vida típico, uma função acionada por um evento de alerta faz o seguinte:

1. Escuta/espera que um tipo de alerta específico seja emitido pelo Firebase.
2. É acionado quando o alerta é emitido e recebe a carga útil do evento que contém informações específicas sobre o evento.
3. Invoca o código da sua função para lidar com a carga do evento.

Acione uma função em eventos de alerta

Use o subpacote firebase-functions/v2/alerts para escrever uma função que processe eventos de alertas. Os exemplos específicos do produto a seguir demonstram um fluxo de trabalho em que uma função usa um webhook para postar uma mensagem em um canal do Discord quando um alerta para esse produto é emitido pelo Firebase.

Lidar com um evento de alerta do Crashlytics

No exemplo do Crashlytics a seguir, você usa o Cloud Functions for Firebase para lidar com um evento de alerta de um novo problema de falha fatal. Esta função publica as informações de alerta em uma mensagem para um canal Discord.

A função escuta o evento correspondente à publicação de um novo problema fatal pelo 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

A função então analisa o objeto de evento retornado, analisando informações úteis da carga do evento e construindo uma mensagem para postar no canal 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

Por fim, a função envia a mensagem construída para o Discord por meio de uma solicitação 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 saber mais sobre todos os eventos de alerta do Crashlytics que você pode capturar, acesse a documentação de referência para alertas do Crashlytics .

Lidar com um evento de alerta do Monitoramento de Desempenho

Este exemplo exporta uma função que escuta eventos de alerta de limite de desempenho:

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

A função então analisa o objeto de evento retornado, analisando informações úteis da carga do evento e construindo uma mensagem para postar no canal 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

Por fim, a função envia a mensagem construída para o Discord por meio de uma solicitação 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 saber mais sobre todos os eventos de alerta de desempenho que você pode capturar, acesse a documentação de referência para alertas do Monitoramento de desempenho .

Lidar com um evento de alerta do App Distribution

O exemplo nesta seção mostra como escrever uma função para alertas de novos dispositivos iOS de testador.

Neste exemplo, a função escuta eventos que são enviados sempre que um testador registra um novo dispositivo iOS. Quando um novo dispositivo iOS é registrado, você precisa atualizar seu perfil de provisionamento com o UDID desse dispositivo e redistribuir o aplicativo.

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

A função então analisa o objeto retornado, analisando informações úteis da carga do evento e construindo uma mensagem para postar no canal 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

Por fim, a função envia a mensagem construída para o Discord por meio de uma solicitação 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 saber mais sobre todos os eventos de alerta do App Distribution que você pode capturar, acesse a documentação de referência para alertas do App Distribution .

Para saber como usar uma função acionada por um alerta de feedback no aplicativo do Firebase do App Distribution , consulte Enviar feedback no aplicativo para o Jira .