const HostStringExtractor& extractor) {

  const auto opt_ref = stream_info.upstreamInfo();

  if (!opt_ref.has_value()) {

  const auto& attempted_hosts = opt_ref->upstreamHostsAttempted();

  if (attempted_hosts.empty()) {

  std::vector<std::string> results;

  results.reserve(attempted_hosts.size());

  for (const auto& host : attempted_hosts) {

    auto result = extractor(host);

    if (result.has_value() && !result->empty()) {

      results.push_back(std::move(*result));

    }

  }

  if (results.empty()) {

    return absl::nullopt;

  }

  return absl::StrJoin(results, ",");

}

const re2::RE2& getSystemTimeFormatNewlinePattern() {

  CONSTRUCT_ON_FIRST_USE(re2::RE2, "%[-_0^#]*[1-9]*(E|O)?n");

}

std::string detectedCloseTypeToString(StreamInfo::DetectedCloseType type) {

  switch (type) {

  case StreamInfo::DetectedCloseType::LocalReset:

    return "LocalReset";

  case StreamInfo::DetectedCloseType::RemoteReset:

    return "RemoteReset";

  case StreamInfo::DetectedCloseType::Normal:

    return "Normal";

  }

}

getUpstreamRemoteAddress(const StreamInfo::StreamInfo& stream_info) {

  auto opt_ref = stream_info.upstreamInfo();

  if (!opt_ref.has_value()) {

    return nullptr;

  }

  if (auto addr = opt_ref->upstreamRemoteAddress(); addr != nullptr) {

    return addr;

  }

  return nullptr;

}

    : filter_namespace_(filter_namespace), path_(path.begin(), path.end()), max_length_(max_length),

      get_func_(get_func) {}

MetadataFormatter::formatMetadata(const envoy::config::core::v3::Metadata& metadata) const {

  Protobuf::Value value = formatMetadataValue(metadata);

  if (value.kind_case() == Protobuf::Value::kNullValue) {

    return absl::nullopt;

  }

  std::string str;

  str.reserve(256);

  if (value.kind_case() == Protobuf::Value::kStringValue) {

    str = value.string_value();

  } else {

    Json::Utility::appendValueToString(value, str);

  }

  SubstitutionFormatUtils::truncate(str, max_length_);

  return str;

}

MetadataFormatter::formatMetadataValue(const envoy::config::core::v3::Metadata& metadata) const {

  if (path_.empty()) {

    const auto filter_it = metadata.filter_metadata().find(filter_namespace_);

    if (filter_it == metadata.filter_metadata().end()) {

      return SubstitutionFormatUtils::unspecifiedValue();

    }

    Protobuf::Value output;

    output.mutable_struct_value()->CopyFrom(filter_it->second);

    return output;

  }

  const Protobuf::Value& val = Config::Metadata::metadataValue(&metadata, filter_namespace_, path_);

  if (val.kind_case() == Protobuf::Value::KindCase::KIND_NOT_SET) {

    return SubstitutionFormatUtils::unspecifiedValue();

  }

  if (max_length_.has_value() && val.kind_case() != Protobuf::Value::kStructValue &&

      val.kind_case() != Protobuf::Value::kListValue) {

    std::string str;

    if (val.kind_case() == Protobuf::Value::kStringValue) {

      str = val.string_value();

    } else {

    if (SubstitutionFormatUtils::truncate(str, max_length_)) {

      Protobuf::Value output;

      output.set_string_value(str);

      return output;

    }

  }

  return val;

}

MetadataFormatter::format(const StreamInfo::StreamInfo& stream_info) const {

  auto metadata = get_func_(stream_info);

  return (metadata != nullptr) ? formatMetadata(*metadata) : absl::nullopt;

}

Protobuf::Value MetadataFormatter::formatValue(const StreamInfo::StreamInfo& stream_info) const {

  auto metadata = get_func_(stream_info);

  return formatMetadataValue((metadata != nullptr) ? *metadata

                                                   : envoy::config::core::v3::Metadata());

}

    : MetadataFormatter(filter_namespace, path, max_length,

                        [](const StreamInfo::StreamInfo& stream_info) {

                          return &stream_info.dynamicMetadata();

                        }) {}

    : MetadataFormatter(filter_namespace, path, max_length,

                        [](const StreamInfo::StreamInfo& stream_info)

                            -> const envoy::config::core::v3::Metadata* {

                          auto cluster_info = stream_info.upstreamClusterInfo();

                          if (!cluster_info.has_value() || cluster_info.value() == nullptr) {

                            return nullptr;

                          }

                          return &cluster_info.value()->metadata();

                        }) {}

    : MetadataFormatter(filter_namespace, path, max_length,

                        [](const StreamInfo::StreamInfo& stream_info)

                            -> const envoy::config::core::v3::Metadata* {

                          if (!stream_info.upstreamInfo().has_value()) {

                            return nullptr;

                          }

                          Upstream::HostDescriptionConstSharedPtr host =

                              stream_info.upstreamInfo()->upstreamHost();

                          if (host == nullptr) {

                            return nullptr;

                          }

                          return host->metadata().get();

                        }) {}

                             bool is_upstream) {

  absl::string_view key, serialize_type, field_name;

  static constexpr absl::string_view PLAIN_SERIALIZATION{"PLAIN"};

  static constexpr absl::string_view TYPED_SERIALIZATION{"TYPED"};

  static constexpr absl::string_view FIELD_SERIALIZATION{"FIELD"};

  SubstitutionFormatUtils::parseSubcommand(format, ':', key, serialize_type, field_name);

  if (key.empty()) {

    throw EnvoyException("Invalid filter state configuration, key cannot be empty.");

  }

  if (serialize_type.empty()) {

    serialize_type = TYPED_SERIALIZATION;

  }

  if (serialize_type != PLAIN_SERIALIZATION && serialize_type != TYPED_SERIALIZATION &&

      serialize_type != FIELD_SERIALIZATION) {

    throw EnvoyException("Invalid filter state serialize type, only "

                         "support PLAIN/TYPED/FIELD.");

  }

  if ((serialize_type == FIELD_SERIALIZATION) ^ !field_name.empty()) {

    throw EnvoyException("Invalid filter state serialize type, FIELD "

                         "should be used with the field name.");

  }

  const bool serialize_as_string = serialize_type == PLAIN_SERIALIZATION;

  return std::make_unique<FilterStateFormatter>(key, max_length, serialize_as_string, is_upstream,

                                                field_name);

}

    : key_(key), max_length_(max_length), is_upstream_(is_upstream) {

  if (!field_name.empty()) {

    format_ = FilterStateFormat::Field;

    field_name_ = std::string(field_name);

  } else if (serialize_as_string) {

    format_ = FilterStateFormat::String;

  } else {

    format_ = FilterStateFormat::Proto;

  }

}

FilterStateFormatter::filterState(const StreamInfo::StreamInfo& stream_info) const {

  const StreamInfo::FilterState* filter_state = nullptr;

  if (is_upstream_) {

    const OptRef<const StreamInfo::UpstreamInfo> upstream_info = stream_info.upstreamInfo();

    if (upstream_info) {

      filter_state = upstream_info->upstreamFilterState().get();

    }

  } else {

    filter_state = &stream_info.filterState();

  }

  if (filter_state) {

    return filter_state->getDataReadOnly<StreamInfo::FilterState::Object>(key_);

  }

}

  absl::optional<std::string> operator()(int64_t val) { return absl::StrCat(val); }

  absl::optional<std::string> operator()(absl::string_view val) { return std::string(val); }

  absl::optional<std::string> operator()(absl::monostate) { return {}; }

FilterStateFormatter::format(const StreamInfo::StreamInfo& stream_info) const {

  const Envoy::StreamInfo::FilterState::Object* state = filterState(stream_info);

  if (!state) {

    return absl::nullopt;

  }

  switch (format_) {

  case FilterStateFormat::String: {

    absl::optional<std::string> plain_value = state->serializeAsString();

    if (plain_value.has_value()) {

      SubstitutionFormatUtils::truncate(plain_value.value(), max_length_);

      return plain_value.value();

    }

    return absl::nullopt;

  }

  case FilterStateFormat::Proto: {

    ProtobufTypes::MessagePtr proto = state->serializeAsProto();

    if (proto == nullptr) {

      return absl::nullopt;

    }

#if defined(ENVOY_ENABLE_FULL_PROTOS)

    std::string value;

    const auto status = Protobuf::util::MessageToJsonString(*proto, &value);

    if (!status.ok()) {

      return absl::nullopt;

    }

    SubstitutionFormatUtils::truncate(value, max_length_);

    return value;

  }

  case FilterStateFormat::Field: {

    auto field_value = state->getField(field_name_);

    auto string_value = absl::visit(StringFieldVisitor(), field_value);

    if (!string_value) {

      return absl::nullopt;

    }

    SubstitutionFormatUtils::truncate(string_value.value(), max_length_);

    return string_value;

  }

  }

}

Protobuf::Value FilterStateFormatter::formatValue(const StreamInfo::StreamInfo& stream_info) const {

  const Envoy::StreamInfo::FilterState::Object* state = filterState(stream_info);

  if (!state) {

    return SubstitutionFormatUtils::unspecifiedValue();

  }

  switch (format_) {

  case FilterStateFormat::String: {

    absl::optional<std::string> plain_value = state->serializeAsString();

    if (plain_value.has_value()) {

      SubstitutionFormatUtils::truncate(plain_value.value(), max_length_);

      return ValueUtil::stringValue(plain_value.value());

    }

    return SubstitutionFormatUtils::unspecifiedValue();

  }

  case FilterStateFormat::Proto: {

    ProtobufTypes::MessagePtr proto = state->serializeAsProto();

    if (!proto) {

      return SubstitutionFormatUtils::unspecifiedValue();

    }

#ifdef ENVOY_ENABLE_YAML

    Protobuf::Value val;

    if (MessageUtil::jsonConvertValue(*proto, val)) {

      return val;

    }

#endif

    return SubstitutionFormatUtils::unspecifiedValue();

  }

  case FilterStateFormat::Field: {

    auto field_value = state->getField(field_name_);

    auto string_value = absl::visit(StringFieldVisitor(), field_value);

    if (!string_value) {

      return SubstitutionFormatUtils::unspecifiedValue();

    }

    SubstitutionFormatUtils::truncate(string_value.value(), max_length_);

    return ValueUtil::stringValue(string_value.value());

  }

  }

}

         [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<MonotonicTime> {

           return stream_info.startTimeMonotonic();

         }},

         [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<MonotonicTime> {

           const auto downstream_timing = stream_info.downstreamTiming();

           if (downstream_timing.has_value()) {

             return downstream_timing->lastDownstreamRxByteReceived();

           }

         }},

         [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<MonotonicTime> {

           const auto upstream_info = stream_info.upstreamInfo();

           if (upstream_info.has_value()) {

             return upstream_info->upstreamTiming().upstream_connect_start_;

           }

         }},

         [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<MonotonicTime> {

           const auto upstream_info = stream_info.upstreamInfo();

           if (upstream_info.has_value()) {

             return upstream_info->upstreamTiming().upstream_connect_complete_;

           }

         }},

         [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<MonotonicTime> {

           const auto upstream_info = stream_info.upstreamInfo();

           if (upstream_info.has_value()) {

             return upstream_info->upstreamTiming().upstream_handshake_complete_;

           }

         }},

         [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<MonotonicTime> {

           const auto upstream_info = stream_info.upstreamInfo();

           if (upstream_info.has_value()) {

             return upstream_info->upstreamTiming().first_upstream_tx_byte_sent_;

           }

         }},

         [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<MonotonicTime> {

           const auto upstream_info = stream_info.upstreamInfo();

           if (upstream_info.has_value()) {

             return upstream_info->upstreamTiming().last_upstream_tx_byte_sent_;

           }

         }},

         [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<MonotonicTime> {

           const auto upstream_info = stream_info.upstreamInfo();

           if (upstream_info.has_value()) {

             return upstream_info->upstreamTiming().first_upstream_rx_byte_received_;

           }

         }},

         [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<MonotonicTime> {

           const auto upstream_info = stream_info.upstreamInfo();

           if (upstream_info.has_value()) {

             return upstream_info->upstreamTiming().last_upstream_rx_byte_received_;

           }

         }},

         [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<MonotonicTime> {

           const auto downstream_timing = stream_info.downstreamTiming();

           if (downstream_timing.has_value()) {

             return downstream_timing->firstDownstreamTxByteSent();

           }

         }},

         [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<MonotonicTime> {

           const auto downstream_timing = stream_info.downstreamTiming();

           if (downstream_timing.has_value()) {

             return downstream_timing->lastDownstreamTxByteSent();

           }

         }},

CommonDurationFormatter::getTimePointGetterByName(absl::string_view name) {

  auto it = KnownTimePointGetters.find(name);

  if (it != KnownTimePointGetters.end()) {

    return it->second;

  }

  return [key = std::string(name)](const StreamInfo::StreamInfo& info) {

    const auto downstream_timing = info.downstreamTiming();

    if (downstream_timing.has_value()) {

      return downstream_timing->getValue(key);

    }

  };

}

CommonDurationFormatter::create(absl::string_view sub_command) {

  absl::InlinedVector<absl::string_view, 3> parsed_sub_commands = absl::StrSplit(sub_command, ':');

  if (parsed_sub_commands.size() < 2 || parsed_sub_commands.size() > 3) {

    throw EnvoyException(fmt::format("Invalid common duration configuration: {}.", sub_command));

  }

  absl::string_view start = parsed_sub_commands[0];

  absl::string_view end = parsed_sub_commands[1];

  DurationPrecision precision = DurationPrecision::Milliseconds;

  if (parsed_sub_commands.size() == 3) {

    absl::string_view precision_str = parsed_sub_commands[2];

    if (precision_str == MillisecondsPrecision) {

      precision = DurationPrecision::Milliseconds;

    } else if (precision_str == MicrosecondsPrecision) {

      precision = DurationPrecision::Microseconds;

    } else if (precision_str == NanosecondsPrecision) {

      precision = DurationPrecision::Nanoseconds;

    } else {

      throw EnvoyException(fmt::format("Invalid common duration precision: {}.", precision_str));

    }

  }

  TimePointGetter start_getter = getTimePointGetterByName(start);

  TimePointGetter end_getter = getTimePointGetterByName(end);

  return std::make_unique<CommonDurationFormatter>(std::move(start_getter), std::move(end_getter),

                                                   precision);

}

CommonDurationFormatter::getDurationCount(const StreamInfo::StreamInfo& info) const {

  auto time_point_beg = time_point_beg_(info);

  auto time_point_end = time_point_end_(info);

  if (!time_point_beg.has_value() || !time_point_end.has_value()) {

    return absl::nullopt;

  }

  if (time_point_end.value() < time_point_beg.value()) {

    return absl::nullopt;

  }

  auto duration = time_point_end.value() - time_point_beg.value();

  switch (duration_precision_) {

  case DurationPrecision::Milliseconds:

    return std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();

  case DurationPrecision::Microseconds:

    return std::chrono::duration_cast<std::chrono::microseconds>(duration).count();

  case DurationPrecision::Nanoseconds:

    return std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count();

  }

CommonDurationFormatter::format(const StreamInfo::StreamInfo& info) const {

  auto duration = getDurationCount(info);

  if (!duration.has_value()) {

    return absl::nullopt;

  }

  return fmt::format_int(duration.value()).str();

}

Protobuf::Value CommonDurationFormatter::formatValue(const StreamInfo::StreamInfo& info) const {

  auto duration = getDurationCount(info);

  if (!duration.has_value()) {

    return SubstitutionFormatUtils::unspecifiedValue();

  }

  return ValueUtil::numberValue(duration.value());

}

    : SystemTimeFormatter(

          format, std::make_unique<SystemTimeFormatter::TimeFieldExtractor>(

                      [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<SystemTime> {

                        return stream_info.startTime();

                      })) {}

    : SystemTimeFormatter(

          format, std::make_unique<SystemTimeFormatter::TimeFieldExtractor>(

                      [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<SystemTime> {

                        const auto connection_info =

                            stream_info.downstreamAddressProvider().sslConnection();

                        return connection_info != nullptr

                                   ? connection_info->validFromPeerCertificate()

                                   : absl::optional<SystemTime>();

                      })) {}

    : SystemTimeFormatter(

          format, std::make_unique<SystemTimeFormatter::TimeFieldExtractor>(

                      [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<SystemTime> {

                        const auto connection_info =

                            stream_info.downstreamAddressProvider().sslConnection();

                        return connection_info != nullptr

                                   ? connection_info->expirationPeerCertificate()

                                   : absl::optional<SystemTime>();

                      })) {}

    : SystemTimeFormatter(

          format, std::make_unique<SystemTimeFormatter::TimeFieldExtractor>(

                      [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<SystemTime> {

                        return stream_info.upstreamInfo() &&

                                       stream_info.upstreamInfo()->upstreamSslConnection() !=

                                           nullptr

                                   ? stream_info.upstreamInfo()

                                         ->upstreamSslConnection()

                                         ->validFromPeerCertificate()

                                   : absl::optional<SystemTime>();

                      })) {}

    : SystemTimeFormatter(

          format, std::make_unique<SystemTimeFormatter::TimeFieldExtractor>(

                      [](const StreamInfo::StreamInfo& stream_info) -> absl::optional<SystemTime> {

                        return stream_info.upstreamInfo() &&

                                       stream_info.upstreamInfo()->upstreamSslConnection() !=

                                           nullptr

                                   ? stream_info.upstreamInfo()

                                         ->upstreamSslConnection()

                                         ->expirationPeerCertificate()

                                   : absl::optional<SystemTime>();

                      })) {}

    : date_formatter_(format, local_time), time_field_extractor_(std::move(f)),

      local_time_(local_time) {

  if (re2::RE2::PartialMatch(format, getSystemTimeFormatNewlinePattern())) {

    throw EnvoyException("Invalid header configuration. Format string contains newline.");

  }

}

SystemTimeFormatter::format(const StreamInfo::StreamInfo& stream_info) const {

  const auto time_field = (*time_field_extractor_)(stream_info);

  if (!time_field.has_value()) {

    return absl::nullopt;

  }

  if (date_formatter_.formatString().empty()) {

    return AccessLogDateTimeFormatter::fromTime(time_field.value(), local_time_);

  }

  return date_formatter_.fromTime(time_field.value());

}

Protobuf::Value SystemTimeFormatter::formatValue(const StreamInfo::StreamInfo& stream_info) const {

  return ValueUtil::optionalStringValue(format(stream_info));

}

                                           absl::optional<size_t> max_length) {

  ASSERT(!key.empty());

  const std::string key_str = std::string(key);

  const char* env_value = std::getenv(key_str.c_str());

  if (env_value != nullptr) {

    std::string env_string = env_value;

    SubstitutionFormatUtils::truncate(env_string, max_length);

    str_.set_string_value(env_string);

    return;

  }

  str_.set_string_value(DefaultUnspecifiedValueString);

}

absl::optional<std::string> EnvironmentFormatter::format(const StreamInfo::StreamInfo&) const {

  return str_.string_value();

}

Protobuf::Value EnvironmentFormatter::formatValue(const StreamInfo::StreamInfo&) const {

  return str_;

}

                                                           absl::string_view option) {

  HostFormatterSource host_source = SNI;

  HostFormatterOption option_enum = OriginalHostOrHost;

  if (source == "SNI_ONLY") {

    host_source = SNI;

  } else if (source == "SNI_FIRST") {

    host_source = SNIFirst;

  } else if (source == "HOST_FIRST") {

    host_source = HostFirst;

  } else if (source.empty()) {

    host_source = SNI;

  } else {

  if (option == "ORIG_OR_HOST") {

    option_enum = OriginalHostOrHost;

  } else if (option == "HOST") {

    option_enum = HostOnly;

  } else if (option == "ORIG") {

  } else if (option.empty()) {

    option_enum = OriginalHostOrHost;

  } else {

  source_ = host_source;

  option_ = option_enum;

}

RequestedServerNameFormatter::format(const StreamInfo::StreamInfo& stream_info) const {

  absl::optional<std::string> result;

  switch (source_) {

  case SNI:

    result = getSNIFromStreamInfo(stream_info);

    break;

  case SNIFirst:

    result = getSNIFromStreamInfo(stream_info);

    if (!result.has_value()) {

      result = getHostFromHeaders(stream_info);

    }

    break;

  case HostFirst:

    result = getHostFromHeaders(stream_info);

    if (!result.has_value()) {

    break;

  }

  return result;

}

    const StreamInfo::StreamInfo& stream_info) const {

  absl::optional<std::string> result;

  if (!stream_info.downstreamAddressProvider().requestedServerName().empty()) {

    result = StringUtil::sanitizeInvalidHostname(

        stream_info.downstreamAddressProvider().requestedServerName());

  }

  return result;

}

RequestedServerNameFormatter::getHostFromHeaders(const StreamInfo::StreamInfo& stream_info) const {

  absl::optional<std::string> result;

  const auto& headers = stream_info.getRequestHeaders();

  if (headers != nullptr) {

    switch (option_) {

    case HostOnly:

      result = headers->Host()->value().getStringView();

      break;

    case OriginalHostOrHost:

      result = headers->EnvoyOriginalHost() != nullptr

                   ? headers->EnvoyOriginalHost()->value().getStringView()

                   : headers->Host()->value().getStringView();

      break;

    }

  }

  return result;

}

RequestedServerNameFormatter::formatValue(const StreamInfo::StreamInfo& stream_info) const {

  return ValueUtil::optionalStringValue(format(stream_info));

}

  StreamInfoStringFormatterProvider(FieldExtractor f) : field_extractor_(f) {}

  absl::optional<std::string> format(const StreamInfo::StreamInfo& stream_info) const override {

    return field_extractor_(stream_info);

  }

  Protobuf::Value formatValue(const StreamInfo::StreamInfo& stream_info) const override {

    return ValueUtil::optionalStringValue(field_extractor_(stream_info));

  }

  StreamInfoDurationFormatterProvider(FieldExtractor f) : field_extractor_(f) {}

  absl::optional<std::string> format(const StreamInfo::StreamInfo& stream_info) const override {

    const auto millis = extractMillis(stream_info);

    if (!millis) {

      return absl::nullopt;

    }

    return fmt::format_int(millis.value()).str();

  }

  Protobuf::Value formatValue(const StreamInfo::StreamInfo& stream_info) const override {

    const auto millis = extractMillis(stream_info);

    if (!millis) {

      return SubstitutionFormatUtils::unspecifiedValue();

    }

    return ValueUtil::numberValue(millis.value());

  }

  absl::optional<int64_t> extractMillis(const StreamInfo::StreamInfo& stream_info) const {

    const auto time = field_extractor_(stream_info);

    if (time) {

      return std::chrono::duration_cast<std::chrono::milliseconds>(time.value()).count();

    }

    return absl::nullopt;

  }

  StreamInfoUInt64FormatterProvider(FieldExtractor f) : field_extractor_(f) {}

  absl::optional<std::string> format(const StreamInfo::StreamInfo& stream_info) const override {

    return fmt::format_int(field_extractor_(stream_info)).str();

  }

  Protobuf::Value formatValue(const StreamInfo::StreamInfo& stream_info) const override {

    return ValueUtil::numberValue(field_extractor_(stream_info));

  }

  static std::unique_ptr<StreamInfoAddressFormatterProvider> withPort(FieldExtractor f) {

    return std::make_unique<StreamInfoAddressFormatterProvider>(

        f, StreamInfoAddressFieldExtractionType::WithPort);

  }

  withoutPort(FieldExtractor f, absl::optional<int> mask_prefix_len = absl::nullopt) {

    return std::make_unique<StreamInfoAddressFormatterProvider>(

        f, StreamInfoAddressFieldExtractionType::WithoutPort, mask_prefix_len);

  }

  static std::unique_ptr<StreamInfoAddressFormatterProvider> justPort(FieldExtractor f) {

    return std::make_unique<StreamInfoAddressFormatterProvider>(

        f, StreamInfoAddressFieldExtractionType::JustPort);

  }

  static std::unique_ptr<StreamInfoAddressFormatterProvider> justEndpointId(FieldExtractor f) {

    return std::make_unique<StreamInfoAddressFormatterProvider>(

        f, StreamInfoAddressFieldExtractionType::JustEndpointId);

  }

      : field_extractor_(f), extraction_type_(extraction_type), mask_prefix_len_(mask_prefix_len) {}

  absl::optional<std::string> format(const StreamInfo::StreamInfo& stream_info) const override {

    Network::Address::InstanceConstSharedPtr address = field_extractor_(stream_info);

    if (!address) {

      return absl::nullopt;

    }

    return toString(*address);

  }

  Protobuf::Value formatValue(const StreamInfo::StreamInfo& stream_info) const override {

    Network::Address::InstanceConstSharedPtr address = field_extractor_(stream_info);

    if (!address) {

      return SubstitutionFormatUtils::unspecifiedValue();

    }

    if (extraction_type_ == StreamInfoAddressFieldExtractionType::JustPort) {

      const auto port = StreamInfo::Utility::extractDownstreamAddressJustPort(*address);

      if (port) {

        return ValueUtil::numberValue(*port);

      }

      return SubstitutionFormatUtils::unspecifiedValue();

    }

    return ValueUtil::stringValue(toString(*address));

  }

  std::string toString(const Network::Address::Instance& address) const {

    switch (extraction_type_) {

    case StreamInfoAddressFieldExtractionType::WithoutPort:

      return StreamInfo::Utility::formatDownstreamAddressNoPort(address, mask_prefix_len_);

    case StreamInfoAddressFieldExtractionType::JustPort:

      return StreamInfo::Utility::formatDownstreamAddressJustPort(address);

    case StreamInfoAddressFieldExtractionType::JustEndpointId:

      return StreamInfo::Utility::formatDownstreamAddressJustEndpointId(address);

    case StreamInfoAddressFieldExtractionType::WithPort:

    default:

      return address.asString();

    }

  }

  StreamInfoSslConnectionInfoFormatterProvider(FieldExtractor f) : field_extractor_(f) {}

  absl::optional<std::string> format(const StreamInfo::StreamInfo& stream_info) const override {

    if (stream_info.downstreamAddressProvider().sslConnection() == nullptr) {

      return absl::nullopt;

    }

    const auto value = field_extractor_(*stream_info.downstreamAddressProvider().sslConnection());

    if (value && value->empty()) {

      return absl::nullopt;

    }

    return value;

  }

  Protobuf::Value formatValue(const StreamInfo::StreamInfo& stream_info) const override {

    if (stream_info.downstreamAddressProvider().sslConnection() == nullptr) {

      return SubstitutionFormatUtils::unspecifiedValue();

    }

    const auto value = field_extractor_(*stream_info.downstreamAddressProvider().sslConnection());

    if (value && value->empty()) {

      return SubstitutionFormatUtils::unspecifiedValue();

    }

    return ValueUtil::optionalStringValue(value);

  }

  StreamInfoUpstreamSslConnectionInfoFormatterProvider(FieldExtractor f) : field_extractor_(f) {}

  absl::optional<std::string> format(const StreamInfo::StreamInfo& stream_info) const override {

    if (!stream_info.upstreamInfo() ||

        stream_info.upstreamInfo()->upstreamSslConnection() == nullptr) {

      return absl::nullopt;

    }

    const auto value = field_extractor_(*(stream_info.upstreamInfo()->upstreamSslConnection()));

    if (value && value->empty()) {

      return absl::nullopt;

    }

    return value;

  }

  Protobuf::Value formatValue(const StreamInfo::StreamInfo& stream_info) const override {

    if (!stream_info.upstreamInfo() ||

        stream_info.upstreamInfo()->upstreamSslConnection() == nullptr) {

      return SubstitutionFormatUtils::unspecifiedValue();

    }

    const auto value = field_extractor_(*(stream_info.upstreamInfo()->upstreamSslConnection()));

    if (value && value->empty()) {

      return SubstitutionFormatUtils::unspecifiedValue();

    }

    return ValueUtil::optionalStringValue(value);

  }

const StreamInfoFormatterProviderLookupTable& getKnownStreamInfoFormatterProviders() {

  CONSTRUCT_ON_FIRST_USE(StreamInfoFormatterProviderLookupTable,

                         {

                             {"REQUEST_DURATION",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoDurationFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       StreamInfo::TimingUtility timing(stream_info);

                                       return timing.lastDownstreamRxByteReceived();

                                     });

                               }}},

                             {"REQUEST_TX_DURATION",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoDurationFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       StreamInfo::TimingUtility timing(stream_info);

                                       return timing.lastUpstreamTxByteSent();

                                     });

                               }}},

                             {"RESPONSE_DURATION",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoDurationFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       StreamInfo::TimingUtility timing(stream_info);

                                       return timing.firstUpstreamRxByteReceived();

                                     });

                               }}},

                             {"RESPONSE_TX_DURATION",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoDurationFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       StreamInfo::TimingUtility timing(stream_info);

                                       auto downstream = timing.lastDownstreamTxByteSent();

                                       auto upstream = timing.firstUpstreamRxByteReceived();

                                       absl::optional<std::chrono::nanoseconds> result;

                                       if (downstream && upstream) {

                                         result = downstream.value() - upstream.value();

                                       }

                                       return result;

                                     });

                               }}},

                             {"DOWNSTREAM_HANDSHAKE_DURATION",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoDurationFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       StreamInfo::TimingUtility timing(stream_info);

                                       return timing.downstreamHandshakeComplete();

                                     });

                               }}},

                             {"ROUNDTRIP_DURATION",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoDurationFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       StreamInfo::TimingUtility timing(stream_info);

                                       return timing.lastDownstreamAckReceived();

                                     });

                               }}},

                             {"BYTES_RECEIVED",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       return stream_info.bytesReceived();

                                     });

                               }}},

                             {"BYTES_RETRANSMITTED",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       return stream_info.bytesRetransmitted();

                                     });

                               }}},

                             {"PACKETS_RETRANSMITTED",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       return stream_info.packetsRetransmitted();

                                     });

                               }}},

                             {"UPSTREAM_WIRE_BYTES_RECEIVED",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       const auto& bytes_meter =

                                           stream_info.getUpstreamBytesMeter();

                                       return bytes_meter ? bytes_meter->wireBytesReceived() : 0;

                                     });

                               }}},

                             {"UPSTREAM_HEADER_BYTES_RECEIVED",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       const auto& bytes_meter =

                                           stream_info.getUpstreamBytesMeter();

                                       return bytes_meter ? bytes_meter->headerBytesReceived() : 0;

                                     });

                               }}},

                             {"UPSTREAM_DECOMPRESSED_HEADER_BYTES_RECEIVED",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       const auto& bytes_meter =

                                           stream_info.getUpstreamBytesMeter();

                                       return bytes_meter

                                                  ? bytes_meter->decompressedHeaderBytesReceived()

                                                  : 0;

                                     });

                               }}},

                             {"DOWNSTREAM_WIRE_BYTES_RECEIVED",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       const auto& bytes_meter =

                                           stream_info.getDownstreamBytesMeter();

                                       return bytes_meter ? bytes_meter->wireBytesReceived() : 0;

                                     });

                               }}},

                             {"DOWNSTREAM_HEADER_BYTES_RECEIVED",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       const auto& bytes_meter =

                                           stream_info.getDownstreamBytesMeter();

                                       return bytes_meter ? bytes_meter->headerBytesReceived() : 0;

                                     });

                               }}},

                             {"DOWNSTREAM_DECOMPRESSED_HEADER_BYTES_RECEIVED",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       const auto& bytes_meter =

                                           stream_info.getDownstreamBytesMeter();

                                       return bytes_meter

                                                  ? bytes_meter->decompressedHeaderBytesReceived()

                                                  : 0;

                                     });

                               }}},

                             {"PROTOCOL",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoStringFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       return SubstitutionFormatUtils::protocolToString(

                                           stream_info.protocol());

                                     });

                               }}},

                             {"UPSTREAM_PROTOCOL",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoStringFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       return stream_info.upstreamInfo()

                                                  ? SubstitutionFormatUtils::protocolToString(

                                                        stream_info.upstreamInfo()

                                                            ->upstreamProtocol())

                                                  : absl::nullopt;

                                     });

                               }}},

                             {"RESPONSE_CODE",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       return stream_info.responseCode().value_or(0);

                                     });

                               }}},

                             {"RESPONSE_CODE_DETAILS",

                              {CommandSyntaxChecker::PARAMS_OPTIONAL,

                               [](absl::string_view format, absl::optional<size_t>) {

                                 bool allow_whitespaces = (format == "ALLOW_WHITESPACES");

                                 return std::make_unique<StreamInfoStringFormatterProvider>(

                                     [allow_whitespaces](

                                         const StreamInfo::StreamInfo& stream_info) {

                                       if (allow_whitespaces ||

                                           !stream_info.responseCodeDetails().has_value()) {

                                         return stream_info.responseCodeDetails();

                                       }

                                       return absl::optional<std::string>(

                                           StringUtil::replaceAllEmptySpace(

                                               stream_info.responseCodeDetails().value()));

                                     });

                               }}},

                             {"CONNECTION_TERMINATION_DETAILS",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoStringFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       return stream_info.connectionTerminationDetails();

                                     });

                               }}},

                             {"BYTES_SENT",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       return stream_info.bytesSent();

                                     });

                               }}},

                             {"UPSTREAM_WIRE_BYTES_SENT",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       const auto& bytes_meter =

                                           stream_info.getUpstreamBytesMeter();

                                       return bytes_meter ? bytes_meter->wireBytesSent() : 0;

                                     });

                               }}},

                             {"UPSTREAM_HEADER_BYTES_SENT",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       const auto& bytes_meter =

                                           stream_info.getUpstreamBytesMeter();

                                       return bytes_meter ? bytes_meter->headerBytesSent() : 0;

                                     });

                               }}},

                             {"UPSTREAM_DECOMPRESSED_HEADER_BYTES_SENT",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       const auto& bytes_meter =

                                           stream_info.getUpstreamBytesMeter();

                                       return bytes_meter

                                                  ? bytes_meter->decompressedHeaderBytesSent()

                                                  : 0;

                                     });

                               }}},

                             {"DOWNSTREAM_WIRE_BYTES_SENT",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       const auto& bytes_meter =

                                           stream_info.getDownstreamBytesMeter();

                                       return bytes_meter ? bytes_meter->wireBytesSent() : 0;

                                     });

                               }}},

                             {"DOWNSTREAM_HEADER_BYTES_SENT",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       const auto& bytes_meter =

                                           stream_info.getDownstreamBytesMeter();

                                       return bytes_meter ? bytes_meter->headerBytesSent() : 0;

                                     });

                               }}},

                             {"DOWNSTREAM_DECOMPRESSED_HEADER_BYTES_SENT",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoUInt64FormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       const auto& bytes_meter =

                                           stream_info.getDownstreamBytesMeter();

                                       return bytes_meter

                                                  ? bytes_meter->decompressedHeaderBytesSent()

                                                  : 0;

                                     });

                               }}},

                             {"DURATION",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoDurationFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       return stream_info.currentDuration();

                                     });

                               }}},

                             {"COMMON_DURATION",

                              {CommandSyntaxChecker::PARAMS_REQUIRED,

                               [](absl::string_view sub_command, absl::optional<size_t>) {

                                 return CommonDurationFormatter::create(sub_command);

                               }}},

                             {"CUSTOM_FLAGS",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoStringFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       return std::string(stream_info.customFlags());

                                     });

                               }}},

                             {"RESPONSE_FLAGS",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoStringFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       return StreamInfo::ResponseFlagUtils::toShortString(

                                           stream_info);

                                     });

                               }}},

                             {"RESPONSE_FLAGS_LONG",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoStringFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info) {

                                       return StreamInfo::ResponseFlagUtils::toString(stream_info);

                                     });

                               }}},

                             {"UPSTREAM_HOST_NAME",

                              {CommandSyntaxChecker::COMMAND_ONLY,

                               [](absl::string_view, absl::optional<size_t>) {

                                 return std::make_unique<StreamInfoStringFormatterProvider>(

                                     [](const StreamInfo::StreamInfo& stream_info)

                                         -> absl::optional<std::string> {

                                       const auto opt_ref = stream_info.upstreamInfo();

                                       if (!opt_ref.has_value()) {

                                         return absl::nullopt;

                                       }

                                       const auto host = opt_ref->upstreamHost();

                                       if (host == nullptr) {