Rebranding (#18)

Author: namikmesic

README.md

@@ -1,4 +1,4 @@
-# EVM RPC Websocket Exporter
+# Blockchain RPC Exporter
 The exporter is used to scrape metrics from blockchain RPC endpoints. The purpose of this exporter is to perform black-box testing on RPC endpoints.
 ## Metrics
 Exporter currently supports all EVM-compatible chains. In addition, there is limited support for the following chains:
@@ -10,6 +10,8 @@ Exporter currently supports all EVM-compatible chains. In addition, there is lim
 - Filecoin (https)
 - Starkware (https)
 
+## Available Metrics
+
 # Disclaimer
 Please note that this tool is in the early development stage and should not be used to influence critical business decisions.
 The project in its current form suits our short-term needs and will receive limited support. We encourage you to fork the project and extend it with additional functionality you might need.

src/collectors/bitcoin.py

@@ -19,13 +19,13 @@ async def _probe(self, metrics):
                 chain_info = await rpc.getblockchaininfo()
                 latency = (perf_counter() - start) * 1000
 
-                metrics['ws_rpc_health'].add_metric(self.labels_values, True)
-                metrics['ws_rpc_latency'].add_metric(self.labels_values, latency)
-                metrics['ws_rpc_block_height'].add_metric(self.labels_values, chain_info['headers'])
-                metrics['ws_rpc_total_difficulty'].add_metric(self.labels_values, chain_info['difficulty'])
+                metrics['brpc_health'].add_metric(self.labels_values, True)
+                metrics['brpc_latency'].add_metric(self.labels_values, latency)
+                metrics['brpc_block_height'].add_metric(self.labels_values, chain_info['headers'])
+                metrics['brpc_total_difficulty'].add_metric(self.labels_values, chain_info['difficulty'])
         except Exception as exc:
             logger.error("Failed probing {} with error: {}".format(strip_url(self.url), exc))
-            metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+            metrics['brpc_health'].add_metric(self.labels_values, False)
 
     def probe(self, metrics):
         asyncio.run(self._probe(metrics))

src/collectors/cardano.py

@@ -32,10 +32,10 @@ def probe(self, metrics):
         try:
             alive = self.ws_collector.get_liveliness()
             if alive:
-                metrics['ws_rpc_health'].add_metric(self.labels_values, True)
-                metrics['ws_rpc_latency'].add_metric(self.labels_values, self.ws_collector.get_latency())
-                metrics['ws_rpc_block_height'].add_metric(self.labels_values, self._get_block_height())
+                metrics['brpc_health'].add_metric(self.labels_values, True)
+                metrics['brpc_latency'].add_metric(self.labels_values, self.ws_collector.get_latency())
+                metrics['brpc_block_height'].add_metric(self.labels_values, self._get_block_height())
             else:
-                metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+                metrics['brpc_health'].add_metric(self.labels_values, False)
         except Exception as exc:
             logger.error("Failed probing {} with error: {}".format(strip_url(self.url), exc))

src/collectors/conflux.py

@@ -27,26 +27,26 @@ def __init__(self, rpc_metadata):
     def probe(self, metrics):
         try:
             if self.client.isConnected():
-                metrics['ws_rpc_health'].add_metric(self.labels_values, True)
-                metrics['ws_rpc_head_count'].add_metric(self.labels_values, self.ws_collector.message_counter)
-                metrics['ws_rpc_disconnects'].add_metric(self.labels_values, self.ws_collector.disconnects_counter)
-                metrics['ws_rpc_latency'].add_metric(self.labels_values, self.ws_collector.get_latency())
-                metrics['ws_rpc_block_height'].add_metric(self.labels_values, self.client.cfx.epoch_number)
+                metrics['brpc_health'].add_metric(self.labels_values, True)
+                metrics['brpc_head_count'].add_metric(self.labels_values, self.ws_collector.message_counter)
+                metrics['brpc_disconnects'].add_metric(self.labels_values, self.ws_collector.disconnects_counter)
+                metrics['brpc_latency'].add_metric(self.labels_values, self.ws_collector.get_latency())
+                metrics['brpc_block_height'].add_metric(self.labels_values, self.client.cfx.epoch_number)
 
                 try:
                     difficulty = self.client.cfx.get_block_by_hash(self.client.cfx.get_best_block_hash())['difficulty']
-                    metrics['ws_rpc_difficulty'].add_metric(self.labels_values, difficulty)
+                    metrics['brpc_difficulty'].add_metric(self.labels_values, difficulty)
                 except TypeError:
                     logger.error(
                         "RPC Endpoint sent faulty response type when querying for difficulty. This is most likely issue with RPC endpoint."
                     )
 
-                metrics['ws_rpc_gas_price'].add_metric(self.labels_values, self.client.cfx.gas_price)
+                metrics['brpc_gas_price'].add_metric(self.labels_values, self.client.cfx.gas_price)
             else:
                 logger.info("Client is not connected to {}".format(strip_url(self.url)))
-                metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+                metrics['brpc_health'].add_metric(self.labels_values, False)
         except asyncio.exceptions.TimeoutError:
             logger.info("Client timed out for {}".format(strip_url(self.url)))
-            metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+            metrics['brpc_health'].add_metric(self.labels_values, False)
         except Exception as exc:
             logger.error("Failed probing {} with error: {}".format(strip_url(self.url), exc))

src/collectors/dogecoin.py

@@ -19,16 +19,16 @@ def probe(self, metrics):
             latency = (perf_counter() - start) * 1000
 
             if response:
-                metrics['ws_rpc_health'].add_metric(self.labels_values, True)
-                metrics['ws_rpc_latency'].add_metric(self.labels_values, latency)
-                metrics['ws_rpc_block_height'].add_metric(self.labels_values, response['result']['blocks'])
-                metrics['ws_rpc_total_difficulty'].add_metric(self.labels_values, response['result']['difficulty'])
+                metrics['brpc_health'].add_metric(self.labels_values, True)
+                metrics['brpc_latency'].add_metric(self.labels_values, latency)
+                metrics['brpc_block_height'].add_metric(self.labels_values, response['result']['blocks'])
+                metrics['brpc_total_difficulty'].add_metric(self.labels_values, response['result']['difficulty'])
             else:
                 logger.error("Bad response from client {}: {}".format(strip_url(self.url), exc))
-                metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+                metrics['brpc_health'].add_metric(self.labels_values, False)
         except requests.RequestException as exc:
             logger.error("Health check failed for {}: {}".format(strip_url(self.url), exc))
-            metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+            metrics['brpc_health'].add_metric(self.labels_values, False)
         except Exception as exc:
             logger.error("Health check failed for {}: {}".format(strip_url(self.url), exc))
-            metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+            metrics['brpc_health'].add_metric(self.labels_values, False)

src/collectors/evm.py

@@ -29,36 +29,36 @@ def __init__(self, rpc_metadata):
     def probe(self, metrics):
         try:
             if self.client.isConnected():
-                metrics['ws_rpc_health'].add_metric(self.labels_values, True)
-                metrics['ws_rpc_head_count'].add_metric(self.labels_values, self.ws_collector.message_counter)
-                metrics['ws_rpc_disconnects'].add_metric(self.labels_values, self.ws_collector.disconnects_counter)
-                metrics['ws_rpc_latency'].add_metric(self.labels_values, self.ws_collector.get_latency())
-                metrics['ws_rpc_block_height'].add_metric(self.labels_values, self.client.eth.block_number)
-                metrics['ws_rpc_total_difficulty'].add_metric(self.labels_values,
+                metrics['brpc_health'].add_metric(self.labels_values, True)
+                metrics['brpc_head_count'].add_metric(self.labels_values, self.ws_collector.message_counter)
+                metrics['brpc_disconnects'].add_metric(self.labels_values, self.ws_collector.disconnects_counter)
+                metrics['brpc_latency'].add_metric(self.labels_values, self.ws_collector.get_latency())
+                metrics['brpc_block_height'].add_metric(self.labels_values, self.client.eth.block_number)
+                metrics['brpc_total_difficulty'].add_metric(self.labels_values,
                                                               self.client.eth.get_block('latest')['totalDifficulty'])
-                metrics['ws_rpc_difficulty'].add_metric(self.labels_values,
+                metrics['brpc_difficulty'].add_metric(self.labels_values,
                                                         self.client.eth.get_block('latest')['difficulty'])
 
                 try:
                     if self.net_peer_enabled:
-                        metrics['ws_rpc_net_peer_count'].add_metric(self.labels_values, self.client.net.peer_count)
+                        metrics['brpc_net_peer_count'].add_metric(self.labels_values, self.client.net.peer_count)
                 except ValueError:
                     logger.error(
                         "Net peer function is not supported for this chain, the collector will ignore this from this point on."
                     )
                     self.net_peer_enabled = False
 
-                metrics['ws_rpc_gas_price'].add_metric(self.labels_values, self.client.eth.gas_price)
-                metrics['ws_rpc_max_priority_fee'].add_metric(self.labels_values, self.client.eth.max_priority_fee)
+                metrics['brpc_gas_price'].add_metric(self.labels_values, self.client.eth.gas_price)
+                metrics['brpc_max_priority_fee'].add_metric(self.labels_values, self.client.eth.max_priority_fee)
             else:
                 logger.info("Client is not connected to {}".format(strip_url(self.url)))
-                metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+                metrics['brpc_health'].add_metric(self.labels_values, False)
         except asyncio.exceptions.TimeoutError as exc:
             logger.info("Client timed out for {}: {}".format(strip_url(self.url), exc))
-            metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+            metrics['brpc_health'].add_metric(self.labels_values, False)
         except WebSocketException as exc:
             logger.info("Websocket client exception {}: {}".format(strip_url(self.url), exc))
-            metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+            metrics['brpc_health'].add_metric(self.labels_values, False)
         except Exception as exc:
             logger.error("Failed probing {} with error: {}".format(strip_url(self.url), exc))
-            metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+            metrics['brpc_health'].add_metric(self.labels_values, False)

src/collectors/filecoin.py

@@ -20,16 +20,16 @@ def probe(self, metrics):
             latency = (perf_counter() - start) * 1000
 
             if response.ok:
-                metrics['ws_rpc_health'].add_metric(self.labels_values, True)
-                metrics['ws_rpc_latency'].add_metric(self.labels_values, latency)
-                metrics['ws_rpc_block_height'].add_metric(self.labels_values, response.json()['result']['Height'])
+                metrics['brpc_health'].add_metric(self.labels_values, True)
+                metrics['brpc_latency'].add_metric(self.labels_values, latency)
+                metrics['brpc_block_height'].add_metric(self.labels_values, response.json()['result']['Height'])
             else:
                 logger.error("Bad response from client while fetching Filecoin.ChainHead method for {}: {}".format(
                     strip_url(self.url), response))
-                metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+                metrics['brpc_health'].add_metric(self.labels_values, False)
         except requests.RequestException as exc:
             logger.error("Health check failed for {}: {}".format(strip_url(self.url), exc))
-            metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+            metrics['brpc_health'].add_metric(self.labels_values, False)
         except Exception as e:
             logger.error("Health check failed for {}: {}".format(strip_url(self.url), e))
-            metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+            metrics['brpc_health'].add_metric(self.labels_values, False)

src/collectors/solana.py

@@ -45,11 +45,11 @@ def is_connected(self) -> bool:
     def probe(self, metrics):
         try:
             if self.is_connected():
-                metrics['ws_rpc_health'].add_metric(self.labels_values, True)
-                metrics['ws_rpc_head_count'].add_metric(self.labels_values, self.ws_collector.message_counter)
-                metrics['ws_rpc_disconnects'].add_metric(self.labels_values, self.ws_collector.disconnects_counter)
-                metrics['ws_rpc_block_height'].add_metric(self.labels_values, self.client.get_block_height()['result'])
+                metrics['brpc_health'].add_metric(self.labels_values, True)
+                metrics['brpc_head_count'].add_metric(self.labels_values, self.ws_collector.message_counter)
+                metrics['brpc_disconnects'].add_metric(self.labels_values, self.ws_collector.disconnects_counter)
+                metrics['brpc_block_height'].add_metric(self.labels_values, self.client.get_block_height()['result'])
             else:
-                metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+                metrics['brpc_health'].add_metric(self.labels_values, False)
         except Exception as exc:
             logger.error("Failed probing {} with error: {}".format(strip_url(self.url), exc))

src/collectors/starkware.py

@@ -21,15 +21,15 @@ def probe(self, metrics):
             latency = (perf_counter() - start) * 1000
 
             if response:
-                metrics['ws_rpc_health'].add_metric(self.labels_values, True)
-                metrics['ws_rpc_latency'].add_metric(self.labels_values, latency)
-                metrics['ws_rpc_block_height'].add_metric(self.labels_values, response['result'])
+                metrics['brpc_health'].add_metric(self.labels_values, True)
+                metrics['brpc_latency'].add_metric(self.labels_values, latency)
+                metrics['brpc_block_height'].add_metric(self.labels_values, response['result'])
             else:
                 logger.error("Bad response from client {}: {}".format(strip_url(self.url), exc))
-                metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+                metrics['brpc_health'].add_metric(self.labels_values, False)
         except requests.RequestException as exc:
             logger.error("Health check failed for {}: {}".format(strip_url(self.url), exc))
-            metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+            metrics['brpc_health'].add_metric(self.labels_values, False)
         except Exception as exc:
             logger.error("Health check failed for {}: {}".format(strip_url(self.url), exc))
-            metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+            metrics['brpc_health'].add_metric(self.labels_values, False)

src/exporter.py

@@ -88,34 +88,34 @@ def _instantiate_starkware(self):
 
     def collect(self):
         metrics = {
-            "ws_rpc_health":
-            GaugeMetricFamily('ws_rpc_health',
+            "brpc_health":
+            GaugeMetricFamily('brpc_health',
                               'Returns 1 if rpc websocket server established a connection with the probe client.',
                               labels=self.labels),
-            "ws_rpc_latency":
-            GaugeMetricFamily('ws_rpc_latency',
+            "brpc_latency":
+            GaugeMetricFamily('brpc_latency',
                               'Latency in milliseconds of the websocket keepalive ping.',
                               labels=self.labels),
-            "ws_rpc_disconnects":
-            GaugeMetricFamily('ws_rpc_disconnects', 'How many times rpc has disconnected.', labels=self.labels),
-            "ws_rpc_block_height":
-            GaugeMetricFamily('ws_rpc_block_height', 'Latest observed block_height.', labels=self.labels),
-            "ws_rpc_head_count":
-            CounterMetricFamily('ws_rpc_head_count', 'Heads received total.', labels=self.labels),
-            "ws_rpc_difficulty":
-            GaugeMetricFamily('ws_rpc_difficulty', 'Difficulty of the latest observed block.', labels=self.labels),
-            "ws_rpc_total_difficulty":
-            GaugeMetricFamily('ws_rpc_total_difficulty',
+            "brpc_disconnects":
+            GaugeMetricFamily('brpc_disconnects', 'How many times rpc has disconnected.', labels=self.labels),
+            "brpc_block_height":
+            GaugeMetricFamily('brpc_block_height', 'Latest observed block_height.', labels=self.labels),
+            "brpc_head_count":
+            CounterMetricFamily('brpc_head_count', 'Heads received total.', labels=self.labels),
+            "brpc_difficulty":
+            GaugeMetricFamily('brpc_difficulty', 'Difficulty of the latest observed block.', labels=self.labels),
+            "brpc_total_difficulty":
+            GaugeMetricFamily('brpc_total_difficulty',
                               'Total canonical chain difficulty observed from the first to the latest block.',
                               labels=self.labels),
-            "ws_rpc_gas_price":
-            GaugeMetricFamily('ws_rpc_gas_price', 'The current gas price in Wei.', labels=self.labels),
-            "ws_rpc_max_priority_fee":
-            GaugeMetricFamily('ws_rpc_max_priority_fee',
+            "brpc_gas_price":
+            GaugeMetricFamily('brpc_gas_price', 'The current gas price in Wei.', labels=self.labels),
+            "brpc_max_priority_fee":
+            GaugeMetricFamily('brpc_max_priority_fee',
                               'Suggested max priority fee for dynamic fee transactions in Wei.',
                               labels=self.labels),
-            "ws_rpc_net_peer_count":
-            GaugeMetricFamily('ws_rpc_net_peer_count',
+            "brpc_net_peer_count":
+            GaugeMetricFamily('brpc_net_peer_count',
                               'Number of peers currently connected to the client.',
                               labels=self.labels)
         }