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.

8.9 KB
Raw Blame
import re
import json
from datetime import datetime
from typing import Any, cast

from django.db.models import QuerySet

from posthog.api.advanced_activity_logs.viewset import apply_organization_scoped_filter
from posthog.models import Team, User
from posthog.models.activity_logging.activity_log import (
    ActivityLog,
    ActivityScope,
    apply_activity_visibility_restrictions,
    field_name_overrides,
)
from posthog.models.activity_logging.retention import get_activity_log_lookback_restriction
from posthog.sync import database_sync_to_async

from ee.hogai.context.activity_log.prompts import (
    ACTIVITY_LOG_CONTEXT_TEMPLATE,
    ACTIVITY_LOG_ENTRY_TEMPLATE,
    ACTIVITY_LOG_NO_RESULTS,
    ACTIVITY_LOG_PAGINATION_END,
    ACTIVITY_LOG_PAGINATION_MORE,
)

MAX_VALUE_LENGTH = 200

# Keep in sync with SCOPE_DISPLAY_NAMES in frontend/src/lib/components/ActivityLog/humanizeActivity.tsx
SCOPE_DISPLAY_NAMES: dict[str, str] = {
    "AlertConfiguration": "Alert",
    "BatchExport": "Destination",
    "WorkloadTrustPolicy": "Workload trust policy",
    "WorkloadTrustPolicyRequest": "Workload trust policy request",
    "ExternalDataSource": "Source",
    "HogFunction": "Data pipeline",
    "PersonalAPIKey": "Personal API key",
    "LLMTrace": "LLM trace",
    "Ticket": "Support ticket",
}


def humanize_scope(scope: str) -> str:
    display = SCOPE_DISPLAY_NAMES.get(scope)
    if display:
        return display
    return re.sub(r"(?<=[a-z])(?=[A-Z])", " ", scope)


class ActivityLogContext:
    def __init__(
        self,
        team: Team,
        user: User,
    ):
        self._team = team
        self._user = user

    async def fetch_and_format(
        self,
        *,
        scope: str | None = None,
        activity: str | None = None,
        item_id: str | None = None,
        user_email: str | None = None,
        after: str | None = None,
        before: str | None = None,
        limit: int = 20,
        offset: int = 0,
    ) -> str:
        warnings: list[str] = []
        if after and self._parse_datetime(after) is None:
            warnings.append(f"Warning: 'after' filter '{after}' is not a valid ISO 8601 datetime and was ignored.")
        if before and self._parse_datetime(before) is None:
            warnings.append(f"Warning: 'before' filter '{before}' is not a valid ISO 8601 datetime and was ignored.")

        entries, total_count = await self._fetch_entries(
            scope=scope,
            activity=activity,
            item_id=item_id,
            user_email=user_email,
            after=after,
            before=before,
            limit=limit,
            offset=offset,
        )
        result = self._format_entries(
            entries,
            scope=scope,
            user_email=user_email,
            total_count=total_count,
            offset=offset,
            limit=limit,
        )
        if warnings:
            return "\n".join(warnings) + "\n\n" + result
        return result

    @staticmethod
    def _parse_datetime(value: str) -> datetime | None:
        try:
            return datetime.fromisoformat(value)
        except (ValueError, TypeError):
            return None

    @database_sync_to_async
    def _fetch_entries(
        self,
        *,
        scope: str | None = None,
        activity: str | None = None,
        item_id: str | None = None,
        user_email: str | None = None,
        after: str | None = None,
        before: str | None = None,
        limit: int = 20,
        offset: int = 0,
    ) -> tuple[list[ActivityLog], int]:
        queryset: QuerySet[ActivityLog] = ActivityLog.objects.select_related("user").order_by("-created_at")

        queryset = apply_organization_scoped_filter(
            queryset,
            bool(self._team.receive_org_level_activity_logs),
            self._team.id,
            self._team.organization_id,
        )

        lookback_date = get_activity_log_lookback_restriction(self._team.organization)
        if lookback_date:
            queryset = queryset.filter(created_at__gte=lookback_date)

        queryset = apply_activity_visibility_restrictions(queryset, self._user)

        if scope:
            queryset = queryset.filter(scope=scope)
        if activity:
            queryset = queryset.filter(activity__iexact=activity)
        if item_id:
            queryset = queryset.filter(item_id=item_id)
        if user_email:
            queryset = queryset.filter(user__email__iexact=user_email)
        if after:
            parsed = self._parse_datetime(after)
            if parsed:
                queryset = queryset.filter(created_at__gte=parsed)
        if before:
            parsed = self._parse_datetime(before)
            if parsed:
                queryset = queryset.filter(created_at__lte=parsed)

        limit = min(max(limit, 1), 50)
        total_count = queryset.count()
        entries = list(queryset[offset : offset + limit])
        return entries, total_count

    def _format_entries(
        self,
        entries: list[ActivityLog],
        *,
        scope: str | None = None,
        user_email: str | None = None,
        total_count: int = 0,
        offset: int = 0,
        limit: int = 20,
    ) -> str:
        if not entries:
            return ACTIVITY_LOG_NO_RESULTS

        formatted_entries: list[str] = []
        for entry in entries:
            formatted_entries.append(self._format_single_entry(entry))

        scope_filter = f" for scope={scope}" if scope else ""
        user_filter = f" by {user_email}" if user_email else ""

        has_more = total_count > offset + limit

        if has_more:
            pagination_hint = ACTIVITY_LOG_PAGINATION_MORE.format(next_offset=offset + limit)
        else:
            pagination_hint = ACTIVITY_LOG_PAGINATION_END

        return ACTIVITY_LOG_CONTEXT_TEMPLATE.format(
            count=len(formatted_entries),
            total_count=total_count,
            offset_start=offset + 1,
            offset_end=offset + len(formatted_entries),
            scope_filter=scope_filter,
            user_filter=user_filter,
            entries="\n".join(formatted_entries),
            pagination_hint=pagination_hint,
        )

    def _format_single_entry(self, entry: ActivityLog) -> str:
        timestamp = entry.created_at.isoformat()

        user_attribution = self._format_user_attribution(entry)
        item_name = self._extract_item_name(entry)
        changes = self._format_changes(entry)

        return ACTIVITY_LOG_ENTRY_TEMPLATE.format(
            timestamp=timestamp,
            scope=humanize_scope(entry.scope),
            activity=entry.activity,
            item_name=item_name,
            user_attribution=user_attribution,
            changes=changes,
        )

    def _format_user_attribution(self, entry: ActivityLog) -> str:
        if entry.is_system:
            return " | by System"
        if entry.user:
            name = entry.user.first_name or entry.user.email
            suffix = " (impersonated)" if entry.was_impersonated else ""
            return f" | by {name}{suffix}"
        return ""

    def _extract_item_name(self, entry: ActivityLog) -> str:
        detail = entry.detail
        if not detail or not isinstance(detail, dict):
            return entry.item_id or "(unknown)"

        name = detail.get("name")
        if name:
            return str(name)

        short_id = detail.get("short_id")
        if short_id:
            return str(short_id)

        return entry.item_id or "(unknown)"

    def _format_changes(self, entry: ActivityLog) -> str:
        detail = entry.safe_detail
        if not detail or not isinstance(detail, dict):
            return ""

        changes_data = detail.get("changes")
        if not changes_data or not isinstance(changes_data, list):
            return ""

        scope = cast(ActivityScope, entry.scope)
        overrides = field_name_overrides.get(scope, {})

        change_lines: list[str] = []
        for change in changes_data:
            if not isinstance(change, dict):
                continue

            raw_field = change.get("field", "unknown")
            field = overrides.get(raw_field, raw_field)
            action = change.get("action", "changed")
            before = self._truncate_value(change.get("before"))
            after = self._truncate_value(change.get("after"))

            if action == "created":
                change_lines.append(f"  - {field}: set to {after}")
            elif action == "deleted":
                change_lines.append(f"  - {field}: removed (was {before})")
            else:
                change_lines.append(f"  - {field}: {before} -> {after}")

        if not change_lines:
            return ""
        return "\n" + "\n".join(change_lines)

    def _truncate_value(self, value: Any) -> str:
        if value is None:
            return "(none)"
        if isinstance(value, dict | list):
            text = json.dumps(value, default=str)
        else:
            text = str(value)

        if len(text) > MAX_VALUE_LENGTH:
            return text[:MAX_VALUE_LENGTH] + "..."
        return text