From efd2a82dea5ec9becbbb77a48d2f51e3dc348121 Mon Sep 17 00:00:00 2001 From: Milan Garnier Date: Thu, 25 Jun 2026 15:20:33 +0200 Subject: [PATCH 1/4] Add DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT to config inversion --- include/datadog/environment.h | 1 + supported-configurations.json | 9 ++++++++- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/include/datadog/environment.h b/include/datadog/environment.h index 824e4a3aa..ff6ade3c7 100644 --- a/include/datadog/environment.h +++ b/include/datadog/environment.h @@ -52,6 +52,7 @@ namespace environment { ENV_DEFAULT_RESOLVED_IN_CODE("Defaults to process name when unset.")) \ MACRO(DD_SPAN_SAMPLING_RULES, ARRAY, "[]") \ MACRO(DD_SPAN_SAMPLING_RULES_FILE, STRING, "") \ + MACRO(DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT, STRING, "continue") \ MACRO(DD_TRACE_PROPAGATION_STYLE_EXTRACT, ARRAY, \ "datadog,tracecontext,baggage") \ MACRO(DD_TRACE_PROPAGATION_STYLE_INJECT, ARRAY, \ diff --git a/supported-configurations.json b/supported-configurations.json index 051ff8b5d..e7ac2d54e 100644 --- a/supported-configurations.json +++ b/supported-configurations.json @@ -203,6 +203,13 @@ "type": "boolean" } ], + "DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT": [ + { + "default": "continue", + "implementation": "B", + "type": "string" + } + ], "DD_TRACE_PROPAGATION_STYLE": [ { "default": "datadog,tracecontext,baggage", @@ -289,4 +296,4 @@ ] }, "version": "2" -} \ No newline at end of file +} From cedc91f8568bb6bf025ae24224e864570f699ca7 Mon Sep 17 00:00:00 2001 From: Milan Garnier Date: Wed, 1 Jul 2026 14:37:47 +0200 Subject: [PATCH 2/4] Add DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT to config --- BUILD.bazel | 2 + CMakeLists.txt | 2 + include/datadog/config.h | 1 + .../datadog/propagation_behavior_extract.h | 30 ++++++++++++++ include/datadog/tracer_config.h | 10 +++++ src/datadog/propagation_behavior_extract.cpp | 40 +++++++++++++++++++ src/datadog/telemetry/telemetry_impl.cpp | 2 + 7 files changed, 87 insertions(+) create mode 100644 include/datadog/propagation_behavior_extract.h create mode 100644 src/datadog/propagation_behavior_extract.cpp diff --git a/BUILD.bazel b/BUILD.bazel index 0b467a696..db6255ee2 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -42,6 +42,7 @@ cc_library( "src/datadog/parse_util.cpp", "src/datadog/parse_util.h", "src/datadog/platform_util.h", + "src/datadog/propagation_behavior_extract.cpp", "src/datadog/propagation_style.cpp", "src/datadog/random.cpp", "src/datadog/random.h", @@ -122,6 +123,7 @@ cc_library( "include/datadog/logger.h", "include/datadog/null_collector.h", "include/datadog/optional.h", + "include/datadog/propagation_behavior_extract.h", "include/datadog/propagation_style.h", "include/datadog/rate.h", "include/datadog/remote_config/capability.h", diff --git a/CMakeLists.txt b/CMakeLists.txt index 8a1bd78a1..bd8049bf2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -151,6 +151,7 @@ target_sources(dd-trace-cpp-objects include/datadog/logger.h include/datadog/null_collector.h include/datadog/optional.h + include/datadog/propagation_behavior_extract.h include/datadog/propagation_style.h include/datadog/rate.h include/datadog/runtime_id.h @@ -196,6 +197,7 @@ target_sources(dd-trace-cpp-objects src/datadog/logger.cpp src/datadog/msgpack.cpp src/datadog/parse_util.cpp + src/datadog/propagation_behavior_extract.cpp src/datadog/propagation_style.cpp src/datadog/random.cpp src/datadog/rate.cpp diff --git a/include/datadog/config.h b/include/datadog/config.h index c02dfd9f3..3489a69c2 100644 --- a/include/datadog/config.h +++ b/include/datadog/config.h @@ -21,6 +21,7 @@ enum class ConfigName : char { TAGS, EXTRACTION_STYLES, INJECTION_STYLES, + PROPAGATION_BEHAVIOR_EXTRACT, STARTUP_LOGS, REPORT_TELEMETRY, DELEGATE_SAMPLING, diff --git a/include/datadog/propagation_behavior_extract.h b/include/datadog/propagation_behavior_extract.h new file mode 100644 index 000000000..210d104a9 --- /dev/null +++ b/include/datadog/propagation_behavior_extract.h @@ -0,0 +1,30 @@ +#pragma once + +// This component provides an `enum class`, `PropagationBehaviorExtract`, that +// indicates a trace context extraction or injection format to be used. +// `TracerConfig` has one `std::vector` for extraction and +// another for injection. See `tracer_config.h`. + +#include "optional.h" +#include "string_view.h" + +namespace datadog { +namespace tracing { + +enum class PropagationBehaviorExtract { + // Propagate extract4ed context normally + CONTINUE, + // Restart a new trace (new sampling decision, no parent) + // Reference previous trace through a span-link + RESTART, + // Discard entirely incoming context + IGNORE, +}; + +StringView to_string_view(PropagationBehaviorExtract behavior); + +// defaults to CONTINUE if empty or unsupported +Optional parse_propagation_behavior_extract(StringView text); + +} // namespace tracing +} // namespace datadog diff --git a/include/datadog/tracer_config.h b/include/datadog/tracer_config.h index 4f9196dbd..77af6ca00 100644 --- a/include/datadog/tracer_config.h +++ b/include/datadog/tracer_config.h @@ -16,6 +16,7 @@ #include "datadog_agent_config.h" #include "expected.h" #include "http_endpoint_calculation_mode.h" +#include "propagation_behavior_extract.h" #include "propagation_style.h" #include "runtime_id.h" #include "span_defaults.h" @@ -107,6 +108,13 @@ struct TracerConfig { // environment variables. Optional> extraction_styles; + // `propagation_behavior_extract` indicates how to handle incoming trace context. + // `continue`: default behavior, all trace contexts are propagated. + // `restart`: restart a new trace (new sampling decision) with a span link to the remote one. baggage is propagated. + // `ignore`: discard entirely any existing trace context and start a new trace. + // Overridden by DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT + Optional propagation_behavior_extract; + // `report_hostname` indicates whether the tracer will include the result of // `gethostname` with traces sent to the collector. Optional report_hostname; @@ -224,6 +232,8 @@ class FinalizedTracerConfig final { std::vector injection_styles; std::vector extraction_styles; + Optional propagation_behavior_extract; + bool report_hostname; std::size_t tags_header_size; std::shared_ptr logger; diff --git a/src/datadog/propagation_behavior_extract.cpp b/src/datadog/propagation_behavior_extract.cpp new file mode 100644 index 000000000..ea5eed794 --- /dev/null +++ b/src/datadog/propagation_behavior_extract.cpp @@ -0,0 +1,40 @@ +#include + +#include + +#include "json.hpp" +#include "string_util.h" + +namespace datadog { +namespace tracing { + +StringView to_string_view(PropagationBehaviorExtract behavior) { + switch (behavior) { + case PropagationBehaviorExtract::CONTINUE: + return "continue"; + case PropagationBehaviorExtract::RESTART: + return "restart"; + case PropagationBehaviorExtract::IGNORE: + return "ignore"; + } +} + +nlohmann::json to_json(PropagationBehaviorExtract behavior) { return to_string_view(behavior); } + + +Optional parse_propagation_behavior_extract(StringView text) { + auto token = std::string{text}; + to_lower(token); + + if (token == "continue" || token.empty()) { + return PropagationBehaviorExtract::CONTINUE; + } else if (token == "restart") { + return PropagationBehaviorExtract::RESTART; + } else if (token == "ignore") { + return PropagationBehaviorExtract::IGNORE; + } + return nullopt; +} + +} // namespace tracing +} // namespace datadog diff --git a/src/datadog/telemetry/telemetry_impl.cpp b/src/datadog/telemetry/telemetry_impl.cpp index 9f1e99143..b76738f76 100644 --- a/src/datadog/telemetry/telemetry_impl.cpp +++ b/src/datadog/telemetry/telemetry_impl.cpp @@ -92,6 +92,8 @@ std::string to_string(datadog::tracing::ConfigName name) { return "trace_propagation_style_extract"; case ConfigName::INJECTION_STYLES: return "trace_propagation_style_inject"; + case ConfigName::PROPAGATION_BEHAVIOR_EXTRACT: + return "trace_propagation_behavior_extract"; case ConfigName::STARTUP_LOGS: return "trace_startup_logs_enabled"; case ConfigName::REPORT_TELEMETRY: From 932c5bc10abc6d38a26b59c7155dd085f0116adf Mon Sep 17 00:00:00 2001 From: Milan Garnier Date: Thu, 2 Jul 2026 12:39:39 +0200 Subject: [PATCH 3/4] Untested POC [compiles, does not support traceflags in span links yet] --- bin/check-format | 2 +- bin/cmake-build | 4 +- examples/http-server/proxy/proxy.cpp | 1 - .../datadog/propagation_behavior_extract.h | 3 +- include/datadog/tracer.h | 5 + include/datadog/tracer_config.h | 13 ++- src/datadog/extracted_data.h | 1 + src/datadog/propagation_behavior_extract.cpp | 8 +- src/datadog/span.cpp | 13 +-- src/datadog/tracer.cpp | 106 ++++++++++++------ src/datadog/tracer_config.cpp | 4 + src/datadog/w3c_propagation.cpp | 2 + 12 files changed, 105 insertions(+), 57 deletions(-) diff --git a/bin/check-format b/bin/check-format index 0a840785b..f7ce9c7db 100755 --- a/bin/check-format +++ b/bin/check-format @@ -1,4 +1,4 @@ #!/bin/sh find binding/ examples/ fuzz/ include/ src/ test/ -type f \( -name '*.h' -o -name '*.cpp' \) -print0 | \ - xargs -0 clang-format-14 --style=file --dry-run -Werror + xargs -0 clang-format --style=file --dry-run -Werror diff --git a/bin/cmake-build b/bin/cmake-build index 349269421..0c484f99d 100755 --- a/bin/cmake-build +++ b/bin/cmake-build @@ -6,5 +6,5 @@ cd "$(dirname "$0")"/.. mkdir -p .build cd .build -cmake .. "$@" -make -j "$(nproc)" +cmake -B . .. -DCMAKE_EXPORT_COMPILE_COMMANDS=ON "$@" +cmake --build . -j diff --git a/examples/http-server/proxy/proxy.cpp b/examples/http-server/proxy/proxy.cpp index 3941e869c..59fb5db67 100644 --- a/examples/http-server/proxy/proxy.cpp +++ b/examples/http-server/proxy/proxy.cpp @@ -5,7 +5,6 @@ #include #include -#include #include #include "datadog/cerr_logger.h" diff --git a/include/datadog/propagation_behavior_extract.h b/include/datadog/propagation_behavior_extract.h index 210d104a9..3305d96b8 100644 --- a/include/datadog/propagation_behavior_extract.h +++ b/include/datadog/propagation_behavior_extract.h @@ -24,7 +24,8 @@ enum class PropagationBehaviorExtract { StringView to_string_view(PropagationBehaviorExtract behavior); // defaults to CONTINUE if empty or unsupported -Optional parse_propagation_behavior_extract(StringView text); +Optional parse_propagation_behavior_extract( + StringView text); } // namespace tracing } // namespace datadog diff --git a/include/datadog/tracer.h b/include/datadog/tracer.h index 6a032a133..938f679ed 100644 --- a/include/datadog/tracer.h +++ b/include/datadog/tracer.h @@ -18,6 +18,7 @@ #include "expected.h" #include "id_generator.h" #include "optional.h" +#include "propagation_behavior_extract.h" #include "span.h" #include "span_config.h" #include "tracer_config.h" @@ -45,6 +46,7 @@ class Tracer { Clock clock_; std::vector injection_styles_; std::vector extraction_styles_; + PropagationBehaviorExtract propagation_behavior_extract_; Optional hostname_; std::size_t tags_header_max_size_; // Store the tracer configuration in an in-memory file, allowing it to be @@ -75,6 +77,9 @@ class Tracer { // `config`. If there is no tracing information in `reader`, then return an // error with code `Error::NO_SPAN_TO_EXTRACT`. If a failure occurs, then // return an error with some other code. + // Depending of the propagation_behavior_restart config, it can continue the + // trace, restart a new trace (with link), or discard the span (returning + // `Error::NO_SPAN_TO_EXTRACT`) Expected extract_span(const DictReader& reader); Expected extract_span(const DictReader& reader, const SpanConfig& config); diff --git a/include/datadog/tracer_config.h b/include/datadog/tracer_config.h index 77af6ca00..2c8b36adf 100644 --- a/include/datadog/tracer_config.h +++ b/include/datadog/tracer_config.h @@ -108,11 +108,12 @@ struct TracerConfig { // environment variables. Optional> extraction_styles; - // `propagation_behavior_extract` indicates how to handle incoming trace context. - // `continue`: default behavior, all trace contexts are propagated. - // `restart`: restart a new trace (new sampling decision) with a span link to the remote one. baggage is propagated. - // `ignore`: discard entirely any existing trace context and start a new trace. - // Overridden by DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT + // `propagation_behavior_extract` indicates how to handle incoming trace + // context. `continue`: default behavior, all trace contexts are propagated. + // `restart`: restart a new trace (new sampling decision) with a span link to + // the remote one. baggage is propagated. `ignore`: discard entirely any + // existing trace context and start a new trace. Overridden by + // DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT Optional propagation_behavior_extract; // `report_hostname` indicates whether the tracer will include the result of @@ -232,7 +233,7 @@ class FinalizedTracerConfig final { std::vector injection_styles; std::vector extraction_styles; - Optional propagation_behavior_extract; + PropagationBehaviorExtract propagation_behavior_extract; bool report_hostname; std::size_t tags_header_size; diff --git a/src/datadog/extracted_data.h b/src/datadog/extracted_data.h index b2d17c303..a26274d78 100644 --- a/src/datadog/extracted_data.h +++ b/src/datadog/extracted_data.h @@ -40,6 +40,7 @@ struct ExtractedData { Optional additional_datadog_w3c_tracestate; // `style` is the extraction style used to obtain this `ExtractedData`. It's // for diagnostics. + Optional tracestate_full; Optional style; // `headers_examined` are the name/value pairs of HTTP headers (or equivalent // request meta-data) that were looked up and had values during the diff --git a/src/datadog/propagation_behavior_extract.cpp b/src/datadog/propagation_behavior_extract.cpp index ea5eed794..fe09c01ce 100644 --- a/src/datadog/propagation_behavior_extract.cpp +++ b/src/datadog/propagation_behavior_extract.cpp @@ -19,10 +19,12 @@ StringView to_string_view(PropagationBehaviorExtract behavior) { } } -nlohmann::json to_json(PropagationBehaviorExtract behavior) { return to_string_view(behavior); } - +nlohmann::json to_json(PropagationBehaviorExtract behavior) { + return to_string_view(behavior); +} -Optional parse_propagation_behavior_extract(StringView text) { +Optional parse_propagation_behavior_extract( + StringView text) { auto token = std::string{text}; to_lower(token); diff --git a/src/datadog/span.cpp b/src/datadog/span.cpp index b402c3ca0..7b8bc28f9 100644 --- a/src/datadog/span.cpp +++ b/src/datadog/span.cpp @@ -166,10 +166,8 @@ void Span::set_source(Source source) { } void Span::add_link(const Span& linked, const SpanLinkAttributes& attrs) { - SpanLink link; - link.trace_id = linked.trace_id(); - link.span_id = linked.id(); - link.attributes = attrs; + Optional tracestate = nullopt; + Optional flags = nullopt; // Capture injected headers (tracestate, traceparent flags) into a map. struct : DictWriter { @@ -180,21 +178,20 @@ void Span::add_link(const Span& linked, const SpanLinkAttributes& attrs) { } w; linked.inject(w); if (auto it = w.map.find("tracestate"); it != w.map.end()) { - link.tracestate = it->second; + tracestate = it->second; } if (auto it = w.map.find("traceparent"); it != w.map.end()) { const auto& tp = it->second; const auto pos = tp.rfind('-'); if (pos != std::string::npos && pos + 1 < tp.size()) { try { - link.flags = static_cast( + flags = static_cast( std::stoul(tp.substr(pos + 1), nullptr, 16)); } catch (...) { } } } - - data_->span_links.push_back(std::move(link)); + add_link(SpanLink{linked.trace_id(), linked.id(), tracestate, attrs, flags}); } void Span::add_link(const SpanLink& link) { data_->span_links.push_back(link); } diff --git a/src/datadog/tracer.cpp b/src/datadog/tracer.cpp index 4209ac228..a03750b60 100644 --- a/src/datadog/tracer.cpp +++ b/src/datadog/tracer.cpp @@ -61,6 +61,7 @@ Tracer::Tracer(const FinalizedTracerConfig& config, clock_(config.clock), injection_styles_(config.injection_styles), extraction_styles_(config.extraction_styles), + propagation_behavior_extract_(config.propagation_behavior_extract), tags_header_max_size_(config.tags_header_size), baggage_opts_(config.baggage_opts), baggage_injection_enabled_(false), @@ -86,10 +87,12 @@ Tracer::Tracer(const FinalizedTracerConfig& config, collector_ = agent; } - for (const auto style : extraction_styles_) { - if (style == PropagationStyle::BAGGAGE) { - baggage_extraction_enabled_ = true; - break; + if (propagation_behavior_extract_ != PropagationBehaviorExtract::IGNORE) { + for (const auto style : extraction_styles_) { + if (style == PropagationStyle::BAGGAGE) { + baggage_extraction_enabled_ = true; + break; + } } } @@ -172,7 +175,7 @@ void Tracer::store_config( // clang-format off msgpack::pack_map( - buffer, + buffer, "schema_version", [&](auto& buffer) { msgpack::pack_integer(buffer, std::uint64_t(2)); return Expected{}; }, "runtime_id", [&](auto& buffer) { return msgpack::pack_string(buffer, runtime_id_.string()); }, "tracer_version", [&](auto& buffer) { return msgpack::pack_string(buffer, signature_.library_version); }, @@ -229,6 +232,13 @@ Expected Tracer::extract_span(const DictReader& reader) { Expected Tracer::extract_span(const DictReader& reader, const SpanConfig& config) { + // ignore: Discard incoming context, new span with new sampling decision + if (propagation_behavior_extract_ == PropagationBehaviorExtract::IGNORE) { + return Error{ + Error::NO_SPAN_TO_EXTRACT, + "Ignoring context extraction (propagation_behavior_extract=ignore)"}; + } + assert(!extraction_styles_.empty()); AuditedReader audited_reader{reader}; @@ -417,37 +427,63 @@ Expected Tracer::extract_span(const DictReader& reader, merged_context.trace_tags.erase(found); } - // When APM Tracing is disabled, the incoming sampling decision MAY be - // overridden based on locally generated spans. As such, the received sampling - // decision is intentionally ignored, and the tracer is expected to make its - // own decision in accordance with the locally enabled product configuration. - Optional sampling_decision; - if (tracing_enabled_ && merged_context.sampling_priority) { - SamplingDecision decision; - decision.priority = *merged_context.sampling_priority; - // `decision.mechanism` is null. We might be able to infer it once we - // extract `trace_tags`, but we would have no use for it, so we won't. - decision.origin = SamplingDecision::Origin::EXTRACTED; - - sampling_decision = decision; - } + switch (propagation_behavior_extract_) { + case PropagationBehaviorExtract::CONTINUE: { + // When APM Tracing is disabled, the incoming sampling decision MAY be + // overridden based on locally generated spans. As such, the received + // sampling decision is intentionally ignored, and the tracer is expected + // to make its own decision in accordance with the locally enabled product + // configuration. + Optional sampling_decision; + if (tracing_enabled_ && merged_context.sampling_priority) { + SamplingDecision decision; + decision.priority = *merged_context.sampling_priority; + // `decision.mechanism` is null. We might be able to infer it once we + // extract `trace_tags`, but we would have no use for it, so we won't. + decision.origin = SamplingDecision::Origin::EXTRACTED; + sampling_decision = decision; + } - const auto span_data_ptr = span_data.get(); - telemetry::counter::increment(metrics::tracer::trace_segments_created, - {"new_continued:continued"}); - const auto segment = std::make_shared( - logger_, collector_, config_manager_->trace_sampler(), span_sampler_, - config_manager_->span_defaults(), config_manager_, runtime_id_, - injection_styles_, hostname_, std::move(merged_context.origin), - tags_header_max_size_, std::move(merged_context.trace_tags), - std::move(sampling_decision), - std::move(merged_context.additional_w3c_tracestate), - std::move(merged_context.additional_datadog_w3c_tracestate), - std::move(span_data), resource_renaming_mode_, tracing_enabled_); - Span span{span_data_ptr, segment, - [generator = generator_]() { return generator->span_id(); }, - clock_}; - return span; + const auto span_data_ptr = span_data.get(); + telemetry::counter::increment(metrics::tracer::trace_segments_created, + {"new_continued:continued"}); + const auto segment = std::make_shared( + logger_, collector_, config_manager_->trace_sampler(), span_sampler_, + config_manager_->span_defaults(), config_manager_, runtime_id_, + injection_styles_, hostname_, std::move(merged_context.origin), + tags_header_max_size_, std::move(merged_context.trace_tags), + std::move(sampling_decision), + std::move(merged_context.additional_w3c_tracestate), + std::move(merged_context.additional_datadog_w3c_tracestate), + std::move(span_data), resource_renaming_mode_, tracing_enabled_); + + Span span{span_data_ptr, segment, + [generator = generator_]() { return generator->span_id(); }, + clock_}; + return span; + } + case PropagationBehaviorExtract::RESTART: { + // restart: create a new trace, with a span link to the previous one + + auto link_attributes = SpanLinkAttributes{}; + link_attributes.emplace("reason", "propagation_behavior_extract"); + link_attributes.emplace("context_headers", "todo"); + + auto tracestate = + extracted_contexts[PropagationStyle::W3C].tracestate_full; + + auto restarted_span = create_span(config); + restarted_span.add_link(SpanLink{span_data->trace_id, span_data->span_id, + tracestate, link_attributes, + nullopt}); // TODO: flags + return restarted_span; + } + default: + // Should be unreachable + return Error{ + Error::NO_SPAN_TO_EXTRACT, + "Ignoring context extraction (propagation_behavior_extract=ignore)"}; + } } Span Tracer::extract_or_create_span(const DictReader& reader) { diff --git a/src/datadog/tracer_config.cpp b/src/datadog/tracer_config.cpp index 1383ce478..728e05009 100644 --- a/src/datadog/tracer_config.cpp +++ b/src/datadog/tracer_config.cpp @@ -403,6 +403,10 @@ Expected finalize_config(const TracerConfig &user_config, final_config.injection_styles.erase(it); } + final_config.propagation_behavior_extract = + value_or(user_config.propagation_behavior_extract, + PropagationBehaviorExtract::CONTINUE); + final_config.runtime_id = user_config.runtime_id; final_config.root_session_id = user_config.root_session_id; final_config.process_tags = user_config.process_tags; diff --git a/src/datadog/w3c_propagation.cpp b/src/datadog/w3c_propagation.cpp index f6e1eb46e..26eb0a020 100644 --- a/src/datadog/w3c_propagation.cpp +++ b/src/datadog/w3c_propagation.cpp @@ -287,6 +287,8 @@ void extract_tracestate( } const auto tracestate = trim(*maybe_tracestate); + result.tracestate_full = tracestate; + auto maybe_parsed = parse_tracestate(tracestate); if (!maybe_parsed) { // No "dd" entry in `tracestate`, so there's nothing to extract. From 7bdf91bc39d7a68c1bc4a51c77ce665af7de0282 Mon Sep 17 00:00:00 2001 From: Milan Garnier Date: Tue, 7 Jul 2026 17:10:31 +0200 Subject: [PATCH 4/4] add branch for PropagationBehaviorExtract::to_string_view --- src/datadog/propagation_behavior_extract.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/datadog/propagation_behavior_extract.cpp b/src/datadog/propagation_behavior_extract.cpp index fe09c01ce..b0d3059d6 100644 --- a/src/datadog/propagation_behavior_extract.cpp +++ b/src/datadog/propagation_behavior_extract.cpp @@ -16,6 +16,8 @@ StringView to_string_view(PropagationBehaviorExtract behavior) { return "restart"; case PropagationBehaviorExtract::IGNORE: return "ignore"; + default: + std::abort(); } }