style: reformat with clang-format-14 (project standard)

Previous commits used clang-format-22 which uses left-aligned references
(Google style). The project uses clang-format-14 via ./bin/format which
keeps right-aligned references. This reverts the spurious & formatting
changes to existing code.

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: bm1549

src/datadog/span_sampler_config.cpp

@@ -15,9 +15,9 @@ namespace datadog {
 namespace tracing {
 namespace {
 
-std::string to_string(const std::vector<SpanSamplerConfig::Rule>& rules) {
+std::string to_string(const std::vector<SpanSamplerConfig::Rule> &rules) {
   nlohmann::json res;
-  for (const auto& r : rules) {
+  for (const auto &r : rules) {
     nlohmann::json j = r;
     j["sample_rate"] = r.sample_rate;
     if (r.max_per_second) {
@@ -38,7 +38,7 @@ Expected<std::vector<SpanSamplerConfig::Rule>> parse_rules(StringView rules_raw,
 
   try {
     json_rules = nlohmann::json::parse(rules_raw);
-  } catch (const nlohmann::json::parse_error& error) {
+  } catch (const nlohmann::json::parse_error &error) {
     std::string message;
     message += "Unable to parse JSON from ";
     append(message, env_var);
@@ -64,9 +64,9 @@ Expected<std::vector<SpanSamplerConfig::Rule>> parse_rules(StringView rules_raw,
   const std::unordered_set<std::string> allowed_properties{
       "service", "name", "resource", "tags", "sample_rate", "max_per_second"};
 
-  for (const auto& json_rule : json_rules) {
+  for (const auto &json_rule : json_rules) {
     auto matcher = from_json(json_rule);
-    if (auto* error = matcher.if_error()) {
+    if (auto *error = matcher.if_error()) {
       std::string prefix;
       prefix += "Unable to create a rule from ";
       append(prefix, env_var);
@@ -119,7 +119,7 @@ Expected<std::vector<SpanSamplerConfig::Rule>> parse_rules(StringView rules_raw,
     }
 
     // Look for unexpected properties.
-    for (const auto& [key, value] : json_rule.items()) {
+    for (const auto &[key, value] : json_rule.items()) {
       if (allowed_properties.count(key)) {
         continue;
       }
@@ -144,14 +144,14 @@ Expected<std::vector<SpanSamplerConfig::Rule>> parse_rules(StringView rules_raw,
   return rules;
 }
 
-Expected<SpanSamplerConfig> load_span_sampler_env_config(Logger& logger) {
+Expected<SpanSamplerConfig> load_span_sampler_env_config(Logger &logger) {
   SpanSamplerConfig env_config;
 
   auto rules_env = lookup(environment::DD_SPAN_SAMPLING_RULES);
   if (rules_env) {
     auto maybe_rules =
         parse_rules(*rules_env, name(environment::DD_SPAN_SAMPLING_RULES));
-    if (auto* error = maybe_rules.if_error()) {
+    if (auto *error = maybe_rules.if_error()) {
       return std::move(*error);
     }
     env_config.rules = std::move(*maybe_rules);
@@ -175,7 +175,7 @@ Expected<SpanSamplerConfig> load_span_sampler_env_config(Logger& logger) {
     } else {
       const auto span_rules_file = std::string(*file_env);
 
-      const auto file_error = [&](const char* operation) {
+      const auto file_error = [&](const char *operation) {
         std::string message;
         message += "Unable to ";
         message += operation;
@@ -200,7 +200,7 @@ Expected<SpanSamplerConfig> load_span_sampler_env_config(Logger& logger) {
 
       auto maybe_rules = parse_rules(
           rules_stream.str(), name(environment::DD_SPAN_SAMPLING_RULES_FILE));
-      if (auto* error = maybe_rules.if_error()) {
+      if (auto *error = maybe_rules.if_error()) {
         std::string prefix;
         prefix += "With ";
         append(prefix, name(environment::DD_SPAN_SAMPLING_RULES_FILE));
@@ -219,11 +219,11 @@ Expected<SpanSamplerConfig> load_span_sampler_env_config(Logger& logger) {
 
 }  // namespace
 
-SpanSamplerConfig::Rule::Rule(const SpanMatcher& base) : SpanMatcher(base) {}
+SpanSamplerConfig::Rule::Rule(const SpanMatcher &base) : SpanMatcher(base) {}
 
 Expected<FinalizedSpanSamplerConfig> finalize_config(
-    const SpanSamplerConfig& user_config, Logger& logger,
-    const StableConfigs* stable_configs) {
+    const SpanSamplerConfig &user_config, Logger &logger,
+    const StableConfigs *stable_configs) {
   Expected<SpanSamplerConfig> env_config = load_span_sampler_env_config(logger);
   if (auto error = env_config.if_error()) {
     return *error;
@@ -242,11 +242,11 @@ Expected<FinalizedSpanSamplerConfig> finalize_config(
   Optional<std::vector<SpanSamplerConfig::Rule>> fleet_rules;
   Optional<std::vector<SpanSamplerConfig::Rule>> local_rules;
   if (stable_configs) {
-    auto parse_span_rules = [](const StableConfig& cfg,
-                               const std::string& key) {
+    auto parse_span_rules = [](const StableConfig &cfg,
+                               const std::string &key) {
       return parse_stable_config_rules<SpanSamplerConfig::Rule, nlohmann::json>(
           cfg, key,
-          [](SpanSamplerConfig::Rule& rule, const nlohmann::json& json_rule) {
+          [](SpanSamplerConfig::Rule &rule, const nlohmann::json &json_rule) {
             if (auto mps = json_rule.find("max_per_second");
                 mps != json_rule.end() && mps->is_number()) {
               rule.max_per_second = *mps;
@@ -262,13 +262,13 @@ Expected<FinalizedSpanSamplerConfig> finalize_config(
   std::vector<SpanSamplerConfig::Rule> rules = resolve_and_record_config(
       fleet_rules, env_rules, user_rules, local_rules, &result.metadata,
       ConfigName::SPAN_SAMPLING_RULES, nullptr,
-      [](const std::vector<SpanSamplerConfig::Rule>& r) {
+      [](const std::vector<SpanSamplerConfig::Rule> &r) {
         return to_string(r);
       });
 
-  for (const auto& rule : rules) {
+  for (const auto &rule : rules) {
     auto maybe_rate = Rate::from(rule.sample_rate);
-    if (auto* error = maybe_rate.if_error()) {
+    if (auto *error = maybe_rate.if_error()) {
       std::string prefix;
       prefix +=
           "Unable to parse sample_rate in span sampling rule with span "
@@ -295,17 +295,17 @@ Expected<FinalizedSpanSamplerConfig> finalize_config(
     }
 
     FinalizedSpanSamplerConfig::Rule finalized;
-    static_cast<SpanMatcher&>(finalized) = rule;
+    static_cast<SpanMatcher &>(finalized) = rule;
     finalized.sample_rate = *maybe_rate;
     finalized.max_per_second = rule.max_per_second;
     result.rules.push_back(std::move(finalized));
   }
   return result;
 }
 
-std::string to_string(const FinalizedSpanSamplerConfig::Rule& rule) {
+std::string to_string(const FinalizedSpanSamplerConfig::Rule &rule) {
   // Get the base class's fields, then add our own.
-  nlohmann::json result = static_cast<const SpanMatcher&>(rule);
+  nlohmann::json result = static_cast<const SpanMatcher &>(rule);
   result["sample_rate"] = double(rule.sample_rate);
   if (rule.max_per_second) {
     result["max_per_second"] = *rule.max_per_second;

src/datadog/trace_sampler_config.cpp

@@ -23,7 +23,7 @@ Expected<TraceSamplerConfig> load_trace_sampler_env_config() {
     nlohmann::json json_rules;
     try {
       json_rules = nlohmann::json::parse(*rules_env);
-    } catch (const nlohmann::json::parse_error& error) {
+    } catch (const nlohmann::json::parse_error &error) {
       std::string message;
       message += "Unable to parse JSON from ";
       append(message, name(environment::DD_TRACE_SAMPLING_RULES));
@@ -50,9 +50,9 @@ Expected<TraceSamplerConfig> load_trace_sampler_env_config() {
     const std::unordered_set<std::string> allowed_properties{
         "service", "name", "resource", "tags", "sample_rate"};
 
-    for (const auto& json_rule : json_rules) {
+    for (const auto &json_rule : json_rules) {
       auto matcher = from_json(json_rule);
-      if (auto* error = matcher.if_error()) {
+      if (auto *error = matcher.if_error()) {
         std::string prefix;
         prefix += "Unable to create a rule from ";
         append(prefix, name(environment::DD_TRACE_SAMPLING_RULES));
@@ -85,7 +85,7 @@ Expected<TraceSamplerConfig> load_trace_sampler_env_config() {
       }
 
       // Look for unexpected properties.
-      for (const auto& [key, value] : json_rule.items()) {
+      for (const auto &[key, value] : json_rule.items()) {
         if (allowed_properties.count(key)) {
           continue;
         }
@@ -110,7 +110,7 @@ Expected<TraceSamplerConfig> load_trace_sampler_env_config() {
 
   if (auto sample_rate_env = lookup(environment::DD_TRACE_SAMPLE_RATE)) {
     auto maybe_sample_rate = parse_double(*sample_rate_env);
-    if (auto* error = maybe_sample_rate.if_error()) {
+    if (auto *error = maybe_sample_rate.if_error()) {
       std::string prefix;
       prefix += "While parsing ";
       append(prefix, name(environment::DD_TRACE_SAMPLE_RATE));
@@ -122,7 +122,7 @@ Expected<TraceSamplerConfig> load_trace_sampler_env_config() {
 
   if (auto limit_env = lookup(environment::DD_TRACE_RATE_LIMIT)) {
     auto maybe_max_per_second = parse_double(*limit_env);
-    if (auto* error = maybe_max_per_second.if_error()) {
+    if (auto *error = maybe_max_per_second.if_error()) {
       std::string prefix;
       prefix += "While parsing ";
       append(prefix, name(environment::DD_TRACE_RATE_LIMIT));
@@ -135,9 +135,9 @@ Expected<TraceSamplerConfig> load_trace_sampler_env_config() {
   return env_config;
 }
 
-std::string to_string(const std::vector<TraceSamplerConfig::Rule>& rules) {
+std::string to_string(const std::vector<TraceSamplerConfig::Rule> &rules) {
   nlohmann::json res;
-  for (const auto& r : rules) {
+  for (const auto &r : rules) {
     auto j = nlohmann::json(static_cast<SpanMatcher>(r));
     j["sample_rate"] = r.sample_rate;
     res.emplace_back(std::move(j));
@@ -147,8 +147,8 @@ std::string to_string(const std::vector<TraceSamplerConfig::Rule>& rules) {
 }
 
 // Convert a stable config string value to Optional<double>.
-Optional<double> stable_config_double(const StableConfig& cfg,
-                                      const std::string& key) {
+Optional<double> stable_config_double(const StableConfig &cfg,
+                                      const std::string &key) {
   auto val = cfg.lookup(key);
   if (!val || val->empty()) return nullopt;
   auto result = parse_double(StringView(*val));
@@ -159,17 +159,17 @@ Optional<double> stable_config_double(const StableConfig& cfg,
 // Try to parse a stable config string value as trace sampling rules JSON.
 // Returns empty vector on any parse error (stable config errors are non-fatal).
 Optional<std::vector<TraceSamplerConfig::Rule>> stable_config_sampling_rules(
-    const StableConfig& cfg, const std::string& key) {
+    const StableConfig &cfg, const std::string &key) {
   return parse_stable_config_rules<TraceSamplerConfig::Rule, nlohmann::json>(
-      cfg, key, [](TraceSamplerConfig::Rule&, const nlohmann::json&) {});
+      cfg, key, [](TraceSamplerConfig::Rule &, const nlohmann::json &) {});
 }
 
 }  // namespace
 
-TraceSamplerConfig::Rule::Rule(const SpanMatcher& base) : SpanMatcher(base) {}
+TraceSamplerConfig::Rule::Rule(const SpanMatcher &base) : SpanMatcher(base) {}
 
 Expected<FinalizedTraceSamplerConfig> finalize_config(
-    const TraceSamplerConfig& config, const StableConfigs* stable_configs) {
+    const TraceSamplerConfig &config, const StableConfigs *stable_configs) {
   Expected<TraceSamplerConfig> env_config = load_trace_sampler_env_config();
   if (auto error = env_config.if_error()) {
     return *error;
@@ -211,9 +211,9 @@ Expected<FinalizedTraceSamplerConfig> finalize_config(
                        ConfigMetadata::Origin::LOCAL_STABLE_CONFIG)};
   }
 
-  for (const auto& rule : rules) {
+  for (const auto &rule : rules) {
     auto maybe_rate = Rate::from(rule.sample_rate);
-    if (auto* error = maybe_rate.if_error()) {
+    if (auto *error = maybe_rate.if_error()) {
       std::string prefix;
       prefix +=
           "Unable to parse sample_rate in trace sampling rule with root span "
@@ -242,7 +242,7 @@ Expected<FinalizedTraceSamplerConfig> finalize_config(
   Optional<double> sample_rate = resolve_and_record_config(
       fleet_sample_rate, env_config->sample_rate, config.sample_rate,
       local_sample_rate, &result.metadata, ConfigName::TRACE_SAMPLING_RATE, 1.0,
-      [](const double& d) { return to_string(d, 1); });
+      [](const double &d) { return to_string(d, 1); });
 
   bool is_sample_rate_provided = fleet_sample_rate || env_config->sample_rate ||
                                  config.sample_rate || local_sample_rate;
@@ -251,7 +251,7 @@ Expected<FinalizedTraceSamplerConfig> finalize_config(
   // sample rate is valid.
   if (sample_rate && is_sample_rate_provided) {
     auto maybe_rate = Rate::from(*sample_rate);
-    if (auto* error = maybe_rate.if_error()) {
+    if (auto *error = maybe_rate.if_error()) {
       return error->with_prefix(
           "Unable to parse overall sample_rate for trace sampling: ");
     }
@@ -275,7 +275,7 @@ Expected<FinalizedTraceSamplerConfig> finalize_config(
   double max_per_second = resolve_and_record_config(
       fleet_rate_limit, env_config->max_per_second, config.max_per_second,
       local_rate_limit, &result.metadata, ConfigName::TRACE_SAMPLING_LIMIT,
-      100.0, [](const double& d) { return std::to_string(d); });
+      100.0, [](const double &d) { return std::to_string(d); });
 
   const auto allowed_types = {FP_NORMAL, FP_SUBNORMAL};
   if (!(max_per_second > 0) ||