def create(self, factory_ctx): """ Automatically called to create the check function's object :param factory_ctx: (dict) names available for Function instantiation :return: an object that implements a check function """ # load plugins dependencies and store them locally for efficiency if not self.http_factory: self.http_factory = plugin_manager.get_plugin_obj_by_name( 'http', 'Function') if not self.jmx_factory: self.jmx_factory = plugin_manager.get_plugin_obj_by_name( 'jmx', 'Function') if not self.counter_factory: self.counter_factory = plugin_manager.get_plugin_obj_by_name( 'counter', 'Function') return propartial(ZomcatWrapper, host=factory_ctx['host'], instance=factory_ctx['instance'], http=self.http_factory.create(factory_ctx), jmx=self.jmx_factory.create(factory_ctx), counter=self.counter_factory.create(factory_ctx))
def test_load_plugins_extras(self): """ Test is we can load correctly the extra plugins. Also loads builtins and simple test plugins. Notice we put two folders to ZMON_PLUGINS env var, separated by ':' """ # reload the plugin reload(plugin_manager) # Lets create a category filter that includes our builtin plugin type and 2 types we defines for our tests category_filter = { 'Function': IFunctionFactoryPlugin, 'Color': IColorPlugin, 'Temperature': ITemperaturePlugin, } # init the plugin manager plugin_manager.init_plugin_manager(category_filter=category_filter) # collect builtins and explore folder in env var, e.g. ZMON_PLUGINS="/path/one:path/two:/path/three" plugin_manager.collect_plugins(load_builtins=True, load_env=True, additional_dirs=None) # check categories all_categories = plugin_manager.get_all_categories() seen_categories = plugin_manager.get_loaded_plugins_categories() self.assertEqual(set(all_categories), set(category_filter.keys()), 'All defined categories are stored') self.assertTrue(len(seen_categories) >= 2 and set(seen_categories).issubset(set(all_categories)), 'found at least 2 categories and they all belong to all defined categories') # check known test plugins are loaded extra_plugins = ['exacrm', 'job_lock', 'nagios', 'snmp', 'mssql'] # non exhaustive list known_plugin_names = extra_plugins + ['http', 'color_spain', 'color_germany', 'temperature_fridge'] plugin_names = plugin_manager.get_all_plugin_names() self.assertTrue(set(known_plugin_names).issubset(plugin_names), 'All known test plugins are loaded') # check extra plugins for name, category in zip(extra_plugins, ['Function']*len(extra_plugins)): p = plugin_manager.get_plugin_by_name(name, category) p_obj = plugin_manager.get_plugin_obj_by_name(name, category) self.assertEqual(id(p.plugin_object), id(p_obj), 'locate plugin object works') self.assertTrue(p.is_activated) self.assertEqual(p.plugin_object.is_activated, p.is_activated, 'plugin is activated') self.assertTrue(isinstance(p_obj, IFunctionFactoryPlugin), 'plugin object is instance of IFunctionFactoryPlugin') # test extra plugin are configured according to config file self.assertEqual(plugin_manager.get_plugin_obj_by_name('exacrm', 'Function')._exacrm_cluster, '--secret--', 'exacrm object is configured')
def test_global_config(self): """ Test that the plugin can configure itself from the global config and that global config takes precedence over local config """ # reload the plugin reload(plugin_manager) # Lets create a category filter that includes our builtin plugin type and 2 types we defines for our tests category_filter = { 'Function': IFunctionFactoryPlugin, 'Color': IColorPlugin, 'Temperature': ITemperaturePlugin, } # init the plugin manager plugin_manager.init_plugin_manager(category_filter=category_filter) # inject as global conf to color_german plugin fashion sites different from the local conf global_conf = { 'plugin.color_germany.fashion_sites': 'superfashion.de hypefashion.de', 'plugin.other_plugin.otherkey': 'this will not be passed to color_germany.configure', } # collect plugins builtin and explore env_var: ZMON_PLUGINS="/.../tests/plugins/simple_plugins" plugin_manager.collect_plugins(load_builtins=True, load_env=True, additional_dirs=None, global_config=global_conf) # test that color_german plugin was configured according to the global conf global_conf_sites = ['superfashion.de', 'hypefashion.de'] color_ger_obj = plugin_manager.get_plugin_obj_by_name('color_germany', 'Color') self.assertTrue(set(global_conf_sites) == set(color_ger_obj.main_fashion_sites), 'object is configured')
def test_load_builtin_plugins(self): """ Test that city plugin can be fully loaded """ # reload the plugin reload(plugin_manager) plugin_manager.init_plugin_manager() # init the plugin manager # collect only builtin plugins plugin_manager.collect_plugins(load_builtins=True, load_env=False, additional_dirs=None) # city plugin is a builtin and is in category entity plugin_name = 'http' plugin_category = 'Function' self.assertIn(plugin_name, plugin_manager.get_all_plugin_names(), 'http plugin name must be found') http_plugin = plugin_manager.get_plugin_by_name(plugin_name, plugin_category) self.assertIsNotNone(http_plugin, 'http plugin must be under category Function') self.assertEqual(http_plugin.name, plugin_name, 'check plugin name field') # check city plugin object self.assertTrue(hasattr(http_plugin, 'plugin_object'), 'http.plugin_object exists') self.assertIsNotNone(http_plugin.plugin_object, 'http.plugin_object is not None') self.assertTrue(isinstance(plugin_manager.get_plugin_obj_by_name(plugin_name, plugin_category), IFunctionFactoryPlugin), 'the entity plugin object is instance of IFunctionFactoryPlugin') # check that city plugin object is activated self.assertTrue(http_plugin.is_activated) self.assertEqual(http_plugin.plugin_object.is_activated, http_plugin.is_activated)
def create(self, factory_ctx): """ Automatically called to create the check function's object :param factory_ctx: (dict) names available for Function instantiation :return: an object that implements a check function """ # load plugins dependencies and store them locally for efficiency if not self.counter_factory: self.counter_factory = plugin_manager.get_plugin_obj_by_name('counter', 'Function') return propartial(MemcachedWrapper, counter=self.counter_factory.create(factory_ctx), host=factory_ctx['host'])
def create(self, factory_ctx): """ Automatically called to create the check function's object :param factory_ctx: (dict) names available for Function instantiation :return: an object that implements a check function """ if not self.counter_factory: self.counter_factory = plugin_manager.get_plugin_obj_by_name('counter', 'Function') return propartial(LdapWrapper, user=self._ldapuser, password=self._ldappass, host=factory_ctx['host'], counter=self.counter_factory.create(factory_ctx))
def create(self, factory_ctx): """ Automatically called to create the check function's object :param factory_ctx: (dict) names available for Function instantiation :return: an object that implements a check function """ if not self.counter_factory: self.counter_factory = plugin_manager.get_plugin_obj_by_name('counter', 'Function') return propartial(LdapWrapper, user=self._ldapuser, password=self._ldappass, host=factory_ctx['host'], counter=self.counter_factory.create(factory_ctx))
def create(self, factory_ctx): """ Automatically called to create the check function's object :param factory_ctx: (dict) names available for Function instantiation :return: an object that implements a check function """ # load plugins dependencies and store them locally for efficiency if not self.http_factory: self.http_factory = plugin_manager.get_plugin_obj_by_name('http', 'Function') return propartial(EventLogWrapper, http_wrapper=self.http_factory.create(factory_ctx), url=self.eventlog_url)
def create(self, factory_ctx): """ Automatically called to create the check function's object :param factory_ctx: (dict) names available for Function instantiation :return: an object that implements a check function """ # load plugins dependencies and store them locally for efficiency if not self.http_factory: self.http_factory = plugin_manager.get_plugin_obj_by_name( 'http', 'Function') return propartial(JobsWrapper, http_wrapper=self.http_factory.create(factory_ctx), project=factory_ctx['entity'].get('name'))
def create(self, factory_ctx): """ Automatically called to create the check function's object :param factory_ctx: (dict) names available for Function instantiation :return: an object that implements a check function """ # load plugins dependencies and store them locally for efficiency if not self.counter_factory: self.counter_factory = plugin_manager.get_plugin_obj_by_name( 'counter', 'Function') return propartial(RedisWrapper, counter=self.counter_factory.create(factory_ctx), host=factory_ctx['host'], password=self.__password)
def test_load_builtin_plugins(self): """ Test that city plugin can be fully loaded """ # reload the plugin reload(plugin_manager) plugin_manager.init_plugin_manager() # init the plugin manager # collect only builtin plugins plugin_manager.collect_plugins(load_builtins=True, load_env=False, additional_dirs=None) # city plugin is a builtin and is in category entity plugin_name = 'http' plugin_category = 'Function' self.assertIn(plugin_name, plugin_manager.get_all_plugin_names(), 'http plugin name must be found') http_plugin = plugin_manager.get_plugin_by_name( plugin_name, plugin_category) self.assertIsNotNone(http_plugin, 'http plugin must be under category Function') self.assertEqual(http_plugin.name, plugin_name, 'check plugin name field') # check city plugin object self.assertTrue(hasattr(http_plugin, 'plugin_object'), 'http.plugin_object exists') self.assertIsNotNone(http_plugin.plugin_object, 'http.plugin_object is not None') self.assertTrue( isinstance( plugin_manager.get_plugin_obj_by_name(plugin_name, plugin_category), IFunctionFactoryPlugin), 'the entity plugin object is instance of IFunctionFactoryPlugin') # check that city plugin object is activated self.assertTrue(http_plugin.is_activated) self.assertEqual(http_plugin.plugin_object.is_activated, http_plugin.is_activated)
def create(self, factory_ctx): """ Automatically called to create the check function's object :param factory_ctx: (dict) names available for Function instantiation :return: an object that implements a check function """ entity = factory_ctx['entity'] project = entity['name'] if entity['type'] == 'project' else None # load plugins dependencies and store them locally for efficiency if not self.http_factory: self.http_factory = plugin_manager.get_plugin_obj_by_name('http', 'Function') return propartial(ExceptionsWrapper, http_wrapper=self.http_factory.create(factory_ctx), host=factory_ctx['host'], instance=factory_ctx['instance'], project=project)
def test_global_config(self): """ Test that the plugin can configure itself from the global config and that global config takes precedence over local config """ # reload the plugin reload(plugin_manager) # Lets create a category filter that includes our builtin plugin type and 2 types we defines for our tests category_filter = { 'Function': IFunctionFactoryPlugin, 'Color': IColorPlugin, 'Temperature': ITemperaturePlugin, } # init the plugin manager plugin_manager.init_plugin_manager(category_filter=category_filter) # inject as global conf to color_german plugin fashion sites different from the local conf global_conf = { 'plugin.color_germany.fashion_sites': 'superfashion.de hypefashion.de', 'plugin.other_plugin.otherkey': 'this will not be passed to color_germany.configure', } # collect plugins builtin and explore env_var: ZMON_PLUGINS="/.../tests/plugins/simple_plugins" plugin_manager.collect_plugins(load_builtins=True, load_env=True, additional_dirs=None, global_config=global_conf) # test that color_german plugin was configured according to the global conf global_conf_sites = ['superfashion.de', 'hypefashion.de'] color_ger_obj = plugin_manager.get_plugin_obj_by_name( 'color_germany', 'Color') self.assertTrue( set(global_conf_sites) == set(color_ger_obj.main_fashion_sites), 'object is configured')
params['time_to'] = time_to params['group_by'] = group_by result = self.__request('count', params) if len(event_type_ids) == 1 and not group_by: return result.get(params['event_type_ids'], 0) else: return result if __name__ == '__main__': import sys import logging logging.basicConfig(level=logging.DEBUG) # init plugin manager and collect plugins, as done by Zmon when worker is starting plugin_manager.init_plugin_manager() plugin_manager.collect_plugins(load_builtins=True, load_env=True) eventlog_url = sys.argv[1] factory_ctx = {} http = plugin_manager.get_plugin_obj_by_name('http', 'Function').create(factory_ctx) # eventlog = EventLogWrapper() eventlog = EventLogWrapper(http_wrapper=http, url=eventlog_url) print eventlog.count(0x96001, time_from='-1m') print eventlog.count([0x96001, 0x63005], time_from='-1m') print eventlog.count(0x96001, time_from='-1m', group_by='appDomainId')
"used_memory_rss": 63475712 } ''' data = self.__con.info() stats = {} for key in STATISTIC_GAUGE_KEYS: stats[key] = data.get(key) for key in STATISTIC_COUNTER_KEYS: stats['{}_per_sec'.format(key).replace('total_', '')] = \ round(self._counter.key(key).per_second(data.get(key, 0)), 2) stats['dbsize'] = self.__con.dbsize() return stats if __name__ == '__main__': import sys import json # init plugin manager and collect plugins, as done by Zmon when worker is starting plugin_manager.init_plugin_manager() plugin_manager.collect_plugins(load_builtins=True, load_env=True) factory_ctx = { 'redis_host': 'localhost', } counter = plugin_manager.get_plugin_obj_by_name( 'counter', 'Function').create(factory_ctx) wrapper = RedisWrapper(counter, sys.argv[1]) print json.dumps(wrapper.statistics(), indent=4, sort_keys=True)
def test_load_plugins_several_categories(self): """ Test is we can load and correctly locate plugins from several categories First it explores folders from ZMON_PLUGINS env_var, and then from additional_dirs """ for test_load_from in ('env_var', 'additional_folders'): # reload the plugin reload(plugin_manager) # Lets create a category filter that includes our builtin plugin type and 2 types we defines for our tests category_filter = { 'Function': IFunctionFactoryPlugin, 'Color': IColorPlugin, 'Temperature': ITemperaturePlugin, } if test_load_from == 'env_var': # init the plugin manager plugin_manager.init_plugin_manager(category_filter=category_filter) # collect plugins builtin and explore env_var: ZMON_PLUGINS="/.../tests/plugins/simple_plugins" plugin_manager.collect_plugins(load_builtins=True, load_env=True, additional_dirs=None) elif test_load_from == 'additional_folders': # init the plugin manager plugin_manager.init_plugin_manager(category_filter=category_filter) test_plugin_dir = simple_plugin_dir_abs_path() # collect plugins builtin and explore additional_dirs: /.../tests/plugins/simple_plugins plugin_manager.collect_plugins(load_builtins=True, load_env=False, additional_dirs=[test_plugin_dir]) # check categories all_categories = plugin_manager.get_all_categories() seen_categories = plugin_manager.get_loaded_plugins_categories() self.assertEqual(set(all_categories), set(category_filter.keys()), 'All defined categories are stored') self.assertTrue(len(seen_categories) >= 2 and set(seen_categories).issubset(set(all_categories)), 'found at least 2 categories and they all belong to all defined categories') # check known test plugins are loaded known_plugin_names = ['http', 'color_spain', 'color_germany', 'temperature_fridge'] plugin_names = plugin_manager.get_all_plugin_names() self.assertTrue(set(known_plugin_names).issubset(plugin_names), 'All known test plugins are loaded') # test get_plugin_obj_by_name() and get_plugin_objs_of_category() color_ger = plugin_manager.get_plugin_by_name('color_germany', 'Color') color_ger_obj = plugin_manager.get_plugin_obj_by_name('color_germany', 'Color') self.assertEqual(id(color_ger.plugin_object), id(color_ger_obj), 'locate plugin object works') self.assertEqual(color_ger.plugin_object.country, 'germany', 'located object field values look good') all_color_objs = plugin_manager.get_plugin_objs_of_category('Color') self.assertEqual(id(color_ger_obj), id([obj for obj in all_color_objs if obj.country == 'germany'][0]), 'locate the plugin object in a convoluted way works too') # test that color_german plugin was configured with the main fashion sites conf_sites_germany = ['www.big_fashion_site.de', 'www.other_fashion_site.de'] self.assertTrue(set(conf_sites_germany) == set(color_ger_obj.main_fashion_sites), 'object is configured') # test that plugin objects run its logic correctly color_obj_de = plugin_manager.get_plugin_obj_by_name('color_germany', 'Color') color_obj_es = plugin_manager.get_plugin_obj_by_name('color_spain', 'Color') simple_colors_de = ['grey', 'white', 'black'] simple_colors_es = ['brown', 'yellow', 'blue'] col_names_de = color_obj_de.get_season_color_names() col_names_es = color_obj_es.get_season_color_names() self.assertEqual(col_names_de, simple_colors_de) self.assertEqual(col_names_es, simple_colors_es) # Test also the logic of temperature plugin object, this simulates a bit more complex logic # Temp readings are simulated as a normal distribution centered at -5 and 0.2 sigma (values from config) # we spawn the thread that periodically do temp reading, we wait some intervals and then get the avg temp # Finally we check that T avg is -5 +- 10 sigmas (see local config) temp_fridge = plugin_manager.get_plugin_obj_by_name('temperature_fridge', 'Temperature') temp_fridge.start_update() time.sleep(temp_fridge.interval * 20) # we wait for some temp collection to happen temp_fridge.stop = True tavg = temp_fridge.get_temperature_average() # This test is non-deterministic, but probability of failure is super small, so in practice it is ok self.assertTrue(abs(-5.0 - tavg) < 0.2 * 10, 'the avg temperature is close to -5') # test subpackage dependencies can be resolved self.assertEqual(temp_fridge.engine.power_unit, 'Watts')
if __name__ == '__main__': # init plugin manager and collect plugins, as done by Zmon when worker is starting plugin_manager.init_plugin_manager() plugin_manager.collect_plugins(load_builtins=True, load_env=True) host = sys.argv[1] instance = sys.argv[2] factory_ctx = { 'base_url': 'http://{host}:3{instance}/'.format(host=host, instance=instance), 'host': host, 'port': ZomcatWrapper.get_jmx_port(instance), 'instance': instance, 'redis_host': 'localhost', } # http = partial(HttpWrapper, base_url='http://{host}:3{instance}/'.format(host=host, instance=instance)) http = plugin_manager.get_plugin_obj_by_name('http', 'Function').create(factory_ctx) # jmx = partial(JmxWrapper, host=host, port=ZomcatWrapper.get_jmx_port(instance)) jmx = plugin_manager.get_plugin_obj_by_name('jmx', 'Function').create(factory_ctx) # counter = partial(CounterWrapper, redis_host='localhost') counter = plugin_manager.get_plugin_obj_by_name('counter', 'Function').create(factory_ctx) zomcat = ZomcatWrapper(host, instance, http=http, jmx=jmx, counter=counter) print json.dumps(zomcat.health(), indent=4, sort_keys=True)
def test_load_plugins_extras(self): """ Test is we can load correctly the extra plugins. Also loads builtins and simple test plugins. Notice we put two folders to ZMON_PLUGINS env var, separated by ':' """ # reload the plugin reload(plugin_manager) # Lets create a category filter that includes our builtin plugin type and 2 types we defines for our tests category_filter = { 'Function': IFunctionFactoryPlugin, 'Color': IColorPlugin, 'Temperature': ITemperaturePlugin, } # init the plugin manager plugin_manager.init_plugin_manager(category_filter=category_filter) # collect builtins and explore folder in env var, e.g. ZMON_PLUGINS="/path/one:path/two:/path/three" plugin_manager.collect_plugins(load_builtins=True, load_env=True, additional_dirs=None) # check categories all_categories = plugin_manager.get_all_categories() seen_categories = plugin_manager.get_loaded_plugins_categories() self.assertEqual(set(all_categories), set(category_filter.keys()), 'All defined categories are stored') self.assertTrue( len(seen_categories) >= 2 and set(seen_categories).issubset(set(all_categories)), 'found at least 2 categories and they all belong to all defined categories' ) # check known test plugins are loaded extra_plugins = ['exacrm', 'job_lock', 'nagios', 'snmp', 'mssql'] # non exhaustive list known_plugin_names = extra_plugins + [ 'http', 'color_spain', 'color_germany', 'temperature_fridge' ] plugin_names = plugin_manager.get_all_plugin_names() self.assertTrue( set(known_plugin_names).issubset(plugin_names), 'All known test plugins are loaded') # check extra plugins for name, category in zip(extra_plugins, ['Function'] * len(extra_plugins)): p = plugin_manager.get_plugin_by_name(name, category) p_obj = plugin_manager.get_plugin_obj_by_name(name, category) self.assertEqual(id(p.plugin_object), id(p_obj), 'locate plugin object works') self.assertTrue(p.is_activated) self.assertEqual(p.plugin_object.is_activated, p.is_activated, 'plugin is activated') self.assertTrue( isinstance(p_obj, IFunctionFactoryPlugin), 'plugin object is instance of IFunctionFactoryPlugin') # test extra plugin are configured according to config file self.assertEqual( plugin_manager.get_plugin_obj_by_name('exacrm', 'Function')._exacrm_cluster, '--secret--', 'exacrm object is configured')
def test_load_plugins_several_categories(self): """ Test is we can load and correctly locate plugins from several categories First it explores folders from ZMON_PLUGINS env_var, and then from additional_dirs """ for test_load_from in ('env_var', 'additional_folders'): # reload the plugin reload(plugin_manager) # Lets create a category filter that includes our builtin plugin type and 2 types we defines for our tests category_filter = { 'Function': IFunctionFactoryPlugin, 'Color': IColorPlugin, 'Temperature': ITemperaturePlugin, } if test_load_from == 'env_var': # init the plugin manager plugin_manager.init_plugin_manager( category_filter=category_filter) # collect plugins builtin and explore env_var: ZMON_PLUGINS="/.../tests/plugins/simple_plugins" plugin_manager.collect_plugins(load_builtins=True, load_env=True, additional_dirs=None) elif test_load_from == 'additional_folders': # init the plugin manager plugin_manager.init_plugin_manager( category_filter=category_filter) test_plugin_dir = simple_plugin_dir_abs_path() # collect plugins builtin and explore additional_dirs: /.../tests/plugins/simple_plugins plugin_manager.collect_plugins( load_builtins=True, load_env=False, additional_dirs=[test_plugin_dir]) # check categories all_categories = plugin_manager.get_all_categories() seen_categories = plugin_manager.get_loaded_plugins_categories() self.assertEqual(set(all_categories), set(category_filter.keys()), 'All defined categories are stored') self.assertTrue( len(seen_categories) >= 2 and set(seen_categories).issubset(set(all_categories)), 'found at least 2 categories and they all belong to all defined categories' ) # check known test plugins are loaded known_plugin_names = [ 'http', 'color_spain', 'color_germany', 'temperature_fridge' ] plugin_names = plugin_manager.get_all_plugin_names() self.assertTrue( set(known_plugin_names).issubset(plugin_names), 'All known test plugins are loaded') # test get_plugin_obj_by_name() and get_plugin_objs_of_category() color_ger = plugin_manager.get_plugin_by_name( 'color_germany', 'Color') color_ger_obj = plugin_manager.get_plugin_obj_by_name( 'color_germany', 'Color') self.assertEqual(id(color_ger.plugin_object), id(color_ger_obj), 'locate plugin object works') self.assertEqual(color_ger.plugin_object.country, 'germany', 'located object field values look good') all_color_objs = plugin_manager.get_plugin_objs_of_category( 'Color') self.assertEqual( id(color_ger_obj), id([obj for obj in all_color_objs if obj.country == 'germany'][0]), 'locate the plugin object in a convoluted way works too') # test that color_german plugin was configured with the main fashion sites conf_sites_germany = [ 'www.big_fashion_site.de', 'www.other_fashion_site.de' ] self.assertTrue( set(conf_sites_germany) == set( color_ger_obj.main_fashion_sites), 'object is configured') # test that plugin objects run its logic correctly color_obj_de = plugin_manager.get_plugin_obj_by_name( 'color_germany', 'Color') color_obj_es = plugin_manager.get_plugin_obj_by_name( 'color_spain', 'Color') simple_colors_de = ['grey', 'white', 'black'] simple_colors_es = ['brown', 'yellow', 'blue'] col_names_de = color_obj_de.get_season_color_names() col_names_es = color_obj_es.get_season_color_names() self.assertEqual(col_names_de, simple_colors_de) self.assertEqual(col_names_es, simple_colors_es) # Test also the logic of temperature plugin object, this simulates a bit more complex logic # Temp readings are simulated as a normal distribution centered at -5 and 0.2 sigma (values from config) # we spawn the thread that periodically do temp reading, we wait some intervals and then get the avg temp # Finally we check that T avg is -5 +- 10 sigmas (see local config) temp_fridge = plugin_manager.get_plugin_obj_by_name( 'temperature_fridge', 'Temperature') temp_fridge.start_update() time.sleep(temp_fridge.interval * 20) # we wait for some temp collection to happen temp_fridge.stop = True tavg = temp_fridge.get_temperature_average() # This test is non-deterministic, but probability of failure is super small, so in practice it is ok self.assertTrue( abs(-5.0 - tavg) < 0.2 * 10, 'the avg temperature is close to -5') # test subpackage dependencies can be resolved self.assertEqual(temp_fridge.engine.power_unit, 'Watts')
return pyjson.loads(self.get(key)) def stats(self, extra_keys=[]): data = self.__con.stats() ret = {} for key in data: if key in COUNTER_KEYS: ret['{}_per_sec'.format(key.replace('total_', ''))] = \ round(self._counter.key(key).per_second(data.get(key, 0)), 2) elif key in VALUE_KEYS: ret[key] = data[key] elif key in extra_keys: ret[key] = data[key] return ret if __name__ == '__main__': import sys import json # init plugin manager and collect plugins, as done by Zmon when worker is starting plugin_manager.init_plugin_manager() plugin_manager.collect_plugins(load_builtins=True, load_env=True) factory_ctx = { 'host': 'localhost', } counter = plugin_manager.get_plugin_obj_by_name('counter', 'Function').create(factory_ctx) wrapper = MemcachedWrapper(counter, sys.argv[1]) print json.dumps(wrapper.stats(), indent=4, sort_keys=True)
host = sys.argv[1] instance = sys.argv[2] factory_ctx = { 'base_url': 'http://{host}:3{instance}/'.format(host=host, instance=instance), 'host': host, 'port': ZomcatWrapper.get_jmx_port(instance), 'instance': instance, 'redis_host': 'localhost', } # http = partial(HttpWrapper, base_url='http://{host}:3{instance}/'.format(host=host, instance=instance)) http = plugin_manager.get_plugin_obj_by_name( 'http', 'Function').create(factory_ctx) # jmx = partial(JmxWrapper, host=host, port=ZomcatWrapper.get_jmx_port(instance)) jmx = plugin_manager.get_plugin_obj_by_name('jmx', 'Function').create(factory_ctx) # counter = partial(CounterWrapper, redis_host='localhost') counter = plugin_manager.get_plugin_obj_by_name( 'counter', 'Function').create(factory_ctx) zomcat = ZomcatWrapper(host, instance, http=http, jmx=jmx, counter=counter) print json.dumps(zomcat.health(), indent=4, sort_keys=True)