1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
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 <gtest/gtest.h>
# include <chrono>
# include <thread>
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<std::vector<std::unique_ptr<LogRecord>>> logs_received,
size_t *batch_size_received)
: shutdown_counter_(shutdown_counter),
logs_received_(logs_received),
batch_size_received(batch_size_received)
{}
std::unique_ptr<Recordable> MakeRecordable() noexcept override
{
return std::unique_ptr<Recordable>(new LogRecord());
}
// Stores the names of the log records this exporter receives to an internal list
ExportResult Export(const nostd::span<std::unique_ptr<Recordable>> &records) noexcept override
{
*batch_size_received = records.size();
for (auto &record : records)
{
auto log_record = std::unique_ptr<LogRecord>(static_cast<LogRecord *>(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<std::vector<std::unique_ptr<LogRecord>>> 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<std::vector<std::unique_ptr<LogRecord>>> logs_received(
new std::vector<std::unique_ptr<LogRecord>>);
size_t batch_size_received = 0;
std::unique_ptr<TestExporter> 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<TestExporter> 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<Recordable> MakeRecordable() noexcept override
{
return std::unique_ptr<Recordable>(new LogRecord());
}
ExportResult Export(const nostd::span<std::unique_ptr<Recordable>> &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<FailShutDownExporter> exporter(new FailShutDownExporter());
SimpleLogProcessor processor(std::move(exporter));
// Expect failure result when exporter fails to shutdown
EXPECT_EQ(false, processor.Shutdown());
}
#endif
|
