pytbox 0.0.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

pytbox/alert/alert_handler.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+
+
+import uuid
+from typing import Literal
+from ..database.mongo import Mongo
+from ..feishu.client import Client as FeishuClient
+from ..dida365 import Dida365
+from ..utils.timeutils import TimeUtils
+from ..mail.client import MailClient
+
+
+class AlertHandler:
+    
+    def __init__(self, 
+                 config: dict=None,
+                 mongo_client: Mongo=None,
+                 feishu_client: FeishuClient=None,
+                 dida_client: Dida365=None,
+                 mail_client: MailClient=None,
+                 env: Literal['dev', 'prod']='prod'
+            ):
+     
+        self.config = config
+        self.mongo = mongo_client
+        self.feishu = feishu_client
+        self.dida = dida_client
+        self.mail = mail_client
+        self.env = env
+
+    def send_alert(self, 
+                 event_id: str=None,
+                 event_type: Literal['trigger', 'resolved'] ='trigger',
+                 event_time: str=None,
+                 event_name: str=None,
+                 event_content: str=None,
+                 entity_name: str=None,
+                 priority: Literal['critical', 'high', 'warning']='high',
+                 resolved_expr: str=None,
+                 suggestion: str='',
+                 troubleshot: str='暂无',
+                 mongo_id: str=None
+            ):
+        
+        if not event_id:
+            event_id = str(uuid.uuid4())
+        if not event_time:
+            event_time = TimeUtils.get_now_time_mongo()
+    
+        if self.mongo.check_alarm_exist(event_type=event_type, event_content=event_content):
+            if event_type == "trigger":
+                self.mongo.collection.insert_one(
+                    {
+                        'event_id': event_id,
+                        'event_type': event_type,
+                        'event_name': event_name,
+                        'event_time': event_time,
+                        'event_content': event_content,
+                        'entity_name': entity_name,
+                        'priority': priority,
+                        'resolved_expr': resolved_expr,
+                        'suggestion': suggestion,
+                        'troubleshot': troubleshot,
+                    }
+                )
+            elif event_type == "resolved":
+                filter_doc = {"_id": mongo_id}
+                update = {"$set": { "resolved_time": event_time}}
+                self.mongo.collection.update_one(filter_doc, update)
+                alarm_time = self.mongo.collection.find_one(filter_doc, {'event_time': 1})['event_time']
+            
+            content = [
+                f'**事件名称**: {event_name}',
+                f'**告警时间**: {TimeUtils.convert_timeobj_to_str(timeobj=event_time, timezone_offset=0) if event_type == "trigger" else TimeUtils.convert_timeobj_to_str(timeobj=alarm_time, timezone_offset=8)}',
+                f'**事件内容**: {event_content + " 已恢复" if event_type == "resolved" else event_content}',
+                f'**告警实例**: {entity_name}',
+                f'**建议**: {suggestion}',
+                f'**故障排查**: {troubleshot}',
+                f'**历史告警**: {self.mongo.recent_alerts(event_content=event_content)}'
+            ]
+            
+            if event_type == "resolved":
+                content.insert(2, f'**恢复时间**: {TimeUtils.convert_timeobj_to_str(event_time, timezone_offset=0)}')
+    
+            if self.config['feishu']['enable_alert']:
+                self.feishu.extensions.send_message_notify(
+                    receive_id=self.config['feishu']['receive_id'],
+                    color='red' if event_type == "trigger" else 'green',
+                    title=event_content + " 已恢复" if event_type == "resolved" else event_content,
+                    priority=priority,
+                    sub_title='测试告警, 无需处理' if self.env == 'dev' else '',
+                    content='\n'.join(content)
+                )
+            
+            if self.config['mail']['enable_mail']:
+                if event_type == "trigger":
+                    self.mail.send_mail(
+                        receiver=[self.config['mail']['mail_address']],
+                        subject=f"{self.config['mail']['subject_trigger']}, {event_content}",
+                        contents=f"event_content:{event_content}, alarm_time: {str(event_time)}, event_id: {event_id}, alarm_name: {event_name}, entity_name: {entity_name}, priority: {priority}, automate_ts: {troubleshot}, suggestion: {suggestion}"
+                    )
+                else:
+                    self.mail.send_mail(
+                        receiver=[self.config['mail']['mail_address']],
+                        subject=f"{self.config['mail']['subject_resolved']}, {event_content}",
+                        contents=f"event_content:{event_content}, alarm_time: {str(TimeUtils.get_now_time_mongo())}, event_id: {event_id}, alarm_name: {event_name}, entity_name: {entity_name}, priority: {priority}, automate_ts: {troubleshot}, suggestion: {suggestion}"
+                    )
+            
+            if self.config['dida']['enable_alert']:
+                if event_type == "trigger":
+                    res = self.dida.task_create(
+                        project_id=self.config['dida']['alert_project_id'],
+                        title=event_content,
+                        content='\n'.join(content),
+                        tags=['L-监控告警', priority]
+                    )
+                    dida_task_id = res.data.get("id")
+                    self.mongo.collection.update_one(
+                        {
+                            "event_id": event_id
+                        },
+                        {
+                            "$set": {
+                                "dida_task_id": dida_task_id
+                            }
+                        }
+                    )
+                else:
+                    task_id = self.mongo.collection.find_one(filter_doc, {'dida_task_id': 1})['dida_task_id']
+                    self.dida.task_update(
+                        task_id=task_id,
+                        project_id=self.config['dida']['alert_project_id'], 
+                        content=f'\n**恢复时间**: {TimeUtils.convert_timeobj_to_str(timeobj=event_time, timezone_offset=0)}'
+                    )
+                    self.dida.task_complete(task_id=task_id, project_id=self.config['dida']['alert_project_id'])
+                    
+                
+            if self.config['wecom']['enable']:
+                pass

pytbox/alert/ping.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+
+from ..database.victoriametrics import VictoriaMetrics
+from ..lib.load_config import load_config
+
+
+def ping(config, target):
+    vm = VictoriaMetrics(url=config['victoriametrics']['url'])
+    ping_status = vm.query_ping_status(target=target, last_minutes=config['alert']['ping']['last_minutes'])
+    if ping_status == '不通':
+        insert_alert(
+            event_name=config['alert']['ping']['event_name'],
+            event_content=f"{target} {config['alert']['ping']['event_name']}",
+            entity_name=target,
+            priority=config['alert']['ping']['priority'],
+            resolved_query={
+                "target": target
+            }
+        )
+
+
+if __name__ == "__main__":
+    config = load_config()
+    ping(config, "10.30.35.38")

pytbox/alicloud/sls.py

@@ -5,29 +5,23 @@ from typing import Literal
 from aliyun.log import GetLogsRequest, LogItem, PutLogsRequest
 from aliyun.log import LogClient as SlsLogClient
 from aliyun.log.auth import AUTH_VERSION_4
-from ..utils.env import check_env
 
 
 
 class AliCloudSls:
-
-    def __init__(self, access_key_id: str=None, access_key_secret: str=None, project: str, logstore: str):
+    '''
+    pip install -U aliyun-log-python-sdk
+    '''
+    def __init__(self, access_key_id: str=None, access_key_secret: str=None, project: str=None, logstore: str=None, env: str='prod'):
         # 日志服务的服务接入点
         self.endpoint = "cn-shanghai.log.aliyuncs.com"
         # 创建 LogClient 实例，使用 V4 签名，根据实际情况填写 region，这里以杭州为例
         self.client = SlsLogClient(self.endpoint, access_key_id, access_key_secret, auth_version=AUTH_VERSION_4, region='cn-shanghai')
         self.project = project
         self.logstore = logstore
+        self.env = env
 
     def get_logs(self, project_name, logstore_name, query, from_time, to_time): 
-        # Project名称。
-        # project_name = "sh-prod-network-devices-log"
-        # Logstore名称
-        # logstore_name = "sh-prod-network-devices-log"
-        # 查询语句。
-        # query = "*| select dev,id from " + logstore_name
-        # query = "*"
-        # 索引。
         logstore_index = {'line': {
             'token': [',', ' ', "'", '"', ';', '=', '(', ')', '[', ']', '{', '}', '?', '@', '&', '<', '>', '/', ':', '\n', '\t',
                     '\r'], 'caseSensitive': False, 'chn': False}, 'keys': {'dev': {'type': 'text',
@@ -65,7 +59,7 @@ class AliCloudSls:
         log_group = []
         log_item = LogItem()
         contents = [
-            ('env', check_env()),
+            ('env', self.env),
             ('level', level),
             ('app', app),
             ('msg', msg),
@@ -77,8 +71,9 @@ class AliCloudSls:
         log_item.set_contents(contents)
         log_group.append(log_item)
         request = PutLogsRequest(self.project, self.logstore, topic, "", log_group, compress=False)
-        self.client.put_logs(request)
-    
+        r = self.client.put_logs(request)
+        return r
+        
     def put_logs_for_meraki(self, alert):
         log_group = []
         log_item = LogItem()

pytbox/base.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+
+import os
+from pytbox.database.mongo import Mongo
+from pytbox.utils.load_config import load_config_by_file
+from pytbox.database.victoriametrics import VictoriaMetrics
+from pytbox.feishu.client import Client as FeishuClient
+from pytbox.dida365 import Dida365
+from pytbox.alert.alert_handler import AlertHandler
+from pytbox.log.logger import AppLogger
+from pytbox.network.meraki import Meraki
+from pytbox.utils.env import get_env_by_os_environment
+from pytbox.vmware import VMwareClient
+from pytbox.pyjira import PyJira
+from pytbox.mail.client import MailClient
+from pytbox.mail.alimail import AliMail
+from pytbox.alicloud.sls import AliCloudSls
+from pytbox.utils.cronjob import cronjob_counter
+from pytbox.notion import Notion
+from pytbox.mingdao import Mingdao
+
+
+config = load_config_by_file(path='/workspaces/pytbox/tests/alert/config_dev.toml', oc_vault_id=os.environ.get('oc_vault_id'))
+
+
+def get_mongo(collection):
+    return Mongo(
+        host=config['mongo']['host'],
+        port=config['mongo']['port'],
+        username=config['mongo']['username'],
+        password=config['mongo']['password'],
+        auto_source=config['mongo']['auto_source'],
+        db_name=config['mongo']['db_name'],
+        collection=collection
+    )
+
+vm = VictoriaMetrics(url=config['victoriametrics']['url'])
+
+feishu = FeishuClient(
+    app_id=config['feishu']['app_id'],
+    app_secret=config['feishu']['app_secret']
+)
+dida = Dida365(
+    cookie=config['dida']['cookie'],
+    access_token=config['dida']['access_token']
+)
+
+
+alert_handler = AlertHandler(config=config, mongo_client=get_mongo('alert_test'), feishu_client=feishu, dida_client=dida)
+
+def get_logger(app):
+    return AppLogger(
+        app_name=app, 
+        enable_victorialog=True, 
+        victorialog_url=config['victorialog']['url'],
+        feishu=feishu,
+        dida=dida,
+        mongo=get_mongo('alert_program')
+    )
+
+def get_logger_sls(app):
+    return AppLogger(
+        app_name=app, 
+        enable_sls=True,
+        feishu=feishu,
+        dida=dida,
+        mongo=get_mongo('alert_program'),
+        sls_access_key_id=config['alicloud']['account1']['access_key_id'],
+        sls_access_key_secret=config['alicloud']['account1']['access_key_secret'],
+        sls_project=config['alicloud']['account1']['project'],
+        sls_logstore=config['alicloud']['account1']['logstore']
+    )
+
+# ad_dev = ADClient(
+#     server=config['ad']['dev']['AD_SERVER'],
+#     base_dn=config['ad']['dev']['BASE_DN'],
+#     username=config['ad']['dev']['AD_USERNAME'],
+#     password=config['ad']['dev']['AD_PASSWORD']
+# )
+
+# ad_prod = ADClient(
+#     server=config['ad']['prod']['AD_SERVER'],
+#     base_dn=config['ad']['prod']['BASE_DN'],
+#     username=config['ad']['prod']['AD_USERNAME'],
+#     password=config['ad']['prod']['AD_PASSWORD']
+# )
+
+env = get_env_by_os_environment(check_key='ENV')
+meraki = Meraki(api_key=config['meraki']['api_key'], organization_id=config['meraki']['organization_id'])
+
+vmware_test = VMwareClient(
+    host=config['vmware']['test']['host'],
+    username=config['vmware']['test']['username'],
+    password=config['vmware']['test']['password'],
+    version=config['vmware']['test']['version'],
+    proxies=config['vmware']['test']['proxies']
+)
+
+pyjira = PyJira(
+    base_url=config['jira']['base_url'],
+    username=config['jira']['username'],
+    token=config['jira']['token']
+)
+
+# mail_163 = MailClient(mail_address=config['mail']['163']['mail_address'], password=config['mail']['163']['password'])
+# mail_qq = MailClient(mail_address=config['mail']['qq']['mail_address'], password=config['mail']['qq']['password'])
+# ali_mail = AliMail(mail_address=config['mail']['aliyun']['mail_address'], client_id=config['mail']['aliyun']['client_id'], client_secret=config['mail']['aliyun']['client_secret'])
+
+sls = AliCloudSls(
+    access_key_id=config['alicloud']['account1']['access_key_id'],
+    access_key_secret=config['alicloud']['account1']['access_key_secret'],
+    project=config['alicloud']['account1']['project'],
+    logstore=config['alicloud']['account1']['logstore']
+)
+
+def get_cronjob_counter(app_type='', app='', comment=None, schedule_interval=None, schedule_cron=None):
+    return cronjob_counter(vm=vm, log=get_logger('cronjob_counter'), app_type=app_type, app=app, comment=comment, schedule_interval=schedule_interval, schedule_cron=schedule_cron)
+
+
+notion = Notion(token=config['notion']['api_secrets'], proxy=config['notion']['proxy'])
+mingdao = Mingdao(app_key=config['mingdao']['app_key'], sign=config['mingdao']['sign'])

pytbox/categraf/build_config.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+
+import os
+from pathlib import Path
+from pytbox.utils.load_config import load_config_by_file
+from glob import glob
+import os
+from jinja2 import Environment, FileSystemLoader
+
+
+jinja2_path = Path(__file__).parent / 'jinja2'
+env = Environment(loader=FileSystemLoader(jinja2_path))
+
+ping_template = env.get_template('input.ping/ping.toml.j2')
+prometheus_template = env.get_template('input.prometheus/prometheus.toml.j2')
+
+
+class BuildConfig:
+    '''
+    生成配置
+
+    Args:
+        instances (_type_): _description_
+        output_dir (_type_): _description_
+    '''
+    def __init__(self, instances, output_dir):
+        self.instances = load_config_by_file(instances)
+        self.output_dir = output_dir
+    
+    def _get_template(self, template_name):
+        return env.get_template(template_name)
+
+    def common(self, input_name):
+        template = self._get_template(f'input.{input_name}/{input_name}.toml.j2')
+        render_data = template.render()
+        target_dir = Path(self.output_dir) / f'input.{input_name}'
+        if not target_dir.exists():
+            target_dir.mkdir(parents=True, exist_ok=True)
+            
+        with open(Path(self.output_dir) / f'input.{input_name}' / f'{input_name}.toml', 'w', encoding='utf-8') as f:
+            f.write(render_data)
+
+    def ping(self):
+        if self.instances.get('ping'):
+            instances = self.instances['ping']['instance']
+            render_data = ping_template.render(instances=instances)
+            target_dir = Path(self.output_dir) / 'input.ping'
+            if not target_dir.exists():
+                target_dir.mkdir(parents=True, exist_ok=True)
+                
+            with open(Path(self.output_dir) / 'input.ping' / 'ping.toml', 'w', encoding='utf-8') as f:
+                f.write(render_data)
+
+    def prometheus(self):
+        if self.instances.get('prometheus'):
+            instances = self.instances['prometheus']['urls']
+            render_data = prometheus_template.render(instances=instances)
+            target_dir = Path(self.output_dir) / 'input.prometheus'
+            if not target_dir.exists():
+                target_dir.mkdir(parents=True, exist_ok=True)
+            with open(Path(self.output_dir) / 'input.prometheus' / 'prometheus.toml', 'w', encoding='utf-8') as f:
+                f.write(render_data)
+
+    def vsphere(self):
+        if self.instances.get('vsphere'):
+            template = self._get_template('input.vsphere/vsphere.toml.j2')
+            instances = self.instances['vsphere']['instance']
+            render_data = template.render(instances=instances)
+            target_dir = Path(self.output_dir) / 'input.vsphere'
+            if not target_dir.exists():
+                target_dir.mkdir(parents=True, exist_ok=True)
+            with open(Path(self.output_dir) / 'input.vsphere' / 'vsphere.toml', 'w', encoding='utf-8') as f:
+                f.write(render_data)
+
+    def http_response(self):
+        template = self._get_template('input.http_response/http_response.toml.j2')
+        if self.instances.get('http_response'):
+            instances = self.instances['http_response']['instance']
+            render_data = template.render(instances=instances)
+            target_dir = Path(self.output_dir) / 'input.http_response'
+            if not target_dir.exists():
+                target_dir.mkdir(parents=True, exist_ok=True)
+            with open(Path(self.output_dir) / 'input.http_response' / 'http_response.toml', 'w', encoding='utf-8') as f:
+                f.write(render_data)
+
+    def net_response(self):
+        template = self._get_template('input.net_response/net_response.toml.j2')
+        if self.instances.get('net_response'):
+            instances = self.instances['net_response']['instance']
+            render_data = template.render(instances=instances)
+            target_dir = Path(self.output_dir) / 'input.net_response'
+            if not target_dir.exists():
+                target_dir.mkdir(parents=True, exist_ok=True)
+            with open(Path(self.output_dir) / 'input.net_response' / 'net_response.toml', 'w', encoding='utf-8') as f:
+                f.write(render_data)
+
+    def dns_query(self):
+        template = self._get_template('input.dns_query/dns_query.toml.j2')
+        if self.instances.get('dns_query'):
+            instances = self.instances['dns_query']['instance']
+            render_data = template.render(instances=instances)
+            target_dir = Path(self.output_dir) / 'input.dns_query'
+            if not target_dir.exists():
+                target_dir.mkdir(parents=True, exist_ok=True)
+            with open(Path(self.output_dir) / 'input.dns_query' / 'dns_query.toml', 'w', encoding='utf-8') as f:
+                f.write(render_data)
+
+    def snmp(self):
+        if self.instances.get('snmp'):
+            device_types = self.instances['snmp']['instances']
+            for device_type in device_types:
+                instances = self.instances['snmp']['instances'][device_type]
+                jinja2_dir = Path(jinja2_path) / 'input.snmp'
+                device_templates = glob(str(jinja2_dir / f'{device_type}_*.toml.j2'))
+                if not device_templates:
+                    continue
+                for tmpl_path in device_templates:
+                    tmpl_name = os.path.basename(tmpl_path)
+                    base_name = tmpl_name.replace('.toml.j2', '')
+                    template = self._get_template(f'input.snmp/{tmpl_name}')
+                    render_data = template.render(instances=instances, config=self.instances['snmp']['config'])
+
+                    target_dir = Path(self.output_dir) / 'input.snmp'
+                    if not target_dir.exists():
+                        target_dir.mkdir(parents=True, exist_ok=True)
+                    
+                    output_file = target_dir / f'{base_name}.toml'
+                    with open(output_file, 'w', encoding='utf-8') as f:
+                        f.write(render_data)
+
+    def run(self):
+        self.common('cpu')
+        self.common('mem')
+        self.common('net')
+        self.common('disk')
+        self.common('diskio')
+        self.vsphere()
+        self.ping()
+        self.prometheus()   
+        self.http_response()
+        self.net_response()
+        self.dns_query()
+        self.snmp()

pytbox/categraf/instances.toml

@@ -0,0 +1,39 @@
+[ping]
+[[ping.instance]]
+"10.1.1.1" = { name = "x", env = "prod" }
+"10.1.1.2" = { name = "demo02", env = "dev" }
+
+[prometheus]
+[[prometheus.urls]]
+"http://10.1.1.1:9100" = { name = "x", env = "prod" }
+
+[vsphere]
+[[vsphere.instance]]
+"test" = { vcenter = "https://10.1.1.1/sdk", username = "categraf@vsphere.local", password = "xxx" }
+
+[http_response]
+[[http_response.instance]]
+"https://www.baidu.com" = { name = "x", env = "prod" }
+
+
+[net_response]
+[[net_response.instance]]
+"124.74.245.90:8443" = { name = "x", env = "prod" }
+
+[dns_query]
+[[dns_query.instance]]
+"119.29.29.29_baidu.com" = { dns_server = "119.29.29.29", domains = "www.baidu.com", labels = { name = "x", env = "prod" } }
+
+[snmp]
+[snmp.config]
+timeout = '120s'
+path = "/usr/share/snmp/mibs"
+# 支持 h3c,huawei,cisco,ruijie
+[[snmp.instances.h3c]]
+"10.1.1.1:161" = { version = 2, community = "public" }
+"10.1.1.2:161" = { version = 2, community = "public" }
+"10.1.1.3:161" = { version = 3, sec_name = "sec", auth_protocol = "SHA", auth_password = "pass01", priv_protocol = "AES", priv_password = "pass02", sec_level = "authPriv" }
+
+# [[snmp.instances.huawei]]
+# "udp://172.16.1.1:161" = { version = 2, community = "public"}
+# "udp://172.16.1.2:161" = { version = 2, community = "public"}

pytbox/categraf/jinja2/__init__.py

@@ -0,0 +1,6 @@
+"""
+Categraf Jinja2 模板文件包
+"""
+
+# 这个文件确保 jinja2 目录被 Python 识别为包
+# 这样模板文件就会被包含在安装包中

pytbox/categraf/jinja2/input.cpu/cpu.toml.j2

@@ -0,0 +1,5 @@
+# # collect interval
+# interval = 15
+
+# # whether collect per cpu
+# collect_per_cpu = false

pytbox/categraf/jinja2/input.disk/disk.toml.j2

@@ -0,0 +1,11 @@
+# # collect interval
+# interval = 15
+
+# # By default stats will be gathered for all mount points.
+# # Set mount_points will restrict the stats to only the specified mount points.
+# mount_points = ["/"]
+
+# Ignore mount points by filesystem type.
+ignore_fs = ["tmpfs", "devtmpfs", "devfs", "iso9660", "overlay", "aufs", "squashfs", "nsfs", "CDFS", "fuse.juicefs"]
+
+ignore_mount_points = ["/boot", "/var/lib/kubelet/pods"]

pytbox/categraf/jinja2/input.diskio/diskio.toml.j2

@@ -0,0 +1,6 @@
+# # collect interval
+# interval = 15
+
+# # By default, categraf will gather stats for all devices including disk partitions.
+# # Setting devices will restrict the stats to the specified devices.
+# devices = ["sda", "sdb", "vd*"]

pytbox/categraf/jinja2/input.dns_query/dns_query.toml.j2

@@ -0,0 +1,12 @@
+{% for instance in instances %}
+{% for name, data in instance.items() %}
+[[instances]]
+#  append some labels for series
+labels = { {% for k, v in data['labels'].items() %}{% if not loop.first %}, {% endif %}{% if k.isidentifier() %}{{ k }}{% else %}"{{ k }}"{% endif %} = "{{ v }}"{% endfor %} }
+servers = ["{{ data['dns_server'] }}"]
+## Domains or subdomains to query.
+domains = ["{{ data['domains'] }}"]
+record_type = "A"
+timeout = 2
+{% endfor %}
+{% endfor %}

pytbox/categraf/jinja2/input.http_response/http_response.toml.j2

@@ -0,0 +1,9 @@
+{% for instance in instances %}
+{% for target, labels in instance.items() %}
+[[instances]]
+targets = [
+    "{{ target }}"
+]
+labels = { {% for k, v in labels.items() %}{% if not loop.first %}, {% endif %}{% if k.isidentifier() %}{{ k }}{% else %}"{{ k }}"{% endif %} = "{{ v }}"{% endfor %} }
+{% endfor %}
+{% endfor %}

pytbox/categraf/jinja2/input.mem/mem.toml.j2

@@ -0,0 +1,5 @@
+# # collect interval
+# interval = 15
+
+# # whether collect platform specified metrics
+collect_platform_fields = true

pytbox/categraf/jinja2/input.net/net.toml.j2

@@ -0,0 +1,11 @@
+# # collect interval
+# interval = 15
+
+# # whether collect protocol stats on Linux
+# collect_protocol_stats = false
+
+# # setting interfaces will tell categraf to gather these explicit interfaces
+# interfaces = ["eth0"]
+ 
+# enable_loopback_stats=true
+# enable_link_down_stats=true

pytbox/categraf/jinja2/input.net_response/net_response.toml.j2

@@ -0,0 +1,9 @@
+{% for instance in instances %}
+{% for target, labels in instance.items() %}
+[[instances]]
+targets = [
+    "{{ target }}"
+]
+labels = { {% for k, v in labels.items() %}{% if not loop.first %}, {% endif %}{% if k.isidentifier() %}{{ k }}{% else %}"{{ k }}"{% endif %} = "{{ v }}"{% endfor %} }
+{% endfor %}
+{% endfor %}

pytbox/categraf/jinja2/input.ping/ping.toml.j2

@@ -0,0 +1,11 @@
+{% for instance in instances %}
+{% for target, labels in instance.items() %}
+[[instances]]
+targets = [
+    "{{ target }}"
+]
+method = "exec"
+count = 3
+labels = { {% for k, v in labels.items() %}{% if not loop.first %}, {% endif %}{% if k.isidentifier() %}{{ k }}{% else %}"{{ k }}"{% endif %} = "{{ v }}"{% endfor %} }
+{% endfor %}
+{% endfor %}

pytbox/categraf/jinja2/input.prometheus/prometheus.toml.j2

@@ -0,0 +1,12 @@
+{% for instance in instances %}
+{% for instance, labels in instance.items() %}
+[[instances]]
+urls = [
+    "{{ instance }}"
+]
+
+url_label_key = "instance"
+url_label_value = "{{ '{{.Host}}' }}"
+labels = { {% for k, v in labels.items() %}{% if not loop.first %}, {% endif %}{% if k.isidentifier() %}{{ k }}{% else %}"{{ k }}"{% endif %} = "{{ v }}"{% endfor %} }
+{% endfor %}
+{% endfor %}