Schedule option

api/client/options.proto

@@ -3,6 +3,7 @@ syntax = "proto3";
 package nighthawk.client;
 
 import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
 import "google/protobuf/wrappers.proto";
 import "envoy/config/core/v3/base.proto";
 import "envoy/config/metrics/v3/stats.proto";
@@ -219,4 +220,7 @@ message CommandLineOptions {
   // "emit_previous_request_delta_in_response_header" to record elapsed time between request
   // arrivals.
   google.protobuf.StringValue latency_response_header_name = 36;
+  // Provide an execution starting date and time. Optional, any value specified must be in the
+  // future.
+  google.protobuf.Timestamp scheduled_start = 105;
 }

api/client/output.proto

@@ -49,6 +49,7 @@ message Result {
   repeated Statistic statistics = 2;
   repeated Counter counters = 3;
   google.protobuf.Duration execution_duration = 4;
+  google.protobuf.Timestamp execution_start = 5;
 }
 
 message Output {

include/nighthawk/client/options.h

@@ -6,6 +6,7 @@
 #include <string>
 
 #include "envoy/common/pure.h"
+#include "envoy/common/time.h"
 #include "envoy/config/cluster/v3/cluster.pb.h"
 #include "envoy/config/core/v3/base.pb.h"
 #include "envoy/config/metrics/v3/stats.pb.h"
@@ -74,7 +75,7 @@ class Options {
   virtual std::vector<envoy::config::metrics::v3::StatsSink> statsSinks() const PURE;
   virtual uint32_t statsFlushInterval() const PURE;
   virtual std::string responseHeaderWithLatencyInput() const PURE;
-
+  virtual absl::optional<Envoy::SystemTime> scheduled_start() const PURE;
   /**
    * Converts an Options instance to an equivalent CommandLineOptions instance in terms of option
    * values.

include/nighthawk/client/output_collector.h

@@ -3,9 +3,12 @@
 #include <memory>
 
 #include "envoy/common/pure.h"
+#include "envoy/common/time.h"
 
 #include "nighthawk/common/statistic.h"
 
+#include "absl/types/optional.h"
+
 namespace Nighthawk {
 namespace Client {
 
@@ -23,10 +26,12 @@ class OutputCollector {
    * @param statistics Reference to a vector of statistics to add to the output.
    * @param counters Reference to a map of counter values, keyed by name, to add to the output.
    * @param execution_duration Execution duration associated to the to-be-added result.
+   * @param first_acquisition_time Timing of the first rate limiter acquisition.
    */
   virtual void addResult(absl::string_view name, const std::vector<StatisticPtr>& statistics,
                          const std::map<std::string, uint64_t>& counters,
-                         const std::chrono::nanoseconds execution_duration) PURE;
+                         const std::chrono::nanoseconds execution_duration,
+                         const absl::optional<Envoy::SystemTime>& first_acquisition_time) PURE;
   /**
    * Directly sets the output value.
    *

include/nighthawk/common/factories.h

@@ -24,7 +24,7 @@ class SequencerFactory {
                               const SequencerTarget& sequencer_target,
                               TerminationPredicatePtr&& termination_predicate,
                               Envoy::Stats::Scope& scope,
-                              const Envoy::SystemTime scheduled_starting_time) const PURE;
+                              const Envoy::MonotonicTime scheduled_starting_time) const PURE;
 };
 
 class StatisticFactory {
@@ -46,7 +46,7 @@ class TerminationPredicateFactory {
   virtual ~TerminationPredicateFactory() = default;
   virtual TerminationPredicatePtr
   create(Envoy::TimeSource& time_source, Envoy::Stats::Scope& scope,
-         const Envoy::SystemTime scheduled_starting_time) const PURE;
+         const Envoy::MonotonicTime scheduled_starting_time) const PURE;
 };
 
 /**

include/nighthawk/common/rate_limiter.h

@@ -33,6 +33,12 @@ class RateLimiter {
    * @return Envoy::TimeSource& time_source used to track time.
    */
   virtual Envoy::TimeSource& timeSource() PURE;
+
+  /**
+   * @return absl::optional<Envoy::SystemTime> Time of the first acquisition, if any.
+   */
+  virtual absl::optional<Envoy::SystemTime> firstAcquisitionTime() const PURE;
+
   /**
    * @return std::chrono::nanoseconds elapsed since the first call to tryAcquireOne(). Used by some
    * rate limiter implementations to compute acquisition rate.

include/nighthawk/common/sequencer.h

@@ -7,6 +7,7 @@
 #include "envoy/common/pure.h"
 
 #include "nighthawk/common/operation_callback.h"
+#include "nighthawk/common/rate_limiter.h"
 #include "nighthawk/common/statistic.h"
 
 namespace Nighthawk {
@@ -35,6 +36,11 @@ class Sequencer {
    */
   virtual std::chrono::nanoseconds executionDuration() const PURE;
 
+  /**
+   * @return RateLimiter& reference to the rate limiter associated to this sequencer.
+   */
+  virtual const RateLimiter& rate_limiter() const PURE;
+
   /**
    * @return double an up-to-date completions per second rate.
    */

source/client/client_worker_impl.cc

@@ -19,7 +19,7 @@ ClientWorkerImpl::ClientWorkerImpl(Envoy::Api::Api& api, Envoy::ThreadLocal::Ins
                                    const SequencerFactory& sequencer_factory,
                                    const RequestSourceFactory& request_generator_factory,
                                    Envoy::Stats::Store& store, const int worker_number,
-                                   const Envoy::SystemTime starting_time,
+                                   const Envoy::MonotonicTime starting_time,
                                    Envoy::Tracing::HttpTracerSharedPtr& http_tracer,
                                    const HardCodedWarmupStyle hardcoded_warmup_style)
     : WorkerImpl(api, tls, store),

source/client/client_worker_impl.h

@@ -33,7 +33,7 @@ class ClientWorkerImpl : public WorkerImpl, virtual public ClientWorker {
                    const SequencerFactory& sequencer_factory,
                    const RequestSourceFactory& request_generator_factory,
                    Envoy::Stats::Store& store, const int worker_number,
-                   const Envoy::SystemTime starting_time,
+                   const Envoy::MonotonicTime starting_time,
                    Envoy::Tracing::HttpTracerSharedPtr& http_tracer,
                    const HardCodedWarmupStyle hardcoded_warmup_style);
   StatisticPtrMap statistics() const override;

source/client/factories_impl.cc

@@ -65,12 +65,10 @@ BenchmarkClientPtr BenchmarkClientFactoryImpl::create(
 SequencerFactoryImpl::SequencerFactoryImpl(const Options& options)
     : OptionBasedFactoryImpl(options) {}
 
-SequencerPtr SequencerFactoryImpl::create(Envoy::TimeSource& time_source,
-                                          Envoy::Event::Dispatcher& dispatcher,
-                                          const SequencerTarget& sequencer_target,
-                                          TerminationPredicatePtr&& termination_predicate,
-                                          Envoy::Stats::Scope& scope,
-                                          const Envoy::SystemTime scheduled_starting_time) const {
+SequencerPtr SequencerFactoryImpl::create(
+    Envoy::TimeSource& time_source, Envoy::Event::Dispatcher& dispatcher,
+    const SequencerTarget& sequencer_target, TerminationPredicatePtr&& termination_predicate,
+    Envoy::Stats::Scope& scope, const Envoy::MonotonicTime scheduled_starting_time) const {
   StatisticFactoryImpl statistic_factory(options_);
   Frequency frequency(options_.requestsPerSecond());
   RateLimiterPtr rate_limiter = std::make_unique<ScheduledStartingRateLimiter>(
@@ -211,7 +209,7 @@ TerminationPredicateFactoryImpl::TerminationPredicateFactoryImpl(const Options&
 
 TerminationPredicatePtr
 TerminationPredicateFactoryImpl::create(Envoy::TimeSource& time_source, Envoy::Stats::Scope& scope,
-                                        const Envoy::SystemTime scheduled_starting_time) const {
+                                        const Envoy::MonotonicTime scheduled_starting_time) const {
   // We'll always link a predicate which checks for requests to cancel.
   TerminationPredicatePtr root_predicate =
       std::make_unique<StatsCounterAbsoluteThresholdTerminationPredicateImpl>(

source/client/factories_impl.h

@@ -44,7 +44,7 @@ class SequencerFactoryImpl : public OptionBasedFactoryImpl, public SequencerFact
   SequencerPtr create(Envoy::TimeSource& time_source, Envoy::Event::Dispatcher& dispatcher,
                       const SequencerTarget& sequencer_target,
                       TerminationPredicatePtr&& termination_predicate, Envoy::Stats::Scope& scope,
-                      const Envoy::SystemTime scheduled_starting_time) const override;
+                      const Envoy::MonotonicTime scheduled_starting_time) const override;
 };
 
 class StatisticFactoryImpl : public OptionBasedFactoryImpl, public StatisticFactory {
@@ -93,7 +93,7 @@ class TerminationPredicateFactoryImpl : public OptionBasedFactoryImpl,
 public:
   TerminationPredicateFactoryImpl(const Options& options);
   TerminationPredicatePtr create(Envoy::TimeSource& time_source, Envoy::Stats::Scope& scope,
-                                 const Envoy::SystemTime scheduled_starting_time) const override;
+                                 const Envoy::MonotonicTime scheduled_starting_time) const override;
   TerminationPredicate* linkConfiguredPredicates(
       TerminationPredicate& last_predicate, const TerminationPredicateMap& predicates,
       const TerminationPredicate::Status termination_status, Envoy::Stats::Scope& scope) const;

source/client/options_impl.cc

@@ -652,7 +652,12 @@ OptionsImpl::OptionsImpl(const nighthawk::client::CommandLineOptions& options) {
   std::copy(options.labels().begin(), options.labels().end(), std::back_inserter(labels_));
   latency_response_header_name_ = PROTOBUF_GET_WRAPPED_OR_DEFAULT(
       options, latency_response_header_name, latency_response_header_name_);
-
+  if (options.has_scheduled_start()) {
+    const auto elapsed_since_epoch = std::chrono::nanoseconds(options.scheduled_start().nanos()) +
+                                     std::chrono::seconds(options.scheduled_start().seconds());
+    scheduled_start_ =
+        Envoy::SystemTime(std::chrono::time_point<std::chrono::system_clock>(elapsed_since_epoch));
+  }
   validate();
 }
 
@@ -829,6 +834,11 @@ CommandLineOptionsPtr OptionsImpl::toCommandLineOptionsInternal() const {
   command_line_options->mutable_stats_flush_interval()->set_value(stats_flush_interval_);
   command_line_options->mutable_latency_response_header_name()->set_value(
       latency_response_header_name_);
+  if (scheduled_start_.has_value()) {
+    *(command_line_options->mutable_scheduled_start()) =
+        Envoy::ProtobufUtil::TimeUtil::NanosecondsToTimestamp(
+            scheduled_start_.value().time_since_epoch().count());
+  }
   return command_line_options;
 }
 

source/client/options_impl.h

@@ -93,6 +93,7 @@ class OptionsImpl : public Options, public Envoy::Logger::Loggable<Envoy::Logger
   std::string responseHeaderWithLatencyInput() const override {
     return latency_response_header_name_;
   };
+  absl::optional<Envoy::SystemTime> scheduled_start() const override { return scheduled_start_; }
 
 private:
   void parsePredicates(const TCLAP::MultiArg<std::string>& arg,
@@ -149,6 +150,7 @@ class OptionsImpl : public Options, public Envoy::Logger::Loggable<Envoy::Logger
   std::vector<envoy::config::metrics::v3::StatsSink> stats_sinks_;
   uint32_t stats_flush_interval_{5};
   std::string latency_response_header_name_;
+  absl::optional<Envoy::SystemTime> scheduled_start_;
 };
 
 } // namespace Client

source/client/output_collector_impl.cc

@@ -23,12 +23,19 @@ OutputCollectorImpl::OutputCollectorImpl(Envoy::TimeSource& time_source, const O
 
 nighthawk::client::Output OutputCollectorImpl::toProto() const { return output_; }
 
-void OutputCollectorImpl::addResult(absl::string_view name,
-                                    const std::vector<StatisticPtr>& statistics,
-                                    const std::map<std::string, uint64_t>& counters,
-                                    const std::chrono::nanoseconds execution_duration) {
+void OutputCollectorImpl::addResult(
+    absl::string_view name, const std::vector<StatisticPtr>& statistics,
+    const std::map<std::string, uint64_t>& counters,
+    const std::chrono::nanoseconds execution_duration,
+    const absl::optional<Envoy::SystemTime>& first_acquisition_time) {
   auto result = output_.add_results();
   result->set_name(name.data(), name.size());
+  if (first_acquisition_time.has_value()) {
+    *(result->mutable_execution_start()) = Envoy::Protobuf::util::TimeUtil::NanosecondsToTimestamp(
+        std::chrono::duration_cast<std::chrono::nanoseconds>(
+            first_acquisition_time.value().time_since_epoch())
+            .count());
+  }
   for (auto& statistic : statistics) {
     // 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

source/client/output_collector_impl.h

@@ -20,7 +20,8 @@ class OutputCollectorImpl : public OutputCollector {
 
   void addResult(absl::string_view name, const std::vector<StatisticPtr>& statistics,
                  const std::map<std::string, uint64_t>& counters,
-                 const std::chrono::nanoseconds execution_duration) override;
+                 const std::chrono::nanoseconds execution_duration,
+                 const absl::optional<Envoy::SystemTime>& first_acquisition_time) override;
   void setOutput(const nighthawk::client::Output& output) override { output_ = output; }
 
   nighthawk::client::Output toProto() const override;