Files
moloapp/tests/src/observability/tracing_test.cpp
T

235 lines
9.3 KiB
C++
Raw Normal View History

// Tracing core: IDs, samplers, span lifecycle, attribute caps,
// null-span fast path, redaction.
#include <cstdint>
#include <memory>
#include <string>
#include "observability/config.h"
#include "observability/tracing/batch_processor.h"
#include "observability/tracing/ids.h"
#include "observability/tracing/memory_exporter.h"
#include "observability/tracing/sampler.h"
#include "observability/tracing/span.h"
#include "observability/tracing/span_context.h"
#include "observability/tracing/tracer.h"
#include "test_helper.h"
int main() {
TestCtx ctx;
// IDs: generation, hex round trip, strict parsing.
{
auto trace = molo::trace::TraceId::generate();
auto span = molo::trace::SpanId::generate();
CHECK(ctx, trace.valid());
CHECK(ctx, span.valid());
CHECK(ctx, trace.to_hex().size() == 32);
CHECK(ctx, span.to_hex().size() == 16);
auto back = molo::trace::TraceId::from_hex(trace.to_hex());
CHECK(ctx, back.has_value() && *back == trace);
auto back_span = molo::trace::SpanId::from_hex(span.to_hex());
CHECK(ctx, back_span.has_value() && *back_span == span);
CHECK(ctx, !molo::trace::TraceId::from_hex("short").has_value());
CHECK(ctx, !molo::trace::TraceId::from_hex(std::string(32, 'z')).has_value());
CHECK(ctx, !molo::trace::SpanId::from_hex("short").has_value());
auto zero = molo::trace::TraceId::from_hex("00000000000000000000000000000000");
CHECK(ctx, zero.has_value() && !zero->valid());
auto flags = molo::trace::TraceFlags::from_hex("01");
CHECK(ctx, flags.has_value() && flags->is_sampled());
auto flags0 = molo::trace::TraceFlags::from_hex("00");
CHECK(ctx, flags0.has_value() && !flags0->is_sampled());
CHECK(ctx, !molo::trace::TraceFlags::from_hex("0").has_value());
CHECK(ctx, !molo::trace::TraceFlags::from_hex("zz").has_value());
molo::trace::SpanContext invalid = molo::trace::SpanContext::invalid();
CHECK(ctx, !invalid.is_valid());
CHECK(ctx, !invalid.is_sampled());
}
// Samplers.
{
molo::trace::AlwaysOnSampler on;
molo::trace::AlwaysOffSampler off;
auto id = molo::trace::TraceId::generate();
CHECK(ctx, on.should_sample(id));
CHECK(ctx, !off.should_sample(id));
CHECK(ctx, on.name() == "always_on");
molo::trace::RatioSampler half(0.5);
const int total = 100000;
int kept = 0;
for (int i = 0; i < total; ++i) {
if (half.should_sample(molo::trace::TraceId::generate())) ++kept;
}
double rate = static_cast<double>(kept) / static_cast<double>(total);
CHECK(ctx, rate > 0.45 && rate < 0.55);
auto fixed = molo::trace::TraceId::generate();
CHECK(ctx, half.should_sample(fixed) == half.should_sample(fixed));
molo::trace::RatioSampler none(0.0);
molo::trace::RatioSampler all(1.0);
CHECK(ctx, !none.should_sample(fixed));
CHECK(ctx, all.should_sample(fixed));
}
// Span lifecycle with parent and child linkage.
{
auto exporter = std::make_shared<molo::trace::MemoryExporter>();
molo::trace::BatchProcessor processor(exporter);
molo::trace::Tracer tracer("test", std::make_shared<molo::trace::AlwaysOnSampler>(),
&processor);
{
molo::trace::Span parent =
tracer.start_span("GET /items/{id}", molo::trace::SpanKind::Server);
CHECK(ctx, parent.valid());
parent.set_attribute("http.request.method", std::string("GET"));
parent.set_attribute("http.response.status_code", std::int64_t(200));
parent.set_attribute("ratio", 0.25);
parent.set_attribute("cached", true);
parent.add_event("db.start");
{
molo::trace::Span child =
tracer.start_span("db.query", molo::trace::SpanKind::Client, parent.context());
CHECK(ctx, child.valid());
CHECK(ctx, child.context().trace_id == parent.context().trace_id);
CHECK(ctx, child.context().span_id != parent.context().span_id);
child.set_status(molo::trace::StatusCode::Ok);
}
parent.set_status(molo::trace::StatusCode::Ok);
parent.end();
parent.end();
}
processor.flush();
auto spans = exporter->spans();
CHECK(ctx, spans.size() == 2);
const molo::trace::FinishedSpan* server = nullptr;
const molo::trace::FinishedSpan* client = nullptr;
for (const auto& span : spans) {
if (span.kind == molo::trace::SpanKind::Server) server = &span;
if (span.kind == molo::trace::SpanKind::Client) client = &span;
}
CHECK(ctx, server != nullptr && client != nullptr);
CHECK(ctx, server->name == "GET /items/{id}");
CHECK(ctx, client->parent_span_id == server->context.span_id);
CHECK(ctx, !server->parent_span_id.valid());
CHECK(ctx, server->attributes.size() == 4);
CHECK(ctx, server->events.size() == 1);
CHECK(ctx, server->status == molo::trace::StatusCode::Ok);
CHECK(ctx, server->end >= server->start);
CHECK(ctx, !server->attributes_truncated);
CHECK(ctx, tracer.spans_started() == 2);
}
// Attribute and event caps with truncation flags.
{
auto exporter = std::make_shared<molo::trace::MemoryExporter>();
molo::trace::BatchProcessor processor(exporter);
molo::trace::Tracer tracer("caps", std::make_shared<molo::trace::AlwaysOnSampler>(),
&processor);
molo::trace::Span span = tracer.start_span("caps");
for (int i = 0; i < 70; ++i) {
span.set_attribute("k" + std::to_string(i), std::int64_t(i));
}
span.set_attribute("big", std::string(2000, 'v'));
for (int i = 0; i < 40; ++i) span.add_event("e" + std::to_string(i));
span.end();
processor.flush();
auto spans = exporter->spans();
CHECK(ctx, spans.size() == 1);
CHECK(ctx, spans[0].attributes.size() == 64);
CHECK(ctx, spans[0].attributes_truncated);
CHECK(ctx, spans[0].events.size() == 32);
CHECK(ctx, spans[0].events_truncated);
}
// Attribute value truncation at 1024 bytes.
{
auto exporter = std::make_shared<molo::trace::MemoryExporter>();
molo::trace::BatchProcessor processor(exporter);
molo::trace::Tracer tracer("trunc", std::make_shared<molo::trace::AlwaysOnSampler>(),
&processor);
molo::trace::Span span = tracer.start_span("trunc");
span.set_attribute("long", std::string(2000, 'w'));
span.end();
processor.flush();
auto spans = exporter->spans();
CHECK(ctx, spans.size() == 1);
auto* text = std::get_if<std::string>(&spans[0].attributes[0].value);
CHECK(ctx, text != nullptr && text->size() == 1024);
CHECK(ctx, spans[0].attributes_truncated);
}
// Unsampled spans are null but carry a propagatable context.
{
auto exporter = std::make_shared<molo::trace::MemoryExporter>();
molo::trace::BatchProcessor processor(exporter);
molo::trace::Tracer tracer("unsampled", std::make_shared<molo::trace::AlwaysOffSampler>(),
&processor);
molo::trace::Span span = tracer.start_span("dropped");
CHECK(ctx, !span.valid());
CHECK(ctx, span.context().is_valid());
CHECK(ctx, !span.context().is_sampled());
span.set_attribute("k", std::int64_t(1));
span.end();
processor.flush();
CHECK(ctx, exporter->spans().empty());
}
// Sampling decision is inherited from the parent (immutable per trace).
{
auto exporter = std::make_shared<molo::trace::MemoryExporter>();
molo::trace::BatchProcessor processor(exporter);
molo::trace::Tracer tracer("inherit", std::make_shared<molo::trace::AlwaysOffSampler>(),
&processor);
molo::trace::SpanContext sampled_parent;
sampled_parent.trace_id = molo::trace::TraceId::generate();
sampled_parent.span_id = molo::trace::SpanId::generate();
sampled_parent.flags.value = molo::trace::TraceFlags::kSampled;
molo::trace::Span child =
tracer.start_span("child", molo::trace::SpanKind::Internal, sampled_parent);
CHECK(ctx, child.valid());
CHECK(ctx, child.context().is_sampled());
child.end();
}
// Secrets in attributes are redacted.
{
auto exporter = std::make_shared<molo::trace::MemoryExporter>();
molo::trace::BatchProcessor processor(exporter);
molo::trace::Tracer tracer("redact", std::make_shared<molo::trace::AlwaysOnSampler>(),
&processor);
molo::trace::Span span = tracer.start_span("redact");
span.set_attribute("auth_token", std::string("abc"));
span.end();
processor.flush();
auto spans = exporter->spans();
CHECK(ctx, spans.size() == 1);
auto* text = std::get_if<std::string>(&spans[0].attributes[0].value);
CHECK(ctx, text != nullptr && *text == "***");
}
// Disabled runtime and missing processor yield null spans and count drops.
{
molo::trace::Tracer tracer("off");
molo::trace::Span span = tracer.start_span("x");
CHECK(ctx, !span.valid());
CHECK(ctx, tracer.spans_dropped() == 1);
auto exporter = std::make_shared<molo::trace::MemoryExporter>();
molo::trace::BatchProcessor processor(exporter);
tracer.set_processor(&processor);
molo::obs::RuntimeToggles::instance().tracing.store(false);
molo::trace::Span span2 = tracer.start_span("y");
molo::obs::RuntimeToggles::instance().tracing.store(true);
CHECK(ctx, !span2.valid());
molo::trace::Span span3 = tracer.start_span("z");
CHECK(ctx, span3.valid());
span3.end();
}
CHECK(ctx, molo::trace::span_kind_name(molo::trace::SpanKind::Server) == "server");
return test_summary(ctx, "tracing");
}