docs: def _get_all_objs(
          self, server_instance, regexes=None, include_only_marked=False, tags=None, use_guest_hostname=False
      ):
          """
          Explore vCenter infrastructure to discover hosts, virtual machines, etc.
          and compute their associated tags.
          Start at the vCenter `rootFolder`, so as to collect every objet.
  
          Example topology:
              ```
              rootFolder
                  - datacenter1
                      - compute_resource1 == cluster
                          - host1
                          - host2
                          - host3
                      - compute_resource2
                          - host5
                              - vm1
                              - vm2
              ```
  
          If it's a node we want to query metric for, it will be enqueued at the
          instance level and will be processed by a subsequent job.
          """
          start = time.time()
          if tags is None:
              tags = []
          obj_list = defaultdict(list)
  
          # Collect objects and their attributes
          all_objects = self._collect_mors_and_attributes(server_instance)
  
          # Add rootFolder since it is not explored by the propertyCollector
          rootFolder = server_instance.content.rootFolder
          all_objects[rootFolder] = {"name": rootFolder.name, "parent": None}
  
          for obj, properties in all_objects.items():
              instance_tags = []
              if not self._is_excluded(obj, properties, regexes, include_only_marked) and any(
                  isinstance(obj, vimtype) for vimtype in RESOURCE_TYPE_METRICS
              ):
                  if use_guest_hostname:
                      hostname = properties.get("guest.hostName", properties.get("name", "unknown"))
                  else:
                      hostname = properties.get("name", "unknown")
                  if properties.get("parent"):
                      instance_tags += self._get_parent_tags(obj, all_objects)
  
                  if isinstance(obj, vim.VirtualMachine):
                      vsphere_type = 'vsphere_type:vm'
                      vimtype = vim.VirtualMachine
                      mor_type = "vm"
                      power_state = properties.get("runtime.powerState")
                      if power_state != vim.VirtualMachinePowerState.poweredOn:
                          self.log.debug("Skipping VM in state {}".format(ensure_unicode(power_state)))
                          continue
                      host_mor = properties.get("runtime.host")
                      host = "unknown"
                      if host_mor:
                          host = ensure_unicode(all_objects.get(host_mor, {}).get("name", "unknown"))
                      instance_tags.append('vsphere_host:{}'.format(ensure_unicode(host)))
                  elif isinstance(obj, vim.HostSystem):
                      vsphere_type = 'vsphere_type:host'
                      vimtype = vim.HostSystem
                      mor_type = "host"
                  elif isinstance(obj, vim.Datastore):
                      vsphere_type = 'vsphere_type:datastore'
                      instance_tags.append(
                          'vsphere_datastore:{}'.format(ensure_unicode(properties.get("name", "unknown")))
                      )
                      hostname = None
                      vimtype = vim.Datastore
                      mor_type = "datastore"
                  elif isinstance(obj, vim.Datacenter):
                      vsphere_type = 'vsphere_type:datacenter'
                      instance_tags.append(
                          "vsphere_datacenter:{}".format(ensure_unicode(properties.get("name", "unknown")))
                      )
                      hostname = None
                      vimtype = vim.Datacenter
                      mor_type = "datacenter"
                  elif isinstance(obj, vim.ClusterComputeResource):
                      vsphere_type = 'vsphere_type:cluster'
                      instance_tags.append("vsphere_cluster:{}".format(ensure_unicode(properties.get("name", "unknown"))))
                      hostname = None
                      vimtype = vim.ClusterComputeResource
                      mor_type = "cluster"
                  else:
                      vsphere_type = None
  
                  if vsphere_type:
                      instance_tags.append(vsphere_type)
  
                  obj_list[vimtype].append(
                      {"mor_type": mor_type, "mor": obj, "hostname": hostname, "tags": tags + instance_tags}
                  )
  
          self.log.debug("All objects with attributes cached in {} seconds.".format(time.time() - start))
          return obj_list