Add InstrumentationLibrary to Tracer

CHANGELOG.md

@@ -15,6 +15,7 @@ Increment the:
 
 ## [Unreleased]
 
+* [SDK] Add instrumentation library and multiple tracer support ([#693](https://github.com/open-telemetry/opentelemetry-cpp/pull/693))
 * [API] Move class from opentelemetry::core namespace to opentelemetry::common namespace ([#686](https://github.com/open-telemetry/opentelemetry-cpp/pull/686))
 
 ## [0.4.0] 2021-04-12

api/include/opentelemetry/trace/tracer.h

@@ -14,6 +14,7 @@
 OPENTELEMETRY_BEGIN_NAMESPACE
 namespace trace
 {
+
 /**
  * Handles span creation and in-process context propagation.
  *

sdk/include/opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h

@@ -0,0 +1,85 @@
+// Copyright 2021, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/nostd/unique_ptr.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+
+namespace sdk
+{
+namespace instrumentationlibrary
+{
+
+class InstrumentationLibrary
+{
+public:
+ InstrumentationLibrary(const InstrumentationLibrary &) = default;
+
+ /**
+ * Returns a newly created InstrumentationLibrary with the specified library name and version.
+ * @param name name of the instrumentation library.
+ * @param version version of the instrumentation library.
+ * @returns the newly created InstrumentationLibrary.
+ */
+ static nostd::unique_ptr<InstrumentationLibrary> create(nostd::string_view name,
+ nostd::string_view version = "")
+ {
+ return nostd::unique_ptr<InstrumentationLibrary>(
+ new InstrumentationLibrary{std::string{name}, std::string{version}});
+ }
+
+ /**
+ * Compare 2 instrumentation libraries.
+ * @param other the instrumentation library to compare to.
+ * @returns true if the 2 instrumentation libraries are equal, false otherwise.
+ */
+ bool operator==(const InstrumentationLibrary &other) const
+ {
+ return equal(other.name_, other.version_);
+ }
+
+ /**
+ * Check whether the instrumentation library has given name and version.
+ * This could be used to check version equality and avoid heap allocation.
+ * @param name name of the instrumentation library to compare.
+ * @param version version of the instrumentatoin library to compare.
+ * @returns true if name and version in this instrumentation library are equal with the given name
+ * and version.
+ */
+ bool equal(const nostd::string_view name, const nostd::string_view version) const
+ {
+ return this->name_ == name && this->version_ == version;
+ }
+
+ const std::string &GetName() const { return name_; }
+ const std::string &GetVersion() const { return version_; }
+
+private:
+ InstrumentationLibrary(nostd::string_view name, nostd::string_view version)
+ : name_(name), version_(version)
+ {}
+
+private:
+ std::string name_;
+ std::string version_;
+};
+
+} // namespace instrumentationlibrary
+} // namespace sdk
+
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/trace/tracer.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "opentelemetry/sdk/common/atomic_shared_ptr.h"
+#include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h"
 #include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/sdk/trace/processor.h"
 #include "opentelemetry/sdk/trace/samplers/always_on.h"
@@ -16,11 +17,16 @@ namespace sdk
 {
 namespace trace
 {
+
+using namespace opentelemetry::sdk::instrumentationlibrary;
+
 class Tracer final : public trace_api::Tracer, public std::enable_shared_from_this<Tracer>
 {
 public:
  /** Construct a new Tracer with the given context pipeline. */
- explicit Tracer(std::shared_ptr<sdk::trace::TracerContext> context) noexcept;
+ explicit Tracer(std::shared_ptr<sdk::trace::TracerContext> context,
+ std::unique_ptr<InstrumentationLibrary> instrumentation_library =
+ InstrumentationLibrary::create("")) noexcept;
 
  nostd::shared_ptr<trace_api::Span> StartSpan(
  nostd::string_view name,
@@ -33,16 +39,23 @@ class Tracer final : public trace_api::Tracer, public std::enable_shared_from_th
  void CloseWithMicroseconds(uint64_t timeout) noexcept override;
 
  /** Returns the currently active span processor. */
- SpanProcessor &GetActiveProcessor() noexcept { return context_->GetActiveProcessor(); }
+ SpanProcessor &GetActiveProcessor() const noexcept { return context_->GetActiveProcessor(); }
 
  /** Returns the configured Id generator */
- IdGenerator &GetIdGenerator() noexcept { return context_->GetIdGenerator(); }
+ IdGenerator &GetIdGenerator() const noexcept { return context_->GetIdGenerator(); }
+
+ /** Returns the associated instruementation library */
+ const InstrumentationLibrary &GetInstrumentationLibrary() const noexcept
+ {
+ return *instrumentation_library_;
+ }
 
  // Note: Test only
  Sampler &GetSampler() { return context_->GetSampler(); }
 
 private:
  std::shared_ptr<sdk::trace::TracerContext> context_;
+ std::shared_ptr<InstrumentationLibrary> instrumentation_library_;
 };
 } // namespace trace
 } // namespace sdk

sdk/include/opentelemetry/sdk/trace/tracer_provider.h

@@ -2,7 +2,9 @@
 
 #include <map>
 #include <memory>
+#include <mutex>
 #include <string>
+#include <vector>
 
 #include "opentelemetry/nostd/shared_ptr.h"
 #include "opentelemetry/sdk/resource/resource.h"
@@ -73,7 +75,8 @@ class TracerProvider final : public opentelemetry::trace::TracerProvider
 
 private:
  std::shared_ptr<sdk::trace::TracerContext> context_;
- std::shared_ptr<opentelemetry::trace::Tracer> tracer_;
+ std::vector<std::shared_ptr<opentelemetry::sdk::trace::Tracer>> tracers_;
+ std::mutex lock_;
 };
 } // namespace trace
 } // namespace sdk

sdk/src/trace/tracer.cc

@@ -11,7 +11,10 @@ namespace sdk
 namespace trace
 {
 
-Tracer::Tracer(std::shared_ptr<sdk::trace::TracerContext> context) noexcept : context_{context} {}
+Tracer::Tracer(std::shared_ptr<sdk::trace::TracerContext> context,
+ std::unique_ptr<InstrumentationLibrary> instrumentation_library) noexcept
+ : context_{context}, instrumentation_library_{std::move(instrumentation_library)}
+{}
 
 trace_api::SpanContext GetCurrentSpanContext(const trace_api::SpanContext &explicit_parent)
 {

sdk/src/trace/tracer_context.cc

@@ -19,7 +19,7 @@ TracerContext::TracerContext(std::unique_ptr<SpanProcessor> processor,
 
 Sampler &TracerContext::GetSampler() const noexcept
 {
- return *sampler_.get();
+ return *sampler_;
 }
 
 const opentelemetry::sdk::resource::Resource &TracerContext::GetResource() const noexcept

sdk/src/trace/tracer_provider.cc

@@ -6,7 +6,7 @@ namespace sdk
 namespace trace
 {
 TracerProvider::TracerProvider(std::shared_ptr<sdk::trace::TracerContext> context) noexcept
- : context_{context}, tracer_(new Tracer(context))
+ : context_{context}
 {}
 
 TracerProvider::TracerProvider(std::unique_ptr<SpanProcessor> processor,
@@ -19,11 +19,29 @@ TracerProvider::TracerProvider(std::unique_ptr<SpanProcessor> processor,
  std::move(id_generator)))
 {}
 
-opentelemetry::nostd::shared_ptr<opentelemetry::trace::Tracer> TracerProvider::GetTracer(
+nostd::shared_ptr<opentelemetry::trace::Tracer> TracerProvider::GetTracer(
  nostd::string_view library_name,
  nostd::string_view library_version) noexcept
 {
- return opentelemetry::nostd::shared_ptr<opentelemetry::trace::Tracer>(tracer_);
+ // if (library_name == "") {
+ // // TODO: log invalid library_name.
+ // }
+
+ const std::lock_guard<std::mutex> guard(lock_);
+
+ for (auto &tracer : tracers_)
+ {
+ auto &tracer_lib = tracer->GetInstrumentationLibrary();
+ if (tracer_lib.equal(library_name, library_version))
+ {
+ return nostd::shared_ptr<opentelemetry::trace::Tracer>{tracer};
+ }
+ }
+
+ auto lib = InstrumentationLibrary::create(library_name, library_version);
+ tracers_.push_back(std::shared_ptr<opentelemetry::sdk::trace::Tracer>(
+ new sdk::trace::Tracer(context_, std::move(lib))));
+ return nostd::shared_ptr<opentelemetry::trace::Tracer>{tracers_.back()};
 }
 
 void TracerProvider::RegisterPipeline(std::unique_ptr<SpanProcessor> processor) noexcept

sdk/test/CMakeLists.txt

@@ -3,3 +3,4 @@ add_subdirectory(trace)
 add_subdirectory(metrics)
 add_subdirectory(logs)
 add_subdirectory(resource)
+add_subdirectory(instrumentationlibrary)

sdk/test/instrumentationlibrary/BUILD

@@ -0,0 +1,13 @@
+load("//bazel:otel_cc_benchmark.bzl", "otel_cc_benchmark")
+
+cc_test(
+ name = "instrumentationlibrary_test",
+ srcs = [
+ "instrumentationlibrary_test.cc",
+ ],
+ deps = [
+ "//api",
+ "//sdk:headers",
+ "@com_google_googletest//:gtest_main",
+ ],
+)

sdk/test/instrumentationlibrary/CMakeLists.txt

@@ -0,0 +1,12 @@
+include(GoogleTest)
+
+foreach(testname instrumentationlibrary_test)
+ add_executable(${testname} "${testname}.cc")
+ target_link_libraries(
+ ${testname} ${GTEST_BOTH_LIBRARIES} ${CORE_RUNTIME_LIBS}
+ ${CMAKE_THREAD_LIBS_INIT} opentelemetry_api)
+ gtest_add_tests(
+ TARGET ${testname}
+ TEST_PREFIX instrumentationlibrary.
+ TEST_LIST ${testname})
+endforeach()

sdk/test/instrumentationlibrary/instrumentationlibrary_test.cc

@@ -0,0 +1,34 @@
+// Copyright 2021, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h"
+
+#include <gtest/gtest.h>
+#include <string>
+#include <vector>
+
+using namespace opentelemetry;
+using namespace opentelemetry::sdk::instrumentationlibrary;
+
+TEST(InstrumentationLibrary, CreateInstrumentationLibrary)
+{
+
+ std::string library_name = "opentelemetry-cpp";
+ std::string library_version = "0.1.0";
+ auto instrumentation_library = InstrumentationLibrary::create(library_name, library_version);
+
+ EXPECT_EQ(instrumentation_library->GetName(), library_name);
+ EXPECT_EQ(instrumentation_library->GetVersion(), library_version);
+}

sdk/test/trace/tracer_provider_test.cc

@@ -24,8 +24,7 @@ TEST(TracerProvider, GetTracer)
 
  // Should return the same instance each time.
  ASSERT_EQ(t1, t2);
- // TODO: t3 should be a different instance.
- ASSERT_EQ(t1, t3);
+ ASSERT_NE(t1, t3);
 
  // Should be an sdk::trace::Tracer with the processor attached.
  auto sdkTracer1 = dynamic_cast<Tracer *>(t1.get());
@@ -37,6 +36,16 @@ TEST(TracerProvider, GetTracer)
  std::unique_ptr<IdGenerator>(new RandomIdGenerator)));
  auto sdkTracer2 = dynamic_cast<Tracer *>(tp2.GetTracer("test").get());
  ASSERT_EQ("AlwaysOffSampler", sdkTracer2->GetSampler().GetDescription());
+
+ auto instrumentation_library1 = sdkTracer1->GetInstrumentationLibrary();
+ ASSERT_EQ(instrumentation_library1.GetName(), "test");
+ ASSERT_EQ(instrumentation_library1.GetVersion(), "");
+
+ // Should be an sdk::trace::Tracer with the processor attached.
+ auto sdkTracer3 = dynamic_cast<Tracer *>(t3.get());
+ auto instrumentation_library3 = sdkTracer3->GetInstrumentationLibrary();
+ ASSERT_EQ(instrumentation_library3.GetName(), "different");
+ ASSERT_EQ(instrumentation_library3.GetVersion(), "1.0.0");
 }
 
 TEST(TracerProvider, Shutdown)
@@ -55,4 +64,4 @@ TEST(TracerProvider, ForceFlush)
  TracerProvider tp1(std::move(processor1));
 
  EXPECT_TRUE(tp1.ForceFlush());
-}
+}

sdk/test/trace/tracer_test.cc

@@ -593,4 +593,4 @@ TEST(Tracer, ExpectParent)
 
  EXPECT_EQ(spandata_first->GetSpanId(), spandata_second->GetParentSpanId());
  EXPECT_EQ(spandata_second->GetSpanId(), spandata_third->GetParentSpanId());
-}
+}