def __init__(self, config, label, items): """Initialize a method wrapped with metric collection. :param config: The global configuration. :param label: The label to use to identify the notifier. :param items: A list of key, value pairs giving the configuration for setting up the notifier. """ self.config = config self.default = False self._driver = None self._driver_cache = None self.additional = {} self.label = label.partition(':')[-1] if not self.label: # No label makes this the default self.default = True # Process configuration for option, value in items: if option == 'driver': self._driver = utils.import_class_or_module(value) # Other options go into additional else: self.additional[option] = value # Default driver to the print notifier if not self._driver: self._driver = notifiers.PrintNotifier
def metric(self): """Return an initialized statistic object.""" if not self._metric_cache: # Select an appropriate statistic cls = utils.import_class_or_module(self._metric) self._metric_cache = cls(self.additional) return self._metric_cache
def __init__(self, config): """Initialize the notifier from the configuration.""" # First, figure out the real notifier self.driver_name = config['real_driver'] # Get the class and instantiate it cls = utils.import_class_or_module(self.driver_name) self.driver = cls(config)
def __init__(self, config): """Initialize the metric from the configuration.""" # First, figure out the real metric self.metric_name = config['real_metric'] # Get the class and instantiate it cls = utils.import_class_or_module(self.metric_name) self.metric = cls(config) self.vtype = self.metric.vtype
def app(self): """Return the application transformer.""" # Don't crash if we don't have an app set if not self._app or not self._app_helper: return None if not self._app_cache: app_cls = utils.import_class_or_module(self._app_helper) self._app_cache = getattr(app_cls, self._app) return self._app_cache
def __init__(self, config): """Initialize the metric from the configuration.""" super(DebugMetric, self).__init__(config) # First, figure out the real metric self.metric_name = config['real_metric'] # Get the class and instantiate it cls = utils.import_class_or_module(self.metric_name) self.metric = cls(config) self.vtype = self.metric.vtype
def __init__(self, config, label, items, **kwargs): """Initialize a method wrapped with metric collection. :param config: The global configuration; needed for the notifier. :param label: The label to use when reporting the collected statistic. :param items: A list of key, value pairs giving the configuration for setting up the method wrapper. """ self.config = config self.label = label self._app_cache = None self._metric_cache = None self._app_helper = kwargs.get('app_helper') # Other important configuration values required = set(['module', 'method', 'metric']) attrs = set(['notifier', 'app']) | required for attr in attrs: setattr(self, '_' + attr, None) self.additional = {} # Process configuration for option, value in items: if option in attrs: setattr(self, '_' + option, value) required.discard(option) else: self.additional[option] = value # Add app to required if necessary if option == 'app' and not self._app_helper: required.add('app_helper') # Make sure we got the essential configuration if required: raise Exception("Missing configuration options for %s: %s" % (label, ', '.join(required))) # Grab the method we're operating on method_cls = utils.import_class_or_module(self._module) if inspect.ismodule(method_cls): method = raw_method = getattr(method_cls, self._method) kind = 'function' else: method, raw_method, kind = _get_method(method_cls, self._method) self._method_cache = method # We need to wrap the replacement if its a static or class # method if kind == 'static method': meth_wrap = staticmethod elif kind == 'class method': meth_wrap = classmethod else: meth_wrap = lambda f: f # Wrap the method to perform statistics collection @functools.wraps(method) def wrapper(*args, **kwargs): # Deal with class method calling conventions if kind == 'class method': args = args[1:] # Handle app translation label = None if self._app: args, kwargs, label = self.app(*args, **kwargs) # Run the method, bracketing with statistics collection # and notification value = self.metric.start() result = method(*args, **kwargs) self.notifier(self.metric(value), self.metric.vtype, label or self.label) return result # Save some introspecting data wrapper.tach_descriptor = self wrapper.tach_function = method # Save what we need self._method_cls = method_cls self._method_wrapper = meth_wrap(wrapper) self._method_orig = raw_method setattr(self._method_cls, self._method, self._method_wrapper)
def __init__(self, config, label, items, **kwargs): """Initialize a method wrapped with metric collection. :param config: The global configuration; needed for the notifier. :param label: The label to use when reporting the collected statistic. :param items: A list of key, value pairs giving the configuration for setting up the method wrapper. """ self.config = config self.label = label self._app_cache = None self._post_app_cache = None self._metric_cache = None self._app_helper = kwargs.get('app_helper') # Other important configuration values required = set(['module', 'method', 'metric']) attrs = set(['notifier', 'app', 'post_app']) | required # if there's a global helper set, we don't require a local one if not self._app_helper: attrs.add('app_helper') for attr in attrs: setattr(self, '_' + attr, None) self.additional = {} # Process configuration for option, value in items: if option in attrs: setattr(self, '_' + option, value) required.discard(option) else: self.additional[option] = value # Add app to required if necessary if option == 'app' and not self._app_helper: required.add('app_helper') # Make sure we got the essential configuration if required: raise Exception("Missing configuration options for %s: %s" % (label, ', '.join(required))) # Grab the method we're operating on method_cls = utils.import_class_or_module(self._module) if inspect.ismodule(method_cls): that_method = raw_method = getattr(method_cls, self._method) kind = 'function' else: that_method, raw_method, kind = _get_method( method_cls, self._method) self._method_cache = that_method # We need to wrap the replacement if it's a static or class # method if kind == 'static method': meth_wrap = staticmethod elif kind == 'class method': meth_wrap = classmethod else: meth_wrap = lambda f: f # Wrap the method to perform statistics collection @functools.wraps(that_method) def wrapper(*args, **kwargs): # Deal with class method calling conventions if kind == 'class method': args = args[1:] # Handle app translation label = None if self._app: args, kwargs, label = self.app(*args, **kwargs) # Run the method, bracketing with statistics collection # and notification if self.metric.bump_transaction_id: self.notifier.bump_transaction_id() value = self.metric.start() result = that_method(*args, **kwargs) if self._post_app: result, label = self.post_app(result, *args, **kwargs) self.notifier(self.metric(value), self.metric.vtype, label or self.label) return result # Save some introspecting data wrapper.tach_descriptor = self wrapper.tach_function = that_method # Save what we need self._method_cls = method_cls self._method_wrapper = meth_wrap(wrapper) self._method_orig = raw_method setattr(self._method_cls, self._method, self._method_wrapper)