docs: def _track(metric_type, metric_call, metric_kwargs, name, description, labels,
                 registry, before=None):
          """
          Internal method decorator logic.
  
          :param metric_type: the type of the metric from the `prometheus_client` library
          :param metric_call: the invocation to execute as a callable with `(metric, time)`
          :param metric_kwargs: additional keyword arguments for creating the metric
          :param name: the name of the metric
          :param description: the description of the metric
          :param labels: a dictionary of `{labelname: callable_or_value}` for labels
          :param before: an optional callable to invoke before executing the
              request handler method accepting the single `metric` argument
          :param registry: the Prometheus Registry to use
          """
  
          if labels is not None and not isinstance(labels, dict):
              raise TypeError('labels needs to be a dictionary of {labelname: callable}')
  
          label_names = labels.keys() if labels else tuple()
          parent_metric = metric_type(
              name, description, labelnames=label_names, registry=registry,
              **metric_kwargs
          )
  
          def argspec(func):
              if hasattr(inspect, 'getfullargspec'):
                  return inspect.getfullargspec(func)
              else:
                  return inspect.getargspec(func)
  
          def label_value(f):
              if not callable(f):
                  return lambda x: f
              if argspec(f).args:
                  return lambda x: f(x)
              else:
                  return lambda x: f()
  
          label_generator = tuple(
              (key, label_value(call))
              for key, call in labels.items()
          ) if labels else tuple()
  
          def get_metric(response):
              if label_names:
                  return parent_metric.labels(
                      **{key: call(response) for key, call in label_generator}
                  )
              else:
                  return parent_metric
  
          def decorator(f):
              @functools.wraps(f)
              def func(*args, **kwargs):
                  if before:
                      metric = get_metric(None)
                      before(metric)
  
                  else:
                      metric = None
  
                  start_time = default_timer()
                  try:
                      response = f(*args, **kwargs)
                  except HTTPException as ex:
                      response = ex
                  except Exception as ex:
                      response = make_response('Exception: %s' % ex, 500)
  
                  total_time = max(default_timer() - start_time, 0)
  
                  if not metric:
                      response_for_metric = response
  
                      if not isinstance(response, Response):
                          if request.endpoint == f.__name__:
                              # we are in a request handler method
                              response_for_metric = make_response(response)
  
                      metric = get_metric(response_for_metric)
  
                  metric_call(metric, time=total_time)
                  return response
  
              return func
  
          return decorator