ceph/src/jaegertracing/opentelemetry-cpp/sdk/test/logs/logger_provider_sdk_test.cc

   1 // Copyright The OpenTelemetry Authors
   2 // SPDX-License-Identifier: Apache-2.0
   3
   4 #ifdef ENABLE_LOGS_PREVIEW
   5
   6 #  include <array>
   7 #  include "opentelemetry/logs/provider.h"
   8 #  include "opentelemetry/nostd/shared_ptr.h"
   9 #  include "opentelemetry/nostd/string_view.h"
  10 #  include "opentelemetry/sdk/logs/log_record.h"
  11 #  include "opentelemetry/sdk/logs/logger.h"
  12 #  include "opentelemetry/sdk/logs/logger_provider.h"
  13 #  include "opentelemetry/sdk/logs/simple_log_processor.h"
  14
  15 #  include <gtest/gtest.h>
  16
  17 using namespace opentelemetry::sdk::logs;
  18 namespace logs_api = opentelemetry::logs;
  19 namespace nostd    = opentelemetry::nostd;
  20
  21 TEST(LoggerProviderSDK, PushToAPI)
  22 {
  23   auto lp =
  24       nostd::shared_ptr<logs_api::LoggerProvider>(new opentelemetry::sdk::logs::LoggerProvider());
  25   logs_api::Provider::SetLoggerProvider(lp);
  26
  27   // Check that the loggerprovider was correctly pushed into the API
  28   ASSERT_EQ(lp, logs_api::Provider::GetLoggerProvider());
  29 }
  30
  31 TEST(LoggerProviderSDK, LoggerProviderGetLoggerSimple)
  32 {
  33   auto lp = std::shared_ptr<logs_api::LoggerProvider>(new LoggerProvider());
  34
  35   nostd::string_view schema_url{"https://opentelemetry.io/schemas/1.11.0"};
  36   auto logger1 = lp->GetLogger("logger1", "", "opentelelemtry_library", "", schema_url);
  37   auto logger2 = lp->GetLogger("logger2", "", "", "", schema_url);
  38
  39   // Check that the logger is not nullptr
  40   ASSERT_NE(logger1, nullptr);
  41   ASSERT_NE(logger2, nullptr);
  42
  43   auto sdk_logger1 = static_cast<opentelemetry::sdk::logs::Logger *>(logger1.get());
  44   auto sdk_logger2 = static_cast<opentelemetry::sdk::logs::Logger *>(logger2.get());
  45   ASSERT_EQ(sdk_logger1->GetInstrumentationLibrary().GetName(), "opentelelemtry_library");
  46   ASSERT_EQ(sdk_logger1->GetInstrumentationLibrary().GetVersion(), "");
  47   ASSERT_EQ(sdk_logger1->GetInstrumentationLibrary().GetSchemaURL(), schema_url);
  48
  49   ASSERT_EQ(sdk_logger2->GetInstrumentationLibrary().GetName(), "logger2");
  50   ASSERT_EQ(sdk_logger2->GetInstrumentationLibrary().GetVersion(), "");
  51   ASSERT_EQ(sdk_logger2->GetInstrumentationLibrary().GetSchemaURL(), schema_url);
  52
  53   // Check that two loggers with different names aren't the same instance
  54   ASSERT_NE(logger1, logger2);
  55
  56   // Check that two loggers with the same name are the same instance
  57   auto logger3 = lp->GetLogger("logger1", "", "opentelelemtry_library", "", schema_url);
  58   ASSERT_EQ(logger1, logger3);
  59   auto sdk_logger3 = static_cast<opentelemetry::sdk::logs::Logger *>(logger3.get());
  60   ASSERT_EQ(sdk_logger3->GetInstrumentationLibrary(), sdk_logger1->GetInstrumentationLibrary());
  61 }
  62
  63 TEST(LoggerProviderSDK, LoggerProviderLoggerArguments)
  64 {
  65   // Currently, arguments are not supported by the loggers.
  66   // TODO: Once the logging spec defines what arguments are allowed, add more
  67   // detail to this test
  68   auto lp = std::shared_ptr<logs_api::LoggerProvider>(new LoggerProvider());
  69
  70   nostd::string_view schema_url{"https://opentelemetry.io/schemas/1.11.0"};
  71   auto logger1 = lp->GetLogger("logger1", "", "opentelelemtry_library", "", schema_url);
  72
  73   // Check GetLogger(logger_name, args)
  74   std::array<nostd::string_view, 1> sv{"string"};
  75   nostd::span<nostd::string_view> args{sv};
  76   auto logger2     = lp->GetLogger("logger2", args, "opentelelemtry_library", "", schema_url);
  77   auto sdk_logger1 = static_cast<opentelemetry::sdk::logs::Logger *>(logger1.get());
  78   auto sdk_logger2 = static_cast<opentelemetry::sdk::logs::Logger *>(logger2.get());
  79   ASSERT_EQ(sdk_logger2->GetInstrumentationLibrary(), sdk_logger1->GetInstrumentationLibrary());
  80 }
  81
  82 class DummyProcessor : public LogProcessor
  83 {
  84   std::unique_ptr<Recordable> MakeRecordable() noexcept
  85   {
  86     return std::unique_ptr<Recordable>(new LogRecord);
  87   }
  88
  89   void OnReceive(std::unique_ptr<Recordable> &&record) noexcept {}
  90   bool ForceFlush(std::chrono::microseconds timeout = std::chrono::microseconds(0)) noexcept
  91   {
  92     return true;
  93   }
  94   bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds(0)) noexcept
  95   {
  96     return true;
  97   }
  98 };
  99
 100 TEST(LoggerProviderSDK, GetResource)
 101 {
 102   // Create a LoggerProvider without a processor
 103   auto resource = opentelemetry::sdk::resource::Resource::Create({{"key", "value"}});
 104   LoggerProvider lp{nullptr, resource};
 105   ASSERT_EQ(nostd::get<std::string>(lp.GetResource().GetAttributes().at("key")), "value");
 106 }
 107
 108 TEST(LoggerProviderSDK, Shutdown)
 109 {
 110   std::unique_ptr<SimpleLogProcessor> processor(new SimpleLogProcessor(nullptr));
 111   std::vector<std::unique_ptr<LogProcessor>> processors;
 112   processors.push_back(std::move(processor));
 113
 114   LoggerProvider lp(std::make_shared<LoggerContext>(std::move(processors)));
 115
 116   EXPECT_TRUE(lp.Shutdown());
 117
 118   // It's safe to shutdown again
 119   EXPECT_TRUE(lp.Shutdown());
 120 }
 121
 122 TEST(LoggerProviderSDK, ForceFlush)
 123 {
 124   std::unique_ptr<SimpleLogProcessor> processor(new SimpleLogProcessor(nullptr));
 125   std::vector<std::unique_ptr<LogProcessor>> processors;
 126   processors.push_back(std::move(processor));
 127
 128   LoggerProvider lp(std::make_shared<LoggerContext>(std::move(processors)));
 129
 130   EXPECT_TRUE(lp.ForceFlush());
 131 }
 132
 133 #endif