Implement dogecoin (#13)

Author: namikmesic

requirements.txt

@@ -7,4 +7,3 @@ web3==v6.0.0-beta.4
 solana==0.25.1
 conflux-web3==1.0.0b1
 bitcoinrpc==0.5.0
-

src/collectors/bitcoin.py

@@ -4,29 +4,38 @@
 from time import perf_counter
 from settings import cfg, logger
 
+
 class bitcoin_collector():
 
     def __init__(self, https_url, provider):
-        self.https_url = https_url 
-        self.labels = ['https_url', 'provider', 'blockchain', 'network_name', 'network_type']
+        self.https_url = https_url
+        self.labels = [
+            'https_url', 'provider', 'blockchain', 'network_name',
+            'network_type'
+        ]
         self.labels_values = [
-            https_url, provider, cfg.blockchain, cfg.network_name, cfg.network_type
+            https_url, provider, cfg.blockchain, cfg.network_name,
+            cfg.network_type
         ]
-    
-    async def _probe(self, metrics): 
+
+    async def _probe(self, metrics):
         try:
             async with BitcoinRPC(self.https_url, "admin", "admin") as rpc:
                 start = perf_counter()
                 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['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'])
         except Exception as exc:
-            logger.error("Failed probing {} with error: {}".format(strip_url(self.url), exc))
+            logger.error("Failed probing {} with error: {}".format(
+                strip_url(self.url), exc))
             metrics['ws_rpc_health'].add_metric(self.labels_values, False)
-    
+
     def probe(self, metrics):
-        asyncio.run(self._probe(metrics))
+        asyncio.run(self._probe(metrics))

src/collectors/dogecoin.py

@@ -0,0 +1,46 @@
+from helpers import strip_url
+from settings import cfg, logger
+from time import perf_counter
+import requests
+
+
+class doge_collector():
+
+    def __init__(self, https_url, provider):
+        self.https_url = https_url
+        self.labels = [
+            'https_url', 'provider', 'blockchain', 'network_name',
+            'network_type'
+        ]
+        self.labels_values = [
+            https_url, provider, cfg.blockchain, cfg.network_name,
+            cfg.network_type
+        ]
+
+    def probe(self, metrics):
+        try:
+            payload = {'version': '1.1', 'method': "getinfo", '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']['blocks'])
+                metrics['ws_rpc_total_difficulty'].add_metric(
+                    self.labels_values, response['result']['difficulty'])
+            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 e:
+            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

@@ -8,6 +8,7 @@
 from collectors.cardano import cardano_collector
 from collectors.conflux import conflux_collector
 from collectors.bitcoin import bitcoin_collector
+from collectors.dogecoin import doge_collector
 from settings import logger, cfg
 
 
@@ -27,69 +28,107 @@ def __init__(self):
             self._instantiate_conflux()
         if cfg.isBitcoin():
             self._instantiate_bitcoin()
+        if cfg.isDoge():
+            self._instantiate_doge()
 
     def _instantiate_evm(self):
         for item in cfg.endpoints:
-            logger.info("Initializing evm node {}".format(strip_url(item['ws_url'])))
-            self.collectors.append(evm_collector(item['ws_url'], item['https_url'], item['provider']))
+            logger.info("Initializing evm node {}".format(
+                strip_url(item['ws_url'])))
+            self.collectors.append(
+                evm_collector(item['ws_url'], item['https_url'],
+                              item['provider']))
         self.labels = self.collectors[0].labels
 
     def _instantiate_conflux(self):
         for item in cfg.endpoints:
-            logger.info("Initializing conflux node {}".format(strip_url(item['ws_url'])))
-            self.collectors.append(conflux_collector(item['ws_url'], item['https_url'], item['provider']))
+            logger.info("Initializing conflux node {}".format(
+                strip_url(item['ws_url'])))
+            self.collectors.append(
+                conflux_collector(item['ws_url'], item['https_url'],
+                                  item['provider']))
         self.labels = self.collectors[0].labels
 
     def _instantiate_solana(self):
         for item in cfg.endpoints:
-            logger.info("Initializing solana node {}".format(strip_url(item['https_url'])))
-            self.collectors.append(solana_collector(item['ws_url'], item['https_url'], item['provider']))
+            logger.info("Initializing solana node {}".format(
+                strip_url(item['https_url'])))
+            self.collectors.append(
+                solana_collector(item['ws_url'], item['https_url'],
+                                 item['provider']))
         self.labels = self.collectors[0].labels
 
     def _instantiate_cardano(self):
         for item in cfg.endpoints:
-            logger.info("Initializing cardano node {}".format(strip_url(item['ws_url'])))
-            self.collectors.append(cardano_collector(item['ws_url'], item['provider']))
+            logger.info("Initializing cardano node {}".format(
+                strip_url(item['ws_url'])))
+            self.collectors.append(
+                cardano_collector(item['ws_url'], item['provider']))
             self.labels = self.collectors[0].labels
 
     def _instantiate_bitcoin(self):
         for item in cfg.endpoints:
-            logger.info("Initializing bitcoin node {}".format(strip_url(item['https_url'])))
-            self.collectors.append(bitcoin_collector(item['https_url'], item['provider']))
+            logger.info("Initializing bitcoin node {}".format(
+                strip_url(item['https_url'])))
+            self.collectors.append(
+                bitcoin_collector(item['https_url'], item['provider']))
+            self.labels = self.collectors[0].labels
+
+    def _instantiate_doge(self):
+        for item in cfg.endpoints:
+            logger.info("Initializing doge node {}".format(
+                strip_url(item['https_url'])))
+            self.collectors.append(
+                doge_collector(item['https_url'], item['provider']))
             self.labels = self.collectors[0].labels
 
     def collect(self):
         metrics = {
             "ws_rpc_health":
-            GaugeMetricFamily('ws_rpc_health',
-                              'Returns 1 if rpc websocket server established a connection with the probe client.',
-                              labels=self.labels),
+            GaugeMetricFamily(
+                'ws_rpc_health',
+                'Returns 1 if rpc websocket server established a connection with the probe client.',
+                labels=self.labels),
             "ws_rpc_latency":
-            GaugeMetricFamily('ws_rpc_latency',
-                              'Latency in milliseconds of the websocket keepalive ping.',
-                              labels=self.labels),
+            GaugeMetricFamily(
+                'ws_rpc_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),
+            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),
+            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),
+            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',
-                              'Total canonical chain difficulty observed from the first to the latest block.',
+            GaugeMetricFamily('ws_rpc_difficulty',
+                              'Difficulty of the latest observed block.',
                               labels=self.labels),
+            "ws_rpc_total_difficulty":
+            GaugeMetricFamily(
+                'ws_rpc_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',
-                              'Suggested max priority fee for dynamic fee transactions in Wei.',
+            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',
+                'Suggested max priority fee for dynamic fee transactions in Wei.',
+                labels=self.labels),
             "ws_rpc_net_peer_count":
-            GaugeMetricFamily('ws_rpc_net_peer_count',
-                              'Number of peers currently connected to the client.',
-                              labels=self.labels)
+            GaugeMetricFamily(
+                'ws_rpc_net_peer_count',
+                'Number of peers currently connected to the client.',
+                labels=self.labels)
         }
 
         def write_metrics(prom_collector, metrics):

src/settings.py

@@ -18,7 +18,7 @@ def __init__(self, config_file_path: str, validation_file_path: str):
         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']:
+        if self.configuration['collector'] not in ['cardano', 'solana', 'bitcoin', 'doge']:
             try:
                 self.chain_id = self.configuration['chain_id']
             except KeyError:
@@ -79,6 +79,9 @@ def isConflux(self) -> bool:
     def isBitcoin(self) -> bool:
         return self.configuration['collector'] == "bitcoin"
 
+    def isDoge(self) -> bool:
+        return self.configuration['collector'] == "doge"
+
     def _load_configuration_file(self, path):
         logger.info('Loading {}'.format(path))
         configuration_file_schema = Schema({
@@ -91,7 +94,7 @@ 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')),
+            And(str, lambda s: s in ('evm', 'cardano', 'conflux', 'solana', 'bitcoin', 'doge')),
             Optional('connection_parameters'): {
                 Optional('open_timeout'): And(int),
                 Optional('close_timeout'): And(int),