codes.h

#pragma once

#include <chrono>
#include <cstdint>
#include <string>

#include "envoy/http/codes.h"
#include "envoy/http/header_map.h"
#include "envoy/stats/scope.h"

#include "source/common/common/thread.h"
#include "source/common/stats/symbol_table.h"

namespace Envoy {
namespace Http {

struct CodeStats::ResponseStatInfo {
  Stats::Scope& global_scope_;
  Stats::Scope& cluster_scope_;
  Stats::StatName prefix_;
  uint64_t response_status_code_;
  bool internal_request_;
  Stats::StatName request_vhost_name_;
  Stats::StatName request_vcluster_name_;
  Stats::StatName request_route_name_;
  Stats::StatName from_zone_;
  Stats::StatName to_zone_;
  bool upstream_canary_;
};

struct CodeStats::ResponseTimingInfo {
  Stats::Scope& global_scope_;
  Stats::Scope& cluster_scope_;
  Stats::StatName prefix_;
  std::chrono::milliseconds response_time_;
  bool upstream_canary_;
  bool internal_request_;
  Stats::StatName request_vhost_name_;
  Stats::StatName request_vcluster_name_;
  Stats::StatName request_route_name_;
  Stats::StatName from_zone_;
  Stats::StatName to_zone_;
};

class CodeStatsImpl : public CodeStats {
public:
  explicit CodeStatsImpl(Stats::SymbolTable& symbol_table);

  // CodeStats
  void chargeBasicResponseStat(Stats::Scope& scope, Stats::StatName prefix, Code response_code,
                               bool exclude_http_code_stats) const override;
  void chargeResponseStat(const ResponseStatInfo& info,
                          bool exclude_http_code_stats) const override;
  void chargeResponseTiming(const ResponseTimingInfo& info) const override;

private:
  friend class CodeStatsTest;

  void writeCategory(const ResponseStatInfo& info, Stats::StatName rq_group,
                     Stats::StatName rq_code, Stats::StatName category) const;
  void incCounter(Stats::Scope& scope, const Stats::StatNameVec& names) const;
  void incCounter(Stats::Scope& scope, Stats::StatName a, Stats::StatName b) const;
  void recordHistogram(Stats::Scope& scope, const Stats::StatNameVec& names,
                       Stats::Histogram::Unit unit, uint64_t count) const;

  Stats::StatName upstreamRqGroup(Code response_code) const;
  Stats::StatName upstreamRqStatName(Code response_code) const;

  mutable Stats::StatNamePool stat_name_pool_;
  Stats::SymbolTable& symbol_table_;

  const Stats::StatName canary_;
  const Stats::StatName empty_; // Used for the group-name for invalid http codes.
  const Stats::StatName external_;
  const Stats::StatName internal_;
  const Stats::StatName upstream_;
  const Stats::StatName upstream_rq_1xx_;
  const Stats::StatName upstream_rq_2xx_;
  const Stats::StatName upstream_rq_3xx_;
  const Stats::StatName upstream_rq_4xx_;
  const Stats::StatName upstream_rq_5xx_;
  const Stats::StatName upstream_rq_unknown_;
  const Stats::StatName upstream_rq_completed_;
  const Stats::StatName upstream_rq_time_;
  const Stats::StatName vcluster_;
  const Stats::StatName vhost_;
  const Stats::StatName route_;
  const Stats::StatName zone_;

  // Use an array of atomic pointers to hold StatNameStorage objects for
  // every conceivable HTTP response code. In the hot-path we'll reference
  // these with a null-check, and if we need to allocate a symbol for a
  // new code, we'll take a mutex to avoid duplicate allocations and
  // subsequent leaks. This is similar in principle to a ReaderMutexLock,
  // but should be faster, as ReaderMutexLocks appear to be too expensive for
  // fine-grained controls. Another option would be to use a lock per
  // stat-name, which might have similar performance to atomics with default
  // barrier policy.
  //
  // We don't allocate these all up front during construction because
  // SymbolTable greedily encodes the first 128 names it discovers in one
  // byte. We don't want those high-value single-byte codes to go to fully
  // enumerating the 4 prefixes combined with HTTP codes that are seldom used,
  // so we allocate these on demand.
  //
  // There can be multiple symbol tables in a server. The one passed into the
  // Codes constructor should be the same as the one passed to
  // Stats::ThreadLocalStore. Note that additional symbol tables can be created
  // from IsolatedStoreImpl's default constructor.
  //
  // The Codes object is global to the server.

  static constexpr uint32_t NumHttpCodes = 500;
  static constexpr uint32_t HttpCodeOffset = 100; // code 100 is at index 0.
  mutable Thread::AtomicPtrArray<const uint8_t, NumHttpCodes,
                                 Thread::AtomicPtrAllocMode::DoNotDelete>
      rc_stat_names_;
};

/**
 * General utility routines for HTTP codes.
 */
class CodeUtility {
public:
  /**
   * Convert an HTTP response code to a descriptive string.
   * @param code supplies the code to convert.
   * @return const char* the string.
   */
  static const char* toString(Code code);

  static bool is1xx(uint64_t code) { return code >= 100 && code < 200; }
  static bool is2xx(uint64_t code) { return code >= 200 && code < 300; }
  static bool is3xx(uint64_t code) { return code >= 300 && code < 400; }
  static bool is4xx(uint64_t code) { return code >= 400 && code < 500; }
  static bool is5xx(uint64_t code) { return code >= 500 && code < 600; }

  static bool isGatewayError(uint64_t code) { return code >= 502 && code < 505; }

  static std::string groupStringForResponseCode(Code response_code);
};

} // namespace Http
} // namespace Envoy