docs: def _get_and_count_containers(self, custom_cgroups=False, healthchecks=False):
          """List all the containers from the API, filter and count them."""
  
          # Querying the size of containers is slow, we don't do it at each run
          must_query_size = self.collect_container_size and self._latest_size_query == 0
          self._latest_size_query = (self._latest_size_query + 1) % SIZE_REFRESH_RATE
  
          running_containers_count = Counter()
          all_containers_count = Counter()
  
          try:
              containers = self.docker_util.client.containers(all=True, size=must_query_size)
          except Exception as e:
              message = "Unable to list Docker containers: {0}".format(e)
              self.service_check(SERVICE_CHECK_NAME, AgentCheck.CRITICAL,
                                 message=message, tags=self.custom_tags)
              raise Exception(message)
  
          else:
              self.service_check(SERVICE_CHECK_NAME, AgentCheck.OK, tags=self.custom_tags)
  
          # Create a set of filtered containers based on the exclude/include rules
          # and cache these rules in docker_util
          self._filter_containers(containers)
  
          containers_by_id = {}
  
          for container in containers:
              container_name = DockerUtil.container_name_extractor(container)[0]
  
              container_status_tags = self._get_tags(container, CONTAINER)
  
              all_containers_count[tuple(sorted(container_status_tags))] += 1
              if self._is_container_running(container):
                  running_containers_count[tuple(sorted(container_status_tags))] += 1
  
              # Check if the container is included/excluded via its tags
              if self._is_container_excluded(container):
                  self.log.debug("Container {0} is excluded".format(container_name))
                  continue
  
              containers_by_id[container['Id']] = container
  
              # grab pid via API if custom cgroups - otherwise we won't find process when
              # crawling for pids.
              if custom_cgroups or healthchecks:
                  try:
                      inspect_dict = self.docker_util.client.inspect_container(container_name)
                      container['_pid'] = inspect_dict['State']['Pid']
                      container['health'] = inspect_dict['State'].get('Health', {})
                  except Exception as e:
                      self.log.debug("Unable to inspect Docker container: %s", e)
  
          total_count = 0
          # TODO: deprecate these 2, they should be replaced by _report_container_count
          for tags, count in running_containers_count.iteritems():
              total_count += count
              self.gauge("docker.containers.running", count, tags=list(tags))
          self.gauge("docker.containers.running.total", total_count, tags=self.custom_tags)
  
          total_count = 0
          for tags, count in all_containers_count.iteritems():
              stopped_count = count - running_containers_count[tags]
              total_count += stopped_count
              self.gauge("docker.containers.stopped", stopped_count, tags=list(tags))
          self.gauge("docker.containers.stopped.total", total_count, tags=self.custom_tags)
  
          return containers_by_id