Skip to content

: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.

fix(tasks): check task channel visibility without channel joins (#126085)

Shy Alterb44b253a8278
diff --git a/products/tasks/backend/facade/api.py b/products/tasks/backend/facade/api.py
index 7194a2593a58..5ed5d335255b 100644
--- a/products/tasks/backend/facade/api.py
+++ b/products/tasks/backend/facade/api.py
@@ -6970,7 +6970,14 @@ def _task_detail_queryset():
).prefetch_related("runs")
-def _visible_task_qs(team_id: int, user_id: int | None, *, bypass_visibility: bool = False, for_control: bool = False):
+def _visible_task_qs(
+ team_id: int,
+ user_id: int | None,
+ *,
+ bypass_visibility: bool = False,
+ for_control: bool = False,
+ for_list: bool = False,
+):
"""Team-scoped live tasks, gated by read visibility — or by the narrower
control predicate when ``for_control`` (mutations, runs, agent commands).
@@ -6980,8 +6987,11 @@ def _visible_task_qs(team_id: int, user_id: int | None, *, bypass_visibility: bo
"""
qs = Task.objects.filter(team_id=team_id, deleted=False).filter(scout_trial_visibility_q(user_id))
if not bypass_visibility:
+ channel_team_id = team_id if for_list else None
qs = qs.filter(
- task_control_q(user_id) if for_control else task_visibility_q(user_id) | _shared_slack_thread_q()
+ task_control_q(user_id, channel_team_id)
+ if for_control
+ else task_visibility_q(user_id, channel_team_id) | _shared_slack_thread_q()
)
# Another product may hide tasks it owns from this user, for example the copies of chats a
# user cannot continue as tasks yet.
@@ -7049,7 +7059,7 @@ def get_conversation_task_dtos(
)
tasks = (
Task.objects.filter(team_id=team_id, id__in=task_ids, deleted=False)
- .filter(task_visibility_q(user_id))
+ .filter(task_visibility_q(user_id, team_id))
.select_related("created_by")
.prefetch_related(Prefetch("team", queryset=Team.objects.only("id", "name")))
.annotate(_latest_run_id=Subquery(latest_run_id_sq))
@@ -7138,7 +7148,7 @@ def is_scout_trial_task(task_id: str | UUID, team_id: int) -> bool:
def list_pinned_task_ids(team_id: int, user_id: int, *, exclude_task_ids: Iterable[UUID] = ()) -> list[UUID]:
- visible_tasks = _visible_task_qs(team_id, user_id).exclude(id__in=exclude_task_ids).values("id")
+ visible_tasks = _visible_task_qs(team_id, user_id, for_list=True).exclude(id__in=exclude_task_ids).values("id")
return list(
TaskPin.objects.filter(user_id=user_id, task_id__in=Subquery(visible_tasks))
.order_by("-pinned_at")
@@ -7185,7 +7195,7 @@ def list_workflow_last_runs(
return {}
latest_run = TaskRun.objects.filter(task=OuterRef("pk"), team_id=team_id).order_by("-created_at", "-id")
rows = (
- _visible_task_qs(team_id, user_id)
+ _visible_task_qs(team_id, user_id, for_list=True)
.filter(hog_flow_id__in=ids, internal=False)
.order_by("hog_flow_id", "-created_at", "-id")
.distinct("hog_flow_id")
@@ -7271,7 +7281,7 @@ def _task_source(origin_product: str, client_provenance: str | None) -> str:
def list_task_sources(team_id: int, user_id: int, *, exclude_task_ids: Iterable[UUID] = ()) -> list[str]:
"""Distinct task list sources of the user's own visible, non-archived, non-internal tasks."""
pairs = (
- _visible_task_qs(team_id, user_id)
+ _visible_task_qs(team_id, user_id, for_list=True)
.filter(internal=False, archived=False, created_by_id=user_id)
.exclude(id__in=exclude_task_ids)
.order_by()
@@ -7286,7 +7296,7 @@ def _list_tasks_queryset(
) -> QuerySet[Task]:
latest_run = TaskRun.objects.filter(task=OuterRef("pk"), team_id=team_id).order_by("-created_at", "-id")
ordering = TASK_LIST_ORDERINGS.get(filters.get("ordering") or "", TASK_LIST_ORDERINGS[DEFAULT_TASK_LIST_ORDERING])
- qs = _visible_task_qs(team_id, user_id, bypass_visibility=bypass_visibility).order_by(*ordering)
+ qs = _visible_task_qs(team_id, user_id, bypass_visibility=bypass_visibility, for_list=True).order_by(*ordering)
origin_product = filters.get("origin_product")
if origin_product:
@@ -7572,7 +7582,7 @@ def search_tasks(
if not normalized:
return []
visible_task_ids = (
- _visible_task_qs(team_id, user_id, bypass_visibility=bypass_visibility)
+ _visible_task_qs(team_id, user_id, bypass_visibility=bypass_visibility, for_list=True)
.filter(internal=False)
.exclude(id__in=exclude_task_ids)
.values("id")
@@ -7629,7 +7639,7 @@ def list_task_repositories(team_id: int, user_id: int | None, *, exclude_task_id
"""Distinct repositories used by non-deleted, non-internal visible tasks for the team."""
tasks = (
Task.objects.filter(team_id=team_id, deleted=False, internal=False)
- .filter(task_visibility_q(user_id))
+ .filter(task_visibility_q(user_id, team_id))
.exclude(id__in=exclude_task_ids)
)
plural = (
@@ -7727,7 +7737,7 @@ def get_task_summaries(
)
tasks = (
Task.objects.filter(team_id=team_id, deleted=False, id__in=ids)
- .filter(task_visibility_q(user_id))
+ .filter(task_visibility_q(user_id, team_id))
.exclude(id__in=exclude_task_ids)
.annotate(
_latest_run=Subquery(latest_run.values("_data")[:1]),
@@ -10606,7 +10616,7 @@ def list_channel_contributors(team_id: int, user_id: int | None) -> list[contrac
return []
task_rows = (
Task.objects.filter(
- task_visibility_q(user_id),
+ task_visibility_q(user_id, team_id),
team_id=team_id,
channel_id__in=channel_ids,
deleted=False,
@@ -11656,7 +11666,7 @@ def list_mentions(
team_id=team_id,
mentioned_user_id=user_id,
# task__in keeps the visibility rules single-sourced in _visible_task_qs.
- task__in=_visible_task_qs(team_id, user_id),
+ task__in=_visible_task_qs(team_id, user_id, for_list=True),
# Legacy turn_complete rows are hidden from threads (see list_thread_messages),
# so their indexed mentions must not surface notifications pointing at them.
).exclude(message__event="turn_complete")
@@ -11737,7 +11747,7 @@ ACTIVITY_FEED_EXCLUDED_ORIGIN_PRODUCTS = (Task.OriginProduct.SIGNALS_SCOUT,)
def _activity_visible_task_qs(team_id: int, user_id: int) -> QuerySet[Task]:
return (
- _visible_task_qs(team_id, user_id)
+ _visible_task_qs(team_id, user_id, for_list=True)
.filter(internal=False, archived=False)
.exclude(origin_product__in=ACTIVITY_FEED_EXCLUDED_ORIGIN_PRODUCTS)
)
diff --git a/products/tasks/backend/max_tools.py b/products/tasks/backend/max_tools.py
index 5d36cfc8e47d..e5486e497a3b 100644
--- a/products/tasks/backend/max_tools.py
+++ b/products/tasks/backend/max_tools.py
@@ -406,7 +406,7 @@ Use this tool when the user wants to:
def query_tasks():
qs = (
Task.objects.filter(team=self._team, deleted=False, internal=False)
- .filter(task_visibility_q(self._user.id))
+ .filter(task_visibility_q(self._user.id, self._team.id))
.order_by("-created_at")
)
diff --git a/products/tasks/backend/tests/test_visibility.py b/products/tasks/backend/tests/test_visibility.py
new file mode 100644
index 000000000000..9e9ba7f5b963
--- /dev/null
+++ b/products/tasks/backend/tests/test_visibility.py
@@ -0,0 +1,52 @@
+from posthog.test.base import BaseTest
+
+from django.test import SimpleTestCase
+
+from parameterized import parameterized
+
+from posthog.models import Team
+
+from products.tasks.backend.models import Channel, Task, TaskRun
+from products.tasks.backend.visibility import task_control_q, task_run_visibility_q, task_visibility_q
+
+
+class TestVisibilityQueryShape(SimpleTestCase):
+ @parameterized.expand(
+ [
+ (f"{name}_{scope}", model, visibility_q, team_id)
+ for name, model, visibility_q in [
+ ("visibility", Task, task_visibility_q),
+ ("control", Task, task_control_q),
+ ("run_visibility", TaskRun, task_run_visibility_q),
+ ]
+ for scope, team_id in [("team_scoped", 1), ("unscoped", None)]
+ ]
+ )
+ def test_outer_query_does_not_join_channel_tables(self, _name, model, visibility_q, team_id) -> None:
+ sql = str(model.objects.filter(team_id=1).filter(visibility_q(7, team_id)).query)
+ outer_from = sql.split(" WHERE ", 1)[0]
+
+ assert "posthog_task_channel" not in outer_from
+ assert "EXISTS" not in sql
+
+
+class TestChildEnvironmentVisibility(BaseTest):
+ @parameterized.expand([("visibility", task_visibility_q), ("control", task_control_q)])
+ def test_creator_sees_child_environment_task_in_root_team_channel(self, _name, visibility_q) -> None:
+ env_team = Team.objects.create(
+ organization=self.organization, project=self.project, parent_team=self.team, name="env"
+ )
+ channel = Channel.objects.unscoped().create(
+ team=env_team, name="me", channel_type=Channel.ChannelType.PERSONAL, created_by=self.user
+ )
+ task = Task.objects.create(
+ team=env_team,
+ created_by=self.user,
+ title="t",
+ description="d",
+ origin_product=Task.OriginProduct.USER_CREATED,
+ channel=channel,
+ )
+
+ assert channel.team_id == self.team.id
+ assert list(Task.objects.filter(team_id=env_team.id).filter(visibility_q(self.user.id, env_team.id))) == [task]
diff --git a/products/tasks/backend/visibility.py b/products/tasks/backend/visibility.py
index e7e7e8b3ab42..7b10af6e0690 100644
--- a/products/tasks/backend/visibility.py
+++ b/products/tasks/backend/visibility.py
@@ -5,7 +5,12 @@ posthog.api.file_system.registrations, which loads at django.setup()) don't pull
tasks API surface. Its module-scope imports reach jsonschema and the modal SDK.
"""
-from django.db.models import Q
+from typing import cast
+
+from django.db.models import BooleanField, OuterRef, Q, Subquery, Value
+from django.db.models.functions import Coalesce
+
+from posthog.models.team import Team
from products.tasks.backend.models import Channel, Task
@@ -39,17 +44,29 @@ def _creator_q(user_id: int | None) -> Q:
return Q(pk__in=[]) if user_id is None else Q(created_by_id=user_id)
+def _visible_channel_q(user_id: int | OuterRef | None, team_id: int | None, *, through_task: bool = False) -> Q:
+ channel_user_id = cast(int, OuterRef(user_id)) if isinstance(user_id, OuterRef) else user_id
+ channels = Channel.objects.unscoped().filter(Channel.visible_to_q(channel_user_id))
+ if team_id is not None:
+ root_team_id = Subquery(Team.objects.filter(id=team_id).values("parent_team_id")[:1])
+ channel_ids = channels.filter(Q(team_id=team_id) | Q(team_id=root_team_id)).values("id")
+ return Q(task__channel_id__in=channel_ids) if through_task else Q(channel_id__in=channel_ids)
+ channel_ref = OuterRef("task__channel_id") if through_task else OuterRef("channel_id")
+ visible_channel = channels.filter(pk=channel_ref).annotate(visible=Value(True)).values("visible")[:1]
+ return Q(Coalesce(Subquery(visible_channel), Value(False), output_field=BooleanField()))
+
+
def scout_trial_visibility_q(user_id: int | None) -> Q:
return ~Task.scout_experiment_q() | _creator_q(user_id)
-def task_control_q(user_id: int | None) -> Q:
+def task_control_q(user_id: int | None, team_id: int | None = None) -> Q:
"""Tasks the user may mutate or drive.
A task with a channel must be visible through that channel and owned by the user.
Null-channel tasks keep the product-origin control rules used before channels.
"""
- channeled_q = Q(channel_id__isnull=False) & Channel.visible_to_q(user_id, relation="channel") & _creator_q(user_id)
+ channeled_q = Q(channel_id__isnull=False) & _visible_channel_q(user_id, team_id) & _creator_q(user_id)
legacy_q = Q(channel_id__isnull=True) & (
_creator_q(user_id) | Q(created_by__isnull=True) | Q(origin_product__in=TEAM_VISIBLE_ORIGIN_PRODUCTS)
)
@@ -60,13 +77,13 @@ def task_control_q(user_id: int | None) -> Q:
)
-def task_visibility_q(user_id: int | None) -> Q:
+def task_visibility_q(user_id: int | None, team_id: int | None = None) -> Q:
"""Tasks readable by the user.
Channel visibility is authoritative when a task has a channel. The creator and
product-origin fallback applies only to null-channel compatibility rows.
"""
- channeled_q = Q(channel_id__isnull=False) & Channel.visible_to_q(user_id, relation="channel")
+ channeled_q = Q(channel_id__isnull=False) & _visible_channel_q(user_id, team_id)
legacy_q = Q(channel_id__isnull=True) & (
_creator_q(user_id) | Q(created_by__isnull=True) | Q(origin_product__in=TEAM_READABLE_ORIGIN_PRODUCTS)
)
@@ -77,9 +94,9 @@ def task_visibility_q(user_id: int | None) -> Q:
)
-def task_run_visibility_q(user_id: int | None) -> Q:
+def task_run_visibility_q(user_id: int | None, team_id: int | None = None) -> Q:
"""``task_visibility_q`` traversed through the parent task relation."""
- channeled_q = Q(task__channel_id__isnull=False) & Channel.visible_to_q(user_id, relation="task__channel")
+ channeled_q = Q(task__channel_id__isnull=False) & _visible_channel_q(user_id, team_id, through_task=True)
legacy_q = Q(task__channel_id__isnull=True) & (
(Q(task__pk__in=[]) if user_id is None else Q(task__created_by_id=user_id))
| Q(task__created_by__isnull=True)