perf(tags): bulk-precompute Location target tag names per flush

`_location_target_names(location)` issued one
`Product.objects.filter(...).distinct()` per location plus N
`product.tags.all()` per related product, producing an N+1 across the
location queryset on every product tag toggle.

Replace the per-location callable with a precomputed
{location_id: set[tag_name]} map built in 3 bulk queries: the two
LocationProductReference / LocationFindingReference paths union together
into {location_id: {product_id}}, then a single Product_tags
through-table read fans out to {product_id: {tag_name}}.

product_tag_add (100 locations, V3): 320 -> 123 queries
product_tag_remove (100 locations, V3): 270 -> 73 queries
ZAP scan import (V3): 984 -> 947
ZAP scan reimport, no change (V3): 140 -> 103

Author: valentijnscholten

dojo/product/helpers.py

@@ -6,7 +6,7 @@
 from django.db.models import Q
 
 from dojo.celery import app
-from dojo.location.models import Location
+from dojo.location.models import Location, LocationFindingReference, LocationProductReference
 from dojo.models import Endpoint, Engagement, Finding, Product, Test
 from dojo.tag_utils import bulk_add_tag_mapping, bulk_remove_tags_from_instances
 
@@ -50,15 +50,19 @@ def propagate_tags_on_product_sync(product):
     )
     if settings.V3_FEATURE_LOCATIONS:
         logger.debug("Propagating tags from %s to all locations", product)
-        location_qs = Location.objects.filter(
+        # Materialize once so we can build a precomputed
+        # {location_id: set[tag_name]} map without re-evaluating the queryset
+        # or paying N+1 in `_location_target_names`.
+        locations = list(Location.objects.filter(
             Q(products__product=product)
             | Q(findings__finding__test__engagement__product=product),
-        ).distinct()
-        # Locations can be linked to multiple products, so the inherited target
-        # is the union of every related product's tags. Compute per-location.
+        ).distinct())
+        location_target_names = _build_location_target_names_map(
+            [loc.pk for loc in locations],
+        )
         _sync_inheritance_for_qs(
-            location_qs,
-            target_names_per_child=_location_target_names,
+            locations,
+            target_names_per_child=lambda loc: location_target_names.get(loc.pk, set()),
         )
     else:
         logger.debug("Propagating tags from %s to all endpoints", product)
@@ -68,13 +72,49 @@ def propagate_tags_on_product_sync(product):
         )
 
 
-def _location_target_names(location):
-    names: set[str] = set()
-    for related_product in location.all_related_products():
-        if related_product is None:
-            continue
-        names.update(tag.name for tag in related_product.tags.all())
-    return names
+def _build_location_target_names_map(location_ids):
+    """
+    Bulk-compute {location_id: set[tag_name]} for the given locations.
+
+    Replaces the per-location `_location_target_names` callable, which issued
+    one `Product.objects.filter(...).distinct()` query plus N `.tags.all()`
+    queries per location. Now: 3 queries total regardless of fan-out.
+    """
+    if not location_ids:
+        return {}
+
+    location_to_products: dict[int, set[int]] = defaultdict(set)
+    for loc_id, prod_id in LocationProductReference.objects.filter(
+        location_id__in=location_ids,
+    ).values_list("location_id", "product_id"):
+        location_to_products[loc_id].add(prod_id)
+    for loc_id, prod_id in LocationFindingReference.objects.filter(
+        location_id__in=location_ids,
+    ).values_list("location_id", "finding__test__engagement__product_id"):
+        if prod_id is not None:
+            location_to_products[loc_id].add(prod_id)
+
+    all_product_ids = {pid for pids in location_to_products.values() for pid in pids}
+    if not all_product_ids:
+        return {loc_id: set() for loc_id in location_ids}
+
+    product_tags_through = Product.tags.through
+    tag_model = Product.tags.tag_model
+    tag_field_name = tag_model._meta.model_name
+    product_to_tag_names: dict[int, set[str]] = defaultdict(set)
+    for prod_id, tag_name in product_tags_through.objects.filter(
+        product_id__in=all_product_ids,
+    ).values_list("product_id", f"{tag_field_name}__name"):
+        product_to_tag_names[prod_id].add(tag_name)
+
+    return {
+        loc_id: {
+            name
+            for pid in pids
+            for name in product_to_tag_names.get(pid, set())
+        }
+        for loc_id, pids in location_to_products.items()
+    }
 
 
 def _sync_inheritance_for_qs(queryset, *, target_names_per_child):

unittests/test_tag_inheritance_perf.py

@@ -387,8 +387,9 @@ def test_baseline_product_tag_remove_propagates_to_100_locations_v3(self):
     EXPECTED_PRODUCT_TAG_REMOVE_100_ENDPOINTS = 56
 
     # V3 location paths. Pre-Phase-A: 4532 add, 4307 remove.
-    EXPECTED_PRODUCT_TAG_ADD_100_LOCATIONS = 320
-    EXPECTED_PRODUCT_TAG_REMOVE_100_LOCATIONS = 270
+    # Phase B Stage 2 + location precompute: bulk-built target-name map.
+    EXPECTED_PRODUCT_TAG_ADD_100_LOCATIONS = 123
+    EXPECTED_PRODUCT_TAG_REMOVE_100_LOCATIONS = 73
 
 
 @override_settings(
@@ -510,6 +511,6 @@ def test_baseline_zap_scan_reimport_no_change_v3(self):
     # when there's no work. Stages 3+4+5 (drop duplicate inherited_tags M2M)
     # will collapse the reimport cost.
     EXPECTED_ZAP_IMPORT_V2 = 1006
-    EXPECTED_ZAP_IMPORT_V3 = 984
+    EXPECTED_ZAP_IMPORT_V3 = 947
     EXPECTED_ZAP_REIMPORT_NO_CHANGE_V2 = 82
-    EXPECTED_ZAP_REIMPORT_NO_CHANGE_V3 = 140
+    EXPECTED_ZAP_REIMPORT_NO_CHANGE_V3 = 103