utility.cc

#include "source/common/stats/utility.h"

#include <algorithm>
#include <string>

#include "absl/strings/match.h"
#include "absl/strings/str_replace.h"
#include "absl/types/optional.h"

namespace Envoy {
namespace Stats {

std::string Utility::sanitizeStatsName(absl::string_view name) {
  if (absl::EndsWith(name, ".")) {
    name.remove_suffix(1);
  }
  if (absl::StartsWith(name, ".")) {
    name.remove_prefix(1);
  }

  return absl::StrReplaceAll(name, {
                                       {"://", "_"},
                                       {":/", "_"},
                                       {":", "_"},
                                       {absl::string_view("\0", 1), "_"},
                                   });
}

absl::optional<StatName> Utility::findTag(const Metric& metric, StatName find_tag_name) {
  absl::optional<StatName> value;
  metric.iterateTagStatNames(
      [&value, &find_tag_name](Stats::StatName tag_name, Stats::StatName tag_value) -> bool {
        if (tag_name == find_tag_name) {
          value = tag_value;
          return false;
        }
        return true;
      });
  return value;
}

namespace {

// Helper class for the three Utility::*FromElements implementations to build up
// a joined StatName from a mix of StatName and string_view.
struct ElementVisitor {
  ElementVisitor(SymbolTable& symbol_table, const ElementVec& elements)
      : symbol_table_(symbol_table), pool_(symbol_table) {
    stat_names_.resize(elements.size());
    for (const Element& element : elements) {
      absl::visit(*this, element);
    }
    joined_ = symbol_table_.join(stat_names_);
  }

  // Overloads provides for absl::visit to call.
  void operator()(StatName stat_name) { stat_names_.push_back(stat_name); }
  void operator()(absl::string_view name) { stat_names_.push_back(pool_.add(name)); }

  /**
   * @return the StatName constructed by joining the elements.
   */
  StatName statName() { return StatName(joined_.get()); }

  SymbolTable& symbol_table_;
  StatNameVec stat_names_;
  StatNameDynamicPool pool_;
  SymbolTable::StoragePtr joined_;
};

} // namespace

namespace Utility {

ScopeSharedPtr scopeFromStatNames(Scope& scope, const StatNameVec& elements) {
  SymbolTable::StoragePtr joined = scope.symbolTable().join(elements);
  return scope.scopeFromStatName(StatName(joined.get()));
}

Counter& counterFromElements(Scope& scope, const ElementVec& elements,
                             StatNameTagVectorOptConstRef tags) {
  ElementVisitor visitor(scope.symbolTable(), elements);
  return scope.counterFromStatNameWithTags(visitor.statName(), tags);
}

Counter& counterFromStatNames(Scope& scope, const StatNameVec& elements,
                              StatNameTagVectorOptConstRef tags) {
  SymbolTable::StoragePtr joined = scope.symbolTable().join(elements);
  return scope.counterFromStatNameWithTags(StatName(joined.get()), tags);
}

Gauge& gaugeFromElements(Scope& scope, const ElementVec& elements, Gauge::ImportMode import_mode,
                         StatNameTagVectorOptConstRef tags) {
  ElementVisitor visitor(scope.symbolTable(), elements);
  return scope.gaugeFromStatNameWithTags(visitor.statName(), tags, import_mode);
}

Gauge& gaugeFromStatNames(Scope& scope, const StatNameVec& elements, Gauge::ImportMode import_mode,
                          StatNameTagVectorOptConstRef tags) {
  SymbolTable::StoragePtr joined = scope.symbolTable().join(elements);
  return scope.gaugeFromStatNameWithTags(StatName(joined.get()), tags, import_mode);
}

Histogram& histogramFromElements(Scope& scope, const ElementVec& elements, Histogram::Unit unit,
                                 StatNameTagVectorOptConstRef tags) {
  ElementVisitor visitor(scope.symbolTable(), elements);
  return scope.histogramFromStatNameWithTags(visitor.statName(), tags, unit);
}

Histogram& histogramFromStatNames(Scope& scope, const StatNameVec& elements, Histogram::Unit unit,
                                  StatNameTagVectorOptConstRef tags) {
  SymbolTable::StoragePtr joined = scope.symbolTable().join(elements);
  return scope.histogramFromStatNameWithTags(StatName(joined.get()), tags, unit);
}

TextReadout& textReadoutFromElements(Scope& scope, const ElementVec& elements,
                                     StatNameTagVectorOptConstRef tags) {
  ElementVisitor visitor(scope.symbolTable(), elements);
  return scope.textReadoutFromStatNameWithTags(visitor.statName(), tags);
}

TextReadout& textReadoutFromStatNames(Scope& scope, const StatNameVec& elements,
                                      StatNameTagVectorOptConstRef tags) {
  SymbolTable::StoragePtr joined = scope.symbolTable().join(elements);
  return scope.textReadoutFromStatNameWithTags(StatName(joined.get()), tags);
}

} // namespace Utility
} // namespace Stats
} // namespace Envoy