Add tracking of response body-size and header-size

api/client/output.proto

@@ -14,17 +14,34 @@ message Counter {
 }
 
 message Percentile {
-  google.protobuf.Duration duration = 1;
+  oneof duration_type {
+    google.protobuf.Duration duration = 1;
+    double raw_value = 4;
+  }
   double percentile = 2;
   uint64 count = 3;
 }
 
 message Statistic {
   uint64 count = 1;
   string id = 2;
-  google.protobuf.Duration mean = 3;
-  google.protobuf.Duration pstdev = 4;
+  oneof mean_type {
+    google.protobuf.Duration mean = 3;
+    double raw_mean = 8;
+  }
+  oneof pstdev_type {
+    google.protobuf.Duration pstdev = 4;
+    double raw_pstdev = 10;
+  }
   repeated Percentile percentiles = 5;
+  oneof min_type {
+    google.protobuf.Duration min = 6;
+    uint64 raw_min = 12;
+  }
+  oneof max_type {
+    google.protobuf.Duration max = 7;
+    uint64 raw_max = 13;
+  }
 }
 
 message Result {

api/client/transform/fortio.proto

@@ -24,37 +24,66 @@ message FortioResult {
   // concatenated into this field, using ' ' as a separator.
   string Labels = 1;
 
+  // Start time of the load test execution.
   google.protobuf.Timestamp StartTime = 2;
 
+  // Configured qps
   uint32 RequestedQPS = 3;
 
+  // Configured duration
   google.protobuf.Duration RequestedDuration = 4;
 
+  // Effective qps
   double ActualQPS = 5;
 
+  // Effective duration
   double ActualDuration = 6;
 
+  // The configured number of used connections
   uint32 NumThreads = 7;
 
+  // Latency histogram
   DurationHistogram DurationHistogram = 8;
 
+  // Fortio tracks per-return-code. We group by 2xx,3xx, etc.
   map<string, uint64> RetCodes = 11;
 
+  // Effective URI.
   string URL = 12;
 
+  // (Unstructured) version. We serialize a representation of the Nighthawk version into this field.
   string Version = 13;
 
+  // Was jitter used Y/N.
   bool Jitter = 14;
 
+  // Run type. Can be "HTTP", "GRPC", and an empty string has also been observed.
+  // We only set HTTP for now.
   string RunType = 15;
 
-  // Exactly can be used to stop fortio after a fixed amount of replies.
+  // Sizes and HeaderSizes seems to mean different things in Fortio depending on if the go stdclient
+  // or DIY fastclient was used. We populate this field with response body sizes, and HeaderSizes
+  // with header sizes. Both are tracked in bytes. Note: we don't use full histograms here, but
+  // rather rely on StreamingStatistic. This means we don't populate percentiles, and only populate
+  // min/mean/max/etc with respect to DurationHistogram.
+  DurationHistogram Sizes = 16;
+
+  // See the 'Sizes' field for detals.
+  DurationHistogram HeaderSizes = 17;
+
+  // Some notes on fields that we do not populate today:
+
+  // "Exactly" can be used to stop fortio after a fixed amount of replies.
   // We don't seem to need this, and going forward it might be hard/annoying to
   // translate this field as Nighthawk's concepts diverge a bit. If end up
   // needing to we can probably inspect the main phase and then figure out if there's a
   // termination predicate configured for a fixed number of responses observed
   // via stats. For now, however, skip this field.
-  // uint64 Exactly = 16;
+
+  // We don't populate SocketCount (sometimes used to track #connections)
+
+  // We don't populate AbortOn (a status code that may abort termination) for reasons
+  // similar to Exactly.
 }
 
 message DurationHistogram {

include/nighthawk/common/statistic.h

@@ -25,18 +25,51 @@ using StatisticPtrMap = std::map<std::string, Statistic const*>;
  */
 class Statistic : Envoy::NonCopyable {
 public:
+  enum class SerializationDomain { RAW, DURATION };
+
   virtual ~Statistic() = default;
+
   /**
    * Method for adding a sample value.
    * @param value the value of the sample to add
    */
   virtual void addValue(uint64_t sample_value) PURE;
 
+  /**
+   * @return uint64_t The number of sampled values.
+   */
   virtual uint64_t count() const PURE;
+
+  /**
+   * @return double Mean derived from the sampled values.
+   */
   virtual double mean() const PURE;
+
+  /**
+   * @return double Variance derived from the sampled values.
+   */
   virtual double pvariance() const PURE;
+
+  /**
+   * @return double Standard deviation derived from the sampled values.
+   */
   virtual double pstdev() const PURE;
 
+  /**
+   * @return uint64_t The smallest sampled value.
+   */
+  virtual uint64_t min() const PURE;
+
+  /**
+   * @return uint64_t The largest sampled value.
+   */
+  virtual uint64_t max() const PURE;
+
+  /**
+   * @return StatisticPtr Yields a new instance of the same type as the instance this is called on.
+   */
+  virtual StatisticPtr createNewInstanceOfSameType() const PURE;
+
   /**
    * Only used in tests to match expectations to the right precision level.
    * @return uint64_t the number of significant digits. 0 is assumed to be max precision.
@@ -51,14 +84,15 @@ class Statistic : Envoy::NonCopyable {
   virtual bool resistsCatastrophicCancellation() const { return false; }
 
   /**
-   * @return std::string a representation of the statistic as a std::string.
+   * @return std::string Gets a string representation of the statistic as a std::string.
    */
   virtual std::string toString() const PURE;
 
   /**
+   * @param domain Used to indicate if serialization should represent durations or raw values.
    * @return nighthawk::client::Statistic a representation of the statistic as a protobuf message.
    */
-  virtual nighthawk::client::Statistic toProto() PURE;
+  virtual nighthawk::client::Statistic toProto(SerializationDomain domain) const PURE;
 
   /**
    * Combines two Statistics into one, and returns a new, merged, Statistic.

source/client/benchmark_client_impl.cc

@@ -92,19 +92,24 @@ void Http2PoolImpl::checkForDrained() {
 
 BenchmarkClientHttpImpl::BenchmarkClientHttpImpl(
     Envoy::Api::Api& api, Envoy::Event::Dispatcher& dispatcher, Envoy::Stats::Scope& scope,
-    StatisticPtr&& connect_statistic, StatisticPtr&& response_statistic, bool use_h2,
-    Envoy::Upstream::ClusterManagerPtr& cluster_manager, Envoy::Tracing::HttpTracerPtr& http_tracer,
-    absl::string_view cluster_name, RequestGenerator request_generator,
-    const bool provide_resource_backpressure)
+    StatisticPtr&& connect_statistic, StatisticPtr&& response_statistic,
+    StatisticPtr&& response_header_size_statistic, StatisticPtr&& response_body_size_statistic,
+    bool use_h2, Envoy::Upstream::ClusterManagerPtr& cluster_manager,
+    Envoy::Tracing::HttpTracerPtr& http_tracer, absl::string_view cluster_name,
+    RequestGenerator request_generator, const bool provide_resource_backpressure)
     : api_(api), dispatcher_(dispatcher), scope_(scope.createScope("benchmark.")),
       connect_statistic_(std::move(connect_statistic)),
-      response_statistic_(std::move(response_statistic)), use_h2_(use_h2),
+      response_statistic_(std::move(response_statistic)),
+      response_header_size_statistic_(std::move(response_header_size_statistic)),
+      response_body_size_statistic_(std::move(response_body_size_statistic)), use_h2_(use_h2),
       benchmark_client_stats_({ALL_BENCHMARK_CLIENT_STATS(POOL_COUNTER(*scope_))}),
       cluster_manager_(cluster_manager), http_tracer_(http_tracer),
       cluster_name_(std::string(cluster_name)), request_generator_(std::move(request_generator)),
       provide_resource_backpressure_(provide_resource_backpressure) {
   connect_statistic_->setId("benchmark_http_client.queue_to_connect");
   response_statistic_->setId("benchmark_http_client.request_to_response");
+  response_header_size_statistic_->setId("benchmark_http_client.response_header_size");
+  response_body_size_statistic_->setId("benchmark_http_client.response_body_size");
 }
 
 void BenchmarkClientHttpImpl::terminate() {
@@ -119,6 +124,8 @@ StatisticPtrMap BenchmarkClientHttpImpl::statistics() const {
   StatisticPtrMap statistics;
   statistics[connect_statistic_->id()] = connect_statistic_.get();
   statistics[response_statistic_->id()] = response_statistic_.get();
+  statistics[response_header_size_statistic_->id()] = response_header_size_statistic_.get();
+  statistics[response_body_size_statistic_->id()] = response_body_size_statistic_.get();
   return statistics;
 };
 
@@ -157,8 +164,9 @@ bool BenchmarkClientHttpImpl::tryStartRequest(CompletionCallback caller_completi
   std::string x_request_id = generator_.uuid();
   auto stream_decoder = new StreamDecoder(
       dispatcher_, api_.timeSource(), *this, std::move(caller_completion_callback),
-      *connect_statistic_, *response_statistic_, request->header(), measureLatencies(),
-      content_length, x_request_id, http_tracer_);
+      *connect_statistic_, *response_statistic_, *response_header_size_statistic_,
+      *response_body_size_statistic_, request->header(), measureLatencies(), content_length,
+      x_request_id, http_tracer_);
   requests_initiated_++;
   pool_ptr->newStream(*stream_decoder, *stream_decoder);
   return true;

source/client/benchmark_client_impl.h

@@ -116,7 +116,9 @@ class BenchmarkClientHttpImpl : public BenchmarkClient,
 public:
   BenchmarkClientHttpImpl(Envoy::Api::Api& api, Envoy::Event::Dispatcher& dispatcher,
                           Envoy::Stats::Scope& scope, StatisticPtr&& connect_statistic,
-                          StatisticPtr&& response_statistic, bool use_h2,
+                          StatisticPtr&& response_statistic,
+                          StatisticPtr&& response_header_size_statistic,
+                          StatisticPtr&& response_body_size_statistic, bool use_h2,
                           Envoy::Upstream::ClusterManagerPtr& cluster_manager,
                           Envoy::Tracing::HttpTracerPtr& http_tracer,
                           absl::string_view cluster_name, RequestGenerator request_generator,
@@ -161,6 +163,8 @@ class BenchmarkClientHttpImpl : public BenchmarkClient,
   // destruction when tls has been involved during usage.
   StatisticPtr connect_statistic_;
   StatisticPtr response_statistic_;
+  StatisticPtr response_header_size_statistic_;
+  StatisticPtr response_body_size_statistic_;
   const bool use_h2_;
   std::chrono::seconds timeout_{5s};
   uint32_t connection_limit_{1};

source/client/factories_impl.cc

@@ -31,8 +31,15 @@ BenchmarkClientPtr BenchmarkClientFactoryImpl::create(
     Envoy::Upstream::ClusterManagerPtr& cluster_manager, Envoy::Tracing::HttpTracerPtr& http_tracer,
     absl::string_view cluster_name, RequestSource& request_generator) const {
   StatisticFactoryImpl statistic_factory(options_);
+  // While we lack options to configure which statistic backend goes where, we directly pass
+  // StreamingStatistic for the stats that track response sizes. Ideally we would have options
+  // for this to route the right stat to the right backend (HdrStatistic, SimpleStatistic,
+  // NullStatistic).
+  // TODO(#292): Create options and have the StatisticFactory consider those when instantiating
+  // statistics.
   auto benchmark_client = std::make_unique<BenchmarkClientHttpImpl>(
-      api, dispatcher, scope, statistic_factory.create(), statistic_factory.create(), options_.h2(),
+      api, dispatcher, scope, statistic_factory.create(), statistic_factory.create(),
+      std::make_unique<StreamingStatistic>(), std::make_unique<StreamingStatistic>(), options_.h2(),
       cluster_manager, http_tracer, cluster_name, request_generator.get(), !options_.openLoop());
   auto request_options = options_.toCommandLineOptions()->request_options();
   benchmark_client->setConnectionLimit(options_.connections());

source/client/output_collector_impl.cc

@@ -30,7 +30,14 @@ void OutputCollectorImpl::addResult(absl::string_view name,
   auto result = output_.add_results();
   result->set_name(name.data(), name.size());
   for (auto& statistic : statistics) {
-    *(result->add_statistics()) = statistic->toProto();
+    // TODO(#292): Looking at if the statistic id ends with "_size" to determine how it should be
+    // serialized is kind of hacky. Maybe we should have a lookup table of sorts, to determine how
+    // statistics should we serialized. Doing so may give us a canonical place to consolidate their
+    // ids as well too.
+    Statistic::SerializationDomain serialization_domain =
+        absl::EndsWith(statistic->id(), "_size") ? Statistic::SerializationDomain::RAW
+                                                 : Statistic::SerializationDomain::DURATION;
+    *(result->add_statistics()) = statistic->toProto(serialization_domain);
   }
   for (const auto& counter : counters) {
     auto new_counters = result->add_counters();