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.

13.6 KB
Raw Blame
import { MakeLogicType, actions, afterMount, connect, kea, path, reducers, selectors } from 'kea'
import type { PostHog } from 'posthog-js/dist/module'

import { uuid } from 'lib/utils/dom'
import { permanentlyMount } from 'lib/utils/kea-logic-builders'

import { CLOUD_INTERNAL_POSTHOG_PROPERTY_KEYS } from '~/taxonomy/taxonomy'
import { PROPERTY_KEYS } from '~/taxonomy/taxonomy'
import { EventCategory, classifyEvent } from '~/toolbar/shared/debug/eventCategories'
import { toolbarConfigLogic } from '~/toolbar/shared/toolbarConfigLogic'
import { EventType } from '~/types'

function tryRegexMatch(text: string, pattern: string): boolean {
    // If the pattern looks like /regex/ or /regex/flags, treat as regex
    const regexMatch = pattern.match(/^\/(.+)\/([gimsuy]*)$/)
    if (regexMatch) {
        try {
            const re = new RegExp(regexMatch[1], regexMatch[2])
            return re.test(text)
        } catch {
            // Invalid regex, fall back to plain includes
            return text.toLowerCase().includes(pattern.toLowerCase())
        }
    }
    // Plain case-insensitive substring match
    return text.toLowerCase().includes(pattern.toLowerCase())
}

const MAX_EVENTS = 5000

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface eventDebugMenuLogicValues {
    posthog: PostHog | null // toolbarConfigLogic
    activeFilteredEvents: EventType[]
    bufferedCount: number
    bufferedEvents: EventType[]
    events: EventType[]
    expandedEvent: string | null | undefined
    expandedProperties: Record<string, any> | never[]
    exportableEvents: object[]
    hidePostHogFlags: boolean
    hidePostHogProperties: boolean
    isCollapsedEventRow: (eventId: string | null | undefined) => boolean
    isPaused: boolean
    pinnedEventIds: Set<string>
    pinnedEvents: EventType[]
    relativeTimestamps: boolean
    searchFilteredEvents: EventType[]
    searchFilteredEventsCount: Record<EventCategory, number>
    searchText: string
    selectedEventTypes: EventCategory[]
    totalEventsCount: number
    unpinnedEvents: EventType[]
    visibleEvents: EventType[]
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface eventDebugMenuLogicActions {
    addEvent: (event: EventType) => {
        event: EventType
    }
    clearEvents: () => {
        value: true
    }
    exportEvents: () => {
        value: true
    }
    markExpanded: (id: string | null | undefined) => {
        id: string | null | undefined
    }
    setHidePostHogFlags: (hide: boolean) => {
        hide: boolean
    }
    setHidePostHogProperties: (hide: boolean) => {
        hide: boolean
    }
    setSearchText: (searchText: string) => {
        searchText: string
    }
    setSelectedEventType: (
        eventType: EventCategory,
        enabled: boolean
    ) => {
        enabled: boolean
        eventType: EventCategory
    }
    togglePaused: () => {
        value: true
    }
    togglePinnedEvent: (eventId: string) => {
        eventId: string
    }
    toggleRelativeTimestamps: () => {
        value: true
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface eventDebugMenuLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        isCollapsedEventRow: (
            expandedEvent: string | null | undefined
        ) => (eventId: string | null | undefined) => boolean
        visibleEvents: (events: EventType[], bufferedEvents: EventType[], isPaused: boolean) => EventType[]
        searchFilteredEvents: (visibleEvents: EventType[], searchText: string) => EventType[]
        searchFilteredEventsCount: (searchFilteredEvents: EventType[]) => Record<EventCategory, number>
        activeFilteredEvents: (selectedEventTypes: EventCategory[], searchFilteredEvents: EventType[]) => EventType[]
        totalEventsCount: (visibleEvents: EventType[]) => number
        bufferedCount: (bufferedEvents: EventType[]) => number
        pinnedEvents: (activeFilteredEvents: EventType[], pinnedEventIds: Set<string>) => EventType[]
        unpinnedEvents: (activeFilteredEvents: EventType[], pinnedEventIds: Set<string>) => EventType[]
        expandedProperties: (
            expandedEvent: string | null | undefined,
            events: EventType[],
            hidePostHogProperties: boolean,
            hidePostHogFlags: boolean
        ) => Record<string, any> | never[]
        exportableEvents: (activeFilteredEvents: EventType[]) => object[]
    }
}

export type eventDebugMenuLogicType = MakeLogicType<
    eventDebugMenuLogicValues,
    eventDebugMenuLogicActions,
    Record<string, any>,
    eventDebugMenuLogicMeta
>

export const eventDebugMenuLogic = kea<eventDebugMenuLogicType>([
    path(['toolbar', 'debug', 'eventDebugMenuLogic']),
    connect(() => ({
        values: [toolbarConfigLogic, ['posthog']],
    })),
    actions({
        addEvent: (event: EventType) => ({ event }),
        markExpanded: (id: string | null | undefined) => ({ id }),
        setSearchText: (searchText: string) => ({ searchText }),
        setSelectedEventType: (eventType: EventCategory, enabled: boolean) => ({
            eventType,
            enabled,
        }),
        setHidePostHogProperties: (hide: boolean) => ({ hide }),
        setHidePostHogFlags: (hide: boolean) => ({ hide }),
        togglePinnedEvent: (eventId: string) => ({ eventId }),
        toggleRelativeTimestamps: true,
        togglePaused: true,
        clearEvents: true,
        exportEvents: true,
    }),
    reducers({
        hidePostHogProperties: [
            false,
            {
                setHidePostHogProperties: (_, { hide }) => hide,
            },
        ],
        hidePostHogFlags: [
            false,
            {
                setHidePostHogFlags: (_, { hide }) => hide,
            },
        ],
        relativeTimestamps: [
            false,
            {
                toggleRelativeTimestamps: (state) => !state,
            },
        ],
        searchText: [
            '',
            {
                setSearchText: (_, { searchText }) => searchText,
            },
        ],
        selectedEventTypes: [
            ['posthog', 'custom'] as EventCategory[],
            {
                setSelectedEventType: (state, { eventType, enabled }) => {
                    if (enabled) {
                        return state.includes(eventType) ? state : [...state, eventType]
                    }
                    return state.filter((t) => t !== eventType)
                },
            },
        ],

        events: [
            [] as EventType[],
            {
                addEvent: (state, { event }) => {
                    const next = [{ ...event, uuid: event.uuid || uuid() }, ...state]
                    return next.length > MAX_EVENTS ? next.slice(0, MAX_EVENTS) : next
                },
                clearEvents: () => [],
            },
        ],
        // Events buffered while paused, prepended on resume
        bufferedEvents: [
            [] as EventType[],
            {
                addEvent: (state, { event }) => {
                    const next = [{ ...event, uuid: event.uuid || uuid() }, ...state]
                    return next.length > MAX_EVENTS ? next.slice(0, MAX_EVENTS) : next
                },
                togglePaused: () => [],
                clearEvents: () => [],
            },
        ],
        isPaused: [
            false,
            {
                togglePaused: (state) => !state,
            },
        ],
        expandedEvent: [
            null as string | null | undefined,
            {
                markExpanded: (_, { id }) => id,
            },
        ],
        pinnedEventIds: [
            new Set<string>(),
            {
                togglePinnedEvent: (state, { eventId }) => {
                    const next = new Set(state)
                    if (next.has(eventId)) {
                        next.delete(eventId)
                    } else {
                        next.add(eventId)
                    }
                    return next
                },
                clearEvents: () => new Set<string>(),
            },
        ],
    }),
    selectors({
        isCollapsedEventRow: [
            (s) => [s.expandedEvent],
            (expandedEvent: string | null | undefined) => {
                return (eventId: string | null | undefined): boolean => {
                    return eventId !== expandedEvent
                }
            },
        ],
        // When paused, show a frozen snapshot; when live, show all events
        visibleEvents: [
            (s) => [s.events, s.bufferedEvents, s.isPaused],
            (events: EventType[], bufferedEvents: EventType[], isPaused: boolean): EventType[] => {
                if (isPaused) {
                    // Show events minus anything buffered since pause
                    return events.slice(bufferedEvents.length)
                }
                return events
            },
        ],
        searchFilteredEvents: [
            (s) => [s.visibleEvents, s.searchText],
            (visibleEvents: EventType[], searchText: string) => {
                return visibleEvents.filter((e: EventType) => {
                    if (searchText && !tryRegexMatch(e.event, searchText)) {
                        return false
                    }
                    return true
                })
            },
        ],
        searchFilteredEventsCount: [
            (s) => [s.searchFilteredEvents],
            (searchFilteredEvents: EventType[]): Record<EventCategory, number> => {
                const counts: Record<EventCategory, number> = { posthog: 0, custom: 0, snapshot: 0 }
                searchFilteredEvents.forEach((e: EventType) => {
                    counts[classifyEvent(e)] += 1
                })
                return counts
            },
        ],

        activeFilteredEvents: [
            (s) => [s.selectedEventTypes, s.searchFilteredEvents],
            (selectedEventTypes: EventCategory[], searchFilteredEvents: EventType[]) => {
                return searchFilteredEvents.filter((e: EventType) => {
                    return selectedEventTypes.includes(classifyEvent(e))
                })
            },
        ],

        totalEventsCount: [(s) => [s.visibleEvents], (visibleEvents: EventType[]): number => visibleEvents.length],

        bufferedCount: [(s) => [s.bufferedEvents], (bufferedEvents: EventType[]): number => bufferedEvents.length],

        pinnedEvents: [
            (s) => [s.activeFilteredEvents, s.pinnedEventIds],
            (activeFilteredEvents: EventType[], pinnedEventIds: Set<string>): EventType[] => {
                if (pinnedEventIds.size === 0) {
                    return []
                }
                return activeFilteredEvents.filter((e: EventType) => e.uuid && pinnedEventIds.has(e.uuid))
            },
        ],

        unpinnedEvents: [
            (s) => [s.activeFilteredEvents, s.pinnedEventIds],
            (activeFilteredEvents: EventType[], pinnedEventIds: Set<string>): EventType[] => {
                if (pinnedEventIds.size === 0) {
                    return activeFilteredEvents
                }
                return activeFilteredEvents.filter((e: EventType) => !e.uuid || !pinnedEventIds.has(e.uuid))
            },
        ],

        expandedProperties: [
            (s) => [s.expandedEvent, s.events, s.hidePostHogProperties, s.hidePostHogFlags],
            (
                expandedEvent: string | null | undefined,
                events: EventType[],
                hidePostHogProperties: boolean,
                hidePostHogFlags: boolean
            ) => {
                if (!expandedEvent) {
                    return []
                }
                const allProperties = events.find((e) => e.uuid === expandedEvent)?.properties
                if (!allProperties) {
                    return []
                }

                const posthogPropertiesFiltered = hidePostHogProperties
                    ? Object.fromEntries(
                          Object.entries(allProperties).filter(([key]) => {
                              const isPostHogProperty = key.startsWith('$') && PROPERTY_KEYS.includes(key)
                              const isNonDollarPostHogProperty = CLOUD_INTERNAL_POSTHOG_PROPERTY_KEYS.includes(key)
                              return !isPostHogProperty && !isNonDollarPostHogProperty
                          })
                      )
                    : allProperties

                const posthogFlagsFiltered = hidePostHogFlags
                    ? Object.fromEntries(
                          Object.entries(posthogPropertiesFiltered).filter(([key]) => {
                              if (key === '$active_feature_flags') {
                                  return false
                              } else if (key.startsWith('$feature/')) {
                                  return false
                              }

                              return true
                          })
                      )
                    : posthogPropertiesFiltered

                return posthogFlagsFiltered
            },
        ],

        exportableEvents: [
            (s) => [s.activeFilteredEvents],
            (activeFilteredEvents: EventType[]): object[] => {
                return activeFilteredEvents.map((e: EventType) => ({
                    event: e.event,
                    timestamp: e.timestamp,
                    properties: e.properties,
                    uuid: e.uuid,
                }))
            },
        ],
    }),
    afterMount(({ values, actions, cache }) => {
        cache.disposables.add(() => {
            return values.posthog?.on('eventCaptured', (e) => {
                actions.addEvent(e)
            })
        }, 'posthogEventListener')
    }),
    permanentlyMount(),
])