From e6918187568dbd01842d8d1d2c808ce16a894239 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 21 Apr 2024 13:54:28 +0200 Subject: Adding upstream version 18.2.2. Signed-off-by: Daniel Baumann --- .../sdk/test/logs/simple_log_processor_test.cc | 152 +++++++++++++++++++++ 1 file changed, 152 insertions(+) create mode 100644 src/jaegertracing/opentelemetry-cpp/sdk/test/logs/simple_log_processor_test.cc (limited to 'src/jaegertracing/opentelemetry-cpp/sdk/test/logs/simple_log_processor_test.cc') diff --git a/src/jaegertracing/opentelemetry-cpp/sdk/test/logs/simple_log_processor_test.cc b/src/jaegertracing/opentelemetry-cpp/sdk/test/logs/simple_log_processor_test.cc new file mode 100644 index 000000000..32c62a508 --- /dev/null +++ b/src/jaegertracing/opentelemetry-cpp/sdk/test/logs/simple_log_processor_test.cc @@ -0,0 +1,152 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#ifdef ENABLE_LOGS_PREVIEW + +# include "opentelemetry/sdk/logs/simple_log_processor.h" +# include "opentelemetry/nostd/span.h" +# include "opentelemetry/sdk/logs/exporter.h" +# include "opentelemetry/sdk/logs/log_record.h" + +# include + +# include +# include + +using namespace opentelemetry::sdk::logs; +using namespace opentelemetry::sdk::common; +namespace nostd = opentelemetry::nostd; + +/* + * A test exporter that can return a vector of all the records it has received, + * and keep track of the number of times its Shutdown() function was called. + */ +class TestExporter final : public LogExporter +{ +public: + TestExporter(int *shutdown_counter, + std::shared_ptr>> logs_received, + size_t *batch_size_received) + : shutdown_counter_(shutdown_counter), + logs_received_(logs_received), + batch_size_received(batch_size_received) + {} + + std::unique_ptr MakeRecordable() noexcept override + { + return std::unique_ptr(new LogRecord()); + } + + // Stores the names of the log records this exporter receives to an internal list + ExportResult Export(const nostd::span> &records) noexcept override + { + *batch_size_received = records.size(); + for (auto &record : records) + { + auto log_record = std::unique_ptr(static_cast(record.release())); + + if (log_record != nullptr) + { + logs_received_->push_back(std::move(log_record)); + } + } + return ExportResult::kSuccess; + } + + // Increment the shutdown counter everytime this method is called + bool Shutdown(std::chrono::microseconds timeout) noexcept override + { + *shutdown_counter_ += 1; + return true; + } + +private: + int *shutdown_counter_; + std::shared_ptr>> logs_received_; + size_t *batch_size_received; +}; + +// Tests whether the simple processor successfully creates a batch of size 1 +// and whether the contents of the record is sent to the exporter correctly +TEST(SimpleLogProcessorTest, SendReceivedLogsToExporter) +{ + // Create a simple processor with a TestExporter attached + std::shared_ptr>> logs_received( + new std::vector>); + size_t batch_size_received = 0; + + std::unique_ptr exporter( + new TestExporter(nullptr, logs_received, &batch_size_received)); + + SimpleLogProcessor processor(std::move(exporter)); + + // Send some log records to the processor (which should then send to the TestExporter) + const int num_logs = 5; + for (int i = 0; i < num_logs; i++) + { + auto recordable = processor.MakeRecordable(); + recordable->SetBody("Log Body"); + processor.OnReceive(std::move(recordable)); + + // Verify that the batch of 1 log record sent by processor matches what exporter received + EXPECT_EQ(1, batch_size_received); + } + + // Test whether the processor's log sent matches the log record received by the exporter + EXPECT_EQ(logs_received->size(), num_logs); + for (int i = 0; i < num_logs; i++) + { + EXPECT_EQ("Log Body", logs_received->at(i)->GetBody()); + } +} + +// Tests behavior when calling the processor's ShutDown() multiple times +TEST(SimpleLogProcessorTest, ShutdownCalledOnce) +{ + // Create a TestExporter + int num_shutdowns = 0; + + std::unique_ptr exporter(new TestExporter(&num_shutdowns, nullptr, nullptr)); + + // Create a processor with the previous test exporter + SimpleLogProcessor processor(std::move(exporter)); + + // The first time processor shutdown is called + EXPECT_EQ(0, num_shutdowns); + EXPECT_EQ(true, processor.Shutdown()); + EXPECT_EQ(1, num_shutdowns); + + EXPECT_EQ(true, processor.Shutdown()); + // Processor::ShutDown(), even if called more than once, should only shutdown exporter once + EXPECT_EQ(1, num_shutdowns); +} + +// A test exporter that always returns failure when shut down +class FailShutDownExporter final : public LogExporter +{ +public: + FailShutDownExporter() {} + + std::unique_ptr MakeRecordable() noexcept override + { + return std::unique_ptr(new LogRecord()); + } + + ExportResult Export(const nostd::span> &records) noexcept override + { + return ExportResult::kSuccess; + } + + bool Shutdown(std::chrono::microseconds timeout) noexcept override { return false; } +}; + +// Tests for when when processor should fail to shutdown +TEST(SimpleLogProcessorTest, ShutDownFail) +{ + std::unique_ptr exporter(new FailShutDownExporter()); + SimpleLogProcessor processor(std::move(exporter)); + + // Expect failure result when exporter fails to shutdown + EXPECT_EQ(false, processor.Shutdown()); +} +#endif -- cgit v1.2.3