:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
feat(tracing): show every trace in one drawer with the dialog layout (#121307)
Jon McCallumcfd469fe112a
diff --git a/frontend/src/lib/lemon-ui/LemonDrawer/LemonDrawer.tsx b/frontend/src/lib/lemon-ui/LemonDrawer/LemonDrawer.tsxindex 240aeec1a05d..882589111b77 100644--- a/frontend/src/lib/lemon-ui/LemonDrawer/LemonDrawer.tsx+++ b/frontend/src/lib/lemon-ui/LemonDrawer/LemonDrawer.tsx@@ -28,6 +28,8 @@ interface LemonDrawerBaseProps {width?: number | string/** Enable drag-to-resize on the left edge of the drawer */resizable?: boolean+ /** Key for the resize state. Give a drawer that opens over another its own, so the two size independently. */+ resizerLogicKey?: stringdescription?: React.ReactNodefooter?: React.ReactNodehideCloseButton?: boolean@@ -81,6 +83,7 @@ export function LemonDrawer({simple,hideCloseButton = false,resizable = false,+ resizerLogicKey = 'lemon-drawer',overlayTransparent = false,forceAbovePopovers = false,contentRef,@@ -98,7 +101,7 @@ export function LemonDrawer({const containerRef = useRef<HTMLDivElement>(null)const resizerLogicProps: ResizerLogicProps = {containerRef,- logicKey: 'lemon-drawer',+ logicKey: resizerLogicKey,persistent: false,placement: 'left',}diff --git a/products/tracing/frontend/TracingScene.tsx b/products/tracing/frontend/TracingScene.tsxindex 603c0ea4fc4f..24a75cf79263 100644--- a/products/tracing/frontend/TracingScene.tsx+++ b/products/tracing/frontend/TracingScene.tsx@@ -44,7 +44,7 @@ import { TracingFilterBar } from './TracingFilterBar'import { TRACING_SCENE_VIEWER_ID, tracingFiltersLogic } from './tracingFiltersLogic'import { type TracingSceneTab, tracingSceneLogic } from './tracingSceneLogic'import { TracingSparkline } from './TracingSparkline'-import { tracingViewerLogic } from './tracingViewerLogic'+import { traceViewId, tracingViewerLogic } from './tracingViewerLogic'import type { Span, SpanInspectorTab } from './types'const TRACING_FEEDBACK_SURVEY_ID = '019e6a26-4943-0000-24a0-dc46310f6b7c'@@ -91,7 +91,6 @@ function TracingSceneContents(): JSX.Element {spansError,isTraceOpen,selectedTraceId,- selectedSpanId,selectedTraceTs,sparklineData,sparklineLoading,@@ -101,7 +100,8 @@ function TracingSceneContents(): JSX.Element {traceSessionId,sessionErrorBadgesEnabled,errorBadgeByRow,- inspectorTab,+ inspectorOpen,+ isFullscreen,errorsScope,isLoadingFullTrace,canLoadMoreTraceSpans,@@ -135,7 +135,6 @@ function TracingSceneContents(): JSX.Element {const {openTrace,closeTrace,- selectSpan,setDateRange,updateComparisonWindows,openCompareFlame,@@ -146,7 +145,8 @@ function TracingSceneContents(): JSX.Element {loadTraceSpans,loadMoreTraceSpans,setVisibleRowRange,- selectInspectorTab,+ toggleInspector,+ toggleFullscreen,setSort,setChartType,applyHeatmapBrush,@@ -379,6 +379,7 @@ function TracingSceneContents(): JSX.Element {</div>{activeSceneTab === 'sql' && <TracingSqlEditor id={TRACING_SCENE_VIEWER_ID} />}<TraceDrawer+ viewId={traceViewId(TRACING_SCENE_VIEWER_ID)}isOpen={isTraceOpen}traceId={selectedTraceId}ts={selectedTraceTs}@@ -386,9 +387,11 @@ function TracingSceneContents(): JSX.Element {identity={traceIdentity}sessionId={traceSessionId}showErrorsTab={sessionErrorBadgesEnabled}- inspectorTab={inspectorTab}errorsScope={errorsScope}- onSelectInspectorTab={selectInspectorTab}+ inspectorOpen={inspectorOpen}+ onToggleInspector={toggleInspector}+ isFullscreen={isFullscreen}+ onToggleFullscreen={toggleFullscreen}loading={isLoadingFullTrace}loadFailed={selectedTraceLoadFailed}filtersActive={traceLoadFiltersActive}@@ -400,8 +403,6 @@ function TracingSceneContents(): JSX.Element {hasMoreSpans={canLoadMoreTraceSpans}loadingMoreSpans={traceSpansLoadingMore}onLoadMoreSpans={loadMoreTraceSpans}- selectedSpanId={selectedSpanId}- onSelectSpan={selectSpan}onClose={closeTrace}/><LemonModaldiff --git a/products/tracing/frontend/components/TraceDialog/TraceDialog.tsx b/products/tracing/frontend/components/TraceDialog/TraceDialog.tsxindex 7e7ded75ba56..62d862e43d08 100644--- a/products/tracing/frontend/components/TraceDialog/TraceDialog.tsx+++ b/products/tracing/frontend/components/TraceDialog/TraceDialog.tsx@@ -1,27 +1,22 @@-import { BindLogic, useActions, useValues } from 'kea'-import { useCallback, useState } from 'react'+import { useActions, useValues } from 'kea'-import { IconCollapse45, IconExpand45, IconExternal, IconSidebarClose, IconSidebarOpen } from '@posthog/icons'-import { LemonBanner, LemonButton, LemonModal, LemonTag, Spinner } from '@posthog/lemon-ui'+import { IconExternal } from '@posthog/icons'+import { LemonBanner, LemonButton, Spinner } from '@posthog/lemon-ui'+import { KeyboardShortcut } from 'lib/components/KeyboardShortcut/KeyboardShortcut'import { RecordingPlayerType } from 'lib/components/ViewRecordingButton/ViewRecordingButton'import { traceUrl } from 'lib/components/ViewTraceButton/traceUrl'-import { FloatingContainerContext } from 'lib/hooks/useFloatingContainerContext'-import { cn } from 'lib/utils/css-classes'-import { pluralize } from 'lib/utils/strings'import { TraceIdentityChips } from 'products/tracing/frontend/components/TraceDrawer/TraceIdentityChips'import { TraceLoadErrorNotice } from 'products/tracing/frontend/components/TraceDrawer/TraceLoadErrorNotice'import { TraceUnavailableNotice } from 'products/tracing/frontend/components/TraceDrawer/TraceUnavailableNotice'-import { formatDuration } from 'products/tracing/frontend/TraceWaterfallView'import { TraceView } from '../TraceView/TraceView'+import { TraceViewDrawer } from '../TraceView/TraceViewDrawer'import { traceViewLogic } from '../TraceView/traceViewLogic'+import { TraceViewShortcuts } from '../TraceView/TraceViewShortcuts'import { TRACE_DIALOG_DATA_ATTR, TRACE_DIALOG_VIEW_ID, traceDialogLogic } from './traceDialogLogic'import { TraceDialogOpenedFromLog } from './TraceDialogOpenedFromLog'-import { TraceDialogShortcuts } from './TraceDialogShortcuts'--const TRACE_VIEW_PROPS = { id: TRACE_DIALOG_VIEW_ID }export function TraceDialog(): JSX.Element | null {const {@@ -40,117 +35,78 @@ export function TraceDialog(): JSX.Element | null {} = useValues(traceDialogLogic)const { closeTraceDialog, loadTraceSpans, openInTracing, toggleInspector, toggleFullscreen } =useActions(traceDialogLogic)- const { summary, timeline } = useValues(traceViewLogic(TRACE_VIEW_PROPS))- // The dialog sits above popovers, so the inspector's menus and drawers, and the person popover,- // portal inside it instead.- const [floatingContainer, setFloatingContainer] = useState<HTMLDivElement | null>(null)- const floatingContainerRef = useCallback((el: HTMLDivElement | null) => setFloatingContainer(el), [])+ const { summary } = useValues(traceViewLogic({ id: TRACE_DIALOG_VIEW_ID }))if (!trace) {return null}return (- <LemonModal+ <TraceViewDrawer+ viewId={TRACE_DIALOG_VIEW_ID}+ traceId={trace.traceId}isOpen={isOpen}// The close button hands onClose its click event, which must not land in the reason argument.onClose={() => closeTraceDialog('dismissed')}- title={<span translate="no">{summary.rootSpan?.name ?? 'Trace'}</span>}- description={- <div className="flex flex-wrap items-center gap-2">- <span className="font-mono text-xs" translate="no">- {trace.traceId}+ inspectorOpen={inspectorOpen}+ onToggleInspector={toggleInspector}+ isFullscreen={isFullscreen}+ onToggleFullscreen={toggleFullscreen}+ // Logs and metrics open it from inside their own modals and popovers.+ forceAbovePopovers+ shortcuts={+ <TraceViewShortcuts closeLabel={openedFrom ? 'Back to log' : 'Close'}>+ <span className="flex items-center gap-1">+ <KeyboardShortcut command />+ <span>Click Open in Tracing for a new tab</span></span>- {traceSpans && traceSpans.spans.length > 0 && (- <>- <LemonTag>{formatDuration(timeline.durationUs * 1_000)}</LemonTag>- <LemonTag>- {pluralize(summary.spanCount, 'span')} · {pluralize(summary.serviceCount, 'service')}- </LemonTag>- {summary.errorCount > 0 && (- <LemonTag type="danger">{pluralize(summary.errorCount, 'error')}</LemonTag>- )}- </>- )}- </div>+ </TraceViewShortcuts>}- forceAbovePopovers- data-attr={TRACE_DIALOG_DATA_ATTR}- width="90vw"- maxWidth={1600}- fullScreen={isFullscreen}- footer={- <div className="flex flex-wrap items-center justify-between gap-2 w-full">- <TraceDialogShortcuts />- <div className="flex items-center gap-2">- <LemonButton- type="secondary"- icon={inspectorOpen ? <IconSidebarClose /> : <IconSidebarOpen />}- tooltip={inspectorOpen ? 'Hide span details' : 'Show span details'}- onClick={toggleInspector}- data-attr="trace-dialog-toggle-inspector"- />- <LemonButton- type="secondary"- icon={isFullscreen ? <IconCollapse45 /> : <IconExpand45 />}- tooltip={isFullscreen ? 'Exit full screen' : 'Full screen'}- onClick={toggleFullscreen}- data-attr="trace-dialog-toggle-fullscreen"- />- <LemonButton- type="secondary"- icon={<IconExternal />}- to={traceUrl(trace)}- onClick={openInTracing}- data-attr="trace-dialog-open-in-tracing"- >- Open in Tracing- </LemonButton>- </div>- </div>+ footerActions={+ <LemonButton+ type="secondary"+ icon={<IconExternal />}+ to={traceUrl(trace)}+ onClick={openInTracing}+ data-attr="trace-dialog-open-in-tracing"+ >+ Open in Tracing+ </LemonButton>}+ data-attr={TRACE_DIALOG_DATA_ATTR}>- <FloatingContainerContext.Provider value={floatingContainer}>- {/* The span list virtualizes, so it needs a definite height to measure against. Full screen- leaves room for the dialog's header and footer. */}- <div className={cn('flex flex-col gap-2', isFullscreen ? 'h-[calc(100vh-12rem)]' : 'h-[65vh]')}>- <TraceDialogOpenedFromLog />- <TraceIdentityChips- identity={traceIdentity}- timestamp={summary.rootSpan?.timestamp ?? trace.ts ?? null}- // The player modal stacks below this dialog, so the recording opens in a new tab.- openRecordingIn={RecordingPlayerType.NewTab}- />- {traceSpans?.truncated && (- <LemonBanner type="info">- Showing the first {summary.spanCount.toLocaleString()} spans. Open this trace in Tracing to- see all of them.- </LemonBanner>- )}- {traceSpansLoading ? (- <div className="flex flex-1 items-center justify-center">- <Spinner className="text-2xl" />- </div>- ) : traceSpansFailed ? (- <TraceLoadErrorNotice onRetry={() => loadTraceSpans(trace)} />- ) : !traceSpans || traceSpans.spans.length === 0 ? (- // The dialog has no filters, and Open in Tracing below covers spans outside its time window.- <TraceUnavailableNotice traceId={trace.traceId} filtersActive={false} surface="trace_dialog" />- ) : (- <BindLogic logic={traceViewLogic} props={TRACE_VIEW_PROPS}>- <TraceView- traceId={trace.traceId}- inspectorOpen={inspectorOpen}- sessionId={traceSessionId}- showErrorsTab={sessionErrorBadgesEnabled}- openedFrom={openedFrom}- openedAtUs={openedAtUs}- />- </BindLogic>- )}+ <TraceDialogOpenedFromLog />+ <TraceIdentityChips+ identity={traceIdentity}+ timestamp={summary.rootSpan?.timestamp ?? trace.ts ?? null}+ // The player modal stacks below this drawer, so the recording opens in a new tab.+ openRecordingIn={RecordingPlayerType.NewTab}+ />+ {traceSpans?.truncated && (+ <LemonBanner type="info">+ Showing the first {summary.spanCount.toLocaleString()} spans. Open this trace in Tracing to see all+ of them.+ </LemonBanner>+ )}+ {traceSpansLoading ? (+ <div className="flex flex-1 items-center justify-center">+ <Spinner className="text-2xl" /></div>- <div ref={floatingContainerRef} />- </FloatingContainerContext.Provider>- </LemonModal>+ ) : traceSpansFailed ? (+ <TraceLoadErrorNotice onRetry={() => loadTraceSpans(trace)} />+ ) : !traceSpans || traceSpans.spans.length === 0 ? (+ // There are no filters here, and Open in Tracing below covers spans outside this time window.+ <TraceUnavailableNotice traceId={trace.traceId} filtersActive={false} surface="trace_dialog" />+ ) : (+ <TraceView+ traceId={trace.traceId}+ inspectorOpen={inspectorOpen}+ sessionId={traceSessionId}+ showErrorsTab={sessionErrorBadgesEnabled}+ openedFrom={openedFrom}+ openedAtUs={openedAtUs}+ />+ )}+ </TraceViewDrawer>)}diff --git a/products/tracing/frontend/components/TraceDialog/TraceDialogSpanTree.tsx b/products/tracing/frontend/components/TraceDialog/TraceDialogSpanTree.tsxindex 31b9ed8f4cd9..7c0a69010d58 100644--- a/products/tracing/frontend/components/TraceDialog/TraceDialogSpanTree.tsx+++ b/products/tracing/frontend/components/TraceDialog/TraceDialogSpanTree.tsx@@ -2,6 +2,8 @@ import { useActions, useValues } from 'kea'import { CSSProperties, useCallback, useEffect, useMemo, useRef, useState } from 'react'import { List, useListRef } from 'react-window'+import { LemonButton, Spinner } from '@posthog/lemon-ui'+import { AutoSizer } from 'lib/components/AutoSizer'import { SizeProps } from 'lib/components/AutoSizer/AutoSizer'@@ -15,6 +17,7 @@ import { rowSpanNode, type TraceDialogRow } from './traceDialogRows'import { TraceDialogSpanRow } from './TraceDialogSpanRow'const ROW_HEIGHT = 32+const LOAD_MORE_THRESHOLD = 10interface SpanListRowData {spanRows: TraceDialogRow[]@@ -125,9 +128,18 @@ const MAX_PINNED_ANCESTORS = 4export interface TraceDialogSpanTreeProps {openedFrom: TraceDialogSource | nullopenedAtUs: number | null+ hasMore?: boolean+ loadingMore?: boolean+ onLoadMore?: () => void}-export function TraceDialogSpanTree({ openedFrom, openedAtUs }: TraceDialogSpanTreeProps): JSX.Element {+export function TraceDialogSpanTree({+ openedFrom,+ openedAtUs,+ hasMore = false,+ loadingMore = false,+ onLoadMore,+}: TraceDialogSpanTreeProps): JSX.Element {const {spanRows,spanTree,@@ -153,9 +165,21 @@ export function TraceDialogSpanTree({ openedFrom, openedAtUs }: TraceDialogSpanT// an early scroll is lost: retry each time the rendered rows change until the span is visible, then// leave scrolling to the user.const revealedIndexRef = useRef<number | null>(null)- const revealOpenedSpan = useCallback(+ // Fires at most once per loaded row count, so a page that adds no rows can't retrigger on every render.+ const lastRequestedRowCountRef = useRef(-1)+ const onRowsRendered = useCallback((visibleRows: { startIndex: number; stopIndex: number }): void => {setTopIndex(visibleRows.startIndex)+ if (+ onLoadMore &&+ hasMore &&+ !loadingMore &&+ visibleRows.stopIndex >= spanRows.length - 1 - LOAD_MORE_THRESHOLD &&+ lastRequestedRowCountRef.current !== spanRows.length+ ) {+ lastRequestedRowCountRef.current = spanRows.length+ onLoadMore()+ }if (openedIndex < 0 || revealedIndexRef.current === openedIndex) {return}@@ -165,7 +189,7 @@ export function TraceDialogSpanTree({ openedFrom, openedAtUs }: TraceDialogSpanT}listRef.current?.scrollToRow({ index: openedIndex, align: 'center' })},- [openedIndex, listRef]+ [openedIndex, listRef, onLoadMore, hasMore, loadingMore, spanRows.length])// Keep each span J and K step to in view. While the opened span still waits for its centred reveal// above, this leaves it alone.@@ -262,11 +286,30 @@ export function TraceDialogSpanTree({ openedFrom, openedAtUs }: TraceDialogSpanTonShowAll: showAllChildren,}}listRef={listRef}- onRowsRendered={revealOpenedSpan}+ onRowsRendered={onRowsRendered}/>)}/></div>+ {hasMore && (+ <div className="flex items-center justify-center gap-2 py-2 text-xs text-muted border-t">+ {loadingMore ? (+ <>+ <Spinner />+ <span>Loading more spans…</span>+ </>+ ) : (+ <LemonButton+ size="xsmall"+ type="tertiary"+ onClick={() => onLoadMore?.()}+ data-attr="trace-view-load-more-spans"+ >+ Load more spans+ </LemonButton>+ )}+ </div>+ )}</div>)}diff --git a/products/tracing/frontend/components/TraceDialog/traceDialogLogic.ts b/products/tracing/frontend/components/TraceDialog/traceDialogLogic.tsindex f3b4094fd4e5..9fe7ec3273d6 100644--- a/products/tracing/frontend/components/TraceDialog/traceDialogLogic.ts+++ b/products/tracing/frontend/components/TraceDialog/traceDialogLogic.ts@@ -168,6 +168,12 @@ export interface traceDialogLogicActions {collapseSelectedSpan: () => {value: true} // traceViewLogic+ disableSpanKeys: () => {+ value: true+ } // traceViewLogic+ enableSpanKeys: (containerSelector: string) => {+ containerSelector: string+ } // traceViewLogicexpandSelectedSpan: () => {value: true} // traceViewLogic@@ -177,8 +183,8 @@ export interface traceDialogLogicActions {selectPreviousSpan: () => {value: true} // traceViewLogic- selectSpan: (spanId: string) => {- spanId: string+ selectSpan: (spanId: string | null) => {+ spanId: string | null} // traceViewLogicsetInspectorTab: (tab: SpanInspectorTab) => {tab: SpanInspectorTab@@ -186,8 +192,12 @@ export interface traceDialogLogicActions {setSpans: (spans: Span[]) => {spans: Span[]} // traceViewLogic- showTrace: (pinnedSpanId: string | null) => {+ showTrace: (+ pinnedSpanId: string | null,+ tab: SpanInspectorTab | null+ ) => {pinnedSpanId: string | null+ tab: SpanInspectorTab | null} // traceViewLogicspanStepped: () => {value: true@@ -288,6 +298,8 @@ export const traceDialogLogic = kea<traceDialogLogicType>(['selectPreviousSpan','collapseSelectedSpan','expandSelectedSpan',+ 'enableSpanKeys',+ 'disableSpanKeys',],],values: [@@ -460,40 +472,12 @@ export const traceDialogLogic = kea<traceDialogLogicType>([has_span: !!trace.spanId,has_log: !!openedFrom,})- actions.showTrace(trace.spanId)+ actions.showTrace(trace.spanId, null)actions.loadTraceSpans(trace)- // Capture phase, and stopped there, so the page under the dialog does not also act on- // the key: with log details open, the logs list binds J and K to its own cursor.- cache.disposables.add(() => {- const onKeyDown = (event: KeyboardEvent): void => {- const target = event.target as HTMLElement | null- // A field behind the dialog can still hold focus, such as one that autofocused- // while the trace loaded. The person cannot see it, so the key is theirs to step with.- const typing =- !!target?.closest(TRACE_DIALOG_SELECTOR) &&- (['input', 'textarea', 'select'].includes(target.tagName.toLowerCase()) ||- target.isContentEditable)- if (typing || event.isComposing || event.metaKey || event.ctrlKey || event.altKey) {- return- }- const step = {- j: actions.selectNextSpan,- k: actions.selectPreviousSpan,- arrowleft: actions.collapseSelectedSpan,- arrowright: actions.expandSelectedSpan,- }[event.key.toLowerCase()]- if (step) {- event.preventDefault()- event.stopPropagation()- step()- }- }- window.addEventListener('keydown', onKeyDown, { capture: true })- return () => window.removeEventListener('keydown', onKeyDown, { capture: true })- }, 'spanKeys')+ actions.enableSpanKeys(TRACE_DIALOG_SELECTOR)},closeTraceDialog: ({ reason }) => {- cache.disposables.dispose('spanKeys')+ actions.disableSpanKeys()const session: TraceDialogSession | undefined = cache.sessionif (!session) {returndiff --git a/products/tracing/frontend/components/TraceDrawer/TraceDrawer.test.tsx b/products/tracing/frontend/components/TraceDrawer/TraceDrawer.test.tsxindex 30b856d6803d..86ae1b23db4b 100644--- a/products/tracing/frontend/components/TraceDrawer/TraceDrawer.test.tsx+++ b/products/tracing/frontend/components/TraceDrawer/TraceDrawer.test.tsx@@ -13,6 +13,7 @@ import { tracingSpansTraceAiEventsRetrieve } from 'products/tracing/frontend/genimport { makeSpan } from '../../__mocks__/span'import { EMPTY_TRACE_IDENTITY } from '../../traceIdentity'+import { traceViewLogic } from '../TraceView/traceViewLogic'import { TraceDrawer, type TraceDrawerProps } from './TraceDrawer'jest.mock('products/tracing/frontend/generated/api', () => ({@@ -38,9 +39,13 @@ describe('TraceDrawer', () => {})const renderDrawer = (props: Partial<TraceDrawerProps>): void => {+ const view = traceViewLogic({ id: 'trace-drawer-test' })+ view.mount()+ view.actions.showTrace(null, 'attributes')render(<Provider><TraceDrawer+ viewId="trace-drawer-test"isOpentraceId="abc123"ts={null}@@ -48,14 +53,14 @@ describe('TraceDrawer', () => {identity={EMPTY_TRACE_IDENTITY}sessionId={null}showErrorsTab={false}- inspectorTab="attributes"errorsScope={null}- onSelectInspectorTab={jest.fn()}+ inspectorOpen+ onToggleInspector={jest.fn()}+ isFullscreen={false}+ onToggleFullscreen={jest.fn()}loading={false}loadFailed={false}filtersActive={false}- selectedSpanId={null}- onSelectSpan={jest.fn()}onClose={jest.fn()}{...props}/>diff --git a/products/tracing/frontend/components/TraceDrawer/TraceDrawer.tsx b/products/tracing/frontend/components/TraceDrawer/TraceDrawer.tsxindex 121031b51024..8813d96a76b1 100644--- a/products/tracing/frontend/components/TraceDrawer/TraceDrawer.tsx+++ b/products/tracing/frontend/components/TraceDrawer/TraceDrawer.tsx@@ -1,35 +1,30 @@import { useActions, useValues } from 'kea'-import { useMemo, useRef } from 'react'+import { useLayoutEffect, useMemo } from 'react'-import { LemonBanner, LemonButton, LemonTag, SpinnerOverlay } from '@posthog/lemon-ui'+import { LemonBanner, LemonButton, SpinnerOverlay } from '@posthog/lemon-ui'-import { Resizer } from 'lib/components/Resizer/Resizer'-import { type ResizerLogicProps, resizerLogic } from 'lib/components/Resizer/resizerLogic'import { IconLink } from 'lib/lemon-ui/icons'-import { LemonDrawer } from 'lib/lemon-ui/LemonDrawer/LemonDrawer'import { copyToClipboard } from 'lib/utils/copyToClipboard'-import { cn } from 'lib/utils/css-classes'import { buildAiEventSpans } from '../../aiEventSpans'import type { ErrorScope } from '../../errorCorrelation'import { useKeepMountedWhileOpen } from '../../hooks/useKeepMountedWhileOpen'import type { TraceIdentity } from '../../traceIdentity'import { absoluteTraceUrl } from '../../traceLinks'-import { buildServiceColorMap, formatDuration, TraceWaterfallView } from '../../TraceWaterfallView'-import type { Span, SpanInspectorTab } from '../../types'-import { SpanInspector } from '../SpanInspector/SpanInspector'-import { MissingParentSpanNotice } from './MissingParentSpanNotice'+import { TRACE_DRAWER_DATA_ATTR } from '../../tracingViewerLogic'+import type { Span } from '../../types'+import { TraceView } from '../TraceView/TraceView'+import { TraceViewDrawer } from '../TraceView/TraceViewDrawer'+import { traceViewLogic } from '../TraceView/traceViewLogic'+import { TraceViewShortcuts } from '../TraceView/TraceViewShortcuts'import { TraceAiEventsCapNotice } from './TraceAiEventsCapNotice'import { traceAiEventsLogic } from './traceAiEventsLogic'import { TraceIdentityChips } from './TraceIdentityChips'import { TraceLoadErrorNotice } from './TraceLoadErrorNotice'import { TraceUnavailableNotice } from './TraceUnavailableNotice'-// Below this the inspector's content (the attribute KVP tables) stops being readable; clamp so a-// drag can't crush it. The max is a flex `max-w` so a too-wide drag can't starve the waterfall.-const MIN_INSPECTOR_WIDTH = 320-export interface TraceDrawerProps {+ viewId: stringisOpen: booleantraceId: string | null/** Timestamp hint echoed into copy-links so cold loads can bound the lookup. */@@ -41,11 +36,12 @@ export interface TraceDrawerProps {sessionId: string | null/** Show the Errors tab, which lists the issues connected to the trace. */showErrorsTab: boolean- /** Which inspector tab is open. Held in tracingViewerLogic so a caller can open one directly. */- inspectorTab: SpanInspectorTab/** The scope the Errors tab opens on, when the caller named one. */errorsScope: ErrorScope | null- onSelectInspectorTab: (tab: SpanInspectorTab) => void+ inspectorOpen: boolean+ onToggleInspector: () => void+ isFullscreen: boolean+ onToggleFullscreen: () => voidloading: boolean/** The last full-trace fetch failed (network, 4xx, 5xx) — shows a retryable error instead of the empty-trace notice. */loadFailed: boolean@@ -53,21 +49,20 @@ export interface TraceDrawerProps {onRetry?: () => void/** List filters scoped the last trace lookup, so an empty trace may be filtered out rather than never sent. */filtersActive: boolean- /** The open trace has more spans than the loaded pages — drives the waterfall's infinite scroll. */+ /** The open trace has more spans than the loaded pages — drives the span tree's infinite scroll. */hasMoreSpans?: boolean/** A next page of spans is being fetched (shows a bottom spinner without the full overlay). */loadingMoreSpans?: booleanonLoadMoreSpans?: () => void- selectedSpanId: string | null- onSelectSpan: (spanId: string | null) => voidonClose: () => void}-// Master-detail split: waterfall on the left drives the span inspector on the right — the same+// Master-detail split: the span tree on the left drives the span inspector on the right — the same// list→detail relationship the span list has with this drawer, one level down. Tabs live *inside*-// the inspector (Attributes / Logs), not at the drawer level — so the waterfall stays visible while+// the inspector (Attributes / Logs), not at the drawer level — so the tree stays visible while// you read a span's attributes or its correlated logs.export function TraceDrawer({+ viewId,isOpen,traceId,ts,@@ -75,9 +70,11 @@ export function TraceDrawer({identity,sessionId,showErrorsTab,- inspectorTab,errorsScope,- onSelectInspectorTab,+ inspectorOpen,+ onToggleInspector,+ isFullscreen,+ onToggleFullscreen,loading,loadFailed,onRetry,@@ -85,8 +82,6 @@ export function TraceDrawer({hasMoreSpans = false,loadingMoreSpans = false,onLoadMoreSpans,- selectedSpanId,- onSelectSpan,onClose,}: TraceDrawerProps): JSX.Element | null {const { aiEvents, hasMoreAiEvents, aiEventsLimit, aiEventsResponseLoading, aiEventsLoadFailed } = useValues(@@ -103,42 +98,23 @@ export function TraceDrawer({loadAiEvents()}}- // The waterfall and the inspector read one list, so an AI row selects and inspects like a span.+ // The tree and the inspector read one list, so an AI row selects and inspects like a span.const spans = useMemo(() => {const aiEventSpans = buildAiEventSpans(aiEvents, realSpans)return aiEventSpans.length > 0 ? [...realSpans, ...aiEventSpans] : realSpans}, [realSpans, aiEvents])- // Waterfall|inspector split. Persisted so a user's preferred split sticks across traces;- // desiredSize is null until the first drag, leaving the responsive default (w-2/5) in place.- // One props object feeds both the value-read and the <Resizer>, so the logicKey can't desync.- const inspectorRef = useRef<HTMLDivElement>(null)- const inspectorResizerProps: ResizerLogicProps = {- logicKey: 'tracing-span-inspector',- placement: 'left',- containerRef: inspectorRef,- persistent: true,- }- const { desiredSize: inspectorWidth } = useValues(resizerLogic(inspectorResizerProps))- // Resolve the inspected span outside render churn: a resize drag re-renders this component on- // every mousemove, and these scans are O(spans) — memoize so they only run when data/selection change.- const rootSpan = useMemo(() => spans.find((span) => span.is_root_span) ?? spans[0] ?? null, [spans])- const selectedSpan = useMemo(- () => (selectedSpanId ? (spans.find((span) => span.span_id === selectedSpanId) ?? null) : null),- [spans, selectedSpanId]- )- // The waterfall's "<parent span missing>" row selects an id that only appears as a parent id.- const missingParentSpanId = useMemo(- () =>- selectedSpanId && !selectedSpan && spans.some((span) => span.parent_span_id === selectedSpanId)- ? selectedSpanId- : null,- [spans, selectedSpanId, selectedSpan]- )- // Shared with the waterfall so a service is the same color in the bars and the summary header.- const serviceColorMap = useMemo(() => buildServiceColorMap(spans), [spans])- // The inspector always shows something: the selected span, falling back to the root.- const inspectedSpan = selectedSpan ?? rootSpan+ const view = traceViewLogic({ id: viewId })+ const { spans: viewSpans, summary, selectedSpanId } = useValues(view)+ const { setSpans } = useActions(view)+ // The AI rows merge here rather than in a logic, so this hands the merged list to the view. Opening a+ // trace clears the view's spans, and comparing against them puts the list back even when it is unchanged.+ // A layout effect, so the cleared tree never paints.+ useLayoutEffect(() => {+ if (viewSpans !== spans) {+ setSpans(spans)+ }+ }, [spans, viewSpans, setSpans])// Gate mounting so a closed drawer holds no react-modal portal (and its listener surface).const shouldRender = useKeepMountedWhileOpen(isOpen)@@ -147,100 +123,63 @@ export function TraceDrawer({}return (- <LemonDrawer+ <TraceViewDrawer+ viewId={viewId}+ traceId={traceId}isOpen={isOpen}onClose={onClose}- width="90vw"- resizable- data-attr="tracing-trace-drawer"- title={- <div className="flex items-center gap-2 min-w-0">- <span className="truncate">{rootSpan?.name ?? 'Trace'}</span>- {rootSpan && <LemonTag>{formatDuration(rootSpan.duration_nano)}</LemonTag>}- <span className="font-mono text-xs text-muted truncate">{traceId}</span>- <LemonButton- size="xsmall"- icon={<IconLink />}- tooltip="Copy link to this trace"- data-attr="tracing-drawer-copy-link"- onClick={() =>- traceId &&- void copyToClipboard(- absoluteTraceUrl({ traceId, spanId: selectedSpanId, ts }),- 'trace link'- )- }- />- </div>+ inspectorOpen={inspectorOpen}+ onToggleInspector={onToggleInspector}+ isFullscreen={isFullscreen}+ onToggleFullscreen={onToggleFullscreen}+ shortcuts={<TraceViewShortcuts closeLabel="Close" />}+ headerActions={+ <LemonButton+ size="xsmall"+ icon={<IconLink />}+ tooltip="Copy link to this trace"+ data-attr="tracing-drawer-copy-link"+ onClick={() =>+ traceId &&+ void copyToClipboard(absoluteTraceUrl({ traceId, spanId: selectedSpanId, ts }), 'trace link')+ }+ />}+ data-attr={TRACE_DRAWER_DATA_ATTR}>- <TraceIdentityChips identity={identity} timestamp={rootSpan?.timestamp ?? ts} />- {/* A failed refetch only replaces the waterfall when there are no spans to fall back on. */}+ <TraceIdentityChips identity={identity} timestamp={summary.rootSpan?.timestamp ?? ts} />+ {/* A failed refetch only replaces the tree when there are no spans to fall back on. */}{traceId && !loading && anyLoadFailed && spans.length === 0 ? (<TraceLoadErrorNotice onRetry={canRetry ? retryFailedLoads : undefined} />) : traceId && !loading && !aiEventsResponseLoading && spans.length === 0 ? (<TraceUnavailableNotice traceId={traceId} filtersActive={filtersActive} surface="drawer" />) : (- <div className="relative min-h-32 flex gap-4 items-start">+ <div className="relative flex flex-col flex-1 min-h-0 gap-2">{(loading || (aiEventsResponseLoading && spans.length === 0)) && <SpinnerOverlay />}- <div className="flex-1 min-w-0">- {anyLoadFailed && (- <LemonBanner- type="warning"- className="mb-2"- action={canRetry ? { children: 'Try again', onClick: retryFailedLoads } : undefined}- data-attr="tracing-trace-load-error-banner"- >- Couldn't load the full trace. Showing the spans loaded so far.- </LemonBanner>- )}- <TraceAiEventsCapNotice aiEvents={aiEvents} hasMore={hasMoreAiEvents} limit={aiEventsLimit} />- {/* Keyed by trace so a new trace resets selection + scroll state. */}- <TraceWaterfallView- key={traceId ?? ''}- spans={spans}- selectedSpanId={selectedSpanId}- onSpanSelect={onSelectSpan}- hasMore={hasMoreSpans}- loadingMore={loadingMoreSpans}- onLoadMore={onLoadMoreSpans}- />- </div>- <div- ref={inspectorRef}- className={cn(- 'relative shrink-0 border-l border-border pl-4 max-w-[70%]',- inspectorWidth == null && 'w-2/5'- )}- // eslint-disable-next-line react/forbid-dom-props- style={- inspectorWidth != null- ? { width: Math.max(MIN_INSPECTOR_WIDTH, inspectorWidth) }- : undefined- }- data-attr="tracing-span-inspector"- >- <Resizer {...inspectorResizerProps} />- {missingParentSpanId ? (- <MissingParentSpanNotice traceId={traceId ?? ''} parentSpanId={missingParentSpanId} />- ) : inspectedSpan ? (- <SpanInspector- span={inspectedSpan}- serviceColorMap={serviceColorMap}- traceTimestamp={rootSpan?.timestamp ?? inspectedSpan.timestamp ?? ts}- sessionId={sessionId}- showErrorsTab={showErrorsTab}- errorsScope={errorsScope}- resolving={loading}- tab={inspectorTab}- onSelectTab={onSelectInspectorTab}- />- ) : (- <div className="text-muted p-4">No spans in this trace</div>- )}- </div>+ {anyLoadFailed && (+ <LemonBanner+ type="warning"+ action={canRetry ? { children: 'Try again', onClick: retryFailedLoads } : undefined}+ data-attr="tracing-trace-load-error-banner"+ >+ Couldn't load the full trace. Showing the spans loaded so far.+ </LemonBanner>+ )}+ <TraceAiEventsCapNotice aiEvents={aiEvents} hasMore={hasMoreAiEvents} limit={aiEventsLimit} />+ <TraceView+ traceId={traceId ?? ''}+ inspectorOpen={inspectorOpen}+ sessionId={sessionId}+ showErrorsTab={showErrorsTab}+ errorsScope={errorsScope}+ showFilterActions+ resolving={loading}+ hasMoreSpans={hasMoreSpans}+ loadingMoreSpans={loadingMoreSpans}+ onLoadMoreSpans={onLoadMoreSpans}+ /></div>)}- </LemonDrawer>+ </TraceViewDrawer>)}diff --git a/products/tracing/frontend/components/TraceView/TraceView.tsx b/products/tracing/frontend/components/TraceView/TraceView.tsxindex 2f9f5d2ce996..03a9d9900d22 100644--- a/products/tracing/frontend/components/TraceView/TraceView.tsx+++ b/products/tracing/frontend/components/TraceView/TraceView.tsx@@ -6,6 +6,7 @@ import { type ResizerLogicProps, resizerLogic } from 'lib/components/Resizer/resimport { SpanInspector } from 'products/tracing/frontend/components/SpanInspector/SpanInspector'import { MissingParentSpanNotice } from 'products/tracing/frontend/components/TraceDrawer/MissingParentSpanNotice'+import type { ErrorScope } from 'products/tracing/frontend/errorCorrelation'import type { TraceDialogSource } from '../TraceDialog/traceDialogLogic'import { TraceDialogSpanTree } from '../TraceDialog/TraceDialogSpanTree'@@ -21,6 +22,14 @@ export interface TraceViewProps {showErrorsTab: booleanopenedFrom?: TraceDialogSource | nullopenedAtUs?: number | null+ errorsScope?: ErrorScope | null+ /** The attribute filter buttons narrow a span list, so show them only where one sits behind the view. */+ showFilterActions?: boolean+ /** Spans are still loading, so the inspector holds off on what it reads from them. */+ resolving?: boolean+ hasMoreSpans?: boolean+ loadingMoreSpans?: boolean+ onLoadMoreSpans?: () => void}/** The span tree beside the inspector for the selected span. Mount it inside a `BindLogic` for `traceViewLogic`. */@@ -31,6 +40,12 @@ export function TraceView({showErrorsTab,openedFrom = null,openedAtUs = null,+ errorsScope = 'span',+ showFilterActions = false,+ resolving = false,+ hasMoreSpans,+ loadingMoreSpans,+ onLoadMoreSpans,}: TraceViewProps): JSX.Element {const inspectorRef = useRef<HTMLDivElement>(null)const inspectorResizerProps: ResizerLogicProps = {@@ -49,7 +64,13 @@ export function TraceView({<div className="@container/trace-dialog flex flex-1 min-h-0"><div className="flex flex-1 min-w-0 min-h-0 flex-col @min-[56rem]/trace-dialog:flex-row"><div className="flex-1 min-w-0 min-h-0">- <TraceDialogSpanTree openedFrom={openedFrom} openedAtUs={openedAtUs} />+ <TraceDialogSpanTree+ openedFrom={openedFrom}+ openedAtUs={openedAtUs}+ hasMore={hasMoreSpans}+ loadingMore={loadingMoreSpans}+ onLoadMore={onLoadMoreSpans}+ /></div>{inspectorOpen && (missingParentSpanId || selectedSpan) && (<div@@ -80,12 +101,11 @@ export function TraceView({traceTimestamp={summary.rootSpan?.timestamp ?? selectedSpan.timestamp}sessionId={sessionId}showErrorsTab={showErrorsTab}- errorsScope="span"- resolving={false}+ errorsScope={errorsScope}+ resolving={resolving}tab={activeInspectorTab}onSelectTab={setInspectorTab}- // There is no span list here for an attribute filter to narrow.- showFilterActions={false}+ showFilterActions={showFilterActions}/>) : null}</div>diff --git a/products/tracing/frontend/components/TraceView/TraceViewDrawer.tsx b/products/tracing/frontend/components/TraceView/TraceViewDrawer.tsxnew file mode 100644index 000000000000..488be04257ee--- /dev/null+++ b/products/tracing/frontend/components/TraceView/TraceViewDrawer.tsx@@ -0,0 +1,114 @@+import { BindLogic, useValues } from 'kea'+import { useCallback, useState } from 'react'++import { IconCollapse45, IconExpand45, IconSidebarClose, IconSidebarOpen } from '@posthog/icons'+import { LemonButton, LemonTag } from '@posthog/lemon-ui'++import { FloatingContainerContext } from 'lib/hooks/useFloatingContainerContext'+import { LemonDrawer } from 'lib/lemon-ui/LemonDrawer/LemonDrawer'+import { pluralize } from 'lib/utils/strings'++import { formatDuration } from 'products/tracing/frontend/TraceWaterfallView'++import { traceViewLogic } from './traceViewLogic'++export interface TraceViewDrawerProps {+ viewId: string+ traceId: string | null+ isOpen: boolean+ onClose: () => void+ inspectorOpen: boolean+ onToggleInspector: () => void+ isFullscreen: boolean+ onToggleFullscreen: () => void+ shortcuts: React.ReactNode+ headerActions?: React.ReactNode+ footerActions?: React.ReactNode+ /** Draw over other modals and popovers, for a drawer opened from inside one. */+ forceAbovePopovers?: boolean+ 'data-attr': string+ children: React.ReactNode+}++export function TraceViewDrawer({+ viewId,+ traceId,+ isOpen,+ onClose,+ inspectorOpen,+ onToggleInspector,+ isFullscreen,+ onToggleFullscreen,+ shortcuts,+ headerActions,+ footerActions,+ forceAbovePopovers = false,+ 'data-attr': dataAttr,+ children,+}: TraceViewDrawerProps): JSX.Element {+ const { summary, timeline } = useValues(traceViewLogic({ id: viewId }))+ // The drawer can sit above popovers, so the inspector's menus, and the person popover, portal inside it.+ const [floatingContainer, setFloatingContainer] = useState<HTMLDivElement | null>(null)+ const floatingContainerRef = useCallback((el: HTMLDivElement | null) => setFloatingContainer(el), [])++ return (+ <LemonDrawer+ isOpen={isOpen}+ onClose={onClose}+ width={isFullscreen ? '100vw' : '90vw'}+ resizable={!isFullscreen}+ resizerLogicKey="trace-view-drawer"+ forceAbovePopovers={forceAbovePopovers}+ data-attr={dataAttr}+ title={<span translate="no">{summary.rootSpan?.name ?? 'Trace'}</span>}+ description={+ <div className="flex flex-wrap items-center gap-2">+ <span className="font-mono text-xs" translate="no">+ {traceId}+ </span>+ {summary.spanCount > 0 && (+ <>+ <LemonTag>{formatDuration(timeline.durationUs * 1_000)}</LemonTag>+ <LemonTag>+ {pluralize(summary.spanCount, 'span')} · {pluralize(summary.serviceCount, 'service')}+ </LemonTag>+ {summary.errorCount > 0 && (+ <LemonTag type="danger">{pluralize(summary.errorCount, 'error')}</LemonTag>+ )}+ </>+ )}+ {headerActions}+ </div>+ }+ footer={+ <div className="flex flex-wrap items-center justify-between gap-2 w-full">+ {shortcuts}+ <div className="flex items-center gap-2">+ <LemonButton+ type="secondary"+ icon={inspectorOpen ? <IconSidebarClose /> : <IconSidebarOpen />}+ tooltip={inspectorOpen ? 'Hide span details' : 'Show span details'}+ onClick={onToggleInspector}+ data-attr={`${dataAttr}-toggle-inspector`}+ />+ <LemonButton+ type="secondary"+ icon={isFullscreen ? <IconCollapse45 /> : <IconExpand45 />}+ tooltip={isFullscreen ? 'Exit full screen' : 'Full screen'}+ onClick={onToggleFullscreen}+ data-attr={`${dataAttr}-toggle-fullscreen`}+ />+ {footerActions}+ </div>+ </div>+ }+ >+ <FloatingContainerContext.Provider value={floatingContainer}>+ <BindLogic logic={traceViewLogic} props={{ id: viewId }}>+ <div className="flex flex-col gap-2 h-full">{children}</div>+ </BindLogic>+ <div ref={floatingContainerRef} />+ </FloatingContainerContext.Provider>+ </LemonDrawer>+ )+}diff --git a/products/tracing/frontend/components/TraceDialog/TraceDialogShortcuts.tsx b/products/tracing/frontend/components/TraceView/TraceViewShortcuts.tsxsimilarity index 62%rename from products/tracing/frontend/components/TraceDialog/TraceDialogShortcuts.tsxrename to products/tracing/frontend/components/TraceView/TraceViewShortcuts.tsxindex 8949d5035be4..551fe4af280e 100644--- a/products/tracing/frontend/components/TraceDialog/TraceDialogShortcuts.tsx+++ b/products/tracing/frontend/components/TraceView/TraceViewShortcuts.tsx@@ -1,17 +1,17 @@-import { useValues } from 'kea'-import { KeyboardShortcut } from 'lib/components/KeyboardShortcut/KeyboardShortcut'-import { traceDialogLogic } from './traceDialogLogic'--export function TraceDialogShortcuts(): JSX.Element {- const { openedFrom } = useValues(traceDialogLogic)+export interface TraceViewShortcutsProps {+ /** What Escape does here, such as "Close" or "Back to log". */+ closeLabel: string+ children?: React.ReactNode+}+export function TraceViewShortcuts({ closeLabel, children }: TraceViewShortcutsProps): JSX.Element {return (<div className="flex flex-wrap items-center gap-x-4 gap-y-1 text-xs text-muted"><span className="flex items-center gap-1"><KeyboardShortcut escape />- <span>{openedFrom ? 'Back to log' : 'Close'}</span>+ <span>{closeLabel}</span></span><span className="flex items-center gap-1"><KeyboardShortcut j />@@ -23,10 +23,7 @@ export function TraceDialogShortcuts(): JSX.Element {<KeyboardShortcut arrowright /><span>Collapse or expand</span></span>- <span className="flex items-center gap-1">- <KeyboardShortcut command />- <span>Click Open in Tracing for a new tab</span>- </span>+ {children}</div>)}diff --git a/products/tracing/frontend/components/TraceView/traceViewLogic.ts b/products/tracing/frontend/components/TraceView/traceViewLogic.tsindex 47370eb5af51..aff640684575 100644--- a/products/tracing/frontend/components/TraceView/traceViewLogic.ts+++ b/products/tracing/frontend/components/TraceView/traceViewLogic.ts@@ -24,6 +24,10 @@ import {type TraceDialogRow,} from '../TraceDialog/traceDialogRows'+// Views with span keys enabled, in the order they enabled them. Each listens on window, so+// only the last one acts on a key.+const spanKeyOwners: symbol[] = []+export interface TraceViewLogicProps {id: string}@@ -77,6 +81,12 @@ export interface traceViewLogicActions {collapseSelectedSpan: () => {value: true}+ disableSpanKeys: () => {+ value: true+ }+ enableSpanKeys: (containerSelector: string) => {+ containerSelector: string+ }expandSelectedSpan: () => {value: true}@@ -89,8 +99,8 @@ export interface traceViewLogicActions {selectPreviousSpan: () => {value: true}- selectSpan: (spanId: string) => {- spanId: string+ selectSpan: (spanId: string | null) => {+ spanId: string | null}setInspectorTab: (tab: SpanInspectorTab) => {tab: SpanInspectorTab@@ -101,8 +111,12 @@ export interface traceViewLogicActions {showAllChildren: (spanId: string) => {spanId: string}- showTrace: (pinnedSpanId: string | null) => {+ showTrace: (+ pinnedSpanId: string | null,+ tab: SpanInspectorTab | null+ ) => {pinnedSpanId: string | null+ tab: SpanInspectorTab | null}spanStepped: () => {value: true@@ -161,9 +175,9 @@ export const traceViewLogic: LogicWrapper<traceViewLogicType> = kea<traceViewLogvalues: [tracingCorrelationConfigLogic, ['sessionErrorBadgesEnabled']],})),actions({- showTrace: (pinnedSpanId: string | null) => ({ pinnedSpanId }),+ showTrace: (pinnedSpanId: string | null, tab: SpanInspectorTab | null) => ({ pinnedSpanId, tab }),setSpans: (spans: Span[]) => ({ spans }),- selectSpan: (spanId: string) => ({ spanId }),+ selectSpan: (spanId: string | null) => ({ spanId }),selectNextSpan: true,selectPreviousSpan: true,collapseSelectedSpan: true,@@ -174,6 +188,8 @@ export const traceViewLogic: LogicWrapper<traceViewLogicType> = kea<traceViewLogtoggleChain: (spanId: string) => ({ spanId }),keepSelectionOnScreen: true,setInspectorTab: (tab: SpanInspectorTab) => ({ tab }),+ enableSpanKeys: (containerSelector: string) => ({ containerSelector }),+ disableSpanKeys: true,}),reducers({spans: [@@ -236,7 +252,7 @@ export const traceViewLogic: LogicWrapper<traceViewLogicType> = kea<traceViewLogchosenInspectorTab: [null as SpanInspectorTab | null,{- showTrace: () => null,+ showTrace: (_, { tab }) => tab,setInspectorTab: (_, { tab }) => tab,},],@@ -344,7 +360,54 @@ export const traceViewLogic: LogicWrapper<traceViewLogicType> = kea<traceViewLog}),],}),- listeners(({ values, actions }) => ({+ listeners(({ values, actions, cache }) => ({+ enableSpanKeys: ({ containerSelector }) => {+ // Capture phase, and stopped there, so the page under the view does not also act on+ // the key: with log details open, the logs list binds J and K to its own cursor.+ cache.disposables.add(() => {+ const owner = Symbol('spanKeys')+ spanKeyOwners.push(owner)+ const onKeyDown = (event: KeyboardEvent): void => {+ const target = event.target as HTMLElement | null+ // A field behind the view can still hold focus, such as one that autofocused+ // while the trace loaded. The person cannot see it, so the key is theirs to step with.+ const typing =+ !!target?.closest(containerSelector) &&+ (['input', 'textarea', 'select'].includes(target.tagName.toLowerCase()) ||+ target.isContentEditable)+ // Only the most recently opened view steps, so a drawer opened over another+ // does not move the selection underneath it too.+ if (spanKeyOwners[spanKeyOwners.length - 1] !== owner) {+ return+ }+ if (typing || event.isComposing || event.metaKey || event.ctrlKey || event.altKey) {+ return+ }+ const step = {+ j: actions.selectNextSpan,+ k: actions.selectPreviousSpan,+ arrowleft: actions.collapseSelectedSpan,+ arrowright: actions.expandSelectedSpan,+ }[event.key.toLowerCase()]+ if (step) {+ event.preventDefault()+ event.stopPropagation()+ step()+ }+ }+ window.addEventListener('keydown', onKeyDown, { capture: true })+ return () => {+ window.removeEventListener('keydown', onKeyDown, { capture: true })+ const index = spanKeyOwners.indexOf(owner)+ if (index >= 0) {+ spanKeyOwners.splice(index, 1)+ }+ }+ }, 'spanKeys')+ },+ disableSpanKeys: () => {+ cache.disposables.dispose('spanKeys')+ },selectNextSpan: () => {actions.spanStepped()// A missing-parent row is selectable too, so step from it rather than from the root fallback.diff --git a/products/tracing/frontend/tracingSceneLogic.ts b/products/tracing/frontend/tracingSceneLogic.tsindex 7eae0c8ad6fc..0fba9ee6520e 100644--- a/products/tracing/frontend/tracingSceneLogic.ts+++ b/products/tracing/frontend/tracingSceneLogic.ts@@ -116,7 +116,9 @@ export interface tracingSceneLogicValues {compareFlameServiceName: string | null // tracingViewerLogiccompareFlameSpanName: string | null // tracingViewerLogicerrorsScope: ErrorScope | null // tracingViewerLogic+ inspectorOpen: boolean // tracingViewerLogicinspectorTab: SpanInspectorTab // tracingViewerLogic+ isFullscreen: boolean // tracingViewerLogicisLoadingFullTrace: boolean // tracingViewerLogicisTraceOpen: boolean // tracingViewerLogicopenTraceSpans: Span[] // tracingViewerLogic@@ -270,6 +272,12 @@ export interface tracingSceneLogicActions {selectSpan: (spanId: string | null) => {spanId: string | null} // tracingViewerLogic+ toggleFullscreen: () => {+ value: true+ } // tracingViewerLogic+ toggleInspector: () => {+ value: true+ } // tracingViewerLogickeepSqlEditorMounted: (editorTabId: string) => {editorTabId: string}@@ -369,6 +377,8 @@ export const tracingSceneLogic = kea<tracingSceneLogicType>(['errorsScope','isLoadingFullTrace','canLoadMoreTraceSpans',+ 'inspectorOpen',+ 'isFullscreen','compareFlameSpanName','compareFlameServiceName','selectedTraceLoadFailed',@@ -402,7 +412,16 @@ export const tracingSceneLogic = kea<tracingSceneLogicType>(['setFilters',],tracingViewerLogic({ id: TRACING_SCENE_VIEWER_ID }),- ['openTrace', 'selectSpan', 'selectInspectorTab', 'closeTrace', 'openCompareFlame', 'closeCompareFlame'],+ [+ 'openTrace',+ 'selectSpan',+ 'selectInspectorTab',+ 'closeTrace',+ 'toggleInspector',+ 'toggleFullscreen',+ 'openCompareFlame',+ 'closeCompareFlame',+ ],featureFlagLogic,['setFeatureFlags'],],diff --git a/products/tracing/frontend/tracingViewerLogic.test.ts b/products/tracing/frontend/tracingViewerLogic.test.tsindex 3bd2bc6fa28a..9eb76a38e422 100644--- a/products/tracing/frontend/tracingViewerLogic.test.ts+++ b/products/tracing/frontend/tracingViewerLogic.test.ts@@ -7,10 +7,13 @@ import { featureFlagLogic } from 'lib/logic/featureFlagLogic'import { initKeaTests } from '~/test/init'import { AccessControlLevel, AccessControlResourceType, AppContext } from '~/types'+import { logsViewerModalLogic } from 'products/logs/frontend/components/LogsViewer/LogsViewerModal/logsViewerModalLogic'+import { makeSpan } from './__mocks__/span'+import { traceViewLogic } from './components/TraceView/traceViewLogic'import { PREFETCH_SPANS, tracingDataLogic } from './tracingDataLogic'import { tracingFiltersLogic } from './tracingFiltersLogic'-import { tracingViewerLogic } from './tracingViewerLogic'+import { traceViewId, tracingViewerLogic } from './tracingViewerLogic'describe('tracingViewerLogic', () => {let logic: ReturnType<typeof tracingViewerLogic.build>@@ -222,17 +225,105 @@ describe('tracingViewerLogic', () => {// The drawer stays mounted from one row to the next, so a person reading the Logs tab row by// row must not be bounced back to Attributes on every click.it('keeps the inspector tab across traces while the drawer is open, and resets it on close', () => {+ const view = traceViewLogic({ id: traceViewId('default') })logic.actions.openTrace('trace-x')- logic.actions.selectInspectorTab('logs')+ expect(view.values.activeInspectorTab).toBe('attributes')+ view.actions.setInspectorTab('logs')logic.actions.openTrace('trace-y')- expect(logic.values.inspectorTab).toBe('logs')+ expect(view.values.activeInspectorTab).toBe('logs')logic.actions.openTrace('trace-z', { tab: 'errors' })- expect(logic.values.inspectorTab).toBe('errors')+ expect(view.values.activeInspectorTab).toBe('errors')logic.actions.closeTrace()- expect(logic.values.inspectorTab).toBe('attributes')+ logic.actions.openTrace('trace-x')+ expect(view.values.activeInspectorTab).toBe('attributes')+ })++ // The URL carries the selected span, so a click in the tree and a span from the URL must each reach the other.+ it('keeps the selected span in step between the URL and the span tree', () => {+ const view = traceViewLogic({ id: traceViewId('default') })+ logic.actions.openTrace('trace-x', { spanId: 'aa01' })+ expect(view.values.selectedSpanId).toBe('AA01')++ view.actions.selectSpan('BB02')+ expect(logic.values.selectedSpanId).toBe('BB02')++ logic.actions.selectSpan('cc03')+ expect(view.values.selectedSpanId).toBe('CC03')++ logic.actions.selectSpan(null)+ expect(view.values.selectedSpanId).toBeNull()+ })++ it('steps through spans with J only while the drawer is open', () => {+ const view = traceViewLogic({ id: traceViewId('default') })+ const press = (): void => {+ document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'j', bubbles: true }))+ }+ logic.actions.openTrace('trace-x', { spanId: 'aa01' })+ view.actions.setSpans([+ makeSpan({ uuid: 'AA01', span_id: 'AA01', trace_id: 'trace-x' }),+ makeSpan({ uuid: 'BB02', span_id: 'BB02', trace_id: 'trace-x' }),+ ])++ press()+ expect(logic.values.selectedSpanId).toBe('BB02')++ logic.actions.closeTrace()+ view.actions.selectSpan('AA01')+ press()+ expect(view.values.selectedSpanId).toBe('AA01')+ })++ it('leaves J to the full-screen logs viewer while it is open over the drawer', () => {+ const view = traceViewLogic({ id: traceViewId('default') })+ const press = (): void => {+ document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'j', bubbles: true }))+ }+ logic.actions.openTrace('trace-x', { spanId: 'aa01' })+ view.actions.setSpans([+ makeSpan({ uuid: 'AA01', span_id: 'AA01', trace_id: 'trace-x' }),+ makeSpan({ uuid: 'BB02', span_id: 'BB02', trace_id: 'trace-x' }),+ ])++ logsViewerModalLogic.actions.openLogsViewerModal()+ press()+ expect(view.values.selectedSpanId).toBe('AA01')++ logsViewerModalLogic.actions.closeLogsViewerModal()+ press()+ expect(view.values.selectedSpanId).toBe('BB02')+ })++ it('steps only the most recently opened view when two have span keys', () => {+ const view = traceViewLogic({ id: traceViewId('default') })+ const overlay = traceViewLogic({ id: 'overlay' })+ overlay.mount()+ const press = (): void => {+ document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'j', bubbles: true }))+ }+ logic.actions.openTrace('trace-x', { spanId: 'aa01' })+ view.actions.setSpans([+ makeSpan({ uuid: 'AA01', span_id: 'AA01', trace_id: 'trace-x' }),+ makeSpan({ uuid: 'BB02', span_id: 'BB02', trace_id: 'trace-x' }),+ ])+ overlay.actions.showTrace('CC01', null)+ overlay.actions.setSpans([+ makeSpan({ uuid: 'CC01', span_id: 'CC01', trace_id: 'trace-y' }),+ makeSpan({ uuid: 'DD02', span_id: 'DD02', trace_id: 'trace-y' }),+ ])+ overlay.actions.enableSpanKeys('[data-attr="overlay"]')++ press()+ expect(overlay.values.selectedSpanId).toBe('DD02')+ expect(view.values.selectedSpanId).toBe('AA01')++ overlay.actions.disableSpanKeys()+ press()+ expect(view.values.selectedSpanId).toBe('BB02')+ overlay.unmount()})describe('closeTrace', () => {diff --git a/products/tracing/frontend/tracingViewerLogic.ts b/products/tracing/frontend/tracingViewerLogic.tsindex 9a145107944b..0ad4a07c42c1 100644--- a/products/tracing/frontend/tracingViewerLogic.ts+++ b/products/tracing/frontend/tracingViewerLogic.ts@@ -2,7 +2,11 @@ import { MakeLogicType, actions, connect, kea, key, listeners, path, props, reduimport posthog from 'posthog-js'import { inApiCase } from 'lib/components/ViewTraceButton/traceUrl'+import { sessionPlayerModalLogic } from 'scenes/session-recordings/player/modal/sessionPlayerModalLogic'+import { logsViewerModalLogic } from 'products/logs/frontend/components/LogsViewer/LogsViewerModal/logsViewerModalLogic'++import { traceViewLogic } from './components/TraceView/traceViewLogic'import type { ErrorScope } from './errorCorrelation'import {EMPTY_TRACE_IDENTITY,@@ -21,6 +25,13 @@ export interface TracingViewerLogicProps {id: string}+// Pinned: autocapture and the span keys both match on the drawer's data-attr.+export const TRACE_DRAWER_DATA_ATTR = 'tracing-trace-drawer'++export function traceViewId(viewerId: string): string {+ return `tracing-viewer-${viewerId}`+}+// Mirrors the prefetch check in the `openTrace` listener: a batch with the trace's root span,// under the cap, is already the trace's complete span set, so a fetch for it would be skipped.// Also used by `selectedTraceLoadFailed` to tell a stale failure (from an earlier, differently@@ -37,7 +48,10 @@ export interface tracingViewerLogicValues {correlationLinksEnabled: boolean // tracingCorrelationConfigLogicsessionErrorBadgesEnabled: boolean // tracingCorrelationConfigLogicspans: Span[] // tracingDataLogic- traceLoadContext: { traceId: string; ts?: string | null } | null // tracingDataLogic+ traceLoadContext: {+ traceId: string+ ts?: string | null+ } | null // tracingDataLogictraceSpans: Span[] // tracingDataLogictraceSpansHasMore: boolean // tracingDataLogictraceSpansLoadFailed: boolean // tracingDataLogic@@ -48,7 +62,9 @@ export interface tracingViewerLogicValues {compareFlameServiceName: string | nullcompareFlameSpanName: string | nullerrorsScope: ErrorScope | null+ inspectorOpen: booleaninspectorTab: SpanInspectorTab+ isFullscreen: booleanisLoadingFullTrace: booleanisTraceOpen: booleanopenTraceSpans: Span[]@@ -62,6 +78,56 @@ export interface tracingViewerLogicValues {// Generated by kea-typegen. Update if you're an agent, ignore if you're human.export interface tracingViewerLogicActions {+ closeLogsViewerModal: () => {+ value: true+ } // logsViewerModalLogic+ openLogsViewerModal: (+ options?:+ | import('products/logs/frontend/components/LogsViewer/LogsViewerModal/logsViewerModalLogic').OpenLogsViewerModalOptions+ | undefined+ ) => {+ fullScreen: boolean+ id: string+ initialFilters: Partial<+ import('products/logs/frontend/components/LogsViewer/config/types').LogsViewerFilters+ > | null+ personId: string | null+ pinnedFilters: null | import('~/types').UniversalFiltersGroup+ sessionId: string | null+ } // logsViewerModalLogic+ closeSessionPlayer: () => {+ value: true+ } // sessionPlayerModalLogic+ openSessionPlayer: (+ sessionRecording: Pick<import('~/types').SessionRecordingType, 'id' | 'matching_events'>,+ initialTimestamp?: number | null | undefined,+ modalContext?:+ | import('scenes/session-recordings/player/modal/sessionPlayerModalLogic').SessionPlayerModalContext+ | undefined+ ) => {+ initialTimestamp: number | null+ modalContext: import('scenes/session-recordings/player/modal/sessionPlayerModalLogic').SessionPlayerModalContext+ sessionRecording: Pick<import('~/types').SessionRecordingType, 'id' | 'matching_events'>+ } // sessionPlayerModalLogic+ disableSpanKeys: () => {+ value: true+ } // traceViewLogic+ enableSpanKeys: (containerSelector: string) => {+ containerSelector: string+ } // traceViewLogic+ selectViewSpan: (spanId: string | null) => {+ spanId: string | null+ } // traceViewLogic+ setInspectorTab: (tab: SpanInspectorTab) => {+ tab: SpanInspectorTab+ } // traceViewLogic+ showTrace: (+ pinnedSpanId: string | null,+ tab: SpanInspectorTab | null+ ) => {+ pinnedSpanId: string | null+ tab: SpanInspectorTab | null+ } // traceViewLogicfetchAggregation: (options?:| {@@ -124,6 +190,12 @@ export interface tracingViewerLogicActions {selectSpan: (spanId: string | null) => {spanId: string | null}+ toggleFullscreen: () => {+ value: true+ }+ toggleInspector: () => {+ value: true+ }}// Generated by kea-typegen. Update if you're an agent, ignore if you're human.@@ -140,7 +212,10 @@ export interface tracingViewerLogicMeta {) => booleanselectedTraceLoadFailed: (traceSpansLoadFailed: boolean,- traceLoadContext: { traceId: string; ts?: string | null } | null,+ traceLoadContext: {+ traceId: string+ ts?: string | null+ } | null,selectedTraceId: string | null,spans: Span[]) => boolean@@ -204,6 +279,12 @@ export const tracingViewerLogic = kea<tracingViewerLogicType>([['loadTraceSpans', 'fetchSpanTree', 'fetchAggregation'],tracingFiltersLogic({ id }),['updateComparisonWindows', 'refreshDeferredFilters'],+ traceViewLogic({ id: traceViewId(id) }),+ ['showTrace', 'selectSpan as selectViewSpan', 'setInspectorTab', 'enableSpanKeys', 'disableSpanKeys'],+ logsViewerModalLogic,+ ['openLogsViewerModal', 'closeLogsViewerModal'],+ sessionPlayerModalLogic,+ ['openSessionPlayer', 'closeSessionPlayer'],],})),@@ -226,6 +307,8 @@ export const tracingViewerLogic = kea<tracingViewerLogicType>([selectInspectorTab: (tab: SpanInspectorTab) => ({ tab }),selectSpan: (spanId: string | null) => ({ spanId: spanId ? inApiCase(spanId) : null }),closeTrace: true,+ toggleInspector: true,+ toggleFullscreen: true,openCompareFlame: (spanName: string, serviceName: string) => ({ spanName, serviceName }),closeCompareFlame: true,}),@@ -275,6 +358,21 @@ export const tracingViewerLogic = kea<tracingViewerLogicType>([openTrace: (state, { tab }) => tab ?? state,closeTrace: () => 'attributes',selectInspectorTab: (_, { tab }) => tab,+ setInspectorTab: (_, { tab }) => tab,+ },+ ],+ inspectorOpen: [+ true,+ { persist: true },+ {+ toggleInspector: (open) => !open,+ },+ ],+ isFullscreen: [+ false,+ { persist: true },+ {+ toggleFullscreen: (fullscreen) => !fullscreen,},],compareFlameSpanName: [@@ -417,15 +515,18 @@ export const tracingViewerLogic = kea<tracingViewerLogicType>([],}),- listeners(({ actions, values }) => ({+ listeners(({ actions, values, props }) => ({closeTrace: () => {+ actions.disableSpanKeys()// The attribute buttons in the drawer defer their query so the list doesn't reload// behind it — run it now that the drawer is closing.if (values.hasDeferredFilterRefresh) {actions.refreshDeferredFilters()}},- openTrace: ({ traceId, ts }) => {+ openTrace: ({ traceId, ts, spanId }) => {+ actions.showTrace(spanId, values.inspectorTab)+ actions.enableSpanKeys(`[data-attr="${TRACE_DRAWER_DATA_ATTR}"]`)posthog.capture('tracing trace opened')// Fetch the trace by id when the prefetch can be incomplete. A batch with no root span is a// cold link (no spans loaded) or an orphan trace, whose prefetch holds only the spans that@@ -434,6 +535,37 @@ export const tracingViewerLogic = kea<tracingViewerLogicType>([actions.loadTraceSpans({ traceId, ts })}},+ // The URL and the span tree each select spans, so each side passes on only a real change.+ selectSpan: ({ spanId }) => {+ if (spanId !== traceViewLogic({ id: traceViewId(props.id) }).values.selectedSpanId) {+ actions.selectViewSpan(spanId)+ }+ },+ selectViewSpan: ({ spanId }) => {+ if (spanId !== values.selectedSpanId) {+ actions.selectSpan(spanId)+ }+ },+ // These modals open over the drawer, so its keys must not step spans while one has focus.+ openLogsViewerModal: () => {+ actions.disableSpanKeys()+ },+ openSessionPlayer: () => {+ actions.disableSpanKeys()+ },+ closeLogsViewerModal: () => {+ if (values.isTraceOpen) {+ actions.enableSpanKeys(`[data-attr="${TRACE_DRAWER_DATA_ATTR}"]`)+ }+ },+ closeSessionPlayer: () => {+ if (values.isTraceOpen) {+ actions.enableSpanKeys(`[data-attr="${TRACE_DRAWER_DATA_ATTR}"]`)+ }+ },+ selectInspectorTab: ({ tab }) => {+ actions.setInspectorTab(tab)+ },openCompareFlame: ({ spanName, serviceName }) => {actions.fetchSpanTree({ spanName, serviceName })},