: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
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(),
])