check_kubernetesd

#!/usr/bin/env python3
""" kubernetes zabbix monitoring daemon
    - tries to read config from file (host, port, token)
    - sends data to zabbix
    - sends data to inventory REST-API
"""
import argparse
import faulthandler
import logging
import os
import signal
import sys
from typing import List

import coloredlogs as coloredlogs
import sentry_sdk
import time

from base.daemon_thread import CheckKubernetesDaemon
from base.config import Configuration

KNOWN_ACTIONS = ['discover', 'get']

formatter_string = '%(asctime)s - %(threadName)s : {%(name)s:%(lineno)d} : %(levelname)s : %(message)s'
formatter = logging.Formatter(formatter_string)
stream = logging.StreamHandler(sys.stdout)
stream.setFormatter(formatter)

logger = logging.getLogger(__file__)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description='Zabbix monitoring daemon for kubernetes'
    )

    parser.add_argument('--show_effective_config', action='store_true',
                        help="display the final config as environment variables" +
                             "based env variables and ini file parameters")
    parser.add_argument('--show_ini', action='store_true',
                        help="show variables as ini files parameters instead of environment variables")
    parser.add_argument('--disable_colors', action='store_true', help="disable colors in logoutput")
    parser.add_argument('ini_file', nargs="?", type=str,
                        help="optional, use a additional inifile for configuration " +
                             "(environment variables take precedence) or execute a " +
                             "binary with a fully qualified file path")
    args = parser.parse_args()

    coloredlogs.install(fmt=formatter_string, isatty=(not args.disable_colors))

    config = Configuration()

    if args.ini_file:
        if args.ini_file.startswith("/bin/"):
            os.system(args.ini_file)
            sys.exit(1)
        else:
            try:
                config.load_config_file(args.ini_file)
            except Exception as e:
                logger.fatal(e)
                sys.exit(1)

    config.load_from_environment_variables()
    if args.show_effective_config:
        config.show_effective_config(show_as_ini_variables=args.show_ini)

    if config.sentry_enabled:
        logger.info("starting with sentry DSN %s" % config.sentry_dsn)
        config.sentry_enabled = True
        if not config.sentry_dsn:
            print("sentry enabled but no DNS set: '%s'! ABORTING!" % config.sentry_dsn)
        sentry_sdk.init(config.sentry_dsn)

    if config.zabbix_debug:
        logger.info("starting with zabbix debug")
        config.zabbix_debug = True
        log = logging.getLogger('pyzabbix')
        log.setLevel(logging.DEBUG)
    else:
        log = logging.getLogger('pyzabbix')
        log.setLevel(logging.INFO)

    if config.debug:
        stream.setLevel(logging.DEBUG)
        logger.setLevel(logging.DEBUG)
    else:
        logger.setLevel(logging.INFO)
    logger.addHandler(stream)

    daemons: List[CheckKubernetesDaemon] = list()

    mgmt_daemon = CheckKubernetesDaemon(config,
                                        ['nodes'],
                                        config.discovery_interval_slow, config.resend_data_interval_slow)
    daemons.append(mgmt_daemon)

    daemons.append(
        CheckKubernetesDaemon(config,
                              # ['components', 'services', 'pvcs'],
                              ['components', 'pvcs'],
                              config.discovery_interval_slow, config.resend_data_interval_fast))

    daemons.append(
        CheckKubernetesDaemon(config,
                              # ['deployments', 'statefulsets', 'daemonsets', 'pods', 'containers',
                              # 'ingresses', 'containers', 'pods'],
                              ['deployments', 'statefulsets', "daemonsets", "pods"],
                              config.discovery_interval_slow, config.resend_data_interval_slow))

    if config.debug_k8s_events:
        for daemon in daemons:
            daemon.debug_k8s_events = True


    # SIGNAL processing
    def _signal_handler(signum, *args):
        mgmt_daemon.handler(signum)


    def stacktraces_and_terminate(signum, frame):
        print("#" * 80)
        print("# Threadump")
        faulthandler.dump_traceback()
        print("#")
        print("#" * 80)
        sys.exit(1)


    signal.signal(signal.SIGQUIT, stacktraces_and_terminate)
    signal.signal(signal.SIGUSR1, _signal_handler)
    signal.signal(signal.SIGUSR2, _signal_handler)

    # Daemon start
    try:
        logger.info("Starting daemon threads now")
        for daemon in daemons:
            daemon.run()
        while True:
            time.sleep(10)
    except KeyboardInterrupt:
        logger.info("got SIGINT, shutting down")
        for daemon in daemons:
            daemon.handler(signal.SIGTERM)
        sys.exit(1)