Importar logs de eventos do Firebase para o BigQuery

Neste tutorial, mostramos como exportar os logs de eventos do Google Analytics para Firebase e do Firebase Crashlytics para o Google BigQuery, a fim de fazer uma análise detalhada dos respectivos dados.

O Firebase é uma plataforma de criação de apps para dispositivos móveis que inclui recursos como armazenamento de arquivos e dados, sincronização em tempo real, autenticação e muito mais. O Google Analytics para Firebase acompanha o uso dos recursos do Firebase e fornece insights sobre o uso do app e o envolvimento do usuário. O Firebase Crashlytics registra falhas do app, dando informações sobre o tipo de problemas enfrentados pelo usuários e a frequência com que ocorrem.

O BigQuery é um armazenamento de dados em escala de petabytes usado para executar consultas semelhantes a SQL em grandes quantidades de dados, quase em tempo real.

A importação de dados do Firebase Analytics para o BigQuery traz diversas vantagens:

  • Dados agregados de várias fontes: é possível importar para o BigQuery os dados que você rastrear de vários locais como Google Analytics para Firebase, Firebase Crashlytics, Google Analytics 360 e as análises personalizadas coletadas por um serviço de back-end móvel. Com isso, você realiza análises que resultam em um panorama completo desses dados.

  • Acesso a dados brutos: ao importar os dados para o BigQuery, você acessa os valores de dados brutos, com flexibilidade na maneira de analisar eventos.

  • Controle de acesso: você passa a ser proprietário dos dados que exporta para o BigQuery. Use as ACLs do BigQuery para gerenciar permissões de projetos e conjuntos de dados, tornando possível o compartilhamento de dados sem fornecer acesso ao app do Firebase.

  • Arquivamento de dados frios: para reter dados brutos, envie os dados para o BigQuery e arquive-os no Google Cloud Storage ou em outro local que ofereça armazenamento de custo baixo e longo prazo.

  • Parâmetros de eventos personalizados: no Google Analytics, defina os parâmetros e eventos personalizados a serem rastreados. Com a importação dos seus dados para o BigQuery, será possível analisar completamente os parâmetros de eventos padrão e personalizados.

Objetivos

Neste tutorial, descrevemos como:

  • vincular um projeto do Firebase ao BigQuery. Isso permite que o Firebase Analytics e o Firebase Crashlytics exportem diariamente logs de eventos para o BigQuery;
  • consultar dados armazenados no BigQuery.

Custos

Para transmitir dados do Firebase para o BigQuery, atualize seu projeto para o nível de serviço Blaze. Para mais informações, consulte preços do Firebase.

Além disso, é cobrada uma taxa para armazenar e consultar dados no BigQuery. Para mais informações, consulte preços do BigQuery.

Antes de começar

  1. Crie um projeto do Firebase.

  2. Crie um app para enviar eventos do Firebase. Para saber como proceder, leia Primeiros passos com o Firebase Crashlytics ou Primeiros passos com o Google Analytics para Firebase em iOS ou Android.

Como vincular dados do projeto ao BigQuery

Ao vincular seu projeto do Firebase ao BigQuery, você tem acesso aos dados de eventos brutos e sem amostra.

  1. Visite a página Integrações no Console do Firebase.

  2. No cartão do BigQuery, clique em Vincular.

  3. Use os switches para determinar se você quer exportar dados do Analytics, do Crashlytics ou de ambos. Ao exportar dados do Google Analytics, também é possível incluir identificadores de divulgação, que fornecem dados mais ricos, mas aumentam os custos de armazenamento e consultas no BigQuery.

  4. Clique em Vincular ao BigQuery para concluir a tarefa.

Após a vinculação do projeto, um conjunto de dados correspondente é criado pelo BigQuery, que o associa a esse projeto. Todos os dias, uma nova tabela é adicionada ao conjunto de dados pelo projeto, para cada app vinculado. O conjunto de dados estará disponível após a primeira exportação diária dos eventos do seu projeto.

Gerenciar quais apps enviam dados ao BigQuery

Ao vincular seu projeto ao BigQuery, os eventos de todos os apps são exportados para ele por meio do Firebase. É possível alterar isso optando por apps fora da exportação diária:

  1. Visite a página Integrações no Console do Firebase.

  2. No cartão do BigQuery, clique em Gerenciar.

  3. Para que um app não envie mais os dados ao BigQuery, clique no botão ao lado do nome desse app e selecione Interromper exportação.

  1. Visite a página Integrações no Console do Firebase.

  2. No cartão do BigQuery, clique em Gerenciar.

  3. Selecione Desvincular projeto na parte inferior da página e clique em Desvincular o BigQuery para confirmar.

Consultar dados do Firebase com o BigQuery

Depois que os dados estiverem carregados no BigQuery, será possível executar consultas semelhantes a SQL usando o BigQuery. Para mais informações, veja consultar dados na documentação do BigQuery.

O BigQuery fornece uma IU da Web que simplifica a execução de consultas nos dados: basta preencher um formulário e clicar em Executar consulta. Para mais informações, consulte Guia de início rápido para usar a IU da Web na documentação do BigQuery.

Trabalhar com dados do Firebase Analytics no BigQuery

A seguir, veja exemplos de consultas executadas nos dados do Analytics. Essas consultas geram relatórios não disponíveis no painel do Google Analytics.

Como consultar um parâmetro de evento personalizado

No Google Analytics, defina valores e chaves de parâmetros personalizados em eventos. As chaves são digitadas como String e os valores são do tipo String, Long ou Double.

Nas consultas a seguir, você aprende a gerar relatórios que agregam valores de eventos personalizados para fornecer informações de negócios.

Exemplo 1:

Uma desenvolvedora de jogos para dispositivos móveis quer saber qual nível do jogo dela dispara a maior parte dos fluxos de compras no jogo. Para fazer isso, ela adiciona ao jogo a chamada de evento personalizada mostrada abaixo, que é executada quando um jogador dispara um fluxo de compras no jogo.

Neste exemplo, o nome do evento personalizado é trigger_purchase, que dispõe de uma chave level. Essa chave especifica um valor inteiro que indica o nível em que o jogador estava quando disparou uma compra.

iOS – Objective C

[FIRAnalytics logEventWithName:@"trigger_purchase"
                parameters:@{
                              @"level": 3,
}];

iOS – Swift

FIRAnalytics.logEventWithName("trigger_purchase", parameters: [
  "level": 3
])

Android – Java

Bundle params = new Bundle();
params.putInt("level", 3);
mFirebaseAnalytics.logEvent("trigger_purchase", params);

Estas são as entradas resultantes no BigQuery para este evento personalizado:

Campo Valor
event_dim.name trigger_purchase
event_dim.params.key level
event_dim.params.value.int_value 3

Para determinar o número de compras por nível, a desenvolvedora escreve uma consulta que relata a distribuição da contagem de eventos trigger_purchase, agrupados pelo nível em que o usuário está atualmente. Essa consulta é executada no intervalo de datas 01/01/2015 a 31/12/2016.

SELECT COUNT(event_dim.name) as NumberOfPurchases,
event_dim.params.value.int_value as level
FROM
TABLE_DATE_RANGE(com_game_example_ANDROID.app_events_, TIMESTAMP('2015-01-01'), TIMESTAMP('2016-12-31'))
WHERE event_dim.name = 'trigger_purchase'
GROUP BY level

Exemplo 2:

Um segundo desenvolvedor que trabalha no mesmo jogo quer determinar quais classes de personagens derrotam a maioria dos adversários. Para isso, ele adiciona ao jogo o registro de eventos personalizado mostrado abaixo quando um jogador derrota um oponente.

Neste exemplo, o nome do evento personalizado é defeat_opponent e ele dispõe de uma chave character, que especifica um valor de string que define o nome do oponente.

iOS – Objective C

[FIRAnalytics logEventWithName:@"defeat_opponent"
                parameters:@{
                              @"character": "Hercules"
}];

iOS – Swift

FIRAnalytics.logEventWithName("defeat_opponent", parameters: [
  "character": "Hercules"
])

Android – Java

Bundle params = new Bundle();
params.putString("character", "Hercules");
mFirebaseAnalytics.logEvent("defeat_opponent", params);

Estas seriam as entradas resultantes no BigQuery para este evento personalizado:

Campo Valor
event_dim.name defeat_opponent
event_dim.params.key character
event_dim.params.value.string_value Hercules

Para encontrar a classe de personagem mais bem-sucedida, ele escreve uma consulta que conta o número de vezes que uma classe de personagem está envolvida em um evento personalizado de derrota de oponente.

SELECT COUNT(event_dim.name) as DefeatEvents,
event_dim.params.value.string_value as CharacterClass
FROM
TABLE_DATE_RANGE( com_game_example_ANDROID.app_events_, TIMESTAMP('2015-01-01'), TIMESTAMP('2016-12-31'))
WHERE event_dim.name = 'defeat_opponent'
AND event_dim.params.key = 'character'
GROUP BY CharacterClass
ORDER BY DefeatEvents desc

Como consultar eventos de usuários

Além de consultar eventos personalizados, você pode gerar relatórios que agregam valores de eventos de usuários para fornecer insights de negócios.

Exemplo 3:

Um desenvolvedor de aplicativos quer usar o Firebase Cloud Messaging para enviar notificações push de reengajamento para usuários que não vêm usando o aplicativo recentemente. Para criar a lista de contatos das notificações, o desenvolvedor usa a consulta mostrada abaixo para encontrar usuários do ano anterior que não tenham visitado o aplicativo nas duas últimas semanas. Essa consulta retorna usuários tanto do iOS como do Android, bem como a data em que os usuários abriram inicialmente o aplicativo.

Na consulta abaixo, o campo user_dim.user_id contém o código do usuário configurado pelo desenvolvedor no app, chamando a API setUserId. Após configurar este valor, ele é mantido e incluído pelo Google Analytics em todas as futuras linhas associadas a esse usuário. O valor não é adicionado retroativamente em linhas anteriores.

Se o desenvolvedor não definir o identificador user_dim.user_id, poderá ser usado o campo app_info.app_instance_id, que contém o identificador padrão gerado pelo Firebase, no lugar de user_dim.user_id. Observe que o Firebase gera um novo app_info.app_instance_id sempre que o aplicativo do Firebase é desinstalado e reinstalado no mesmo dispositivo.

A tabela de dados exportada para o BigQuery do app para IOS é com_retail_example_IOS.app_events_[DATE] e a tabela de dados correspondente para Android é com_retail_example_ANDROID.app_events_[DATE], em que [DATE] é a data atual.

SELECT
  userId,
  DATE(MIN( firstOpenTime )) firstOpenTime
FROM (
  SELECT
    user_dim.user_id AS userId,
    user_dim.first_open_timestamp_micros AS firstOpenTime
  FROM (TABLE_DATE_RANGE([com_retail_example_IOS.app_events_],
    DATE_ADD(CURRENT_TIMESTAMP(), -1, 'YEAR'), CURRENT_TIMESTAMP())),
    (TABLE_DATE_RANGE([com_retail_example_ANDROID.app_events_],
    DATE_ADD(CURRENT_TIMESTAMP(), -1, 'YEAR'), CURRENT_TIMESTAMP())) )
WHERE
  userId NOT IN (
  SELECT
    user_dim.user_id AS userId
  FROM (TABLE_DATE_RANGE([com_retail_example_IOS.app_events_],
    DATE_ADD(CURRENT_TIMESTAMP(), -14, 'DAY'), CURRENT_TIMESTAMP())),
    (TABLE_DATE_RANGE([com_retail_example_ANDROID.app_events_],
    DATE_ADD(CURRENT_TIMESTAMP(), -14, 'DAY'), CURRENT_TIMESTAMP())) )
GROUP BY
  userId

Exemplo 4:

Um desenvolvedor de aplicativos quer determinar os países com os usuários mais ativos nas plataformas iOS e Android. Para fazer isso, ele usa a consulta mostrada abaixo para listar o número de usuários e eventos por país em uma determinada data.

A consulta interna retorna o user_id e o country de uma linha e, em seguida, faz uma contagem de todos os eventos dentro dessa linha. A cláusula WITHIN RECORD é utilizada pela consulta como um event_dim em um RECORD. É a melhor maneira de tratar das agregações de registros aninhados.

A consulta externa faz uso de EXACT_COUNT_DISTINCT do userId para fornecer um número exato para o total de usuários. Como alternativa, o desenvolvedor pode usar COUNT(DISTINCT user_id), mas isso dá uma estimativa em vez de um valor exato. Uma estimativa pode ser mais rápida quando há um conjunto de dados muito grande e você está procurando tendências ao longo do tempo. Nesse caso, a precisão pode ser menos importante do que a velocidade.

SELECT
  country,
  EXACT_COUNT_DISTINCT(user_id) AS users,
  SUM(noOfEvents) AS totalEvents
FROM (
  SELECT
    user_dim.app_info.app_instance_id AS user_id,
    user_dim.geo_info.country AS country,
    COUNT(event_dim.name) WITHIN RECORD noOfEvents
  FROM
    [com_retail_example_IOS.app_events_20160723],
    [com_retail_example_ANDROID.app_events_20160723]
    )
GROUP BY
  1
ORDER BY
  2 DESC

Como entender o esquema do Google Analytics no BigQuery

Quando você conecta o Google Analytics para Firebase ao BigQuery, o Firebase passa a exportar dados para o BigQuery diariamente. Isso é feito nos seguintes formatos:

Conjuntos de dados

O Google Analytics para Firebase cria um novo conjunto de dados no BigQuery para cada aplicativo do Firebase. O nome do conjunto de dados é formatado como: [app_name]_[PLATFORM], em que app_name é o código (iOS) ou o nome (Android) de pacote.

O Google Analytics converte pontos em sublinhados no código do pacote ou no nome do pacote para corresponder às convenções de nomenclatura do BigQuery. O Analytics especifica o nome da plataforma em letras maiúsculas para corresponder às convenções de nomenclatura do Firebase.

Por exemplo, o conjunto de dados correspondente a um app para iOS com um código de pacote "com.username.myapp" resultaria em um conjunto de dados chamado com_username_myapp_IOS.

Tabelas

Todos os dias uma nova tabela é criada pelo Google Analytics no conjunto de dados do BigQuery correspondente ao aplicativo. As tabelas são nomeadas seguindo o padrão app_events_YYYYMMDD e contêm os eventos registrados no dia especificado.

Linhas

Cada linha de uma tabela corresponde a um pacote de eventos. O tamanho do pacote é determinado pelo aplicativo, que envia os dados em chamadas para o SDK do Google Analytics para Firebase.

Colunas

O Google Analytics exporta eventos de usuários como colunas, o que inclui eventos de dados personalizados. Para ver a lista das colunas padrão exportadas para o BigQuery, consulte esquema do BigQuery Export na documentação de ajuda do Firebase.

Trabalhar com dados do Firebase Crashlytics no BigQuery

Nos exemplos a seguir, mostramos consultas que podem ser executadas nos dados do Crashlytics. Essas consultas geram relatórios não disponíveis no painel do Crashlytics.

Exemplos de consultas Crashlytics

Nos exemplos abaixo, veja como gerar relatórios que agregam dados de eventos com falha em resumos mais fáceis de entender.

Exemplo 1:

Após trabalhar na eliminação do maior número de bugs possível, o desenvolvedor líder da Friendly Pix acredita que estão finalmente prontos para lançar o novo app de compartilhamento de fotos. Antes disso, eles verificam o número de falhas por dia, durante o último mês, para ter certeza de que a busca de bugs tornou o app mais estável ao longo do tempo.

#standardSQL
SELECT
  COUNT(DISTINCT event_id) AS number_of_crashes,
  FORMAT_TIMESTAMP("%F", event_timestamp) AS date_of_crashes
FROM
  `projectId.crashlytics.package_name_ANDROID`
GROUP BY
  date_of_crashes
ORDER BY
  date_of_crashes DESC
LIMIT
  30;

Exemplo 2:

Para priorizar corretamente os planos de produção, um gerente de projetos da PineapplePlusPlus avalia como apontar as falhas mais abrangentes nos produtos da empresa. É feita uma consulta que para que sejam fornecidos os pontos de dados pertinentes:

#standardSQL
SELECT
  DISTINCT issue_id,
  COUNT(DISTINCT event_id) AS number_of_crashes,
  COUNT(DISTINCT installation_uuid) AS number_of_impacted_user,
  blame_frame.file,
  blame_frame.line
FROM
  `projectId.crashlytics.package_name_ANDROID`
WHERE
  event_timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(),INTERVAL 168 HOUR)
  AND event_timestamp < CURRENT_TIMESTAMP()
GROUP BY
  issue_id,
  blame_frame.file,
  blame_frame.line
ORDER BY
  number_of_crashes DESC
LIMIT
  10;

Exemplo 3:

O outono é a temporada de lançamento de novos smartphones! Um desenvolvedor da Planned Obsolescence, Inc. sabe que isso também significa uma nova temporada de problemas específicos de cada dispositivo. Para superar as preocupações de compatibilidade, eles criaram uma consulta que identifica os 10 dispositivos que apresentaram mais falhas na última semana:

#standardSQL
SELECT
  device.model,
  COUNT(DISTINCT event_id) AS number_of_crashes
FROM
  `projectId.crashlytics.package_name_ANDROID`
WHERE
  event_timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 168 HOUR)
  AND event_timestamp < CURRENT_TIMESTAMP()
GROUP BY
  device.model
ORDER BY
  number_of_crashes DESC
LIMIT
  10;

Exemplo 4:

Um desenvolvedor de jogos do Mecha Hamster 2: Hammy's Revenge quer saber em qual nível o jogo apresenta mais falhas. Para ajudá-los a rastrear essa estatística, eles configuram uma chave Crashlytics current_level personalizada e a atualizam cada vez que o usuário atinge um novo nível:

iOS – Objective C

[CrashlyticsKit setIntValue:3 forKey:@"current_level"];

iOS – Swift

Crashlytics.sharedInstance().setIntValue(3, forKey: "current_level")

Android – Java

Crashlytics.setInt("current_level", 3);

Com essa chave na respectiva exportação do BigQuery, uma consulta é gravada para relatar a distribuição dos valores de current_level associados a cada evento com falha:

#standardSQL
SELECT
  COUNT(DISTINCT event_id) AS num_of_crashes,
  value
FROM
  `projectId.crashlytics.package_name_ANDROID`,
  UNNEST(custom_keys)
WHERE
  key = "current_level"
GROUP BY
  key,
  value
ORDER BY
  num_of_crashes DESC

Exemplo 5:

Um desenvolvedor com o Software Mostly Okay tem um app no acesso antecipado. A maioria dos usuários adoram, mas alguns vivenciaram uma quantidade incomum de falhas. Para chegar ao fundo do problema, uma consulta é gravada para extrair todos os eventos com falha ocorrido com esses usuários, usando o código de usuário correspondente:

#standardSQL
SELECT
  *
FROM
  `projectId.crashlytics.package_name_ANDROID`
WHERE
  user.id IN ("userid1",
    "userid2",
    "userid3")
ORDER BY
  user.id

Noções básicas sobre o esquema do Firebase Analytics no BigQuery

Ao vincular o Crashlytics ao BigQuery, os eventos fatais e não fatais recentes com falha são exportados pelo Firebase, incluindo eventos de até dois dias antes da vinculação. Enquanto a vinculação estiver ativada, os eventos do Crashlytics serão exportados diariamente pelo Firebase. Após cada exportação, levará alguns minutos para os dados estejam disponíveis no BigQuery.

Conjuntos de dados

Um novo conjunto de dados é criado pelo Firebase Crashlytics nos dados do BigQuery para Crashlytics. O conjunto de dados abrange todo o projeto, mesmo que tenha vários apps, mas não inclui exportações do Google Analytics.

Tabelas

No Firebase Crashlytics, é criada uma tabela no conjunto de dados para cada app no seu projeto, a não ser que você opte por não exportar dados para esse app. O Firebase nomeia as tabelas com base no identificador de pacote do app, com períodos convertidos em sublinhados e um nome de plataforma anexado ao final. Por exemplo, os dados de um app com o código com.google.test estariam em uma tabela chamada com_google_test_ANDROID.

Linhas

Cada linha em uma tabela representa um erro encontrado pelo app.

Colunas

As colunas em uma tabela são idênticas para erros fatais e não fatais. Para ver uma lista de colunas exportadas para o BigQuery, consulte o Esquema de exportação do BigQuery no Crashlytics.

Visualizar dados do Crashlytics, exportados com o Data Studio

Com o Google Data Studio, você transforma os conjuntos de dados do Crashlytics no BigQuery em relatórios fáceis de ler, compartilhar, além de totalmente personalizáveis.

Para saber mais sobre como usar o Data Studio, leia o Guia de início rápido, Bem-vindo ao Data Studio.

Como usar um modelo de relatório do Crashlytics

No Data Studio, há um relatório de amostra do Crashlytics que inclui um conjunto abrangente de dimensões e métricas do esquema exportado a partir do BigQuery do Crashlytics. Use a amostra como modelo para criar rapidamente novos relatórios e visualizações com base nos dados brutos do próprio app:

  1. Abra o modelo do Painel do Data Studio do Crashlytics.
  2. Clique em Usar modelo no canto superior direito.
  3. No menu suspenso Selecionar uma origem de dados, selecione Criar nova origem de dados.
  4. Clique em Selecionar no cartão do BigQuery.
  5. Para selecionar uma tabela com os dados do Crashlytics exportados, escolha Meus projetos > [nome-do-projeto] > crashlytics > [nome-da-tabela]
  6. Em Configuração, configure o Nível do modelo Crashlytics como Padrão.
  7. Em Tabela particionada, exclua User _PARTITIONTIME como dimensão de tempo.
  8. Clique em Conectar para criar a nova origem de dados.
  9. Clique em Adicionar ao Relatório para retornar ao modelo do Crashlytics.
  10. Para concluir, clique em Criar relatório para criar sua cópia do modelo do Painel do Data Studio do Crashlytics.

Limpeza

Para evitar cobranças dos recursos usados neste tutorial na conta do Google Cloud Platform:

A maneira mais simples de parar a cobrança é excluir o projeto. Como o projeto do Firebase é igual ao projeto do Cloud Platform, você pode excluí-lo usando o console Cloud Platform ou do Firebase.

  1. No Console do GCP, acesse a página Projetos.

    Acessar a página Projetos

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir delete.
  3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

Caso você queira permanecer com seu projeto do Cloud Platform e do Firebase, desvincule o projeto do BigQuery para reduzir custos.

A seguir

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…