tracer, rgw, osd: rewrite Tracer class using opentelemetry sdk

Signed-off-by: Omri Zeneva <ozeneva@redhat.com>

diff --git a/doc/jaegertracing/index.rst b/doc/jaegertracing/index.rst
index 7261337d3738ed88ad676a3be4f1b9a4af14ea13..7dcc70cc3290086bfd96814934245c1a34ef4db3 100644 (file)
--- a/doc/jaegertracing/index.rst
+++ b/doc/jaegertracing/index.rst
@@ -25,7 +25,7 @@ BASIC ARCHITECTURE AND TERMINOLOGY
 
 read more about jaeger tracing:.
 
-  https://medium.com/opentracing/take-opentracing-for-a-hotrod-ride-f6e3141f7941
+  https://www.jaegertracing.io/docs/
 
 
 JAEGER DEPLOYMENT

diff --git a/src/common/tracer.cc b/src/common/tracer.cc
index 33894f5dea6cd2cc07762e057a7a86d2bdcb6299..ee2961ef77bbfcc47fd13ba2d89d88e67633d765 100644 (file)
--- a/src/common/tracer.cc
+++ b/src/common/tracer.cc
@@ -9,37 +9,44 @@
 
 namespace tracing {
 
-const std::shared_ptr<opentracing::Tracer> Tracer::noop_tracer = opentracing::MakeNoopTracer();
+const opentelemetry::nostd::shared_ptr<opentelemetry::trace::Tracer> Tracer::noop_tracer = opentelemetry::trace::Provider::GetTracerProvider()->GetTracer("no-op", OPENTELEMETRY_SDK_VERSION);
 
-Tracer::Tracer(opentracing::string_view service_name) {
+Tracer::Tracer(opentelemetry::nostd::string_view service_name) {
   init(service_name);
 }
 
-void Tracer::init(opentracing::string_view service_name) {
-  if (!open_tracer) {
-    using namespace jaeger_configuration;
-    const jaegertracing::Config conf(false, const_sampler, reporter_default_config, headers_config, baggage_config, service_name, std::vector<jaegertracing::Tag>());
-    open_tracer = jaegertracing::Tracer::make(conf);
+void Tracer::init(opentelemetry::nostd::string_view service_name) {
+  if (!tracer) {
+    const opentelemetry::exporter::jaeger::JaegerExporterOptions opts;
+    auto jaeger_exporter  = std::unique_ptr<opentelemetry::sdk::trace::SpanExporter>(new opentelemetry::exporter::jaeger::JaegerExporter(opts));
+    auto processor = std::unique_ptr<opentelemetry::sdk::trace::SpanProcessor>(new opentelemetry::sdk::trace::SimpleSpanProcessor(std::move(jaeger_exporter)));
+    const auto jaeger_resource = opentelemetry::sdk::resource::Resource::Create(std::move(opentelemetry::sdk::resource::ResourceAttributes{{"service.name", service_name}}));
+    const auto provider = opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider>(new opentelemetry::sdk::trace::TracerProvider(std::move(processor), jaeger_resource));
+    tracer = provider->GetTracer(service_name, OPENTELEMETRY_SDK_VERSION);
   }
 }
 
 void Tracer::shutdown() {
-  open_tracer.reset();
+  if (tracer) {
+    tracer->CloseWithMicroseconds(1);
+  }
 }
 
-jspan Tracer::start_trace(opentracing::string_view trace_name) {
+jspan Tracer::start_trace(opentelemetry::nostd::string_view trace_name) {
   if (is_enabled()) {
-    return open_tracer->StartSpan(trace_name);
+    return tracer->StartSpan(trace_name);
   }
   return noop_tracer->StartSpan(trace_name);
 }
 
-jspan Tracer::add_span(opentracing::string_view span_name, jspan& parent_span) {
-  if (is_enabled()) {
-    if (parent_span) {
-      return open_tracer->StartSpan(span_name, { opentracing::ChildOf(&parent_span->context()) });
+jspan Tracer::add_span(opentelemetry::nostd::string_view span_name, jspan& parent_span) {
+  if (is_enabled() && parent_span) {
+    const auto parent_ctx = parent_span->GetContext();
+    if (parent_ctx.IsValid()) {
+      opentelemetry::trace::StartSpanOptions span_opts;
+      span_opts.parent = parent_ctx;
+      return tracer->StartSpan(span_name, span_opts);
     }
-    return open_tracer->StartSpan(span_name);
   }
   return noop_tracer->StartSpan(span_name);
 }
@@ -47,6 +54,7 @@ jspan Tracer::add_span(opentracing::string_view span_name, jspan& parent_span) {
 bool Tracer::is_enabled() const {
   return g_ceph_context->_conf->jaeger_tracing_enable;
 }
+
 } // namespace tracing
 
 #endif // HAVE_JAEGER

diff --git a/src/common/tracer.h b/src/common/tracer.h
index 4b2885cc00b5d5b5c074972831736231b42f86e2..5e7f4e799be4c8766768fc00283d6fdadeb39183 100644 (file)
--- a/src/common/tracer.h
+++ b/src/common/tracer.h
@@ -1,55 +1,45 @@
 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
 // vim: ts=8 sw=2 smarttab
 
-#ifndef TRACER_H
-#define TRACER_H
+#pragma once
 
 #include "acconfig.h"
 
 #ifdef HAVE_JAEGER
 
-#define SIGNED_RIGHT_SHIFT_IS 1
-#define ARITHMETIC_RIGHT_SHIFT 1
-#include <jaegertracing/Tracer.h>
+#include "opentelemetry/trace/provider.h"
+#include "opentelemetry/exporters/jaeger/jaeger_exporter.h"
+#include "opentelemetry/sdk/trace/simple_processor.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
+
+using jspan = opentelemetry::nostd::shared_ptr<opentelemetry::trace::Span>;
 
-typedef std::unique_ptr<opentracing::Span> jspan;
 namespace tracing {
 
 class Tracer {
  private:
-  const static std::shared_ptr<opentracing::Tracer> noop_tracer;
-  std::shared_ptr<opentracing::Tracer> open_tracer;
+  const static opentelemetry::nostd::shared_ptr<opentelemetry::trace::Tracer> noop_tracer;
+  opentelemetry::nostd::shared_ptr<opentelemetry::trace::Tracer> tracer;
 
  public:
   Tracer() = default;
-  Tracer(opentracing::string_view service_name);
+  Tracer(opentelemetry::nostd::string_view service_name);
 
-  void init(opentracing::string_view service_name);
+  void init(opentelemetry::nostd::string_view service_name);
   void shutdown();
 
   bool is_enabled() const;
   // creates and returns a new span with `trace_name`
   // this span represents a trace, since it has no parent.
-  jspan start_trace(opentracing::string_view trace_name);
+  jspan start_trace(opentelemetry::nostd::string_view trace_name);
   // creates and returns a new span with `span_name` which parent span is `parent_span'
-  jspan add_span(opentracing::string_view span_name, jspan& parent_span);
+  jspan add_span(opentelemetry::nostd::string_view span_name, jspan& parent_span);
 
 };
 
 
 } // namespace tracing
 
-namespace jaeger_configuration {
-
-inline const jaegertracing::samplers::Config const_sampler("const", 1, "", 0, jaegertracing::samplers::Config::defaultSamplingRefreshInterval());
-
-inline const jaegertracing::reporters::Config reporter_default_config(jaegertracing::reporters::Config::kDefaultQueueSize, jaegertracing::reporters::Config::defaultBufferFlushInterval(), true, jaegertracing::reporters::Config::kDefaultLocalAgentHostPort, "");
-
-inline const jaegertracing::propagation::HeadersConfig headers_config("", "", "", "");
-
-inline const jaegertracing::baggage::RestrictionsConfig baggage_config(false, "", std::chrono::steady_clock::duration());
-
-}
 
 #else  // !HAVE_JAEGER
 
@@ -62,8 +52,8 @@ class Value {
 
 struct span_stub {
   template <typename T>
-  void SetTag(std::string_view key, const T& value) const noexcept {}
-  void Log(std::initializer_list<std::pair<std::string_view, Value>> fields) {}
+  void SetAttribute(std::string_view key, const T& value) const noexcept {}
+  void AddEvent(std::string_view, std::initializer_list<std::pair<std::string_view, Value>> fields) {}
 };
 
 class jspan {
@@ -90,5 +80,3 @@ struct Tracer {
 }
 
 #endif // !HAVE_JAEGER
-
-#endif // TRACER_H

diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc
index 3b8c4ca67d5f08e7c9b909e71b2d08fccc0bfc44..7c343137923973071f1dbbf626ea7b83da12342d 100644 (file)
--- a/src/osd/OSD.cc
+++ b/src/osd/OSD.cc
@@ -9639,7 +9639,7 @@ void OSD::enqueue_op(spg_t pg, OpRequestRef&& op, epoch_t epoch)
   op->osd_trace.keyval("cost", cost);
 
   auto enqueue_span = tracing::osd::tracer.add_span(__func__, op->osd_parent_span);
-  enqueue_span->Log({
+  enqueue_span->AddEvent(__func__, {
     {"priority", priority},
     {"cost", cost},
     {"epoch", epoch},

diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc
index 244f59f6f37c586995a353ea7afe1350d4094508..8da8726e50ed68267497ba58b2c7fbbcd8abcd3b 100644 (file)
--- a/src/rgw/rgw_op.cc
+++ b/src/rgw/rgw_op.cc
@@ -3924,7 +3924,7 @@ void RGWPutObj::execute(optional_yield y)
   rgw_placement_rule *pdest_placement = &s->dest_placement;
 
   if (multipart) {
-    s->trace->SetTag(tracing::rgw::UPLOAD_ID, multipart_upload_id);
+    s->trace->SetAttribute(tracing::rgw::UPLOAD_ID, multipart_upload_id);
     std::unique_ptr<rgw::sal::MultipartUpload> upload;
     upload = store->get_multipart_upload(s->bucket.get(), s->object->get_name(),
                                         multipart_upload_id);
@@ -6158,7 +6158,7 @@ void RGWInitMultipart::execute(optional_yield y)
   if (op_ret == 0) {
     upload_id = upload->get_upload_id();
   }
-  s->trace->SetTag(tracing::rgw::UPLOAD_ID, upload_id);
+  s->trace->SetAttribute(tracing::rgw::UPLOAD_ID, upload_id);
 
 }
 
@@ -6280,7 +6280,7 @@ void RGWCompleteMultipart::execute(optional_yield y)
 
   upload = store->get_multipart_upload(s->bucket.get(), s->object->get_name(), upload_id);
 
-  s->trace->SetTag(tracing::rgw::UPLOAD_ID, upload_id);
+  s->trace->SetAttribute(tracing::rgw::UPLOAD_ID, upload_id);
 
   RGWCompressionInfo cs_info;
   bool compressed = false;

diff --git a/src/rgw/rgw_process.cc b/src/rgw/rgw_process.cc
index 25fdaacf0cbf67758ed74d831a326459abaeef2a..80338086c750966496ad9307b1621fe75791ba1e 100644 (file)
--- a/src/rgw/rgw_process.cc
+++ b/src/rgw/rgw_process.cc
@@ -275,7 +275,6 @@ int process_request(rgw::sal::Store* const store,
   }
   req->op = op;
   ldpp_dout(op, 10) << "op=" << typeid(*op).name() << dendl;
-
   s->op_type = op->get_type();
 
   try {
@@ -309,8 +308,8 @@ int process_request(rgw::sal::Store* const store,
 
     const auto trace_name = std::string(op->name()) + " " + s->trans_id;
     s->trace = tracing::rgw::tracer.start_trace(trace_name);
-    s->trace->SetTag(tracing::rgw::OP, op->name());
-    s->trace->SetTag(tracing::rgw::TYPE, tracing::rgw::REQUEST);
+    s->trace->SetAttribute(tracing::rgw::OP, op->name());
+    s->trace->SetAttribute(tracing::rgw::TYPE, tracing::rgw::REQUEST);
 
     ret = rgw_process_authenticated(handler, op, req, s, yield);
     if (ret < 0) {
@@ -324,15 +323,15 @@ int process_request(rgw::sal::Store* const store,
 
 done:
   if (op) {
-    s->trace->SetTag(tracing::rgw::RETURN, op->get_ret());
+    s->trace->SetAttribute(tracing::rgw::RETURN, op->get_ret());
     if (s->user) {
-      s->trace->SetTag(tracing::rgw::USER_ID, s->user->get_id().id);
+      s->trace->SetAttribute(tracing::rgw::USER_ID, s->user->get_id().id);
     }
     if (s->bucket) {
-      s->trace->SetTag(tracing::rgw::BUCKET_NAME, s->bucket->get_name());
+      s->trace->SetAttribute(tracing::rgw::BUCKET_NAME, s->bucket->get_name());
     }
     if (s->object) {
-      s->trace->SetTag(tracing::rgw::OBJECT_NAME, s->object->get_name());
+      s->trace->SetAttribute(tracing::rgw::OBJECT_NAME, s->object->get_name());
     }
     std::string script;
     auto rc = rgw::lua::read_script(s, store, s->bucket_tenant, s->yield, rgw::lua::context::postRequest, script);