C++语言接入

load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")

http_archive(
    name = "io_opentelemetry_cpp",
    sha256 = "<sha256>", # specify sha256 based on the URL specified in the urls parameter.
    strip_prefix = "opentelemetry-cpp-1.10.0",
    urls = [
        "https://github.com/open-telemetry/opentelemetry-cpp/archive/refs/tags/v1.10.0.tar.gz"
    ],
)

# Load OpenTelemetry dependencies after load.
load("@io_opentelemetry_cpp//bazel:repository.bzl", "opentelemetry_cpp_deps")

opentelemetry_cpp_deps()

# (required after v1.8.0) Load extra dependencies required for OpenTelemetry
load("@io_opentelemetry_cpp//bazel:extra_deps.bzl", "opentelemetry_extra_deps")

opentelemetry_extra_deps()

# Load gRPC dependencies after load.
load("@com_github_grpc_grpc//bazel:grpc_deps.bzl", "grpc_deps")

grpc_deps()

# Load extra gRPC dependencies due to https://github.com/grpc/grpc/issues/20511
load("@com_github_grpc_grpc//bazel:grpc_extra_deps.bzl", "grpc_extra_deps")

grpc_extra_deps()

# Copyright The OpenTelemetry Authors
# SPDX-License-Identifier: Apache-2.0

cc_binary(
    name = "example_http_server",
    srcs = [
        "server.cc",
        "server.h",
    ],
    tags = ["ostream"],
    deps = [
        "@io_opentelemetry_cpp//api",
        "@io_opentelemetry_cpp//exporters/ostream:ostream_span_exporter",
        "@io_opentelemetry_cpp//ext:headers",
        "@io_opentelemetry_cpp//sdk/src/trace",
        "@io_opentelemetry_cpp//exporters/otlp:otlp_grpc_exporter",
    ],
)

测试代码包含server.cc、server.h两个文件。

#include "server.h"
  #include "opentelemetry/trace/context.h"
  #include "opentelemetry/trace/semantic_conventions.h"

  #include "opentelemetry/exporters/ostream/span_exporter_factory.h"
  #include "opentelemetry/sdk/trace/exporter.h"
  #include "opentelemetry/sdk/trace/processor.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/provider.h"

  #include "opentelemetry/context/propagation/global_propagator.h"
  #include "opentelemetry/context/propagation/text_map_propagator.h"
  #include "opentelemetry/trace/propagation/http_trace_context.h"

  #include <cstring>
  #include <string>
  #include <unistd.h>
  #include <iostream>
  #include <vector>
  #include "opentelemetry/ext/http/client/http_client.h"
  #include "opentelemetry/nostd/shared_ptr.h"

  #include "opentelemetry/sdk/trace/tracer_provider.h"
  #include "opentelemetry/exporters/otlp/otlp_grpc_exporter_factory.h"

  #include <iostream>
  #include <thread>

  namespace trace = opentelemetry::trace;
  namespace trace_sdk = opentelemetry::sdk::trace;
  namespace otlp = opentelemetry::exporter::otlp;

  namespace {

    using namespace opentelemetry::trace;
    namespace context = opentelemetry::context;
    opentelemetry::exporter::otlp::OtlpGrpcExporterOptions opts;

    uint16_t server_port = 8800;
    constexpr const char *server_name = "localhost";

    std::string getHostName() {
        char hostname[256];
        if (gethostname(hostname, sizeof(hostname)) == 0) {
            return hostname;
        } else {
            return "default_hostname";
        }
    }

    template<typename T>
    class HttpTextMapCarrier : public opentelemetry::context::propagation::TextMapCarrier {
    public:
        HttpTextMapCarrier(T &headers) : headers_(headers) {}

        HttpTextMapCarrier() = default;

        virtual opentelemetry::nostd::string_view Get(opentelemetry::nostd::string_view key) const noexcept override {
            std::string key_to_compare = key.data();
            // Header's first letter seems to be  automatically capitaliazed by our test http-server, so
            // compare accordingly.
            if (key == opentelemetry::trace::propagation::kTraceParent) {
                key_to_compare = "Traceparent";
            } else if (key == opentelemetry::trace::propagation::kTraceState) {
                key_to_compare = "Tracestate";
            }
            auto it = headers_.find(key_to_compare);
            if (it != headers_.end()) {
                return it->second;
            }
            return "";
        }

        virtual void Set(opentelemetry::nostd::string_view key, opentelemetry::nostd::string_view value) noexcept override {
            headers_.insert(std::pair<std::string, std::string>(std::string(key), std::string(value)));
        }

        T headers_;
    };

    void InitTracer() {
        // Change this parameter based on the configuration of the access site.


      std::string endpoint = "http://**.**.**.**:***";
      std::string token = "8ecF***x";
      std::string serviceName = "应用名称.组件名称.环境名称";


      opts.endpoint = endpoint;
      opts.metadata.insert(std::pair<std::string, std::string>("authentication", token));
      // Create OTLP exporter instance
      auto exporter = otlp::OtlpGrpcExporterFactory::Create(opts);
      auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));

      opentelemetry::sdk::resource::ResourceAttributes attributes = {
          {"service.name", serviceName},
          {"host.name",    getHostName()}
      };
      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);
    }

    opentelemetry::nostd::shared_ptr <opentelemetry::trace::Tracer> get_tracer(std::string tracer_name) {
      auto provider = opentelemetry::trace::Provider::GetTracerProvider();
      return provider->GetTracer(tracer_name);
    }

    class RequestHandler : public HTTP_SERVER_NS::HttpRequestCallback {
    public:
      virtual int onHttpRequest(HTTP_SERVER_NS::HttpRequest const &request, HTTP_SERVER_NS::HttpResponse &response) override {
          StartSpanOptions options;
          options.kind = SpanKind::kServer;  // server
          std::string span_name = request.uri;

          // extract context from http header
          std::map <std::string, std::string> &request_headers =
                  const_cast<std::map <std::string, std::string> &>(request.headers);
          const HttpTextMapCarrier<std::map < std::string, std::string>>
          carrier(request_headers);
          auto prop = context::propagation::GlobalTextMapPropagator::GetGlobalPropagator();
          auto current_ctx = context::RuntimeContext::GetCurrent();
          auto new_context = prop->Extract(carrier, current_ctx);
          options.parent = GetSpan(new_context)->GetContext();

          // start span with parent context extracted from http header
          auto span = get_tracer("http-server")
                  ->StartSpan(span_name,
                  {{"server.address", server_name},
                  {"server.port",    server_port},
                  {"http.method",    request.method},
                  {"url.scheme",     "http"},
                  {"http.request.body.size",
                  static_cast<uint64_t>(request.content.length())},
                  {"client.address", request.client}},
                  options);

          auto scope = get_tracer("http_server")->WithActiveSpan(span);

          for (auto &kv : request.headers) {
              span->SetAttribute("http.header." + std::string(kv.first.data()), kv.second);
          }
          if (request.uri == "/helloworld") {
              span->AddEvent("Processing request");
              response.headers[HTTP_SERVER_NS::CONTENT_TYPE] = HTTP_SERVER_NS::CONTENT_TYPE_TEXT;
              response.body = "Welcome to the APM demo!";
              span->End();
              return 200;
          }
          span->End();
          return 404;
      }
    };
  }  // namespace

  int main(int argc, char *argv[]) {
      InitTracer();

      // The port the validation service listens to can be specified via the command line.
      if (argc > 1) {
        server_port = (uint16_t) atoi(argv[1]);
      }

      HttpServer http_server(server_name, server_port);
      RequestHandler req_handler;
      http_server.AddHandler("/helloworld", &req_handler);
      auto root_span = get_tracer("http_server")->StartSpan(__func__);
      Scope scope(root_span);
      http_server.Start();
      std::cout << "Server is running..Press ctrl-c to exit...
";
      while (1) {
        std::this_thread::sleep_for(std::chrono::seconds(100));
      }
      http_server.Stop();
      root_span->End();
      CleanupTracer();
      return 0;
  }

// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0

#pragma once

#include <atomic>
#include <string>
#include "opentelemetry/ext/http/server/http_server.h"

namespace {

    class HttpServer : public HTTP_SERVER_NS::HttpRequestCallback {

    protected:
        HTTP_SERVER_NS::HttpServer server_;
        std::string server_url_;
        uint16_t port_;
        std::atomic<bool> is_running_{false};

    public:
        HttpServer(std::string server_name = "test_server", uint16_t port = 8800) : port_(port) {
            server_.setServerName(server_name);
            server_.setKeepalive(false);
        }

        void AddHandler(std::string path, HTTP_SERVER_NS::HttpRequestCallback *request_handler) {
            server_.addHandler(path, *request_handler);
        }

        void Start() {
            if (!is_running_.exchange(true)) {
                server_.addListeningPort(port_);
                server_.start();
            }
        }

        void Stop() {
            if (is_running_.exchange(false)) {
                server_.stop();
            }
        }

        ~HttpServer() { Stop(); }
    };

}  // namespace