:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
feat(access-control): batch permission reads and writes (#123650)
Arthur Moreira de Deus9afcfe59cb29
diff --git a/docs/internal/activity-logging.md b/docs/internal/activity-logging.mdindex e5c27eaeb239..adc0c38c0549 100644--- a/docs/internal/activity-logging.md+++ b/docs/internal/activity-logging.md@@ -318,6 +318,7 @@ Test the behavior the receiver adds, through a public interface, at the cheapest- One test that a write through the API or the facade creates a row with the expected `activity` and `changes`.- One test per bulk-write site that its explicit logging produces the expected rows.+- Batch object access-rule writes preserve the same changes and actor details as individual writes through `bulk_log_activity`.- A `changes_between` test only when the scope adds exclusions or masks.- For a separate-database product, one test that a rolled-back product write leaves no row (`override_settings(ACTIVITY_LOG_TRANSACTION_MANAGEMENT=True)` plus `captureOnCommitCallbacks(using=<writer alias>, execute=True)`).diff --git a/posthog/models/file_system/signal_handlers.py b/posthog/models/file_system/signal_handlers.pyindex aa13bd366895..d6fd04411155 100644--- a/posthog/models/file_system/signal_handlers.py+++ b/posthog/models/file_system/signal_handlers.py@@ -9,7 +9,7 @@ from posthog.models.file_system.starred_products import star_default_products@receiver(post_save, sender="ee.AccessControl")def access_control_created(sender, instance, created, **kwargs):"""Star the default products for a user who is granted access to a project."""- if created and instance.organization_member and instance.resource == "project":+ if created and instance.resource == "project" and instance.organization_member:user = instance.organization_member.userteam = instance.teamdiff --git a/posthog/models/test/test_default_starred_products.py b/posthog/models/test/test_default_starred_products.pyindex e970c4792324..a50fb05ad58c 100644--- a/posthog/models/test/test_default_starred_products.py+++ b/posthog/models/test/test_default_starred_products.py@@ -1,6 +1,11 @@+from uuid import uuid4+from posthog.test.base import BaseTestfrom unittest.mock import patch+from django.db.models.signals import post_save+from django.test import SimpleTestCase+from parameterized import parameterizedfrom posthog.constants import AvailableFeature@@ -18,6 +23,20 @@ from posthog.products import Productsfrom products.access_control.backend.models.access_control import AccessControl+class TestDefaultStarredProductsAccessControlSignals(SimpleTestCase):+ @parameterized.expand([("dashboard",), ("customer_task",)])+ def test_object_access_grant_does_not_query_membership(self, resource: str) -> None:+ rule = AccessControl(+ team_id=1,+ resource=resource,+ resource_id=str(uuid4()),+ organization_member_id=uuid4(),+ access_level="editor",+ )++ post_save.send(sender=AccessControl, instance=rule, created=True)++class TestDefaultStarredProducts(BaseTest):def _default_paths_for(self, user: User, team: Team) -> set[str]:return set(FileSystemShortcut.objects.filter(user=user, team=team).values_list("path", flat=True))diff --git a/products/access_control/backend/activity_logging.py b/products/access_control/backend/activity_logging.pyindex 14d50c446edc..c01c40e4f405 100644--- a/products/access_control/backend/activity_logging.py+++ b/products/access_control/backend/activity_logging.py@@ -12,6 +12,7 @@ from posthog.models.activity_logging.activity_log import (ActivityContextBase,Change,Detail,+ LogActivityEntry,changes_between,log_activity,)@@ -29,20 +30,17 @@ class AccessControlContext(ActivityContextBase):organization_member_id: str | None-@mutable_receiver(model_activity_signal, sender=AccessControl)-def handle_access_control_change(- sender: type,- scope: str,+def get_access_control_log_entry(+ *,before_update: Optional[AccessControl],after_update: Optional[AccessControl],activity: str,user: Optional[User],was_impersonated: bool = False,- **kwargs: Any,-) -> None:+) -> LogActivityEntry | None:rule = after_update or before_updateif rule is None:- return+ return Noneif activity == "created":changes = [Change(type="AccessControl", field="access_level", action="created", after=rule.access_level)]@@ -51,13 +49,13 @@ def handle_access_control_change(else:changes = changes_between("AccessControl", previous=before_update, current=after_update)- log_activity(+ return LogActivityEntry(organization_id=rule.team.organization_id,team_id=rule.team_id,user=user,was_impersonated=was_impersonated,item_id=rule.id,- scope=scope,+ scope="AccessControl",activity=activity,detail=Detail(name=f"{rule.resource} {rule.resource_id}" if rule.resource_id else rule.resource,@@ -72,3 +70,25 @@ def handle_access_control_change(),),)+++@mutable_receiver(model_activity_signal, sender=AccessControl)+def handle_access_control_change(+ sender: type,+ scope: str,+ before_update: Optional[AccessControl],+ after_update: Optional[AccessControl],+ activity: str,+ user: Optional[User],+ was_impersonated: bool = False,+ **kwargs: Any,+) -> None:+ entry = get_access_control_log_entry(+ before_update=before_update,+ after_update=after_update,+ activity=activity,+ user=user,+ was_impersonated=was_impersonated,+ )+ if entry is not None:+ log_activity(**entry)diff --git a/products/access_control/backend/facade/api.py b/products/access_control/backend/facade/api.pyindex c5a23d347abb..29a98cb1e01b 100644--- a/products/access_control/backend/facade/api.py+++ b/products/access_control/backend/facade/api.py@@ -18,10 +18,14 @@ Do NOT:from __future__ import annotations+from collections import defaultdict+from copy import copyfrom typing import castfrom uuid import UUIDfrom django.db import transaction+from django.db.models import Q+from django.db.models.signals import post_savefrom django.http import Http404from django.shortcuts import get_object_or_404from django.utils import timezone@@ -29,11 +33,15 @@ from django.utils import timezonefrom posthog.hogql.property_access_types import RestrictedPropertyfrom posthog.constants import AvailableFeature+from posthog.dataclasses import frozenfrom posthog.models import Organization, OrganizationMembership, PropertyDefinition, Team+from posthog.models.activity_logging.activity_log import LogActivityEntry, bulk_log_activity+from posthog.models.activity_logging.model_activity import get_current_user, get_was_impersonatedfrom posthog.models.team.extensions import get_or_create_team_extensionfrom posthog.models.user import Userfrom posthog.scopes import API_SCOPE_OBJECTS, INTERNAL_API_SCOPE_OBJECTS, APIScopeObject+from products.access_control.backend.activity_logging import get_access_control_log_entryfrom products.access_control.backend.models.role import Role, RoleMembershipfrom products.event_definitions.backend.models import effective_project_id_expr@@ -562,9 +570,7 @@ def _to_object_rule(rule: AccessControl) -> contracts.ObjectAccessControlRule:)-def _validate_object_access_control(- *, organization_id: UUID, input: contracts.SetObjectAccessControlInput-) -> APIScopeObject:+def _validate_object_access_control_level(input: contracts.SetObjectAccessControlInput) -> APIScopeObject:resource = input.resourceif resource not in API_SCOPE_OBJECTS or resource in INTERNAL_API_SCOPE_OBJECTS:raise InvalidObjectAccessControlError(f"{resource} is not an access controlled resource.")@@ -584,6 +590,13 @@ def _validate_object_access_control(if level_index > levels.index(highest_access_level(scoped_resource)):raise InvalidObjectAccessControlError(f"Access level is above the maximum for {resource}.")+ return scoped_resource+++def _validate_object_access_control(+ *, organization_id: UUID, input: contracts.SetObjectAccessControlInput+) -> APIScopeObject:+ resource = _validate_object_access_control_level(input)if (input.organization_member_id is not Noneand not OrganizationMembership.objects.filter(@@ -596,7 +609,118 @@ def _validate_object_access_control(and not Role.objects.filter(id=input.role_id, organization_id=organization_id).exists()):raise InvalidObjectAccessControlError("role does not belong to this team's organization.")- return scoped_resource+ return resource+++@frozen+class _ObjectAccessControlKey:+ resource: str+ resource_id: str | None+ organization_member_id: UUID | None+ role_id: UUID | None+++def _object_access_control_key(+ rule: contracts.SetObjectAccessControlInput | AccessControl,+) -> _ObjectAccessControlKey:+ return _ObjectAccessControlKey(+ resource=rule.resource,+ resource_id=rule.resource_id,+ organization_member_id=rule.organization_member_id,+ role_id=rule.role_id,+ )+++def bulk_set_object_access_controls(*, team_id: int, inputs: list[contracts.SetObjectAccessControlInput]) -> None:+ if not inputs:+ return+ team = Team.objects.only("id", "organization_id").get(id=team_id)+ requested = {_object_access_control_key(input): input for input in inputs}+ if len(requested) != len(inputs):+ raise InvalidObjectAccessControlError("Provide each object and subject only once.")+ for input in inputs:+ _validate_object_access_control_level(input)+ member_ids = {input.organization_member_id for input in inputs if input.organization_member_id is not None}+ role_ids = {input.role_id for input in inputs if input.role_id is not None}+ if member_ids != set(+ OrganizationMembership.objects.filter(organization_id=team.organization_id, id__in=member_ids).values_list(+ "id", flat=True+ )+ ):+ raise InvalidObjectAccessControlError("organization_member does not belong to this team's organization.")+ if role_ids != set(+ Role.objects.filter(organization_id=team.organization_id, id__in=role_ids).values_list("id", flat=True)+ ):+ raise InvalidObjectAccessControlError("role does not belong to this team's organization.")++ requested_pairs = Q()+ for key in requested:+ requested_pairs |= Q(+ resource=key.resource,+ resource_id=key.resource_id,+ organization_member_id=key.organization_member_id,+ role_id=key.role_id,+ )+ with transaction.atomic():+ existing: dict[_ObjectAccessControlKey, list[AccessControl]] = defaultdict(list)+ for existing_rule in (+ AccessControl.objects.select_for_update().filter(requested_pairs, team_id=team_id).order_by("id")+ ):+ existing[_object_access_control_key(existing_rule)].append(existing_rule)+ created: list[AccessControl] = []+ updated: list[AccessControl] = []+ deleted_ids: list[UUID] = []+ entries: list[LogActivityEntry] = []+ now = timezone.now()+ for key, input in requested.items():+ matching_rules: list[AccessControl | None] = [*existing.get(key, [])] or [None]+ for rule in matching_rules:+ before = copy(rule) if rule is not None else None+ if before is not None:+ before.team = team+ if input.access_level is None:+ if rule is None:+ continue+ deleted_ids.append(rule.id)+ activity = "deleted"+ rule = None+ elif rule is None:+ rule = AccessControl(+ team=team,+ resource=input.resource,+ resource_id=input.resource_id,+ organization_member_id=input.organization_member_id,+ role_id=input.role_id,+ access_level=input.access_level,+ created_by_id=input.created_by_id,+ )+ created.append(rule)+ activity = "created"+ else:+ if rule.access_level == input.access_level:+ continue+ rule.team = team+ rule.access_level = input.access_level+ rule.updated_at = now+ updated.append(rule)+ activity = "updated"+ entry = get_access_control_log_entry(+ before_update=before,+ after_update=rule,+ activity=activity,+ user=get_current_user(),+ was_impersonated=get_was_impersonated(),+ )+ if entry is not None:+ entries.append(entry)+ AccessControl.objects.bulk_create(created)+ AccessControl.objects.bulk_update(updated, ["access_level", "updated_at"])+ AccessControl.objects.filter(team_id=team_id, id__in=deleted_ids).delete()+ for rule in created:+ post_save.send(sender=AccessControl, instance=rule, created=True)+ for rule in updated:+ post_save.send(sender=AccessControl, instance=rule, created=False)+ bulk_log_activity(entries)def set_object_access_control(diff --git a/products/access_control/backend/facade/user_access_control.py b/products/access_control/backend/facade/user_access_control.pyindex ac1c43779f1e..f43a14d29ad9 100644--- a/products/access_control/backend/facade/user_access_control.py+++ b/products/access_control/backend/facade/user_access_control.py@@ -5,6 +5,7 @@ from dataclasses import replacefrom enum import Enumfrom functools import cache, cached_propertyfrom typing import TYPE_CHECKING, Any, Literal, Optional, cast, get_args+from uuid import UUIDfrom django.db.models import Case, CharField, Exists, F, ForeignKey, Model, OuterRef, Q, QuerySet, Value, Whenfrom django.db.models.functions import Cast@@ -32,6 +33,7 @@ else:from products.access_control.backend.models.access_control import AccessControl+from products.access_control.backend.models.role import RoleMembershipfrom .contracts import ObjectAccessReffrom .enums import ResolvedAccessSourceSubjectValue, ResolvedAccessSourceValue@@ -453,6 +455,60 @@ class UserAccessControl:self._organization_id = organization_id+ @classmethod+ def for_user_ids(cls, *, user_ids: Iterable[int], team: Team) -> dict[int, "UserAccessControl"]:+ memberships = list(+ OrganizationMembership.objects.filter(+ organization_id=team.organization_id, user_id__in=set(user_ids)+ ).select_related("user", "organization")+ )+ if not memberships:+ return {}++ roles_by_user: dict[int, list[UUID]] = defaultdict(list)+ if memberships[0].organization.is_feature_available(AvailableFeature.ROLE_BASED_ACCESS):+ for user_id, role_id in (+ RoleMembership.objects.filter(+ user_id__in=[member.user_id for member in memberships], role__organization_id=team.organization_id+ )+ .valid_for_authorization()+ .values_list("user_id", "role_id")+ ):+ roles_by_user[user_id].append(role_id)++ default_rules: list[AccessControl] = []+ rules_by_member: dict[UUID, list[AccessControl]] = defaultdict(list)+ rules_by_role: dict[UUID, list[AccessControl]] = defaultdict(list)+ if EE_AVAILABLE and memberships[0].organization.is_feature_available(AvailableFeature.ACCESS_CONTROL):+ for rule in AccessControl.objects.filter(team_id=team.id).filter(+ Q(organization_member__isnull=True, role__isnull=True)+ | Q(organization_member_id__in=[member.id for member in memberships], role__isnull=True)+ | Q(+ organization_member__isnull=True,+ role_id__in={role_id for roles in roles_by_user.values() for role_id in roles},+ )+ ):+ if rule.organization_member_id is not None:+ rules_by_member[rule.organization_member_id].append(rule)+ elif rule.role_id is not None:+ rules_by_role[rule.role_id].append(rule)+ else:+ default_rules.append(rule)++ access_by_user: dict[int, UserAccessControl] = {}+ for member in memberships:+ access = cls(user=member.user, team=team)+ role_ids = roles_by_user[member.user_id]+ access.__dict__["_organization_membership"] = member+ access.__dict__["_user_role_ids"] = role_ids+ access.__dict__["_cached_access_controls"] = [+ *default_rules,+ *rules_by_member.get(member.id, []),+ *(rule for role_id in role_ids for rule in rules_by_role.get(role_id, [])),+ ]+ access_by_user[member.user_id] = access+ return access_by_user+def allowed_object_ids(self, resource: str, team_id: int, required_level: str, resolve: Callable[[], frozenset]) -> frozenset:diff --git a/products/access_control/backend/tests/test_api.py b/products/access_control/backend/tests/test_api.pyindex 7b8009a0e1f8..c9904bb3a828 100644--- a/products/access_control/backend/tests/test_api.py+++ b/products/access_control/backend/tests/test_api.py@@ -1,6 +1,9 @@import pytestfrom posthog.test.base import BaseTest+from django.db import connection+from django.test.utils import CaptureQueriesContext+from parameterized import parameterizedfrom posthog.constants import AvailableFeature@@ -11,6 +14,7 @@ from posthog.models.organization import Organization, OrganizationMembershipfrom products.access_control.backend.facade import contractsfrom products.access_control.backend.facade.api import (InvalidObjectAccessControlError,+ bulk_set_object_access_controls,every_member_has_resource_access,object_ids_restricted_from_any_member,role_belongs_to_organization,@@ -111,6 +115,136 @@ class TestSetObjectAccessControl(BaseTest):with pytest.raises(ValueError):self._grant("viewer", role_id=role.id)+ @parameterized.expand([("member", False), ("role", False), ("member", True), ("role", True)])+ def test_bulk_rules_preserve_access_and_audit(self, subject: str, duplicates: bool) -> None:+ role = Role.objects.create(name="Support", organization=self.organization)+ RoleMembership.objects.create(user=self.other_user, role=role)+ if duplicates:+ AccessControl.objects.bulk_create(+ [+ AccessControl(+ team=self.team,+ resource="dashboard",+ resource_id=str(self.dashboard.id),+ access_level="viewer",+ organization_member_id=self.other_membership.id if subject == "member" else None,+ role_id=role.id if subject == "role" else None,+ )+ for _ in range(2)+ ]+ )+ for level in ("viewer", "editor", "editor", None, None):+ bulk_set_object_access_controls(+ team_id=self.team.id,+ inputs=[+ contracts.SetObjectAccessControlInput(+ resource="dashboard",+ resource_id=str(self.dashboard.id),+ access_level=level,+ created_by_id=self.user.id,+ organization_member_id=self.other_membership.id if subject == "member" else None,+ role_id=role.id if subject == "role" else None,+ )+ ],+ )+ assert self._other_user_level() == (level or "none")+ logs = list(+ ActivityLog.objects.filter(+ team_id=self.team.id, scope="AccessControl", detail__name=f"dashboard {self.dashboard.id}"+ ).order_by("created_at")+ )+ assert [log.activity for log in logs] == (+ ["updated", "updated", "deleted", "deleted"] if duplicates else ["created", "updated", "deleted"]+ )+ assert len({log.item_id for log in logs}) == (2 if duplicates else 1)+ detail = logs[0 if duplicates else 1].detail+ assert detail is not None+ assert detail["changes"] == [+ {+ "type": "AccessControl",+ "field": "access_level",+ "action": "changed",+ "before": "viewer",+ "after": "editor",+ }+ ]++ @parameterized.expand([("member",), ("role",)])+ def test_bulk_rules_lock_only_requested_object_subject_pairs(self, subject: str) -> None:+ other_dashboard = Dashboard.objects.create(team=self.team, created_by=self.user)+ roles = Role.objects.bulk_create([Role(name=f"Role {i}", organization=self.organization) for i in range(2)])+ subjects = (+ [(self.other_membership.id, None), (self.organization_membership.id, None)]+ if subject == "member"+ else [(None, role.id) for role in roles]+ )+ rules = AccessControl.objects.bulk_create(+ [+ AccessControl(+ team=self.team,+ resource="dashboard",+ resource_id=str(dashboard.id),+ organization_member_id=member_id,+ role_id=role_id,+ access_level="viewer",+ )+ for dashboard in (self.dashboard, other_dashboard)+ for member_id, role_id in subjects+ ]+ )+ selected = [rules[0], rules[3]]+ with CaptureQueriesContext(connection) as queries:+ bulk_set_object_access_controls(+ team_id=self.team.id,+ inputs=[+ contracts.SetObjectAccessControlInput(+ resource=rule.resource,+ resource_id=str(rule.resource_id),+ organization_member_id=rule.organization_member_id,+ role_id=rule.role_id,+ access_level="editor",+ )+ for rule in selected+ ],+ )+ locking_queries = [+ query["sql"]+ for query in queries.captured_queries+ if "FOR UPDATE" in query["sql"] and AccessControl._meta.db_table in query["sql"]+ ]+ assert len(locking_queries) == 1+ assert {rule.id for rule in AccessControl.objects.raw(locking_queries[0])} == {rule.id for rule in selected}+ assert set(+ AccessControl.objects.filter(id__in=[rules[1].id, rules[2].id]).values_list("access_level", flat=True)+ ) == {"viewer"}++ @parameterized.expand([("member",), ("role",)])+ def test_bulk_rules_reject_foreign_subject_before_writing(self, subject: str) -> None:+ other_org = Organization.objects.create(name="Other organization")+ outsider = User.objects.create_and_join(other_org, "[email protected]", "testtest")+ member = OrganizationMembership.objects.get(user=outsider, organization=other_org)+ role = Role.objects.create(name="Other role", organization=other_org)+ with pytest.raises(InvalidObjectAccessControlError):+ bulk_set_object_access_controls(+ team_id=self.team.id,+ inputs=[+ contracts.SetObjectAccessControlInput(+ resource="dashboard",+ resource_id=str(self.dashboard.id),+ access_level="editor",+ organization_member_id=self.other_membership.id,+ ),+ contracts.SetObjectAccessControlInput(+ resource="dashboard",+ resource_id=str(self.dashboard.id),+ access_level="editor",+ organization_member_id=member.id if subject == "member" else None,+ role_id=role.id if subject == "role" else None,+ ),+ ],+ )+ assert not AccessControl.objects.filter(team=self.team, resource_id=str(self.dashboard.id)).exists()+class TestEveryMemberHasResourceAccess(BaseTest):"""`account` inherits from `customer_analytics`, so every rule here is written on the parent,diff --git a/products/access_control/backend/tests/test_user_access_control.py b/products/access_control/backend/tests/test_user_access_control.pyindex 19b65383c977..a28e743298cc 100644--- a/products/access_control/backend/tests/test_user_access_control.py+++ b/products/access_control/backend/tests/test_user_access_control.py@@ -80,6 +80,42 @@ class BaseUserAccessControlTest(BaseTest):@pytest.mark.eeclass TestUserAccessControl(BaseUserAccessControlTest):+ @parameterized.expand([(False, False), (False, True), (True, False), (True, True)])+ def test_preloaded_users_match_single_user_permissions(self, most_specific: bool, entitled: bool) -> None:+ self.organization.uses_most_specific_access_resolution = most_specific+ if not entitled:+ self.organization.available_product_features = []+ self.organization.save()+ self.organization_membership.level = OrganizationMembership.Level.MEMBER+ self.organization_membership.save()+ dashboard = Dashboard.objects.create(team=self.team)+ self._create_access_control(resource="dashboard", resource_id=str(dashboard.id), access_level="none")+ self._create_access_control(+ resource="dashboard", resource_id=str(dashboard.id), access_level="viewer", role=self.role_a+ )+ member = OrganizationMembership.objects.get(organization=self.organization, user=self.other_user)+ self._create_access_control(+ resource="dashboard", resource_id=str(dashboard.id), access_level="editor", organization_member=member+ )+ other_org = Organization.objects.create(name="Other organization")+ outsider = User.objects.create_and_join(other_org, "[email protected]", "testtest")+ foreign_member = OrganizationMembership.objects.get(organization=other_org, user=outsider)+ foreign_role = Role.objects.create(name="Other role", organization=other_org)+ RoleMembership.objects.create(user=self.user_with_no_role, role=foreign_role)+ RoleMembership.objects.create(user=self.user_with_no_role, role=self.role_a, organization_member=foreign_member)+ self._create_access_control(+ resource="dashboard", resource_id=str(dashboard.id), access_level="manager", role=foreign_role+ )+ users = [self.user, self.other_user, self.user_with_no_role]+ access_by_user = UserAccessControl.for_user_ids(+ user_ids=[user.id for user in users] + [outsider.id], team=self.team+ )+ assert set(access_by_user) == {user.id for user in users}+ for user in users:+ assert access_by_user[user.id].get_user_access_level(dashboard) == UserAccessControl(+ user=user, team=self.team+ ).get_user_access_level(dashboard)+def test_no_organization_id_passed(self):# Create a user without an organizationuser_without_org = User.objects.create(email="[email protected]", password="testtest")