235 lines
9.3 KiB
C++
235 lines
9.3 KiB
C++
// 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");
|
||
|
|
}
|