Add starkware (#15)

Author: namikmesic

README.md

@@ -7,6 +7,8 @@ Exporter currently supports all EVM-compatible chains. In addition, there is lim
 - Solana
 - Bitcoin
 - Dogecoin
+- Filecoin
+- Starkware
 
 # Disclaimer
 Please note that this tool is in the early development stage and should not be used to influence critical business decisions.

src/collectors/dogecoin.py

@@ -40,7 +40,7 @@ def probe(self, metrics):
             logger.error("Health check failed for {}: {}".format(
                 strip_url(self.https_url), exc))
             metrics['ws_rpc_health'].add_metric(self.labels_values, False)
-        except Exception as e:
+        except Exception as exc:
             logger.error("Health check failed for {}: {}".format(
                 strip_url(self.https_url), exc))
             metrics['ws_rpc_health'].add_metric(self.labels_values, False)

src/collectors/starkware.py

@@ -0,0 +1,49 @@
+from settings import cfg, logger
+from helpers import strip_url
+from time import perf_counter
+import requests
+
+
+class starkware_collector():
+
+    def __init__(self, https_url, provider):
+        self.labels = [
+            'websocket_url', 'https_url', 'provider', 'blockchain',
+            'network_name', 'network_type'
+        ]
+        self.labels_values = [
+            https_url, provider, cfg.blockchain, cfg.network_name,
+            cfg.network_type
+        ]
+        self.https_url = https_url
+
+    def probe(self, metrics):
+        try:
+            payload = {
+                "method": "starknet_blockNumber",
+                "jsonrpc": "2.0",
+                "id": 1
+            }
+            start = perf_counter()
+
+            response = requests.post(self.https_url, json=payload).json()
+            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'])
+            else:
+                logger.error("Bad response from client {}: {}".format(
+                    strip_url(self.https_url), exc))
+                metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+        except requests.RequestException as exc:
+            logger.error("Health check failed for {}: {}".format(
+                strip_url(self.https_url), exc))
+            metrics['ws_rpc_health'].add_metric(self.labels_values, False)
+        except Exception as exc:
+            logger.error("Health check failed for {}: {}".format(
+                strip_url(self.https_url), exc))
+            metrics['ws_rpc_health'].add_metric(self.labels_values, False)

src/exporter.py

@@ -10,6 +10,7 @@
 from collectors.bitcoin import bitcoin_collector
 from collectors.dogecoin import doge_collector
 from collectors.filecoin import filecoin_collector
+from collectors.starkware import starkware_collector
 from settings import logger, cfg
 
 
@@ -33,6 +34,8 @@ def __init__(self):
             self._instantiate_doge()
         if cfg.isFilecoin():
             self._instantiate_filecoin()
+        if cfg.isStarkware():
+            self._instantiate_starkware()
 
     def _instantiate_evm(self):
         for item in cfg.endpoints:
@@ -93,6 +96,14 @@ def _instantiate_filecoin(self):
                 filecoin_collector(item['https_url'], item['provider']))
             self.labels = self.collectors[0].labels
 
+    def _instantiate_starkware(self):
+        for item in cfg.endpoints:
+            logger.info("Initializing starkware node {}".format(
+                strip_url(item['https_url'])))
+            self.collectors.append(
+                starkware_collector(item['https_url'], item['provider']))
+            self.labels = self.collectors[0].labels
+
     def collect(self):
         metrics = {
             "ws_rpc_health":

src/settings.py

@@ -7,43 +7,56 @@
 logger = logging.getLogger('exporter')
 LOGLEVEL = os.environ.get('LOGLEVEL', 'INFO').upper()
 
-logging.basicConfig(level=LOGLEVEL,
-                    format="{'thread': '%(threadName)s', 'level': '%(levelname)s', 'message': '%(message)s'}")
+logging.basicConfig(
+    level=LOGLEVEL,
+    format=
+    "{'thread': '%(threadName)s', 'level': '%(levelname)s', 'message': '%(message)s'}"
+)
 
 
 class configuration():
 
     def __init__(self, config_file_path: str, validation_file_path: str):
-        self.allowed_providers = self._load_validation_file(validation_file_path)
+        self.allowed_providers = self._load_validation_file(
+            validation_file_path)
         self.configuration = self._load_configuration_file(config_file_path)
         self.blockchain = self.configuration['blockchain']
         # Load chain_id only if evm compatible collector
-        if self.configuration['collector'] not in ['cardano', 'solana', 'bitcoin', 'doge' , 'filecoin']:
+        if self.configuration['collector'] not in [
+                'cardano', 'solana', 'bitcoin', 'doge', 'filecoin', 'starkware'
+        ]:
             try:
                 self.chain_id = self.configuration['chain_id']
             except KeyError:
-                logger.error("This chain requires chain_id configuration, but it is not provided.")
+                logger.error(
+                    "This chain requires chain_id configuration, but it is not provided."
+                )
         self.network_type = self.configuration['network_type']
         self.network_name = self.configuration['network_name']
         self.endpoints = self.configuration['endpoints']
         try:
-            self.open_timeout = self.configuration['connection_parameters']['open_timeout']
+            self.open_timeout = self.configuration['connection_parameters'][
+                'open_timeout']
         except KeyError:
             self.open_timeout = 3
         try:
-            self.close_timeout = self.configuration['connection_parameters']['close_timeout']
+            self.close_timeout = self.configuration['connection_parameters'][
+                'close_timeout']
         except KeyError:
             self.close_timeout = 1
         try:
-            self.response_timeout = self.configuration['connection_parameters']['response_timeout']
+            self.response_timeout = self.configuration[
+                'connection_parameters']['response_timeout']
         except KeyError:
             self.response_timeout = 3
         try:
-            self.ping_interval = self.configuration['connection_parameters']['ping_interval']
+            self.ping_interval = self.configuration['connection_parameters'][
+                'ping_interval']
         except KeyError:
             self.ping_interval = 6
         try:
-            self.ping_timeout = self.configuration['connection_parameters']['ping_timeout']
+            self.ping_timeout = self.configuration['connection_parameters'][
+                'ping_timeout']
         except KeyError:
             self.ping_timeout = 2
 
@@ -85,6 +98,9 @@ def isDoge(self) -> bool:
     def isFilecoin(self) -> bool:
         return self.configuration['collector'] == "filecoin"
 
+    def isStarkware(self) -> bool:
+        return self.configuration['collector'] == "starkware"
+
     def _load_configuration_file(self, path):
         logger.info('Loading {}'.format(path))
         configuration_file_schema = Schema({
@@ -97,7 +113,10 @@ def _load_configuration_file(self, path):
             'network_type':
             And(str, lambda s: s in ('Testnet', 'Mainnet')),
             'collector':
-            And(str, lambda s: s in ('evm', 'cardano', 'conflux', 'solana', 'bitcoin', 'doge', 'filecoin')),
+            And(
+                str, lambda s: s in
+                ('evm', 'cardano', 'conflux', 'solana', 'bitcoin', 'doge',
+                 'filecoin', 'starkware')),
             Optional('connection_parameters'): {
                 Optional('open_timeout'): And(int),
                 Optional('close_timeout'): And(int),
@@ -106,9 +125,12 @@ def _load_configuration_file(self, path):
                 Optional('ping_timeout'): And(int),
             },
             'endpoints': [{
-                Optional('ws_url'): And(str),
-                Optional('https_url'): And(str),
-                'provider': And(str, lambda s: s in self.allowed_providers)
+                Optional('ws_url'):
+                And(str),
+                Optional('https_url'):
+                And(str),
+                'provider':
+                And(str, lambda s: s in self.allowed_providers)
             }]
         })
         try:
@@ -129,11 +151,13 @@ def _load_file(self, path):
             logger.info('Validating {}'.format(path))
             return file
         except IOError as e:
-            logger.error('Problem with configuration file detected: {}'.format(e))
+            logger.error(
+                'Problem with configuration file detected: {}'.format(e))
             exit(1)
 
 
 cfg_file_path = os.getenv('CONFIG_FILE_PATH', default='/config/config.yml')
-valid_file_path = os.getenv('VALIDATION_FILE_PATH', default='/config/validation.yml')
+valid_file_path = os.getenv('VALIDATION_FILE_PATH',
+                            default='/config/validation.yml')
 
 cfg = configuration(cfg_file_path, valid_file_path)