Como configurar o Cloud Logging para Node.js

Para aplicativos Node.js, os plug-ins são mantidos para as conhecidas bibliotecas de geração de registros Winston e Bunyan (links em inglês). O Winston é uma biblioteca de uso geral que implementa vários formatadores e transportes de registros. O Bunyan, especializado em registros JSON estruturados, é compatível com a formatação de registros por meio do encadeamento para a linha de comando Bunyan.

Também é possível usar a biblioteca de cliente do Logging para Node.js diretamente ou criar suas próprias integrações com sua biblioteca de geração de registros preferida. Por exemplo, é possível usar o framework de registro do Pino (em inglês).

Não é preciso instalar o agente do Logging para usar o Winston ou o Bunyan em uma instância de máquina virtual (VM) do Compute Engine.

Antes de começar

1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

4. Ative a Cloud Logging API.

   Ative a API

5. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

6. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

7. Ative a Cloud Logging API.

   Ative a API

8. Prepare o ambiente para o desenvolvimento do Node.js.

   Acessar o guia de configuração do Node.js

Configurar a geração de registros

Esta seção descreve como instalar e configurar os plug-ins das bibliotecas de geração de registros Winston e Bunyan (links em inglês). Para o Bunyan, há informações sobre como usá-lo com um aplicativo Node.js Express.

Você pode usar outras bibliotecas ou frameworks. Por exemplo, use o framework de registro do Pino (em inglês). Para conferir exemplos de código que usam o OpenTelemetry para coletar métricas e dados de traces e o framework de registros do Pino para coletar dados de registros, consulte Gerar traces e métricas com o Node.js. Se você usar o Pino, precisará implementar um mapeamento entre os níveis de gravidade do Pino e aqueles usados pelo Cloud Logging. Para conferir um exemplo de código, consulte Como mapear níveis de registro do Pino.

Instalar e configurar o plug-in Winston

O Cloud Logging fornece um plug-in para a biblioteca de geração de registros Node.js do Winston. O plug-in do Logging para Winston fornece uma camada mais simples e de nível superior para trabalhar com o Logging.

Para instalar e configurar o plug-in Winston, faça o seguinte:

1. Para instalar o plug-in Winston do Logging, use npm:

   npm install --save @google-cloud/logging-winston winston

2. Importe o plug-in e adicione-o à configuração do Winston:

   const winston = require('winston');
   
   // Imports the Google Cloud client library for Winston
   const {LoggingWinston} = require('@google-cloud/logging-winston');
   
   const loggingWinston = new LoggingWinston();
   
   // Create a Winston logger that streams to Cloud Logging
   // Logs will be written to: "projects/YOUR_PROJECT_ID/logs/winston_log"
   const logger = winston.createLogger({
     level: 'info',
     transports: [
       new winston.transports.Console(),
       // Add Cloud Logging
       loggingWinston,
     ],
   });
   
   // Writes some log entries
   logger.error('warp nacelles offline');
   logger.info('shields at 99%');

3. Configure o plug-in.

   É possível personalizar o comportamento do plug-in Winston usando as mesmas opções de configuração compatíveis com a biblioteca de cliente do Cloud da API Cloud Logging para Node.js. Essas opções podem ser transmitidas no objeto options transmitido para o construtor do plug-in.

Instalar e configurar o plug-in Bunyan

O Cloud Logging fornece um plug-in para a biblioteca de geração de registros Node.js do Bunyan. O plug-in do Logging para Bunyan fornece uma camada mais simples e de nível superior para trabalhar com o Logging.

Para instalar e configurar o plug-in Bunyan, faça o seguinte:

1. Para instalar o plug-in do Logging Bunyan, use npm:

   npm install --save bunyan @google-cloud/logging-bunyan

2. Importe o plug-in e adicione-o à configuração do Bunyan:

   const bunyan = require('bunyan');
   
   // Imports the Google Cloud client library for Bunyan
   const {LoggingBunyan} = require('@google-cloud/logging-bunyan');
   
   // Creates a Bunyan Cloud Logging client
   const loggingBunyan = new LoggingBunyan();
   
   // Create a Bunyan logger that streams to Cloud Logging
   // Logs will be written to: "projects/YOUR_PROJECT_ID/logs/bunyan_log"
   const logger = bunyan.createLogger({
     // The JSON payload of the log as it appears in Cloud Logging
     // will contain "name": "my-service"
     name: 'my-service',
     streams: [
       // Log to the console at 'info' and above
       {stream: process.stdout, level: 'info'},
       // And log to Cloud Logging, logging at 'info' and above
       loggingBunyan.stream('info'),
     ],
   });
   
   // Writes some log entries
   logger.error('warp nacelles offline');
   logger.info('shields at 99%');

3. Configure o plug-in.

   É possível personalizar o comportamento do plug-in Bunyan usando as mesmas opções de configuração compatíveis com a biblioteca de cliente do Cloud da API Cloud Logging para Node.js. Essas opções podem ser transmitidas no objeto options transmitido para o construtor do plug-in.

Usar o Bunyan e o Express

É possível configurar e usar o Bunyan com o Logging em um aplicativo Node.js Express.

// Imports the Google Cloud client library for Bunyan.
const lb = require('@google-cloud/logging-bunyan');

// Import express module and create an http server.
const express = require('express');

async function startServer() {
  const {logger, mw} = await lb.express.middleware({
    logName: 'samples_express',
  });
  const app = express();

  // Install the logging middleware. This ensures that a Bunyan-style `log`
  // function is available on the `request` object. This should be the very
  // first middleware you attach to your app.
  app.use(mw);

  // Setup an http route and a route handler.
  app.get('/', (req, res) => {
    // `req.log` can be used as a bunyan style log method. All logs generated
    // using `req.log` use the current request context. That is, all logs
    // corresponding to a specific request will be bundled in the Stackdriver
    // UI.
    req.log.info('this is an info log message');
    res.send('hello world');
  });

  const port = process.env.PORT || 8080;

  // `logger` can be used as a global logger, one not correlated to any specific
  // request.
  logger.info({port}, 'bonjour');

  // Start listening on the http server.
  const server = app.listen(port, () => {
    console.log(`http server listening on port ${port}`);
  });

  app.get('/shutdown', (req, res) => {
    res.sendStatus(200);
    server.close();
  });
}

startServer();

Para mais informações sobre a instalação, consulte a documentação para as bibliotecas do Cloud Logging para Node.js. Além disso, use o rastreador de problemas (em inglês) para informá-los.

Gravar registros com a biblioteca de cliente do Cloud Logging

Para informações sobre como usar a biblioteca de cliente do Cloud Logging para Node.js diretamente, consulte Bibliotecas de cliente do Cloud Logging.

Executar no Google Cloud

Para que um aplicativo grave registros usando as bibliotecas do Cloud Logging para Node.js, a conta de serviço do recurso subjacente precisa ter o papel de Gravador de registros (roles/logging.logWriter) do IAM. A maioria dos ambientes do Google Cloud configura automaticamente a conta de serviço padrão para ter esse papel.

App Engine

O Cloud Logging é ativado automaticamente para o App Engine, e a conta de serviço padrão do aplicativo tem as permissões do IAM por padrão para gravar entradas de registro.

Para gravar entradas de registro do seu app, recomendamos que você use o Bunyan ou o Winston (links em inglês), conforme descrito nesta página.

Para mais informações, consulte Como gravar e ver registros.

Google Kubernetes Engine (GKE)

O GKE concede automaticamente à conta de serviço padrão o papel do IAM de Gravador de registros (roles/logging.logWriter). Se você usar a Identidade da carga de trabalho com essa conta de serviço padrão para permitir que as cargas de trabalho acessem APIs específicas do Google Cloud, nenhuma outra configuração será necessária. No entanto, se você usar a Identidade da carga de trabalho com uma conta de serviço do IAM personalizada, verifique se essa conta tem o papel de Gravador de registros (roles/logging.logWriter).

Se necessário, também é possível usar o seguinte comando para adicionar o escopo de acesso logging.write ao criar o cluster:

gcloud container clusters create example-cluster-name \
    --scopes https://www.googleapis.com/auth/logging.write

Compute Engine

Observação: para usar as bibliotecas do Cloud Logging para Node.js em uma instância de VM do Compute Engine, não é necessário instalar o agente do Cloud Logging.

Ao usar instâncias de VM do Compute Engine, adicione o escopo de acesso cloud-platform a cada instância. Ao criar uma nova instância por meio do console do Google Cloud, faça isso na seção Identidade e acesso à API do painel Criar instância. Use a conta de serviço padrão do Compute Engine ou outra de sua escolha e selecione Permitir acesso completo a todas as APIs do Cloud na seção Identidade e acesso à API. Seja qual for a conta de serviço selecionada, verifique se ela recebeu o papel de gravador de registros na seção IAM e administrador do console do Google Cloud.

Cloud Functions

O Cloud Functions concede o papel de gravador de registros por padrão.

As bibliotecas do Cloud Logging para Node.js podem ser usadas sem a necessidade de fornecer credenciais explicitamente.

O Cloud Functions é configurado para usar o Cloud Logging automaticamente.

Observação :os registros gravados em stdout e stderr são enviados automaticamente para o Cloud Logging sem que seja necessário usar as bibliotecas do Cloud Logging para Node.js.

Execute localmente e em outro lugar

Para usar as bibliotecas do Cloud Logging para Node.js fora do Google Cloud, incluindo a execução da biblioteca na sua própria estação de trabalho, nos computadores do data center ou nas instâncias de VM de outro provedor de nuvem, forneça o ID do projeto do Google Cloud e as credenciais da conta de serviço adequadas diretamente às bibliotecas do Cloud Logging para Node.js.

Para contas de serviço atuais, faça o seguinte:

1. Conceda à conta de serviço o papel do IAM Gravador de registros (roles/logging.logWriter). Para mais informações sobre os papéis do IAM, consulte Controle de acesso.

2. Configurar o Application Default Credentials

Se você não tiver uma conta de serviço, crie uma. Para mais informações sobre esse processo, consulte Criar contas de serviço.

Para informações gerais sobre os métodos que podem ser usados para autenticação, consulte Terminologia: contas de serviço.

Como usar o Winston:

// Imports the Google Cloud client library for Winston
const {LoggingWinston} = require('@google-cloud/logging-winston');

// Creates a client
const loggingWinston = new LoggingWinston({
  projectId: 'your-project-id',
  keyFilename: '/path/to/key.json',
});

Use o Bunyan:

// Imports the Google Cloud client library for Bunyan
const {LoggingBunyan} = require('@google-cloud/logging-bunyan');

// Creates a client
const loggingBunyan = new LoggingBunyan({
  projectId: 'your-project-id',
  keyFilename: '/path/to/key.json',
});

Visualize os registros

No console do Google Cloud, acesse a página Análise de registros:

Acessar a Análise de registros

Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Geração de registros.

No Explorador de registros, é preciso especificar um ou mais recursos, mas a escolha deles pode não ser óbvia. Veja a seguir algumas dicas para ajudar você a começar:

• Se você estiver implantando seu aplicativo no App Engine ou usando as bibliotecas específicas dele, defina seu recurso como Aplicativo do GAE.

• Se você estiver implantando seu aplicativo no Compute Engine, defina o recurso como Instância de VM do GCE.

• Se você estiver implantando seu aplicativo no Google Kubernetes Engine, a configuração de geração de registros do cluster determinará o tipo de recurso das entradas de registro. Para ver uma discussão detalhada sobre as soluções de observabilidade legada do Google Cloud e do Kubernetes Monitoring do Google Cloud e como essas opções afetam o tipo de recurso, consulte Como migrar para o Kubernetes Monitoring de observabilidade do Google Cloud.

• Se o aplicativo estiver usando a API Cloud Logging diretamente, o recurso dependerá da API e da configuração. Por exemplo, no seu aplicativo, é possível especificar um recurso ou usar um recurso padrão.

• Se você não vir registros no Explorador de registros, alterne para o modo de consulta avançada e use uma consulta vazia para ver todas as entradas de registro.

  1. Se quiser alternar para o modo de consulta avançada, clique no menu (▾) na parte superior do Explorador de registros e selecione Converter para filtro avançado.
  2. Limpe o conteúdo que aparece na caixa de filtro.
  3. Clique em Enviar filtro.

  É possível examinar as entradas individuais para identificar seus recursos.

Para mais informações, acesse Como usar a Análise de registros.