Enabled latencystats metric collection and fixed lack of setupname on timeseries for cpu/memory/commandstats (#400)

* Enabled latencystats metric collection and fixed lack of setupname on timeseries for cpu/memory/commandstats

* Enabled commandstats/latencystats/cpu/memory data collection on all branches and tags

* Extended test_metrics with latencystats checks

Author: filipecosta90

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "redisbench-admin"
-version = "0.10.0"
+version = "0.10.1"
 description = "Redis benchmark run helper. A wrapper around Redis and Redis Modules benchmark tools ( ftsb_redisearch, memtier_benchmark, redis-benchmark, aibench, etc... )."
 authors = ["filipecosta90 <filipecosta.90@gmail.com>","Redis Performance Group <performance@redis.com>"]
 readme = "README.md"

redisbench_admin/run/metrics.py

@@ -85,7 +85,9 @@ def extract_results_table(
 
 
 def collect_redis_metrics(
-    redis_conns, sections=["memory", "cpu", "commandstats"], section_filter=None
+    redis_conns,
+    sections=["memory", "cpu", "commandstats", "latencystats"],
+    section_filter=None,
 ):
     start_time = dt.datetime.utcnow()
     start_time_ms = int((start_time - dt.datetime(1970, 1, 1)).total_seconds() * 1000)

redisbench_admin/run_remote/run_remote.py

@@ -89,12 +89,7 @@
 
 
 def is_important_data(tf_github_branch, artifact_version):
-    if artifact_version is not None or (
-        tf_github_branch == "master" or tf_github_branch == "main"
-    ):
-        return True
-    else:
-        return False
+    return True
 
 
 def run_remote_command_logic(args, project_name, project_version):
@@ -812,6 +807,28 @@ def run_remote_command_logic(args, project_name, project_version):
                                                     {"metric-type": "commandstats"},
                                                     expire_ms,
                                                 )
+                                                (
+                                                    end_time_ms,
+                                                    _,
+                                                    overall_commandstats_metrics,
+                                                ) = collect_redis_metrics(
+                                                    redis_conns, ["latencystats"]
+                                                )
+                                                export_redis_metrics(
+                                                    artifact_version,
+                                                    end_time_ms,
+                                                    overall_commandstats_metrics,
+                                                    rts,
+                                                    setup_name,
+                                                    setup_type,
+                                                    test_name,
+                                                    tf_github_branch,
+                                                    tf_github_org,
+                                                    tf_github_repo,
+                                                    tf_triggering_env,
+                                                    {"metric-type": "latencystats"},
+                                                    expire_ms,
+                                                )
 
                                         if setup_details["env"] is None:
                                             if (
@@ -1204,10 +1221,11 @@ def export_redis_metrics(
             metric_name,
             metric_value,
         ) in overall_end_time_metrics.items():
-            tsname_metric = "{}/{}/{}/benchmark_end/{}".format(
+            tsname_metric = "{}/{}/{}/benchmark_end/{}/{}".format(
                 sprefix,
                 test_name,
                 by_variant,
+                setup_name,
                 metric_name,
             )
 
@@ -1219,8 +1237,18 @@ def export_redis_metrics(
                     tsname_metric,
                 )
             )
-            variant_labels_dict["test_name"] = test_name
             variant_labels_dict["metric"] = metric_name
+            commandstats_latencystats_process_name(
+                metric_name, "commandstats_cmdstat_", setup_name, variant_labels_dict
+            )
+            commandstats_latencystats_process_name(
+                metric_name,
+                "latencystats_latency_percentiles_usec_",
+                setup_name,
+                variant_labels_dict,
+            )
+
+            variant_labels_dict["test_name"] = test_name
             if metadata_dict is not None:
                 variant_labels_dict.update(metadata_dict)
 
@@ -1243,6 +1271,28 @@ def export_redis_metrics(
     return datapoint_errors, datapoint_inserts
 
 
+def commandstats_latencystats_process_name(
+    metric_name, prefix, setup_name, variant_labels_dict
+):
+    if prefix in metric_name:
+        command_and_metric_and_shard = metric_name[len(prefix) :]
+        command = (
+            command_and_metric_and_shard[0]
+            + command_and_metric_and_shard[1:].split("_", 1)[0]
+        )
+        metric_and_shard = command_and_metric_and_shard[1:].split("_", 1)[1]
+        metric = metric_and_shard
+        shard = "1"
+        if "_shard_" in metric_and_shard:
+            metric = metric_and_shard.split("_shard_")[0]
+            shard = metric_and_shard.split("_shard_")[1]
+        variant_labels_dict["metric"] = metric
+        variant_labels_dict["command"] = command
+        variant_labels_dict["command_and_setup"] = "{} - {}".format(command, setup_name)
+        variant_labels_dict["shard"] = shard
+        variant_labels_dict["metric_and_shard"] = metric_and_shard
+
+
 def shutdown_remote_redis(redis_conns, ssh_tunnel):
     logging.info("Shutting down remote redis.")
     for conn in redis_conns:

tests/test_metrics.py

@@ -41,10 +41,11 @@ def test_collect_redis_metrics():
     rts.ping()
     time_ms, metrics_arr, overall_metrics = collect_redis_metrics([rts])
     assert len(metrics_arr) == 1
-    assert len(metrics_arr[0].keys()) == 3
+    assert len(metrics_arr[0].keys()) == 4
     assert "cpu" in metrics_arr[0].keys()
     assert "memory" in metrics_arr[0].keys()
     assert "commandstats" in metrics_arr[0].keys()
+    assert "latencystats" in metrics_arr[0].keys()
     assert "allocator_active" in metrics_arr[0]["memory"]
     assert "cmdstat_ping" in metrics_arr[0]["commandstats"]
     allocator_active = metrics_arr[0]["memory"]["allocator_active"]
@@ -55,5 +56,9 @@ def test_collect_redis_metrics():
     assert "memory_allocator_active" in overall_metrics
     assert "cmdstat_ping" in metrics_arr[0]["commandstats"]
     assert "cmdstat_ping" in metrics_arr[1]["commandstats"]
+    assert "latency_percentiles_usec_ping" in metrics_arr[0]["latencystats"]
+    assert "latency_percentiles_usec_ping" in metrics_arr[1]["latencystats"]
     assert "commandstats_cmdstat_ping_calls_shard_1" in overall_metrics
     assert "commandstats_cmdstat_ping_calls_shard_2" in overall_metrics
+    assert "latencystats_latency_percentiles_usec_ping_p50_shard_1" in overall_metrics
+    assert "latencystats_latency_percentiles_usec_ping_p50_shard_2" in overall_metrics

tests/test_run_remote.py

@@ -82,17 +82,41 @@ def test_export_redis_metrics():
             tf_triggering_env,
             {"metric-type": "test-tag"},
         )
-        assert (
+        labels_rts_cmdstats = (
             rts.ts()
             .info(
-                "ci.benchmarks.redislabs/env/org/repo/test1/by.version/6.2.3/benchmark_end/commandstats_cmdstat_ping_calls"
+                "ci.benchmarks.redislabs/env/org/repo/test1/by.version/6.2.3/benchmark_end/setup_name/commandstats_cmdstat_ping_calls"
             )
-            .labels["metric-type"]
-            == "test-tag"
+            .labels
         )
-        assert "ci.benchmarks.redislabs/env/org/repo/test1/by.version/6.2.3/benchmark_end/commandstats_cmdstat_ping_calls" in rts.ts().queryindex(
+        assert labels_rts_cmdstats["metric-type"] == "test-tag"
+        assert labels_rts_cmdstats["command"] == "ping"
+        assert labels_rts_cmdstats["command_and_setup"] == "ping - setup_name"
+        assert labels_rts_cmdstats["metric"] == "calls"
+        assert labels_rts_cmdstats["shard"] == "1"
+        assert labels_rts_cmdstats["metric_and_shard"] == "calls"
+        assert "ci.benchmarks.redislabs/env/org/repo/test1/by.version/6.2.3/benchmark_end/setup_name/commandstats_cmdstat_ping_calls" in rts.ts().queryindex(
             ["metric-type=test-tag"]
         )
+        assert "ci.benchmarks.redislabs/env/org/repo/test1/by.version/6.2.3/benchmark_end/setup_name/commandstats_cmdstat_ping_calls" in rts.ts().queryindex(
+            ["command=ping"]
+        )
+        assert "ci.benchmarks.redislabs/env/org/repo/test1/by.version/6.2.3/benchmark_end/setup_name/latencystats_latency_percentiles_usec_ping_p50" in rts.ts().queryindex(
+            ["command=ping"]
+        )
+        labels_rts_latencystats = (
+            rts.ts()
+            .info(
+                "ci.benchmarks.redislabs/env/org/repo/test1/by.version/6.2.3/benchmark_end/setup_name/latencystats_latency_percentiles_usec_ping_p50"
+            )
+            .labels
+        )
+        assert labels_rts_latencystats["metric-type"] == "test-tag"
+        assert labels_rts_latencystats["command"] == "ping"
+        assert labels_rts_latencystats["command_and_setup"] == "ping - setup_name"
+        assert labels_rts_latencystats["metric"] == "p50"
+        assert labels_rts_latencystats["shard"] == "1"
+        assert labels_rts_latencystats["metric_and_shard"] == "p50"
         assert datapoint_errors == 0
         assert datapoint_inserts == (1 * len(list(overall_end_time_metrics.keys())))
         tf_github_branch = "master"