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)

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
            )