Added a new metric: Client Processing Time

osbenchmark/client.py

@@ -57,15 +57,27 @@ def request_start(self):
     def request_end(self):
         return self.ctx["request_end"]
 
+    @property
+    def client_request_start(self):
+        return self.ctx["client_request_start"]
+
+    @property
+    def client_request_end(self):
+        return self.ctx["client_request_end"]
+
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         # propagate earliest request start and most recent request end to parent
         request_start = self.request_start
         request_end = self.request_end
+        client_request_start = self.client_request_start
+        client_request_end = self.client_request_end
         self.ctx_holder.restore_context(self.token)
         # don't attempt to restore these values on the top-level context as they don't exist
         if self.token.old_value != contextvars.Token.MISSING:
             self.ctx_holder.update_request_start(request_start)
             self.ctx_holder.update_request_end(request_end)
+            self.ctx_holder.update_client_request_start(client_request_start)
+            self.ctx_holder.update_client_request_end(client_request_end)
         self.token = None
         return False
 
@@ -101,6 +113,25 @@ def update_request_end(cls, new_request_end):
         meta = cls.request_context.get()
         meta["request_end"] = new_request_end
 
+    @classmethod
+    def update_client_request_start(cls, new_client_request_start):
+        meta = cls.request_context.get()
+        if "client_request_start" not in meta:
+            meta["client_request_start"] = new_client_request_start
+
+    @classmethod
+    def update_client_request_end(cls, new_client_request_end):
+        meta = cls.request_context.get()
+        meta["client_request_end"] = new_client_request_end
+
+    @classmethod
+    def on_client_request_start(cls):
+        cls.update_client_request_start(time.perf_counter())
+
+    @classmethod
+    def on_client_request_end(cls):
+        cls.update_client_request_end(time.perf_counter())
+
     @classmethod
     def on_request_start(cls):
         cls.update_request_start(time.perf_counter())

osbenchmark/metrics.py

@@ -1742,6 +1742,7 @@ def __call__(self):
                         self.summary_stats("throughput", t, op_type),
                         self.single_latency(t, op_type),
                         self.single_latency(t, op_type, metric_name="service_time"),
+                        self.single_latency(t, op_type, metric_name="client_processing_time"),
                         self.single_latency(t, op_type, metric_name="processing_time"),
                         error_rate,
                         duration,
@@ -1991,6 +1992,8 @@ def op_metrics(op_item, key, single_value=False):
                         all_results.append(op_metrics(item, "latency"))
                     if "service_time" in item:
                         all_results.append(op_metrics(item, "service_time"))
+                    if "client_processing_time" in item:
+                        all_results.append(op_metrics(item, "client_processing_time"))
                     if "processing_time" in item:
                         all_results.append(op_metrics(item, "processing_time"))
                     if "error_rate" in item:
@@ -2035,13 +2038,15 @@ def op_metrics(op_item, key, single_value=False):
     def v(self, d, k, default=None):
         return d.get(k, default) if d else default
 
-    def add_op_metrics(self, task, operation, throughput, latency, service_time, processing_time, error_rate, duration, meta):
+    def add_op_metrics(self, task, operation, throughput, latency, service_time, client_processing_time,
+                       processing_time, error_rate, duration, meta):
         doc = {
             "task": task,
             "operation": operation,
             "throughput": throughput,
             "latency": latency,
             "service_time": service_time,
+            "client_processing_time": client_processing_time,
             "processing_time": processing_time,
             "error_rate": error_rate,
             "duration": duration