Add support for dynamic loading. (#64)

Author: rnburn

CMakeLists.txt

@@ -142,6 +142,8 @@ set(SRC
     src/jaegertracing/Tag.cpp
     src/jaegertracing/TraceID.cpp
     src/jaegertracing/Tracer.cpp
+    src/jaegertracing/TracerFactory.cpp
+    src/jaegertracing/DynamicLoad.cpp
     src/jaegertracing/Transport.cpp
     src/jaegertracing/UDPTransport.cpp
     src/jaegertracing/baggage/BaggageSetter.cpp
@@ -259,6 +261,8 @@ if(BUILD_TESTING)
       src/jaegertracing/TagTest.cpp
       src/jaegertracing/TraceIDTest.cpp
       src/jaegertracing/TracerTest.cpp
+      src/jaegertracing/TracerFactoryTest.cpp
+      src/jaegertracing/DynamicLoadTest.cpp
       src/jaegertracing/UDPTransportTest.cpp
       src/jaegertracing/baggage/BaggageTest.cpp
       src/jaegertracing/metrics/MetricsTest.cpp
@@ -283,8 +287,14 @@ if(BUILD_TESTING)
       GTEST_HAS_TR1_TUPLE=0
       GTEST_USE_OWN_TR1_TUPLE=0)
   target_link_libraries(
-      UnitTest testutils GTest::main jaegertracing-static ${LIBS})
+      UnitTest testutils GTest::main jaegertracing ${LIBS})
   add_test(NAME UnitTest COMMAND UnitTest)
+
+  add_executable(DynamicallyLoadTracerTest src/jaegertracing/DynamicallyLoadTracerTest.cpp)
+  target_link_libraries(
+    DynamicallyLoadTracerTest OpenTracing::opentracing-static)
+  add_test(NAME DynamicallyLoadTracerTest COMMAND DynamicallyLoadTracerTest 
+    ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}jaegertracing${CMAKE_SHARED_LIBRARY_SUFFIX})
   if(JAEGERTRACING_COVERAGE)
       setup_target_for_coverage(NAME UnitTestCoverage
                                 EXECUTABLE UnitTest

src/jaegertracing/DynamicLoad.cpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2018 Uber Technologies, Inc.
+ *
+ * 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 <cassert>
+#include <cstring>
+#include <system_error>
+
+#include <opentracing/dynamic_load.h>
+
+#include "TracerFactory.h"
+#include "jaegertracing/Tracer.h"
+
+int OpenTracingMakeTracerFactory(const char* opentracingVersion,
+                                 const void** errorCategory,
+                                 void** tracerFactory)
+{
+    assert(errorCategory != nullptr);
+    assert(tracerFactory != nullptr);
+#ifndef JAEGERTRACING_WITH_YAML_CPP
+    *errorCategory =
+        static_cast<const void*>(&opentracing::dynamic_load_error_category());
+    return opentracing::dynamic_load_not_supported_error.value();
+#endif
+    if (std::strcmp(opentracingVersion, OPENTRACING_VERSION) != 0) {
+        *errorCategory = static_cast<const void*>(
+            &opentracing::dynamic_load_error_category());
+        return opentracing::incompatible_library_versions_error.value();
+    }
+
+    *tracerFactory = new (std::nothrow) jaegertracing::TracerFactory{};
+    if (*tracerFactory == nullptr) {
+        *errorCategory = static_cast<const void*>(&std::generic_category());
+        return static_cast<int>(std::errc::not_enough_memory);
+    }
+
+    return 0;
+}

src/jaegertracing/DynamicLoadTest.cpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018 Uber Technologies, Inc.
+ *
+ * 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 <iostream>
+#include <string>
+
+#include "jaegertracing/Constants.h"
+#include <gtest/gtest.h>
+#include <opentracing/dynamic_load.h>
+
+namespace jaegertracing {
+#ifdef JAEGERTRACING_WITH_YAML_CPP
+TEST(DynamicLoad, invalidVersion)
+{
+    const void* errorCategory = nullptr;
+    void* tracerFactory = nullptr;
+    const auto rcode = OpenTracingMakeTracerFactory(
+        "1.0.0" /*invalid version*/, &errorCategory, &tracerFactory);
+    ASSERT_EQ(rcode, opentracing::incompatible_library_versions_error.value());
+    ASSERT_EQ(
+        errorCategory,
+        static_cast<const void*>(&opentracing::dynamic_load_error_category()));
+    ASSERT_EQ(tracerFactory, nullptr);
+}
+
+TEST(DynamicLoad, validVersion)
+{
+    const void* errorCategory = nullptr;
+    void* tracerFactory = nullptr;
+    const auto rcode = OpenTracingMakeTracerFactory(
+        OPENTRACING_VERSION, &errorCategory, &tracerFactory);
+    ASSERT_EQ(rcode, 0);
+    ASSERT_EQ(errorCategory, nullptr);
+    ASSERT_NE(tracerFactory, nullptr);
+    delete static_cast<opentracing::TracerFactory*>(tracerFactory);
+}
+#else
+TEST(DynamicLoad, noYAML)
+{
+    const void* errorCategory = nullptr;
+    void* tracerFactory = nullptr;
+    const auto rcode = OpenTracingMakeTracerFactory(
+        OPENTRACING_VERSION, &errorCategory, &tracerFactory);
+    ASSERT_NE(rcode, 0);
+}
+#endif  // JAEGERTRACING_WITH_YAML_CPP
+}  // namespace jaegertracing

src/jaegertracing/DynamicallyLoadTracerTest.cpp

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2018 Uber Technologies, Inc.
+ *
+ * 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 <iostream>
+#include <string>
+
+#include <opentracing/dynamic_load.h>
+
+// Verify that Jaeger's shared library can be dynamically loaded and used
+// as a plugin.
+int main(int argc, char* argv[])
+{
+    if (argc != 2) {
+        std::cerr << "DynamicLoadTest <tracer-library>\n";
+        return -1;
+    }
+    const char* library = argv[1];
+    std::string errorMessage;
+    auto tracerFactoryMaybe =
+        opentracing::DynamicallyLoadTracingLibrary(library, errorMessage);
+#ifdef JAEGERTRACING_WITH_YAML_CPP
+    if (!errorMessage.empty()) {
+        std::cerr << "Failed to load tracing tracer: " << errorMessage << "\n";
+        return -1;
+    }
+    if (!tracerFactoryMaybe) {
+        std::cerr << "Failed to load tracing library: "
+                  << tracerFactoryMaybe.error().message() << "\n";
+        return -1;
+    }
+#else
+    if (tracerFactoryMaybe) {
+        std::cerr << "Dynamically loading a tracing library should fail "
+                     "without YAML support\n";
+        return -1;
+    }
+#endif  // JAEGERTRACING_WITH_YAML_CPP
+    return 0;
+}

src/jaegertracing/TracerFactory.cpp

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2018 Uber Technologies, Inc.
+ *
+ * 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 "TracerFactory.h"
+
+#include "jaegertracing/Tracer.h"
+
+namespace jaegertracing {
+
+opentracing::expected<std::shared_ptr<opentracing::Tracer>>
+TracerFactory::MakeTracer(const char* configuration,
+                          std::string& errorMessage) const noexcept try {
+#ifndef JAEGERTRACING_WITH_YAML_CPP
+    errorMessage =
+        "Failed to construct tracer: Jaeger was not build with yaml support.";
+    return opentracing::make_unexpected(
+        std::make_error_code(std::errc::not_supported));
+#else
+    YAML::Node yaml;
+    try {
+        yaml = YAML::Load(configuration);
+    } catch (const YAML::ParserException& e) {
+        errorMessage = e.what();
+        return opentracing::make_unexpected(
+            opentracing::configuration_parse_error);
+    }
+
+    const auto serviceNameNode = yaml["service_name"];
+    if (!serviceNameNode) {
+        errorMessage = "`service_name` not provided";
+        return opentracing::make_unexpected(
+            opentracing::invalid_configuration_error);
+    }
+    if (!serviceNameNode.IsScalar()) {
+        errorMessage = "`service_name` must be a string";
+        return opentracing::make_unexpected(
+            opentracing::invalid_configuration_error);
+    }
+    std::string serviceName = serviceNameNode.Scalar();
+
+    const auto tracerConfig = jaegertracing::Config::parse(yaml);
+    return jaegertracing::Tracer::make(serviceName, tracerConfig);
+#endif  // JAEGERTRACING_WITH_YAML_CPP
+} catch (const std::bad_alloc&) {
+    return opentracing::make_unexpected(
+        std::make_error_code(std::errc::not_enough_memory));
+} catch (const std::exception& e) {
+    errorMessage = e.what();
+    return opentracing::make_unexpected(
+        opentracing::invalid_configuration_error);
+}
+}  // namespace jaegertracing

src/jaegertracing/TracerFactory.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2018 Uber Technologies, Inc.
+ *
+ * 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.
+ */
+
+#ifndef JAEGERTRACING_TRACER_FACTORY_H
+#define JAEGERTRACING_TRACER_FACTORY_H
+
+#include <opentracing/tracer_factory.h>
+
+namespace jaegertracing {
+
+class TracerFactory : public opentracing::TracerFactory {
+  public:
+    opentracing::expected<std::shared_ptr<opentracing::Tracer>>
+    MakeTracer(const char* configuration, std::string& errorMessage) const
+        noexcept override;
+};
+}  // namespace jaegertracing
+
+#endif  // JAEGERTRACING_TRACER_FACTORY_H

src/jaegertracing/TracerFactoryTest.cpp

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2018 Uber Technologies, Inc.
+ *
+ * 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 "jaegertracing/TracerFactory.h"
+#include <gtest/gtest.h>
+
+namespace jaegertracing {
+#ifdef JAEGERTRACING_WITH_YAML_CPP
+TEST(TracerFactory, testInvalidConfig)
+{
+    const char* invalidConfigTestCases[] = { "",
+                                             "abc: {",
+                                             R"({
+      "service_name": {}
+    })",
+                                             R"({
+      "service_name": "t",
+      "badField": 97
+    })" };
+    TracerFactory tracerFactory;
+    for (auto&& invalidConfig : invalidConfigTestCases) {
+        std::string errorMessage;
+        auto tracerMaybe =
+            tracerFactory.MakeTracer(invalidConfig, errorMessage);
+        ASSERT_FALSE(tracerMaybe);
+        ASSERT_NE(errorMessage, "");
+    }
+}
+
+TEST(TracerFactory, testValidConfig)
+{
+    const char* config = R"(
+  {
+    "service_name": "test",
+    "disabled": true,
+    "sampler": {
+      "type": "probabilistic",
+      "param": 0.001
+    },
+    "reporter": {
+      "queueSize": 100,
+      "bufferFlushInterval": 10,
+      "logSpans": false,
+      "localAgentHostPort": "127.0.0.1:6831"
+    },
+    "headers": {
+      "jaegerDebugHeader": "debug-id",
+      "jaegerBaggageHeader": "baggage",
+      "TraceContextHeaderName": "trace-id",
+      "traceBaggageHeaderPrefix": "testctx-"
+    },
+    "baggage_restrictions": {
+        "denyBaggageOnInitializationFailure": false,
+        "hostPort": "127.0.0.1:5778",
+        "refreshInterval": 60
+    }
+  })";
+    TracerFactory tracerFactory;
+    std::string errorMessage;
+    auto tracerMaybe = tracerFactory.MakeTracer(config, errorMessage);
+    ASSERT_EQ(errorMessage, "");
+    ASSERT_TRUE(tracerMaybe);
+}
+#else
+TEST(TracerFactory, failsWithoutYAML)
+{
+    const char* config = "";
+    TracerFactory tracerFactory;
+    std::string errorMessage;
+    auto tracerMaybe = tracerFactory.MakeTracer(config, errorMessage);
+    ASSERT_NE(errorMessage, "");
+    ASSERT_FALSE(tracerMaybe);
+}
+#endif  // JAEGERTRACING_WITH_YAML_CPP
+}  // namespace jaegertracing