diff --git a/include/datadog/sampling_decision.h b/include/datadog/sampling_decision.h index cfccbf74..003cfe08 100644 --- a/include/datadog/sampling_decision.h +++ b/include/datadog/sampling_decision.h @@ -38,7 +38,7 @@ struct SamplingDecision { Optional limiter_effective_rate; // The per-second maximum allowed number of "keeps" configured for the limiter // consulted in this decision, if any. - Optional limiter_max_per_second; + Optional limiter_max_per_second; // The provenance of this decision. Origin origin; }; diff --git a/include/datadog/span_sampler_config.h b/include/datadog/span_sampler_config.h index d23228bd..33d857c4 100644 --- a/include/datadog/span_sampler_config.h +++ b/include/datadog/span_sampler_config.h @@ -23,7 +23,7 @@ namespace tracing { struct SpanSamplerConfig { struct Rule : public SpanMatcher { double sample_rate = 1.0; - Optional max_per_second; + Optional max_per_second; Rule(const SpanMatcher&); Rule() = default; @@ -45,7 +45,7 @@ class FinalizedSpanSamplerConfig { public: struct Rule : public SpanMatcher { Rate sample_rate; - Optional max_per_second; + Optional max_per_second; }; std::vector rules; diff --git a/include/datadog/trace_sampler_config.h b/include/datadog/trace_sampler_config.h index 07a2ff53..3339171c 100644 --- a/include/datadog/trace_sampler_config.h +++ b/include/datadog/trace_sampler_config.h @@ -36,7 +36,7 @@ struct TraceSamplerConfig { Optional sample_rate; std::vector rules; - Optional max_per_second; + Optional max_per_second; }; class FinalizedTraceSamplerConfig { @@ -47,7 +47,7 @@ class FinalizedTraceSamplerConfig { FinalizedTraceSamplerConfig() = default; public: - double max_per_second; + int max_per_second; std::vector rules; std::unordered_map metadata; }; diff --git a/src/datadog/span_sampler.cpp b/src/datadog/span_sampler.cpp index 734053c0..5663887d 100644 --- a/src/datadog/span_sampler.cpp +++ b/src/datadog/span_sampler.cpp @@ -10,7 +10,7 @@ namespace datadog { namespace tracing { SpanSampler::SynchronizedLimiter::SynchronizedLimiter(const Clock& clock, - double max_per_second) + int max_per_second) : limiter(clock, max_per_second) {} SpanSampler::Rule::Rule(const FinalizedSpanSamplerConfig::Rule& rule, diff --git a/src/datadog/span_sampler.h b/src/datadog/span_sampler.h index 0d4f09a2..52530ce9 100644 --- a/src/datadog/span_sampler.h +++ b/src/datadog/span_sampler.h @@ -37,7 +37,7 @@ class SpanSampler { std::mutex mutex; Limiter limiter; - SynchronizedLimiter(const Clock&, double max_per_second); + SynchronizedLimiter(const Clock&, int max_per_second); }; class Rule : public FinalizedSpanSamplerConfig::Rule { diff --git a/src/datadog/span_sampler_config.cpp b/src/datadog/span_sampler_config.cpp index f16c61b0..c19a95a2 100644 --- a/src/datadog/span_sampler_config.cpp +++ b/src/datadog/span_sampler_config.cpp @@ -254,12 +254,8 @@ Expected finalize_config( return error->with_prefix(prefix); } - const auto allowed_types = {FP_NORMAL, FP_SUBNORMAL}; if (rule.max_per_second && - (!(*rule.max_per_second > 0) || - std::find(std::begin(allowed_types), std::end(allowed_types), - std::fpclassify(*rule.max_per_second)) == - std::end(allowed_types))) { + (!(*rule.max_per_second > 0))) { std::string message; message += "Span sampling rule with pattern "; message += nlohmann::json(static_cast(rule)).dump(); diff --git a/src/datadog/trace_sampler.h b/src/datadog/trace_sampler.h index 034e6f31..bc0291bf 100644 --- a/src/datadog/trace_sampler.h +++ b/src/datadog/trace_sampler.h @@ -110,7 +110,7 @@ class TraceSampler { std::unordered_map collector_sample_rates_; std::vector rules_; Limiter limiter_; - double limiter_max_per_second_; + int limiter_max_per_second_; public: TraceSampler(const FinalizedTraceSamplerConfig& config, const Clock& clock); diff --git a/src/datadog/trace_sampler_config.cpp b/src/datadog/trace_sampler_config.cpp index 9216a0e6..50eb116a 100644 --- a/src/datadog/trace_sampler_config.cpp +++ b/src/datadog/trace_sampler_config.cpp @@ -118,7 +118,7 @@ Expected load_trace_sampler_env_config() { } if (auto limit_env = lookup(environment::DD_TRACE_RATE_LIMIT)) { - auto maybe_max_per_second = parse_double(*limit_env); + auto maybe_max_per_second = parse_int(*limit_env, 10); if (auto *error = maybe_max_per_second.if_error()) { std::string prefix; prefix += "While parsing "; @@ -224,14 +224,11 @@ Expected finalize_config( } const auto [origin, max_per_second] = - pick(env_config->max_per_second, config.max_per_second, 200); + pick(env_config->max_per_second, config.max_per_second, 100); result.metadata[ConfigName::TRACE_SAMPLING_LIMIT] = ConfigMetadata( ConfigName::TRACE_SAMPLING_LIMIT, std::to_string(max_per_second), origin); - const auto allowed_types = {FP_NORMAL, FP_SUBNORMAL}; - if (!(max_per_second > 0) || - std::find(std::begin(allowed_types), std::end(allowed_types), - std::fpclassify(max_per_second)) == std::end(allowed_types)) { + if (!(max_per_second > 0)) { std::string message; message += "Trace sampling max_per_second must be greater than zero, but the " diff --git a/test/test_span_sampler.cpp b/test/test_span_sampler.cpp index 298ee72b..3c4b1065 100644 --- a/test/test_span_sampler.cpp +++ b/test/test_span_sampler.cpp @@ -48,7 +48,7 @@ namespace { struct SpanSamplingTags { Optional mechanism; Optional rule_rate; - Optional max_per_second; + Optional max_per_second; }; SpanSamplingTags span_sampling_tags(const SpanData& span) { @@ -292,7 +292,7 @@ TEST_CASE("span rule limiter") { struct TestCase { std::string name; std::size_t num_spans; - Optional max_per_second; + Optional max_per_second; std::size_t expected_count; }; diff --git a/test/test_trace_sampler.cpp b/test/test_trace_sampler.cpp index 10704cf9..0266d230 100644 --- a/test/test_trace_sampler.cpp +++ b/test/test_trace_sampler.cpp @@ -105,14 +105,14 @@ TEST_CASE("trace sampling rate limiter") { // second does not exceed that allowed by the configured limit. struct TestCase { std::string name; - double max_per_second; + int max_per_second; std::size_t burst_size; std::size_t expected_kept_count; }; - auto test_case = GENERATE(values({{"allow one", 1.0, 100, 1}, - {"allow all", 100.0, 100, 100}, - {"allow some", 10.0, 100, 10}})); + auto test_case = GENERATE(values({{"allow one", 1, 100, 1}, + {"allow all", 100, 100, 100}, + {"allow some", 10, 100, 10}})); CAPTURE(test_case.name); CAPTURE(test_case.max_per_second); diff --git a/test/test_tracer_config.cpp b/test/test_tracer_config.cpp index 1050e216..4c7e6811 100644 --- a/test/test_tracer_config.cpp +++ b/test/test_tracer_config.cpp @@ -707,16 +707,16 @@ TEST_CASE("TracerConfig::trace_sampler") { } SECTION("max_per_second") { - SECTION("defaults to 200") { + SECTION("defaults to 100") { auto finalized = finalize_config(config); REQUIRE(finalized); - REQUIRE(finalized->trace_sampler.max_per_second == 200); + REQUIRE(finalized->trace_sampler.max_per_second == 100); } SECTION("must be >0 and a finite number") { auto limit = GENERATE(0.0, -1.0, std::nan(""), - std::numeric_limits::infinity(), - -std::numeric_limits::infinity()); + std::numeric_limits::infinity(), + -std::numeric_limits::infinity()); CAPTURE(limit); CAPTURE(std::fpclassify(limit)); @@ -744,9 +744,11 @@ TEST_CASE("TracerConfig::trace_sampler") { }; auto test_case = GENERATE(values({ - {"nonsense", "nonsense", {Error::INVALID_DOUBLE}}, - {"trailing space", "23 ", {Error::INVALID_DOUBLE}}, - {"out of range of double", "123e9999999999", {Error::INVALID_DOUBLE}}, + {"nonsense", "nonsense", {Error::INVALID_INTEGER}}, + {"trailing space", "23 ", {Error::INVALID_INTEGER}}, + {"out of range of double", + "123e9999999999", + {Error::INVALID_INTEGER}}, // Some C++ standard libraries parse "nan" and "inf" as the // corresponding special floating point values. Other standard // libraries consider "nan" and "inf" invalid. @@ -755,17 +757,17 @@ TEST_CASE("TracerConfig::trace_sampler") { // (0.0, Inf) allowed. {"NaN", "NaN", - {Error::INVALID_DOUBLE, Error::MAX_PER_SECOND_OUT_OF_RANGE}}, + {Error::INVALID_INTEGER, Error::MAX_PER_SECOND_OUT_OF_RANGE}}, {"nan", "nan", - {Error::INVALID_DOUBLE, Error::MAX_PER_SECOND_OUT_OF_RANGE}}, + {Error::INVALID_INTEGER, Error::MAX_PER_SECOND_OUT_OF_RANGE}}, {"inf", "inf", - {Error::INVALID_DOUBLE, Error::MAX_PER_SECOND_OUT_OF_RANGE}}, + {Error::INVALID_INTEGER, Error::MAX_PER_SECOND_OUT_OF_RANGE}}, {"Inf", "Inf", - {Error::INVALID_DOUBLE, Error::MAX_PER_SECOND_OUT_OF_RANGE}}, - {"below range", "-0.1", {Error::MAX_PER_SECOND_OUT_OF_RANGE}}, + {Error::INVALID_INTEGER, Error::MAX_PER_SECOND_OUT_OF_RANGE}}, + {"below range", "-0.1", {Error::INVALID_INTEGER}}, {"zero (also below range)", "0", {Error::MAX_PER_SECOND_OUT_OF_RANGE}}, @@ -926,7 +928,7 @@ TEST_CASE("TracerConfig::span_sampler") { "TracerConfig::span_sampler.rules") { SpanSamplerConfig::Rule config_rule; config_rule.service = "foosvc"; - config_rule.max_per_second = 9.2; + config_rule.max_per_second = 9; config.span_sampler.rules.push_back(config_rule); auto rules_json = R"json([ @@ -982,7 +984,7 @@ TEST_CASE("TracerConfig::span_sampler") { Error::RULE_WRONG_TYPE}, {"sample_rate must be a number", R"json([{"sample_rate": true}])json", Error::SPAN_SAMPLING_RULES_SAMPLE_RATE_WRONG_TYPE}, - {"max_per_second must be a number (or absent)", + {"max_per_second must be an integer (or absent)", R"json([{"max_per_second": false}])json", Error::SPAN_SAMPLING_RULES_MAX_PER_SECOND_WRONG_TYPE}, {"no unknown properties", R"json([{"extension": "denied!"}])json", @@ -1005,7 +1007,7 @@ TEST_CASE("TracerConfig::span_sampler") { // This rule will be overridden. SpanSamplerConfig::Rule config_rule; config_rule.service = "foosvc"; - config_rule.max_per_second = 9.2; + config_rule.max_per_second = 9; config.span_sampler.rules.push_back(config_rule); auto rules_file_json = R"json([