Gatilhos em alertas do Firebase

O Firebase conta com alertas para uma ampla variedade de eventos de gerenciamento de projetos e apps. Veja a seguir alguns exemplos de eventos em que o Firebase pode enviar esse tipo de alerta:

• Para o Crashlytics, um alerta poderá ser enviado se o app apresentar um aumento drástico de falhas.
• Para o Performance Monitoring, um alerta poderá ser enviado se o tempo de inicialização do app ultrapassar o limite configurado.
• Para o App Distribution, um alerta poderá ser enviado se um dos testadores registrar um novo dispositivo iOS.

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

Nesta página, descrevemos como criar funções no Cloud Functions for Firebase (2ª geração) que processam eventos de alerta.

Como funciona?

É possível acionar funções em resposta a eventos de alerta emitidos pelas seguintes fontes:

• Processar um evento de alerta de App Distribution
• Processar um evento de alerta de Crashlytics
• Processar um evento de alerta de Performance Monitoring

Em um ciclo de vida comum, uma função acionada por um evento de alerta faz o seguinte:

1. Detecta/aguarda a emissão de um tipo específico de alerta do Firebase.
2. É acionada quando o alerta é emitido e recebe o payload do evento contendo informações específicas.
3. Invoca o código da sua função para processar o payload do evento.

Acionar uma função em eventos de alerta

Use o subpacote firebase-functions/v2/alerts para criar uma função que processe eventos de alertas. Os seguintes exemplos específicos de produto mostram 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 a partir do Firebase.

Processar um evento de alerta de Crashlytics

No exemplo de Crashlytics abaixo, use Cloud Functions for Firebase para processar um evento de alerta de um novo problema de falha fatal. Essa função posta as informações de alerta em uma mensagem enviada em um canal do Discord.

A função detecta o evento correspondente ao Firebase publicando um novo 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

Em seguida, a função analisa o objeto de evento retornado, analisando informações úteis do payload do evento e criando uma mensagem para postar no canal do 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 criada para o Discord por 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 podem ser capturados, acesse a documentação de referência dos alertas do Crashlytics.

Processar um evento de alerta de Performance Monitoring

Este exemplo exporta uma função que detecta 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

Em seguida, a função analisa o objeto de evento retornado, analisando informações úteis do payload do evento e criando uma mensagem para postar no canal do 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 criada para o Discord por 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 dos alertas do Performance Monitoring.

Processar um evento de alerta de App Distribution

No exemplo desta seção podemos ver como criar uma função para novos alertas de dispositivo iOS de testadores.

Neste exemplo, a função detecta eventos que são enviados sempre que um testador registra um novo dispositivo iOS. Quando um novo dispositivo iOS é registrado, o perfil de provisionamento precisa ser atualizado com o UDID dele, e o app precisa ser redistribuído.

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

Em seguida, a função analisa o objeto retornado, analisando informações úteis do payload do evento e criando uma mensagem para postar no canal do 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 criada para o Discord por 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 podem ser capturados, acesse a documentação de referência dos alertas do App Distribution.

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