Qual devo usar: agente do Logging ou biblioteca de cliente?
Mantenha tudo organizado com as coleções
Salve e categorize o conteúdo com base nas suas preferências.
Este documento fornece as informações necessárias para decidir se
envia registros de aplicativo ao Cloud Logging de forma programática usando
bibliotecas de cliente ou um
agente de registro. Os agentes de registro enviam dados gravados em um arquivo, como
stdout ou um arquivo, como registros para o Cloud Logging. Serviços como o Google Kubernetes Engine, o ambiente flexível do App Engine e as funções do Cloud Run contêm um agente de registro integrado. Para o Compute Engine, é possível instalar o
Agente de operações ou o agente legado do Cloud Logging.
Esses agentes coletam registros de locais de arquivo conhecidos ou serviços de geração de registro, como Windows Event Log, journald ou syslogd.
Quando você não puder usar uma biblioteca de cliente ou um agente do Logging ou quando
apenas quiser fazer testes, use o comando
gcloud logging write
ou envie comandos HTTP para o endpoint
entries.write da API Cloud Logging.
A API Cloud Logging oferece suporte a chamadas HTTP e gRPC. O agente de operações e a maioria das bibliotecas de cliente do Logging
chamam a API gRPC Logging. O agente do Logging legado e as bibliotecas de cliente para algumas linguagens chamam a API REST Logging.
Como escolher um agente ou bibliotecas de cliente
Ao decidir entre um agente ou as bibliotecas de cliente, considere as seguintes perguntas:
Seu aplicativo está sendo executado fora do Google Cloud?
Se o aplicativo não estiver em execução em Google Cloud, será necessário
enviar registros para a API Logging. Para rotear registros de
sistemas locais para o Logging, recomendamos o uso do
Bindplane, que implanta e gerencia
coletores do OpenTelemetry para enviar telemetria a Google Cloud. Para mais
informações, consulte Sobre o Bindplane.
Como alternativa, é possível rotear os registros para o Logging diretamente do
aplicativo usando as bibliotecas de cliente. Para ambientes temporários,
como a computação sem servidor, é necessário usar bibliotecas de cliente para fazer chamadas
diretas à API Logging.
O serviço Google Cloud em execução no seu aplicativo oferece suporte
escrever conteúdo stdout e stderr para seu projeto?
Alguns Google Cloud serviços são totalmente gerenciados. Portanto, não é necessário
usar agentes para enviar registros ao projeto Google Cloud . É possível usar qualquer framework de geração de registros estabelecido na linguagem de sua escolha, como Go, Node.js e Python, para enviar registros para o Logging em produtos compatíveis com stdout e stderr por padrão. Uma vantagem de usar stdout e stderr
em vez de usar bibliotecas de cliente é que falhas no aplicativo não interrompem
o envio de registros para o projeto. Para informações sobre como enviar
registros estruturados por stdout e
stderr, consulte a seção O aplicativo tem flexibilidade para
mudar o formato do registro?.
É possível usar bibliotecas de cliente do Logging, mas lembre-se de que ela pode gerar uma dependência do Logging para testes locais, quando isso não é necessariamente necessário. O uso das bibliotecas de cliente também pode
exigir codificação mais complexa para processar explicitamente o armazenamento em buffer e as novas tentativas.
Além disso, cada uso das bibliotecas de cliente do Logging cria um novo fluxo de conexão para a API. Essas novas conexões apresentam mais
complexidade, usam portas adicionais e enviam solicitações separadas apenas com os
registros do aplicativo, o que pode ser um desperdício se não houver muitos
registros.
Os registros do aplicativo precisam estar acessíveis no seu ambiente local?
Se você precisar acessar os registros do aplicativo no ambiente local para depuração e outros fins, poderá usar os módulos de geração de registros em algumas linguagens para enviar os resultados para stdout e stderr. As bibliotecas de cliente
do Logging para algumas linguagens são compatíveis com registros de roteamento para stdout e stderr.
Ao executar seu aplicativo em serviços Google Cloud que não oferecem suporte ao envio automático de registros gravados em stdout e stderr para o projetoGoogle Cloud , é possível coletar registros stdout e stderr em arquivos no disco e configurar o agente para raspá-los e enviá-los ao Logging. Para mais informações,
consulte o guia de configuração do Agente de operações
ou do Agente do Logging legados.
O processo de instalação do agente é manual ou automático?
Alguns serviços instalam agentes automaticamente ou permitem que você mesmo os instale. Se o serviço usado não permitir a instalação de agentes,
será necessário usar as bibliotecas de cliente para usar o Logging.
Você também está coletando métricas do aplicativo para o Cloud Monitoring?
Nas VMs do Compute Engine, o agente de operações pode coletar registros e a maioria das métricas. Consulte
Recursos do agente de operações para mais informações.
Seu aplicativo tem flexibilidade para alterar o formato do registro?
Essa pergunta ajuda você a decidir se o aplicativo pode gerar
registros estruturados.
O Logging reconhece registros estruturados se você enviar os registros para a
API Logging no formato de geração de registros estruturados.
As bibliotecas de cliente fornecem os métodos para processar esse formato.
Configure o agente para reconhecer registros estruturados.
Por padrão, os agentes são configurados para detectar registros no formato JSON e processá-los como registros estruturados. Se o aplicativo tiver um formato de registro próprio que não possa ser alterado, mas você quiser que os registros sejam reconhecidos como registros estruturados, será necessário gravar os registros no formato de geração de registros estruturados, geralmente JSON, para stdout e stderr, para que os agentes possam reconhecê-los como registros estruturados. Caso contrário, você precisará configurar seu agente para entender
seu próprio formato.
Resumo de cada opção
Bibliotecas de cliente do Cloud Logging
Vantagens
É possível rotear registros diretamente para a API Cloud Logging.
Algumas linguagens podem gerar registros para stdout e stderr usando a
biblioteca.
Desvantagens
Falhas no aplicativo interrompem o envio de registros para o projeto Google Cloud .
Agente de operações
Vantagens
O Agente de operações pode enviar registros e métricas usando
tecnologias de código aberto estáveis: Fluent Bit para coleta de registros e o
OpenTelemetry Collector para coleta de métricas.
[[["Fácil de entender","easyToUnderstand","thumb-up"],["Meu problema foi resolvido","solvedMyProblem","thumb-up"],["Outro","otherUp","thumb-up"]],[["Difícil de entender","hardToUnderstand","thumb-down"],["Informações incorretas ou exemplo de código","incorrectInformationOrSampleCode","thumb-down"],["Não contém as informações/amostras de que eu preciso","missingTheInformationSamplesINeed","thumb-down"],["Problema na tradução","translationIssue","thumb-down"],["Outro","otherDown","thumb-down"]],["Última atualização 2025-09-03 UTC."],[],[],null,["# Which should you use: Logging agent or client library?\n\nThis document provides the information that you need to help you decide whether\nto programmatically send application logs to Cloud Logging by using\n[client libraries](/logging/docs/reference/libraries) or by using a\nlogging agent. Logging agents send data written to a file, such as\n`stdout` or a file, as logs to Cloud Logging. Services such as\nGoogle Kubernetes Engine, App Engine flexible environment, and Cloud Run functions, contain an integrated\nlogging agent. For Compute Engine, you can install the\n[Ops Agent or the legacy Cloud Logging agent](/logging/docs/agent).\nThese agents collect logs from known file locations or logging\nservices like the `Windows Event Log`, `journald`, or `syslogd`.\n\nWhen you can't use a client library or a Logging agent, or when\nyou only want to experiment, you can write logs by using the\n[`gcloud logging write`](/sdk/gcloud/reference/logging/write)\ncommand or by sending HTTP commands to the Cloud Logging API endpoint\n[`entries.write`](/logging/docs/reference/v2/rest/v2/entries/write).\nThe [Cloud Logging API](/logging/docs/reference/api-overview) supports both\nHTTP and gRPC calls. The Ops Agent and most Logging client\nlibraries call the gRPC Logging API. The legacy Logging\nagent and client libraries for some languages call the REST\nLogging API.\n| **Note:** There will be no new feature development or support for new operating systems for the legacy Logging agent. We recommend that you use the [Ops Agent](/logging/docs/agent/ops-agent) for new workloads and eventually transition your existing VMs to use the Ops Agent.\n\nChoosing an agent or client libraries\n-------------------------------------\n\nWhen you're deciding between an agent or the client libraries, consider\nthe following questions:\n\nIs your application running outside of Google Cloud?\n\n: If your application isn't running on Google Cloud, you need\n some way to send logs to the Logging API. To route logs from\n on-premises systems to Logging, we recommend that you use\n [Bindplane](https://bindplane.com/google), which deploys and manages\n OpenTelemetry collectors to send telemetry to Google Cloud. For more\n information, see [About Bindplane](/stackdriver/bindplane).\n\n Alternatively, you can route logs to Logging directly from\n the application by using client libraries. For ephemeral environments,\n like Serverless computing, you must use client libraries to make direct\n calls to the Logging API.\n\nDoes the Google Cloud service running your application support\nwriting `stdout` and `stderr` content to your project?\n\n: Some Google Cloud services are fully managed, so you don't need\n to use agents to send logs to your Google Cloud project. You can use any\n established logging framework in\n the language of your choice, such as Go, Node.js, and Python, to send logs to\n Logging in products where `stdout` and `stderr` are supported\n by default. An advantage to relying on `stdout` and `stderr`\n instead of using client libraries is that application crashes don't break\n sending logs to your project. For information about sending\n [structured logs](/logging/docs/structured-logging) through `stdout` and\n `stderr`, see the section, [Does your application have the flexibility to\n change the log format?](#log-format).\n\n You can use Logging client libraries, but keep in mind that\n it might introduce a dependency on Logging for local testing,\n when you don't necessarily need it. Using the client libraries might also\n require more complex coding to explicitly handle buffering and retries.\n Also, each use of the Logging client libraries creates a new\n connection stream to the API. These new connections introduce more\n complexity, use additional ports, and send separate requests with only the\n logs from the application, which could be wasteful if there aren't many\n logs.\n\nDo the application logs need to be accessible in your local environment?\n\n: If you need to access the application logs in your local environment, for\n debugging and other purposes, then you can use the logging modules in some\n languages to output to `stdout` and `stderr`. Logging client\n libraries for some languages support routing logs to `stdout` and `stderr`.\n\n When running your application in Google Cloud services that don't support\n automatically sending logs written to `stdout` and `stderr` to your\n Google Cloud project, you can collect\n `stdout` and `stderr` logs in on-disk files and configure the agent to\n scrape those and send them to Logging. For more information,\n see the configuration guide for the [Ops Agent](/logging/docs/agent/ops-agent/configuration)\n or the legacy [Logging agent](/logging/docs/agent/logging/configuration).\n\nIs the agent-installation process manual or automatic?\n\n: Some services install agents automatically or allow you to install the agents\n yourself. If the service you are using doesn't allow you to install agents,\n then you must use the client libraries to use Logging.\n\nAre you running Fluentd in your system already?\n\n: The legacy Logging agent is based on Fluentd.\n\n If you already have Fluentd running in your system, and you would like to\n use that daemon to send your logs to Logging, then use the\n [Google Cloud Logging plugin for\n fluentd](https://github.com/GoogleCloudPlatform/fluent-plugin-google-cloud).\n\nAre you collecting application metrics for Cloud Monitoring as well?\n\n: In Compute Engine VMs, the Ops Agent can collect logs and most metrics. See\n [Ops Agent features](/stackdriver/docs/solutions/agents/ops-agent#features) for more information.\n\n If the Ops Agent doesn't address your use cases, then you can use the\n [legacy Monitoring agent](/monitoring/agent/monitoring) or the\n [Monitoring client libraries](/monitoring/docs/reference/libraries)\n to collect your metrics.\n\nDoes your application have the flexibility to change the log format?\n\n: This question helps you decide if your application can generate\n [structured logs](/logging/docs/structured-logging).\n Logging recognizes structured logs if you send the logs to the\n Logging API in [the structured-logging format](/logging/docs/reference/v2/rpc/google.logging.v2#google.logging.v2.WriteLogEntriesRequest).\n Client libraries provide the methods for handling this format.\n\n There are two way of writing structured logs: one is to set [specific fields\n in the `LogEntry` envelope](/logging/docs/structured-logging#special-payload-fields),\n and the other is to set the [`jsonPayload` field within the `LogEntry`\n envelope](/logging/docs/structured-logging#use-gcloud).\n The schema for the former is determined by Cloud Logging, while the\n schema for the latter is determined by the user.\n\n You must configure the agent to recognize [structured logs](/logging/docs/structured-logging).\n By default, the agents are configured to detect logs in JSON format and to\n handle them as structured logs. If your application has its own log format\n that you can't change, but you want the logs to be recognized as structured\n logs, then you must write logs in the structured-logging format, usually\n JSON, to `stdout` and `stderr`, so that the agents can recognize them as\n structured logs. Otherwise, you must configure your agent to understand your\n own format.\n\nSummary of each option\n----------------------\n\n- Cloud Logging client libraries\n\n - Advantages\n\n - You can route logs directly to Cloud Logging API.\n - Some languages can output logs to `stdout` and `stderr` by using the library.\n - Disadvantages\n\n - Application crashes break sending logs to your Google Cloud project.\n- Ops Agent\n\n - Advantages\n\n - The Ops Agent can send logs and metrics by using stable open source technologies: Fluent Bit for log collection and the OpenTelemetry Collector for metric collection.\n - You can collect both logs and metrics from many common applications; see [Monitor and collect logs from third-party\n applications](/stackdriver/docs/solutions/agents/ops-agent/third-party).\n - You can retain logs in your local environment.\n - You might be able to recover logs from application crashes.\n - The Ops Agent is under active development.\n - Disadvantages\n\n - Fluent Bit only supports UTF-8 encoding. It doesn't support encoding conversion.\n- Legacy Logging agent\n\n - Advantages\n - The agent uses Fluentd to collect logs, which supports encoding conversion.\n - You can retain logs in your local environment.\n - You might be able to recover logs from application crashes.\n - Disadvantages\n - The agent is currently supported but is not under active development.\n- `stdout` and `stderr` logs automatically sent to your Google Cloud project\n\n - Advantages\n - This process is a common way to emit logs to local environments.\n - You can use arbitrary logging libraries.\n - You might be able to recover logs from application crashes.\n - Disadvantages\n - Not all environments automatically route logs to Logging."]]