span_sampler_config.cpp

#include <datadog/environment.h>
#include <datadog/expected.h>
#include <datadog/span_sampler_config.h>

#include <cmath>
#include <fstream>
#include <sstream>
#include <unordered_set>

#include "json.hpp"
#include "json_serializer.h"
#include "stable_config.h"

namespace datadog {
namespace tracing {
namespace {

// Parse a stable config JSON string as an array of sampling rules.
// `customize_rule` is a callable that receives (Rule&, const json_rule&) to set
// rule-specific fields beyond the base matcher and sample_rate.
// Returns nullopt on any parse error (stable config errors are non-fatal).
template <typename Rule, typename Json, typename Customize>
Optional<std::vector<Rule>> parse_stable_config_rules(
    const StableConfig &cfg, const std::string &key, Logger &logger,
    Customize customize_rule) {
  auto val = cfg.lookup(key);
  if (!val || val->empty()) return nullopt;

  try {
    auto json_rules = Json::parse(*val);
    if (!json_rules.is_array()) {
      logger.log_error([&key](std::ostream &log) {
        log << "Unable to parse JSON sampling rules from " << key
            << ": expected a JSON array";
      });
      return nullopt;
    }

    std::vector<Rule> rules;
    for (const auto &json_rule : json_rules) {
      auto matcher = from_json(json_rule);
      if (matcher.if_error()) {
        logger.log_error([&key](std::ostream &log) {
          log << "Unable to parse JSON sampling rules from " << key
              << ": invalid rule matcher";
        });
        return nullopt;
      }

      Rule rule{*matcher};
      if (auto sr = json_rule.find("sample_rate");
          sr != json_rule.end() && sr->is_number()) {
        rule.sample_rate = *sr;
      }
      customize_rule(rule, json_rule);
      rules.emplace_back(std::move(rule));
    }
    return rules;
  } catch (...) {
    logger.log_error([&key](std::ostream &log) {
      log << "Unable to parse JSON sampling rules from " << key;
    });
    return nullopt;
  }
}

std::string to_string(const std::vector<SpanSamplerConfig::Rule> &rules) {
  nlohmann::json res;
  for (const auto &r : rules) {
    nlohmann::json j = r;
    j["sample_rate"] = r.sample_rate;
    if (r.max_per_second) {
      j["max_per_second"] = *r.max_per_second;
    }
    res.emplace_back(std::move(j));
  }

  return res.dump();
}

// `env_var` is the name of the environment variable from which `rules_raw` was
// obtained.  It's used for error messages.
Expected<std::vector<SpanSamplerConfig::Rule>> parse_rules(StringView rules_raw,
                                                           StringView env_var) {
  std::vector<SpanSamplerConfig::Rule> rules;
  nlohmann::json json_rules;

  try {
    json_rules = nlohmann::json::parse(rules_raw);
  } catch (const nlohmann::json::parse_error &error) {
    std::string message;
    message += "Unable to parse JSON from ";
    append(message, env_var);
    message += " value ";
    append(message, rules_raw);
    message += ": ";
    message += error.what();
    return Error{Error::SPAN_SAMPLING_RULES_INVALID_JSON, std::move(message)};
  }

  std::string type = json_rules.type_name();
  if (type != "array") {
    std::string message;
    message += "Trace sampling rules must be an array, but JSON in ";
    append(message, env_var);
    message += " has type \"";
    message += type;
    message += "\": ";
    append(message, rules_raw);
    return Error{Error::SPAN_SAMPLING_RULES_WRONG_TYPE, std::move(message)};
  }

  const std::unordered_set<std::string> allowed_properties{
      "service", "name", "resource", "tags", "sample_rate", "max_per_second"};

  for (const auto &json_rule : json_rules) {
    auto matcher = from_json(json_rule);
    if (auto *error = matcher.if_error()) {
      std::string prefix;
      prefix += "Unable to create a rule from ";
      append(prefix, env_var);
      prefix += " JSON ";
      append(prefix, rules_raw);
      prefix += ": ";
      return error->with_prefix(prefix);
    }

    SpanSamplerConfig::Rule rule{*matcher};

    auto sample_rate = json_rule.find("sample_rate");
    if (sample_rate != json_rule.end()) {
      type = sample_rate->type_name();
      if (type != "number") {
        std::string message;
        message += "Unable to parse a rule from ";
        append(message, env_var);
        message += " JSON ";
        append(message, rules_raw);
        message += ".  The \"sample_rate\" property of the rule ";
        message += json_rule.dump();
        message += " is not a number, but instead has type \"";
        message += type;
        message += "\".";
        return Error{Error::SPAN_SAMPLING_RULES_SAMPLE_RATE_WRONG_TYPE,
                     std::move(message)};
      }
      rule.sample_rate = *sample_rate;
    }

    auto max_per_second = json_rule.find("max_per_second");
    if (max_per_second != json_rule.end()) {
      type = max_per_second->type_name();
      if (type != "number") {
        std::string message;
        message += "Unable to parse a rule from ";
        append(message, env_var);
        message += " JSON ";
        append(message, rules_raw);
        message += ".  The \"max_per_second\" property of the rule ";
        message += json_rule.dump();
        message += " is not a number, but instead has type \"";
        message += type;
        message += "\".";
        return Error{Error::SPAN_SAMPLING_RULES_MAX_PER_SECOND_WRONG_TYPE,
                     std::move(message)};
      }
      rule.max_per_second = *max_per_second;
    }

    // Look for unexpected properties.
    for (const auto &[key, value] : json_rule.items()) {
      if (allowed_properties.count(key)) {
        continue;
      }
      std::string message;
      message += "Unexpected property \"";
      message += key;
      message += "\" having value ";
      message += value.dump();
      message += " in trace sampling rule ";
      message += json_rule.dump();
      message += ".  Error occurred while parsing from ";
      append(message, env_var);
      message += ": ";
      append(message, rules_raw);
      return Error{Error::SPAN_SAMPLING_RULES_UNKNOWN_PROPERTY,
                   std::move(message)};
    }

    rules.emplace_back(std::move(rule));
  }

  return rules;
}

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()) {
      return std::move(*error);
    }
    env_config.rules = std::move(*maybe_rules);
  }

  if (auto file_env = lookup(environment::DD_SPAN_SAMPLING_RULES_FILE)) {
    if (rules_env) {
      const auto rules_file_name =
          name(environment::DD_SPAN_SAMPLING_RULES_FILE);
      const auto rules_name = name(environment::DD_SPAN_SAMPLING_RULES);
      std::string message;
      append(message, rules_file_name);
      message += " is overridden by ";
      append(message, rules_name);
      message += ".  Since both are set, ";
      append(message, rules_name);
      message += " takes precedence, and ";
      append(message, rules_file_name);
      message += " will be ignored.";
      logger.log_error(message);
    } else {
      const auto span_rules_file = std::string(*file_env);

      const auto file_error = [&](const char *operation) {
        std::string message;
        message += "Unable to ";
        message += operation;
        message += " file \"";
        message += span_rules_file;
        message += "\" specified as value of environment variable ";
        append(message, name(environment::DD_SPAN_SAMPLING_RULES_FILE));

        return Error{Error::SPAN_SAMPLING_RULES_FILE_IO, std::move(message)};
      };

      std::ifstream file(span_rules_file);
      if (!file) {
        return file_error("open");
      }

      std::ostringstream rules_stream;
      rules_stream << file.rdbuf();
      if (!file) {
        return file_error("read");
      }

      auto maybe_rules = parse_rules(
          rules_stream.str(), name(environment::DD_SPAN_SAMPLING_RULES_FILE));
      if (auto *error = maybe_rules.if_error()) {
        std::string prefix;
        prefix += "With ";
        append(prefix, name(environment::DD_SPAN_SAMPLING_RULES_FILE));
        prefix += '=';
        append(prefix, *file_env);
        prefix += ": ";
        return error->with_prefix(prefix);
      }

      env_config.rules = std::move(*maybe_rules);
    }
  }

  return env_config;
}

}  // namespace

SpanSamplerConfig::Rule::Rule(const SpanMatcher &base) : SpanMatcher(base) {}

Expected<FinalizedSpanSamplerConfig> finalize_config(
    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;
  }

  FinalizedSpanSamplerConfig result;
  Optional<std::vector<SpanSamplerConfig::Rule>> env_rules;
  Optional<std::vector<SpanSamplerConfig::Rule>> user_rules;
  if (!env_config->rules.empty()) {
    env_rules = env_config->rules;
  }
  if (!user_config.rules.empty()) {
    user_rules = user_config.rules;
  }

  Optional<std::vector<SpanSamplerConfig::Rule>> fleet_rules;
  Optional<std::vector<SpanSamplerConfig::Rule>> local_rules;
  if (stable_configs) {
    auto parse_span_rules = [&logger](const StableConfig &cfg,
                                      const std::string &key) {
      return parse_stable_config_rules<SpanSamplerConfig::Rule, nlohmann::json>(
          cfg, key, logger,
          [](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;
            }
          });
    };
    fleet_rules =
        parse_span_rules(stable_configs->fleet, "DD_SPAN_SAMPLING_RULES");
    local_rules =
        parse_span_rules(stable_configs->local, "DD_SPAN_SAMPLING_RULES");
  }

  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) {
        return to_string(r);
      });

  for (const auto &rule : rules) {
    auto maybe_rate = Rate::from(rule.sample_rate);
    if (auto *error = maybe_rate.if_error()) {
      std::string prefix;
      prefix +=
          "Unable to parse sample_rate in span sampling rule with span "
          "pattern ";
      prefix += nlohmann::json(static_cast<SpanMatcher>(rule)).dump();
      prefix += ": ";
      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))) {
      std::string message;
      message += "Span sampling rule with pattern ";
      message += nlohmann::json(static_cast<SpanMatcher>(rule)).dump();
      message +=
          " should have a max_per_second value greater than zero, but the "
          "following value was given: ";
      message += std::to_string(*rule.max_per_second);
      return Error{Error::MAX_PER_SECOND_OUT_OF_RANGE, std::move(message)};
    }

    FinalizedSpanSamplerConfig::Rule finalized;
    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) {
  // Get the base class's fields, then add our own.
  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;
  }

  return result.dump();
}

}  // namespace tracing
}  // namespace datadog