Add trace context injection and Logger limit to Logging SDK

sdk/include/opentelemetry/sdk/logs/exporter.h

@@ -55,7 +55,7 @@ class LogExporter
    * @returns an ExportResult code (whether export was success or failure)
    */
   virtual ExportResult Export(
-      const nostd::span<std::unique_ptr<opentelemetry::logs::LogRecord>> &records) noexcept = 0;
+      const nostd::span<std::shared_ptr<opentelemetry::logs::LogRecord>> &records) noexcept = 0;
 
   /**
    * Marks the exporter as ShutDown and cleans up any resources as required.

sdk/include/opentelemetry/sdk/logs/logger_provider.h

@@ -29,8 +29,8 @@
 #include "opentelemetry/sdk/logs/processor.h"
 
 // Define the maximum number of loggers that are allowed to be registered to the loggerprovider.
-// TODO: Add link to logging spec once this is added to it
-#define MAX_LOGGER_COUNT 100
+// References spec issue https://github.com/open-telemetry/opentelemetry-specification/issues/1259
+#define OTEL_MAX_LOGGER_COUNT 1000
 
 OPENTELEMETRY_BEGIN_NAMESPACE
 namespace sdk
@@ -95,6 +95,9 @@ class LoggerProvider final : public opentelemetry::logs::LoggerProvider,
 
   // A mutex that ensures only one thread is using the map of loggers
   std::mutex mu_;
+
+  // A noop logger that is returned by GetLogger() when OTEL_MAX_LOGGER_COUNT reached
+  opentelemetry::nostd::shared_ptr<opentelemetry::logs::Logger> noop_logger_;
 };
 }  // namespace logs
 }  // namespace sdk

sdk/include/opentelemetry/sdk/logs/processor.h

@@ -38,7 +38,7 @@ class LogProcessor
    * OnReceive is called by the SDK once a log record has been successfully created.
    * @param record the log record
    */
-  virtual void OnReceive(std::unique_ptr<opentelemetry::logs::LogRecord> &&record) noexcept = 0;
+  virtual void OnReceive(std::shared_ptr<opentelemetry::logs::LogRecord> record) noexcept = 0;
 
   /**
    * Exports all log records that have not yet been exported to the configured Exporter.

sdk/include/opentelemetry/sdk/logs/simple_log_processor.h

@@ -43,7 +43,7 @@ class SimpleLogProcessor : public LogProcessor
   explicit SimpleLogProcessor(std::unique_ptr<LogExporter> &&exporter);
   virtual ~SimpleLogProcessor() = default;
 
-  void OnReceive(std::unique_ptr<opentelemetry::logs::LogRecord> &&record) noexcept override;
+  void OnReceive(std::shared_ptr<opentelemetry::logs::LogRecord> record) noexcept override;
 
   bool ForceFlush(
       std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;

sdk/src/logs/BUILD

@@ -22,5 +22,6 @@ cc_library(
     deps = [
         "//api",
         "//sdk:headers",
+        "//sdk/src/trace",
     ],
 )

sdk/src/logs/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_library(opentelemetry_logs logger_provider.cc logger.cc
                                simple_log_processor.cc)
 
-target_link_libraries(opentelemetry_logs opentelemetry_common)
+target_link_libraries(opentelemetry_logs opentelemetry_common
+                      opentelemetry_trace)

sdk/src/logs/logger.cc

@@ -15,6 +15,8 @@
  */
 
 #include "opentelemetry/sdk/logs/logger.h"
+#include "opentelemetry/sdk/trace/span_data.h"
+#include "opentelemetry/trace/provider.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
 namespace sdk
@@ -36,23 +38,43 @@ void Logger::log(const opentelemetry::logs::LogRecord &record) noexcept
 
   // TODO: Sampler logic (should include check for minSeverity)
 
-  /**
-   * Convert the LogRecord to the heap first before sending to processor.
-   * TODO: Change the API log(LogRecord) function to log(*LogRecord) so the following line
-   * converting record a heap variable can be removed
-   */
+  // Create a shared pointer to the LogRecord to be passed to the processor(s)
   auto record_pointer =
-      std::unique_ptr<opentelemetry::logs::LogRecord>(new opentelemetry::logs::LogRecord(record));
+      std::shared_ptr<opentelemetry::logs::LogRecord>(new opentelemetry::logs::LogRecord(record));
 
-  // TODO: Do not want to overwrite user-set timestamp if there already is one -
-  // add a flag in the API to check if timestamp is set by user already before setting timestamp
+  // Inject values into record if not user specified
+  // Timestamp
+  if (record_pointer->timestamp == opentelemetry::core::SystemTimestamp(std::chrono::seconds(0)))
+  {
+    record_pointer->timestamp = core::SystemTimestamp(std::chrono::system_clock::now());
+  }
+
+  auto provider     = opentelemetry::trace::Provider::GetTracerProvider();
+  auto tracer       = provider->GetTracer("foo_library");
+  auto span_context = tracer->GetCurrentSpan()->GetContext();
+
+  // Traceid
+  if (!record_pointer->trace_id.IsValid())
+  {
+    record_pointer->trace_id = span_context.trace_id();
+  }
+
+  // Spanid
+  if (!record_pointer->span_id.IsValid())
+  {
+    record_pointer->span_id = span_context.span_id();
+  }
+
+  // Traceflag
+  if (!record_pointer->trace_flag.IsSampled())
+  {
+    record_pointer->trace_flag = span_context.trace_flags();
+  }
 
-  // Inject timestamp if none is set
-  record_pointer->timestamp = core::SystemTimestamp(std::chrono::system_clock::now());
-  // TODO: inject traceid/spanid later
+  // TODO: Inject logger name into record
 
   // Send the log record to the processor
-  processor->OnReceive(std::move(record_pointer));
+  processor->OnReceive(record_pointer);
 }
 
 }  // namespace logs

sdk/src/logs/logger_provider.cc

@@ -22,7 +22,11 @@ namespace sdk
 namespace logs
 {
 
-LoggerProvider::LoggerProvider() noexcept : processor_{nullptr} {}
+LoggerProvider::LoggerProvider() noexcept
+    : processor_{nullptr},
+      noop_logger_{
+          nostd::shared_ptr<opentelemetry::logs::NoopLogger>(new opentelemetry::logs::NoopLogger)}
+{}
 
 opentelemetry::nostd::shared_ptr<opentelemetry::logs::Logger> LoggerProvider::GetLogger(
     opentelemetry::nostd::string_view name,
@@ -39,20 +43,13 @@ opentelemetry::nostd::shared_ptr<opentelemetry::logs::Logger> LoggerProvider::Ge
   }
 
   // Check if creating a new logger would exceed the max number of loggers
-  // TODO: Remove the noexcept from the API's and SDK's GetLogger(~)
-  /*
-  if (loggers_.size() > MAX_LOGGER_COUNT)
+  if (loggers_.size() >= OTEL_MAX_LOGGER_COUNT)
   {
-#if __EXCEPTIONS
-    throw std::length_error("Number of loggers exceeds max count");
-#else
-    std::terminate();
-#endif
+    // Return a noop logger
+    return noop_logger_;
   }
-  */
 
   // If no logger with that name exists yet, create it and add it to the map of loggers
-
   opentelemetry::nostd::shared_ptr<opentelemetry::logs::Logger> logger(
       new Logger(this->shared_from_this()));
   loggers_[name.data()] = logger;

sdk/src/logs/simple_log_processor.cc

@@ -36,14 +36,15 @@ SimpleLogProcessor::SimpleLogProcessor(std::unique_ptr<LogExporter> &&exporter)
  * Batches the log record it receives in a batch of 1 and immediately sends it
  * to the configured exporter
  */
-void SimpleLogProcessor::OnReceive(
-    std::unique_ptr<opentelemetry::logs::LogRecord> &&record) noexcept
+void SimpleLogProcessor::OnReceive(std::shared_ptr<opentelemetry::logs::LogRecord> record) noexcept
 {
-  nostd::span<std::unique_ptr<opentelemetry::logs::LogRecord>> batch(&record, 1);
+  std::vector<std::shared_ptr<opentelemetry::logs::LogRecord>> batch;
+  batch.emplace_back(record);
   // Get lock to ensure Export() is never called concurrently
   const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
 
-  if (exporter_->Export(batch) != ExportResult::kSuccess)
+  if (exporter_->Export(opentelemetry::nostd::span<std::shared_ptr<opentelemetry::logs::LogRecord>>(
+          batch.data(), batch.size())) != ExportResult::kSuccess)
   {
     /* Alert user of the failed export */
   }

sdk/test/logs/simple_log_processor_test.cc

@@ -26,7 +26,7 @@ class TestExporter final : public LogExporter
 
   // Stores the names of the log records this exporter receives to an internal list
   ExportResult Export(
-      const opentelemetry::nostd::span<std::unique_ptr<LogRecord>> &records) noexcept override
+      const opentelemetry::nostd::span<std::shared_ptr<LogRecord>> &records) noexcept override
   {
     *batch_size_received = records.size();
     for (auto &record : records)
@@ -66,12 +66,12 @@ TEST(SimpleLogProcessorTest, SendReceivedLogsToExporter)
   const int num_logs = 5;
   for (int i = 0; i < num_logs; i++)
   {
-    auto record = std::unique_ptr<LogRecord>(new LogRecord());
+    auto record = std::shared_ptr<LogRecord>(new LogRecord());
     std::string s("Log name");
     s += std::to_string(i);
     record->name = s;
 
-    processor.OnReceive(std::move(record));
+    processor.OnReceive(record);
 
     // Verify that the batch of 1 log record sent by processor matches what exporter received
     EXPECT_EQ(1, batch_size_received);
@@ -116,7 +116,7 @@ class FailShutDownExporter final : public LogExporter
   FailShutDownExporter() {}
 
   ExportResult Export(
-      const opentelemetry::nostd::span<std::unique_ptr<LogRecord>> &records) noexcept override
+      const opentelemetry::nostd::span<std::shared_ptr<LogRecord>> &records) noexcept override
   {
     return ExportResult::kSuccess;
   }