def METHOD_NAME(self) -> None:
    with ThreadPoolExecutor(
        thread_name_prefix=f"gcp_{self.project.id}", max_workers=self.config.project_pool_size
    ) as executor:
        # The shared executor is used to parallelize the collection of resources "as fast as possible"
        # It should only be used in scenarios, where it is safe to do so.
        # This executor is shared between all regions.
        shared_queue = ExecutorQueue(executor, self.project.safe_name)
        project_global_region = GcpRegion.fallback_global_region(self.project)
        global_builder = GraphBuilder(
            self.graph,
            self.cloud,
            self.project,
            self.credentials,
            shared_queue,
            self.core_feedback,
            project_global_region,
        )
        global_builder.add_node(project_global_region, {})
        # fetch available regions and zones
        log.info(f"[Gcp:{self.project.id}] Collecting project wide resources.")
        GcpRegion.collect_resources(global_builder)
        global_builder.prepare_region_zone_lookup()
        GcpZone.collect_resources(global_builder)
        global_builder.prepare_region_zone_lookup()
        # fetch all project level resources
        for resource_class in all_resources:
            if not self.config.should_collect(resource_class.kind):
                continue
            if resource_class.api_spec and resource_class.api_spec.is_project_level:
                global_builder.submit_work(resource_class.collect_resources, global_builder)
        # fetch all region level resources
        for region in global_builder.resources_of(GcpRegion):
            if region.name == "global":
                continue
            global_builder.submit_work(self.collect_region, region, global_builder.for_region(region))
        global_builder.executor.wait_for_submitted_work()
        # connect nodes
        for node, data in list(self.graph.nodes(data=True)):
            if isinstance(node, GcpResource):
                node.connect_in_graph(global_builder, data.get("source", {}))
        # remove unconnected nodes
        self.remove_unconnected_nodes()
        # post process nodes
        for node, data in list(self.graph.nodes(data=True)):
            if isinstance(node, GcpResource):
                node.post_process_instance(global_builder, data.get("source", {}))
        log.info(f"[GCP:{self.project.id}] Collecting resources done.")