C++ e OpenTelemetry

Esta página é destinada a desenvolvedores de aplicativos que querem coletar dados do Cloud Trace para aplicativos C++ usando o OpenTelemetry. O OpenTelemetry é um framework de instrumentação neutro em relação ao fornecedor que pode ser usado para coletar dados de rastreamento e métricas. Para informações sobre como instrumentar seu código, consulte Instrumentação e observabilidade.

Esta página mostra as etapas a seguir:

  • Instale os pacotes do OpenTelemetry.
  • Configure seu aplicativo para exportar períodos para o Cloud Trace.
  • Configure sua plataforma.

Para ver informações sobre a versão, consulte:

Para conteúdo de referência do OpenTelemetry, consulte:

Para conferir os detalhes mais recentes sobre o OpenTelemetry para C++, além de documentação e exemplos adicionais, consulte OpenTelemetry (link em inglês).

Antes de começar

Enable the Cloud Trace API.

Enable the API

Instalar os pacotes do OpenTelemetry

Configurar a exportação de períodos para o Cloud Trace

Para configurar a exportação de dados de rastreamento, chame o método google::cloud::otel::ConfigureBasicTracing(...) no método main():

namespace gc = ::google::cloud;
[](std::string project_id) {
  auto project = gc::Project(std::move(project_id));
  auto configuration = gc::otel::ConfigureBasicTracing(project);

  MyApplicationCode();
}

O campo project_id é o projeto do Google Cloud em que você quer armazenar o vestígios.

O método ConfigureBasicTracing(...) instancia um objeto TracerProvider que implementa um exportador do Cloud Trace. Se o objeto retornado pela chamada de ConfigureBasicTracing(...) sai do escopo, então o arquivo anterior O objeto TracerProvider será restabelecido, quando existir.

Configurar taxa de amostragem

Os aplicativos podem gerar um grande volume de dados de trace. O exemplo a seguir ilustra como configurar a taxa de amostragem:

namespace gc = ::google::cloud;
[](std::string project_id) {
  auto project = gc::Project(std::move(project_id));
  auto options = gc::Options{}.set<gc::otel::BasicTracingRateOption>(.001);
  auto configuration = gc::otel::ConfigureBasicTracing(project, options);

  MyApplicationCode();
}

Exportar para o Cloud Trace com um TracerProvider personalizado

Talvez você tenha casos de uso que exijam um objeto TracerProvider personalizado. Para exemplo, para usar vários exportadores ao mesmo tempo, é necessário para criar um objeto TracerProvider personalizado. Nesses casos, você pode usar o exportador do Cloud Trace diretamente:

namespace gc = ::google::cloud;
using ::opentelemetry::trace::Scope;
[](std::string project_id) {
  // Use the Cloud Trace Exporter directly.
  auto project = gc::Project(std::move(project_id));
  auto exporter = gc::otel::MakeTraceExporter(project);

  // Advanced use cases may need to create their own tracer provider, e.g. to
  // export to Cloud Trace and another backend simultaneously. In this
  // example, we just tweak some OpenTelemetry settings that google-cloud-cpp
  // does not expose.
  opentelemetry::sdk::trace::BatchSpanProcessorOptions options;
  options.schedule_delay_millis = std::chrono::milliseconds(1000);
  auto processor =
      opentelemetry::sdk::trace::BatchSpanProcessorFactory::Create(
          std::move(exporter), options);

  // Create a tracer provider and set it as the global trace provider
  opentelemetry::trace::Provider::SetTracerProvider(
      std::shared_ptr<opentelemetry::trace::TracerProvider>(
          opentelemetry::sdk::trace::TracerProviderFactory::Create(
              std::move(processor))));

  MyApplicationCode();

  // Clear the global trace provider
  opentelemetry::trace::Provider::SetTracerProvider(
      opentelemetry::nostd::shared_ptr<
          opentelemetry::trace::TracerProvider>());
}

Instrumentar o próprio aplicativo

Para ver informações sobre como configurar seu aplicativo para capturar períodos de rastreamento, consulte Rastreamento do OpenTelemetry. Esta página descreve como fazer o seguinte:

  • Criar um período
  • Criar períodos aninhados
  • Definir atributos de período
  • Criar períodos com eventos
  • Criar períodos com links
// For more details on the OpenTelemetry code in this sample, see:
//     https://opentelemetry.io/docs/instrumentation/cpp/manual/
namespace gc = ::google::cloud;
using ::opentelemetry::trace::Scope;
[](std::string project_id) {
  auto project = gc::Project(std::move(project_id));
  auto configuration = gc::otel::ConfigureBasicTracing(project);

  // Initialize the `Tracer`. This would typically be done once.
  auto provider = opentelemetry::trace::Provider::GetTracerProvider();
  auto tracer = provider->GetTracer("my-application");

  // If your application makes multiple client calls that are logically
  // connected, you may want to instrument your application.
  auto my_function = [tracer] {
    // Start an active span. The span is ended when the `Scope` object is
    // destroyed.
    auto scope = Scope(tracer->StartSpan("my-function-span"));

    // Any spans created by the client library will be children of
    // "my-function-span". i.e. In the distributed trace, the client calls are
    // sub-units of work of `my_function()`, and will be displayed as such in
    // Cloud Trace.
    Client client;
    client.CreateFoo();
    client.DeleteFoo();
  };

  // As an example, start a span to cover both calls to `my_function()`.
  auto scope = Scope(tracer->StartSpan("my-application-span"));
  my_function();
  my_function();
}

Exemplo de aplicativo

Para conferir um aplicativo de exemplo, consulte o guia de início rápido.

Configurar sua plataforma

Você pode usar o Cloud Trace no Google Cloud e em outras plataformas.

Como executar no Google Cloud

Quando seu aplicativo está em execução no Google Cloud, não é necessário fornecer credenciais de autenticação na forma de uma conta de serviço para a biblioteca de cliente. No entanto, você precisa garantir que seu Google Cloud Platform tem Escopo de acesso da API Cloud Trace ativado.

Para uma lista de ambientes do Google Cloud compatíveis, consulte Suporte ao ambiente.

Para as seguintes configurações, as definições de escopo de acesso padrão ativam a API Cloud Trace:

Se você usar escopos de acesso personalizados, verifique se o escopo de acesso da API Cloud Trace está ativado.

  • Para informações sobre como configurar os escopos de acesso para o ambiente usando o console do Google Cloud, consulte Como configurar o projeto do Google Cloud.

  • Para usuários do gcloud, especifique os escopos de acesso usando a sinalização --scopes e inclua o escopo de acesso da API Cloud Trace trace.append. Por exemplo, para criar um cluster do GKE com apenas a API Cloud Trace ativada, faça o seguinte:

    gcloud container clusters create example-cluster-name --scopes=https://www.googleapis.com/auth/trace.append

Execução local e em outro lugar

Se o aplicativo estiver em execução fora do Google Cloud, forneça as credenciais de autenticação na forma de uma conta de serviço para a biblioteca de cliente. A conta de serviço precisa conter o papel de agente do Cloud Trace. Para instruções, consulte Como criar uma conta de serviço.

As bibliotecas de cliente do Google Cloud usam o Application Default Credentials (ADC) para encontrar as credenciais do aplicativo.

É possível fornecer essas credenciais de três maneiras:

  • Executar gcloud auth application-default login

  • Coloque a conta de serviço em um caminho padrão para seu sistema operacional. Esta é a lista dos caminhos padrão para Windows e Linux:

    • Windows: %APPDATA%/gcloud/application_default_credentials.json

    • Linux: $HOME/.config/gcloud/application_default_credentials.json

  • Defina a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS para o caminho da sua conta de serviço:

Linux/macOS

    export GOOGLE_APPLICATION_CREDENTIALS=path-to-your-service-accounts-private-key

Windows

    set GOOGLE_APPLICATION_CREDENTIALS=path-to-your-service-accounts-private-key

PowerShell:

    $env:GOOGLE_APPLICATION_CREDENTIALS="path-to-your-service-accounts-private-key"

Ver traces

No console do Google Cloud, acesse a página Explorador de traces:

Acessar o Explorador de traces

Também é possível encontrar essa página usando a barra de pesquisa.

Solução de problemas

Para informações sobre como solucionar problemas com o Cloud Trace, acesse a página de solução de problemas.

Para depurar o exportador do Cloud Trace em C++, consulte a seção Solução de problemas da documentação de referência.

Recursos