Tous les produits
Search

Ce produit

    Managed Service for OpenTelemetry:Use OpenTelemetry to report trace data of C++ applications

    Centre de documentation

    Managed Service for OpenTelemetry:Use OpenTelemetry to report trace data of C++ applications

    Dernière mise à jour :Aug 27, 2026

    Le traçage distribué vous aide à identifier les goulots d'étranglement liés à la latence et les défaillances au sein des microservices. En instrumentant votre application C++ avec le SDK OpenTelemetry C++, vous pouvez exporter les données de trace vers Managed Service for OpenTelemetry via HTTP ou gRPC. Une fois la connexion établie, la console ARMS affiche la topologie de l'application, les traces, les transactions anormales et lentes, ainsi que l'analyse SQL de votre application.

    Fonctionnement

    Le SDK OpenTelemetry C++ s'appuie sur trois composants principaux pour collecter et exporter les données de trace :

    Composant Rôle
    TracerProvider Crée et gère les traceurs. Chaque traceur génère des spans qui représentent des unités de travail.
    SpanProcessor Reçoit les spans terminées et les transmet à un exportateur. SimpleSpanProcessor exporte chaque span immédiatement et convient aux démonstrations. Pour les environnements de production, utilisez BatchSpanProcessor afin d'améliorer le débit.
    Exportateur OTLP Envoie les spans à un backend via HTTP ou gRPC. Ce guide utilise Managed Service for OpenTelemetry comme backend.

    Prérequis

    Obtenir le point de terminaison et le jeton d'authentification

    1. Connectez-vous à la console Managed Service for OpenTelemetry.

    2. Dans le volet de navigation de gauche, cliquez sur Cluster Configurations, puis sélectionnez l'onglet Access point information.

    3. Dans la barre de navigation supérieure, sélectionnez une région. Dans la section Cluster Information, activez l'option Show Token.

    4. Définissez le paramètre Client sur OpenTelemetry.

    5. Dans la colonne Related Information, copiez le point de terminaison et le jeton correspondant à votre environnement réseau. Pour gRPC, copiez également le jeton d'authentification affiché sur la même ligne.

      Déploiement Point de terminaison à utiliser
      Sur Alibaba Cloud (ECS, ACK ou autres services Alibaba Cloud) Point de terminaison VPC
      En dehors d'Alibaba Cloud ou pour le développement local Point de terminaison public

      Access point information

    Configuration requise

    Exemple de code

    L'exemple de code complet est disponible sur le dépôt alibabacloud-observability/cpp-demo.

    Préparer l'environnement

    1. (Facultatif) Démarrez un conteneur Docker avec la chaîne d'outils GCC :

         docker pull gcc                               # Debian-based image
   docker run -it --name otel-cpp-demo gcc bash

    2. Installez les dépendances système (protobuf, gRPC et outils de compilation) :

         apt-get update
   apt-get install sudo

   sudo apt-get install git cmake g++ libcurl4-openssl-dev
   # protobuf
   sudo apt-get install protobuf-compiler libprotobuf-dev
   # gRPC
   sudo apt-get install -y libgrpc++-dev libgrpc-dev protobuf-compiler-grpc

    Compiler et installer le SDK OpenTelemetry C++

    Clonez le dépôt, compilez-le avec la prise en charge de l'exportateur OTLP, puis installez-le dans /usr/local :

    git clone --recurse-submodules https://github.com/open-telemetry/opentelemetry-cpp

cd opentelemetry-cpp
mkdir build && cd build
cmake -DBUILD_TESTING=OFF -DWITH_OTLP_GRPC=ON -DWITH_OTLP_HTTP=ON ..

cmake --build . --target all

# Install to /usr/local (recommended default path)
cmake --install .

# To install to a custom path instead, uncomment the following line:
# cmake --install . --prefix /opentelemetry-cpp-lib

    Exporter les données de trace

    Choisissez un protocole de transport. HTTP et gRPC permettent tous deux d'exporter les spans vers Managed Service for OpenTelemetry. Utilisez le point de terminaison approprié indiqué dans la section Prérequis.

    Protocole Cas d'utilisation Authentification
    HTTP Configuration plus simple, fonctionne avec la plupart des proxys et pare-feu Les identifiants sont intégrés directement dans l'URL du point de terminaison
    gRPC Surcharge réduite pour les volumes élevés de données de trace Nécessite un jeton d'authentification distinct

    Exporter les données via HTTP

    1. Créez un répertoire de projet :

         mkdir otel-http-export-demo
   cd otel-http-export-demo

    2. Créez un fichier CMakeLists.txt :

         cmake_minimum_required(VERSION 3.25.1)
   project(otel-http-export-demo)

   add_executable(otel-http-export-demo http_exporter.cc)

   find_package(opentelemetry-cpp CONFIG REQUIRED)
   find_package(protobuf)
   find_package(gRPC)
   find_package(CURL)
   find_package(nlohmann_json)

   include_directories("${OPENTELEMETRY_CPP_INCLUDE_DIRS}")

   target_link_libraries(
       otel-http-export-demo
       opentelemetry_trace
       opentelemetry_common
       opentelemetry_http_client_curl
       opentelemetry_exporter_otlp_http
       opentelemetry_exporter_otlp_grpc
       opentelemetry_exporter_otlp_http_client
       opentelemetry_otlp_recordable
       opentelemetry_resources
   )

    3. Créez un fichier http_exporter.cc. Remplacez les espaces réservés suivants par vos valeurs réelles :

      Espace réservé Description Exemple
      <your-service-name> Nom identifiant votre application dans la console ARMS my-cpp-service
      <your-host-name> Nom d'hôte de la machine exécutant l'application prod-server-01 
         // Copyright The OpenTelemetry Authors
   // SPDX-License-Identifier: Apache-2.0

   #include "opentelemetry/exporters/otlp/otlp_http_exporter_factory.h"
   #include "opentelemetry/exporters/otlp/otlp_http_exporter_options.h"
   #include "opentelemetry/context/propagation/global_propagator.h"
   #include "opentelemetry/context/propagation/text_map_propagator.h"
   #include "opentelemetry/exporters/ostream/span_exporter_factory.h"
   #include "opentelemetry/nostd/shared_ptr.h"
   #include "opentelemetry/sdk/trace/simple_processor_factory.h"
   #include "opentelemetry/sdk/trace/tracer_context.h"
   #include "opentelemetry/sdk/trace/tracer_context_factory.h"
   #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
   #include "opentelemetry/trace/propagation/http_trace_context.h"
   #include "opentelemetry/trace/provider.h"
   #include "opentelemetry/ext/http/client/http_client_factory.h"
   #include "opentelemetry/sdk/resource/semantic_conventions.h"
   #include "opentelemetry/sdk/common/global_log_handler.h"

   #include <string>

   namespace trace     = opentelemetry::trace;
   namespace trace_sdk = opentelemetry::sdk::trace;
   namespace otlp      = opentelemetry::exporter::otlp;
   namespace internal_log = opentelemetry::sdk::common::internal_log;
   namespace resource = opentelemetry::sdk::resource;

   namespace nostd = opentelemetry::nostd;

   namespace
   {
       opentelemetry::exporter::otlp::OtlpHttpExporterOptions opts;
       void InitTracer()
       {
           // Create an OTLP/HTTP exporter that sends spans to the configured endpoint.
           auto exporter  = otlp::OtlpHttpExporterFactory::Create(opts);
           // SimpleSpanProcessor exports each span immediately. For production,
           // consider BatchSpanProcessor to reduce network overhead.
           auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));

           // Set resource attributes so ARMS can identify this application.
           resource::ResourceAttributes attributes = {
                   {resource::SemanticConventions::kServiceName, "<your-service-name>"},
                   {resource::SemanticConventions::kHostName, "<your-host-name>"}
           };
           auto resource = opentelemetry::sdk::resource::Resource::Create(attributes);

           std::shared_ptr<opentelemetry::trace::TracerProvider> provider =
                   trace_sdk::TracerProviderFactory::Create(std::move(processor), std::move(resource));

           // Register as the global tracer provider.
           trace::Provider::SetTracerProvider(provider);
       }

       void CleanupTracer()
       {
           std::shared_ptr<opentelemetry::trace::TracerProvider> none;
           trace::Provider::SetTracerProvider(none);
       }

       nostd::shared_ptr<trace::Tracer> get_tracer()
       {
           auto provider = trace::Provider::GetTracerProvider();
           return provider->GetTracer("library name to trace", OPENTELEMETRY_SDK_VERSION);
       }

       void f1()
       {
           auto scoped_span = trace::Scope(get_tracer()->StartSpan("f1"));
       }

       void f2()
       {
           auto scoped_span = trace::Scope(get_tracer()->StartSpan("f2"));

           f1();
           f1();
       }

       void foo_library()
       {
           auto scoped_span = trace::Scope(get_tracer()->StartSpan("library"));

           f2();
       }
   }  // namespace

   /*
     Usage:
     - example_otlp_http
     - example_otlp_http <URL>
     - example_otlp_http <URL> <DEBUG>
     - example_otlp_http <URL> <DEBUG> <BIN>
     <DEBUG> = yes|no, to turn console debug on or off
     <BIN> = bin, to export in binary format
   */
   int main(int argc, char *argv[])
   {
       if (argc > 1)
       {
           opts.url = argv[1];
           if (argc > 2)
           {
               std::string debug  = argv[2];
               opts.console_debug = debug != "" && debug != "0" && debug != "no";
           }

           if (argc > 3)
           {
               std::string binary_mode = argv[3];
               if (binary_mode.size() >= 3 && binary_mode.substr(0, 3) == "bin")
               {
                   opts.content_type = otlp::HttpRequestContentType::kBinary;
               }
           }
       }

       if (opts.console_debug)
       {
           internal_log::GlobalLogHandler::SetLogLevel(internal_log::LogLevel::Debug);
       }

       InitTracer();

       foo_library();

       CleanupTracer();
   }

    4. Compilez le projet :

         mkdir build && cd build && cmake .. && make

    5. Exécutez la démonstration. Transmettez le point de terminaison HTTP indiqué dans la section Prérequis en tant que premier argument. Par exemple, pour activer la journalisation de débogage et confirmer l'exportation des spans, passez yes en deuxième argument. Si le programme se termine sans erreur, les spans ont été exportées. Consultez la section Vérifier les données de trace pour confirmer leur apparition dans la console.

         ./otel-http-export-demo <http-endpoint>
         ./otel-http-export-demo http://tracing-analysis-dc-hz.aliyuncs.com/adapt_xxxxx_xxxxx/api/otlp/traces
         ./otel-http-export-demo <http-endpoint> yes

    Exporter les données via gRPC

    1. Créez un répertoire de projet :

         mkdir otel-grpc-export-demo
   cd otel-grpc-export-demo

    2. Créez un fichier CMakeLists.txt :

         cmake_minimum_required(VERSION 3.25.1)
   project(otel-grpc-export-demo)

   add_executable(otel-grpc-export-demo grpc_exporter.cc)

   find_package(opentelemetry-cpp CONFIG REQUIRED)
   find_package(protobuf)
   find_package(gRPC)
   find_package(CURL)
   find_package(nlohmann_json)

   include_directories("${OPENTELEMETRY_CPP_INCLUDE_DIRS}")

   target_link_libraries(
       otel-grpc-export-demo ${OPENTELEMETRY_CPP_LIBRARIES}
       opentelemetry_trace
       opentelemetry_common
       opentelemetry_http_client_curl
       opentelemetry_exporter_otlp_http
       opentelemetry_exporter_otlp_grpc
       opentelemetry_exporter_otlp_http_client
       opentelemetry_otlp_recordable
       opentelemetry_resources
   )

    3. Créez un fichier grpc_exporter.cc. Remplacez les espaces réservés suivants par vos valeurs réelles :

      Espace réservé Description Exemple
      <your-service-name> Nom identifiant votre application dans la console ARMS my-cpp-service
      <your-host-name> Nom d'hôte de la machine exécutant l'application prod-server-01 
         // Copyright The OpenTelemetry Authors
   // SPDX-License-Identifier: Apache-2.0

   #include "opentelemetry/exporters/otlp/otlp_grpc_exporter_factory.h"
   #include "opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h"
   #include "opentelemetry/context/propagation/global_propagator.h"
   #include "opentelemetry/context/propagation/text_map_propagator.h"
   #include "opentelemetry/exporters/ostream/span_exporter_factory.h"
   #include "opentelemetry/nostd/shared_ptr.h"
   #include "opentelemetry/sdk/trace/simple_processor_factory.h"
   #include "opentelemetry/sdk/trace/tracer_context.h"
   #include "opentelemetry/sdk/trace/tracer_context_factory.h"
   #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
   #include "opentelemetry/trace/propagation/http_trace_context.h"
   #include "opentelemetry/trace/provider.h"
   #include "opentelemetry/ext/http/client/http_client_factory.h"
   #include "opentelemetry/sdk/resource/semantic_conventions.h"
   #include "opentelemetry/sdk/common/global_log_handler.h"

   #include <string>

   namespace trace     = opentelemetry::trace;
   namespace trace_sdk = opentelemetry::sdk::trace;
   namespace otlp      = opentelemetry::exporter::otlp;
   namespace internal_log = opentelemetry::sdk::common::internal_log;
   namespace resource = opentelemetry::sdk::resource;

   namespace nostd = opentelemetry::nostd;

   namespace
   {
       opentelemetry::exporter::otlp::OtlpGrpcExporterOptions opts;
       void InitTracer()
       {
           // Create an OTLP/gRPC exporter that sends spans to the configured endpoint.
           auto exporter  = otlp::OtlpGrpcExporterFactory::Create(opts);
           // SimpleSpanProcessor exports each span immediately. For production,
           // consider BatchSpanProcessor to reduce network overhead.
           auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));

           // Set resource attributes so ARMS can identify this application.
           resource::ResourceAttributes attributes = {
                   {resource::SemanticConventions::kServiceName, "<your-service-name>"},
                   {resource::SemanticConventions::kHostName, "<your-host-name>"}
           };
           auto resource = opentelemetry::sdk::resource::Resource::Create(attributes);

           std::shared_ptr<opentelemetry::trace::TracerProvider> provider =
                   trace_sdk::TracerProviderFactory::Create(std::move(processor), std::move(resource));

           // Register as the global tracer provider.
           trace::Provider::SetTracerProvider(provider);
       }

       void CleanupTracer()
       {
           std::shared_ptr<opentelemetry::trace::TracerProvider> none;
           trace::Provider::SetTracerProvider(none);
       }

       nostd::shared_ptr<trace::Tracer> get_tracer()
       {
           auto provider = trace::Provider::GetTracerProvider();
           return provider->GetTracer("library name to trace", OPENTELEMETRY_SDK_VERSION);
       }

       void f1()
       {
           auto scoped_span = trace::Scope(get_tracer()->StartSpan("f1"));
       }

       void f2()
       {
           auto scoped_span = trace::Scope(get_tracer()->StartSpan("f2"));

           f1();
           f1();
       }

       void foo_library()
       {
           auto scoped_span = trace::Scope(get_tracer()->StartSpan("library"));

           f2();
       }
   }  // namespace

   /*
     Usage:
     - example_otlp_grpc
     - example_otlp_grpc <URL> <TOKEN>
   */
   int main(int argc, char *argv[])
   {
       if (argc > 1)
       {
           opts.endpoint = argv[1];
           if (argc > 2)
           {
               opts.metadata.insert(std::pair<std::string, std::string>("authentication",argv[2]));
           }

           if (argc > 3)
           {
               opts.use_ssl_credentials         = true;
               opts.ssl_credentials_cacert_path = argv[3];
           }
       }

       InitTracer();

       foo_library();

       CleanupTracer();
   }

    4. Compilez le projet :

         mkdir build && cd build && cmake .. && make

    5. Exécutez la démonstration. Transmettez le point de terminaison gRPC et le jeton d'authentification indiqués dans la section Prérequis. Par exemple : Si le programme se termine sans erreur, les spans ont été exportées. Consultez la section Vérifier les données de trace pour confirmer leur apparition dans la console.

         ./otel-grpc-export-demo <gRPC-endpoint> <token>
         ./otel-grpc-export-demo http://tracing-analysis-dc-hz.aliyuncs.com:8090 xxxxx_xxxxxx

    Dépannage

    Bibliothèque partagée introuvable

    Si vous rencontrez l'erreur suivante lors de l'exécution de la démonstration :

    ./otel-grpc-export-demo: error while loading shared libraries: libopentelemetry_proto_grpc.so: cannot open shared object file: No such file or directory

    Ajoutez le chemin d'installation du SDK OpenTelemetry C++ au chemin de recherche des bibliothèques :

    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib/

    /usr/local/lib correspond au chemin d'installation par défaut. Si vous avez installé le SDK dans un chemin personnalisé, adaptez-le en conséquence.

    Vérifier les données de trace

    1. Connectez-vous à la console ARMS.

    2. Dans le volet de navigation de gauche, choisissez Application Monitoring > Applications.

    3. Recherchez le nom de votre application dans la liste et cliquez dessus pour afficher les données de trace, y compris la topologie, les traces individuelles et les métriques de performance.

    L'icône de la colonne Language indique la source des données. L'icône language icon signifie que l'application est connectée à Application Monitoring. Un trait d'union ( - ) indique qu'elle est connectée à Managed Service for OpenTelemetry.

    Recommandations pour la production

    Le code de démonstration présenté dans ce guide utilise SimpleSpanProcessor, qui exporte chaque span de manière synchrone et bloque le thread appelant. Pour les charges de travail de production :

    • Basculez vers BatchSpanProcessor pour mettre en mémoire tampon et exporter les spans par lots, réduisant ainsi la surcharge réseau et l'impact sur la latence de votre application.

    • Définissez des attributs de ressource significatifs (service.name, host.name, service.version) afin de pouvoir filtrer et regrouper les traces dans la console ARMS.

    • Pour l'exportateur gRPC, envisagez d'activer SSL (opts.use_ssl_credentials = true) lors de l'envoi des données de trace via Internet public.

    Références