Simple Log Service:Import trace data from Qt to Simple Log Service by using OpenTelemetry SDK for C++

Prerequisites

• A trace instance is created. For more information, see Create a trace instance.

• A development environment in which OpenTelemetry SDK for C++ can be compiled and run is prepared.

  • If you use CMake, make sure that the CMake version is 3.1 or later.

  • If you use GCC or G++, make sure that the GCC or G++ version is 4.8 or later.

  • If you use MSVC, make sure that the MSVC version is VS2015 or later. We recommend that you use VS2019.

• The following C++ versions are supported:

  • ISO/IEC 14882:2011 (C++11, C++0x)

  • ISO/IEC 14882:2014 (C++14, C++1y)

  • ISO/IEC 14882:2017 (C++17, C++1z)

  • ISO/IEC 14882:2020 (C++20)

• The version control tool Git is installed.

• For information about dependencies and versions, see opentelemetry-cpp.

Step 1: Configure Microsoft Visual Studio

To compile OpenTelemetry SDK for C++ together with the Qt project, use MSVC as a compilation tool in Qt. To use MSVC, you must install the Qt Visual Studio Tools plug-in in Visual Studio.

1. In the top menu bar of Visual Studio, choose Extensions > Manage Extensions and search for Qt Visual Studio Tools.

2. Click Download next to Qt Visual Studio Tools.

3. After you download the plug-in, close all windows of Visual Studio.

4. In the VSIX Installer dialog box, click Modify. The plug-in is automatically installed.

5. Verify the installation result.

   Reopen the Visual Studio project. If the Qt VS Tools option is displayed in the Extensions menu, the Qt Visual Studio Tools plug-in is installed.

For more information about Qt Visual Studio Tools, see Qt Visual Studio Tools.

Step 2: Integrate the SDK

CMake is required to build and compile the opentelemetry-cpp project. You must use CMake as a compilation tool in Qt. In this example, opentelemetry-cpp 1.9.0 is used.

Step 3: Verify the import result

1. Add the following code to the Qt project and then run the project:

   #include "mainwindow.h"
   
   #include <QApplication>
   
   #include "opentelemetry/exporters/ostream/span_exporter_factory.h"
   #include "opentelemetry/exporters/otlp/otlp_http.h"
   #include "opentelemetry/exporters/otlp/otlp_http_exporter_factory.h"
   #include "opentelemetry/exporters/otlp/otlp_http_exporter_options.h"
   #include "opentelemetry/sdk/trace/simple_processor_factory.h"
   #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
   #include "opentelemetry/trace/provider.h"
   #include "opentelemetry/sdk/trace/tracer_provider.h"
   
   #include "opentelemetry/sdk/version/version.h"
   #include "opentelemetry/trace/provider.h"
   #include "opentelemetry/sdk/resource/resource.h"
   #include "opentelemetry/sdk/resource/semantic_conventions.h"
   
   #include "opentelemetry/sdk/common/global_log_handler.h"
   
   
   
   namespace trace = opentelemetry::trace;
   namespace trace_sdk = opentelemetry::sdk::trace;
   namespace otlp = opentelemetry::exporter::otlp;
   namespace trace_exporter = opentelemetry::exporter::trace;
   namespace resource = opentelemetry::sdk::resource;
   
   namespace
   {
       opentelemetry::exporter::otlp::OtlpHttpExporterOptions opts;
       void InitTracer()
       {
           opts.url = "https://<your project>.<your endpoint>/opentelemetry/v1/traces";
           opts.console_debug = true;
           opts.content_type = otlp::HttpRequestContentType::kBinary;
           // Setup credentials info
           opts.http_headers.insert(std::pair<std::string, std::string>("x-sls-otel-project", "<your project>"));
           opts.http_headers.insert(std::pair<std::string, std::string>("x-sls-otel-instance-id", "<your instanceId>"));
           opts.http_headers.insert(std::pair<std::string, std::string>("x-sls-otel-ak-id", "<your accesskey id>"));
           opts.http_headers.insert(std::pair<std::string, std::string>("x-sls-otel-ak-secret", "<your accesskey secret>"));
   
           // Create OTLP exporter instance
           auto exporter = otlp::OtlpHttpExporterFactory::Create(opts);
           auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
   
           resource::ResourceAttributes attributes = {
             {resource::SemanticConventions::kServiceName, "test"},
             {resource::SemanticConventions::kServiceNamespace, "OTelExample4QT"},
             {resource::SemanticConventions::kServiceVersion, "1.0.0"},
             {resource::SemanticConventions::kHostName, "Win64"},
             {resource::SemanticConventions::kDeploymentEnvironment, "dev"}
           };
           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));
           // Set the global trace provider
           trace::Provider::SetTracerProvider(provider); 
       }
   
       void CleanupTracer()
       {
           // We call ForceFlush to prevent to cancel running exportings, It's optional.
           opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider> provider =
               trace::Provider::GetTracerProvider();
           if (provider)
           {
               static_cast<trace_sdk::TracerProvider*>(provider.get())->ForceFlush();
           }
   
           std::shared_ptr<opentelemetry::trace::TracerProvider> none;
           trace::Provider::SetTracerProvider(none);
       }
   }  // namespace
   
   namespace trace = opentelemetry::trace;
   namespace nostd = opentelemetry::nostd;
   
   namespace
   {
       nostd::shared_ptr<trace::Tracer> get_tracer()
       {
           auto provider = trace::Provider::GetTracerProvider();
           return provider->GetTracer("foo_library", OPENTELEMETRY_SDK_VERSION);
       }
   
       void basic_f1()
       {
           auto span = get_tracer()->StartSpan("basic_f1");
           // do your stuff
           // ...
           span->End();
       }
   
       void basic_f1_with_attributes()
       {
           auto span = get_tracer()->StartSpan("basic_f1_with_attributes");
           span->SetAttribute("ags", 12);
           span->SetAttribute("sex", "man");
           span->SetAttribute("height", 154.5);
   
   
           span->AddEvent("message: success");
   
           span->SetStatus(trace::StatusCode::kError);
   
           span->End();
       }
   
       void basic_active_f1()
       {
           auto span_child = get_tracer()->StartSpan("operation B");
           // do your stuff
           // ...
           span_child->End();
       }
   
       void basic_active()
       {
           auto span = get_tracer()->StartSpan("operation A");
           auto scope = get_tracer()->WithActiveSpan(span);
   
           basic_active_f1();
   
           span->End();
       }
   
   
       void f1()
       {
           auto scoped_span = trace::Scope(get_tracer()->StartSpan("f1"));
       }
   
       void f2()
       {
           auto scoped_span = trace::Scope(get_tracer()->StartSpan("f2"));
   
           f1();
           f1();
       }
   }  // namespace
   
   void foo_library()
   {
   
       basic_f1();
       basic_active();
       basic_f1_with_attributes();
   
       auto scoped_span = trace::Scope(get_tracer()->StartSpan("library"));
   
       f2();
   
   }
   
   int main(int argc, char *argv[])
   {
       QApplication a(argc, argv);
       MainWindow w;
       w.show();
   
       InitTracer();
   
       foo_library();
   
       CleanupTracer();
   
       return a.exec();
   }
   

2. In the Log Service console, view trace data in the Trace application.

   Add the filter condition service : "test" to view the imported Qt trace data.