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.

feat(toolbar): add events, vitals, more and experiments to the side panel (#121480)

Rafael Audibertc2134672a3cc
diff --git a/frontend/src/toolbar/TELEMETRY.md b/frontend/src/toolbar/TELEMETRY.md
index 393fd71bd59d..22548ae7dbf7 100644
--- a/frontend/src/toolbar/TELEMETRY.md
+++ b/frontend/src/toolbar/TELEMETRY.md
@@ -366,10 +366,10 @@ Fired when the side panel shows a new state.
Fired when the user runs a tool on the page from the extension.
-| Property | Type | Description |
-| --------- | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `tool` | `string` | `'inspect'`, `'heatmap'`, `'save-heatmap'`, `'actions'`, `'create-action'`, `'save-action'`, `'flags'`, `'override-flag'`, `'clear-flag-overrides'`, or `'impersonate-flags'` |
-| `payload` | `boolean \| undefined` | `true` when `'override-flag'` sets a payload |
+| Property | Type | Description |
+| --------- | ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `tool` | `string` | `'inspect'`, `'heatmap'`, `'save-heatmap'`, `'actions'`, `'create-action'`, `'save-action'`, `'flags'`, `'override-flag'`, `'clear-flag-overrides'`, `'impersonate-flags'`, `'events'`, `'export-events'`, `'web-vitals'`, `'experiments'`, `'create-experiment'`, `'save-experiment'`, `'more'`, `'pii-masking'`, `'screenshot-for-event'`, or `'view-session-recording'` |
+| `payload` | `boolean \| undefined` | `true` when `'override-flag'` sets a payload |
**File:** `extension/extensionTelemetry.ts`
diff --git a/frontend/src/toolbar/actions/SelectorCountContext.ts b/frontend/src/toolbar/actions/SelectorCountContext.ts
index 7f8d80b666d4..3e50749634a8 100644
--- a/frontend/src/toolbar/actions/SelectorCountContext.ts
+++ b/frontend/src/toolbar/actions/SelectorCountContext.ts
@@ -1,17 +1,38 @@
import { querySelectorAllDeep } from 'query-selector-shadow-dom'
import { createContext } from 'react'
+/**
+ * `deep` also matches inside shadow roots, like actions do. `document` matches only the document itself, like
+ * posthog-js applies web experiments with `document.querySelectorAll`.
+ */
+export type SelectorScope = 'deep' | 'document'
+
+export type SelectorMatchCounts = Record<SelectorScope, number>
+
export interface SelectorMatchCounter {
/** `undefined` while the count is pending, `null` for an invalid selector. */
- count: (selector: string) => number | null | undefined
+ count: (selector: string, scope?: SelectorScope) => number | null | undefined
request: (selector: string) => void
}
+function countInScope(selector: string, scope: SelectorScope): number {
+ return scope === 'deep' ? querySelectorAllDeep(selector).length : document.querySelectorAll(selector).length
+}
+
+/** Counts in both scopes, or returns `null` for an invalid selector. */
+export function countSelectorMatches(selector: string): SelectorMatchCounts | null {
+ try {
+ return { deep: countInScope(selector, 'deep'), document: countInScope(selector, 'document') }
+ } catch {
+ return null
+ }
+}
+
/** Counts in the document the component renders in, which is the page for the floating toolbar. */
const pageDocumentCounter: SelectorMatchCounter = {
- count: (selector) => {
+ count: (selector, scope = 'deep') => {
try {
- return querySelectorAllDeep(selector).length
+ return countInScope(selector, scope)
} catch {
return null
}
diff --git a/frontend/src/toolbar/bar/Toolbar.tsx b/frontend/src/toolbar/bar/Toolbar.tsx
index b47ac03a737e..2415b0fbd440 100644
--- a/frontend/src/toolbar/bar/Toolbar.tsx
+++ b/frontend/src/toolbar/bar/Toolbar.tsx
@@ -43,6 +43,7 @@ import { PII_MASKING_PRESET_COLORS } from '~/toolbar/bar/piiMaskingStyles'
import { ToolbarLockedFeature } from '~/toolbar/bar/ToolbarLockedFeature'
import { toolbarLogic } from '~/toolbar/bar/toolbarLogic'
import { UiHostConfigModal } from '~/toolbar/bar/UiHostConfigModal'
+import { readPosthogDebugInfo } from '~/toolbar/debug/posthogDebugInfo'
import { fieldNotesLogic } from '~/toolbar/field-notes/fieldNotesLogic'
import { productToursLogic } from '~/toolbar/product-tours/productToursLogic'
import { screenshotUploadLogic } from '~/toolbar/screenshot-upload/screenshotUploadLogic'
@@ -147,7 +148,7 @@ function postHogDebugInfoMenuItem(
loadingSurveys: boolean,
surveysCount: number
): LemonMenuItem {
- const isAutocaptureEnabled = posthog?.autocapture?.isEnabled
+ const info = readPosthogDebugInfo(posthog)
return {
icon: <IconStethoscope />,
@@ -157,7 +158,7 @@ function postHogDebugInfoMenuItem(
label: (
<div className="flex justify-between items-center w-full">
<div>version: </div>
- <div>{posthog?.version || 'posthog not available'}</div>
+ <div>{info.version || 'posthog not available'}</div>
</div>
),
},
@@ -165,7 +166,7 @@ function postHogDebugInfoMenuItem(
label: (
<div className="flex justify-between items-center w-full">
<div>api host: </div>
- <div>{posthog?.config.api_host}</div>
+ <div>{info.apiHost}</div>
</div>
),
},
@@ -173,28 +174,14 @@ function postHogDebugInfoMenuItem(
label: (
<div className="flex justify-between items-center w-full">
<div>ui host: </div>
- <div>{posthog?.config.ui_host || 'not set'}</div>
+ <div>{info.uiHost || 'not set'}</div>
</div>
),
},
- { label: <EnabledStatusItem label="autocapture" value={!!isAutocaptureEnabled} /> },
- {
- label: (
- <EnabledStatusItem
- label="rageclicks"
- value={!!(isAutocaptureEnabled && posthog?.config.rageclick)}
- />
- ),
- },
- {
- label: (
- <EnabledStatusItem
- label="dead clicks"
- value={!!posthog?.deadClicksAutocapture?.lazyLoadedDeadClicksAutocapture}
- />
- ),
- },
- { label: <EnabledStatusItem label="heatmaps" value={!!posthog?.heatmaps?.isEnabled} /> },
+ { label: <EnabledStatusItem label="autocapture" value={info.autocapture} /> },
+ { label: <EnabledStatusItem label="rageclicks" value={info.rageclicks} /> },
+ { label: <EnabledStatusItem label="dead clicks" value={info.deadClicks} /> },
+ { label: <EnabledStatusItem label="heatmaps" value={info.heatmaps} /> },
{
label: (
<div className="flex justify-between items-center w-full">
@@ -205,19 +192,19 @@ function postHogDebugInfoMenuItem(
</div>
),
},
- { label: <EnabledStatusItem label="session recording" value={!!posthog?.sessionRecording?.started} /> },
+ { label: <EnabledStatusItem label="session recording" value={info.sessionRecordingStarted} /> },
{
label: (
<div className="flex justify-between items-center w-full">
<div>session recording status: </div>
- <div>{posthog?.sessionRecording?.status || 'unknown'}</div>
+ <div>{info.sessionRecordingStatus || 'unknown'}</div>
</div>
),
},
{
label: (
<div className="flex items-center w-full">
- <Link to={posthog?.get_session_replay_url()} target="_blank">
+ <Link to={info.sessionReplayUrl ?? undefined} target="_blank">
View current session recording
</Link>
</div>
diff --git a/frontend/src/toolbar/bar/piiMaskingStyles.ts b/frontend/src/toolbar/bar/piiMaskingStyles.ts
index a92743fc1b83..6f6be51c718e 100644
--- a/frontend/src/toolbar/bar/piiMaskingStyles.ts
+++ b/frontend/src/toolbar/bar/piiMaskingStyles.ts
@@ -136,3 +136,57 @@ export const PII_MASKING_PRESET_COLORS = [
{ label: 'Purple', value: '#9988aa' },
{ label: 'Orange', value: '#aa9988' },
] as const
+
+export const getPiiMaskingWarnings = (posthog: PostHog): string[] => {
+ const warnings: string[] = []
+ if (posthog.sessionRecording?.status === 'active') {
+ if (
+ posthog.config.session_recording?.blockClass !== undefined &&
+ typeof posthog.config.session_recording?.blockClass !== 'string'
+ ) {
+ warnings.push(
+ "The toolbar's PII masking tool doesn't support non-string `session_recording.blockClass`. If you want to use PII masking, please set it to a string, or file a feature request at https://posthog.com/roadmap."
+ )
+ }
+ if (
+ posthog.config.session_recording?.maskTextClass !== undefined &&
+ typeof posthog.config.session_recording?.maskTextClass !== 'string'
+ ) {
+ warnings.push(
+ "The toolbar's PII masking tool doesn't support non-string `session_recording.maskTextClass`. If you want to use PII masking, please set it to a string, or file a feature request at https://posthog.com/roadmap."
+ )
+ }
+ if (
+ posthog.config.session_recording?.maskTextSelector !== undefined &&
+ typeof posthog.config.session_recording?.maskTextSelector !== 'string'
+ ) {
+ warnings.push(
+ "The toolbar's PII masking tool doesn't support non-string `session_recording.maskTextSelector`. If you want to use PII masking, please set it to a string, or file a feature request at https://posthog.com/roadmap."
+ )
+ }
+ }
+
+ return warnings
+}
+
+export const DEFAULT_PII_MASKING_COLOR = '#888888'
+
+/** Adds, updates or removes the masking preview stylesheet in the page's head. */
+export function applyPiiMaskingStylesheet(
+ styleId: string,
+ enabled: boolean,
+ color: string,
+ posthog: PostHog | null
+): void {
+ const existing = document.getElementById(styleId)
+ if (!enabled) {
+ existing?.remove()
+ return
+ }
+ const styleElement = existing ?? document.createElement('style')
+ styleElement.id = styleId
+ styleElement.textContent = generatePiiMaskingCSS(color, posthog)
+ if (!existing) {
+ document.head.appendChild(styleElement)
+ }
+}
diff --git a/frontend/src/toolbar/bar/toolbarLogic.ts b/frontend/src/toolbar/bar/toolbarLogic.ts
index 6d3e33e51485..3fb1d6cbdf9b 100644
--- a/frontend/src/toolbar/bar/toolbarLogic.ts
+++ b/frontend/src/toolbar/bar/toolbarLogic.ts
@@ -26,7 +26,7 @@ import { AvailableFeature } from '~/types'
import type { CommonFilters, HeatmapFilters, HeatmapFixedPositionMode } from '../../lib/components/heatmaps/types'
import type { HedgehogModeInterface } from '../../lib/components/HedgehogMode/types'
import type { ActionType } from '../../types'
-import { generatePiiMaskingCSS } from './piiMaskingStyles'
+import { DEFAULT_PII_MASKING_COLOR, applyPiiMaskingStylesheet, getPiiMaskingWarnings } from './piiMaskingStyles'
const MARGIN = 2
const HEDGEHOG_OFFSET = 80
@@ -521,7 +521,7 @@ export const toolbarLogic = kea<toolbarLogicType>([
},
],
piiMaskingColor: [
- '#888888' as string,
+ DEFAULT_PII_MASKING_COLOR as string,
{ persist: true },
{
setPiiMaskingColor: (_, { color }) => color,
@@ -699,36 +699,7 @@ export const toolbarLogic = kea<toolbarLogicType>([
if (!posthog || !piiMaskingEnabled) {
return null
}
-
- const warnings: string[] = []
- if (posthog.sessionRecording?.status === 'active') {
- if (
- posthog.config.session_recording?.blockClass !== undefined &&
- typeof posthog.config.session_recording?.blockClass !== 'string'
- ) {
- warnings.push(
- "The toolbar's PII masking tool doesn't support non-string `session_recording.blockClass`. If you want to use PII masking, please set it to a string, or file a feature request at https://posthog.com/roadmap."
- )
- }
- if (
- posthog.config.session_recording?.maskTextClass !== undefined &&
- typeof posthog.config.session_recording?.maskTextClass !== 'string'
- ) {
- warnings.push(
- "The toolbar's PII masking tool doesn't support non-string `session_recording.maskTextClass`. If you want to use PII masking, please set it to a string, or file a feature request at https://posthog.com/roadmap."
- )
- }
- if (
- posthog.config.session_recording?.maskTextSelector !== undefined &&
- typeof posthog.config.session_recording?.maskTextSelector !== 'string'
- ) {
- warnings.push(
- "The toolbar's PII masking tool doesn't support non-string `session_recording.maskTextSelector`. If you want to use PII masking, please set it to a string, or file a feature request at https://posthog.com/roadmap."
- )
- }
- }
-
- return warnings
+ return getPiiMaskingWarnings(posthog)
},
],
isLoading: [
@@ -950,30 +921,15 @@ export const toolbarLogic = kea<toolbarLogicType>([
})
},
togglePiiMasking: () => {
- const styleElement = document.getElementById(PII_MASKING_STYLESHEET_ID) as HTMLStyleElement | null
-
- if (values.piiMaskingEnabled) {
- const css = generatePiiMaskingCSS(values.piiMaskingColor, values.posthog)
- if (!styleElement) {
- const newStyleElement = document.createElement('style')
- newStyleElement.id = PII_MASKING_STYLESHEET_ID
- document.head.appendChild(newStyleElement)
- newStyleElement.textContent = css
- } else {
- styleElement.textContent = css
- }
- } else {
- if (styleElement) {
- styleElement.remove()
- }
- }
+ applyPiiMaskingStylesheet(
+ PII_MASKING_STYLESHEET_ID,
+ values.piiMaskingEnabled,
+ values.piiMaskingColor,
+ values.posthog
+ )
},
- setPiiMaskingColor: async ({ color }) => {
- const styleElement = document.getElementById(PII_MASKING_STYLESHEET_ID) as HTMLStyleElement | null
-
- if (styleElement && values.piiMaskingEnabled) {
- styleElement.textContent = generatePiiMaskingCSS(color, values.posthog)
- }
+ setPiiMaskingColor: ({ color }) => {
+ applyPiiMaskingStylesheet(PII_MASKING_STYLESHEET_ID, values.piiMaskingEnabled, color, values.posthog)
},
startGracefulExit: () => {
actions.setVisibleMenu('none')
@@ -1036,22 +992,13 @@ export const toolbarLogic = kea<toolbarLogicType>([
// Initialize PII masking if already enabled
// Remove stylesheet on unmount
cache.disposables.add(() => {
- if (values.piiMaskingEnabled) {
- let styleElement = document.getElementById(PII_MASKING_STYLESHEET_ID) as HTMLStyleElement | null
- if (!styleElement) {
- styleElement = document.createElement('style')
- styleElement.id = PII_MASKING_STYLESHEET_ID
- document.head.appendChild(styleElement)
- }
- styleElement.textContent = generatePiiMaskingCSS(values.piiMaskingColor, values.posthog)
- }
-
- return () => {
- const styleElement = document.getElementById(PII_MASKING_STYLESHEET_ID)
- if (styleElement) {
- styleElement.remove()
- }
- }
+ applyPiiMaskingStylesheet(
+ PII_MASKING_STYLESHEET_ID,
+ values.piiMaskingEnabled,
+ values.piiMaskingColor,
+ values.posthog
+ )
+ return () => applyPiiMaskingStylesheet(PII_MASKING_STYLESHEET_ID, false, values.piiMaskingColor, null)
}, 'piiMasking')
// the toolbar can be run within the posthog parent app
diff --git a/frontend/src/toolbar/debug/EventDebugMenu.tsx b/frontend/src/toolbar/debug/EventDebugMenu.tsx
index 7d79a8769a61..06f53d794343 100644
--- a/frontend/src/toolbar/debug/EventDebugMenu.tsx
+++ b/frontend/src/toolbar/debug/EventDebugMenu.tsx
@@ -1,194 +1,21 @@
import clsx from 'clsx'
import { useActions, useValues } from 'kea'
-import {
- BaseIcon,
- IconCheck,
- IconChevronDown,
- IconClock,
- IconCopy,
- IconDownload,
- IconEye,
- IconHide,
- IconLogomark,
- IconPause,
- IconPin,
- IconPinFilled,
- IconPlay,
- IconTrash,
- IconVideoCamera,
- IconX,
-} from '@posthog/icons'
+import { IconClock, IconDownload, IconEye, IconHide, IconPause, IconPlay, IconTrash, IconX } from '@posthog/icons'
import { SettingsBar, SettingsMenu } from 'lib/components/PanelSettings/PanelSettings'
-import { PropertyKeyInfo } from 'lib/components/PropertyKeyInfo'
-import { SimpleKeyValueList } from 'lib/components/SimpleKeyValueList'
-import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
-import { dayjs } from 'lib/dayjs'
-import { IconUnverifiedEvent } from 'lib/lemon-ui/icons'
import { LemonInput } from 'lib/lemon-ui/LemonInput'
-import { LemonMenuItem } from 'lib/lemon-ui/LemonMenu'
import { Tooltip } from 'lib/lemon-ui/Tooltip'
import { toolbarLogic } from '~/toolbar/bar/toolbarLogic'
-import { classifyEvent, EventCategory, eventDebugMenuLogic } from '~/toolbar/debug/eventDebugMenuLogic'
+import { downloadEventsAsJson } from '~/toolbar/debug/downloadEventsAsJson'
+import { eventTypeMenuItems, hidePropertiesMenuItems } from '~/toolbar/debug/eventDebugMenuItems'
+import { eventDebugMenuLogic } from '~/toolbar/debug/eventDebugMenuLogic'
+import { EventRow } from '~/toolbar/debug/EventRow'
import { EventType } from '~/types'
import { ToolbarMenu } from '../bar/ToolbarMenu'
-const EVENT_CATEGORY_COLORS: Record<EventCategory, string> = {
- posthog: '#5375FF',
- custom: '#43B573',
- snapshot: '#F1A82C',
-}
-
-function checkableMenuItem(
- label: string,
- count: number | null,
- icon: JSX.Element | null,
- isActive: boolean,
- onClick: () => void
-): LemonMenuItem {
- return {
- label: (
- <div className="w-full flex flex-row justify-between items-center">
- <div className="flex flex-row items-center gap-1">
- {isActive ? <IconCheck /> : <BaseIcon />}
- {icon}
- {label}
- </div>
- {count !== null && (
- <span
- // without setting fontVariant to none a single digit number between brackets gets rendered as a ligature
- // eslint-disable-next-line react/forbid-dom-props
- style={{ fontVariant: 'none' }}
- >
- ({count})
- </span>
- )}
- </div>
- ),
- active: isActive,
- onClick: onClick,
- }
-}
-
-function EventTimestamp({ e, relative }: { e: EventType; relative?: boolean }): JSX.Element {
- const ts = dayjs(e.timestamp)
-
- if (relative) {
- return <span className="whitespace-nowrap">{ts.fromNow()}</span>
- }
-
- let formatString = 'HH:mm:ss'
- if (!ts.isSame(dayjs(), 'day')) {
- formatString = 'ddd HH:mm:ss'
- }
-
- return (
- <span className="whitespace-nowrap">
- <span>{ts.format(formatString)}</span>
- <span className="text-xxs text-secondary">{ts.format('.SSS')}</span>
- </span>
- )
-}
-
-function EventCategoryDot({ category }: { category: EventCategory }): JSX.Element {
- return (
- <span
- className="inline-block w-1.5 h-1.5 rounded-full shrink-0"
- // eslint-disable-next-line react/forbid-dom-props
- style={{ backgroundColor: EVENT_CATEGORY_COLORS[category] }}
- />
- )
-}
-
-function EventRow({
- e,
- expanded,
- isPinned,
- expandedProperties,
- searchText,
- relativeTimestamps,
- onToggleExpand,
- onTogglePin,
-}: {
- e: EventType
- expanded: boolean
- isPinned: boolean
- expandedProperties: any
- searchText: string
- relativeTimestamps: boolean
- onToggleExpand: () => void
- onTogglePin: (eventId: string) => void
-}): JSX.Element {
- const category = classifyEvent(e)
-
- const handleCopyPayload = (ev: React.MouseEvent): void => {
- ev.stopPropagation()
- const payload = { event: e.event, timestamp: e.timestamp, properties: e.properties, uuid: e.uuid }
- void navigator.clipboard.writeText(JSON.stringify(payload, null, 2))
- }
-
- return (
- <div
- className={clsx('group/row -mx-1 py-1 px-2 cursor-pointer rounded', isPinned && 'bg-surface-primary')}
- onClick={onToggleExpand}
- >
- <div className="flex flex-row justify-between items-center gap-2">
- <div className="flex flex-row items-center gap-1.5 min-w-0">
- <EventCategoryDot category={category} />
- <span className="truncate font-medium text-sm">
- <PropertyKeyInfo disableIcon value={e.event} type={TaxonomicFilterGroupType.Events} />
- </span>
- </div>
-
- <div className="flex flex-row items-center gap-1 shrink-0">
- <button
- className={clsx(
- 'flex items-center justify-center cursor-pointer',
- isPinned ? 'opacity-100' : 'opacity-0 group-hover/row:opacity-100'
- )}
- onClick={(ev) => {
- ev.stopPropagation()
- if (e.uuid) {
- onTogglePin(e.uuid)
- }
- }}
- title={isPinned ? 'Unpin event' : 'Pin event'}
- >
- {isPinned ? (
- <IconPinFilled className="text-warning text-sm" />
- ) : (
- <IconPin className="text-secondary text-sm" />
- )}
- </button>
- <EventTimestamp e={e} relative={relativeTimestamps} />
- <IconChevronDown className={clsx('text-secondary text-sm', expanded ? 'rotate-180' : '')} />
- </div>
- </div>
- {expanded && (
- <div className="my-1 ml-1 pl-2 border-l-2">
- <div className="flex justify-end mb-1">
- <button
- className="flex items-center gap-1 text-xxs text-secondary cursor-pointer hover:text-primary"
- onClick={handleCopyPayload}
- title="Copy event payload as JSON"
- >
- <IconCopy className="text-xs" />
- Copy payload
- </button>
- </div>
- <SimpleKeyValueList
- item={expandedProperties}
- emptyMessage={searchText ? 'No matching properties' : 'No properties'}
- />
- </div>
- )}
- </div>
- )
-}
-
function ToolbarIconButton({
onClick,
title,
@@ -247,49 +74,13 @@ export const EventDebugMenu = (): JSX.Element => {
} = useActions(eventDebugMenuLogic)
const { setVisibleMenu } = useActions(toolbarLogic)
- const handleExport = (): void => {
- const json = JSON.stringify(exportableEvents, null, 2)
- const blob = new Blob([json], { type: 'application/json' })
- const url = URL.createObjectURL(blob)
- const a = document.createElement('a')
- a.href = url
- a.download = `posthog-events-${dayjs().format('YYYY-MM-DD-HHmmss')}.json`
- a.click()
- URL.revokeObjectURL(url)
- }
-
- const showEventsMenuItems = [
- checkableMenuItem(
- 'PostHog events',
- searchFilteredEventsCount['posthog'],
- <IconLogomark />,
- selectedEventTypes.includes('posthog'),
- () => setSelectedEventType('posthog', !selectedEventTypes.includes('posthog'))
- ),
- checkableMenuItem(
- 'Custom events',
- searchFilteredEventsCount['custom'],
- <IconVideoCamera />,
- selectedEventTypes.includes('custom'),
- () => setSelectedEventType('custom', !selectedEventTypes.includes('custom'))
- ),
- checkableMenuItem(
- 'Replay events',
- searchFilteredEventsCount['snapshot'],
- <IconUnverifiedEvent />,
- selectedEventTypes.includes('snapshot'),
- () => setSelectedEventType('snapshot', !selectedEventTypes.includes('snapshot'))
- ),
- ]
-
- const hideThingsMenuItems = [
- checkableMenuItem('Hide PostHog properties', null, null, hidePostHogProperties, () =>
- setHidePostHogProperties(!hidePostHogProperties)
- ),
- checkableMenuItem('Hide PostHog flags', null, null, hidePostHogFlags, () =>
- setHidePostHogFlags(!hidePostHogFlags)
- ),
- ]
+ const showEventsMenuItems = eventTypeMenuItems(searchFilteredEventsCount, selectedEventTypes, setSelectedEventType)
+ const hideThingsMenuItems = hidePropertiesMenuItems(
+ hidePostHogProperties,
+ hidePostHogFlags,
+ setHidePostHogProperties,
+ setHidePostHogFlags
+ )
const renderEventRow = (e: EventType): JSX.Element => {
const expanded = e.uuid !== undefined && !isCollapsedEventRow(e.uuid)
@@ -398,7 +189,7 @@ export const EventDebugMenu = (): JSX.Element => {
label="Hide"
/>
<ToolbarIconButton
- onClick={handleExport}
+ onClick={() => downloadEventsAsJson(exportableEvents)}
title="Export events as JSON"
disabled={activeFilteredEvents.length === 0}
>
diff --git a/frontend/src/toolbar/debug/EventRow.tsx b/frontend/src/toolbar/debug/EventRow.tsx
new file mode 100644
index 000000000000..48acf1ac9d26
--- /dev/null
+++ b/frontend/src/toolbar/debug/EventRow.tsx
@@ -0,0 +1,133 @@
+import clsx from 'clsx'
+
+import { IconChevronDown, IconCopy, IconPin, IconPinFilled } from '@posthog/icons'
+
+import { PropertyKeyInfo } from 'lib/components/PropertyKeyInfo'
+import { SimpleKeyValueList } from 'lib/components/SimpleKeyValueList'
+import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
+import { dayjs } from 'lib/dayjs'
+
+import { classifyEvent, EventCategory } from '~/toolbar/debug/eventCategories'
+import { EventType } from '~/types'
+
+const EVENT_CATEGORY_COLORS: Record<EventCategory, string> = {
+ posthog: '#5375FF',
+ custom: '#43B573',
+ snapshot: '#F1A82C',
+}
+
+function EventTimestamp({ e, relative }: { e: EventType; relative?: boolean }): JSX.Element {
+ const ts = dayjs(e.timestamp)
+
+ if (relative) {
+ return <span className="whitespace-nowrap">{ts.fromNow()}</span>
+ }
+
+ let formatString = 'HH:mm:ss'
+ if (!ts.isSame(dayjs(), 'day')) {
+ formatString = 'ddd HH:mm:ss'
+ }
+
+ return (
+ <span className="whitespace-nowrap">
+ <span>{ts.format(formatString)}</span>
+ <span className="text-xxs text-secondary">{ts.format('.SSS')}</span>
+ </span>
+ )
+}
+
+function EventCategoryDot({ category }: { category: EventCategory }): JSX.Element {
+ return (
+ <span
+ className="inline-block w-1.5 h-1.5 rounded-full shrink-0"
+ // eslint-disable-next-line react/forbid-dom-props
+ style={{ backgroundColor: EVENT_CATEGORY_COLORS[category] }}
+ />
+ )
+}
+
+export function EventRow({
+ e,
+ expanded,
+ isPinned,
+ expandedProperties,
+ searchText,
+ relativeTimestamps,
+ onToggleExpand,
+ onTogglePin,
+}: {
+ e: EventType
+ expanded: boolean
+ isPinned: boolean
+ expandedProperties: any
+ searchText: string
+ relativeTimestamps: boolean
+ onToggleExpand: () => void
+ onTogglePin: (eventId: string) => void
+}): JSX.Element {
+ const category = classifyEvent(e)
+
+ const handleCopyPayload = (ev: React.MouseEvent): void => {
+ ev.stopPropagation()
+ const payload = { event: e.event, timestamp: e.timestamp, properties: e.properties, uuid: e.uuid }
+ void navigator.clipboard.writeText(JSON.stringify(payload, null, 2))
+ }
+
+ return (
+ <div
+ className={clsx('group/row -mx-1 py-1 px-2 cursor-pointer rounded', isPinned && 'bg-surface-primary')}
+ onClick={onToggleExpand}
+ >
+ <div className="flex flex-row justify-between items-center gap-2">
+ <div className="flex flex-row items-center gap-1.5 min-w-0">
+ <EventCategoryDot category={category} />
+ <span className="truncate font-medium text-sm">
+ <PropertyKeyInfo disableIcon value={e.event} type={TaxonomicFilterGroupType.Events} />
+ </span>
+ </div>
+
+ <div className="flex flex-row items-center gap-1 shrink-0">
+ <button
+ className={clsx(
+ 'flex items-center justify-center cursor-pointer',
+ isPinned ? 'opacity-100' : 'opacity-0 group-hover/row:opacity-100'
+ )}
+ onClick={(ev) => {
+ ev.stopPropagation()
+ if (e.uuid) {
+ onTogglePin(e.uuid)
+ }
+ }}
+ title={isPinned ? 'Unpin event' : 'Pin event'}
+ >
+ {isPinned ? (
+ <IconPinFilled className="text-warning text-sm" />
+ ) : (
+ <IconPin className="text-secondary text-sm" />
+ )}
+ </button>
+ <EventTimestamp e={e} relative={relativeTimestamps} />
+ <IconChevronDown className={clsx('text-secondary text-sm', expanded ? 'rotate-180' : '')} />
+ </div>
+ </div>
+ {expanded && (
+ <div className="my-1 ml-1 pl-2 border-l-2">
+ <div className="flex justify-end mb-1">
+ <button
+ className="flex items-center gap-1 text-xxs text-secondary cursor-pointer hover:text-primary"
+ onClick={handleCopyPayload}
+ title="Copy event payload as JSON"
+ >
+ <IconCopy className="text-xs" />
+ Copy payload
+ </button>
+ </div>
+ <SimpleKeyValueList
+ item={expandedProperties}
+ emptyMessage={searchText ? 'No matching properties' : 'No properties'}
+ />
+ </div>
+ )}
+ </div>
+ )
+}
diff --git a/frontend/src/toolbar/debug/downloadEventsAsJson.ts b/frontend/src/toolbar/debug/downloadEventsAsJson.ts
new file mode 100644
index 000000000000..89932c0fe663
--- /dev/null
+++ b/frontend/src/toolbar/debug/downloadEventsAsJson.ts
@@ -0,0 +1,12 @@
+import { dayjs } from 'lib/dayjs'
+
+export function downloadEventsAsJson(events: object[]): void {
+ const json = JSON.stringify(events, null, 2)
+ const blob = new Blob([json], { type: 'application/json' })
+ const url = URL.createObjectURL(blob)
+ const a = document.createElement('a')
+ a.href = url
+ a.download = `posthog-events-${dayjs().format('YYYY-MM-DD-HHmmss')}.json`
+ a.click()
+ URL.revokeObjectURL(url)
+}
diff --git a/frontend/src/toolbar/debug/eventCategories.ts b/frontend/src/toolbar/debug/eventCategories.ts
new file mode 100644
index 000000000000..fa7c4446c4d7
--- /dev/null
+++ b/frontend/src/toolbar/debug/eventCategories.ts
@@ -0,0 +1,14 @@
+import { CORE_FILTER_DEFINITIONS_BY_GROUP } from '~/taxonomy/taxonomy'
+import type { EventType } from '~/types'
+
+export type EventCategory = 'posthog' | 'custom' | 'snapshot'
+
+export function classifyEvent(e: EventType): EventCategory {
+ if (e.event === '$snapshot') {
+ return 'snapshot'
+ }
+ if (e.event.startsWith('$') || Object.keys(CORE_FILTER_DEFINITIONS_BY_GROUP.events).includes(e.event)) {
+ return 'posthog'
+ }
+ return 'custom'
+}
diff --git a/frontend/src/toolbar/debug/eventDebugMenuItems.tsx b/frontend/src/toolbar/debug/eventDebugMenuItems.tsx
new file mode 100644
index 000000000000..6b5420c7f033
--- /dev/null
+++ b/frontend/src/toolbar/debug/eventDebugMenuItems.tsx
@@ -0,0 +1,83 @@
+import { BaseIcon, IconCheck, IconLogomark, IconVideoCamera } from '@posthog/icons'
+
+import { IconUnverifiedEvent } from 'lib/lemon-ui/icons'
+import { LemonMenuItem } from 'lib/lemon-ui/LemonMenu'
+
+import { EventCategory } from '~/toolbar/debug/eventCategories'
+
+function checkableMenuItem(
+ label: string,
+ count: number | null,
+ icon: JSX.Element | null,
+ isActive: boolean,
+ onClick: () => void
+): LemonMenuItem {
+ return {
+ label: (
+ <div className="w-full flex flex-row justify-between items-center">
+ <div className="flex flex-row items-center gap-1">
+ {isActive ? <IconCheck /> : <BaseIcon />}
+ {icon}
+ {label}
+ </div>
+ {count !== null && (
+ <span
+ // without setting fontVariant to none a single digit number between brackets gets rendered as a ligature
+ // eslint-disable-next-line react/forbid-dom-props
+ style={{ fontVariant: 'none' }}
+ >
+ ({count})
+ </span>
+ )}
+ </div>
+ ),
+ active: isActive,
+ onClick: onClick,
+ }
+}
+
+export function eventTypeMenuItems(
+ counts: Record<EventCategory, number>,
+ selectedEventTypes: EventCategory[],
+ setSelectedEventType: (eventType: EventCategory, enabled: boolean) => void
+): LemonMenuItem[] {
+ return [
+ checkableMenuItem(
+ 'PostHog events',
+ counts['posthog'],
+ <IconLogomark />,
+ selectedEventTypes.includes('posthog'),
+ () => setSelectedEventType('posthog', !selectedEventTypes.includes('posthog'))
+ ),
+ checkableMenuItem(
+ 'Custom events',
+ counts['custom'],
+ <IconVideoCamera />,
+ selectedEventTypes.includes('custom'),
+ () => setSelectedEventType('custom', !selectedEventTypes.includes('custom'))
+ ),
+ checkableMenuItem(
+ 'Replay events',
+ counts['snapshot'],
+ <IconUnverifiedEvent />,
+ selectedEventTypes.includes('snapshot'),
+ () => setSelectedEventType('snapshot', !selectedEventTypes.includes('snapshot'))
+ ),
+ ]
+}
+
+export function hidePropertiesMenuItems(
+ hidePostHogProperties: boolean,
+ hidePostHogFlags: boolean,
+ setHidePostHogProperties: (hide: boolean) => void,
+ setHidePostHogFlags: (hide: boolean) => void
+): LemonMenuItem[] {
+ return [
+ checkableMenuItem('Hide PostHog properties', null, null, hidePostHogProperties, () =>
+ setHidePostHogProperties(!hidePostHogProperties)
+ ),
+ checkableMenuItem('Hide PostHog flags', null, null, hidePostHogFlags, () =>
+ setHidePostHogFlags(!hidePostHogFlags)
+ ),
+ ]
+}
diff --git a/frontend/src/toolbar/debug/eventDebugMenuLogic.test.ts b/frontend/src/toolbar/debug/eventDebugMenuLogic.test.ts
index 26901bf6b84f..477a1651a89c 100644
--- a/frontend/src/toolbar/debug/eventDebugMenuLogic.test.ts
+++ b/frontend/src/toolbar/debug/eventDebugMenuLogic.test.ts
@@ -1,7 +1,8 @@
import { expectLogic } from 'kea-test-utils'
import { initKeaTests } from '~/test/init'
-import { classifyEvent, eventDebugMenuLogic } from '~/toolbar/debug/eventDebugMenuLogic'
+import { classifyEvent } from '~/toolbar/debug/eventCategories'
+import { eventDebugMenuLogic } from '~/toolbar/debug/eventDebugMenuLogic'
import { toolbarConfigLogic } from '~/toolbar/toolbarConfigLogic'
import { EventType } from '~/types'
diff --git a/frontend/src/toolbar/debug/eventDebugMenuLogic.ts b/frontend/src/toolbar/debug/eventDebugMenuLogic.ts
index 62729a03f54a..9f0eeedd6dc0 100644
--- a/frontend/src/toolbar/debug/eventDebugMenuLogic.ts
+++ b/frontend/src/toolbar/debug/eventDebugMenuLogic.ts
@@ -5,7 +5,8 @@ import { uuid } from 'lib/utils/dom'
import { permanentlyMount } from 'lib/utils/kea-logic-builders'
import { CLOUD_INTERNAL_POSTHOG_PROPERTY_KEYS } from '~/taxonomy/taxonomy'
-import { CORE_FILTER_DEFINITIONS_BY_GROUP, PROPERTY_KEYS } from '~/taxonomy/taxonomy'
+import { PROPERTY_KEYS } from '~/taxonomy/taxonomy'
+import { EventCategory, classifyEvent } from '~/toolbar/debug/eventCategories'
import { toolbarConfigLogic } from '~/toolbar/toolbarConfigLogic'
import { EventType } from '~/types'
@@ -27,18 +28,6 @@ function tryRegexMatch(text: string, pattern: string): boolean {
const MAX_EVENTS = 5000
-export type EventCategory = 'posthog' | 'custom' | 'snapshot'
-
-export function classifyEvent(e: EventType): EventCategory {
- if (e.event === '$snapshot') {
- return 'snapshot'
- }
- if (e.event.startsWith('$') || Object.keys(CORE_FILTER_DEFINITIONS_BY_GROUP.events).includes(e.event)) {
- return 'posthog'
- }
- return 'custom'
-}
-
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface eventDebugMenuLogicValues {
posthog: PostHog | null // toolbarConfigLogic
diff --git a/frontend/src/toolbar/debug/posthogDebugInfo.ts b/frontend/src/toolbar/debug/posthogDebugInfo.ts
new file mode 100644
index 000000000000..6a084add156a
--- /dev/null
+++ b/frontend/src/toolbar/debug/posthogDebugInfo.ts
@@ -0,0 +1,48 @@
+/** The parts of posthog-js that the toolbar's debug info reads. Any posthog-js version on a page fits it. */
+export interface DebugInfoPosthog {
+ version?: string
+ config?: { api_host?: string; ui_host?: string | null; rageclick?: unknown }
+ autocapture?: { isEnabled?: boolean }
+ deadClicksAutocapture?: { lazyLoadedDeadClicksAutocapture?: unknown }
+ heatmaps?: { isEnabled?: boolean }
+ sessionRecording?: { started?: boolean; status?: string }
+ get_session_replay_url?: () => string
+}
+
+export interface PosthogDebugInfo {
+ version: string | null
+ apiHost: string | null
+ uiHost: string | null
+ autocapture: boolean
+ rageclicks: boolean
+ deadClicks: boolean
+ heatmaps: boolean
+ sessionRecordingStarted: boolean
+ sessionRecordingStatus: string | null
+ sessionReplayUrl: string | null
+}
+
+/** A page can replace any of these with a getter that throws, so each read stands alone. */
+function read<T>(get: () => T | null | undefined): T | null {
+ try {
+ return get() ?? null
+ } catch {
+ return null
+ }
+}
+
+export function readPosthogDebugInfo(posthog: DebugInfoPosthog | null): PosthogDebugInfo {
+ const autocapture = !!read(() => posthog?.autocapture?.isEnabled)
+ return {
+ version: read(() => posthog?.version),
+ apiHost: read(() => posthog?.config?.api_host),
+ uiHost: read(() => posthog?.config?.ui_host),
+ autocapture,
+ rageclicks: autocapture && !!read(() => posthog?.config?.rageclick),
+ deadClicks: !!read(() => posthog?.deadClicksAutocapture?.lazyLoadedDeadClicksAutocapture),
+ heatmaps: !!read(() => posthog?.heatmaps?.isEnabled),
+ sessionRecordingStarted: !!read(() => posthog?.sessionRecording?.started),
+ sessionRecordingStatus: read(() => posthog?.sessionRecording?.status),
+ sessionReplayUrl: read(() => posthog?.get_session_replay_url?.()),
+ }
+}
diff --git a/frontend/src/toolbar/experiments/ExperimentsEditingToolbarMenu.tsx b/frontend/src/toolbar/experiments/ExperimentsEditingToolbarMenu.tsx
index eb6e501237c3..634ed8d7ca02 100644
--- a/frontend/src/toolbar/experiments/ExperimentsEditingToolbarMenu.tsx
+++ b/frontend/src/toolbar/experiments/ExperimentsEditingToolbarMenu.tsx
@@ -10,6 +10,7 @@ import { LemonInput } from 'lib/lemon-ui/LemonInput'
import { LemonLabel } from 'lib/lemon-ui/LemonLabel'
import { ToolbarMenu } from '~/toolbar/bar/ToolbarMenu'
+import { ExperimentsTabEditorProvider } from '~/toolbar/experiments/ExperimentsTabEditorProvider'
import { experimentsTabLogic } from '~/toolbar/experiments/experimentsTabLogic'
import { WebExperimentVariant } from '~/toolbar/experiments/WebExperimentVariant'
import { WebExperimentVariantHeader } from '~/toolbar/experiments/WebExperimentVariantHeader'
@@ -77,7 +78,7 @@ export const ExperimentsEditingToolbarMenu = (): JSX.Element => {
)}
</div>
<Group name="variants">
- <div>
+ <ExperimentsTabEditorProvider>
<LemonCollapse
size="medium"
activeKey={selectedVariant}
@@ -106,7 +107,7 @@ export const ExperimentsEditingToolbarMenu = (): JSX.Element => {
}
})}
/>
- </div>
+ </ExperimentsTabEditorProvider>
</Group>
</div>
</div>
diff --git a/frontend/src/toolbar/experiments/ExperimentsTabEditorProvider.tsx b/frontend/src/toolbar/experiments/ExperimentsTabEditorProvider.tsx
new file mode 100644
index 000000000000..1b38e73cd30d
--- /dev/null
+++ b/frontend/src/toolbar/experiments/ExperimentsTabEditorProvider.tsx
@@ -0,0 +1,109 @@
+import { useActions, useValues } from 'kea'
+import { useMemo } from 'react'
+
+import { experimentsTabLogic } from '~/toolbar/experiments/experimentsTabLogic'
+import { setSanitizedHTML, setSanitizedStyle } from '~/toolbar/experiments/sanitize'
+import {
+ WebExperimentEditor,
+ WebExperimentEditorContext,
+ canRenameVariant,
+} from '~/toolbar/experiments/webExperimentEditorContext'
+
+/** Binds the web experiment editor components to the floating toolbar's experiment form. */
+export function ExperimentsTabEditorProvider({ children }: { children: React.ReactNode }): JSX.Element {
+ const {
+ experimentForm,
+ selectedExperimentId,
+ selectedVariant,
+ selectedElementType,
+ inspectingElement,
+ removeVariantAvailable,
+ } = useValues(experimentsTabLogic)
+ const {
+ setExperimentFormValue,
+ removeVariant,
+ addNewTransformation,
+ removeElement,
+ selectElementType,
+ selectVariant,
+ inspectForElementWithIndex,
+ inspectElementSelected,
+ } = useActions(experimentsTabLogic)
+
+ const editor = useMemo((): WebExperimentEditor => {
+ const variants = experimentForm.variants ?? {}
+ return {
+ variants,
+ selectedExperimentId,
+ selectedVariant,
+ selectedElementType,
+ inspectingElement,
+ removeVariantAvailable: !!removeVariantAvailable,
+ renameVariant: (variant, newKey) => {
+ if (!canRenameVariant(variants, variant, newKey)) {
+ return false
+ }
+ setExperimentFormValue(
+ 'variants',
+ Object.fromEntries(
+ Object.entries(variants).map(([key, value]) => [key === variant ? newKey : key, value])
+ )
+ )
+ return true
+ },
+ removeVariant,
+ addTransformation: addNewTransformation,
+ removeTransformation: removeElement,
+ selectElementType,
+ inspectForTransformation: (variant, index) => {
+ selectVariant(variant)
+ inspectForElementWithIndex(variant, selectedElementType, index)
+ },
+ setTransformationField: (variant, index, field, value) => {
+ const webVariant = variants[variant]
+ if (!webVariant) {
+ return
+ }
+ setExperimentFormValue('variants', {
+ ...variants,
+ [variant]: {
+ ...webVariant,
+ transforms: webVariant.transforms.map((t, i) => (i === index ? { ...t, [field]: value } : t)),
+ },
+ })
+ const selector = webVariant.transforms[index]?.selector
+ const element = selector ? (document.querySelector(selector) as HTMLElement | null) : null
+ if (element) {
+ if (field === 'html') {
+ setSanitizedHTML(element, value)
+ } else {
+ setSanitizedStyle(element, value)
+ }
+ }
+ },
+ setTransformationSelector: (variant, index, selector) => {
+ const element = document.querySelector(selector)
+ if (element) {
+ inspectElementSelected(element as HTMLElement, variant, index, selector)
+ }
+ },
+ }
+ }, [
+ experimentForm.variants,
+ selectedExperimentId,
+ selectedVariant,
+ selectedElementType,
+ inspectingElement,
+ removeVariantAvailable,
+ setExperimentFormValue,
+ removeVariant,
+ addNewTransformation,
+ removeElement,
+ selectElementType,
+ selectVariant,
+ inspectForElementWithIndex,
+ inspectElementSelected,
+ ])
+
+ return <WebExperimentEditorContext.Provider value={editor}>{children}</WebExperimentEditorContext.Provider>
+}
diff --git a/frontend/src/toolbar/experiments/SelectorEditor.tsx b/frontend/src/toolbar/experiments/SelectorEditor.tsx
index da5f7428940e..3095722b78ed 100644
--- a/frontend/src/toolbar/experiments/SelectorEditor.tsx
+++ b/frontend/src/toolbar/experiments/SelectorEditor.tsx
@@ -1,5 +1,4 @@
-import { useActions } from 'kea'
-import { useMemo, useState } from 'react'
+import { useContext, useEffect, useState } from 'react'
import { IconPencil } from '@posthog/icons'
@@ -7,7 +6,8 @@ import { LemonButton } from 'lib/lemon-ui/LemonButton'
import { LemonInput } from 'lib/lemon-ui/LemonInput'
import { LemonModal } from 'lib/lemon-ui/LemonModal'
-import { experimentsTabLogic } from './experimentsTabLogic'
+import { SelectorCountContext } from '~/toolbar/actions/SelectorCountContext'
+import { useWebExperimentEditor } from '~/toolbar/experiments/webExperimentEditorContext'
interface SelectorEditorProps {
selector: string | null
@@ -16,21 +16,19 @@ interface SelectorEditorProps {
}
export function SelectorEditor({ selector, variant, transformIndex }: SelectorEditorProps): JSX.Element {
- const { inspectElementSelected } = useActions(experimentsTabLogic)
+ const { setTransformationSelector } = useWebExperimentEditor()
+ const counter = useContext(SelectorCountContext)
const [editSelectorOpen, setEditSelectorOpen] = useState(false)
const [editSelectorValue, setEditSelectorValue] = useState('')
- const isValidSelector = useMemo(() => {
- if (!editSelectorValue) {
- return false
+ useEffect(() => {
+ if (editSelectorOpen && editSelectorValue) {
+ counter.request(editSelectorValue)
}
- try {
- return !!document.querySelector(editSelectorValue)
- } catch {
- return false
- }
- }, [editSelectorValue])
+ }, [editSelectorOpen, editSelectorValue, counter])
+ // posthog-js applies web experiments with document.querySelectorAll, which skips shadow roots.
+ const isValidSelector = !!editSelectorValue && !!counter.count(editSelectorValue, 'document')
return (
<>
@@ -55,12 +53,7 @@ export function SelectorEditor({ selector, variant, transformIndex }: SelectorEd
type="primary"
onClick={() => {
setEditSelectorOpen(false)
- inspectElementSelected(
- document.querySelector(editSelectorValue) as HTMLElement,
- variant,
- transformIndex,
- editSelectorValue
- )
+ setTransformationSelector(variant, transformIndex, editSelectorValue)
}}
disabledReason={
!isValidSelector
diff --git a/frontend/src/toolbar/experiments/WebExperimentTransformField.tsx b/frontend/src/toolbar/experiments/WebExperimentTransformField.tsx
index 0712d7a9b2c4..7b6e403aae08 100644
--- a/frontend/src/toolbar/experiments/WebExperimentTransformField.tsx
+++ b/frontend/src/toolbar/experiments/WebExperimentTransformField.tsx
@@ -1,22 +1,12 @@
-import { useActions, useValues } from 'kea'
-
import { IconCursorClick } from '@posthog/icons'
import { LemonLabel, LemonSelect } from '@posthog/lemon-ui'
import { LemonButton } from 'lib/lemon-ui/LemonButton'
import { LemonTextArea } from 'lib/lemon-ui/LemonTextArea/LemonTextArea'
-import {
- ElementSelectorButtonTypes,
- ElementSelectorType,
- experimentsTabLogic,
-} from '~/toolbar/experiments/experimentsTabLogic'
-import {
- htmlSanitizationWouldStrip,
- setSanitizedHTML,
- setSanitizedStyle,
- styleSanitizationWouldStrip,
-} from '~/toolbar/experiments/sanitize'
+import { ElementSelectorButtonTypes, ElementSelectorType } from '~/toolbar/experiments/elementSelectorTypes'
+import { htmlSanitizationWouldStrip, styleSanitizationWouldStrip } from '~/toolbar/experiments/sanitize'
+import { useWebExperimentEditor } from '~/toolbar/experiments/webExperimentEditorContext'
import { WebExperimentTransform } from '~/toolbar/types'
interface WebExperimentTransformFieldProps {
@@ -30,9 +20,15 @@ export function WebExperimentTransformField({
transformIndex,
transform,
}: WebExperimentTransformFieldProps): JSX.Element {
- const { experimentForm, inspectingElement, selectedVariant, selectedElementType } = useValues(experimentsTabLogic)
- const { setExperimentFormValue, selectVariant, selectElementType, inspectForElementWithIndex } =
- useActions(experimentsTabLogic)
+ const {
+ inspectingElement,
+ selectedVariant,
+ selectedElementType,
+ selectElementType,
+ inspectForTransformation,
+ setTransformationField,
+ } = useWebExperimentEditor()
+ const isInspecting = inspectingElement === transformIndex && selectedVariant === variant
return (
<>
@@ -40,19 +36,10 @@ export function WebExperimentTransformField({
<LemonButton
icon={<IconCursorClick />}
size="small"
- type={inspectingElement === transformIndex && selectedVariant === variant ? 'primary' : 'secondary'}
- onClick={() => {
- selectVariant(variant)
- inspectForElementWithIndex(
- variant,
- selectedElementType as ElementSelectorType,
- inspectingElement === transformIndex ? null : transformIndex
- )
- }}
+ type={isInspecting ? 'primary' : 'secondary'}
+ onClick={() => inspectForTransformation(variant, isInspecting ? null : transformIndex)}
>
- {inspectingElement === transformIndex && selectedVariant === variant
- ? 'Selecting…'
- : 'Select element'}
+ {isInspecting ? 'Selecting…' : 'Select element'}
</LemonButton>
<LemonSelect
placeholder="Select element type"
@@ -71,27 +58,7 @@ export function WebExperimentTransformField({
<div className="mt-4">
<LemonLabel>Inner HTML</LemonLabel>
<LemonTextArea
- onChange={(value) => {
- // Update state
- const updatedVariants = {
- ...experimentForm.variants,
- [variant]: {
- ...experimentForm.variants[variant],
- transforms: experimentForm.variants[variant].transforms.map((t, i) =>
- i === transformIndex ? { ...t, html: value } : t
- ),
- },
- }
- setExperimentFormValue('variants', updatedVariants)
-
- // Update DOM
- const element = transform.selector
- ? (document.querySelector(transform.selector) as HTMLElement)
- : null
- if (element) {
- setSanitizedHTML(element, value)
- }
- }}
+ onChange={(value) => setTransformationField(variant, transformIndex, 'html', value)}
value={transform.html}
maxRows={8}
/>
@@ -104,29 +71,7 @@ export function WebExperimentTransformField({
<div className="mt-4">
<LemonLabel>CSS</LemonLabel>
<LemonTextArea
- onChange={(value) => {
- if (experimentForm.variants) {
- // Create new variants object with updated CSS
- const updatedVariants = {
- ...experimentForm.variants,
- [variant]: {
- ...experimentForm.variants[variant],
- transforms: experimentForm.variants[variant].transforms.map((t, i) =>
- i === transformIndex ? { ...t, css: value } : t
- ),
- },
- }
- setExperimentFormValue('variants', updatedVariants)
-
- // Update DOM
- const element = transform.selector
- ? (document.querySelector(transform.selector) as HTMLElement)
- : null
- if (element) {
- setSanitizedStyle(element, value)
- }
- }
- }}
+ onChange={(value) => setTransformationField(variant, transformIndex, 'css', value)}
value={transform.css || ''}
maxRows={8}
/>
diff --git a/frontend/src/toolbar/experiments/WebExperimentTransformHeader.tsx b/frontend/src/toolbar/experiments/WebExperimentTransformHeader.tsx
index b044e30113b3..059165885156 100644
--- a/frontend/src/toolbar/experiments/WebExperimentTransformHeader.tsx
+++ b/frontend/src/toolbar/experiments/WebExperimentTransformHeader.tsx
@@ -1,12 +1,10 @@
-import { useActions, useValues } from 'kea'
-
import { IconTrash } from '@posthog/icons'
import { Tooltip } from '@posthog/lemon-ui'
import { LemonButton } from 'lib/lemon-ui/LemonButton'
import { SelectorCount } from '~/toolbar/actions/SelectorCount'
-import { experimentsTabLogic } from '~/toolbar/experiments/experimentsTabLogic'
+import { useWebExperimentEditor } from '~/toolbar/experiments/webExperimentEditorContext'
import { WebExperimentTransform } from '~/toolbar/types'
import { SelectorEditor } from './SelectorEditor'
@@ -22,8 +20,7 @@ export function WebExperimentTransformHeader({
transformIndex,
transform,
}: WebExperimentTransformHeaderProps): JSX.Element {
- const { removeElement } = useActions(experimentsTabLogic)
- const { experimentForm } = useValues(experimentsTabLogic)
+ const { removeTransformation } = useWebExperimentEditor()
return (
<div className="flex w-full gap-4 items-center">
@@ -44,20 +41,18 @@ export function WebExperimentTransformHeader({
</div>
)}
- {experimentForm?.variants && (
- <LemonButton
- icon={<IconTrash />}
- size="small"
- className="shrink"
- noPadding
- status="danger"
- tooltip="Remove transformation"
- onClick={(e) => {
- e.stopPropagation()
- removeElement(variant, transformIndex)
- }}
- />
- )}
+ <LemonButton
+ icon={<IconTrash />}
+ size="small"
+ className="shrink"
+ noPadding
+ status="danger"
+ tooltip="Remove transformation"
+ onClick={(e) => {
+ e.stopPropagation()
+ removeTransformation(variant, transformIndex)
+ }}
+ />
</div>
)
}
diff --git a/frontend/src/toolbar/experiments/WebExperimentVariant.test.tsx b/frontend/src/toolbar/experiments/WebExperimentVariant.test.tsx
index 5d06d7aada8c..95ec922cc4f1 100644
--- a/frontend/src/toolbar/experiments/WebExperimentVariant.test.tsx
+++ b/frontend/src/toolbar/experiments/WebExperimentVariant.test.tsx
@@ -4,6 +4,7 @@ import { render, screen, within } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { initKeaTests } from '~/test/init'
+import { ExperimentsTabEditorProvider } from '~/toolbar/experiments/ExperimentsTabEditorProvider'
import { experimentsTabLogic } from '~/toolbar/experiments/experimentsTabLogic'
import { WebExperimentVariant } from '~/toolbar/experiments/WebExperimentVariant'
import { toolbarConfigLogic } from '~/toolbar/toolbarConfigLogic'
@@ -28,7 +29,11 @@ describe('WebExperimentVariant', () => {
it('opens the only transformation on mount', () => {
setVariantTransforms(['.headline'])
- render(<WebExperimentVariant variant="test" />)
+ render(
+ <ExperimentsTabEditorProvider>
+ <WebExperimentVariant variant="test" />
+ </ExperimentsTabEditorProvider>
+ )
expect(screen.getByText('Select element')).toBeInTheDocument()
})
@@ -36,7 +41,11 @@ describe('WebExperimentVariant', () => {
it('lets you open a later transformation once the variant has several', async () => {
setVariantTransforms(['.headline', '.subtitle'])
- render(<WebExperimentVariant variant="test" />)
+ render(
+ <ExperimentsTabEditorProvider>
+ <WebExperimentVariant variant="test" />
+ </ExperimentsTabEditorProvider>
+ )
await userEvent.click(screen.getByText('.subtitle'))
const secondPanel = screen.getByText('.subtitle').closest('.LemonCollapsePanel') as HTMLElement
diff --git a/frontend/src/toolbar/experiments/WebExperimentVariant.tsx b/frontend/src/toolbar/experiments/WebExperimentVariant.tsx
index 1da655e08ae5..889abe90a1af 100644
--- a/frontend/src/toolbar/experiments/WebExperimentVariant.tsx
+++ b/frontend/src/toolbar/experiments/WebExperimentVariant.tsx
@@ -1,4 +1,3 @@
-import { useActions, useValues } from 'kea'
import { useState } from 'react'
import { IconPlus } from '@posthog/icons'
@@ -8,7 +7,7 @@ import { LemonButton } from 'lib/lemon-ui/LemonButton'
import { LemonCollapse } from 'lib/lemon-ui/LemonCollapse'
import { LemonInput } from 'lib/lemon-ui/LemonInput/LemonInput'
-import { experimentsTabLogic } from '~/toolbar/experiments/experimentsTabLogic'
+import { useWebExperimentEditor } from '~/toolbar/experiments/webExperimentEditorContext'
import { WebExperimentTransformField } from '~/toolbar/experiments/WebExperimentTransformField'
import { WebExperimentTransformHeader } from '~/toolbar/experiments/WebExperimentTransformHeader'
@@ -17,12 +16,12 @@ interface WebExperimentVariantProps {
}
export function WebExperimentVariant({ variant }: WebExperimentVariantProps): JSX.Element {
- const { experimentForm, selectedExperimentId } = useValues(experimentsTabLogic)
+ const { variants, selectedExperimentId, renameVariant, addTransformation } = useWebExperimentEditor()
const [localTentativeValue, setLocalTentativeValue] = useState(variant)
- const { addNewTransformation, setExperimentFormValue } = useActions(experimentsTabLogic)
+ const transforms = variants[variant]?.transforms ?? []
return (
<div className="deprecated-space-y-4">
- {selectedExperimentId === 'new' && experimentForm.variants && experimentForm.variants[variant].is_new && (
+ {selectedExperimentId === 'new' && variants[variant]?.is_new && (
<div>
<LemonLabel>Variant key</LemonLabel>
<LemonInput
@@ -34,13 +33,8 @@ export function WebExperimentVariant({ variant }: WebExperimentVariantProps): JS
}}
onBlur={(e) => {
e.stopPropagation()
- if (experimentForm.variants && localTentativeValue !== variant) {
- const webVariant = experimentForm.variants[variant]
- if (webVariant) {
- experimentForm.variants[localTentativeValue] = webVariant
- delete experimentForm.variants[variant]
- setExperimentFormValue('variants', experimentForm.variants)
- }
+ if (localTentativeValue !== variant && !renameVariant(variant, localTentativeValue)) {
+ setLocalTentativeValue(variant)
}
}}
placeholder='Example: "test-1"'
@@ -55,20 +49,17 @@ export function WebExperimentVariant({ variant }: WebExperimentVariantProps): JS
icon={<IconPlus />}
onClick={(e) => {
e.stopPropagation()
- addNewTransformation(variant)
+ addTransformation(variant)
}}
>
Add transformation
</LemonButton>
</div>
- {experimentForm?.variants &&
- experimentForm?.variants[variant] &&
- experimentForm?.variants[variant].transforms &&
- experimentForm?.variants[variant].transforms?.length > 0 ? (
+ {transforms.length > 0 ? (
<LemonCollapse
size="small"
- defaultActiveKey={experimentForm?.variants[variant].transforms.length === 1 ? 0 : undefined}
- panels={experimentForm?.variants[variant].transforms.map((transform, transformIndex) => {
+ defaultActiveKey={transforms.length === 1 ? 0 : undefined}
+ panels={transforms.map((transform, transformIndex) => {
return {
key: transformIndex,
header: (
diff --git a/frontend/src/toolbar/experiments/WebExperimentVariantHeader.tsx b/frontend/src/toolbar/experiments/WebExperimentVariantHeader.tsx
index e5921248e7ea..14b96a9fb284 100644
--- a/frontend/src/toolbar/experiments/WebExperimentVariantHeader.tsx
+++ b/frontend/src/toolbar/experiments/WebExperimentVariantHeader.tsx
@@ -1,19 +1,16 @@
-import { useActions, useValues } from 'kea'
-
import { IconTrash } from '@posthog/icons'
import { LemonButton } from 'lib/lemon-ui/LemonButton'
import { LemonTag } from 'lib/lemon-ui/LemonTag'
-import { experimentsTabLogic } from '~/toolbar/experiments/experimentsTabLogic'
+import { useWebExperimentEditor } from '~/toolbar/experiments/webExperimentEditorContext'
interface WebExperimentVariantHeaderProps {
variant: string
}
export function WebExperimentVariantHeader({ variant }: WebExperimentVariantHeaderProps): JSX.Element {
- const { experimentForm, removeVariantAvailable, selectedVariant } = useValues(experimentsTabLogic)
- const { removeVariant } = useActions(experimentsTabLogic)
+ const { variants, removeVariantAvailable, selectedVariant, removeVariant } = useWebExperimentEditor()
return (
<div className="flex w-full items-center justify-between">
<div className="flex items-center gap-2">
@@ -26,13 +23,7 @@ export function WebExperimentVariantHeader({ variant }: WebExperimentVariantHead
</div>
<div className="flex items-center gap-2">
<LemonTag className="px-1 py-0.5 font-semibold" size="small" type="muted">
- <span>
- {`Rollout: ${
- experimentForm.variants && experimentForm.variants[variant]
- ? (experimentForm.variants[variant].rollout_percentage ?? 0)
- : 0
- } %`}
- </span>
+ <span>{`Rollout: ${variants[variant]?.rollout_percentage ?? 0} %`}</span>
</LemonTag>
{removeVariantAvailable && variant !== 'control' && (
<LemonButton
diff --git a/frontend/src/toolbar/experiments/elementSelectorTypes.ts b/frontend/src/toolbar/experiments/elementSelectorTypes.ts
new file mode 100644
index 000000000000..8951d795fe1a
--- /dev/null
+++ b/frontend/src/toolbar/experiments/elementSelectorTypes.ts
@@ -0,0 +1,8 @@
+export type ElementSelectorType = 'all-elements' | 'headers' | 'buttons' | 'images'
+
+export const ElementSelectorButtonTypes = {
+ 'all-elements': 'All Elements',
+ headers: 'Headers',
+ buttons: 'Buttons',
+ images: 'Images',
+}
diff --git a/frontend/src/toolbar/experiments/experimentsTabLogic.test.ts b/frontend/src/toolbar/experiments/experimentsTabLogic.test.ts
index f50cea511923..1a8c474b332f 100644
--- a/frontend/src/toolbar/experiments/experimentsTabLogic.test.ts
+++ b/frontend/src/toolbar/experiments/experimentsTabLogic.test.ts
@@ -144,6 +144,27 @@ describe('experimentsTabLogic', () => {
.toDispatchActions(['selectExperiment'])
})
+ it('does not restore a previous experiment snapshot after the page changed', async () => {
+ const heading = document.createElement('h1')
+ heading.textContent = 'Pricing page'
+ document.body.appendChild(heading)
+ try {
+ await expectLogic(theExperimentsLogic).toDispatchActions(['getExperimentsSuccess'])
+ theExperimentsTabLogic.actions.selectExperiment(2)
+ expect(theExperimentsTabLogic.values.experimentForm.original_html_state).toEqual({
+ h1: { html: 'Pricing page' },
+ })
+ theExperimentsTabLogic.actions.selectExperiment(null)
+ heading.textContent = 'Blog page'
+
+ theExperimentsTabLogic.actions.selectExperiment(1)
+
+ expect(heading.textContent).toEqual('Blog page')
+ } finally {
+ heading.remove()
+ }
+ })
+
it('can create a new experiment', async () => {
await expectLogic(theExperimentsTabLogic, () => {
theExperimentsTabLogic.actions.selectExperiment('new')
@@ -312,7 +333,9 @@ describe('experimentsTabLogic', () => {
await expectLogic(theExperimentsTabLogic, () => {
theExperimentsTabLogic.actions.submitExperimentForm()
- }).delay(0)
+ })
+ .toDispatchActions(['submitExperimentFormFailure'])
+ .toNotHaveDispatchedActions(['submitExperimentFormSuccess'])
expect(lemonToast.error).toHaveBeenCalledWith('Invalid experiment config')
})
@@ -387,6 +410,31 @@ describe('experimentsTabLogic', () => {
})
})
+ it('puts the page back when the user leaves a previewed experiment', async () => {
+ document.body.innerHTML = '<h1>Original headline</h1>'
+ await expectLogic(theExperimentsLogic, () => {
+ theExperimentsLogic.actions.getExperiments()
+ }).toDispatchActions(['getExperimentsSuccess'])
+
+ theExperimentsTabLogic.actions.selectExperiment(2)
+ theExperimentsTabLogic.actions.applyVariant('test')
+ expect(document.querySelector('h1')?.innerHTML).toEqual('<b> Hello world! </b>')
+
+ theExperimentsTabLogic.actions.selectExperiment(null)
+ expect(document.querySelector('h1')?.innerHTML).toEqual('Original headline')
+ })
+
+ it('keeps a new experiment form when the experiment list reloads', async () => {
+ theExperimentsTabLogic.actions.newExperiment()
+ theExperimentsTabLogic.actions.setExperimentFormValue('name', 'Shorter headline')
+
+ await expectLogic(theExperimentsLogic, () => {
+ theExperimentsLogic.actions.getExperiments()
+ }).toDispatchActions(['getExperimentsSuccess'])
+
+ expect(theExperimentsTabLogic.values.experimentForm.name).toEqual('Shorter headline')
+ })
+
it('can switch between variants', async () => {
await expectLogic(theExperimentsLogic, () => {
theExperimentsLogic.actions.getExperiments()
diff --git a/frontend/src/toolbar/experiments/experimentsTabLogic.tsx b/frontend/src/toolbar/experiments/experimentsTabLogic.tsx
index 778e6725d815..f08459167cf5 100644
--- a/frontend/src/toolbar/experiments/experimentsTabLogic.tsx
+++ b/frontend/src/toolbar/experiments/experimentsTabLogic.tsx
@@ -7,6 +7,7 @@ import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
import { EXPERIMENT_TARGET_SELECTOR } from 'lib/utils/actions'
import { toolbarLogic } from '~/toolbar/bar/toolbarLogic'
+import { ElementSelectorType } from '~/toolbar/experiments/elementSelectorTypes'
import { experimentsLogic } from '~/toolbar/experiments/experimentsLogic'
import {
sanitizeExperimentHTML,
@@ -46,20 +47,12 @@ const EXPERIMENT_HEADER_TARGETS = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']
const EXPERIMENT_BUTTON_TARGETS = ['input[type="button"]', 'button']
-export type ElementSelectorType = 'all-elements' | 'headers' | 'buttons' | 'images'
-
const ElementSelectorMap: Record<ElementSelectorType, string> = {
'all-elements': EXPERIMENT_TARGET_SELECTOR,
headers: EXPERIMENT_HEADER_TARGETS.join(','),
buttons: EXPERIMENT_BUTTON_TARGETS.join(','),
images: 'img',
}
-export const ElementSelectorButtonTypes = {
- 'all-elements': 'All Elements',
- headers: 'Headers',
- buttons: 'Buttons',
- images: 'Images',
-}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface experimentsTabLogicValues {
@@ -86,9 +79,10 @@ export interface experimentsTabLogicValues {
isExperimentFormValid: boolean
newExperimentForElement: HTMLElement | null
removeVariantAvailable: boolean | undefined
- selectedElementType: string
+ selectedElementType: ElementSelectorType
selectedExperiment: Experiment | WebExperimentDraftType | null
selectedExperimentId: number | 'new' | 'web' | null
+ selectedExperimentKey: string | null
selectedVariant: string
showExperimentFormErrors: boolean
showExperimentsTooltip: boolean
@@ -219,6 +213,10 @@ export interface experimentsTabLogicMeta {
selectedExperimentId: number | 'new' | 'web' | null,
allExperiments: WebExperiment[]
) => Experiment | WebExperimentDraftType | null
+ selectedExperimentKey: (
+ selectedExperimentId: number | 'new' | 'web' | null,
+ selectedExperiment: Experiment | WebExperimentDraftType | null
+ ) => string | null
}
}
@@ -229,6 +227,25 @@ export type experimentsTabLogicType = MakeLogicType<
experimentsTabLogicMeta
>
+/** Puts back the HTML and styles saved before a preview. Sanitizes once per selector and reuses it across matches. */
+export function restoreOriginalHtmlState(
+ originalHtmlState: WebExperimentForm['original_html_state'] | undefined
+): void {
+ Object.entries(originalHtmlState || {}).forEach(([selector, originalState]) => {
+ const sanitizedHtml = sanitizeExperimentHTML(originalState.html)
+ const sanitizedCss = sanitizeExperimentStyle(originalState.css)
+ document.querySelectorAll(selector).forEach((element) => {
+ const htmlElement = element as HTMLElement
+ htmlElement.innerHTML = sanitizedHtml
+ if (sanitizedCss) {
+ htmlElement.setAttribute('style', sanitizedCss)
+ } else {
+ htmlElement.removeAttribute('style')
+ }
+ })
+ })
+}
+
export const experimentsTabLogic = kea<experimentsTabLogicType>([
path(['toolbar', 'experiments', 'experimentsTabLogic']),
actions({
@@ -304,7 +321,7 @@ export const experimentsTabLogic = kea<experimentsTabLogicType>([
},
],
selectedElementType: [
- 'all-elements',
+ 'all-elements' as ElementSelectorType,
{
selectElementType: (_, { elementType }) => elementType,
},
@@ -372,7 +389,8 @@ export const experimentsTabLogic = kea<experimentsTabLogicType>([
})
if (!result.ok) {
- return
+ // Throwing makes the form report a failure instead of a successful submit.
+ throw new Error('Failed to save experiment')
}
const response = result.data
@@ -429,12 +447,23 @@ export const experimentsTabLogic = kea<experimentsTabLogicType>([
return allExperiments.find((a) => a.id === selectedExperimentId) || null
},
],
+ // A reloaded experiment list builds new experiment objects, which must not reset the form being edited.
+ selectedExperimentKey: [
+ (s) => [s.selectedExperimentId, s.selectedExperiment],
+ (
+ selectedExperimentId: number | 'new' | 'web' | null,
+ selectedExperiment: Experiment | WebExperimentDraftType | null
+ ): string | null => (selectedExperiment ? String(selectedExperimentId) : null),
+ ],
}),
- subscriptions(({ actions }) => ({
- selectedExperiment: (selectedExperiment: Experiment | WebExperimentDraftType | null) => {
+ subscriptions(({ actions, values }) => ({
+ selectedExperimentKey: () => {
+ // The page still shows the previous experiment's preview, so put its original HTML back first.
+ restoreOriginalHtmlState(values.experimentForm?.original_html_state)
+ const { selectedExperiment } = values
if (!selectedExperiment) {
- actions.setExperimentFormValues({ name: '', variants: {} })
+ actions.setExperimentFormValues({ name: '', variants: {}, original_html_state: {} })
} else {
// Build original_html_state from existing selectors
const original_html_state: Record<string, { html: string; css?: string }> = {}
@@ -482,12 +511,13 @@ export const experimentsTabLogic = kea<experimentsTabLogicType>([
actions.showButtonExperiments()
}
- toolbarLogic.actions.setVisibleMenu('experiments')
+ // The browser extension runs this logic without the floating toolbar's bar.
+ toolbarLogic.findMounted()?.actions.setVisibleMenu('experiments')
}
},
newExperiment: () => {
actions.showButtonExperiments()
- toolbarLogic.actions.setVisibleMenu('experiments')
+ toolbarLogic.findMounted()?.actions.setVisibleMenu('experiments')
},
inspectElementSelected: ({ element, variant, index, selector }) => {
if (values.experimentForm?.variants) {
@@ -558,25 +588,7 @@ export const experimentsTabLogic = kea<experimentsTabLogicType>([
if (values.experimentForm && values.experimentForm.variants) {
const selectedVariant = values.experimentForm.variants[newVariantKey]
if (selectedVariant) {
- // Restore original HTML state — sanitize once per selector, reuse across matches.
- Object.entries(values.experimentForm.original_html_state || {}).forEach(
- ([selector, originalState]) => {
- const sanitizedHtml = sanitizeExperimentHTML(originalState.html)
- const sanitizedCss = sanitizeExperimentStyle(originalState.css)
- const elements = document.querySelectorAll(selector)
- elements.forEach((element) => {
- const htmlElement = element as HTMLElement
- if (htmlElement) {
- htmlElement.innerHTML = sanitizedHtml
- if (sanitizedCss) {
- htmlElement.setAttribute('style', sanitizedCss)
- } else {
- htmlElement.removeAttribute('style')
- }
- }
- })
- }
- )
+ restoreOriginalHtmlState(values.experimentForm.original_html_state)
// Apply variant transforms — sanitize once per transform, reuse across matches.
selectedVariant.transforms?.forEach((transform) => {
diff --git a/frontend/src/toolbar/experiments/webExperimentEditorContext.ts b/frontend/src/toolbar/experiments/webExperimentEditorContext.ts
new file mode 100644
index 000000000000..c98cd68e8713
--- /dev/null
+++ b/frontend/src/toolbar/experiments/webExperimentEditorContext.ts
@@ -0,0 +1,49 @@
+import { createContext, useContext } from 'react'
+
+import type { WebExperimentVariant } from '~/toolbar/types'
+import type { ExperimentIdType } from '~/types'
+
+import type { ElementSelectorType } from './elementSelectorTypes'
+
+/**
+ * What the web experiment editor components read and change. The floating toolbar binds it to
+ * `experimentsTabLogic` in the page. The extension side panel binds it to the panel's copy of the form, and the page
+ * applies the changes.
+ */
+export interface WebExperimentEditor {
+ variants: Record<string, WebExperimentVariant>
+ selectedExperimentId: ExperimentIdType | null
+ selectedVariant: string
+ selectedElementType: ElementSelectorType
+ /** The transformation waiting for an element pick on the page. */
+ inspectingElement: number | null
+ removeVariantAvailable: boolean
+ /** Returns false when the rename is rejected, for example because another variant has the key. */
+ renameVariant: (variant: string, newKey: string) => boolean
+ removeVariant: (variant: string) => void
+ addTransformation: (variant: string) => void
+ removeTransformation: (variant: string, index: number) => void
+ selectElementType: (elementType: ElementSelectorType) => void
+ /** Pass a null index to stop picking. */
+ inspectForTransformation: (variant: string, index: number | null) => void
+ setTransformationField: (variant: string, index: number, field: 'html' | 'css', value: string) => void
+ setTransformationSelector: (variant: string, index: number, selector: string) => void
+}
+
+export function canRenameVariant(
+ variants: Record<string, WebExperimentVariant>,
+ variant: string,
+ newKey: string
+): boolean {
+ return !!variants[variant] && !!newKey && newKey !== variant && !variants[newKey]
+}
+
+export const WebExperimentEditorContext = createContext<WebExperimentEditor | null>(null)
+
+export function useWebExperimentEditor(): WebExperimentEditor {
+ const editor = useContext(WebExperimentEditorContext)
+ if (!editor) {
+ throw new Error('The web experiment editor components need a WebExperimentEditorContext provider')
+ }
+ return editor
+}
diff --git a/frontend/src/toolbar/extension/ExtensionDebugInfo.tsx b/frontend/src/toolbar/extension/ExtensionDebugInfo.tsx
new file mode 100644
index 000000000000..bf467f46e3df
--- /dev/null
+++ b/frontend/src/toolbar/extension/ExtensionDebugInfo.tsx
@@ -0,0 +1,87 @@
+import { useActions, useValues } from 'kea'
+
+import { IconCheck, IconRefresh, IconX } from '@posthog/icons'
+
+import { LemonButton } from 'lib/lemon-ui/LemonButton'
+import { Spinner } from 'lib/lemon-ui/Spinner'
+
+import { extensionMoreLogic } from './extensionMoreLogic'
+import { NoPagePosthogBanner } from './NoPagePosthogBanner'
+
+function DebugInfoRow({ label, value }: { label: string; value: string | boolean | number | null }): JSX.Element {
+ return (
+ <>
+ <dt className="text-secondary">{label}</dt>
+ <dd className="m-0 min-w-0 truncate text-right" translate="no">
+ {typeof value === 'boolean' ? (
+ value ? (
+ <IconCheck className="text-success" aria-label="On" />
+ ) : (
+ <IconX className="text-danger" aria-label="Off" />
+ )
+ ) : (
+ (value ?? 'Unknown')
+ )}
+ </dd>
+ </>
+ )
+}
+
+/** The posthog-js settings the toolbar's "Debug info" menu shows. */
+export function ExtensionDebugInfo(): JSX.Element {
+ const { moreState } = useValues(extensionMoreLogic)
+ const { sendMoreCommand, openSessionRecording } = useActions(extensionMoreLogic)
+ const debugInfo = moreState?.debugInfo ?? null
+ const loading = !moreState || moreState.debugInfoLoading
+
+ return (
+ <section className="flex flex-col gap-2">
+ <div className="flex items-center justify-between gap-2">
+ <h4 className="m-0 text-sm font-semibold">Debug info</h4>
+ <LemonButton
+ size="xsmall"
+ icon={<IconRefresh />}
+ tooltip="Read the page's settings again"
+ loading={loading}
+ onClick={() => sendMoreCommand({ type: 'reload-debug-info' })}
+ data-attr="toolbar-extension-debug-info-reload"
+ />
+ </div>
+ {debugInfo ? (
+ <>
+ <dl className="m-0 grid grid-cols-[auto_minmax(0,1fr)] gap-x-4 gap-y-1 text-xs">
+ <DebugInfoRow label="posthog-js version" value={debugInfo.version} />
+ <DebugInfoRow label="API host" value={debugInfo.apiHost} />
+ <DebugInfoRow label="UI host" value={debugInfo.uiHost ?? 'Not set'} />
+ <DebugInfoRow label="Autocapture" value={debugInfo.autocapture} />
+ <DebugInfoRow label="Rageclicks" value={debugInfo.rageclicks} />
+ <DebugInfoRow label="Dead clicks" value={debugInfo.deadClicks} />
+ <DebugInfoRow label="Heatmaps" value={debugInfo.heatmaps} />
+ <DebugInfoRow label="Surveys" value={debugInfo.surveysCount} />
+ <DebugInfoRow label="Session recording" value={debugInfo.sessionRecordingStarted} />
+ <DebugInfoRow label="Session recording status" value={debugInfo.sessionRecordingStatus} />
+ </dl>
+ <LemonButton
+ size="small"
+ type="secondary"
+ fullWidth
+ center
+ disabledReason={
+ debugInfo.sessionReplayUrl ? null : "The page's posthog-js has no session recording URL"
+ }
+ onClick={() => debugInfo.sessionReplayUrl && openSessionRecording(debugInfo.sessionReplayUrl)}
+ data-attr="toolbar-extension-view-session-recording"
+ >
+ View current session recording
+ </LemonButton>
+ </>
+ ) : loading ? (
+ <div className="flex justify-center p-2">
+ <Spinner />
+ </div>
+ ) : (
+ <NoPagePosthogBanner consequence="there is no debug info." />
+ )}
+ </section>
+ )
+}
diff --git a/frontend/src/toolbar/extension/ExtensionEntityList.tsx b/frontend/src/toolbar/extension/ExtensionEntityList.tsx
index f11738399ec9..974f6161c62c 100644
--- a/frontend/src/toolbar/extension/ExtensionEntityList.tsx
+++ b/frontend/src/toolbar/extension/ExtensionEntityList.tsx
@@ -28,7 +28,7 @@ interface ExtensionEntityListProps {
dataAttrs: { search: string; row: string; create: string; openSaved: string }
}
-/** The list a tool opens with: search, pick an item to edit it, or make a new one. */
+/** The list that opens the actions and experiments tools: search, pick an item to edit it, or make a new one. */
export function ExtensionEntityList({
noun,
pluralNoun,
diff --git a/frontend/src/toolbar/extension/ExtensionEventsMenu.tsx b/frontend/src/toolbar/extension/ExtensionEventsMenu.tsx
new file mode 100644
index 000000000000..1cca6c15cca1
--- /dev/null
+++ b/frontend/src/toolbar/extension/ExtensionEventsMenu.tsx
@@ -0,0 +1,167 @@
+import { useActions, useValues } from 'kea'
+
+import { IconClock, IconDownload, IconEye, IconHide, IconPause, IconPlay, IconTrash } from '@posthog/icons'
+
+import { SettingsBar, SettingsMenu } from 'lib/components/PanelSettings/PanelSettings'
+import { LemonButton } from 'lib/lemon-ui/LemonButton'
+import { LemonInput } from 'lib/lemon-ui/LemonInput'
+import { LemonTag } from 'lib/lemon-ui/LemonTag'
+
+import { eventTypeMenuItems, hidePropertiesMenuItems } from '~/toolbar/debug/eventDebugMenuItems'
+import { EventRow } from '~/toolbar/debug/EventRow'
+import { EventType } from '~/types'
+
+import { extensionEventsLogic } from './extensionEventsLogic'
+import type { PageEventsCommand } from './extensionPageEventsLogic'
+import { extensionPageToolbarConnectionLogic } from './extensionPageToolbarConnectionLogic'
+import { ExtensionToolLoading } from './ExtensionToolLoading'
+import { NoPagePosthogBanner } from './NoPagePosthogBanner'
+import { DebugEventRow, PageToolbarEventsState } from './pageToolbarBridge'
+
+function asEvent(row: DebugEventRow, eventsState: PageToolbarEventsState): EventType {
+ const payload = row.uuid === eventsState.expandedEventId ? eventsState.expandedEventPayload : null
+ return {
+ uuid: row.uuid,
+ event: row.event,
+ timestamp: row.timestamp,
+ properties: (payload?.properties as Record<string, any> | undefined) ?? {},
+ } as EventType
+}
+
+export function ExtensionEventsMenu(): JSX.Element {
+ const { eventsState, searchText } = useValues(extensionEventsLogic)
+ const { setSearchText, exportEvents } = useActions(extensionEventsLogic)
+ const { sendCommand } = useActions(extensionPageToolbarConnectionLogic)
+ const send = (command: PageEventsCommand): void => sendCommand({ tool: 'events', command })
+
+ if (!eventsState) {
+ return <ExtensionToolLoading />
+ }
+ const { rows, totalCount, filteredCount, isPaused, bufferedCount } = eventsState
+ const pinnedRows = rows.filter((row) => row.pinned)
+ const unpinnedRows = rows.filter((row) => !row.pinned)
+ const renderRow = (row: DebugEventRow): JSX.Element => (
+ <EventRow
+ key={row.uuid}
+ e={asEvent(row, eventsState)}
+ expanded={row.uuid === eventsState.expandedEventId}
+ isPinned={row.pinned}
+ expandedProperties={eventsState.expandedProperties}
+ searchText={searchText}
+ relativeTimestamps={eventsState.relativeTimestamps}
+ onToggleExpand={() =>
+ send({ type: 'expand-event', uuid: row.uuid === eventsState.expandedEventId ? null : row.uuid })
+ }
+ onTogglePin={(uuid) => send({ type: 'toggle-pinned-event', uuid })}
+ />
+ )
+
+ return (
+ <div className="flex flex-col gap-2">
+ {!eventsState.available && <NoPagePosthogBanner consequence="the debugger can't see its events." />}
+ <div className="flex items-center gap-1">
+ <LemonInput
+ className="flex-1 min-w-0"
+ type="search"
+ size="small"
+ placeholder="Filter events (or /regex/)"
+ value={searchText}
+ onChange={setSearchText}
+ data-attr="toolbar-extension-events-search"
+ />
+ <LemonTag type={isPaused ? 'muted' : 'success'}>{isPaused ? 'Paused' : 'Live'}</LemonTag>
+ <LemonButton
+ size="small"
+ icon={isPaused ? <IconPlay /> : <IconPause />}
+ tooltip={isPaused ? `Resume (${bufferedCount} buffered)` : 'Pause the stream'}
+ onClick={() => send({ type: 'toggle-events-paused' })}
+ data-attr="toolbar-extension-events-pause"
+ />
+ <LemonButton
+ size="small"
+ icon={<IconTrash />}
+ tooltip="Clear events"
+ disabledReason={totalCount === 0 ? 'No events to clear' : null}
+ onClick={() => send({ type: 'clear-events' })}
+ data-attr="toolbar-extension-events-clear"
+ />
+ </div>
+ {isPaused && bufferedCount > 0 && (
+ <div className="text-xs text-warning">
+ Paused. {bufferedCount} new {bufferedCount === 1 ? 'event is' : 'events are'} waiting.
+ </div>
+ )}
+ {rows.length === 0 ? (
+ <div className="p-2 text-xs text-secondary">
+ {totalCount > 0 ? 'No events match your filters.' : 'Interact with your page to see events here.'}
+ </div>
+ ) : (
+ <div className="flex flex-col gap-0.5" translate="no">
+ {pinnedRows.length > 0 && (
+ <>
+ <div className="text-xxs font-bold text-secondary uppercase tracking-wide pl-1">Pinned</div>
+ {pinnedRows.map(renderRow)}
+ {unpinnedRows.length > 0 && (
+ <div className="text-xxs font-bold text-secondary uppercase tracking-wide pl-1 pt-1">
+ Events
+ </div>
+ )}
+ </>
+ )}
+ {unpinnedRows.map(renderRow)}
+ </div>
+ )}
+ {rows.length < filteredCount && (
+ <div className="text-xs text-secondary">
+ The panel shows the newest {rows.length} of {filteredCount} events. Export them to see all of them.
+ </div>
+ )}
+ <SettingsBar border="top" className="justify-between flex-wrap">
+ <div className="flex items-center">
+ <SettingsMenu
+ items={hidePropertiesMenuItems(
+ eventsState.hidePostHogProperties,
+ eventsState.hidePostHogFlags,
+ (hide) => send({ type: 'set-hide-posthog-properties', hide }),
+ (hide) => send({ type: 'set-hide-posthog-flags', hide })
+ )}
+ highlightWhenActive={false}
+ icon={<IconHide />}
+ label="Hide"
+ />
+ <LemonButton
+ size="xsmall"
+ icon={<IconDownload />}
+ tooltip="Export events as JSON"
+ disabledReason={filteredCount === 0 ? 'No events to export' : null}
+ onClick={exportEvents}
+ data-attr="toolbar-extension-events-export"
+ />
+ <LemonButton
+ size="xsmall"
+ icon={<IconClock />}
+ active={eventsState.relativeTimestamps}
+ tooltip={
+ eventsState.relativeTimestamps ? 'Show absolute timestamps' : 'Show relative timestamps'
+ }
+ onClick={() => send({ type: 'toggle-relative-timestamps' })}
+ />
+ </div>
+ <SettingsMenu
+ items={eventTypeMenuItems(
+ eventsState.countsByType,
+ eventsState.selectedEventTypes,
+ (eventType, enabled) => send({ type: 'set-event-type-enabled', eventType, enabled })
+ )}
+ highlightWhenActive={false}
+ icon={<IconEye />}
+ label={
+ filteredCount === totalCount
+ ? `Showing ${totalCount}`
+ : `Showing ${filteredCount} of ${totalCount}`
+ }
+ />
+ </SettingsBar>
+ </div>
+ )
+}
diff --git a/frontend/src/toolbar/extension/ExtensionExperimentEditor.tsx b/frontend/src/toolbar/extension/ExtensionExperimentEditor.tsx
new file mode 100644
index 000000000000..de1e4aa975a3
--- /dev/null
+++ b/frontend/src/toolbar/extension/ExtensionExperimentEditor.tsx
@@ -0,0 +1,134 @@
+import { useActions, useValues } from 'kea'
+import { Field, Form } from 'kea-forms'
+
+import { IconArrowLeft, IconPlus } from '@posthog/icons'
+
+import { IconOpenInNew } from 'lib/lemon-ui/icons'
+import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
+import { LemonButton } from 'lib/lemon-ui/LemonButton'
+import { LemonCollapse } from 'lib/lemon-ui/LemonCollapse'
+import { LemonDivider } from 'lib/lemon-ui/LemonDivider'
+import { LemonInput } from 'lib/lemon-ui/LemonInput'
+import { LemonLabel } from 'lib/lemon-ui/LemonLabel'
+import { Link } from 'lib/lemon-ui/Link'
+
+import { WebExperimentVariant } from '~/toolbar/experiments/WebExperimentVariant'
+import { WebExperimentVariantHeader } from '~/toolbar/experiments/WebExperimentVariantHeader'
+import { urls } from '~/toolbar/urls'
+
+import { ExtensionExperimentEditorProvider } from './ExtensionExperimentEditorProvider'
+import { extensionExperimentsLogic } from './extensionExperimentsLogic'
+import { extensionPanelLogic } from './extensionPanelLogic'
+
+const byControlFirst = (a: string, b: string): number =>
+ a === 'control' ? -1 : b === 'control' ? 1 : a.localeCompare(b)
+
+export function ExtensionExperimentEditor(): JSX.Element | null {
+ const { experimentsState, experimentForm, saving } = useValues(extensionExperimentsLogic)
+ const { selectExperiment, sendExperimentsCommand } = useActions(extensionExperimentsLogic)
+ const { projectUrl } = useValues(extensionPanelLogic)
+
+ if (!experimentsState || experimentsState.selectedExperimentId === null) {
+ return null
+ }
+ const { selectedExperimentId, selectedVariant, addVariantAvailable, saveResult } = experimentsState
+ const isNew = selectedExperimentId === 'new'
+
+ return (
+ <ExtensionExperimentEditorProvider>
+ <Form
+ logic={extensionExperimentsLogic}
+ formKey="experimentForm"
+ enableFormOnSubmit
+ className="flex flex-col gap-2"
+ >
+ <div className="flex items-center gap-1">
+ <LemonButton
+ size="small"
+ icon={<IconArrowLeft />}
+ tooltip="Back to the experiments"
+ onClick={() => selectExperiment(null)}
+ data-attr="toolbar-extension-experiment-back"
+ />
+ <span className="flex-1 truncate font-semibold">
+ {isNew ? 'New experiment' : experimentForm.name || 'Untitled'}
+ </span>
+ {!isNew && (
+ <Link
+ to={projectUrl(urls.experiment(selectedExperimentId))}
+ target="_blank"
+ className="text-xs"
+ >
+ Open in PostHog <IconOpenInNew />
+ </Link>
+ )}
+ </div>
+ {saveResult?.status === 'failed' && (
+ <LemonBanner type="error">Couldn't save the experiment: {saveResult.error}</LemonBanner>
+ )}
+ {isNew && (
+ <Field name="name" label="Experiment name">
+ <LemonInput
+ placeholder="For example: Pricing page conversion"
+ data-attr="toolbar-extension-experiment-name"
+ />
+ </Field>
+ )}
+ <div className="flex items-center justify-between gap-2">
+ <LemonLabel>Variants</LemonLabel>
+ {addVariantAvailable && (
+ <LemonButton
+ type="secondary"
+ size="xsmall"
+ icon={<IconPlus />}
+ onClick={() => sendExperimentsCommand({ type: 'add-experiment-variant' })}
+ data-attr="toolbar-extension-experiment-add-variant"
+ >
+ Add variant
+ </LemonButton>
+ )}
+ </div>
+ <div className="text-xs text-secondary">Open a variant to show it on the page.</div>
+ <LemonCollapse
+ size="small"
+ activeKey={selectedVariant || null}
+ onChange={(variant) => sendExperimentsCommand({ type: 'select-experiment-variant', variant })}
+ panels={Object.keys(experimentForm.variants)
+ .sort(byControlFirst)
+ .map((variant) => ({
+ key: variant,
+ header: <WebExperimentVariantHeader variant={variant} />,
+ content:
+ variant === 'control' ? (
+ <div className="text-xs text-secondary">
+ The control variant is your page in its original state.
+ </div>
+ ) : (
+ <WebExperimentVariant key={variant} variant={variant} />
+ ),
+ }))}
+ />
+ <LemonDivider className="my-1" />
+ <div className="flex flex-wrap items-center justify-end gap-2">
+ <LemonButton
+ size="small"
+ type="secondary"
+ onClick={() => selectExperiment(null)}
+ data-attr="toolbar-extension-experiment-cancel"
+ >
+ Cancel
+ </LemonButton>
+ <LemonButton
+ size="small"
+ type="primary"
+ htmlType="submit"
+ loading={saving}
+ data-attr="toolbar-extension-experiment-save"
+ >
+ {isNew ? 'Save as draft' : 'Save experiment'}
+ </LemonButton>
+ </div>
+ </Form>
+ </ExtensionExperimentEditorProvider>
+ )
+}
diff --git a/frontend/src/toolbar/extension/ExtensionExperimentEditorProvider.tsx b/frontend/src/toolbar/extension/ExtensionExperimentEditorProvider.tsx
new file mode 100644
index 000000000000..e9b27c0ac960
--- /dev/null
+++ b/frontend/src/toolbar/extension/ExtensionExperimentEditorProvider.tsx
@@ -0,0 +1,52 @@
+import { useActions, useValues } from 'kea'
+import { useMemo } from 'react'
+
+import {
+ WebExperimentEditor,
+ WebExperimentEditorContext,
+ canRenameVariant,
+} from '~/toolbar/experiments/webExperimentEditorContext'
+
+import { extensionExperimentsLogic } from './extensionExperimentsLogic'
+
+/** Binds the toolbar's web experiment editor components to the panel's copy of the form. The page applies the changes. */
+export function ExtensionExperimentEditorProvider({ children }: { children: React.ReactNode }): JSX.Element | null {
+ const { experimentsState, experimentForm } = useValues(extensionExperimentsLogic)
+ const { sendExperimentsCommand, renameVariant, setTransformField } = useActions(extensionExperimentsLogic)
+
+ const editor = useMemo((): WebExperimentEditor | null => {
+ if (!experimentsState) {
+ return null
+ }
+ return {
+ variants: experimentForm.variants,
+ selectedExperimentId: experimentsState.selectedExperimentId,
+ selectedVariant: experimentsState.selectedVariant,
+ selectedElementType: experimentsState.selectedElementType,
+ inspectingElement: experimentsState.inspectingElement,
+ removeVariantAvailable: experimentsState.removeVariantAvailable,
+ renameVariant: (variant, newKey) => {
+ if (!canRenameVariant(experimentForm.variants, variant, newKey)) {
+ return false
+ }
+ renameVariant(variant, newKey)
+ return true
+ },
+ removeVariant: (variant) => sendExperimentsCommand({ type: 'remove-experiment-variant', variant }),
+ addTransformation: (variant) => sendExperimentsCommand({ type: 'add-experiment-transform', variant }),
+ removeTransformation: (variant, index) =>
+ sendExperimentsCommand({ type: 'remove-experiment-transform', variant, index }),
+ selectElementType: (elementType) =>
+ sendExperimentsCommand({ type: 'set-experiment-element-type', elementType }),
+ inspectForTransformation: (variant, index) =>
+ sendExperimentsCommand({ type: 'inspect-for-experiment-transform', variant, index }),
+ setTransformationField: setTransformField,
+ setTransformationSelector: (variant, index, selector) =>
+ sendExperimentsCommand({ type: 'set-experiment-transform-selector', variant, index, selector }),
+ }
+ }, [experimentsState, experimentForm.variants, sendExperimentsCommand, renameVariant, setTransformField])
+
+ return editor ? (
+ <WebExperimentEditorContext.Provider value={editor}>{children}</WebExperimentEditorContext.Provider>
+ ) : null
+}
diff --git a/frontend/src/toolbar/extension/ExtensionExperimentsList.tsx b/frontend/src/toolbar/extension/ExtensionExperimentsList.tsx
new file mode 100644
index 000000000000..e2e6e0bc9c32
--- /dev/null
+++ b/frontend/src/toolbar/extension/ExtensionExperimentsList.tsx
@@ -0,0 +1,58 @@
+import { useActions, useValues } from 'kea'
+
+import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
+import { Link } from 'lib/lemon-ui/Link'
+
+import { urls } from '~/toolbar/urls'
+
+import { ExtensionEntityList } from './ExtensionEntityList'
+import { extensionExperimentsLogic } from './extensionExperimentsLogic'
+import { extensionPanelLogic } from './extensionPanelLogic'
+
+export function ExtensionExperimentsList(): JSX.Element {
+ const { experimentsState, filteredExperiments, searchTerm } = useValues(extensionExperimentsLogic)
+ const { setSearchTerm, selectExperiment } = useActions(extensionExperimentsLogic)
+ const { projectUrl } = useValues(extensionPanelLogic)
+ const saveResult = experimentsState?.saveResult
+
+ return (
+ <ExtensionEntityList
+ noun="experiment"
+ pluralNoun="experiments"
+ items={experimentsState ? filteredExperiments : null}
+ loading={!!experimentsState?.loading}
+ searchTerm={searchTerm}
+ onSearch={setSearchTerm}
+ onSelect={selectExperiment}
+ onCreate={() => selectExperiment('new')}
+ saved={
+ saveResult?.status === 'saved'
+ ? { name: saveResult.name, url: projectUrl(urls.experiment(saveResult.experimentId)) }
+ : null
+ }
+ viewAllUrl={projectUrl(urls.experiments())}
+ emptyText="This project has no web experiments yet."
+ notice={
+ experimentsState?.webExperimentsDisabled && (
+ <LemonBanner type="warning">
+ Web experiments are off in this page's PostHog setup. To run experiments, set{' '}
+ <code>disable_web_experiments: false</code> in your configuration.{' '}
+ <Link
+ target="_blank"
+ targetBlankIcon
+ to="https://posthog.com/docs/experiments/no-code-web-experiments"
+ >
+ Learn more
+ </Link>
+ </LemonBanner>
+ )
+ }
+ dataAttrs={{
+ search: 'toolbar-extension-experiments-search',
+ row: 'toolbar-extension-experiment-row',
+ create: 'toolbar-extension-new-experiment',
+ openSaved: 'toolbar-extension-open-saved-experiment',
+ }}
+ />
+ )
+}
diff --git a/frontend/src/toolbar/extension/ExtensionMoreMenu.tsx b/frontend/src/toolbar/extension/ExtensionMoreMenu.tsx
new file mode 100644
index 000000000000..c2f361694fef
--- /dev/null
+++ b/frontend/src/toolbar/extension/ExtensionMoreMenu.tsx
@@ -0,0 +1,24 @@
+import { LemonDivider } from 'lib/lemon-ui/LemonDivider'
+import { Link } from 'lib/lemon-ui/Link'
+
+import { ExtensionDebugInfo } from './ExtensionDebugInfo'
+import { ExtensionPiiMasking } from './ExtensionPiiMasking'
+import { ExtensionScreenshotForEvent } from './ExtensionScreenshotForEvent'
+
+const TOOLBAR_DOCS_URL = 'https://posthog.com/docs/toolbar?utm_medium=in-product&utm_campaign=toolbar-extension-help'
+
+export function ExtensionMoreMenu(): JSX.Element {
+ return (
+ <div className="flex flex-col gap-3">
+ <ExtensionDebugInfo />
+ <LemonDivider className="my-0" />
+ <ExtensionPiiMasking />
+ <LemonDivider className="my-0" />
+ <ExtensionScreenshotForEvent />
+ <LemonDivider className="my-0" />
+ <Link to={TOOLBAR_DOCS_URL} target="_blank" className="text-xs">
+ Toolbar docs
+ </Link>
+ </div>
+ )
+}
diff --git a/frontend/src/toolbar/extension/ExtensionPageToolbarTools.tsx b/frontend/src/toolbar/extension/ExtensionPageToolbarTools.tsx
index 3c4d02b5b2eb..d806f369df4b 100644
--- a/frontend/src/toolbar/extension/ExtensionPageToolbarTools.tsx
+++ b/frontend/src/toolbar/extension/ExtensionPageToolbarTools.tsx
@@ -11,21 +11,22 @@ import { SelectorCountContext, SelectorMatchCounter } from '~/toolbar/actions/Se
import { ExtensionActionEditor } from './ExtensionActionEditor'
import { ExtensionActionsList } from './ExtensionActionsList'
+import { ExtensionEventsMenu } from './ExtensionEventsMenu'
+import { ExtensionExperimentEditor } from './ExtensionExperimentEditor'
+import { ExtensionExperimentsList } from './ExtensionExperimentsList'
import { ExtensionFeatureList } from './ExtensionFeatureList'
import { ExtensionFlagsMenu } from './ExtensionFlagsMenu'
import { ExtensionHeatmapMenu } from './ExtensionHeatmapMenu'
import { ExtensionInspectedElement } from './ExtensionInspectedElement'
+import { ExtensionMoreMenu } from './ExtensionMoreMenu'
import { extensionPageToolbarConnectionLogic } from './extensionPageToolbarConnectionLogic'
import { PAGE_TOOLS, PageToolDefinition, PageToolMode } from './extensionPageTools'
import { extensionPanelLogic } from './extensionPanelLogic'
+import { ExtensionWebVitalsMenu } from './ExtensionWebVitalsMenu'
import { usePageToolDisabledReason } from './usePageToolDisabledReason'
-type PanelTool = PageToolDefinition & { mode: PageToolMode }
-
-const PANEL_TOOLS = PAGE_TOOLS.filter((tool): tool is PanelTool => !!tool.mode)
-
function ToolBody({ mode }: { mode: PageToolMode }): JSX.Element {
- const { selectedActionId } = useValues(extensionPageToolbarConnectionLogic)
+ const { selectedActionId, selectedExperimentId } = useValues(extensionPageToolbarConnectionLogic)
switch (mode) {
case 'inspect':
@@ -44,10 +45,18 @@ function ToolBody({ mode }: { mode: PageToolMode }): JSX.Element {
return selectedActionId !== null ? <ExtensionActionEditor /> : <ExtensionActionsList />
case 'flags':
return <ExtensionFlagsMenu />
+ case 'events':
+ return <ExtensionEventsMenu />
+ case 'web-vitals':
+ return <ExtensionWebVitalsMenu />
+ case 'experiments':
+ return selectedExperimentId !== null ? <ExtensionExperimentEditor /> : <ExtensionExperimentsList />
+ case 'more':
+ return <ExtensionMoreMenu />
}
}
-function ToolHeader({ tool }: { tool: PanelTool }): JSX.Element {
+function ToolHeader({ tool }: { tool: PageToolDefinition }): JSX.Element {
const { openFeature } = useActions(extensionPanelLogic)
const { setMode } = useActions(extensionPageToolbarConnectionLogic)
const { feature } = tool
@@ -80,7 +89,7 @@ export function ExtensionPageToolbarTools({ origin }: { origin: string }): JSX.E
const { mode, connectionStatus, selectorCounter } = useValues(extensionPageToolbarConnectionLogic)
const { setMode, connectPage, requestSelectorCount } = useActions(extensionPageToolbarConnectionLogic)
const disabledReason = usePageToolDisabledReason()
- const activeTool = PANEL_TOOLS.find((tool) => tool.mode === mode)
+ const activeTool = PAGE_TOOLS.find((tool) => tool.mode === mode)
// The page counts selector matches for every editor in the panel.
const counter = useMemo<SelectorMatchCounter>(
() => ({ count: selectorCounter.count, request: requestSelectorCount }),
@@ -95,7 +104,7 @@ export function ExtensionPageToolbarTools({ origin }: { origin: string }): JSX.E
size="small"
value={activeTool?.mode}
onChange={(toolMode) => setMode(toolMode === mode ? 'none' : toolMode)}
- options={PANEL_TOOLS.map((tool) => ({
+ options={PAGE_TOOLS.map((tool) => ({
value: tool.mode,
icon: tool.icon,
tooltip: tool.label,
@@ -122,7 +131,7 @@ export function ExtensionPageToolbarTools({ origin }: { origin: string }): JSX.E
) : (
<>
<div className="flex flex-col gap-1">
- {PANEL_TOOLS.map((tool) => (
+ {PAGE_TOOLS.map((tool) => (
<LemonButton
key={tool.mode}
fullWidth
diff --git a/frontend/src/toolbar/extension/ExtensionPiiMasking.tsx b/frontend/src/toolbar/extension/ExtensionPiiMasking.tsx
new file mode 100644
index 000000000000..892f846f0b46
--- /dev/null
+++ b/frontend/src/toolbar/extension/ExtensionPiiMasking.tsx
@@ -0,0 +1,63 @@
+import { useActions, useValues } from 'kea'
+
+import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
+import { LemonSelect } from 'lib/lemon-ui/LemonSelect'
+import { LemonSwitch } from 'lib/lemon-ui/LemonSwitch'
+
+import { PII_MASKING_PRESET_COLORS } from '~/toolbar/bar/piiMaskingStyles'
+
+import { extensionMoreLogic } from './extensionMoreLogic'
+
+function ColorSwatch({ color }: { color: string }): JSX.Element {
+ return (
+ <span
+ className="inline-block w-4 h-4 rounded border"
+ // eslint-disable-next-line react/forbid-dom-props
+ style={{ backgroundColor: color }}
+ />
+ )
+}
+
+/** Previews on the page what session recordings mask, with the page's masking settings. */
+export function ExtensionPiiMasking(): JSX.Element {
+ const { moreState } = useValues(extensionMoreLogic)
+ const { setPiiMasking, sendMoreCommand } = useActions(extensionMoreLogic)
+ const enabled = !!moreState?.piiMaskingEnabled
+
+ return (
+ <section className="flex flex-col gap-2">
+ <h4 className="m-0 text-sm font-semibold">PII masking</h4>
+ <LemonSwitch
+ fullWidth
+ bordered
+ label="Hide PII on this page"
+ checked={enabled}
+ disabledReason={moreState ? null : 'Connecting to the page…'}
+ onChange={setPiiMasking}
+ data-attr="toolbar-extension-pii-masking"
+ />
+ {enabled && moreState && (
+ <LemonSelect
+ size="small"
+ fullWidth
+ value={moreState.piiMaskingColor}
+ onChange={(color) => sendMoreCommand({ type: 'set-pii-masking-color', color })}
+ options={PII_MASKING_PRESET_COLORS.map(({ label, value }) => ({
+ label,
+ value,
+ icon: <ColorSwatch color={value} />,
+ }))}
+ data-attr="toolbar-extension-pii-masking-color"
+ />
+ )}
+ {moreState?.piiWarnings.map((warning) => (
+ <LemonBanner key={warning} type="warning">
+ {warning}
+ </LemonBanner>
+ ))}
+ <div className="text-xs text-secondary">
+ Shows on the page which text and elements session recordings mask.
+ </div>
+ </section>
+ )
+}
diff --git a/frontend/src/toolbar/extension/ExtensionScreenshotForEvent.tsx b/frontend/src/toolbar/extension/ExtensionScreenshotForEvent.tsx
new file mode 100644
index 000000000000..cda23d3ac55b
--- /dev/null
+++ b/frontend/src/toolbar/extension/ExtensionScreenshotForEvent.tsx
@@ -0,0 +1,106 @@
+import { useActions, useValues } from 'kea'
+
+import { IconCamera } from '@posthog/icons'
+
+import { LemonBanner } from 'lib/lemon-ui/LemonBanner'
+import { LemonButton } from 'lib/lemon-ui/LemonButton'
+import { LemonInput } from 'lib/lemon-ui/LemonInput'
+import { Spinner } from 'lib/lemon-ui/Spinner'
+
+import { extensionMoreLogic } from './extensionMoreLogic'
+
+/** Takes a screenshot of the page and adds it to an event definition, like the toolbar's "Screenshot for event". */
+export function ExtensionScreenshotForEvent(): JSX.Element {
+ const { moreState, screenshotEventName, screenshotPreview } = useValues(extensionMoreLogic)
+ const { takeScreenshot, setScreenshotEventName, selectScreenshotEvent, uploadScreenshot, closeScreenshot } =
+ useActions(extensionMoreLogic)
+ const screenshot = moreState?.screenshot
+ const selectedEvent = screenshot?.suggestions.find(({ id }) => id === screenshot.selectedEventId)
+
+ return (
+ <section className="flex flex-col gap-2">
+ <h4 className="m-0 text-sm font-semibold">Screenshot for an event</h4>
+ {screenshot?.result?.status === 'uploaded' && (
+ <LemonBanner type="success">The screenshot is now on the event's definition.</LemonBanner>
+ )}
+ {screenshot?.result?.status === 'failed' && (
+ <LemonBanner type="error">Couldn't add the screenshot: {screenshot.result.error}</LemonBanner>
+ )}
+ {screenshot?.open && screenshotPreview ? (
+ <>
+ <img
+ src={screenshotPreview}
+ alt="Screenshot of the page"
+ className="w-full h-auto max-h-60 object-contain border rounded"
+ />
+ <LemonInput
+ size="small"
+ placeholder="Search for an event"
+ value={screenshotEventName}
+ onChange={setScreenshotEventName}
+ disabledReason={screenshot.uploading ? 'Uploading…' : null}
+ data-attr="toolbar-extension-screenshot-event"
+ />
+ {screenshotEventName.trim() && !selectedEvent && (
+ <div className="flex flex-col gap-px max-h-48 overflow-y-auto">
+ {screenshot.suggestionsLoading ? (
+ <div className="flex justify-center p-2">
+ <Spinner />
+ </div>
+ ) : screenshot.suggestions.length > 0 ? (
+ screenshot.suggestions.map(({ id, name }) => (
+ <LemonButton
+ key={id}
+ size="small"
+ fullWidth
+ onClick={() => selectScreenshotEvent(id, name)}
+ >
+ <span className="truncate" translate="no">
+ {name}
+ </span>
+ </LemonButton>
+ ))
+ ) : (
+ <div className="p-2 text-xs text-secondary">No events match this name.</div>
+ )}
+ </div>
+ )}
+ <div className="flex flex-wrap justify-end gap-2">
+ <LemonButton
+ size="small"
+ type="secondary"
+ disabledReason={screenshot.uploading ? 'Uploading…' : null}
+ onClick={closeScreenshot}
+ >
+ Cancel
+ </LemonButton>
+ <LemonButton
+ size="small"
+ type="primary"
+ loading={screenshot.uploading}
+ disabledReason={selectedEvent ? null : 'Pick an event first'}
+ onClick={uploadScreenshot}
+ data-attr="toolbar-extension-screenshot-upload"
+ >
+ Upload
+ </LemonButton>
+ </div>
+ </>
+ ) : (
+ <LemonButton
+ size="small"
+ type="secondary"
+ icon={<IconCamera />}
+ fullWidth
+ center
+ loading={!!screenshot?.taking}
+ disabledReason={moreState ? null : 'Connecting to the page…'}
+ onClick={takeScreenshot}
+ data-attr="toolbar-extension-screenshot-take"
+ >
+ Take a screenshot of the page
+ </LemonButton>
+ )}
+ </section>
+ )
+}
diff --git a/frontend/src/toolbar/extension/ExtensionWebVitalsMenu.tsx b/frontend/src/toolbar/extension/ExtensionWebVitalsMenu.tsx
new file mode 100644
index 000000000000..4dd62c6a439c
--- /dev/null
+++ b/frontend/src/toolbar/extension/ExtensionWebVitalsMenu.tsx
@@ -0,0 +1,56 @@
+import { useActions, useValues } from 'kea'
+
+import { IconRefresh } from '@posthog/icons'
+
+import { LemonButton } from 'lib/lemon-ui/LemonButton'
+import { Link } from 'lib/lemon-ui/Link'
+
+import { urls } from '~/toolbar/urls'
+import { WebVitalsReport } from '~/toolbar/web-vitals/WebVitalsReport'
+
+import { extensionPageToolbarConnectionLogic } from './extensionPageToolbarConnectionLogic'
+import { extensionPanelLogic } from './extensionPanelLogic'
+import { ExtensionToolLoading } from './ExtensionToolLoading'
+
+const WEB_VITALS_DOCS_URL = 'https://posthog.com/docs/web-analytics/web-vitals'
+
+export function ExtensionWebVitalsMenu(): JSX.Element {
+ const { webVitals } = useValues(extensionPageToolbarConnectionLogic)
+ const { sendCommand } = useActions(extensionPageToolbarConnectionLogic)
+ const { projectUrl } = useValues(extensionPanelLogic)
+
+ if (!webVitals) {
+ return <ExtensionToolLoading />
+ }
+
+ return (
+ <div className="flex flex-col gap-2">
+ <WebVitalsReport
+ localWebVitals={webVitals.localWebVitals}
+ remoteWebVitals={webVitals.remoteWebVitals}
+ pathname={webVitals.pathname}
+ autocaptureEnabled={webVitals.autocaptureEnabled}
+ settingsUrl={projectUrl(urls.settings())}
+ />
+ <div className="flex flex-wrap items-center justify-between gap-2">
+ <div className="flex flex-wrap gap-x-3 text-xs">
+ <Link to={projectUrl(urls.webAnalyticsWebVitals())} target="_blank">
+ View all metrics
+ </Link>
+ <Link to={WEB_VITALS_DOCS_URL} target="_blank">
+ Web vitals docs
+ </Link>
+ </div>
+ <LemonButton
+ size="small"
+ type="secondary"
+ icon={<IconRefresh />}
+ onClick={() => sendCommand({ tool: 'web-vitals', command: { type: 'reload-web-vitals' } })}
+ data-attr="toolbar-extension-web-vitals-reload"
+ >
+ Reload
+ </LemonButton>
+ </div>
+ </div>
+ )
+}
diff --git a/frontend/src/toolbar/extension/README.md b/frontend/src/toolbar/extension/README.md
index 574eb2d633f3..a77a8817348c 100644
--- a/frontend/src/toolbar/extension/README.md
+++ b/frontend/src/toolbar/extension/README.md
@@ -62,6 +62,9 @@ The page tools run the floating toolbar's own logics in the content script, and
- `heatmapToolbarMenuLogic`, `heatmapDataLogic` and `heatmapCaptureLogic` for the heatmap.
- `actionsLogic` and `actionsTabLogic` for actions.
- `flagsToolbarLogic` for feature flags.
+- `eventDebugMenuLogic` for the event debugger, and `webVitalsToolbarLogic` for web vitals.
+- `screenshotUploadLogic` for screenshots for events.
+- `experimentsLogic` and `experimentsTabLogic` for web experiments.
The panel shows their controls. It sends each command to the tool it belongs to, and gets their state back through a port.
@@ -90,9 +93,16 @@ flowchart LR
The content script asks the page agent for the page's posthog-js settings when the page tools start, and stands in for posthog-js with them.
When a page loads posthog-js later, the page agent reports it, and the page tools start again with it.
For flag overrides the page agent calls posthog-js and reports the flag state back. A change it doesn't answer fails after 5 seconds.
-- **Forms.** The panel edits its own copy of the action form, so typing doesn't wait for the page, and sends the form after a short pause.
- It sends the form right away before any command that changes it on the page, and takes the page's copy only when the page changed the form itself, for example when the user picks an element.
+ The page agent also forwards each event posthog-js captures, for the event debugger and the web vitals of the page load, and reads the debug info.
+- **Event debugger.** The debugger starts the first time the user opens it. The page keeps up to 5,000 events, like the floating toolbar.
+ While the debugger is open, its slice carries the newest 200 rows the filters show, and the properties of the open event.
+ The page agent sends the payload of `$snapshot` events only while the debugger shows them.
+ **Export** downloads every filtered event from the page.
+- **Forms.** The panel edits its own copy of the action and experiment forms, so typing doesn't wait for the page, and sends the form after a short pause.
+ It sends a pending edit right away before any command that changes the form on the page, and takes the page's copy only when the page changed the form itself, for example when the user picks an element.
The page counts the matches of the selectors the panel shows, and counts again when the page changes.
+- **Experiments.** The page previews the open variant by changing its own DOM, and puts back the original HTML when the user closes the variant, leaves the experiment, saves it, or closes the tool, and when the page tools stop.
+ An experiment selector must match in the document itself, because posthog-js applies web experiments with `document.querySelectorAll`, which doesn't look inside shadow roots.
- **Injection.** The panel injects the content script on first use. The script answers a ping, so the panel doesn't inject it twice.
- **Navigation.** When a single-page app changes the URL, the port stays open and the page tools follow the new URL.
A new document closes the port. The panel then connects again and turns the mode the user picked back on.
@@ -112,3 +122,9 @@ Use a site in the project's authorized URLs. Do these steps in Chrome and in Fir
8. Open a page that doesn't load posthog-js as `window.posthog`. **Flags** says that it can't override flags there.
9. Switch to a tab with another site, then back. The panel shows the state of each tab.
10. Switch the project in the panel. The panel connects the toolbar to the new project.
+11. Click **Events** and use the page. The events stream in. Open one, search, pause and resume, and export them.
+12. Click **Web vitals**. The project's P90 metrics show, and the page load's metrics fill in as posthog-js reports them.
+13. Click **More**. Check the debug info, open the current session recording, turn on **Hide PII on this page**, and add a screenshot to an event.
+14. Click **Experiments** and open an experiment. Open a variant: the page shows it. Edit its HTML: the page changes as you type. Close the variant, then go back: the page shows its original state.
+15. Create an experiment, pick an element for a transformation with **Select element**, edit it, and save it. Open a page whose snippet sets `disable_web_experiments`: **Experiments** shows a warning.
+16. Switch the browser to dark mode. The panel follows it.
diff --git a/frontend/src/toolbar/extension/extensionEventsLogic.ts b/frontend/src/toolbar/extension/extensionEventsLogic.ts
new file mode 100644
index 000000000000..036c4567561b
--- /dev/null
+++ b/frontend/src/toolbar/extension/extensionEventsLogic.ts
@@ -0,0 +1,71 @@
+import { MakeLogicType, actions, connect, kea, listeners, path, reducers, selectors } from 'kea'
+
+import { extensionPageToolbarConnectionLogic } from './extensionPageToolbarConnectionLogic'
+import { capturePageToolUsed } from './extensionTelemetry'
+import type { PageToolbarEventsState, PageToolbarState } from './pageToolbarBridge'
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionEventsLogicValues {
+ pageToolbarState: PageToolbarState | null // extensionPageToolbarConnectionLogic
+ eventsState: PageToolbarEventsState | null
+ searchText: string
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionEventsLogicActions {
+ sendCommand: (message: import('./pageToolbarBridge').PageToolbarCommand) => {
+ message: import('./pageToolbarBridge').PageToolbarCommand
+ } // extensionPageToolbarConnectionLogic
+ exportEvents: () => {
+ value: true
+ }
+ setSearchText: (searchText: string) => {
+ searchText: string
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionEventsLogicMeta {
+ __keaTypeGenInternalSelectorTypes: {
+ eventsState: (pageToolbarState: PageToolbarState | null) => PageToolbarEventsState | null
+ }
+}
+
+export type extensionEventsLogicType = MakeLogicType<
+ extensionEventsLogicValues,
+ extensionEventsLogicActions,
+ Record<string, any>,
+ extensionEventsLogicMeta
+>
+
+/** The panel side of the event debugger. The page runs the toolbar's debugger logic, which keeps the events. */
+export const extensionEventsLogic = kea<extensionEventsLogicType>([
+ path(['toolbar', 'extension', 'extensionEventsLogic']),
+ connect(() => ({
+ values: [extensionPageToolbarConnectionLogic, ['pageToolbarState']],
+ actions: [extensionPageToolbarConnectionLogic, ['sendCommand']],
+ })),
+ actions({
+ setSearchText: (searchText: string) => ({ searchText }),
+ exportEvents: true,
+ }),
+ reducers({
+ // The page filters with the search a moment later, so the input keeps what the user typed meanwhile.
+ searchText: ['', { setSearchText: (_, { searchText }) => searchText }],
+ }),
+ selectors({
+ eventsState: [
+ (s) => [s.pageToolbarState],
+ (pageToolbarState: PageToolbarState | null): PageToolbarEventsState | null =>
+ pageToolbarState?.events ?? null,
+ ],
+ }),
+ listeners(({ actions }) => ({
+ setSearchText: ({ searchText }) =>
+ actions.sendCommand({ tool: 'events', command: { type: 'set-events-search', searchText } }),
+ exportEvents: () => {
+ actions.sendCommand({ tool: 'events', command: { type: 'export-events' } })
+ capturePageToolUsed('export-events')
+ },
+ })),
+])
diff --git a/frontend/src/toolbar/extension/extensionExperimentsLogic.ts b/frontend/src/toolbar/extension/extensionExperimentsLogic.ts
new file mode 100644
index 000000000000..fd4d64c6df24
--- /dev/null
+++ b/frontend/src/toolbar/extension/extensionExperimentsLogic.ts
@@ -0,0 +1,266 @@
+import { MakeLogicType, actions, afterMount, connect, kea, listeners, path, reducers, selectors } from 'kea'
+import { forms } from 'kea-forms'
+import type { DeepPartial, DeepPartialMap, FieldName, ValidationErrorType } from 'kea-forms'
+import { subscriptions } from 'kea-subscriptions'
+
+import { canRenameVariant } from '~/toolbar/experiments/webExperimentEditorContext'
+
+import type { PageExperimentsCommand } from './extensionPageExperimentsLogic'
+import { extensionPageToolbarConnectionLogic } from './extensionPageToolbarConnectionLogic'
+import { capturePageToolUsed } from './extensionTelemetry'
+import { PageFormSync } from './pageFormSync'
+import type { ExperimentFormDraft, PageToolbarExperimentsState, PageToolbarState } from './pageToolbarBridge'
+
+const EMPTY_EXPERIMENT_FORM: ExperimentFormDraft = { name: '', variants: {} }
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionExperimentsLogicValues {
+ pageToolbarState: PageToolbarState | null // extensionPageToolbarConnectionLogic
+ experimentForm: ExperimentFormDraft
+ experimentFormAllErrors: Record<string, any>
+ experimentFormChanged: boolean
+ experimentFormErrors: DeepPartialMap<ExperimentFormDraft, ValidationErrorType>
+ experimentFormHasErrors: boolean
+ experimentFormManualErrors: Record<string, any>
+ experimentFormTouched: boolean
+ experimentFormTouches: Record<string, boolean>
+ experimentFormValidationErrors: DeepPartialMap<ExperimentFormDraft, ValidationErrorType>
+ experimentsState: PageToolbarExperimentsState | null
+ filteredExperiments: PageToolbarExperimentsState['experiments']
+ isExperimentFormSubmitting: boolean
+ isExperimentFormValid: boolean
+ saveRequested: boolean
+ saving: boolean
+ searchTerm: string
+ showExperimentFormErrors: boolean
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionExperimentsLogicActions {
+ sendCommand: (message: import('./pageToolbarBridge').PageToolbarCommand) => {
+ message: import('./pageToolbarBridge').PageToolbarCommand
+ } // extensionPageToolbarConnectionLogic
+ renameVariant: (
+ variant: string,
+ newKey: string
+ ) => {
+ newKey: string
+ variant: string
+ }
+ resetExperimentForm: (values?: ExperimentFormDraft) => {
+ values?: ExperimentFormDraft
+ }
+ selectExperiment: (id: number | 'new' | null) => {
+ id: number | 'new' | null
+ }
+ sendExperimentsCommand: (command: PageExperimentsCommand) => {
+ command: PageExperimentsCommand
+ }
+ setExperimentFormManualErrors: (errors: Record<string, any>) => {
+ errors: Record<string, any>
+ }
+ setExperimentFormValue: (
+ key: FieldName,
+ value: any
+ ) => {
+ name: FieldName
+ value: any
+ }
+ setExperimentFormValues: (values: DeepPartial<ExperimentFormDraft>) => {
+ values: DeepPartial<ExperimentFormDraft>
+ }
+ setSaveRequested: (saveRequested: boolean) => {
+ saveRequested: boolean
+ }
+ setSearchTerm: (searchTerm: string) => {
+ searchTerm: string
+ }
+ setTransformField: (
+ variant: string,
+ index: number,
+ field: 'css' | 'html',
+ value: string
+ ) => {
+ field: 'css' | 'html'
+ index: number
+ value: string
+ variant: string
+ }
+ submitExperimentForm: () => {
+ value: boolean
+ }
+ submitExperimentFormFailure: (
+ error: Error,
+ errors: Record<string, any>
+ ) => {
+ error: Error
+ errors: Record<string, any>
+ }
+ submitExperimentFormRequest: (experimentForm: ExperimentFormDraft) => {
+ experimentForm: ExperimentFormDraft
+ }
+ submitExperimentFormSuccess: (experimentForm: ExperimentFormDraft) => {
+ experimentForm: ExperimentFormDraft
+ }
+ touchExperimentFormField: (key: string) => {
+ key: string
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionExperimentsLogicMeta {
+ __keaTypeGenInternalSelectorTypes: {
+ experimentsState: (pageToolbarState: PageToolbarState | null) => PageToolbarExperimentsState | null
+ filteredExperiments: (
+ experimentsState: PageToolbarExperimentsState | null,
+ searchTerm: string
+ ) => PageToolbarExperimentsState['experiments']
+ saving: (experimentsState: PageToolbarExperimentsState | null, saveRequested: boolean) => boolean
+ }
+}
+
+export type extensionExperimentsLogicType = MakeLogicType<
+ extensionExperimentsLogicValues,
+ extensionExperimentsLogicActions,
+ Record<string, any>,
+ extensionExperimentsLogicMeta
+>
+
+/**
+ * The panel side of the experiments tool. The page runs the toolbar's experiment logics and previews the variants, the
+ * panel edits its own copy of the form.
+ */
+export const extensionExperimentsLogic = kea<extensionExperimentsLogicType>([
+ path(['toolbar', 'extension', 'extensionExperimentsLogic']),
+ connect(() => ({
+ values: [extensionPageToolbarConnectionLogic, ['pageToolbarState']],
+ actions: [extensionPageToolbarConnectionLogic, ['sendCommand']],
+ })),
+ actions({
+ setSearchTerm: (searchTerm: string) => ({ searchTerm }),
+ sendExperimentsCommand: (command: PageExperimentsCommand) => ({ command }),
+ selectExperiment: (id: number | 'new' | null) => ({ id }),
+ renameVariant: (variant: string, newKey: string) => ({ variant, newKey }),
+ setTransformField: (variant: string, index: number, field: 'html' | 'css', value: string) => ({
+ variant,
+ index,
+ field,
+ value,
+ }),
+ setSaveRequested: (saveRequested: boolean) => ({ saveRequested }),
+ }),
+ forms(({ actions }) => ({
+ experimentForm: {
+ defaults: EMPTY_EXPERIMENT_FORM,
+ errors: ({ name }) => ({
+ name: !name ? 'Please enter a name for this experiment' : undefined,
+ }),
+ submit: () => {
+ actions.sendExperimentsCommand({ type: 'save-experiment' })
+ capturePageToolUsed('save-experiment')
+ },
+ showErrorsOnTouch: true,
+ },
+ })),
+ reducers({
+ searchTerm: ['', { setSearchTerm: (_, { searchTerm }) => searchTerm }],
+ // The page takes a moment to report that it started saving, so the button waits from the click.
+ saveRequested: [
+ false,
+ {
+ submitExperimentForm: () => true,
+ // kea-forms fails the submit without calling submit when validation fails.
+ submitExperimentFormFailure: () => false,
+ setSaveRequested: (_, { saveRequested }) => saveRequested,
+ },
+ ],
+ }),
+ selectors({
+ experimentsState: [
+ (s) => [s.pageToolbarState],
+ (pageToolbarState: PageToolbarState | null): PageToolbarExperimentsState | null =>
+ pageToolbarState?.experiments ?? null,
+ ],
+ filteredExperiments: [
+ (s) => [s.experimentsState, s.searchTerm],
+ (
+ experimentsState: PageToolbarExperimentsState | null,
+ searchTerm: string
+ ): PageToolbarExperimentsState['experiments'] =>
+ (experimentsState?.experiments ?? []).filter(({ name }) =>
+ (name ?? '').toLowerCase().includes(searchTerm.trim().toLowerCase())
+ ),
+ ],
+ saving: [
+ (s) => [s.experimentsState, s.saveRequested],
+ (experimentsState: PageToolbarExperimentsState | null, saveRequested: boolean): boolean =>
+ saveRequested || !!experimentsState?.saving,
+ ],
+ }),
+ listeners(({ actions, values, cache }) => ({
+ sendExperimentsCommand: ({ command }) => {
+ // Every command can make the page change the form, so the page gets the user's edits first.
+ if (command.type !== 'set-experiment-form') {
+ cache.formSync.flush()
+ }
+ actions.sendCommand({ tool: 'experiments', command })
+ },
+ setExperimentFormValue: () => cache.formSync.schedule(),
+ setExperimentFormValues: () => cache.formSync.schedule(),
+ selectExperiment: ({ id }) => {
+ actions.sendExperimentsCommand({ type: 'select-experiment', id })
+ if (id === 'new') {
+ capturePageToolUsed('create-experiment')
+ }
+ },
+ setTransformField: ({ variant, index, field, value }) => {
+ const webVariant = values.experimentForm.variants[variant]
+ if (webVariant) {
+ actions.setExperimentFormValue('variants', {
+ ...values.experimentForm.variants,
+ [variant]: {
+ ...webVariant,
+ transforms: webVariant.transforms.map((transform, i) =>
+ i === index ? { ...transform, [field]: value } : transform
+ ),
+ },
+ })
+ }
+ },
+ renameVariant: ({ variant, newKey }) => {
+ const { variants } = values.experimentForm
+ if (!canRenameVariant(variants, variant, newKey)) {
+ return
+ }
+ actions.setExperimentFormValues({
+ variants: Object.fromEntries(
+ Object.entries(variants).map(([key, value]) => [key === variant ? newKey : key, value])
+ ),
+ })
+ actions.sendExperimentsCommand({ type: 'select-experiment-variant', variant: newKey })
+ },
+ })),
+ afterMount(({ actions, values, cache }) => {
+ cache.formSync = new PageFormSync(() =>
+ actions.sendCommand({
+ tool: 'experiments',
+ command: { type: 'set-experiment-form', form: values.experimentForm },
+ })
+ )
+ cache.disposables.add(() => () => cache.formSync.cancel(), 'formSync')
+ }),
+ // Runs after afterMount above, which creates the form sync the first call reads.
+ subscriptions(({ actions, values, cache }) => ({
+ experimentsState: (page: PageToolbarExperimentsState | null) => {
+ if (!page) {
+ return
+ }
+ if (cache.formSync.adopt(page.selectedExperimentId, page.formRevision)) {
+ actions.setSaveRequested(false)
+ actions.resetExperimentForm(page.experimentForm)
+ } else if (values.saveRequested && !page.saving && page.saveResult) {
+ actions.setSaveRequested(false)
+ }
+ },
+ })),
+])
diff --git a/frontend/src/toolbar/extension/extensionMoreLogic.ts b/frontend/src/toolbar/extension/extensionMoreLogic.ts
new file mode 100644
index 000000000000..cb8968fd0dd8
--- /dev/null
+++ b/frontend/src/toolbar/extension/extensionMoreLogic.ts
@@ -0,0 +1,122 @@
+import { MakeLogicType, actions, connect, kea, listeners, path, reducers, selectors } from 'kea'
+
+import { openTab } from './extensionBrowser'
+import type { PageMoreCommand } from './extensionPageMoreLogic'
+import { extensionPageToolbarConnectionLogic } from './extensionPageToolbarConnectionLogic'
+import { capturePageToolUsed } from './extensionTelemetry'
+import { PageToolbarMoreState, PageToolbarState } from './pageToolbarBridge'
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionMoreLogicValues {
+ pageToolbarState: PageToolbarState | null // extensionPageToolbarConnectionLogic
+ screenshotPreview: string | null // extensionPageToolbarConnectionLogic
+ moreState: PageToolbarMoreState | null
+ screenshotEventName: string
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionMoreLogicActions {
+ sendCommand: (message: import('./pageToolbarBridge').PageToolbarCommand) => {
+ message: import('./pageToolbarBridge').PageToolbarCommand
+ } // extensionPageToolbarConnectionLogic
+ closeScreenshot: () => {
+ value: true
+ }
+ openSessionRecording: (url: string) => {
+ url: string
+ }
+ selectScreenshotEvent: (
+ id: string,
+ name: string
+ ) => {
+ id: string
+ name: string
+ }
+ sendMoreCommand: (command: PageMoreCommand) => {
+ command: PageMoreCommand
+ }
+ setPiiMasking: (enabled: boolean) => {
+ enabled: boolean
+ }
+ setScreenshotEventName: (name: string) => {
+ name: string
+ }
+ takeScreenshot: () => {
+ value: true
+ }
+ uploadScreenshot: () => {
+ value: true
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionMoreLogicMeta {
+ __keaTypeGenInternalSelectorTypes: {
+ moreState: (pageToolbarState: PageToolbarState | null) => PageToolbarMoreState | null
+ }
+}
+
+export type extensionMoreLogicType = MakeLogicType<
+ extensionMoreLogicValues,
+ extensionMoreLogicActions,
+ Record<string, any>,
+ extensionMoreLogicMeta
+>
+
+/** The panel side of the toolbar's "More" menu tools. */
+export const extensionMoreLogic = kea<extensionMoreLogicType>([
+ path(['toolbar', 'extension', 'extensionMoreLogic']),
+ connect(() => ({
+ values: [extensionPageToolbarConnectionLogic, ['pageToolbarState', 'screenshotPreview']],
+ actions: [extensionPageToolbarConnectionLogic, ['sendCommand']],
+ })),
+ actions({
+ sendMoreCommand: (command: PageMoreCommand) => ({ command }),
+ openSessionRecording: (url: string) => ({ url }),
+ setPiiMasking: (enabled: boolean) => ({ enabled }),
+ takeScreenshot: true,
+ setScreenshotEventName: (name: string) => ({ name }),
+ selectScreenshotEvent: (id: string, name: string) => ({ id, name }),
+ uploadScreenshot: true,
+ closeScreenshot: true,
+ }),
+ reducers({
+ // The page searches event names a moment later, so the input keeps what the user typed meanwhile.
+ screenshotEventName: [
+ '',
+ {
+ setScreenshotEventName: (_, { name }) => name,
+ selectScreenshotEvent: (_, { name }) => name,
+ closeScreenshot: () => '',
+ takeScreenshot: () => '',
+ },
+ ],
+ }),
+ selectors({
+ moreState: [
+ (s) => [s.pageToolbarState],
+ (pageToolbarState: PageToolbarState | null): PageToolbarMoreState | null => pageToolbarState?.more ?? null,
+ ],
+ }),
+ listeners(({ actions }) => ({
+ sendMoreCommand: ({ command }) => actions.sendCommand({ tool: 'more', command }),
+ openSessionRecording: ({ url }) => {
+ void openTab(url)
+ capturePageToolUsed('view-session-recording')
+ },
+ setPiiMasking: ({ enabled }) => {
+ actions.sendMoreCommand({ type: 'set-pii-masking', enabled })
+ if (enabled) {
+ capturePageToolUsed('pii-masking')
+ }
+ },
+ takeScreenshot: () => actions.sendMoreCommand({ type: 'take-screenshot' }),
+ setScreenshotEventName: ({ name }) => actions.sendMoreCommand({ type: 'set-screenshot-event-name', name }),
+ selectScreenshotEvent: ({ id }) => actions.sendMoreCommand({ type: 'select-screenshot-event', id }),
+ uploadScreenshot: () => {
+ actions.sendMoreCommand({ type: 'upload-screenshot' })
+ capturePageToolUsed('screenshot-for-event')
+ },
+ closeScreenshot: () => actions.sendMoreCommand({ type: 'close-screenshot' }),
+ })),
+])
diff --git a/frontend/src/toolbar/extension/extensionPageEventsLogic.ts b/frontend/src/toolbar/extension/extensionPageEventsLogic.ts
new file mode 100644
index 000000000000..540be3b5b3c8
--- /dev/null
+++ b/frontend/src/toolbar/extension/extensionPageEventsLogic.ts
@@ -0,0 +1,280 @@
+import { MakeLogicType, actions, connect, kea, listeners, path, props, reducers, selectors } from 'kea'
+import { subscriptions } from 'kea-subscriptions'
+import type { PostHog } from 'posthog-js'
+
+import { downloadEventsAsJson } from '~/toolbar/debug/downloadEventsAsJson'
+import type { EventCategory } from '~/toolbar/debug/eventCategories'
+import { eventDebugMenuLogic } from '~/toolbar/debug/eventDebugMenuLogic'
+import { toolbarConfigLogic } from '~/toolbar/toolbarConfigLogic'
+import type { EventType } from '~/types'
+
+import type { PagePosthogBridge } from './pagePosthogBridge'
+import type { DebugEventRow, PageToolbarEventsState } from './pageToolbarBridge'
+
+// Every change to the events slice carries the rows, so the panel gets the newest events only. The debugger keeps more.
+const MAX_PANEL_EVENT_ROWS = 200
+
+export type PageEventsCommand =
+ | { type: 'set-events-search'; searchText: string }
+ | { type: 'set-event-type-enabled'; eventType: EventCategory; enabled: boolean }
+ | { type: 'set-hide-posthog-properties'; hide: boolean }
+ | { type: 'set-hide-posthog-flags'; hide: boolean }
+ | { type: 'expand-event'; uuid: string | null }
+ | { type: 'toggle-pinned-event'; uuid: string }
+ | { type: 'toggle-relative-timestamps' }
+ | { type: 'toggle-events-paused' }
+ | { type: 'clear-events' }
+ | { type: 'export-events' }
+
+export interface ExtensionPageEventsLogicProps {
+ /** Null when the page has no `window.posthog`. */
+ posthogBridge: PagePosthogBridge | null
+}
+
+export const EMPTY_PAGE_EVENTS_STATE: PageToolbarEventsState = {
+ available: false,
+ selectedEventTypes: [],
+ hidePostHogProperties: false,
+ hidePostHogFlags: false,
+ relativeTimestamps: false,
+ isPaused: false,
+ bufferedCount: 0,
+ totalCount: 0,
+ filteredCount: 0,
+ countsByType: { posthog: 0, custom: 0, snapshot: 0 },
+ rows: [],
+ expandedEventId: null,
+ expandedProperties: {},
+ expandedEventPayload: null,
+}
+
+function eventRow(event: EventType, pinned: boolean): DebugEventRow {
+ return { uuid: event.uuid ?? '', event: event.event, timestamp: String(event.timestamp), pinned }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionPageEventsLogicValues {
+ activeFilteredEvents: EventType[] // eventDebugMenuLogic
+ bufferedCount: number // eventDebugMenuLogic
+ events: EventType[] // eventDebugMenuLogic
+ expandedEvent: string | null | undefined // eventDebugMenuLogic
+ expandedProperties: Record<string, any> | never[] // eventDebugMenuLogic
+ exportableEvents: object[] // eventDebugMenuLogic
+ hidePostHogFlags: boolean // eventDebugMenuLogic
+ hidePostHogProperties: boolean // eventDebugMenuLogic
+ isPaused: boolean // eventDebugMenuLogic
+ pinnedEvents: EventType[] // eventDebugMenuLogic
+ relativeTimestamps: boolean // eventDebugMenuLogic
+ searchFilteredEventsCount: Record<EventCategory, number> // eventDebugMenuLogic
+ selectedEventTypes: EventCategory[] // eventDebugMenuLogic
+ totalEventsCount: number // eventDebugMenuLogic
+ unpinnedEvents: EventType[] // eventDebugMenuLogic
+ posthog: PostHog | null // toolbarConfigLogic
+ expandedEventPayload: Record<string, unknown> | null
+ open: boolean
+ pageState: PageToolbarEventsState
+ rows: DebugEventRow[]
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionPageEventsLogicActions {
+ handleCommand: (command: PageEventsCommand) => {
+ command: PageEventsCommand
+ }
+ setOpen: (open: boolean) => {
+ open: boolean
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionPageEventsLogicMeta {
+ __keaTypeGenInternalSelectorTypes: {
+ rows: (open: boolean, pinnedEvents: EventType[], unpinnedEvents: EventType[]) => DebugEventRow[]
+ expandedEventPayload: (
+ open: boolean,
+ expandedEvent: string | null | undefined,
+ events: EventType[]
+ ) => Record<string, unknown> | null
+ pageState: (
+ posthog: PostHog | null,
+ open: boolean,
+ selectedEventTypes: EventCategory[],
+ hidePostHogProperties: boolean,
+ hidePostHogFlags: boolean,
+ relativeTimestamps: boolean,
+ isPaused: boolean,
+ bufferedCount: number,
+ totalEventsCount: number,
+ activeFilteredEvents: EventType[],
+ searchFilteredEventsCount: Record<EventCategory, number>,
+ rows: DebugEventRow[],
+ expandedEvent: string | null | undefined,
+ expandedProperties: Record<string, any> | never[],
+ expandedEventPayload: Record<string, unknown> | null
+ ) => PageToolbarEventsState
+ }
+}
+
+export type extensionPageEventsLogicType = MakeLogicType<
+ extensionPageEventsLogicValues,
+ extensionPageEventsLogicActions,
+ ExtensionPageEventsLogicProps,
+ extensionPageEventsLogicMeta
+>
+
+/** Runs in the content script, from the first time the user opens the events tool. */
+export const extensionPageEventsLogic = kea<extensionPageEventsLogicType>([
+ path(['toolbar', 'extension', 'extensionPageEventsLogic']),
+ props({} as ExtensionPageEventsLogicProps),
+ connect(() => ({
+ values: [
+ eventDebugMenuLogic,
+ [
+ 'selectedEventTypes',
+ 'hidePostHogProperties',
+ 'hidePostHogFlags',
+ 'relativeTimestamps',
+ 'isPaused',
+ 'bufferedCount',
+ 'totalEventsCount',
+ 'activeFilteredEvents',
+ 'searchFilteredEventsCount',
+ 'pinnedEvents',
+ 'unpinnedEvents',
+ 'expandedEvent',
+ 'expandedProperties',
+ 'events',
+ 'exportableEvents',
+ ],
+ toolbarConfigLogic,
+ ['posthog'],
+ ],
+ })),
+ actions({
+ handleCommand: (command: PageEventsCommand) => ({ command }),
+ setOpen: (open: boolean) => ({ open }),
+ }),
+ reducers({
+ open: [true, { setOpen: (_, { open }) => open }],
+ }),
+ selectors({
+ rows: [
+ (s) => [s.open, s.pinnedEvents, s.unpinnedEvents],
+ (open: boolean, pinnedEvents: EventType[], unpinnedEvents: EventType[]): DebugEventRow[] => {
+ // A closed debugger keeps collecting, but sends no rows until it opens again.
+ if (!open) {
+ return []
+ }
+ const pinnedRows = pinnedEvents.slice(0, MAX_PANEL_EVENT_ROWS).map((event) => eventRow(event, true))
+ const unpinnedRows = unpinnedEvents
+ .slice(0, MAX_PANEL_EVENT_ROWS - pinnedRows.length)
+ .map((event) => eventRow(event, false))
+ return [...pinnedRows, ...unpinnedRows]
+ },
+ ],
+ expandedEventPayload: [
+ (s) => [s.open, s.expandedEvent, s.events],
+ (open: boolean, expandedEventId: string | null, events: EventType[]): Record<string, unknown> | null => {
+ const event = open && expandedEventId ? events.find(({ uuid }) => uuid === expandedEventId) : undefined
+ return event
+ ? { event: event.event, timestamp: event.timestamp, properties: event.properties, uuid: event.uuid }
+ : null
+ },
+ ],
+ pageState: [
+ (s) => [
+ s.posthog,
+ s.open,
+ s.selectedEventTypes,
+ s.hidePostHogProperties,
+ s.hidePostHogFlags,
+ s.relativeTimestamps,
+ s.isPaused,
+ s.bufferedCount,
+ s.totalEventsCount,
+ s.activeFilteredEvents,
+ s.searchFilteredEventsCount,
+ s.rows,
+ s.expandedEvent,
+ s.expandedProperties,
+ s.expandedEventPayload,
+ ],
+ (
+ posthog: PostHog | null,
+ open: boolean,
+ selectedEventTypes: EventCategory[],
+ hidePostHogProperties: boolean,
+ hidePostHogFlags: boolean,
+ relativeTimestamps: boolean,
+ isPaused: boolean,
+ bufferedCount: number,
+ totalEventsCount: number,
+ activeFilteredEvents: EventType[],
+ searchFilteredEventsCount: Record<EventCategory, number>,
+ rows: DebugEventRow[],
+ expandedEvent: string | null,
+ expandedProperties: Record<string, unknown> | unknown[],
+ expandedEventPayload: Record<string, unknown> | null
+ ): PageToolbarEventsState => ({
+ available: !!posthog,
+ selectedEventTypes,
+ hidePostHogProperties,
+ hidePostHogFlags,
+ relativeTimestamps,
+ isPaused,
+ bufferedCount,
+ totalCount: totalEventsCount,
+ filteredCount: activeFilteredEvents.length,
+ countsByType: searchFilteredEventsCount,
+ rows,
+ expandedEventId: expandedEvent ?? null,
+ expandedProperties: open && !Array.isArray(expandedProperties) ? expandedProperties : {},
+ expandedEventPayload,
+ }),
+ ],
+ }),
+ listeners(({ values }) => ({
+ handleCommand: ({ command }) => {
+ const debug = eventDebugMenuLogic.actions
+ switch (command.type) {
+ case 'set-events-search':
+ debug.setSearchText(command.searchText)
+ return
+ case 'set-event-type-enabled':
+ debug.setSelectedEventType(command.eventType, command.enabled)
+ return
+ case 'set-hide-posthog-properties':
+ debug.setHidePostHogProperties(command.hide)
+ return
+ case 'set-hide-posthog-flags':
+ debug.setHidePostHogFlags(command.hide)
+ return
+ case 'expand-event':
+ debug.markExpanded(command.uuid)
+ return
+ case 'toggle-pinned-event':
+ debug.togglePinnedEvent(command.uuid)
+ return
+ case 'toggle-relative-timestamps':
+ debug.toggleRelativeTimestamps()
+ return
+ case 'toggle-events-paused':
+ debug.togglePaused()
+ return
+ case 'clear-events':
+ debug.clearEvents()
+ return
+ case 'export-events':
+ // The download starts from the page, which keeps every event. The panel only has the newest rows.
+ downloadEventsAsJson(values.exportableEvents)
+ return
+ }
+ },
+ })),
+ subscriptions(({ props }) => ({
+ selectedEventTypes: (selectedEventTypes: EventCategory[]) => {
+ // Snapshot events carry the page's recording, so the page sends their payload only to a debugger that shows them.
+ props.posthogBridge?.setForwardSnapshotPayloads(selectedEventTypes.includes('snapshot'))
+ },
+ })),
+])
diff --git a/frontend/src/toolbar/extension/extensionPageExperimentsLogic.ts b/frontend/src/toolbar/extension/extensionPageExperimentsLogic.ts
new file mode 100644
index 000000000000..910c1079ef45
--- /dev/null
+++ b/frontend/src/toolbar/extension/extensionPageExperimentsLogic.ts
@@ -0,0 +1,339 @@
+import { MakeLogicType, actions, connect, kea, listeners, path, reducers, selectors } from 'kea'
+import type { PostHog } from 'posthog-js'
+
+import type { ElementSelectorType } from '~/toolbar/experiments/elementSelectorTypes'
+import { experimentsLogic } from '~/toolbar/experiments/experimentsLogic'
+import { experimentsTabLogic, restoreOriginalHtmlState } from '~/toolbar/experiments/experimentsTabLogic'
+import { toolbarConfigLogic } from '~/toolbar/toolbarConfigLogic'
+import type { WebExperiment, WebExperimentForm } from '~/toolbar/types'
+
+import type { ExperimentFormDraft, ExperimentSaveResult, PageToolbarExperimentsState } from './pageToolbarBridge'
+
+/** Finds the element like posthog-js applies web experiments, without entering shadow roots. */
+function querySelectorInDocument(selector: string): HTMLElement | null {
+ try {
+ return document.querySelector<HTMLElement>(selector)
+ } catch {
+ return null
+ }
+}
+
+export type PageExperimentsCommand =
+ | { type: 'select-experiment'; id: number | 'new' | null }
+ | { type: 'set-experiment-form'; form: ExperimentFormDraft }
+ /** A null variant closes the open variant and shows the page as it was. */
+ | { type: 'select-experiment-variant'; variant: string | null }
+ | { type: 'add-experiment-variant' }
+ | { type: 'remove-experiment-variant'; variant: string }
+ | { type: 'add-experiment-transform'; variant: string }
+ | { type: 'remove-experiment-transform'; variant: string; index: number }
+ | { type: 'set-experiment-element-type'; elementType: ElementSelectorType }
+ | { type: 'inspect-for-experiment-transform'; variant: string; index: number | null }
+ | { type: 'set-experiment-transform-selector'; variant: string; index: number; selector: string }
+ | { type: 'save-experiment' }
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionPageExperimentsLogicValues {
+ allExperimentsLoading: boolean // experimentsLogic
+ sortedExperiments: WebExperiment[] // experimentsLogic
+ addVariantAvailable: boolean | undefined // experimentsTabLogic
+ experimentForm: WebExperimentForm // experimentsTabLogic
+ inspectingElement: number | null // experimentsTabLogic
+ isExperimentFormSubmitting: boolean // experimentsTabLogic
+ removeVariantAvailable: boolean | undefined // experimentsTabLogic
+ selectedElementType: ElementSelectorType // experimentsTabLogic
+ selectedVariant: string // experimentsTabLogic
+ posthog: PostHog | null // toolbarConfigLogic
+ experimentFormDraft: ExperimentFormDraft
+ experimentsList: PageToolbarExperimentsState['experiments']
+ formRevision: number
+ pageState: PageToolbarExperimentsState
+ saveResult: ExperimentSaveResult | null
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionPageExperimentsLogicActions {
+ updateExperiment: (args_0: { experiment: WebExperiment }) => {
+ experiment: WebExperiment
+ } // experimentsLogic
+ addNewTransformation: (variant: string) => {
+ variant: string
+ } // experimentsTabLogic
+ addNewVariant: () => {} // experimentsTabLogic
+ inspectElementSelected: (
+ element: HTMLElement,
+ variant: string,
+ index: number | null,
+ selector?: string | null | undefined
+ ) => {
+ element: HTMLElement
+ index: number | null
+ selector: string | null | undefined
+ variant: string
+ } // experimentsTabLogic
+ newExperiment: (element?: HTMLElement | undefined) => {
+ element: HTMLElement | null
+ } // experimentsTabLogic
+ removeElement: (
+ variant: string,
+ index: number
+ ) => {
+ index: number
+ variant: string
+ } // experimentsTabLogic
+ removeVariant: (variant: string) => {
+ variant: string
+ } // experimentsTabLogic
+ selectExperiment: (id: null | import('../../types').ExperimentIdType) => {
+ id: null | import('../../types').ExperimentIdType
+ } // experimentsTabLogic
+ submitExperimentForm: () => {
+ value: boolean
+ } // experimentsTabLogic
+ submitExperimentFormFailure: (
+ error: Error,
+ errors: Record<string, any>
+ ) => {
+ error: Error
+ errors: Record<string, any>
+ } // experimentsTabLogic
+ closeExperiments: () => {
+ value: true
+ }
+ handleCommand: (command: PageExperimentsCommand) => {
+ command: PageExperimentsCommand
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionPageExperimentsLogicMeta {
+ __keaTypeGenInternalSelectorTypes: {
+ experimentsList: (sortedExperiments: WebExperiment[]) => PageToolbarExperimentsState['experiments']
+ experimentFormDraft: (experimentForm: WebExperimentForm) => ExperimentFormDraft
+ pageState: (
+ allExperimentsLoading: boolean,
+ experimentsList: {
+ id: number
+ name: string | null
+ }[],
+ posthog: PostHog | null,
+ selectedExperimentId: number | 'new' | 'web' | null,
+ experimentFormDraft: ExperimentFormDraft,
+ formRevision: number,
+ selectedVariant: string,
+ selectedElementType: ElementSelectorType,
+ inspectingElement: number | null,
+ addVariantAvailable: boolean | undefined,
+ removeVariantAvailable: boolean | undefined,
+ isExperimentFormSubmitting: boolean,
+ saveResult: ExperimentSaveResult | null
+ ) => PageToolbarExperimentsState
+ }
+}
+
+export type extensionPageExperimentsLogicType = MakeLogicType<
+ extensionPageExperimentsLogicValues,
+ extensionPageExperimentsLogicActions,
+ Record<string, any>,
+ extensionPageExperimentsLogicMeta
+>
+
+export const extensionPageExperimentsLogic = kea<extensionPageExperimentsLogicType>([
+ path(['toolbar', 'extension', 'extensionPageExperimentsLogic']),
+ connect(() => ({
+ values: [
+ experimentsLogic,
+ ['sortedExperiments', 'allExperimentsLoading'],
+ experimentsTabLogic,
+ [
+ 'experimentForm',
+ 'selectedVariant',
+ 'selectedElementType',
+ 'inspectingElement',
+ 'addVariantAvailable',
+ 'removeVariantAvailable',
+ 'isExperimentFormSubmitting',
+ ],
+ toolbarConfigLogic,
+ ['posthog'],
+ ],
+ actions: [
+ experimentsTabLogic,
+ [
+ 'selectExperiment',
+ 'newExperiment',
+ 'inspectElementSelected',
+ 'addNewVariant',
+ 'removeVariant',
+ 'addNewTransformation',
+ 'removeElement',
+ 'submitExperimentForm',
+ 'submitExperimentFormFailure',
+ ],
+ experimentsLogic,
+ ['updateExperiment'],
+ ],
+ })),
+ actions({
+ handleCommand: (command: PageExperimentsCommand) => ({ command }),
+ closeExperiments: true,
+ }),
+ reducers({
+ formRevision: [
+ 0,
+ {
+ selectExperiment: (revision) => revision + 1,
+ newExperiment: (revision) => revision + 1,
+ inspectElementSelected: (revision) => revision + 1,
+ addNewVariant: (revision) => revision + 1,
+ removeVariant: (revision) => revision + 1,
+ addNewTransformation: (revision) => revision + 1,
+ removeElement: (revision) => revision + 1,
+ },
+ ],
+ saveResult: [
+ null as ExperimentSaveResult | null,
+ {
+ updateExperiment: (_, { experiment }) => ({
+ status: 'saved' as const,
+ experimentId: Number(experiment.id),
+ name: experiment.name ?? null,
+ }),
+ submitExperimentFormFailure: (_, { error }) => ({
+ status: 'failed' as const,
+ error: error?.message || 'Check the form and try again.',
+ }),
+ // A save clears the selection, which must keep the result for the list to show.
+ selectExperiment: (saveResult, { id }) => (id === null ? saveResult : null),
+ newExperiment: () => null,
+ submitExperimentForm: () => null,
+ closeExperiments: () => null,
+ },
+ ],
+ }),
+ selectors({
+ experimentsList: [
+ (s) => [s.sortedExperiments],
+ (sortedExperiments: WebExperiment[]): PageToolbarExperimentsState['experiments'] =>
+ sortedExperiments.map(({ id, name }) => ({ id: Number(id), name: name ?? null })),
+ ],
+ experimentFormDraft: [
+ (s) => [s.experimentForm],
+ (experimentForm: WebExperimentForm): ExperimentFormDraft => ({
+ name: experimentForm.name,
+ variants: experimentForm.variants ?? {},
+ }),
+ ],
+ pageState: [
+ (s) => [
+ s.allExperimentsLoading,
+ s.experimentsList,
+ s.posthog,
+ // kea-typegen drops the 'new' literal when it copies a connected value's type, so read the selector.
+ experimentsTabLogic.selectors.selectedExperimentId,
+ s.experimentFormDraft,
+ s.formRevision,
+ s.selectedVariant,
+ s.selectedElementType,
+ s.inspectingElement,
+ s.addVariantAvailable,
+ s.removeVariantAvailable,
+ s.isExperimentFormSubmitting,
+ s.saveResult,
+ ],
+ (
+ allExperimentsLoading: boolean,
+ experimentsList: PageToolbarExperimentsState['experiments'],
+ posthog: PostHog | null,
+ selectedExperimentId: number | 'new' | 'web' | null,
+ experimentFormDraft: ExperimentFormDraft,
+ formRevision: number,
+ selectedVariant: string,
+ selectedElementType: ElementSelectorType,
+ inspectingElement: number | null,
+ addVariantAvailable: boolean | undefined,
+ removeVariantAvailable: boolean | undefined,
+ isExperimentFormSubmitting: boolean,
+ saveResult: ExperimentSaveResult | null
+ ): PageToolbarExperimentsState => ({
+ loading: allExperimentsLoading,
+ experiments: experimentsList,
+ webExperimentsDisabled: !!posthog?.config?.disable_web_experiments,
+ selectedExperimentId: selectedExperimentId === 'web' ? null : selectedExperimentId,
+ experimentForm: experimentFormDraft,
+ formRevision,
+ selectedVariant,
+ selectedElementType,
+ inspectingElement,
+ addVariantAvailable: !!addVariantAvailable,
+ removeVariantAvailable: !!removeVariantAvailable,
+ saving: isExperimentFormSubmitting,
+ saveResult,
+ }),
+ ],
+ }),
+ listeners(({ values }) => ({
+ closeExperiments: () => {
+ experimentsTabLogic.actions.selectExperiment(null)
+ experimentsTabLogic.actions.hideButtonExperiments()
+ },
+ handleCommand: ({ command }) => {
+ const tab = experimentsTabLogic.actions
+ switch (command.type) {
+ case 'select-experiment':
+ if (command.id === 'new') {
+ tab.newExperiment()
+ } else {
+ tab.selectExperiment(command.id)
+ }
+ return
+ case 'set-experiment-form':
+ tab.setExperimentFormValues(command.form)
+ // Shows the edited HTML and CSS on the page as the user types.
+ tab.applyVariant(values.selectedVariant)
+ return
+ case 'select-experiment-variant':
+ if (command.variant === null) {
+ tab.selectVariant('')
+ // The form keeps the original HTML, so leaving the experiment can still restore it.
+ restoreOriginalHtmlState(values.experimentForm.original_html_state)
+ return
+ }
+ tab.selectVariant(command.variant)
+ tab.applyVariant(command.variant)
+ return
+ case 'add-experiment-variant':
+ tab.addNewVariant()
+ return
+ case 'remove-experiment-variant':
+ tab.removeVariant(command.variant)
+ tab.applyVariant('control')
+ return
+ case 'add-experiment-transform':
+ tab.addNewTransformation(command.variant)
+ return
+ case 'remove-experiment-transform':
+ tab.removeElement(command.variant, command.index)
+ tab.applyVariant(values.selectedVariant)
+ return
+ case 'set-experiment-element-type':
+ tab.selectElementType(command.elementType)
+ return
+ case 'inspect-for-experiment-transform':
+ tab.selectVariant(command.variant)
+ tab.inspectForElementWithIndex(command.variant, values.selectedElementType, command.index)
+ return
+ case 'set-experiment-transform-selector': {
+ const element = querySelectorInDocument(command.selector)
+ if (element) {
+ tab.inspectElementSelected(element, command.variant, command.index, command.selector)
+ }
+ return
+ }
+ case 'save-experiment':
+ tab.submitExperimentForm()
+ return
+ }
+ },
+ })),
+])
diff --git a/frontend/src/toolbar/extension/extensionPageMoreLogic.ts b/frontend/src/toolbar/extension/extensionPageMoreLogic.ts
new file mode 100644
index 000000000000..0e3817e1b8bf
--- /dev/null
+++ b/frontend/src/toolbar/extension/extensionPageMoreLogic.ts
@@ -0,0 +1,377 @@
+import { MakeLogicType, actions, afterMount, connect, kea, listeners, path, props, reducers, selectors } from 'kea'
+import { loaders } from 'kea-loaders'
+import type { PostHog } from 'posthog-js'
+
+import {
+ DEFAULT_PII_MASKING_COLOR,
+ applyPiiMaskingStylesheet,
+ getPiiMaskingWarnings,
+} from '~/toolbar/bar/piiMaskingStyles'
+import { screenshotUploadLogic } from '~/toolbar/screenshot-upload/screenshotUploadLogic'
+import { toolbarConfigLogic } from '~/toolbar/toolbarConfigLogic'
+
+import type { EventDefinition } from '../../types'
+import type { PagePosthogBridge } from './pagePosthogBridge'
+import type { PageDebugInfo, PageToolbarMoreState } from './pageToolbarBridge'
+
+export type PageMoreCommand =
+ | { type: 'reload-debug-info' }
+ | { type: 'set-pii-masking'; enabled: boolean }
+ | { type: 'set-pii-masking-color'; color: string }
+ | { type: 'take-screenshot' }
+ | { type: 'set-screenshot-event-name'; name: string }
+ | { type: 'select-screenshot-event'; id: string }
+ | { type: 'upload-screenshot' }
+ | { type: 'close-screenshot' }
+
+// The floating toolbar's PII masking stylesheet has another id, so the two never remove each other's.
+const PII_MASKING_STYLESHEET_ID = 'posthog-toolbar-extension-pii-masking'
+
+// The panel shows the screenshot at its own width, so a small copy keeps the message light.
+const SCREENSHOT_PREVIEW_WIDTH = 640
+
+type ScreenshotResult = PageToolbarMoreState['screenshot']['result']
+
+async function previewDataUrl(objectUrl: string): Promise<string> {
+ const image = new Image()
+ image.src = objectUrl
+ await image.decode()
+ const scale = Math.min(1, SCREENSHOT_PREVIEW_WIDTH / image.naturalWidth)
+ const canvas = document.createElement('canvas')
+ canvas.width = Math.round(image.naturalWidth * scale)
+ canvas.height = Math.round(image.naturalHeight * scale)
+ canvas.getContext('2d')?.drawImage(image, 0, 0, canvas.width, canvas.height)
+ return canvas.toDataURL('image/jpeg', 0.8)
+}
+
+interface ExtensionPageMoreLogicProps {
+ /** Null when the page has no `window.posthog`. */
+ posthogBridge: PagePosthogBridge | null
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionPageMoreLogicValues {
+ eventDefinitions: EventDefinition[] // screenshotUploadLogic
+ eventDefinitionsLoading: boolean // screenshotUploadLogic
+ eventName: string // screenshotUploadLogic
+ isModalOpen: boolean // screenshotUploadLogic
+ isTakingScreenshot: boolean // screenshotUploadLogic
+ selectedDefinition: EventDefinition | null // screenshotUploadLogic
+ uploadResultLoading: boolean // screenshotUploadLogic
+ posthog: PostHog | null // toolbarConfigLogic
+ debugInfo: PageDebugInfo | null
+ debugInfoLoading: boolean
+ pageState: PageToolbarMoreState
+ piiMaskingColor: string
+ piiMaskingEnabled: boolean
+ piiWarnings: string[]
+ screenshotPreview: string | null
+ screenshotResult: ScreenshotResult
+ suggestions: PageToolbarMoreState['screenshot']['suggestions']
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionPageMoreLogicActions {
+ closeModal: () => {
+ value: true
+ } // screenshotUploadLogic
+ openModal: (previewUrl: string) => {
+ previewUrl: string
+ } // screenshotUploadLogic
+ submitUpload: (_: any) => any // screenshotUploadLogic
+ submitUploadFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ } // screenshotUploadLogic
+ submitUploadSuccess: (
+ uploadResult: {
+ success: true
+ },
+ payload?: any
+ ) => {
+ payload?: any
+ uploadResult: {
+ success: true
+ }
+ } // screenshotUploadLogic
+ takeScreenshot: () => {
+ value: true
+ } // screenshotUploadLogic
+ takeScreenshotFailure: (error: string) => {
+ error: string
+ } // screenshotUploadLogic
+ handleCommand: (command: PageMoreCommand) => {
+ command: PageMoreCommand
+ }
+ loadDebugInfo: () => any
+ loadDebugInfoFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ }
+ loadDebugInfoSuccess: (
+ debugInfo: PageDebugInfo | null,
+ payload?: any
+ ) => {
+ debugInfo: PageDebugInfo | null
+ payload?: any
+ }
+ openMore: () => {
+ value: true
+ }
+ setPiiMaskingColor: (color: string) => {
+ color: string
+ }
+ setPiiMaskingEnabled: (enabled: boolean) => {
+ enabled: boolean
+ }
+ setScreenshotPreview: (dataUrl: string | null) => {
+ dataUrl: string | null
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionPageMoreLogicMeta {
+ __keaTypeGenInternalSelectorTypes: {
+ piiWarnings: (posthog: PostHog | null, piiMaskingEnabled: boolean) => string[]
+ suggestions: (eventDefinitions: EventDefinition[]) => PageToolbarMoreState['screenshot']['suggestions']
+ pageState: (
+ debugInfo: PageDebugInfo | null,
+ debugInfoLoading: boolean,
+ piiMaskingEnabled: boolean,
+ piiMaskingColor: string,
+ piiWarnings: string[],
+ isTakingScreenshot: boolean,
+ isModalOpen: boolean,
+ eventName: string,
+ suggestions: {
+ id: string
+ name: string
+ }[],
+ eventDefinitionsLoading: boolean,
+ selectedDefinition: EventDefinition | null,
+ uploadResultLoading: boolean,
+ screenshotResult:
+ | {
+ status: 'uploaded'
+ }
+ | {
+ error: string
+ status: 'failed'
+ }
+ | null
+ ) => PageToolbarMoreState
+ }
+}
+
+export type extensionPageMoreLogicType = MakeLogicType<
+ extensionPageMoreLogicValues,
+ extensionPageMoreLogicActions,
+ ExtensionPageMoreLogicProps,
+ extensionPageMoreLogicMeta
+>
+
+/** Runs in the content script for the toolbar's "More" menu tools. */
+export const extensionPageMoreLogic = kea<extensionPageMoreLogicType>([
+ path(['toolbar', 'extension', 'extensionPageMoreLogic']),
+ props({} as ExtensionPageMoreLogicProps),
+ connect(() => ({
+ values: [
+ toolbarConfigLogic,
+ ['posthog'],
+ screenshotUploadLogic,
+ [
+ 'isTakingScreenshot',
+ 'isModalOpen',
+ 'eventName',
+ 'eventDefinitions',
+ 'eventDefinitionsLoading',
+ 'selectedDefinition',
+ 'uploadResultLoading',
+ ],
+ ],
+ actions: [
+ screenshotUploadLogic,
+ [
+ 'takeScreenshot',
+ 'takeScreenshotFailure',
+ 'openModal',
+ 'closeModal',
+ 'submitUpload',
+ 'submitUploadSuccess',
+ 'submitUploadFailure',
+ ],
+ ],
+ })),
+ actions({
+ openMore: true,
+ handleCommand: (command: PageMoreCommand) => ({ command }),
+ setPiiMaskingEnabled: (enabled: boolean) => ({ enabled }),
+ setPiiMaskingColor: (color: string) => ({ color }),
+ setScreenshotPreview: (dataUrl: string | null) => ({ dataUrl }),
+ }),
+ loaders(({ props }) => ({
+ debugInfo: [
+ null as PageDebugInfo | null,
+ {
+ loadDebugInfo: async () => (await props.posthogBridge?.readDebugInfo()) ?? null,
+ },
+ ],
+ })),
+ reducers({
+ piiMaskingEnabled: [false, { persist: true }, { setPiiMaskingEnabled: (_, { enabled }) => enabled }],
+ piiMaskingColor: [
+ DEFAULT_PII_MASKING_COLOR as string,
+ { persist: true },
+ { setPiiMaskingColor: (_, { color }) => color },
+ ],
+ // The host sends the preview in its own message, so it stays out of the state the panel gets on every change.
+ screenshotPreview: [
+ null as string | null,
+ { setScreenshotPreview: (_, { dataUrl }) => dataUrl, closeModal: () => null },
+ ],
+ screenshotResult: [
+ null as ScreenshotResult,
+ {
+ takeScreenshot: () => null,
+ submitUpload: () => null,
+ submitUploadSuccess: () => ({ status: 'uploaded' }),
+ submitUploadFailure: (_, { error }) => ({ status: 'failed', error }),
+ takeScreenshotFailure: (_, { error }) => ({ status: 'failed', error }),
+ },
+ ],
+ }),
+ selectors({
+ piiWarnings: [
+ (s) => [s.posthog, s.piiMaskingEnabled],
+ (posthog: PostHog | null, piiMaskingEnabled: boolean): string[] =>
+ posthog && piiMaskingEnabled ? getPiiMaskingWarnings(posthog) : [],
+ ],
+ suggestions: [
+ (s) => [s.eventDefinitions],
+ (eventDefinitions: EventDefinition[]): PageToolbarMoreState['screenshot']['suggestions'] =>
+ eventDefinitions.map(({ id, name }) => ({ id, name })),
+ ],
+ pageState: [
+ (s) => [
+ s.debugInfo,
+ s.debugInfoLoading,
+ s.piiMaskingEnabled,
+ s.piiMaskingColor,
+ s.piiWarnings,
+ s.isTakingScreenshot,
+ s.isModalOpen,
+ s.eventName,
+ s.suggestions,
+ s.eventDefinitionsLoading,
+ s.selectedDefinition,
+ s.uploadResultLoading,
+ s.screenshotResult,
+ ],
+ (
+ debugInfo: PageDebugInfo | null,
+ debugInfoLoading: boolean,
+ piiMaskingEnabled: boolean,
+ piiMaskingColor: string,
+ piiWarnings: string[],
+ isTakingScreenshot: boolean,
+ isModalOpen: boolean,
+ eventName: string,
+ suggestions: PageToolbarMoreState['screenshot']['suggestions'],
+ eventDefinitionsLoading: boolean,
+ selectedDefinition: EventDefinition | null,
+ uploadResultLoading: boolean,
+ screenshotResult: ScreenshotResult
+ ): PageToolbarMoreState => ({
+ debugInfo,
+ debugInfoLoading,
+ piiMaskingEnabled,
+ piiMaskingColor,
+ piiWarnings,
+ screenshot: {
+ taking: isTakingScreenshot,
+ open: isModalOpen,
+ eventName,
+ suggestions,
+ suggestionsLoading: eventDefinitionsLoading,
+ selectedEventId: selectedDefinition?.id ?? null,
+ uploading: uploadResultLoading,
+ result: screenshotResult,
+ },
+ }),
+ ],
+ }),
+ listeners(({ actions, values }) => {
+ const applyPiiMasking = (): void =>
+ applyPiiMaskingStylesheet(
+ PII_MASKING_STYLESHEET_ID,
+ values.piiMaskingEnabled,
+ values.piiMaskingColor,
+ values.posthog
+ )
+ return {
+ openMore: () => {
+ actions.loadDebugInfo()
+ },
+ setPiiMaskingEnabled: applyPiiMasking,
+ setPiiMaskingColor: applyPiiMasking,
+ openModal: async ({ previewUrl }) => {
+ try {
+ actions.setScreenshotPreview(await previewDataUrl(previewUrl))
+ } catch {
+ actions.takeScreenshotFailure("Couldn't read the screenshot")
+ }
+ },
+ handleCommand: ({ command }) => {
+ const screenshot = screenshotUploadLogic.actions
+ switch (command.type) {
+ case 'reload-debug-info':
+ actions.loadDebugInfo()
+ return
+ case 'set-pii-masking':
+ actions.setPiiMaskingEnabled(command.enabled)
+ return
+ case 'set-pii-masking-color':
+ actions.setPiiMaskingColor(command.color)
+ return
+ case 'take-screenshot':
+ screenshot.takeScreenshot()
+ return
+ case 'set-screenshot-event-name':
+ screenshot.setEventName(command.name)
+ return
+ case 'select-screenshot-event': {
+ const definition = values.eventDefinitions.find(({ id }) => id === command.id)
+ if (definition) {
+ screenshot.selectEvent(definition)
+ }
+ return
+ }
+ case 'upload-screenshot':
+ screenshot.submitUpload(null)
+ return
+ case 'close-screenshot':
+ screenshot.closeModal()
+ return
+ }
+ },
+ }
+ }),
+ afterMount(({ values, cache }) => {
+ cache.disposables.add(() => {
+ // A persisted preview comes back on with the page tools, like the floating toolbar's.
+ applyPiiMaskingStylesheet(
+ PII_MASKING_STYLESHEET_ID,
+ values.piiMaskingEnabled,
+ values.piiMaskingColor,
+ values.posthog
+ )
+ return () => applyPiiMaskingStylesheet(PII_MASKING_STYLESHEET_ID, false, values.piiMaskingColor, null)
+ }, 'piiMasking')
+ }),
+])
diff --git a/frontend/src/toolbar/extension/extensionPageToolbarConnectionLogic.ts b/frontend/src/toolbar/extension/extensionPageToolbarConnectionLogic.ts
index f625497ad31b..43c7dd6b935a 100644
--- a/frontend/src/toolbar/extension/extensionPageToolbarConnectionLogic.ts
+++ b/frontend/src/toolbar/extension/extensionPageToolbarConnectionLogic.ts
@@ -25,7 +25,8 @@ import {
PageToolbarState,
isPageToolbarMessage,
} from './pageToolbarBridge'
-import type { PageToolbarHeatmapState, PageToolbarInspectState, PageToolbarTokens } from './pageToolbarBridge'
+import type { PageToolbarTokens } from './pageToolbarBridge'
+import type { PageToolbarHeatmapState, PageToolbarInspectState, PageToolbarWebVitalsState } from './pageToolbarBridge'
export type PageToolbarConnectionStatus = 'idle' | 'connecting' | 'connected' | 'failed'
@@ -46,9 +47,12 @@ export interface extensionPageToolbarConnectionLogicValues {
mode: PageToolbarMode
pageToolbarState: PageToolbarState | null
requestedSelectors: string[]
+ screenshotPreview: string | null
selectedActionId: number | 'new' | null
+ selectedExperimentId: number | 'new' | null
selectorCounter: Pick<SelectorMatchCounter, 'count'>
wantedMode: PageToolbarMode
+ webVitals: PageToolbarWebVitalsState | null
wildcardHrefDraft: string | null
}
@@ -83,6 +87,9 @@ export interface extensionPageToolbarConnectionLogicActions {
receivePatch: (patch: Partial<PageToolbarState>) => {
patch: Partial<PageToolbarState>
}
+ receiveScreenshotPreview: (dataUrl: string) => {
+ dataUrl: string
+ }
receiveState: (state: PageToolbarState | null) => {
state: PageToolbarState | null
}
@@ -109,7 +116,9 @@ export interface extensionPageToolbarConnectionLogicMeta {
mode: (pageToolbarState: PageToolbarState | null, wantedMode: PageToolbarMode) => PageToolbarMode
inspect: (pageToolbarState: PageToolbarState | null) => PageToolbarInspectState | null
heatmap: (pageToolbarState: PageToolbarState | null) => PageToolbarHeatmapState | null
+ webVitals: (pageToolbarState: PageToolbarState | null) => PageToolbarWebVitalsState | null
selectedActionId: (pageToolbarState: PageToolbarState | null) => number | 'new' | null
+ selectedExperimentId: (pageToolbarState: PageToolbarState | null) => number | 'new' | null
selectorCounter: (pageToolbarState: PageToolbarState | null) => Pick<SelectorMatchCounter, 'count'>
}
}
@@ -137,6 +146,7 @@ export const extensionPageToolbarConnectionLogic = kea<extensionPageToolbarConne
setConnectionStatus: (status: PageToolbarConnectionStatus) => ({ status }),
receiveState: (state: PageToolbarState | null) => ({ state }),
receivePatch: (patch: Partial<PageToolbarState>) => ({ patch }),
+ receiveScreenshotPreview: (dataUrl: string) => ({ dataUrl }),
sendCommand: (message: PageToolbarCommand) => ({ message }),
setMode: (mode: PageToolbarMode) => ({ mode }),
setWildcardHref: (href: string) => ({ href }),
@@ -157,6 +167,10 @@ export const extensionPageToolbarConnectionLogic = kea<extensionPageToolbarConne
setTab: () => null,
},
],
+ screenshotPreview: [
+ null as string | null,
+ { receiveScreenshotPreview: (_, { dataUrl }) => dataUrl, receiveState: () => null, setTab: () => null },
+ ],
// The page echoes the URL back a moment later. Until then the input shows what the user typed, so a fast typist
// doesn't lose characters to an older echo.
wildcardHrefDraft: [
@@ -198,14 +212,25 @@ export const extensionPageToolbarConnectionLogic = kea<extensionPageToolbarConne
(s) => [s.pageToolbarState],
(pageToolbarState: PageToolbarState | null) => pageToolbarState?.heatmap ?? null,
],
+ webVitals: [
+ (s) => [s.pageToolbarState],
+ (pageToolbarState: PageToolbarState | null) => pageToolbarState?.webVitals ?? null,
+ ],
selectedActionId: [
(s) => [s.pageToolbarState],
(pageToolbarState: PageToolbarState | null) => pageToolbarState?.actions.selectedActionId ?? null,
],
+ selectedExperimentId: [
+ (s) => [s.pageToolbarState],
+ (pageToolbarState: PageToolbarState | null) => pageToolbarState?.experiments.selectedExperimentId ?? null,
+ ],
selectorCounter: [
(s) => [s.pageToolbarState],
(pageToolbarState: PageToolbarState | null): Pick<SelectorMatchCounter, 'count'> => ({
- count: (selector) => pageToolbarState?.selectorCounts[selector],
+ count: (selector, scope = 'deep') => {
+ const counts = pageToolbarState?.selectorCounts[selector]
+ return counts ? counts[scope] : counts
+ },
}),
],
}),
@@ -248,6 +273,8 @@ export const extensionPageToolbarConnectionLogic = kea<extensionPageToolbarConne
actions.receiveState(message.state)
} else if (message.type === 'patch') {
actions.receivePatch(message.patch)
+ } else if (message.type === 'screenshot-preview') {
+ actions.receiveScreenshotPreview(message.dataUrl)
} else if (message.type === 'tokens') {
actions.updateTokens(message.tokens)
} else if (message.type === 'token-expired') {
diff --git a/frontend/src/toolbar/extension/extensionPageToolbarLogic.ts b/frontend/src/toolbar/extension/extensionPageToolbarLogic.ts
index 8cc152a0539b..065098ab3cac 100644
--- a/frontend/src/toolbar/extension/extensionPageToolbarLogic.ts
+++ b/frontend/src/toolbar/extension/extensionPageToolbarLogic.ts
@@ -1,18 +1,24 @@
-import { MakeLogicType, actions, afterMount, connect, kea, listeners, path, reducers, selectors } from 'kea'
-import { querySelectorAllDeep } from 'query-selector-shadow-dom'
+import { MakeLogicType, actions, afterMount, connect, kea, listeners, path, props, reducers, selectors } from 'kea'
import { actionsLogic } from '~/toolbar/actions/actionsLogic'
import { actionsTabLogic } from '~/toolbar/actions/actionsTabLogic'
+import { SelectorMatchCounts, countSelectorMatches } from '~/toolbar/actions/SelectorCountContext'
import { elementsLogic } from '~/toolbar/elements/elementsLogic'
import { heatmapToolbarMenuLogic } from '~/toolbar/elements/heatmapToolbarMenuLogic'
+import { experimentsTabLogic } from '~/toolbar/experiments/experimentsTabLogic'
import { currentPageLogic } from '~/toolbar/stats/currentPageLogic'
import { toolbarConfigLogic } from '~/toolbar/toolbarConfigLogic'
import type { ElementWithMetadata } from '~/toolbar/types'
import type { FragileSelectorResult } from '../utils/selectorQuality'
import { extensionPageActionsLogic } from './extensionPageActionsLogic'
+import { EMPTY_PAGE_EVENTS_STATE, extensionPageEventsLogic } from './extensionPageEventsLogic'
+import { extensionPageExperimentsLogic } from './extensionPageExperimentsLogic'
import { extensionPageFlagsLogic } from './extensionPageFlagsLogic'
import { extensionPageHeatmapLogic } from './extensionPageHeatmapLogic'
+import { extensionPageMoreLogic } from './extensionPageMoreLogic'
+import { extensionPageWebVitalsLogic, getPageWebVitalsState } from './extensionPageWebVitalsLogic'
+import type { PagePosthogBridge } from './pagePosthogBridge'
import type {
InspectedElementInfo,
PageToolCommands,
@@ -33,9 +39,14 @@ export type PageInspectCommand = { type: 'clear-selected-element' }
export type PageSelectorsCommand = { type: 'count-selectors'; selectors: string[] }
-type PanelMenuMode = Extract<PageToolbarMode, 'flags'>
+export interface ExtensionPageToolbarLogicProps {
+ /** Null when the page has no `window.posthog`. */
+ posthogBridge: PagePosthogBridge | null
+}
+
+type PanelMenuMode = Extract<PageToolbarMode, 'flags' | 'events' | 'web-vitals' | 'more'>
-const PANEL_MENU_MODES: PanelMenuMode[] = ['flags']
+const PANEL_MENU_MODES: PanelMenuMode[] = ['flags', 'events', 'web-vitals', 'more']
// The panel asks about the selectors its open form shows, so a short list covers it.
const MAX_COUNTED_SELECTORS = 20
@@ -43,16 +54,8 @@ const MAX_COUNTED_SELECTORS = 20
// Recounts the selectors once the page stops changing for this long.
const SELECTOR_RECOUNT_DEBOUNCE_MS = 300
-function countMatches(selectors: string[]): Record<string, number | null> {
- return Object.fromEntries(
- selectors.map((selector) => {
- try {
- return [selector, querySelectorAllDeep(selector).length]
- } catch {
- return [selector, null]
- }
- })
- )
+function countMatches(selectors: string[]): Record<string, SelectorMatchCounts | null> {
+ return Object.fromEntries(selectors.map((selector) => [selector, countSelectorMatches(selector)]))
}
function inspectedElementInfo(meta: ElementWithMetadata | null): InspectedElementInfo | null {
@@ -86,12 +89,13 @@ export interface extensionPageToolbarLogicValues {
activeMetaIsSelected: boolean // elementsLogic
inspectEnabled: boolean // elementsLogic
selectedElement: HTMLElement | null // elementsLogic
+ buttonExperimentsVisible: boolean // experimentsTabLogic
heatmapEnabled: boolean // heatmapToolbarMenuLogic
countedSelectors: string[]
inspectState: PageToolbarInspectState
mode: PageToolbarMode
openMenu: PanelMenuMode | null
- selectorCounts: Record<string, number | null>
+ selectorCounts: Record<string, SelectorMatchCounts | null>
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
@@ -115,7 +119,8 @@ export interface extensionPageToolbarLogicMeta {
__keaTypeGenInternalSelectorTypes: {
mode: (
buttonActionsVisible: boolean,
- openMenu: 'flags' | null,
+ buttonExperimentsVisible: boolean,
+ openMenu: PanelMenuMode | null,
inspectEnabled: boolean,
heatmapEnabled: boolean
) => PageToolbarMode
@@ -133,13 +138,14 @@ export interface extensionPageToolbarLogicMeta {
export type extensionPageToolbarLogicType = MakeLogicType<
extensionPageToolbarLogicValues,
extensionPageToolbarLogicActions,
- Record<string, any>,
+ ExtensionPageToolbarLogicProps,
extensionPageToolbarLogicMeta
>
/** Runs in the content script. Mount it after `toolbarConfigLogic`, because the connected logics read its tokens. */
export const extensionPageToolbarLogic = kea<extensionPageToolbarLogicType>([
path(['toolbar', 'extension', 'extensionPageToolbarLogic']),
+ props({} as ExtensionPageToolbarLogicProps),
connect(() => ({
values: [
elementsLogic,
@@ -148,8 +154,16 @@ export const extensionPageToolbarLogic = kea<extensionPageToolbarLogicType>([
['heatmapEnabled'],
actionsTabLogic,
['buttonActionsVisible'],
+ experimentsTabLogic,
+ ['buttonExperimentsVisible'],
+ ],
+ logic: [
+ extensionPageHeatmapLogic,
+ extensionPageActionsLogic,
+ extensionPageFlagsLogic,
+ extensionPageWebVitalsLogic,
+ extensionPageExperimentsLogic,
],
- logic: [extensionPageHeatmapLogic, extensionPageActionsLogic, extensionPageFlagsLogic],
})),
actions({
handleCommand: (message: PageToolbarCommand) => ({ message }),
@@ -168,7 +182,7 @@ export const extensionPageToolbarLogic = kea<extensionPageToolbarLogicType>([
],
countedSelectors: [[] as string[], { setCountedSelectors: (_, { selectors }) => selectors }],
selectorCounts: [
- {} as Record<string, number | null>,
+ {} as Record<string, SelectorMatchCounts | null>,
{
setCountedSelectors: (_, { selectors }) => countMatches(selectors),
recountSelectors: (counts) => countMatches(Object.keys(counts)),
@@ -177,23 +191,26 @@ export const extensionPageToolbarLogic = kea<extensionPageToolbarLogicType>([
}),
selectors({
mode: [
- (s) => [s.buttonActionsVisible, s.openMenu, s.inspectEnabled, s.heatmapEnabled],
+ (s) => [s.buttonActionsVisible, s.buttonExperimentsVisible, s.openMenu, s.inspectEnabled, s.heatmapEnabled],
(
buttonActionsVisible: boolean,
+ buttonExperimentsVisible: boolean,
openMenu: PanelMenuMode | null,
inspectEnabled: boolean,
heatmapEnabled: boolean
): PageToolbarMode =>
- // Actions come first, because picking an element for a step turns inspect on too.
+ // Actions and experiments come first, because picking an element for them turns inspect on too.
buttonActionsVisible
? 'actions'
- : openMenu
- ? openMenu
- : inspectEnabled
- ? 'inspect'
- : heatmapEnabled
- ? 'heatmap'
- : 'none',
+ : buttonExperimentsVisible
+ ? 'experiments'
+ : openMenu
+ ? openMenu
+ : inspectEnabled
+ ? 'inspect'
+ : heatmapEnabled
+ ? 'heatmap'
+ : 'none',
],
inspectState: [
(s) => [s.activeMeta, s.activeMetaIsSelected],
@@ -203,13 +220,17 @@ export const extensionPageToolbarLogic = kea<extensionPageToolbarLogicType>([
}),
],
}),
- listeners(({ actions, values, cache }) => ({
+ listeners(({ actions, values, props, cache }) => ({
setMode: ({ mode }) => {
// The floating toolbar opens one menu at a time, and each menu turns the others' page modes off.
elementsLogic.actions.disableInspect()
heatmapToolbarMenuLogic.actions.disableHeatmap()
actionsTabLogic.actions.inspectForElementWithIndex(null)
actionsTabLogic.actions.hideButtonActions()
+ if (values.buttonExperimentsVisible) {
+ extensionPageExperimentsLogic.actions.closeExperiments()
+ }
+ extensionPageEventsLogic.findMounted()?.actions.setOpen(mode === 'events')
// Each tool loads its data the first time it opens, and keeps it while the page tools run.
const firstOpen = !cache.openedModes.has(mode)
cache.openedModes.add(mode)
@@ -222,10 +243,22 @@ export const extensionPageToolbarLogic = kea<extensionPageToolbarLogicType>([
if (firstOpen) {
actionsLogic.actions.getActions()
}
+ } else if (mode === 'experiments') {
+ // experimentsTabLogic loads the list when it mounts with the page tools.
+ experimentsTabLogic.actions.showButtonExperiments()
} else if (mode === 'flags') {
if (firstOpen) {
extensionPageFlagsLogic.actions.openFlags()
}
+ } else if (mode === 'events') {
+ // The debugger stays mounted once it opens, and keeps collecting events like the floating toolbar's.
+ if (!extensionPageEventsLogic.findMounted()) {
+ extensionPageEventsLogic({ posthogBridge: props.posthogBridge }).mount()
+ }
+ } else if (mode === 'web-vitals') {
+ extensionPageWebVitalsLogic.actions.openWebVitals()
+ } else if (mode === 'more') {
+ extensionPageMoreLogic.findMounted()?.actions.openMore()
}
},
handleCommand: ({ message }) => {
@@ -254,6 +287,10 @@ export const extensionPageToolbarLogic = kea<extensionPageToolbarLogicType>([
extensionPageActionsLogic.actions.handleCommand(command)
},
flags: (command) => extensionPageFlagsLogic.actions.handleCommand(command),
+ events: (command) => extensionPageEventsLogic.findMounted()?.actions.handleCommand(command),
+ 'web-vitals': () => extensionPageWebVitalsLogic.actions.reloadWebVitals(),
+ more: (command) => extensionPageMoreLogic.findMounted()?.actions.handleCommand(command),
+ experiments: (command) => extensionPageExperimentsLogic.actions.handleCommand(command),
}
;(handlers[message.tool] as (command: PageToolbarCommand['command']) => void)(message.command)
},
@@ -288,5 +325,9 @@ export function getPageToolbarState(): PageToolbarState {
heatmap: extensionPageHeatmapLogic.values.pageState,
actions: extensionPageActionsLogic.values.pageState,
flags: extensionPageFlagsLogic.values.pageState,
+ events: extensionPageEventsLogic.findMounted()?.values.pageState ?? EMPTY_PAGE_EVENTS_STATE,
+ webVitals: getPageWebVitalsState(extensionPageWebVitalsLogic.values.posthog),
+ experiments: extensionPageExperimentsLogic.values.pageState,
+ more: extensionPageMoreLogic.values.pageState,
}
}
diff --git a/frontend/src/toolbar/extension/extensionPageTools.tsx b/frontend/src/toolbar/extension/extensionPageTools.tsx
index 201b14ea32ae..7c9fb0a69c94 100644
--- a/frontend/src/toolbar/extension/extensionPageTools.tsx
+++ b/frontend/src/toolbar/extension/extensionPageTools.tsx
@@ -1,4 +1,6 @@
-import { IconBolt, IconCursorClick, IconFlask, IconPieChart, IconSearch, IconToggle } from '@posthog/icons'
+import { IconBolt, IconCursorClick, IconFlask, IconLive, IconPieChart, IconSearch, IconToggle } from '@posthog/icons'
+
+import { IconMenu } from 'lib/lemon-ui/icons'
import { urls } from '~/toolbar/urls'
import { AvailableFeature } from '~/types'
@@ -11,8 +13,7 @@ export type PageToolMode = Exclude<PageToolbarMode, 'none'>
export type ExtensionFeatureKey = 'heatmaps' | 'actions' | 'feature-flags' | 'experiments' | 'web-vitals'
export interface PageToolDefinition {
- /** Missing for a tool the panel only links to in PostHog. */
- mode?: PageToolMode
+ mode: PageToolMode
label: string
description: string
icon: JSX.Element
@@ -53,15 +54,29 @@ export const PAGE_TOOLS: PageToolDefinition[] = [
feature: { key: 'feature-flags', path: urls.featureFlags() },
},
{
+ mode: 'events',
+ label: 'Events',
+ description: 'Watch the events this page sends, as it sends them',
+ icon: <IconLive />,
+ },
+ {
+ mode: 'web-vitals',
label: 'Web vitals',
description: 'Check how fast this page loads',
icon: <IconPieChart />,
feature: { key: 'web-vitals', path: urls.webAnalyticsWebVitals() },
},
{
+ mode: 'experiments',
label: 'Experiments',
description: 'Build no-code web experiments and preview their variants on the page',
icon: <IconFlask />,
feature: { key: 'experiments', path: urls.experiments() },
},
+ {
+ mode: 'more',
+ label: 'More',
+ description: 'Debug info, PII masking and screenshots for events',
+ icon: <IconMenu />,
+ },
]
diff --git a/frontend/src/toolbar/extension/extensionPageWebVitalsLogic.ts b/frontend/src/toolbar/extension/extensionPageWebVitalsLogic.ts
new file mode 100644
index 000000000000..619920660bcd
--- /dev/null
+++ b/frontend/src/toolbar/extension/extensionPageWebVitalsLogic.ts
@@ -0,0 +1,71 @@
+import { MakeLogicType, actions, connect, kea, listeners, path } from 'kea'
+import type { PostHog } from 'posthog-js'
+
+import { toolbarConfigLogic } from '~/toolbar/toolbarConfigLogic'
+import { webVitalsToolbarLogic } from '~/toolbar/web-vitals/webVitalsToolbarLogic'
+
+import type { PageToolbarWebVitalsState } from './pageToolbarBridge'
+
+export type PageWebVitalsCommand = { type: 'reload-web-vitals' }
+
+const NO_WEB_VITALS = { LCP: undefined, FCP: undefined, CLS: undefined, INP: undefined }
+
+let lastPageState: PageToolbarWebVitalsState | null = null
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionPageWebVitalsLogicValues {
+ posthog: PostHog | null // toolbarConfigLogic
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface extensionPageWebVitalsLogicActions {
+ openWebVitals: () => {
+ value: true
+ }
+ reloadWebVitals: () => {
+ value: true
+ }
+}
+
+export type extensionPageWebVitalsLogicType = MakeLogicType<
+ extensionPageWebVitalsLogicValues,
+ extensionPageWebVitalsLogicActions
+>
+
+/** Runs in the content script. The toolbar's web vitals logic mounts the first time the user opens the tool. */
+export const extensionPageWebVitalsLogic = kea<extensionPageWebVitalsLogicType>([
+ path(['toolbar', 'extension', 'extensionPageWebVitalsLogic']),
+ connect(() => ({
+ values: [toolbarConfigLogic, ['posthog']],
+ })),
+ actions({
+ openWebVitals: true,
+ reloadWebVitals: true,
+ }),
+ listeners(() => ({
+ openWebVitals: () => {
+ if (!webVitalsToolbarLogic.findMounted()) {
+ webVitalsToolbarLogic.mount()
+ }
+ },
+ reloadWebVitals: () => {
+ webVitalsToolbarLogic.findMounted()?.actions.getWebVitals()
+ },
+ })),
+])
+
+/** Keeps the previous object while nothing changed, so the host doesn't post the slice again. */
+export function getPageWebVitalsState(posthog: PostHog | null): PageToolbarWebVitalsState {
+ const webVitals = webVitalsToolbarLogic.findMounted()?.values
+ const next: PageToolbarWebVitalsState = {
+ autocaptureEnabled: !!posthog?.webVitalsAutocapture?.isEnabled,
+ pathname: window.location.pathname,
+ localWebVitals: webVitals?.localWebVitals ?? NO_WEB_VITALS,
+ remoteWebVitals: webVitals?.remoteWebVitals ?? NO_WEB_VITALS,
+ }
+ const unchanged =
+ lastPageState &&
+ (Object.keys(next) as (keyof PageToolbarWebVitalsState)[]).every((key) => lastPageState?.[key] === next[key])
+ lastPageState = unchanged ? lastPageState : next
+ return lastPageState as PageToolbarWebVitalsState
+}
diff --git a/frontend/src/toolbar/extension/extensionTelemetry.ts b/frontend/src/toolbar/extension/extensionTelemetry.ts
index dcdba1a3b535..c68d91436678 100644
--- a/frontend/src/toolbar/extension/extensionTelemetry.ts
+++ b/frontend/src/toolbar/extension/extensionTelemetry.ts
@@ -12,6 +12,16 @@ type PageToolKey =
| 'override-flag'
| 'clear-flag-overrides'
| 'impersonate-flags'
+ | 'events'
+ | 'export-events'
+ | 'web-vitals'
+ | 'experiments'
+ | 'create-experiment'
+ | 'save-experiment'
+ | 'more'
+ | 'pii-masking'
+ | 'screenshot-for-event'
+ | 'view-session-recording'
export function capturePageToolUsed(tool: PageToolKey, properties?: Record<string, unknown>): void {
// pinned: analytics event name
diff --git a/frontend/src/toolbar/extension/pageAgent.ts b/frontend/src/toolbar/extension/pageAgent.ts
index 5df2509b4642..90ca4a081bf6 100644
--- a/frontend/src/toolbar/extension/pageAgent.ts
+++ b/frontend/src/toolbar/extension/pageAgent.ts
@@ -1,3 +1,5 @@
+import { DebugInfoPosthog, readPosthogDebugInfo } from '~/toolbar/debug/posthogDebugInfo'
+
import {
PAGE_AGENT_REPLY_SOURCE,
PageAgentReply,
@@ -5,16 +7,17 @@ import {
PageAgentRequest,
isPageAgentRequestMessage,
} from './pageAgentProtocol'
-import type { PageAnalyticsInfo, PageFeatureFlagsSnapshot } from './pageToolbarBridge'
+import type { PageAnalyticsInfo, PageDebugInfo, PageFeatureFlagsSnapshot } from './pageToolbarBridge'
-interface PagePosthog {
+interface PagePosthog extends DebugInfoPosthog {
__loaded?: boolean
- version?: string
- config?: {
+ config?: DebugInfoPosthog['config'] & {
disable_scroll_properties?: boolean
+ disable_web_experiments?: boolean
scroll_root_selector?: string | string[]
+ session_recording?: Record<string, unknown>
}
- heatmaps?: { isEnabled?: boolean }
+ webVitalsAutocapture?: { isEnabled?: boolean }
featureFlags?: {
overrideFeatureFlags?: (overrides: unknown) => void
reloadFeatureFlags?: () => void
@@ -23,11 +26,15 @@ interface PagePosthog {
get_property?: (key: string) => unknown
getGroups?: () => Record<string, string>
onFeatureFlags?: (callback: () => void) => unknown
+ on?: (event: 'eventCaptured', callback: (event: unknown) => void) => unknown
+ surveys?: { getSurveys?: (callback: (surveys: unknown[]) => void, forceReload?: boolean) => void }
}
// The panel injects this file again on each connection, so a second run in the same page must do nothing.
const INSTALLED_FLAG = '__posthogToolbarExtensionPageAgent'
+const SURVEYS_TIMEOUT_MS = 2000
+
// An async snippet loads posthog-js after the page loads, so the agent watches for it this often, for this long.
const POSTHOG_CHECK_INTERVAL_MS = 500
const POSTHOG_CHECK_DURATION_MS = 10_000
@@ -61,11 +68,24 @@ function featureFlagsSnapshot(posthog: PagePosthog): PageFeatureFlagsSnapshot {
}
function analyticsInfo(posthog: PagePosthog): PageAnalyticsInfo {
+ const sessionRecording = posthog.config?.session_recording ?? {}
return {
version: read(() => posthog.version, null),
scrollPropertiesDisabled: !!read(() => posthog.config?.disable_scroll_properties, false),
scrollRootSelector: read(() => posthog.config?.scroll_root_selector, null),
heatmapsEnabled: posthog.heatmaps ? !!read(() => posthog.heatmaps?.isEnabled, false) : null,
+ webVitalsEnabled: posthog.webVitalsAutocapture
+ ? !!read(() => posthog.webVitalsAutocapture?.isEnabled, false)
+ : null,
+ webExperimentsDisabled: !!read(() => posthog.config?.disable_web_experiments, false),
+ sessionRecordingConfig: Object.fromEntries(
+ ['blockClass', 'maskTextClass', 'maskTextSelector', 'maskAllInputs']
+ .map((key): [string, unknown] => [key, sessionRecording[key]])
+ .filter(([, value]) => value !== undefined)
+ // A RegExp or a function can't leave the page, and the masking preview treats any non-string the same.
+ .map(([key, value]) => [key, ['string', 'boolean'].includes(typeof value) ? value : {}])
+ ),
+ sessionRecordingStatus: read(() => posthog.sessionRecording?.status, null),
featureFlags: featureFlagsSnapshot(posthog),
}
}
@@ -77,8 +97,54 @@ function reply(message: PageAgentReply): void {
)
}
+function postCapturedEvent(event: unknown, forwardSnapshotPayloads: boolean): void {
+ // A snapshot carries the page's recording, which a debugger that hides snapshots never shows.
+ const forwarded =
+ !forwardSnapshotPayloads && (event as { event?: string } | null)?.event === '$snapshot'
+ ? { ...(event as Record<string, unknown>), properties: {} }
+ : event
+ try {
+ reply({ kind: 'event-captured', event: forwarded })
+ } catch {
+ // postMessage can't clone a function or a DOM node, which some event properties can hold.
+ try {
+ reply({ kind: 'event-captured', event: JSON.parse(JSON.stringify(forwarded)) })
+ } catch {
+ // An event that JSON can't hold either never reaches the debugger.
+ }
+ }
+}
+
+function readDebugInfo(posthog: PagePosthog): Promise<PageDebugInfo> {
+ const info = readPosthogDebugInfo(posthog)
+ return new Promise((resolve) => {
+ const finish = (surveysCount: number | null): void => resolve({ ...info, surveysCount })
+ const getSurveys = posthog.surveys?.getSurveys
+ if (!getSurveys) {
+ finish(null)
+ return
+ }
+ const timeout = setTimeout(() => finish(null), SURVEYS_TIMEOUT_MS)
+ try {
+ getSurveys.call(
+ posthog.surveys,
+ (surveys) => {
+ clearTimeout(timeout)
+ finish(Array.isArray(surveys) ? surveys.length : null)
+ },
+ false
+ )
+ } catch {
+ clearTimeout(timeout)
+ finish(null)
+ }
+ })
+}
+
function install(): void {
let flagsSubscribed = false
+ let forwardSnapshotPayloads = false
+ let unsubscribeEvents: (() => void) | null = null
const subscribeToFlags = (posthog: PagePosthog): void => {
if (!flagsSubscribed && posthog.onFeatureFlags) {
@@ -92,6 +158,23 @@ function install(): void {
case 'read-analytics':
reply({ kind: 'analytics', id, info: analyticsInfo(posthog) })
return
+ case 'subscribe-events': {
+ forwardSnapshotPayloads = request.forwardSnapshotPayloads
+ if (!unsubscribeEvents && posthog.on) {
+ const unsubscribe = posthog.on('eventCaptured', (event) =>
+ postCapturedEvent(event, forwardSnapshotPayloads)
+ )
+ unsubscribeEvents = typeof unsubscribe === 'function' ? (unsubscribe as () => void) : () => {}
+ }
+ return
+ }
+ case 'unsubscribe-events':
+ unsubscribeEvents?.()
+ unsubscribeEvents = null
+ return
+ case 'read-debug-info':
+ void readDebugInfo(posthog).then((info) => reply({ kind: 'debug-info', id, info }))
+ return
case 'override-flags':
case 'reload-flags':
try {
diff --git a/frontend/src/toolbar/extension/pageAgentProtocol.ts b/frontend/src/toolbar/extension/pageAgentProtocol.ts
index 3deb55d2b9be..2535b8dfff48 100644
--- a/frontend/src/toolbar/extension/pageAgentProtocol.ts
+++ b/frontend/src/toolbar/extension/pageAgentProtocol.ts
@@ -1,4 +1,4 @@
-import type { PageAnalyticsInfo, PageFeatureFlagsSnapshot } from './pageToolbarBridge'
+import type { PageAnalyticsInfo, PageDebugInfo, PageFeatureFlagsSnapshot } from './pageToolbarBridge'
// The content script's isolated world can't call the page's `window.posthog`, so the page agent calls it from the
// page's own world.
@@ -11,6 +11,9 @@ export type PageAgentRequest =
| { method: 'read-analytics' }
| { method: 'override-flags'; flags: Record<string, string | boolean> | false; payloads?: Record<string, unknown> }
| { method: 'reload-flags' }
+ | { method: 'subscribe-events'; forwardSnapshotPayloads: boolean }
+ | { method: 'unsubscribe-events' }
+ | { method: 'read-debug-info' }
export type PageAgentReply =
/** `id` is null when the page agent reports by itself that posthog-js appeared on the page. */
@@ -18,6 +21,8 @@ export type PageAgentReply =
| { kind: 'result'; id: number; ok: true; featureFlags: PageFeatureFlagsSnapshot }
| { kind: 'result'; id: number; ok: false; error: string }
| { kind: 'feature-flags'; featureFlags: PageFeatureFlagsSnapshot }
+ | { kind: 'event-captured'; event: unknown }
+ | { kind: 'debug-info'; id: number; info: PageDebugInfo }
export interface PageAgentRequestMessage {
source: typeof PAGE_AGENT_REQUEST_SOURCE
diff --git a/frontend/src/toolbar/extension/pagePosthogBridge.test.ts b/frontend/src/toolbar/extension/pagePosthogBridge.test.ts
index ad39e96cac5d..4c0c9a59acc0 100644
--- a/frontend/src/toolbar/extension/pagePosthogBridge.test.ts
+++ b/frontend/src/toolbar/extension/pagePosthogBridge.test.ts
@@ -7,6 +7,10 @@ const INFO: PageAnalyticsInfo = {
scrollPropertiesDisabled: false,
scrollRootSelector: null,
heatmapsEnabled: true,
+ webVitalsEnabled: true,
+ webExperimentsDisabled: false,
+ sessionRecordingConfig: {},
+ sessionRecordingStatus: null,
featureFlags: { overrides: {}, variants: { 'launch-banner': false }, groups: {} },
}
@@ -78,4 +82,25 @@ describe('PagePosthogBridge', () => {
expect(statuses.at(-1)).toEqual({ pending: false, error: 'The page has no posthog-js', revision: 1 })
expect(bridge.posthog.get_property('$override_feature_flags')).toEqual({})
})
+
+ it('ends a debug info request when the page has no posthog-js to answer it', async () => {
+ const debugInfo = bridge.readDebugInfo()
+
+ reply({ kind: 'result', id: requests[0].id, ok: false, error: 'The page has no posthog-js' })
+
+ await expect(debugInfo).resolves.toBeNull()
+ })
+
+ it("subscribes once to the page's events and gives each one to every listener", () => {
+ const debuggerEvents: unknown[] = []
+ const webVitalsEvents: unknown[] = []
+ bridge.posthog.on('eventCaptured', (event) => debuggerEvents.push(event))
+ bridge.posthog.on('eventCaptured', (event) => webVitalsEvents.push(event))
+
+ reply({ kind: 'event-captured', event: { event: '$pageview' } })
+
+ expect(requests.map(({ request }) => request.method)).toEqual(['subscribe-events'])
+ expect(debuggerEvents).toEqual([{ event: '$pageview' }])
+ expect(webVitalsEvents).toEqual([{ event: '$pageview' }])
+ })
})
diff --git a/frontend/src/toolbar/extension/pagePosthogBridge.ts b/frontend/src/toolbar/extension/pagePosthogBridge.ts
index 2dd7b9a41ba2..c1be25755486 100644
--- a/frontend/src/toolbar/extension/pagePosthogBridge.ts
+++ b/frontend/src/toolbar/extension/pagePosthogBridge.ts
@@ -7,7 +7,7 @@ import {
PageAgentRequestMessage,
isPageAgentReplyMessage,
} from './pageAgentProtocol'
-import type { PageAnalyticsInfo, PageFeatureFlagsSnapshot } from './pageToolbarBridge'
+import type { PageAnalyticsInfo, PageDebugInfo, PageFeatureFlagsSnapshot } from './pageToolbarBridge'
export interface PageFlagMutationStatus {
pending: boolean
@@ -17,9 +17,12 @@ export interface PageFlagMutationStatus {
type FeatureFlagsCallback = (flags: string[], variants: Record<string, string | boolean>) => void
+type EventCapturedCallback = (event: unknown) => void
+
// The page agent answers in milliseconds. Past these, the page most likely reloaded or has no agent.
const ANALYTICS_TIMEOUT_MS = 1000
const MUTATION_TIMEOUT_MS = 5000
+const DEBUG_INFO_TIMEOUT_MS = 5000
let nextRequestId = 1
@@ -77,6 +80,9 @@ export class PagePosthogBridge {
private featureFlags: PageFeatureFlagsSnapshot
private pendingMutations = new Map<number, ReturnType<typeof setTimeout>>()
private featureFlagsCallbacks: FeatureFlagsCallback[] = []
+ private eventCapturedCallbacks: EventCapturedCallback[] = []
+ private forwardSnapshotPayloads = false
+ private debugInfoRequests = new Map<number, (info: PageDebugInfo | null) => void>()
private mutationStatus: PageFlagMutationStatus = { pending: false, error: null, revision: 0 }
private removeListener: () => void
/** The parts of posthog-js that the toolbar's logics read. */
@@ -93,10 +99,36 @@ export class PagePosthogBridge {
dispose(): void {
this.removeListener()
+ if (this.eventCapturedCallbacks.length > 0) {
+ postToPageAgent({ method: 'unsubscribe-events' })
+ }
for (const timeout of this.pendingMutations.values()) {
clearTimeout(timeout)
}
this.pendingMutations.clear()
+ for (const resolve of this.debugInfoRequests.values()) {
+ resolve(null)
+ }
+ this.debugInfoRequests.clear()
+ }
+
+ /** Resolves with null when the page has no posthog-js, or when it doesn't answer in time. */
+ readDebugInfo(): Promise<PageDebugInfo | null> {
+ const id = postToPageAgent({ method: 'read-debug-info' })
+ return new Promise((resolve) => {
+ const timeout = setTimeout(() => this.resolveDebugInfo(id, null), DEBUG_INFO_TIMEOUT_MS)
+ this.debugInfoRequests.set(id, (info) => {
+ clearTimeout(timeout)
+ resolve(info)
+ })
+ })
+ }
+
+ setForwardSnapshotPayloads(forward: boolean): void {
+ this.forwardSnapshotPayloads = forward
+ if (this.eventCapturedCallbacks.length > 0) {
+ postToPageAgent({ method: 'subscribe-events', forwardSnapshotPayloads: forward })
+ }
}
private buildPosthog(): PostHog {
@@ -105,9 +137,31 @@ export class PagePosthogBridge {
version: info.version ?? undefined,
config: {
disable_scroll_properties: info.scrollPropertiesDisabled,
+ disable_web_experiments: info.webExperimentsDisabled,
scroll_root_selector: info.scrollRootSelector ?? undefined,
+ session_recording: info.sessionRecordingConfig,
},
heatmaps: info.heatmapsEnabled === null ? undefined : { isEnabled: info.heatmapsEnabled },
+ webVitalsAutocapture: info.webVitalsEnabled === null ? undefined : { isEnabled: info.webVitalsEnabled },
+ sessionRecording: { status: info.sessionRecordingStatus ?? undefined },
+ on: (event: string, callback: EventCapturedCallback) => {
+ if (event !== 'eventCaptured') {
+ return () => {}
+ }
+ if (this.eventCapturedCallbacks.length === 0) {
+ postToPageAgent({
+ method: 'subscribe-events',
+ forwardSnapshotPayloads: this.forwardSnapshotPayloads,
+ })
+ }
+ this.eventCapturedCallbacks.push(callback)
+ return () => {
+ this.eventCapturedCallbacks = this.eventCapturedCallbacks.filter((c) => c !== callback)
+ if (this.eventCapturedCallbacks.length === 0) {
+ postToPageAgent({ method: 'unsubscribe-events' })
+ }
+ }
+ },
// Matches posthog-js, which measures scroll depth on the page's scroll root when the config names one.
scrollManager: { scrollY: () => scrollRoot(info.scrollRootSelector)?.scrollTop ?? window.scrollY },
featureFlags: {
@@ -165,7 +219,23 @@ export class PagePosthogBridge {
})
}
+ private resolveDebugInfo(id: number, info: PageDebugInfo | null): void {
+ const resolve = this.debugInfoRequests.get(id)
+ this.debugInfoRequests.delete(id)
+ resolve?.(info)
+ }
+
private handleReply(reply: PageAgentReply): void {
+ if (reply.kind === 'event-captured') {
+ for (const callback of this.eventCapturedCallbacks) {
+ callback(reply.event)
+ }
+ return
+ }
+ if (reply.kind === 'debug-info') {
+ this.resolveDebugInfo(reply.id, reply.info)
+ return
+ }
if (reply.kind === 'feature-flags') {
this.setFeatureFlags(reply.featureFlags)
this.onChange(this.mutationStatus)
@@ -174,6 +244,11 @@ export class PagePosthogBridge {
if (reply.kind !== 'result') {
return
}
+ if (this.debugInfoRequests.has(reply.id)) {
+ // The page agent answers with a failed result when the page has no posthog-js.
+ this.resolveDebugInfo(reply.id, null)
+ return
+ }
if (!this.pendingMutations.has(reply.id)) {
return
}
diff --git a/frontend/src/toolbar/extension/pageToolbarBridge.ts b/frontend/src/toolbar/extension/pageToolbarBridge.ts
index eb50ae94a271..22f16d6d5b8a 100644
--- a/frontend/src/toolbar/extension/pageToolbarBridge.ts
+++ b/frontend/src/toolbar/extension/pageToolbarBridge.ts
@@ -5,13 +5,22 @@ import type {
ScrollDepthPosthogJsError,
} from 'lib/components/heatmaps/types'
-import type { ActionForm } from '~/toolbar/types'
+import type { SelectorMatchCounts } from '~/toolbar/actions/SelectorCountContext'
+import type { EventCategory } from '~/toolbar/debug/eventCategories'
+import type { PosthogDebugInfo } from '~/toolbar/debug/posthogDebugInfo'
+import type { ElementSelectorType } from '~/toolbar/experiments/elementSelectorTypes'
+import type { ActionForm, WebExperimentForm } from '~/toolbar/types'
+import type { WebVitalsMetrics } from '~/toolbar/web-vitals/webVitalsToolbarLogic'
import type { ActionStepType, ElementType } from '~/types'
import type { PageActionsCommand } from './extensionPageActionsLogic'
+import type { PageEventsCommand } from './extensionPageEventsLogic'
+import type { PageExperimentsCommand } from './extensionPageExperimentsLogic'
import type { PageFlagsCommand } from './extensionPageFlagsLogic'
import type { PageHeatmapCommand } from './extensionPageHeatmapLogic'
+import type { PageMoreCommand } from './extensionPageMoreLogic'
import type { PageInspectCommand, PageSessionCommand, PageSelectorsCommand } from './extensionPageToolbarLogic'
+import type { PageWebVitalsCommand } from './extensionPageWebVitalsLogic'
/**
* The content script runs the toolbar's own logics in the page, signed in with the extension's OAuth tokens. The panel
@@ -21,7 +30,16 @@ import type { PageInspectCommand, PageSessionCommand, PageSelectorsCommand } fro
// pinned: extension port name, the panel and an already injected content script must agree on it
export const PAGE_TOOLBAR_PORT = 'posthog-toolbar-page'
-export type PageToolbarMode = 'none' | 'heatmap' | 'inspect' | 'actions' | 'flags'
+export type PageToolbarMode =
+ | 'none'
+ | 'heatmap'
+ | 'inspect'
+ | 'actions'
+ | 'flags'
+ | 'events'
+ | 'web-vitals'
+ | 'experiments'
+ | 'more'
/** What the content script reads from the page's posthog-js through the page agent. */
export interface PageAnalyticsInfo {
@@ -31,9 +49,21 @@ export interface PageAnalyticsInfo {
scrollRootSelector: string | string[] | null
/** Null when the posthog-js version has no heatmaps module. */
heatmapsEnabled: boolean | null
+ /** Null when the posthog-js version has no web vitals module. */
+ webVitalsEnabled: boolean | null
+ webExperimentsDisabled: boolean
+ /** The masking settings, with each value that isn't a string or a boolean replaced by `{}`. */
+ sessionRecordingConfig: Record<string, unknown>
+ sessionRecordingStatus: string | null
featureFlags: PageFeatureFlagsSnapshot
}
+/** The toolbar's debug info, read from the page's posthog-js when the user opens it. */
+export interface PageDebugInfo extends PosthogDebugInfo {
+ /** Null when the page's posthog-js has no surveys, or didn't answer in time. */
+ surveysCount: number | null
+}
+
export interface PageFeatureFlagsSnapshot {
overrides: Record<string, string | boolean>
variants: Record<string, string | boolean>
@@ -59,6 +89,10 @@ export interface PageToolCommands {
heatmap: PageHeatmapCommand
actions: PageActionsCommand
flags: PageFlagsCommand
+ events: PageEventsCommand
+ 'web-vitals': PageWebVitalsCommand
+ more: PageMoreCommand
+ experiments: PageExperimentsCommand
}
export type PageToolName = keyof PageToolCommands
@@ -141,6 +175,33 @@ export interface PageToolbarActionsState {
saveResult: ActionSaveResult | null
}
+/** The experiment form without `original_html_state`, which only the page uses to undo a preview. */
+export type ExperimentFormDraft = Pick<WebExperimentForm, 'name' | 'variants'>
+
+export type ExperimentSaveResult =
+ | { status: 'saved'; experimentId: number; name: string | null }
+ | { status: 'failed'; error: string }
+
+export interface PageToolbarExperimentsState {
+ loading: boolean
+ experiments: { id: number; name: string | null }[]
+ /** True when the page's posthog-js config sets `disable_web_experiments`. */
+ webExperimentsDisabled: boolean
+ selectedExperimentId: number | 'new' | null
+ experimentForm: ExperimentFormDraft
+ /** Goes up when the page changes the form itself, for example when the user picks an element for a transform. */
+ formRevision: number
+ /** The variant the page shows. */
+ selectedVariant: string
+ selectedElementType: ElementSelectorType
+ /** The transform waiting for an element pick on the page. */
+ inspectingElement: number | null
+ addVariantAvailable: boolean
+ removeVariantAvailable: boolean
+ saving: boolean
+ saveResult: ExperimentSaveResult | null
+}
+
export interface FlagInfo {
key: string
id: number | null
@@ -167,14 +228,72 @@ export interface PageToolbarFlagsState {
mutationRevision: number
}
+export interface DebugEventRow {
+ uuid: string
+ event: string
+ timestamp: string
+ pinned: boolean
+}
+
+export interface PageToolbarEventsState {
+ /** False when the page has no `window.posthog`, so no events reach the debugger. */
+ available: boolean
+ selectedEventTypes: EventCategory[]
+ hidePostHogProperties: boolean
+ hidePostHogFlags: boolean
+ relativeTimestamps: boolean
+ isPaused: boolean
+ bufferedCount: number
+ totalCount: number
+ filteredCount: number
+ countsByType: Record<EventCategory, number>
+ /** The newest filtered events, pinned ones first. */
+ rows: DebugEventRow[]
+ expandedEventId: string | null
+ /** The expanded event's properties after the hide toggles. */
+ expandedProperties: Record<string, unknown>
+ /** The expanded event as captured, for copying. */
+ expandedEventPayload: Record<string, unknown> | null
+}
+
+export interface PageToolbarWebVitalsState {
+ autocaptureEnabled: boolean
+ pathname: string
+ localWebVitals: WebVitalsMetrics
+ remoteWebVitals: WebVitalsMetrics
+}
+
+export interface PageToolbarMoreState {
+ debugInfo: PageDebugInfo | null
+ debugInfoLoading: boolean
+ piiMaskingEnabled: boolean
+ piiMaskingColor: string
+ piiWarnings: string[]
+ screenshot: {
+ taking: boolean
+ /** The page sends the preview image in its own `screenshot-preview` message, once. */
+ open: boolean
+ eventName: string
+ suggestions: { id: string; name: string }[]
+ suggestionsLoading: boolean
+ selectedEventId: string | null
+ uploading: boolean
+ result: { status: 'uploaded' } | { status: 'failed'; error: string } | null
+ }
+}
+
export interface PageToolbarState {
mode: PageToolbarMode
inspect: PageToolbarInspectState
/** Matches on the page for the selectors the panel asked about. `null` marks an invalid selector. */
- selectorCounts: Record<string, number | null>
+ selectorCounts: Record<string, SelectorMatchCounts | null>
heatmap: PageToolbarHeatmapState
actions: PageToolbarActionsState
flags: PageToolbarFlagsState
+ events: PageToolbarEventsState
+ webVitals: PageToolbarWebVitalsState
+ experiments: PageToolbarExperimentsState
+ more: PageToolbarMoreState
}
export type PageToolbarMessage =
@@ -184,6 +303,7 @@ export type PageToolbarMessage =
/** The page refreshed the tokens, which rotates the refresh token. */
| { type: 'tokens'; tokens: PageToolbarTokens }
| { type: 'token-expired' }
+ | { type: 'screenshot-preview'; dataUrl: string }
function isObject(message: unknown): message is Record<string, unknown> {
return !!message && typeof message === 'object'
diff --git a/frontend/src/toolbar/extension/pageToolbarHost.tsx b/frontend/src/toolbar/extension/pageToolbarHost.tsx
index 1b1a017f7ceb..2d7778025e29 100644
--- a/frontend/src/toolbar/extension/pageToolbarHost.tsx
+++ b/frontend/src/toolbar/extension/pageToolbarHost.tsx
@@ -6,7 +6,9 @@ import { toolbarConfigLogic } from '~/toolbar/toolbarConfigLogic'
import { ToolbarProps } from '~/types'
import { ExtensionPort, extensionFileUrl, onPageToolbarConnect } from './extensionBrowser'
+import { extensionPageExperimentsLogic } from './extensionPageExperimentsLogic'
import { extensionPageFlagsLogic } from './extensionPageFlagsLogic'
+import { extensionPageMoreLogic } from './extensionPageMoreLogic'
import { extensionPageToolbarLogic, getPageToolbarState } from './extensionPageToolbarLogic'
import { PagePosthogBridge, onPagePosthogAppeared, requestPageAnalytics } from './pagePosthogBridge'
import {
@@ -40,6 +42,7 @@ export class PageToolbarHost {
private overlayRoot: Root | null = null
private ports = new Set<ExtensionPort>()
private lastState: PageToolbarState | null = null
+ private lastScreenshotPreview: string | null = null
private lastAccessToken: string | null = null
private postTimeout: ReturnType<typeof setTimeout> | null = null
private idleTimeout: ReturnType<typeof setTimeout> | null = null
@@ -132,9 +135,11 @@ export class PageToolbarHost {
}
const unsubscribe = getContext().store.subscribe(() => this.scheduleStatePost())
const unmountConfig = toolbarConfigLogic(props).mount()
- const unmountPageToolbar = extensionPageToolbarLogic.mount()
+ const unmountPageToolbar = extensionPageToolbarLogic({ posthogBridge: this.posthogBridge }).mount()
+ const unmountMore = extensionPageMoreLogic({ posthogBridge: this.posthogBridge }).mount()
this.unmountLogics = () => {
unsubscribe()
+ unmountMore()
unmountPageToolbar()
unmountConfig()
// The toolbar mounts some logics for good, and they keep toolbarConfigLogic with the last session's props
@@ -148,6 +153,8 @@ export class PageToolbarHost {
}
private stop(): void {
+ // A restart and a host change both stop the tools, and the page must not keep a variant preview.
+ extensionPageExperimentsLogic.findMounted()?.actions.closeExperiments()
this.clearIdleTimeout()
if (this.postTimeout !== null) {
clearTimeout(this.postTimeout)
@@ -164,6 +171,7 @@ export class PageToolbarHost {
this.posthogBridge = null
this.uiHost = null
this.lastState = null
+ this.lastScreenshotPreview = null
}
private clearIdleTimeout(): void {
@@ -208,6 +216,10 @@ export class PageToolbarHost {
const state = getPageToolbarState()
this.lastState = state
port.postMessage({ type: 'state', state } satisfies PageToolbarMessage)
+ const preview = this.screenshotPreview()
+ if (preview) {
+ port.postMessage({ type: 'screenshot-preview', dataUrl: preview } satisfies PageToolbarMessage)
+ }
}
private postChanges(): void {
@@ -234,6 +246,15 @@ export class PageToolbarHost {
if (Object.keys(patch).length > 0) {
this.broadcast({ type: 'patch', patch })
}
+ const preview = this.screenshotPreview()
+ if (preview && preview !== this.lastScreenshotPreview) {
+ this.broadcast({ type: 'screenshot-preview', dataUrl: preview })
+ }
+ this.lastScreenshotPreview = preview
+ }
+
+ private screenshotPreview(): string | null {
+ return extensionPageMoreLogic.findMounted()?.values.screenshotPreview ?? null
}
private broadcast(message: PageToolbarMessage): void {
diff --git a/frontend/src/toolbar/extension/panel.tsx b/frontend/src/toolbar/extension/panel.tsx
index b1a92b34d8b3..cc68972db914 100644
--- a/frontend/src/toolbar/extension/panel.tsx
+++ b/frontend/src/toolbar/extension/panel.tsx
@@ -10,6 +10,12 @@ import { extensionAuthLogic } from './extensionAuthLogic'
import { ExtensionPanel } from './ExtensionPanel'
import { extensionPanelLogic } from './extensionPanelLogic'
+// The app's styles pick their colors from the body's theme attribute, which the panel takes from the browser.
+const darkModeQuery = window.matchMedia('(prefers-color-scheme: dark)')
+const applyBrowserTheme = (): void => document.body.setAttribute('theme', darkModeQuery.matches ? 'dark' : 'light')
+applyBrowserTheme()
+darkModeQuery.addEventListener('change', applyBrowserTheme)
+
resetContext({ plugins: [disposablesPlugin, loadersPlugin, subscriptionsPlugin] })
extensionPanelLogic.mount()
extensionAuthLogic.mount()
diff --git a/frontend/src/toolbar/screenshot-upload/screenshotUploadLogic.ts b/frontend/src/toolbar/screenshot-upload/screenshotUploadLogic.ts
index b7e8c195a9fb..cdcf9f05f323 100644
--- a/frontend/src/toolbar/screenshot-upload/screenshotUploadLogic.ts
+++ b/frontend/src/toolbar/screenshot-upload/screenshotUploadLogic.ts
@@ -79,17 +79,20 @@ export interface screenshotUploadLogicActions {
submitUploadSuccess: (
uploadResult: {
success: true
- } | null,
+ },
payload?: any
) => {
uploadResult: {
success: true
- } | null
+ }
payload?: any
}
takeScreenshot: () => {
value: true
}
+ takeScreenshotFailure: (error: string) => {
+ error: string
+ }
}
export type screenshotUploadLogicType = MakeLogicType<
@@ -107,12 +110,16 @@ export const screenshotUploadLogic = kea<screenshotUploadLogicType>([
selectEvent: (definition: EventDefinition) => ({ definition }),
setShowSuggestions: (show: boolean) => ({ show }),
takeScreenshot: true,
+ takeScreenshotFailure: (error: string) => ({ error }),
openModal: (previewUrl: string) => ({ previewUrl }),
closeModal: true,
}),
reducers({
- isTakingScreenshot: [false, { takeScreenshot: () => true, openModal: () => false }],
+ isTakingScreenshot: [
+ false,
+ { takeScreenshot: () => true, openModal: () => false, takeScreenshotFailure: () => false },
+ ],
isModalOpen: [false, { openModal: () => true, closeModal: () => false }],
previewUrl: [null as string | null, { openModal: (_, { previewUrl }) => previewUrl, closeModal: () => null }],
eventName: [
@@ -169,8 +176,7 @@ export const screenshotUploadLogic = kea<screenshotUploadLogicType>([
submitUpload: async (_, breakpoint) => {
const { previewUrl, selectedDefinition } = screenshotUploadLogic.values
if (!previewUrl || !selectedDefinition) {
- lemonToast.error('Please select an event')
- return null
+ throw new Error('Please select an event')
}
// safeFetch can hand back a synthetic 502 JSON response (customer fetch
@@ -205,8 +211,15 @@ export const screenshotUploadLogic = kea<screenshotUploadLogicType>([
listeners(({ actions, props, values }) => ({
takeScreenshot: async () => {
- const blob = await captureElementScreenshot(document.documentElement)
- actions.openModal(URL.createObjectURL(blob))
+ try {
+ const blob = await captureElementScreenshot(document.documentElement)
+ actions.openModal(URL.createObjectURL(blob))
+ } catch (error) {
+ actions.takeScreenshotFailure(error instanceof Error ? error.message : String(error))
+ }
+ },
+ takeScreenshotFailure: ({ error }) => {
+ lemonToast.error(`Failed to take screenshot: ${error}`)
},
closeModal: () => {
if (values.previewUrl) {
diff --git a/frontend/src/toolbar/utils/screenshot.ts b/frontend/src/toolbar/utils/screenshot.ts
index 6cc5b4e9a892..3c271b3c1114 100644
--- a/frontend/src/toolbar/utils/screenshot.ts
+++ b/frontend/src/toolbar/utils/screenshot.ts
@@ -1,14 +1,14 @@
import { captureElementImage } from 'lib/utils/captureElementImage'
import { toolbarUploadMedia } from '~/toolbar/toolbarFetch'
-import { TOOLBAR_ID, toError } from '~/toolbar/utils'
+import { isToolbarRootElement, toError } from '~/toolbar/utils'
export interface ElementScreenshot {
mediaId: string
}
function screenshotFilter(node: Node): boolean {
- return !(node instanceof HTMLElement && node.id === TOOLBAR_ID)
+ return !(node instanceof HTMLElement && isToolbarRootElement(node))
}
export interface CaptureOptions {
diff --git a/frontend/src/toolbar/web-vitals/WebVitalsReport.tsx b/frontend/src/toolbar/web-vitals/WebVitalsReport.tsx
new file mode 100644
index 000000000000..b066d7000f97
--- /dev/null
+++ b/frontend/src/toolbar/web-vitals/WebVitalsReport.tsx
@@ -0,0 +1,152 @@
+import { LemonBanner, Link, Spinner, Tooltip } from '@posthog/lemon-ui'
+
+import { inStorybook, inStorybookTestRunner } from 'lib/utils/dom'
+
+import {
+ METRIC_DESCRIPTION,
+ WEB_VITALS_THRESHOLDS,
+ getThresholdColor,
+ getValueWithUnit,
+} from '~/queries/nodes/WebVitals/definitions'
+import { WebVitalsMetric } from '~/queries/schema/schema-general'
+
+import type { WebVitalsMetrics } from './webVitalsToolbarLogic'
+
+// Same order as in the Web Vitals report
+const ALL_METRICS: WebVitalsMetric[] = ['INP', 'LCP', 'FCP', 'CLS']
+
+export interface WebVitalsReportProps {
+ localWebVitals: WebVitalsMetrics
+ remoteWebVitals: WebVitalsMetrics
+ /** The path of the page the metrics belong to. */
+ pathname: string
+ autocaptureEnabled: boolean
+ settingsUrl: string
+}
+
+export function WebVitalsReport({
+ localWebVitals,
+ remoteWebVitals,
+ pathname,
+ autocaptureEnabled,
+ settingsUrl,
+}: WebVitalsReportProps): JSX.Element {
+ return (
+ <div className="flex flex-col gap-2">
+ {!autocaptureEnabled && !inStorybookTestRunner() && !inStorybook() && (
+ <LemonBanner type="warning">
+ Web vitals are not enabled for this project so you won't see any data here. Enable it on the{' '}
+ <Link to={settingsUrl} target="_blank">
+ settings page
+ </Link>{' '}
+ to start capturing web vitals.
+ </LemonBanner>
+ )}
+
+ <MetricCards
+ metrics={localWebVitals}
+ label={<span className="text-sm font-bold">Metrics for the current page load</span>}
+ />
+ <span className="text-sm mb-2">
+ <i>
+ Not all metrics are reported on every page load. INP/CLS won't be reported until you've interacted
+ enough with the page.
+ </i>
+ </span>
+
+ <MetricCards
+ metrics={remoteWebVitals}
+ label={
+ <span className="text-sm font-bold">
+ <DottedTooltip title="90% of all page loads have a performance better than this value">
+ P90
+ </DottedTooltip>{' '}
+ metrics for{' '}
+ <DottedTooltip
+ title={
+ <span className="text-sm">
+ <code>{pathname}</code> and all paths under the same result after path cleaning
+ </span>
+ }
+ >
+ this path
+ </DottedTooltip>{' '}
+ in the last 7 days.
+ </span>
+ }
+ />
+ </div>
+ )
+}
+
+const MetricCards = ({ metrics, label }: { metrics: WebVitalsMetrics; label: React.ReactNode }): JSX.Element => {
+ return (
+ <div>
+ <span className="text-sm mb-1">{label}</span>
+ <div className="flex flex-row flex-wrap gap-2">
+ {ALL_METRICS.map((metric) => (
+ <MetricCard key={metric} metric={metric} value={metrics[metric]} />
+ ))}
+ </div>
+ </div>
+ )
+}
+
+const MetricCard = ({ metric, value }: { metric: WebVitalsMetric; value: number | null | undefined }): JSX.Element => {
+ const { value: valueWithUnit, unit = '' } = getValueWithUnit(value ?? 0, metric)
+
+ const color = getThresholdColor(value ?? 0, metric)
+
+ const threshold = WEB_VITALS_THRESHOLDS[metric]
+ const thresholdUnit = metric === 'CLS' ? '' : 'ms'
+
+ return (
+ <div className="border rounded-md p-2">
+ <DottedTooltip
+ title={
+ <p>
+ {METRIC_DESCRIPTION[metric]}
+ <br />
+ <div>
+ <strong>Great:</strong> Below {threshold.good}
+ {thresholdUnit} <br />
+ <strong>Needs Improvement:</strong> Between {threshold.good}
+ {thresholdUnit} and {threshold.poor}
+ {thresholdUnit} <br />
+ <strong>Poor:</strong> Above {threshold.poor}
+ {thresholdUnit}
+ </div>
+ </p>
+ }
+ >
+ {metric}:
+ </DottedTooltip>
+ <span
+ // eslint-disable-next-line react/forbid-dom-props
+ style={{ color }}
+ className="text-sm"
+ >
+ {' '}
+ {value === undefined ? <WebVitalsToolbarSpinner /> : value === null ? 'N/A' : `${valueWithUnit}${unit}`}
+ </span>
+ </div>
+ )
+}
+
+const DottedTooltip = ({ children, title }: { children: React.ReactNode; title: React.ReactNode }): JSX.Element => {
+ return (
+ <Tooltip title={<div className="text-sm min-w-80">{title}</div>} interactive>
+ <span className="text-sm font-bold border-b border-dotted border-accent cursor-help">{children}</span>
+ </Tooltip>
+ )
+}
+
+const WebVitalsToolbarSpinner = (): JSX.Element => {
+ // Avoid showing a spinner in Storybook Test Runner,
+ // because tests won't ever finish waiting for them to disappear
+ if (inStorybookTestRunner()) {
+ return <></>
+ }
+
+ return <Spinner speed="2s" />
+}
diff --git a/frontend/src/toolbar/web-vitals/WebVitalsToolbarMenu.tsx b/frontend/src/toolbar/web-vitals/WebVitalsToolbarMenu.tsx
index b1e3f4de7aba..101ccb7e4ce9 100644
--- a/frontend/src/toolbar/web-vitals/WebVitalsToolbarMenu.tsx
+++ b/frontend/src/toolbar/web-vitals/WebVitalsToolbarMenu.tsx
@@ -1,25 +1,14 @@
import { useValues } from 'kea'
-import { LemonBanner, Link, Spinner, Tooltip } from '@posthog/lemon-ui'
+import { Link } from '@posthog/lemon-ui'
-import { inStorybook, inStorybookTestRunner } from 'lib/utils/dom'
-
-import {
- METRIC_DESCRIPTION,
- WEB_VITALS_THRESHOLDS,
- getThresholdColor,
- getValueWithUnit,
-} from '~/queries/nodes/WebVitals/definitions'
-import { WebVitalsMetric } from '~/queries/schema/schema-general'
import { ToolbarMenu } from '~/toolbar/bar/ToolbarMenu'
import { urls } from '~/toolbar/urls'
import { joinWithUiHost } from '~/toolbar/utils'
import { toolbarConfigLogic } from '../toolbarConfigLogic'
-import { WebVitalsMetrics, webVitalsToolbarLogic } from './webVitalsToolbarLogic'
-
-// Same order as in the Web Vitals report
-const ALL_METRICS: WebVitalsMetric[] = ['INP', 'LCP', 'FCP', 'CLS']
+import { WebVitalsReport } from './WebVitalsReport'
+import { webVitalsToolbarLogic } from './webVitalsToolbarLogic'
export const WebVitalsToolbarMenu = (): JSX.Element => {
const { localWebVitals, remoteWebVitals } = useValues(webVitalsToolbarLogic)
@@ -28,51 +17,13 @@ export const WebVitalsToolbarMenu = (): JSX.Element => {
return (
<ToolbarMenu>
<ToolbarMenu.Body>
- <div className="flex flex-col gap-2">
- {!posthog?.webVitalsAutocapture?.isEnabled && !inStorybookTestRunner() && !inStorybook() && (
- <LemonBanner type="warning">
- Web vitals are not enabled for this project so you won't see any data here. Enable it on the{' '}
- <Link to={joinWithUiHost(uiHost, urls.settings())} target="_blank">
- settings page
- </Link>{' '}
- to start capturing web vitals.
- </LemonBanner>
- )}
-
- <MetricCards
- metrics={localWebVitals}
- label={<span className="text-sm font-bold">Metrics for the current page load</span>}
- />
- <span className="text-sm mb-2">
- <i>
- Not all metrics are reported on every page load. INP/CLS won't be reported until you've
- interacted enough with the page.
- </i>
- </span>
-
- <MetricCards
- metrics={remoteWebVitals}
- label={
- <span className="text-sm font-bold">
- <DottedTooltip title="90% of all page loads have a performance better than this value">
- P90
- </DottedTooltip>{' '}
- metrics for{' '}
- <DottedTooltip
- title={
- <span className="text-sm">
- <code>{window.location.pathname}</code> and all paths under the same result
- after path cleaning
- </span>
- }
- >
- this path
- </DottedTooltip>{' '}
- in the last 7 days.
- </span>
- }
- />
- </div>
+ <WebVitalsReport
+ localWebVitals={localWebVitals}
+ remoteWebVitals={remoteWebVitals}
+ pathname={window.location.pathname}
+ autocaptureEnabled={!!posthog?.webVitalsAutocapture?.isEnabled}
+ settingsUrl={joinWithUiHost(uiHost, urls.settings())}
+ />
</ToolbarMenu.Body>
<ToolbarMenu.Footer>
@@ -88,75 +39,3 @@ export const WebVitalsToolbarMenu = (): JSX.Element => {
</ToolbarMenu>
)
}
-
-const MetricCards = ({ metrics, label }: { metrics: WebVitalsMetrics; label: React.ReactNode }): JSX.Element => {
- return (
- <div>
- <span className="text-sm mb-1">{label}</span>
- <div className="flex flex-row gap-2">
- {ALL_METRICS.map((metric) => (
- <MetricCard key={metric} metric={metric} value={metrics[metric]} />
- ))}
- </div>
- </div>
- )
-}
-
-const MetricCard = ({ metric, value }: { metric: WebVitalsMetric; value: number | null | undefined }): JSX.Element => {
- const { value: valueWithUnit, unit = '' } = getValueWithUnit(value ?? 0, metric)
-
- const color = getThresholdColor(value ?? 0, metric)
-
- const threshold = WEB_VITALS_THRESHOLDS[metric]
- const thresholdUnit = metric === 'CLS' ? '' : 'ms'
-
- return (
- <div className="border rounded-md p-2">
- <DottedTooltip
- title={
- <p>
- {METRIC_DESCRIPTION[metric]}
- <br />
- <div>
- <strong>Great:</strong> Below {threshold.good}
- {thresholdUnit} <br />
- <strong>Needs Improvement:</strong> Between {threshold.good}
- {thresholdUnit} and {threshold.poor}
- {thresholdUnit} <br />
- <strong>Poor:</strong> Above {threshold.poor}
- {thresholdUnit}
- </div>
- </p>
- }
- >
- {metric}:
- </DottedTooltip>
- <span
- // eslint-disable-next-line react/forbid-dom-props
- style={{ color }}
- className="text-sm"
- >
- {' '}
- {value === undefined ? <WebVitalsToolbarSpinner /> : value === null ? 'N/A' : `${valueWithUnit}${unit}`}
- </span>
- </div>
- )
-}
-
-const DottedTooltip = ({ children, title }: { children: React.ReactNode; title: React.ReactNode }): JSX.Element => {
- return (
- <Tooltip title={<div className="text-sm min-w-80">{title}</div>} interactive>
- <span className="text-sm font-bold border-b border-dotted border-accent cursor-help">{children}</span>
- </Tooltip>
- )
-}
-
-const WebVitalsToolbarSpinner = (): JSX.Element => {
- // Avoid showing a spinner in Storybook Test Runner,
- // because tests won't ever finish waiting for them to disappear
- if (inStorybookTestRunner()) {
- return <></>
- }
-
- return <Spinner speed="2s" />
-}