: handler_(handler), params_(params), admin_stream_(admin_stream) {}

  Http::Code start(Http::ResponseHeaderMap& response_headers) override {

    code_ = handler_.prometheusFlushAndRender(params_, admin_stream_.getRequestHeaders(),

                                              response_headers, response_);

    return code_;

  }

  bool nextChunk(Buffer::Instance& response) override {

    response.move(response_);

    return false;

  }

StatsHandler::StatsHandler(Server::Instance& server) : HandlerContextBase(server) {}

                                              AdminStream&) {

  for (const Stats::CounterSharedPtr& counter : server_.stats().counters()) {

    counter->reset();

  }

  server_.stats().symbolTable().clearRecentLookups();

  response.add("OK\n");

  return Http::Code::OK;

}

                                                   Buffer::Instance& response, AdminStream&) {

  Stats::SymbolTable& symbol_table = server_.stats().symbolTable();

  std::string table;

  const uint64_t total =

      symbol_table.getRecentLookups([&table](absl::string_view name, uint64_t count) {

        table += fmt::format("{:8d} {}\n", count, name);

      });

  if (table.empty() && symbol_table.recentLookupCapacity() == 0) {

    table = "Lookup tracking is not enabled. Use /stats/recentlookups/enable to enable.\n";

  } else {

    response.add("   Count Lookup\n");

  }

  response.add(absl::StrCat(table, "\ntotal: ", total, "\n"));

  return Http::Code::OK;

}

                                                        Buffer::Instance& response, AdminStream&) {

  server_.stats().symbolTable().clearRecentLookups();

  response.add("OK\n");

  return Http::Code::OK;

}

                                                          AdminStream&) {

  server_.stats().symbolTable().setRecentLookupCapacity(0);

  response.add("OK\n");

  return Http::Code::OK;

}

                                                         Buffer::Instance& response, AdminStream&) {

  server_.stats().symbolTable().setRecentLookupCapacity(RecentLookupsCapacity);

  response.add("OK\n");

  return Http::Code::OK;

}

Admin::RequestPtr StatsHandler::makeRequest(AdminStream& admin_stream) {

  StatsParams params;

  Buffer::OwnedImpl response;

  Http::Code code = params.parse(admin_stream.getRequestHeaders().getPathValue(), response);

  if (code != Http::Code::OK) {

    return Admin::makeStaticTextRequest(response, code);

  }

  if (params.format_ == StatsFormat::Prometheus) {

    return std::make_unique<PrometheusRequest>(*this, params, admin_stream);

  }

  if (params.histogram_buckets_mode_ == Utility::HistogramBucketsMode::PrometheusNative) {

    return Admin::makeStaticTextRequest(

        "Invalid histogram_buckets type for non prometheus stats type", Http::Code::BadRequest);

  }

  if (server_.statsConfig().flushOnAdmin()) {

    server_.flushStats();

  }

  bool active_mode;

#ifdef ENVOY_ADMIN_HTML

  active_mode = params.format_ == StatsFormat::ActiveHtml;

  return makeRequest(

      server_.stats(), params, server_.clusterManager(),

      [this, active_mode]() -> Admin::UrlHandler { return statsHandler(active_mode); });

}

                                            StatsRequest::UrlHandlerFn url_handler_fn) {

  return std::make_unique<StatsRequest>(stats, params, cluster_manager, url_handler_fn);

}

                                                AdminStream& admin_stream) {

  return prometheusStats(admin_stream.getRequestHeaders(), response_headers, response);

}

                                         Buffer::Instance& response) {

  StatsParams params;

  Http::Code code = params.parse(request_headers.getPathValue(), response);

  if (code != Http::Code::OK) {

  return prometheusFlushAndRender(params, request_headers, response_headers, response);

}

                                                  Buffer::Instance& response) {

  absl::Status paramsStatus = PrometheusStatsFormatter::validateParams(params, request_headers);

  if (!paramsStatus.ok()) {

    response.add(paramsStatus.message());

    return Http::Code::BadRequest;

  }

  if (server_.statsConfig().flushOnAdmin()) {

  prometheusRender(server_.stats(), server_.api().customStatNamespaces(), server_.clusterManager(),

                   params, request_headers, response_headers, response);

  return Http::Code::OK;

}

                                    Buffer::Instance& response) {

  const std::vector<Stats::TextReadoutSharedPtr>& text_readouts_vec =

      params.prometheus_text_readouts_ ? stats.textReadouts()

                                       : std::vector<Stats::TextReadoutSharedPtr>();

  PrometheusStatsFormatter::statsAsPrometheus(

      stats.counters(), stats.gauges(), stats.histograms(), text_readouts_vec, cluster_manager,

      request_headers, response_headers, response, params, custom_namespaces);

}

                                           Buffer::Instance& response, AdminStream&) {

  if (server_.options().mutexTracingEnabled() && server_.mutexTracer() != nullptr) {

    response_headers.setReferenceContentType(Http::Headers::get().ContentTypeValues.Json);

    envoy::admin::v3::MutexStats mutex_stats;

    mutex_stats.set_num_contentions(server_.mutexTracer()->numContentions());

    mutex_stats.set_current_wait_cycles(server_.mutexTracer()->currentWaitCycles());

    mutex_stats.set_lifetime_wait_cycles(server_.mutexTracer()->lifetimeWaitCycles());

    response.add(MessageUtil::getJsonStringFromMessageOrError(mutex_stats, true, true));

  } else {

    response.add("Mutex contention tracing is not enabled. To enable, run Envoy with flag "

                 "--enable-mutex-tracing.");

  }

  return Http::Code::OK;

}

Admin::UrlHandler StatsHandler::statsHandler(bool active_mode) {

  Admin::ParamDescriptor usedonly{

      Admin::ParamDescriptor::Type::Boolean, "usedonly",

      "Only include stats that have been written by system since restart"};

  Admin::ParamDescriptor histogram_buckets{Admin::ParamDescriptor::Type::Enum,

                                           "histogram_buckets",

                                           "Histogram bucket display mode",

                                           {"cumulative", "disjoint", "detailed", "summary"}};

  Admin::ParamDescriptor format{Admin::ParamDescriptor::Type::Enum,

                                "format",

                                "Format to use",

                                {"html", "active-html", "text", "json"}};

  Admin::ParamDescriptor filter{Admin::ParamDescriptor::Type::String, "filter",

                                "Regular expression (Google re2) for filtering stats"};

  Admin::ParamDescriptor type{Admin::ParamDescriptor::Type::Enum,

                              "type",

                              "Stat types to include.",

                              {StatLabels::All, StatLabels::Counters, StatLabels::Histograms,

                               StatLabels::Gauges, StatLabels::TextReadouts}};

  Admin::ParamDescriptorVec params{usedonly, filter};

  if (!active_mode) {

    params.push_back(format);

  }

  params.push_back(type);

  if (!active_mode) {

    params.push_back(histogram_buckets);

  }

  return {

      "/stats",

      "print server stats",

      [this](AdminStream& admin_stream) -> Admin::RequestPtr { return makeRequest(admin_stream); },

      false,

      false,

      params};

}