add more metadata to timescale db listener

- add function to try to get client version of target node/endpoint
- add metadata such as chainbench version, target node host, client and version
- refactor get_master_command and get_worker_command into a single class and reduce code redundancy

Author: erwin-wee

chainbench/main.py

@@ -18,12 +18,11 @@
 )
 from chainbench.util.cli import (
     ContextData,
+    LocustOptions,
     ensure_results_dir,
     get_base_path,
-    get_master_command,
     get_profile_path,
     get_profiles,
-    get_worker_command,
 )
 from chainbench.util.monitor import monitors
 from chainbench.util.notify import NoopNotifier, Notifier
@@ -296,8 +295,7 @@ def start(
         for tag in exclude_tags:
             custom_exclude_tags.append(tag)
 
-    # Start the Locust master
-    master_command = get_master_command(
+    locust_options = LocustOptions(
         profile_path=profile_path,
         host=host,
         port=port,
@@ -321,6 +319,9 @@ def start(
         method=method,
         enable_class_picker=enable_class_picker,
     )
+    # Start the Locust master
+    master_command = locust_options.get_master_command()
+
     if headless:
         click.echo("Starting master in headless mode")
     else:
@@ -334,24 +335,7 @@ def start(
 
     # Start the Locust workers
     for worker_id in range(workers):
-        worker_command = get_worker_command(
-            profile_path=profile_path,
-            host=host,
-            port=port,
-            results_path=results_path,
-            headless=headless,
-            target=target,
-            worker_id=worker_id,
-            log_level=log_level,
-            exclude_tags=custom_exclude_tags,
-            timescale=timescale,
-            pg_host=pg_host,
-            pg_port=pg_port,
-            pg_username=pg_username,
-            pg_password=pg_password,
-            use_latest_blocks=use_latest_blocks,
-            method=method,
-        )
+        worker_command = locust_options.get_worker_command(worker_id=worker_id)
         worker_args = shlex.split(worker_command, posix=is_posix)
         worker_process = subprocess.Popen(worker_args)
         ctx.obj.workers.append(worker_process)

chainbench/util/cli.py

@@ -3,6 +3,14 @@
 from datetime import datetime
 from pathlib import Path
 
+from geventhttpclient import URL
+
+from chainbench.util.http import (
+    HttpClient,
+    HttpErrorLevel,
+    HttpStatusError,
+    JsonRpcError,
+)
 from chainbench.util.notify import NoopNotifier, Notifier
 
 
@@ -58,112 +66,123 @@ def get_timescale_args(
     return f" --timescale --pghost={pg_host} --pgport={pg_port}" f" --pgpassword={pg_password} --pguser={pg_username}"
 
 
-def get_master_command(
-    profile_path: Path,
-    host: str,
-    port: int,
-    users: int,
-    workers: int,
-    spawn_rate: int,
-    test_time: str,
-    log_level: str,
-    results_path: Path,
-    exclude_tags: list[str],
-    target: str | None = None,
-    headless: bool = False,
-    timescale: bool = False,
-    pg_host: str | None = None,
-    pg_port: int | None = None,
-    pg_username: str | None = None,
-    pg_password: str | None = None,
-    override_plan_name: str | None = None,
-    use_latest_blocks: bool = False,
-    size: str | None = None,
-    method: str | None = None,
-    enable_class_picker: bool = False,
-) -> str:
-    """Generate master command."""
-    command = (
-        f"locust -f {profile_path} --master "
-        f"--master-bind-host {host} --master-bind-port {port} "
-        f"--web-host {host} "
-        f"-u {users} -r {spawn_rate} --run-time {test_time} "
-        f"--html {results_path}/report.html --csv {results_path}/report.csv "
-        f"--logfile {results_path}/report.log "
-        f"--loglevel {log_level} --expect-workers {workers} "
-        f"--size {size}"
-    )
-
-    if timescale:
-        command += get_timescale_args(pg_host, pg_port, pg_username, pg_password)
-        if override_plan_name is not None:
-            command += f" --override-plan-name {override_plan_name}"
-
-    if target is not None:
-        command += f" --host {target}"
-
-    if headless:
-        command += " --headless"
-
-    if len(exclude_tags) > 0:
-        command += f" --exclude-tags {' '.join(exclude_tags)}"
-
-    if use_latest_blocks:
-        command += " --use-latest-blocks True"
-
-    if method is not None:
-        command += f" --method {method}"
-
-    if enable_class_picker:
-        command += " --class-picker"
-    return command
-
-
-def get_worker_command(
-    profile_path: Path,
-    host: str,
-    port: int,
-    results_path: Path,
-    log_level: str,
-    exclude_tags: list[str],
-    target: str | None = None,
-    headless: bool = False,
-    worker_id: int = 0,
-    timescale: bool = False,
-    pg_host: str | None = None,
-    pg_port: int | None = None,
-    pg_username: str | None = None,
-    pg_password: str | None = None,
-    override_plan_name: str | None = None,
-    use_latest_blocks: bool = False,
-    method: str | None = None,
-) -> str:
-    """Generate worker command."""
-    command = (
-        f"locust -f {profile_path} --worker --master-host {host} --master-port {port} "
-        f"--logfile {results_path}/worker_{worker_id}.log --loglevel {log_level}"
-    )
+def get_url_domain(target_url: str) -> str:
+    """Get domain from URL."""
+    return URL(target_url).host
+
 
-    if timescale:
-        command += get_timescale_args(pg_host, pg_port, pg_username, pg_password)
-        if override_plan_name is not None:
-            command += f" --override-plan-name {override_plan_name}"
+def get_target_client_version(target_url: str) -> str:
+    """Get client version from target URL."""
+    http = HttpClient(target_url, error_level=HttpErrorLevel.ClientError)
 
-    if target is not None:
-        command += f" --host {target}"
+    def _get_version_rpc(_method: str, _path: str) -> str:
+        try:
+            _response = http.make_rpc_call(method=_method, path=_path)
+            return str(_response)
+        except (JsonRpcError, HttpStatusError):
+            return "unknown"
 
-    if headless:
-        command += " --headless"
+    rpc_methods = [
+        "web3_clientVersion",
+        "getVersion",
+        ("pathfinder_version", "/rpc/pathfinder/v0.1"),
+        "juno_version",
+        "nodeVersion",
+    ]
 
-    if len(exclude_tags) > 0:
-        command += f" --exclude-tags {' '.join(exclude_tags)}"
+    for rpc_method in rpc_methods:
+        if isinstance(rpc_method, tuple):
+            method, path = rpc_method
+        else:
+            method = rpc_method
+            path = ""
+        version = _get_version_rpc(method, path)
+        if version != "unknown":
+            return version
+
+    try:
+        response = http.get("eth/v1/node/version")
+        return response.json["data"]["version"]
+    except (JsonRpcError, HttpStatusError):
+        return "unknown"
 
-    if use_latest_blocks:
-        command += " --use-latest-blocks True"
 
-    if method is not None:
-        command += f" --method {method}"
-    return command
+@dataclass
+class LocustOptions:
+    profile_path: Path
+    host: str
+    port: int
+    users: int
+    workers: int
+    spawn_rate: int
+    test_time: str
+    log_level: str
+    results_path: Path
+    exclude_tags: list[str]
+    target: str
+    headless: bool = False
+    timescale: bool = False
+    pg_host: str | None = None
+    pg_port: int | None = None
+    pg_username: str | None = None
+    pg_password: str | None = None
+    override_plan_name: str | None = None
+    use_latest_blocks: bool = False
+    size: str | None = None
+    method: str | None = None
+    enable_class_picker: bool = False
+
+    def get_master_command(self) -> str:
+        """Generate master command."""
+        command = (
+            f"locust -f {self.profile_path} --master "
+            f"--master-bind-host {self.host} --master-bind-port {self.port} "
+            f"--web-host {self.host} "
+            f"-u {self.users} -r {self.spawn_rate} --run-time {self.test_time} "
+            f"--html {self.results_path}/report.html --csv {self.results_path}/report.csv "
+            f"--logfile {self.results_path}/report.log "
+            f"--loglevel {self.log_level} --expect-workers {self.workers} "
+            f"--size {self.size}"
+        )
+
+        if self.enable_class_picker:
+            command += " --class-picker"
+
+        return self.get_extra_options(command)
+
+    def get_worker_command(self, worker_id: int = 0) -> str:
+        """Generate worker command."""
+        command = (
+            f"locust -f {self.profile_path} --worker --master-host {self.host} --master-port {self.port} "
+            f"--logfile {self.results_path}/worker_{worker_id}.log --loglevel {self.log_level}"
+        )
+        return self.get_extra_options(command)
+
+    def get_extra_options(self, command: str):
+        if self.timescale:
+            command += get_timescale_args(self.pg_host, self.pg_port, self.pg_username, self.pg_password)
+            if self.override_plan_name is not None:
+                command += f" --override-plan-name {self.override_plan_name}"
+            from importlib import metadata
+
+            command += f" --test-version chainbench-{metadata.version('chainbench')}"
+            command += f' --description "{get_url_domain(self.target)} [{get_target_client_version(self.target)}]"'
+
+        if self.target is not None:
+            command += f" --host {self.target}"
+
+        if self.headless:
+            command += " --headless"
+
+        if len(self.exclude_tags) > 0:
+            command += f" --exclude-tags {' '.join(self.exclude_tags)}"
+
+        if self.use_latest_blocks:
+            command += " --use-latest-blocks True"
+
+        if self.method is not None:
+            command += f" --method {self.method}"
+        return command
 
 
 @dataclass

chainbench/util/http.py

@@ -151,11 +151,11 @@ def _make_body(self, method: str, params: list[t.Any]) -> dict[str, t.Any]:
             "id": token_hex(8),
         }
 
-    def make_rpc_call(self, method: str, params: list[t.Any] | None = None) -> t.Any:
+    def make_rpc_call(self, method: str, params: list[t.Any] | None = None, path: str = "") -> t.Any:
         if params is None:
             params = []
 
-        response = self.post(data=self._make_body(method, params))
+        response = self.post(path=path, data=self._make_body(method, params))
 
         logger.debug(f"Making call to {self._host} with method {method} and params {params}")
         logger.debug(f"Response: {response.json}")