: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
"""Resource endpoints — bearer-authenticated, status envelope.
A "resource" is a provisioned team, addressed by the partner as an opaque
resource id. All endpoints proxy cross-region on bearer lookup and read the
authenticated token off ``request.auth``.
"""
from __future__ import annotations
from typing import cast
from rest_framework.request import Request
from rest_framework.response import Response
from posthog.exceptions_capture import capture_exception
from posthog.models.oauth import OAuthAccessToken
from posthog.models.team.team import Team
from posthog.models.team.team_provisioning_config import TeamProvisioningConfig
from posthog.models.user import User
from ee.api.agentic_provisioning.analytics import capture_provisioning_event
from ee.api.agentic_provisioning.credentials import maybe_create_provisioned_pat
from ee.api.agentic_provisioning.exceptions import ProvisioningError
from ee.api.agentic_provisioning.ratelimits import Budget, rate_limited
from ee.api.agentic_provisioning.regions import current_region_host
from ee.api.agentic_provisioning.serializers import ResourceCreateSerializer, RotateCredentialsSerializer
from ee.api.agentic_provisioning.teams import ProjectIdCollisionError, resolve_or_create_project_team
from ee.api.agentic_provisioning.tokens import remove_team_from_token_scopes
from ee.api.agentic_provisioning.views.base import BearerResourceAPIView
def _access_configuration_response(
*,
resource_id: str,
team: Team,
user: User,
access_token: OAuthAccessToken,
label_prefix: str | None,
mint_pat: bool = True,
) -> Response:
access_configuration: dict[str, str] = {
"api_key": team.api_token,
"host": current_region_host(),
}
if mint_pat and (
personal_api_key := maybe_create_provisioned_pat(
user, team, access_token.application, access_token.scope, label_prefix=label_prefix
)
):
access_configuration["personal_api_key"] = personal_api_key
return Response(
{
"status": "complete",
"id": resource_id,
"complete": {
"access_configuration": access_configuration,
},
}
)
class ResourcesCreateView(BearerResourceAPIView):
@rate_limited("resource_creates", budget=Budget(burst=10, per_hour=30))
def post(self, request: Request) -> Response:
user = cast(User, request.user)
access_token = cast(OAuthAccessToken, request.auth)
app = access_token.application
data = self.validated_body(ResourceCreateSerializer, request, context={"partner": app})
label_prefix = data["label_prefix"]
scoped_teams = access_token.scoped_teams or []
if not scoped_teams:
capture_provisioning_event("resource_created", "error", partner=app, error_code="no_team")
raise ProvisioningError("no_team", "No team associated with this token")
project_id = data["project_id"]
configuration = data["configuration"]
if project_id:
try:
team, scoped_teams = resolve_or_create_project_team(
project_id, scoped_teams, user, configuration, access_token
)
except ProjectIdCollisionError:
capture_provisioning_event(
"resource_created", "error", partner=app, error_code="project_id_conflict", project_id=project_id
)
raise ProvisioningError(
"project_id_conflict",
"Project ID already linked to another organization",
status=409,
)
if team is None:
capture_provisioning_event(
"resource_created", "error", partner=app, error_code="not_found", project_id=project_id
)
raise ProvisioningError("not_found", "Resource not found", status=404)
else:
team_id = scoped_teams[0]
try:
team = Team.objects.get(id=team_id)
except Team.DoesNotExist:
capture_provisioning_event(
"resource_created", "error", partner=app, error_code="team_not_found", team_id=team_id
)
raise ProvisioningError("team_not_found", "Team not found", resource_id=str(team_id), status=404)
# The project_id branch above re-checks access inside resolve_or_create_project_team;
# this branch takes the team straight off the token's scope, so it checks here.
self.assert_team_access(team, access_token, resource_id=str(team_id))
capture_provisioning_event(
"resource_created",
"success",
partner=app,
team_id=team.id,
)
return _access_configuration_response(
resource_id=str(team.id),
team=team,
user=user,
access_token=access_token,
label_prefix=label_prefix,
)
class ResourceDetailView(BearerResourceAPIView):
@rate_limited("resource_reads")
def get(self, request: Request, resource_id: str) -> Response:
user = cast(User, request.user)
access_token = cast(OAuthAccessToken, request.auth)
team = self.get_scoped_team(resource_id, access_token)
return _access_configuration_response(
resource_id=resource_id,
team=team,
user=user,
access_token=access_token,
label_prefix=None,
# A read never mints a personal API key; rotation/creation do.
mint_pat=False,
)
class RotateCredentialsView(BearerResourceAPIView):
@rate_limited("credential_rotations")
def post(self, request: Request, resource_id: str) -> Response:
user = cast(User, request.user)
access_token = cast(OAuthAccessToken, request.auth)
data = self.validated_body(
RotateCredentialsSerializer, request, resource_id=resource_id, context={"resource_id": resource_id}
)
label_prefix = data["label_prefix"]
team = self.get_scoped_team(resource_id, access_token)
try:
# Bearer flow resolves the token outside DRF's session machinery,
# so read impersonation off the token directly.
team.reset_token_and_save(user=user, is_impersonated_session=access_token.impersonated_by_id is not None)
except Exception:
capture_exception(additional_properties={"team_id": team.id})
capture_provisioning_event("credential_rotation", "failed", team_id=team.id)
raise ProvisioningError(
"credential_rotation_failed", "Failed to rotate credentials", resource_id=resource_id, status=500
)
capture_provisioning_event("credential_rotation", "success", team_id=team.id)
return _access_configuration_response(
resource_id=resource_id,
team=team,
user=user,
access_token=access_token,
label_prefix=label_prefix,
)
class ResourceRemoveView(BearerResourceAPIView):
"""Detaches the resource from the orchestrator: removes it from the token's
scope and clears provisioning metadata. Preserves the underlying team and
user data so the customer can still access PostHog directly."""
@rate_limited("resource_removals")
def post(self, request: Request, resource_id: str) -> Response:
access_token = cast(OAuthAccessToken, request.auth)
team_id = self.parse_resource_team_id(resource_id, access_token)
try:
# Clear the mapping only if it is unclaimed or owned by the caller's
# application; an in-scope partner must not delete another partner's
# provisioning mapping for the same team.
config = TeamProvisioningConfig.objects.filter(team_id=team_id).first()
if config is not None and config.application_id in (None, access_token.application_id):
config.delete()
except Exception:
capture_exception(additional_properties={"team_id": team_id, "step": "remove_provisioning_config"})
capture_provisioning_event("resource_removed", "error", team_id=team_id, error_code="remove_config_failed")
raise ProvisioningError("remove_failed", "Failed to remove resource", resource_id=resource_id, status=500)
remove_team_from_token_scopes(access_token, team_id)
capture_provisioning_event("resource_removed", "success", team_id=team_id)
return Response({"status": "removed", "id": resource_id})