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.

11.7 KB
Raw Blame
import { MakeLogicType, actions, connect, kea, listeners, path } from 'kea'
import posthog from 'posthog-js'

import { isLogEntryPropertyFilter, isValidPropertyFilter } from 'lib/components/PropertyFilters/utils'
import { isActionFilter, isEventFilter } from 'lib/components/UniversalFilters/utils'
import { preflightLogic } from 'lib/logic/preflightLogic'
import { metricCount, metricHistogram } from 'lib/operationalMetrics'
import { MiniFilterKey } from 'scenes/session-recordings/player/inspector/miniFiltersLogic'
import { InspectorListItemType } from 'scenes/session-recordings/player/inspector/playerInspectorLogic'
import { filtersFromUniversalFilterGroups } from 'scenes/session-recordings/utils'
import { userLogic } from 'scenes/userLogic'

import {
    PropertyFilterType,
    RecordingDurationFilter,
    RecordingUniversalFilters,
    SessionPlayerData,
    SessionRecordingType,
} from '~/types'

import type { Realm, UserType } from '../../types'

export enum SessionRecordingFilterType {
    Duration = 'duration',
    EventAndAction = 'event_and_action',
    PersonAndCohort = 'person_and_cohort',
    DateRange = 'date_range',
    DurationType = 'duration_type',
}

interface RecordingViewedProps {
    delay: number // Not reported: Number of delayed **seconds** to report event (useful to measure insights where users don't navigate immediately away)
    duration: number // How long is the total recording (milliseconds)
    recording_id: string // Id of the session
    start_time?: number // Start timestamp of the session
    end_time?: number // End timestamp of the session
    snapshot_source: 'web' | 'mobile' | 'unknown'
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface sessionRecordingEventUsageLogicValues {
    realm: Realm | null // preflightLogic
    user: UserType | null // userLogic
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface sessionRecordingEventUsageLogicActions {
    reportNextRecordingTriggered: (automatic: boolean) => {
        automatic: boolean
    }
    reportRecordingDebugChatReopened: () => {
        value: true
    }
    reportRecordingDebuggedWithAI: (
        playerTimeSeconds: number,
        promptEdited: boolean
    ) => {
        playerTimeSeconds: number
        promptEdited: boolean
    }
    reportRecordingExportedToFile: (format: 'json' | 'mp4') => {
        format: 'json' | 'mp4'
    }
    reportRecordingInspectorItemExpanded: (
        tab: InspectorListItemType,
        index: number
    ) => {
        index: number
        tab:
            | 'app-state'
            | 'browser-visibility'
            | 'comment'
            | 'console'
            | 'doctor'
            | 'events'
            | 'experiment-variant'
            | 'inactivity'
            | 'inspector-summary'
            | 'logs'
            | 'metric-event'
            | 'network'
            | 'offline-status'
            | 'performance'
            | 'session-change'
    }
    reportRecordingInspectorMiniFilterViewed: (
        minifilterKey: MiniFilterKey,
        enabled: boolean
    ) => {
        enabled: boolean
        minifilterKey: string
    }
    reportRecordingLoaded: (
        playerData: SessionPlayerData,
        metadata: SessionRecordingType | null
    ) => {
        metadata: SessionRecordingType | null
        playerData: SessionPlayerData
    }
    reportRecordingLoadedFromFile: (data: { error?: string; success: boolean }) => {
        error?: string | undefined
        success: boolean
    }
    reportRecordingOpenedFromRecentRecordingList: () => {
        value: true
    }
    reportRecordingPinnedToList: (pinned: boolean) => {
        pinned: boolean
    }
    reportRecordingsListFetched: (
        loadTime: number,
        filters: RecordingUniversalFilters,
        defaultDurationFilter: RecordingDurationFilter,
        page: {
            hasNext: boolean
            isFirstPage: boolean
            resultCount: number
        },
        source?: string
    ) => {
        defaultDurationFilter: RecordingDurationFilter
        filters: RecordingUniversalFilters
        loadTime: number
        page: {
            hasNext: boolean
            isFirstPage: boolean
            resultCount: number
        }
        source: string | undefined
    }
    reportRecordingsListFilterAdded: (filterType: SessionRecordingFilterType) => {
        filterType: SessionRecordingFilterType
    }
    reportRecordingsListPropertiesFetched: (loadTime: number) => {
        loadTime: number
    }
}

export type sessionRecordingEventUsageLogicType = MakeLogicType<
    sessionRecordingEventUsageLogicValues,
    sessionRecordingEventUsageLogicActions
>

export const sessionRecordingEventUsageLogic = kea<sessionRecordingEventUsageLogicType>([
    path(['scenes', 'session-recordings', 'sessionRecordingEventUsageLogic']),
    connect(() => ({
        values: [preflightLogic, ['realm'], userLogic, ['user']],
    })),
    actions({
        reportRecordingLoaded: (playerData: SessionPlayerData, metadata: SessionRecordingType | null) => ({
            playerData,
            metadata,
        }),
        reportRecordingsListFetched: (
            loadTime: number,
            filters: RecordingUniversalFilters,
            defaultDurationFilter: RecordingDurationFilter,
            /** What the response held, so an empty list can be told from a full page of results. */
            page: { resultCount: number; hasNext: boolean; isFirstPage: boolean },
            /** Which surface embeds the playlist, so a list load can be read per host page. */
            source?: string
        ) => ({
            loadTime,
            filters,
            defaultDurationFilter,
            page,
            source,
        }),
        reportRecordingsListPropertiesFetched: (loadTime: number) => ({ loadTime }),
        reportRecordingsListFilterAdded: (filterType: SessionRecordingFilterType) => ({ filterType }),
        reportRecordingInspectorItemExpanded: (tab: InspectorListItemType, index: number) => ({ tab, index }),
        reportRecordingInspectorMiniFilterViewed: (minifilterKey: MiniFilterKey, enabled: boolean) => ({
            minifilterKey,
            enabled,
        }),
        reportNextRecordingTriggered: (automatic: boolean) => ({
            automatic,
        }),
        reportRecordingExportedToFile: (format: 'json' | 'mp4') => ({ format }),
        reportRecordingDebuggedWithAI: (playerTimeSeconds: number, promptEdited: boolean) => ({
            playerTimeSeconds,
            promptEdited,
        }),
        reportRecordingDebugChatReopened: true,
        reportRecordingLoadedFromFile: (data: { success: boolean; error?: string }) => data,
        reportRecordingPinnedToList: (pinned: boolean) => ({ pinned }),
        reportRecordingOpenedFromRecentRecordingList: true,
    }),
    listeners(() => ({
        reportRecordingLoaded: ({ playerData, metadata }) => {
            // older recordings did not store this, and so "null" is equivalent to web,
            // but for reporting we want to distinguish between not loaded and no value to load
            const snapshotSource = metadata?.snapshot_source || 'unknown'
            const payload: Partial<RecordingViewedProps> = {
                duration: playerData.durationMs,
                recording_id: playerData.sessionRecordingId,
                start_time: playerData.start?.valueOf() ?? 0,
                end_time: playerData.end?.valueOf() ?? 0,
                snapshot_source: snapshotSource,
            }
            posthog.capture(`recording loaded`, payload)
            // the runtime value is caller-controlled, so allowlist it to keep the metric series bounded
            const snapshotSourceLabel = ['web', 'mobile'].includes(snapshotSource) ? snapshotSource : 'unknown'
            metricCount('replay_player_recordings_loaded', 1, { snapshot_source: snapshotSourceLabel })
        },
        reportRecordingsListFilterAdded: ({ filterType }) => {
            posthog.capture('recording list filter added', { filter_type: filterType })
        },
        reportRecordingsListFetched: ({ loadTime, filters, defaultDurationFilter, page, source }) => {
            metricHistogram('replay_list_load_ms', loadTime, 'ms')
            try {
                const filterValues = filtersFromUniversalFilterGroups(filters)

                const eventFilters = filterValues.filter(isEventFilter)
                const actionFilters = filterValues.filter(isActionFilter)
                const propertyFilters = filterValues.filter(isValidPropertyFilter)
                const consoleLogFilters = propertyFilters.filter(isLogEntryPropertyFilter)

                const filterBreakdown =
                    filters && defaultDurationFilter
                        ? {
                              hasEventsFilters: !!eventFilters.length,
                              hasActionsFilters: !!actionFilters.length,
                              hasPropertiesFilters: !!propertyFilters.length,
                              hasCohortFilter: propertyFilters.some((p) => p.type === PropertyFilterType.Cohort),
                              hasPersonFilter: propertyFilters.some((p) => p.type === PropertyFilterType.Person),
                              hasDurationFilters:
                                  ((filters.duration.length > 0 && filters.duration[0].value) || -1) >
                                  defaultDurationFilter.value,
                              hasConsoleLogsFilters: !!consoleLogFilters.length,
                          }
                        : {}
                posthog.capture('recording list fetched', {
                    load_time: loadTime,
                    listing_version: '3',
                    filters,
                    source,
                    result_count: page.resultCount,
                    has_next: page.hasNext,
                    // False for the pages scrolling adds, which say nothing about what the list
                    // first showed.
                    is_first_page: page.isFirstPage,
                    ...filterBreakdown,
                })
            } catch (e) {
                posthog.captureException(e, { filters })
            }
        },
        reportRecordingsListPropertiesFetched: ({ loadTime }) => {
            posthog.capture('recording list properties fetched', { load_time: loadTime })
        },
        reportRecordingOpenedFromRecentRecordingList: () => {
            posthog.capture('recording opened from recent recording list')
        },
        reportRecordingInspectorItemExpanded: ({ tab, index }) => {
            posthog.capture('recording inspector item expanded', { tab: 'replay-4000', type: tab, index })
        },
        reportRecordingInspectorMiniFilterViewed: ({ minifilterKey, enabled }) => {
            posthog.capture('recording inspector minifilter selected', { tab: 'replay-4000', enabled, minifilterKey })
        },
        reportNextRecordingTriggered: ({ automatic }) => {
            posthog.capture('recording next recording triggered', { automatic })
        },
        reportRecordingExportedToFile: ({ format }) => {
            posthog.capture('recording exported to file', { format })
        },
        reportRecordingDebuggedWithAI: ({ playerTimeSeconds, promptEdited }) => {
            posthog.capture('recording debugged with ai', {
                player_time_seconds: playerTimeSeconds,
                prompt_edited: promptEdited,
            })
        },
        reportRecordingDebugChatReopened: () => {
            posthog.capture('recording debug chat reopened')
        },
        reportRecordingLoadedFromFile: (properties) => {
            posthog.capture('recording loaded from file', properties)
        },
        reportRecordingPinnedToList: (properties) => {
            posthog.capture('recording pinned to list', properties)
        },
    })),
])