// Tracing core: IDs, samplers, span lifecycle, attribute caps, // null-span fast path, redaction. #include #include #include #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(kept) / static_cast(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::BatchProcessor processor(exporter); molo::trace::Tracer tracer("test", std::make_shared(), &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::BatchProcessor processor(exporter); molo::trace::Tracer tracer("caps", std::make_shared(), &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::BatchProcessor processor(exporter); molo::trace::Tracer tracer("trunc", std::make_shared(), &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(&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::BatchProcessor processor(exporter); molo::trace::Tracer tracer("unsampled", std::make_shared(), &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::BatchProcessor processor(exporter); molo::trace::Tracer tracer("inherit", std::make_shared(), &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::BatchProcessor processor(exporter); molo::trace::Tracer tracer("redact", std::make_shared(), &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(&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::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"); }