def _initialise_github_alerter() -> GithubAlerter: alerter_display_name = GITHUB_ALERTER_NAME github_alerter_logger = _initialise_alerter_logger(alerter_display_name, GithubAlerter.__name__) # Try initialising an alerter until successful while True: try: rabbitmq = RabbitMQApi(logger=github_alerter_logger.getChild( RabbitMQApi.__name__), host=RABBIT_IP) github_alerter = GithubAlerter(alerter_display_name, github_alerter_logger, rabbitmq, ALERTER_PUBLISHING_QUEUE_SIZE) log_and_print( "Successfully initialised {}".format(alerter_display_name), github_alerter_logger) break except Exception as e: msg = get_initialisation_error_message(alerter_display_name, e) log_and_print(msg, github_alerter_logger) # sleep 10 seconds before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return github_alerter
def _initialise_system_alerter(system_alerts_config: SystemAlertsConfig, chain: str) -> SystemAlerter: # Alerter display name based on system alerter_display_name = SYSTEM_ALERTER_NAME_TEMPLATE.format(chain) system_alerter_logger = _initialise_alerter_logger(alerter_display_name, SystemAlerter.__name__) # Try initialising an alerter until successful while True: try: rabbitmq = RabbitMQApi(logger=system_alerter_logger.getChild( RabbitMQApi.__name__), host=RABBIT_IP) system_alerter = SystemAlerter(alerter_display_name, system_alerts_config, system_alerter_logger, rabbitmq, ALERTER_PUBLISHING_QUEUE_SIZE) log_and_print( "Successfully initialised {}".format(alerter_display_name), system_alerter_logger) break except Exception as e: msg = get_initialisation_error_message(alerter_display_name, e) log_and_print(msg, system_alerter_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return system_alerter
def _initialise_monitor(monitor_type: Type[T], monitor_display_name: str, monitoring_period: int, config: Union[SystemConfig, RepoConfig]) -> T: monitor_logger = _initialise_monitor_logger(monitor_display_name, monitor_type.__name__) # Try initialising the monitor until successful while True: try: rabbitmq = RabbitMQApi(logger=monitor_logger.getChild( RabbitMQApi.__name__), host=env.RABBIT_IP) monitor = monitor_type(monitor_display_name, config, monitor_logger, monitoring_period, rabbitmq) log_and_print( "Successfully initialised {}".format(monitor_display_name), monitor_logger) break except Exception as e: msg = get_initialisation_error_message(monitor_display_name, e) log_and_print(msg, monitor_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return monitor
def _initialise_data_transformer(data_transformer_type: Type[T], data_transformer_display_name: str) -> T: transformer_logger = _initialise_transformer_logger( data_transformer_display_name, data_transformer_type.__name__) redis = _initialise_transformer_redis(data_transformer_display_name, transformer_logger) # Try initialising the transformer until successful while True: try: rabbitmq = RabbitMQApi(logger=transformer_logger.getChild( RabbitMQApi.__name__), host=env.RABBIT_IP) data_transformer = data_transformer_type( data_transformer_display_name, transformer_logger, redis, rabbitmq, env.DATA_TRANSFORMER_PUBLISHING_QUEUE_SIZE) log_and_print( "Successfully initialised {}".format( data_transformer_display_name), transformer_logger) break except Exception as e: msg = get_initialisation_error_message( data_transformer_display_name, e) log_and_print(msg, transformer_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return data_transformer
def _initialise_component_redis(component_display_name: str, component_logger: logging.Logger) -> RedisApi: # Try initialising the Redis API until successful. This had to be done # separately to avoid instances when Redis creation failed and we # attempt to use it. while True: try: redis_db = env.REDIS_DB redis_port = env.REDIS_PORT redis_host = env.REDIS_IP unique_alerter_identifier = env.UNIQUE_ALERTER_IDENTIFIER redis = RedisApi(logger=component_logger.getChild( RedisApi.__name__), db=redis_db, host=redis_host, port=redis_port, namespace=unique_alerter_identifier) break except Exception as e: msg = get_initialisation_error_message(component_display_name, e) log_and_print(msg, component_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return redis
def _initialise_system_monitors_manager() -> SystemMonitorsManager: manager_display_name = SYSTEM_MONITORS_MANAGER_NAME system_monitors_manager_logger = _initialise_logger( manager_display_name, SystemMonitorsManager.__name__, env.MANAGERS_LOG_FILE_TEMPLATE) # Attempt to initialise the system monitors manager while True: try: rabbit_ip = env.RABBIT_IP rabbitmq = RabbitMQApi( logger=system_monitors_manager_logger.getChild( RabbitMQApi.__name__), host=rabbit_ip) system_monitors_manager = SystemMonitorsManager( system_monitors_manager_logger, manager_display_name, rabbitmq) break except Exception as e: log_and_print( get_initialisation_error_message(manager_display_name, e), system_monitors_manager_logger) log_and_print(get_reattempting_message(manager_display_name), system_monitors_manager_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return system_monitors_manager
def _initialise_data_store_manager() -> StoreManager: manager_display_name = DATA_STORE_MANAGER_NAME data_store_manager_logger = _initialise_logger( manager_display_name, StoreManager.__name__, env.MANAGERS_LOG_FILE_TEMPLATE) # Attempt to initialise the data store manager while True: try: rabbitmq = RabbitMQApi(logger=data_store_manager_logger.getChild( RabbitMQApi.__name__), host=env.RABBIT_IP) data_store_manager = StoreManager(data_store_manager_logger, manager_display_name, rabbitmq) break except Exception as e: log_and_print( get_initialisation_error_message(manager_display_name, e), data_store_manager_logger) log_and_print(get_reattempting_message(manager_display_name), data_store_manager_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return data_store_manager
def _initialise_logger(component_display_name: str, component_module_name: str, log_file_template: str) -> logging.Logger: # Try initialising the logger until successful. This had to be done # separately to avoid instances when the logger creation failed and we # attempt to use it. while True: try: new_logger = create_logger( log_file_template.format(component_display_name), component_module_name, env.LOGGING_LEVEL, rotating=True) break except Exception as e: # Use a dummy logger in this case because we cannot create the # manager's logger. dummy_logger = logging.getLogger('DUMMY_LOGGER') log_and_print( get_initialisation_error_message(component_display_name, e), dummy_logger) log_and_print(get_reattempting_message(component_display_name), dummy_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return new_logger
def _initialise_github_alerter_manager() -> GithubAlerterManager: manager_display_name = GITHUB_ALERTER_MANAGER_NAME github_alerter_manager_logger = _initialise_logger( manager_display_name, GithubAlerterManager.__name__, env.MANAGERS_LOG_FILE_TEMPLATE) # Attempt to initialise the system alerters manager while True: try: rabbitmq = RabbitMQApi( logger=github_alerter_manager_logger.getChild( RabbitMQApi.__name__), host=env.RABBIT_IP) github_alerter_manager = GithubAlerterManager( github_alerter_manager_logger, manager_display_name, rabbitmq) break except Exception as e: log_and_print( get_initialisation_error_message(manager_display_name, e), github_alerter_manager_logger) log_and_print(get_reattempting_message(manager_display_name), github_alerter_manager_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return github_alerter_manager
def _initialise_channels_manager() -> ChannelsManager: manager_display_name = CHANNELS_MANAGER_NAME channels_manager_logger = _initialise_logger( manager_display_name, ChannelsManager.__name__, env.MANAGERS_LOG_FILE_TEMPLATE) # Attempt to initialise the data transformers manager while True: try: rabbitmq = RabbitMQApi(logger=channels_manager_logger.getChild( RabbitMQApi.__name__), host=env.RABBIT_IP) channels_manager = ChannelsManager(channels_manager_logger, manager_display_name, rabbitmq) break except Exception as e: log_and_print( get_initialisation_error_message(manager_display_name, e), channels_manager_logger) log_and_print(get_reattempting_message(manager_display_name), channels_manager_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return channels_manager
def _initialise_log_alerts_handler(channel_id: str, channel_name: str) -> LogAlertsHandler: # Handler display name based on channel name handler_display_name = LOG_ALERTS_HANDLER_NAME_TEMPLATE.format( channel_name) handler_logger = _initialise_channel_handler_logger( handler_display_name, LogAlertsHandler.__name__) alerts_logger = _initialise_alerts_logger() # Try initialising handler until successful while True: try: log_channel = LogChannel( channel_name, channel_id, handler_logger.getChild(LogChannel.__name__), alerts_logger) rabbitmq = RabbitMQApi(logger=handler_logger.getChild( RabbitMQApi.__name__), host=env.RABBIT_IP) log_alerts_handler = LogAlertsHandler(handler_display_name, handler_logger, rabbitmq, log_channel) log_and_print( "Successfully initialised {}".format(handler_display_name), handler_logger) break except Exception as e: msg = get_initialisation_error_message(handler_display_name, e) log_and_print(msg, handler_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return log_alerts_handler
def _initialise_telegram_commands_handler( bot_token: str, bot_chat_id: str, channel_id: str, channel_name: str, associated_chains: Dict) -> TelegramCommandsHandler: # Handler display name based on channel name handler_display_name = TELEGRAM_COMMANDS_HANDLER_NAME_TEMPLATE.format( channel_name) handler_logger = _initialise_channel_handler_logger( handler_display_name, TelegramCommandsHandler.__name__) # Try initialising handler until successful while True: try: telegram_bot = TelegramBotApi(bot_token, bot_chat_id) telegram_channel = TelegramChannel( channel_name, channel_id, handler_logger.getChild(TelegramChannel.__name__), telegram_bot) cmd_handlers_logger = handler_logger.getChild( TelegramCommandHandlers.__name__) cmd_handlers_rabbitmq = RabbitMQApi( logger=cmd_handlers_logger.getChild(RabbitMQApi.__name__), host=env.RABBIT_IP) cmd_handlers_redis = RedisApi( logger=cmd_handlers_logger.getChild(RedisApi.__name__), host=env.REDIS_IP, db=env.REDIS_DB, port=env.REDIS_PORT, namespace=env.UNIQUE_ALERTER_IDENTIFIER) cmd_handlers_mongo = MongoApi(logger=cmd_handlers_logger.getChild( MongoApi.__name__), host=env.DB_IP, db_name=env.DB_NAME, port=env.DB_PORT) cmd_handlers = TelegramCommandHandlers( TELEGRAM_COMMAND_HANDLERS_NAME, cmd_handlers_logger, associated_chains, telegram_channel, cmd_handlers_rabbitmq, cmd_handlers_redis, cmd_handlers_mongo) handler_rabbitmq = RabbitMQApi(logger=handler_logger.getChild( RabbitMQApi.__name__), host=env.RABBIT_IP) telegram_commands_handler = TelegramCommandsHandler( handler_display_name, handler_logger, handler_rabbitmq, telegram_channel, cmd_handlers) log_and_print( "Successfully initialised {}".format(handler_display_name), handler_logger) break except Exception as e: msg = get_initialisation_error_message(handler_display_name, e) log_and_print(msg, handler_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return telegram_commands_handler
def _initialise_alert_router() -> Tuple[AlertRouter, logging.Logger]: display_name = ALERT_ROUTER_NAME # Try initialising the logger until successful. This had to be done # separately to avoid instances when the logger creation failed and we # attempt to use it. while True: try: alert_router_logger = create_logger(env.ALERT_ROUTER_LOG_FILE, AlertRouter.__name__, env.LOGGING_LEVEL, rotating=True) break except Exception as e: # Use a dummy logger in this case because we cannot create the # manager's logger. dummy_logger = logging.getLogger('DUMMY_LOGGER') log_and_print(get_initialisation_error_message(display_name, e), dummy_logger) log_and_print(get_reattempting_message(display_name), dummy_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) rabbit_ip = env.RABBIT_IP redis_ip = env.REDIS_IP redis_db = env.REDIS_DB redis_port = env.REDIS_PORT unique_alerter_identifier = env.UNIQUE_ALERTER_IDENTIFIER while True: try: alert_router = AlertRouter(display_name, alert_router_logger, rabbit_ip, redis_ip, redis_db, redis_port, unique_alerter_identifier, env.ENABLE_CONSOLE_ALERTS, env.ENABLE_LOG_ALERTS) return alert_router, alert_router_logger except Exception as e: log_and_print(get_initialisation_error_message(display_name, e), alert_router_logger) log_and_print(get_reattempting_message(display_name), alert_router_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
def _initialise_alerts_logger() -> logging.Logger: # Try initialising the logger until successful. This had to be done # separately to avoid instances when the logger creation failed and we # attempt to use it. while True: try: alerts_logger = create_logger(env.ALERTS_LOG_FILE, 'Alerts', env.LOGGING_LEVEL, True) break except Exception as e: msg = get_initialisation_error_message('Alerts Log File', e) # Use a dummy logger in this case because we cannot create the # logger. log_and_print(msg, logging.getLogger('DUMMY_LOGGER')) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return alerts_logger
def _initialise_email_alerts_handler(smtp: str, email_from: str, emails_to: List[str], channel_id: str, channel_name: str, username: Optional[str], password: Optional[str], port: int = 0) -> EmailAlertsHandler: # Handler display name based on channel name handler_display_name = EMAIL_ALERTS_HANDLER_NAME_TEMPLATE.format( channel_name) handler_logger = _initialise_channel_handler_logger( handler_display_name, EmailAlertsHandler.__name__) # Try initialising handler until successful while True: try: email_api = EmailApi(smtp, email_from, username, password, port) email_channel = EmailChannel( channel_name, channel_id, handler_logger.getChild(EmailChannel.__name__), emails_to, email_api) rabbitmq = RabbitMQApi(logger=handler_logger.getChild( RabbitMQApi.__name__), host=env.RABBIT_IP) email_alerts_handler = EmailAlertsHandler( handler_display_name, handler_logger, rabbitmq, email_channel, env.CHANNELS_MANAGER_PUBLISHING_QUEUE_SIZE) log_and_print( "Successfully initialised {}".format(handler_display_name), handler_logger) break except Exception as e: msg = get_initialisation_error_message(handler_display_name, e) log_and_print(msg, handler_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return email_alerts_handler
def _initialise_store_logger( store_display_name: str, store_module_name: str) -> logging.Logger: # Try initialising the logger until successful. This had to be done # separately to avoid instances when the logger creation failed and we # attempt to use it. while True: try: store_logger = create_logger( env.DATA_STORE_LOG_FILE_TEMPLATE.format(store_display_name), store_module_name, env.LOGGING_LEVEL, rotating=True) break except Exception as e: msg = get_initialisation_error_message(store_display_name, e) # Use a dummy logger in this case because we cannot create the # transformer's logger. log_and_print(msg, logging.getLogger('DUMMY_LOGGER')) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return store_logger
def _initialise_store(store_type: Type[T], store_display_name: str) -> T: store_logger = _initialise_store_logger(store_display_name, store_type.__name__) # Try initialising the store until successful while True: try: rabbitmq = RabbitMQApi( logger=store_logger.getChild(RabbitMQApi.__name__), host=env.RABBIT_IP) store = store_type(store_display_name, store_logger, rabbitmq) log_and_print("Successfully initialised {}".format( store_display_name), store_logger) break except Exception as e: msg = get_initialisation_error_message(store_display_name, e) log_and_print(msg, store_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return store
def _initialise_transformer_redis( transformer_name: str, transformer_logger: logging.Logger) -> RedisApi: # Try initialising the Redis API until successful. This had to be done # separately to avoid instances when Redis creation failed and we # attempt to use it. while True: try: redis = RedisApi(logger=transformer_logger.getChild( RedisApi.__name__), db=env.REDIS_DB, host=env.REDIS_IP, port=env.REDIS_PORT, namespace=env.UNIQUE_ALERTER_IDENTIFIER) break except Exception as e: msg = get_initialisation_error_message(transformer_name, e) log_and_print(msg, transformer_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return redis
def _initialise_health_checker_manager() -> HealthCheckerManager: manager_display_name = HEALTH_CHECKER_MANAGER_NAME health_checker_manager_logger = _initialise_logger( manager_display_name, HealthCheckerManager.__name__, env.MANAGERS_LOG_FILE_TEMPLATE) # Attempt to initialise the health checker manager while True: try: health_checker_manager = HealthCheckerManager( health_checker_manager_logger, manager_display_name) break except Exception as e: msg = get_initialisation_error_message(manager_display_name, e) log_and_print(msg, health_checker_manager_logger) log_and_print(get_reattempting_message(manager_display_name), health_checker_manager_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return health_checker_manager
def _initialise_heartbeat_handler() -> HeartbeatHandler: component_display_name = HEARTBEAT_HANDLER_NAME logger = _initialise_health_checker_logger(component_display_name, HeartbeatHandler.__name__) redis = _initialise_component_redis(component_display_name, logger) # Try initialising the heartbeat handler until successful while True: try: heartbeat_handler = HeartbeatHandler(logger, redis, component_display_name) log_and_print( "Successfully initialised {}".format(component_display_name), logger) break except Exception as e: msg = get_initialisation_error_message(component_display_name, e) log_and_print(msg, logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return heartbeat_handler
def _initialise_ping_publisher() -> PingPublisher: component_display_name = PING_PUBLISHER_NAME logger = _initialise_health_checker_logger(component_display_name, PingPublisher.__name__) redis = _initialise_component_redis(component_display_name, logger) # Try initialising the ping publisher until successful while True: try: ping_publisher = PingPublisher(30, logger, redis, component_display_name) log_and_print( "Successfully initialised {}".format(component_display_name), logger) break except Exception as e: msg = get_initialisation_error_message(component_display_name, e) log_and_print(msg, logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return ping_publisher
def _initialise_config_manager() -> Tuple[ConfigsManager, logging.Logger]: display_name = CONFIGS_MANAGER_NAME config_manager_logger = _initialise_logger(display_name, ConfigsManager.__name__, env.CONFIG_MANAGER_LOG_FILE) rabbit_ip = env.RABBIT_IP while True: try: config_manager = ConfigsManager(display_name, config_manager_logger, '../config', rabbit_ip) return config_manager, config_manager_logger except Exception as e: # This is already logged, we need to try again. This exception # should not happen, but if it does the program can't fully start # up log_and_print(get_initialisation_error_message(display_name, e), config_manager_logger) log_and_print(get_reattempting_message(display_name), config_manager_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
def _initialise_telegram_alerts_handler( bot_token: str, bot_chat_id: str, channel_id: str, channel_name: str) -> TelegramAlertsHandler: # Handler display name based on channel name handler_display_name = TELEGRAM_ALERTS_HANDLER_NAME_TEMPLATE.format( channel_name) handler_logger = _initialise_channel_handler_logger( handler_display_name, TelegramAlertsHandler.__name__) # Try initialising handler until successful while True: try: telegram_bot = TelegramBotApi(bot_token, bot_chat_id) telegram_channel = TelegramChannel( channel_name, channel_id, handler_logger.getChild(TelegramChannel.__name__), telegram_bot) rabbitmq = RabbitMQApi(logger=handler_logger.getChild( RabbitMQApi.__name__), host=env.RABBIT_IP) telegram_alerts_handler = TelegramAlertsHandler( handler_display_name, handler_logger, rabbitmq, telegram_channel, env.CHANNELS_MANAGER_PUBLISHING_QUEUE_SIZE) log_and_print( "Successfully initialised {}".format(handler_display_name), handler_logger) break except Exception as e: msg = get_initialisation_error_message(handler_display_name, e) log_and_print(msg, handler_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return telegram_alerts_handler
def _initialise_opsgenie_alerts_handler( api_key: str, eu_host: bool, channel_id: str, channel_name: str) -> OpsgenieAlertsHandler: # Handler display name based on channel name handler_display_name = OPSGENIE_ALERTS_HANDLER_NAME_TEMPLATE.format( channel_name) handler_logger = _initialise_channel_handler_logger( handler_display_name, OpsgenieAlertsHandler.__name__) # Try initialising handler until successful while True: try: opsgenie_api = OpsgenieApi(api_key, eu_host) opsgenie_channel = OpsgenieChannel( channel_name, channel_id, handler_logger.getChild(OpsgenieChannel.__name__), opsgenie_api) rabbitmq = RabbitMQApi(logger=handler_logger.getChild( RabbitMQApi.__name__), host=env.RABBIT_IP) opsgenie_alerts_handler = OpsgenieAlertsHandler( handler_display_name, handler_logger, rabbitmq, opsgenie_channel, env.CHANNELS_MANAGER_PUBLISHING_QUEUE_SIZE) log_and_print( "Successfully initialised {}".format(handler_display_name), handler_logger) break except Exception as e: msg = get_initialisation_error_message(handler_display_name, e) log_and_print(msg, handler_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return opsgenie_alerts_handler
def _initialise_pagerduty_alerts_handler( integration_key: str, channel_id: str, channel_name: str) -> PagerDutyAlertsHandler: # Handler display name based on channel name handler_display_name = PAGERDUTY_ALERTS_HANDLER_NAME_TEMPLATE.format( channel_name) handler_logger = _initialise_channel_handler_logger( handler_display_name, PagerDutyAlertsHandler.__name__) # Try initialising handler until successful while True: try: pagerduty_api = PagerDutyApi(integration_key) pagerduty_channel = PagerDutyChannel( channel_name, channel_id, handler_logger.getChild(PagerDutyChannel.__name__), pagerduty_api) rabbitmq = RabbitMQApi(logger=handler_logger.getChild( RabbitMQApi.__name__), host=env.RABBIT_IP) pagerduty_alerts_handler = PagerDutyAlertsHandler( handler_display_name, handler_logger, rabbitmq, pagerduty_channel, env.CHANNELS_MANAGER_PUBLISHING_QUEUE_SIZE) log_and_print( "Successfully initialised {}".format(handler_display_name), handler_logger) break except Exception as e: msg = get_initialisation_error_message(handler_display_name, e) log_and_print(msg, handler_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return pagerduty_alerts_handler
def _initialise_twilio_alerts_handler( account_sid: str, auth_token: str, channel_id: str, channel_name: str, call_from: str, call_to: List[str], twiml: str, twiml_is_url: bool) \ -> TwilioAlertsHandler: # Handler display name based on channel name handler_display_name = TWILIO_ALERTS_HANDLER_NAME_TEMPLATE.format( channel_name) handler_logger = _initialise_channel_handler_logger( handler_display_name, TwilioAlertsHandler.__name__) # Try initialising handler until successful while True: try: twilio_api = TwilioApi(account_sid, auth_token) twilio_channel = TwilioChannel( channel_name, channel_id, handler_logger.getChild(TwilioChannel.__name__), twilio_api) rabbitmq = RabbitMQApi(logger=handler_logger.getChild( RabbitMQApi.__name__), host=env.RABBIT_IP) twilio_alerts_handler = TwilioAlertsHandler( handler_display_name, handler_logger, rabbitmq, twilio_channel, call_from, call_to, twiml, twiml_is_url) log_and_print( "Successfully initialised {}".format(handler_display_name), handler_logger) break except Exception as e: msg = get_initialisation_error_message(handler_display_name, e) log_and_print(msg, handler_logger) # sleep before trying again time.sleep(RE_INITIALISE_SLEEPING_PERIOD) return twilio_alerts_handler