docs: def get_stats(
          self,
          instance,
          base_url,
          object_type,
          max_detailed,
          filters,
          limit_vhosts,
          custom_tags,
          auth=None,
          ssl_verify=True,
      ):
          """
          instance: the check instance
          base_url: the url of the rabbitmq management api (e.g. http://localhost:15672/api)
          object_type: either QUEUE_TYPE or NODE_TYPE or EXCHANGE_TYPE
          max_detailed: the limit of objects to collect for this type
          filters: explicit or regexes filters of specified queues or nodes (specified in the yaml file)
          """
          instance_proxy = self.get_instance_proxy(instance, base_url)
          # Make a copy of this list as we will remove items from it at each
          # iteration
          explicit_filters = list(filters['explicit'])
          regex_filters = filters['regexes']
  
          data = []
  
          # only do this if vhosts were specified,
          # otherwise it'll just be making more queries for the same data
          if self._limit_vhosts(instance) and object_type == QUEUE_TYPE:
              for vhost in limit_vhosts:
                  url = '{}/{}'.format(object_type, quote_plus(vhost))
                  try:
                      data += self._get_data(
                          urljoin(base_url, url), auth=auth, ssl_verify=ssl_verify, proxies=instance_proxy
                      )
                  except Exception as e:
                      self.log.debug("Couldn't grab queue data from vhost, {}: {}".format(vhost, e))
          else:
              data = self._get_data(
                  urljoin(base_url, object_type), auth=auth, ssl_verify=ssl_verify, proxies=instance_proxy
              )
  
          """ data is a list of nodes or queues:
          data = [
              {
                  'status': 'running',
                  'node': 'rabbit@host',
                  'name': 'queue1',
                  'consumers': 0,
                  'vhost': '/',
                  'backing_queue_status': {
                      'q1': 0,
                      'q3': 0,
                      'q2': 0,
                      'q4': 0,
                      'avg_ack_egress_rate': 0.0,
                      'ram_msg_count': 0,
                      'ram_ack_count': 0,
                      'len': 0,
                      'persistent_count': 0,
                      'target_ram_count': 'infinity',
                      'next_seq_id': 0,
                      'delta': ['delta', 'undefined', 0, 'undefined'],
                      'pending_acks': 0,
                      'avg_ack_ingress_rate': 0.0,
                      'avg_egress_rate': 0.0,
                      'avg_ingress_rate': 0.0
                  },
                  'durable': True,
                  'idle_since': '2013-10-03 13:38:18',
                  'exclusive_consumer_tag': '',
                  'arguments': {},
                  'memory': 10956,
                  'policy': '',
                  'auto_delete': False
              },
              {
                  'status': 'running',
                  'node': 'rabbit@host,
                  'name': 'queue10',
                  'consumers': 0,
                  'vhost': '/',
                  'backing_queue_status': {
                      'q1': 0,
                      'q3': 0,
                      'q2': 0,
                      'q4': 0,
                      'avg_ack_egress_rate': 0.0,
                      'ram_msg_count': 0,
                      'ram_ack_count': 0,
                      'len': 0,
                      'persistent_count': 0,
                      'target_ram_count': 'infinity',
                      'next_seq_id': 0,
                      'delta': ['delta', 'undefined', 0, 'undefined'],
                      'pending_acks': 0,
                      'avg_ack_ingress_rate': 0.0,
                      'avg_egress_rate': 0.0, 'avg_ingress_rate': 0.0
                  },
                  'durable': True,
                  'idle_since': '2013-10-03 13:38:18',
                  'exclusive_consumer_tag': '',
                  'arguments': {},
                  'memory': 10956,
                  'policy': '',
                  'auto_delete': False
              },
              {
                  'status': 'running',
                  'node': 'rabbit@host',
                  'name': 'queue11',
                  'consumers': 0,
                  'vhost': '/',
                  'backing_queue_status': {
                      'q1': 0,
                      'q3': 0,
                      'q2': 0,
                      'q4': 0,
                      'avg_ack_egress_rate': 0.0,
                      'ram_msg_count': 0,
                      'ram_ack_count': 0,
                      'len': 0,
                      'persistent_count': 0,
                      'target_ram_count': 'infinity',
                      'next_seq_id': 0,
                      'delta': ['delta', 'undefined', 0, 'undefined'],
                      'pending_acks': 0,
                      'avg_ack_ingress_rate': 0.0,
                      'avg_egress_rate': 0.0,
                      'avg_ingress_rate': 0.0
                  },
                  'durable': True,
                  'idle_since': '2013-10-03 13:38:18',
                  'exclusive_consumer_tag': '',
                  'arguments': {},
                  'memory': 10956,
                  'policy': '',
                  'auto_delete': False
              },
              ...
          ]
          """
          if len(explicit_filters) > max_detailed:
              raise Exception("The maximum number of {} you can specify is {}.".format(object_type, max_detailed))
  
          # a list of queues/nodes is specified. We process only those
          data = self._filter_list(
              data, explicit_filters, regex_filters, object_type, instance.get("tag_families", False)
          )
  
          # if no filters are specified, check everything according to the limits
          if len(data) > ALERT_THRESHOLD * max_detailed:
              # Post a message on the dogweb stream to warn
              self.alert(base_url, max_detailed, len(data), object_type, custom_tags)
  
          if len(data) > max_detailed:
              # Display a warning in the info page
              msg = (
                  "Too many items to fetch. "
                  "You must choose the {} you are interested in by editing the rabbitmq.yaml configuration file"
                  "or get in touch with Datadog support"
              ).format(object_type)
              self.warning(msg)
  
          for data_line in data[:max_detailed]:
              # We truncate the list if it's above the limit
              self._get_metrics(data_line, object_type, custom_tags)
  
          # get a list of the number of bindings on a given queue
          # /api/queues/vhost/name/bindings
          if object_type is QUEUE_TYPE:
              self._get_queue_bindings_metrics(
                  base_url, custom_tags, data, instance_proxy, instance, object_type, auth, ssl_verify
              )