From 8c7bfb6b959362d887cfa3f17caf0b1a3d35b194 Mon Sep 17 00:00:00 2001 From: Kev Date: Mon, 3 Mar 2025 17:19:18 -0500 Subject: [PATCH 1/4] feat(ourlogs): Show all log details when expanding a row This adds the EventsTagTree like behaviour that queries and shows all log details when opening a row. --- .../views/explore/contexts/logs/fields.tsx | 2 + .../explore/contexts/logs/logsPageParams.tsx | 10 + .../app/views/explore/logs/fieldRenderers.tsx | 131 +++- .../app/views/explore/logs/logFieldsTree.tsx | 639 ++++++++++++++++++ static/app/views/explore/logs/logsTable.tsx | 143 ++-- static/app/views/explore/logs/styles.tsx | 31 +- static/app/views/explore/logs/types.tsx | 11 +- .../app/views/explore/logs/useLogsQuery.tsx | 131 +++- 8 files changed, 1011 insertions(+), 87 deletions(-) create mode 100644 static/app/views/explore/logs/logFieldsTree.tsx diff --git a/static/app/views/explore/contexts/logs/fields.tsx b/static/app/views/explore/contexts/logs/fields.tsx index 00c709213e6d..9f2cb77b0003 100644 --- a/static/app/views/explore/contexts/logs/fields.tsx +++ b/static/app/views/explore/contexts/logs/fields.tsx @@ -5,6 +5,8 @@ import {type OurLogFieldKey, OurLogKnownFieldKey} from 'sentry/views/explore/log function defaultLogFields(): OurLogKnownFieldKey[] { return [ + OurLogKnownFieldKey.ID, + OurLogKnownFieldKey.PROJECT_ID, OurLogKnownFieldKey.SEVERITY_TEXT, OurLogKnownFieldKey.SEVERITY_NUMBER, OurLogKnownFieldKey.BODY, diff --git a/static/app/views/explore/contexts/logs/logsPageParams.tsx b/static/app/views/explore/contexts/logs/logsPageParams.tsx index 2050b9dda7e4..5f0c2a5a70d9 100644 --- a/static/app/views/explore/contexts/logs/logsPageParams.tsx +++ b/static/app/views/explore/contexts/logs/logsPageParams.tsx @@ -109,6 +109,16 @@ export function useSetLogsQuery() { ); } +export function useSetLogsSearch() { + const setPageParams = useSetLogsPageParams(); + return useCallback( + (search: MutableSearch) => { + setPageParams({search}); + }, + [setPageParams] + ); +} + export function useLogsSortBys() { const {sortBys} = useLogsPageParams(); return sortBys; diff --git a/static/app/views/explore/logs/fieldRenderers.tsx b/static/app/views/explore/logs/fieldRenderers.tsx index 031713361ea2..b022434597a0 100644 --- a/static/app/views/explore/logs/fieldRenderers.tsx +++ b/static/app/views/explore/logs/fieldRenderers.tsx @@ -1,5 +1,8 @@ +import {Fragment} from 'react'; + import {DateTime} from 'sentry/components/dateTime'; import {Tooltip} from 'sentry/components/tooltip'; +import {t} from 'sentry/locale'; import { ColoredLogCircle, ColoredLogText, @@ -8,51 +11,131 @@ import { LogsHighlight, WrappingText, } from 'sentry/views/explore/logs/styles'; +import { + type OurLogFieldKey, + OurLogKnownFieldKey, + type OurLogsResponseItem, +} from 'sentry/views/explore/logs/types'; import { getLogSeverityLevel, SeverityLevel, severityLevelToText, } from 'sentry/views/explore/logs/utils'; -export function severityCircleRenderer( - severityNumber: number, - severityText: string, - logColors: ReturnType -) { - const level = getLogSeverityLevel(severityNumber, severityText); - const levelLabel = severityLevelToText(level); +interface FieldRendererProps { + attribute_value: any; + extra: RendererExtra; + tableResultLogRow?: OurLogsResponseItem; +} + +export interface RendererExtra { + highlightTerms: string[]; + logColors: ReturnType; + renderSeverityCircle?: boolean; + useFullSeverityText?: boolean; + wrapBody?: boolean; +} + +function SeverityCircle(props: { + level: SeverityLevel; + levelLabel: string; + logColors: ReturnType; + severityText: string; +}) { return ( - - {severityText} + + + {props.severityText} + ); } -export function severityTextRenderer( - severityNumber: number, - severityText: string, - logColors: ReturnType, - useFullSeverityText = false -) { - const level = getLogSeverityLevel(severityNumber, severityText); - const levelLabel = useFullSeverityText ? level : severityLevelToText(level); - return [{levelLabel}]; +export function severityTextRenderer(props: FieldRendererProps) { + const attribute_value = props.attribute_value as string; + const _severityNumber = props.tableResultLogRow?.[OurLogKnownFieldKey.SEVERITY_NUMBER]; + const severityNumber = _severityNumber ? Number(_severityNumber) : null; + const useFullSeverityText = props.extra.useFullSeverityText ?? false; + const level = getLogSeverityLevel(severityNumber, attribute_value); + const levelLabel = useFullSeverityText ? attribute_value : severityLevelToText(level); + const renderSeverityCircle = props.extra.renderSeverityCircle ?? false; + return ( + + {renderSeverityCircle && ( + + )} + + [{levelLabel}] + + ); } -export function TimestampRenderer({timestamp}: {timestamp: string}) { +export function TimestampRenderer(props: FieldRendererProps) { return ( - + ); } -export function bodyRenderer(body: string, highlightTerms: string[], wrap = false) { - const highlightTerm = highlightTerms[0] ?? ''; +export function bodyRenderer(props: FieldRendererProps) { + const attribute_value = props.attribute_value as string; + const highlightTerm = props.extra.highlightTerms[0] ?? ''; // TODO: Allow more than one highlight term to be highlighted at once. return ( - - {body} + + {attribute_value} ); } + +function wrappedSeverityTextRenderer(props: { + attribute_value: any; + extra?: RendererExtra; +}) { + const extra = props.extra || { + highlightTerms: [], + logColors: {} as ReturnType, + }; + return severityTextRenderer({...props, extra}); +} + +export const LogAttributesRendererMap: Record< + OurLogFieldKey, + (props: {attribute_value: any; extra?: RendererExtra}) => React.ReactNode +> = { + [OurLogKnownFieldKey.TIMESTAMP]: props => { + // Ensure extra is defined for the wrapped function + const extra = props.extra || { + highlightTerms: [], + logColors: {} as ReturnType, + }; + return TimestampRenderer({...props, extra}); + }, + [OurLogKnownFieldKey.SEVERITY_TEXT]: wrappedSeverityTextRenderer, + [OurLogKnownFieldKey.SENTRY_SEVERITY_TEXT]: wrappedSeverityTextRenderer, +}; + +export const LogAttributesHumanLabel: Record = { + [OurLogKnownFieldKey.TIMESTAMP]: t('Timestamp'), + [OurLogKnownFieldKey.SEVERITY_TEXT]: t('Severity'), +}; + +export const HiddenLogAttributes: OurLogFieldKey[] = [ + OurLogKnownFieldKey.SEVERITY_NUMBER, + OurLogKnownFieldKey.ID, + OurLogKnownFieldKey.BODY, + OurLogKnownFieldKey.PROJECT_ID, + OurLogKnownFieldKey.SENTRY_ORGANIZATION_ID, + OurLogKnownFieldKey.SENTRY_PROJECT_ID, + OurLogKnownFieldKey.SENTRY_ITEM_TYPE, +]; diff --git a/static/app/views/explore/logs/logFieldsTree.tsx b/static/app/views/explore/logs/logFieldsTree.tsx new file mode 100644 index 000000000000..7f7bd935cb30 --- /dev/null +++ b/static/app/views/explore/logs/logFieldsTree.tsx @@ -0,0 +1,639 @@ +import {Fragment, useCallback, useMemo, useRef, useState} from 'react'; +import styled from '@emotion/styled'; + +import {openNavigateToExternalLinkModal} from 'sentry/actionCreators/modal'; +import {DropdownMenu, type MenuItemProps} from 'sentry/components/dropdownMenu'; +import {useIssueDetailsColumnCount} from 'sentry/components/events/eventTags/util'; +import ExternalLink from 'sentry/components/links/externalLink'; +import {IconEllipsis} from 'sentry/icons'; +import {t} from 'sentry/locale'; +import {space} from 'sentry/styles/space'; +import {defined} from 'sentry/utils'; +import {isEmptyObject} from 'sentry/utils/object/isEmptyObject'; +import {isUrl} from 'sentry/utils/string/isUrl'; +import useCopyToClipboard from 'sentry/utils/useCopyToClipboard'; +import { + useLogsSearch, + useSetLogsSearch, +} from 'sentry/views/explore/contexts/logs/logsPageParams'; +import type {RendererExtra} from 'sentry/views/explore/logs/fieldRenderers'; +import type {OurLogFieldKey} from 'sentry/views/explore/logs/types'; +import type {OurLogsTableRowDetails} from 'sentry/views/explore/logs/useLogsQuery'; + +const MAX_TREE_DEPTH = 4; +const INVALID_BRANCH_REGEX = /\.{2,}/; + +interface Attribute { + attribute_key: string; + attribute_value: string | number | null; + original_attribute_key: string; +} + +interface AttributeTree { + [key: string]: AttributeTreeContent; +} + +interface AttributeTreeContent { + subtree: AttributeTree; + value: string | number | null; + // These will be omitted on pseudo attributes (see addToAttributeTree) + meta?: Record; + originalAttribute?: Attribute; +} + +interface AttributeTreeColumnData { + columns: React.ReactNode[]; + runningTotal: number; + startIndex: number; +} + +interface LogFieldsTreeProps { + attributes: OurLogsTableRowDetails['attributes']; + hiddenAttributes?: OurLogFieldKey[]; + renderExtra?: RendererExtra; + renderers?: Record< + string, + (props: {attribute_value: any; extra?: RendererExtra}) => React.ReactNode + >; +} + +interface LogFieldsTreeColumnsProps { + attributes: OurLogsTableRowDetails['attributes']; + columnCount: number; + hiddenAttributes?: OurLogFieldKey[]; + renderExtra?: RendererExtra; + renderers?: Record< + string, + (props: {attribute_value: any; extra?: RendererExtra}) => React.ReactNode + >; +} + +interface LogFieldsTreeRowConfig { + // Omits the dropdown of actions applicable to this attribute + disableActions?: boolean; + // Omit error styling from being displayed, even if context is invalid + disableErrors?: boolean; + // Displays attribute value as plain text, rather than a hyperlink if applicable + disableRichValue?: boolean; +} + +interface LogFieldsTreeRowProps { + attributeKey: string; + content: AttributeTreeContent; + config?: LogFieldsTreeRowConfig; + isLast?: boolean; + spacerCount?: number; +} + +function addToAttributeTree( + tree: AttributeTree, + attribute: Attribute, + meta: Record, + originalAttribute: Attribute +): AttributeTree { + const BRANCH_MATCHES_REGEX = /\./g; + if (!defined(attribute.attribute_key)) { + return tree; + } + + const branchMatches = attribute.attribute_key.match(BRANCH_MATCHES_REGEX) ?? []; + + const hasInvalidBranchCount = + branchMatches.length <= 0 || branchMatches.length > MAX_TREE_DEPTH; + const hasInvalidBranchSequence = INVALID_BRANCH_REGEX.test(attribute.attribute_key); + + // Ignore attributes with 0, or >4 branches, as well as sequential dots (e.g. 'some..attribute') + if (hasInvalidBranchCount || hasInvalidBranchSequence) { + tree[attribute.attribute_key] = { + value: attribute.attribute_value, + subtree: {}, + meta, + originalAttribute, + }; + return tree; + } + // E.g. 'device.model.version' + const splitIndex = attribute.attribute_key.indexOf('.'); // 6 + const trunk = attribute.attribute_key.slice(0, splitIndex); // 'device' + const branch = attribute.attribute_key.slice(splitIndex + 1); // 'model.version' + + if (tree[trunk] === undefined) { + tree[trunk] = {value: '', subtree: {}}; + } + // Recurse with a pseudo attribute, e.g. 'model', to create nesting structure + const pseudoAttribute = { + attribute_key: branch, + attribute_value: attribute.attribute_value, + original_attribute_key: attribute.original_attribute_key, + }; + tree[trunk].subtree = addToAttributeTree( + tree[trunk].subtree, + pseudoAttribute, + meta, + originalAttribute + ); + return tree; +} + +/** + * Function to recursively create a flat list of all rows to be rendered for a given AttributeTree + * @param props The props for rendering the root of the AttributeTree + * @returns A list of LogFieldsTreeRow components to be rendered in this tree + */ +function getAttributeTreeRows({ + attributeKey, + content, + spacerCount = 0, + uniqueKey, + renderers = {}, + renderExtra, + isLast = false, +}: LogFieldsTreeRowProps & { + uniqueKey: string; + renderExtra?: RendererExtra; + renderers?: Record< + string, + (props: {attribute_value: any; extra?: RendererExtra}) => React.ReactNode + >; +}): React.ReactNode[] { + const subtreeAttributes = Object.keys(content.subtree); + const subtreeRows = subtreeAttributes.reduce( + (rows: React.ReactNode[], attribute, i) => { + const branchRows = getAttributeTreeRows({ + attributeKey: attribute, + content: content.subtree[attribute]!, + spacerCount: spacerCount + 1, + isLast: i === subtreeAttributes.length - 1, + uniqueKey: `${uniqueKey}-${i}`, + renderers, + renderExtra, + }); + return rows.concat(branchRows); + }, + [] + ); + return [ + , + ...subtreeRows, + ]; +} + +/** + * Component to render proportional columns for log fields. The columns will not separate + * branch attributes from their roots, and attempt to be as evenly distributed as possible. + */ +function LogFieldsTreeColumns({ + attributes, + columnCount, + hiddenAttributes = [], + renderers = {}, + renderExtra, +}: LogFieldsTreeColumnsProps) { + const assembledColumns = useMemo(() => { + if (!attributes) { + return []; + } + + // Convert attributes record to the format expected by addToAttributeTree + const visibleAttributes = Object.keys(attributes) + .map(key => getAttribute(attributes, key, hiddenAttributes)) + .filter(defined); + + // Create the AttributeTree data structure using all the given attributes + const attributeTree = visibleAttributes.reduce( + (tree, attribute) => addToAttributeTree(tree, attribute, {}, attribute), + {} + ); + + // Create a list of AttributeTreeRow lists, containing every row to be rendered. They are grouped by + // root parent so that we do not split up roots/branches when forming columns + const attributeTreeRowGroups: React.ReactNode[][] = Object.entries(attributeTree).map( + ([attributeKey, content], i) => + getAttributeTreeRows({ + attributeKey, + content, + uniqueKey: `${i}`, + renderers, + renderExtra, + }) + ); + + // Get the total number of LogFieldsTreeRow components to be rendered, and a goal size for each column + const attributeTreeRowTotal = attributeTreeRowGroups.reduce( + (sum, group) => sum + group.length, + 0 + ); + const columnRowGoal = Math.ceil(attributeTreeRowTotal / columnCount); + + // Iterate through the row groups, splitting rows into columns when we exceed the goal size + const data = attributeTreeRowGroups.reduce( + ({startIndex, runningTotal, columns}, rowList, index) => { + // If it's the last entry, create a column with the remaining rows + if (index === attributeTreeRowGroups.length - 1) { + columns.push( + + {attributeTreeRowGroups.slice(startIndex)} + + ); + return {startIndex, runningTotal, columns}; + } + // If we reach the goal column size, wrap rows in a TreeColumn. + if (runningTotal >= columnRowGoal) { + columns.push( + + {attributeTreeRowGroups.slice(startIndex, index)} + + ); + runningTotal = 0; + startIndex = index; + } + runningTotal += rowList.length; + return {startIndex, runningTotal, columns}; + }, + {startIndex: 0, runningTotal: 0, columns: []} + ); + return data.columns; + }, [attributes, columnCount, hiddenAttributes, renderers, renderExtra]); + + return {assembledColumns}; +} + +export function LogFieldsTree(props: LogFieldsTreeProps) { + const containerRef = useRef(null); + const columnCount = useIssueDetailsColumnCount(containerRef); + return ( + + + + ); +} + +function LogFieldsTreeRow({ + content, + attributeKey, + spacerCount = 0, + isLast = false, + config = {}, + renderers = {}, + renderExtra, + ...props +}: LogFieldsTreeRowProps & { + renderExtra?: RendererExtra; + renderers?: Record< + string, + (props: {attribute_value: any; extra?: RendererExtra}) => React.ReactNode + >; +}) { + const originalAttribute = content.originalAttribute; + const hasErrors = false; // No error handling in this simplified version + const hasStem = !isLast && isEmptyObject(content.subtree); + + if (!originalAttribute) { + return ( + + + {spacerCount > 0 && ( + + + + + )} + {attributeKey} + + + + ); + } + + const attributeActions = !config?.disableActions ? ( + + ) : null; + + return ( + + + {spacerCount > 0 && ( + + + + + )} + {originalAttribute.attribute_key} + + {attributeKey} + + + + + + + {attributeActions} + + + ); +} + +function LogFieldsTreeRowDropdown({content}: {content: AttributeTreeContent}) { + const {onClick: handleCopy} = useCopyToClipboard({ + text: String(content.value), + }); + const setLogsSearch = useSetLogsSearch(); + const search = useLogsSearch(); + const [isVisible, setIsVisible] = useState(false); + const originalAttribute = content.originalAttribute; + + const addFilter = useCallback(() => { + if (!originalAttribute) { + return; + } + const newSearch = search.copy(); + newSearch.addFilterValue(originalAttribute.attribute_key, String(content.value)); + setLogsSearch(newSearch); + }, [originalAttribute, content.value, setLogsSearch, search]); + + if (!originalAttribute) { + return null; + } + + const items: MenuItemProps[] = [ + { + key: 'search-for-value', + label: t('Search for this value'), + onAction: () => { + addFilter(); + }, + }, + { + key: 'copy-value', + label: t('Copy attribute value to clipboard'), + onAction: handleCopy, + }, + ]; + + // Add external link option if the value is a URL + if (isUrl(String(content.value))) { + items.push({ + key: 'external-link', + label: t('Visit this external link'), + onAction: () => { + openNavigateToExternalLinkModal({linkText: String(content.value)}); + }, + }); + } + + return ( + setIsVisible(isOpen)} + triggerProps={{ + 'aria-label': t('Attribute Actions Menu'), + icon: , + showChevron: false, + className: 'attribute-button', + }} + items={items} + /> + ); +} + +function LogFieldsTreeValue({ + config, + content, + renderers = {}, + renderExtra, +}: { + content: AttributeTreeContent; + config?: LogFieldsTreeRowConfig; + renderExtra?: RendererExtra; + renderers?: Record< + string, + (props: {attribute_value: any; extra?: RendererExtra}) => React.ReactNode + >; +}) { + const {originalAttribute} = content; + if (!originalAttribute) { + return null; + } + + // Check if we have a custom renderer for this attribute + const attributeKey = originalAttribute.original_attribute_key; + const renderer = renderers[attributeKey]; + + const defaultValue = {String(content.value)}; + + if (config?.disableRichValue) { + return defaultValue; + } + + if (renderer) { + return renderer({ + attribute_value: content.value, + extra: renderExtra, + }); + } + + return !isUrl(String(content.value)) ? ( + defaultValue + ) : ( + + { + e.preventDefault(); + openNavigateToExternalLinkModal({linkText: String(content.value)}); + }} + > + {String(content.value)} + + + ); +} + +/** + * Filters out hidden attributes, replaces sentry. prefixed keys, and simplifies the value + */ +function getAttribute( + attributes: OurLogsTableRowDetails['attributes'], + attributeKey: string, + hiddenAttributes: OurLogFieldKey[] +): Attribute | undefined { + // Filter out hidden attributes + if (hiddenAttributes.includes(attributeKey as OurLogFieldKey)) { + return undefined; + } + + const attribute = attributes[attributeKey]; + if (!attribute) { + return undefined; + } + + // Replace the key name with the new key name + const newKeyName = attributeKey.replace('sentry.', ''); + + const attributeValue = attribute.valStr ?? attribute.valFloat ?? attribute.valInt; + if (!attributeValue) { + return undefined; + } + + return { + attribute_key: newKeyName, + attribute_value: attributeValue, + original_attribute_key: attributeKey, + }; +} + +const TreeContainer = styled('div')<{columnCount: number}>` + display: grid; + grid-template-columns: repeat(${p => p.columnCount}, 1fr); + align-items: start; + white-space: normal; +`; + +const TreeColumn = styled('div')` + display: grid; + grid-template-columns: minmax(auto, 175px) 1fr; + grid-column-gap: ${space(3)}; + &:first-child { + margin-left: -${space(1)}; + } + &:not(:first-child) { + border-left: 1px solid ${p => p.theme.innerBorder}; + padding-left: ${space(2)}; + margin-left: -1px; + } + &:not(:last-child) { + border-right: 1px solid ${p => p.theme.innerBorder}; + padding-right: ${space(2)}; + } +`; + +const TreeRow = styled('div')<{hasErrors: boolean}>` + border-radius: ${space(0.5)}; + padding-left: ${space(1)}; + position: relative; + display: grid; + align-items: center; + grid-column: span 2; + column-gap: ${space(1.5)}; + grid-template-columns: subgrid; + :nth-child(odd) { + background-color: ${p => + p.hasErrors ? p.theme.alert.error.backgroundLight : p.theme.backgroundSecondary}; + } + .invisible { + visibility: hidden; + } + &:hover, + &:active { + .invisible { + visibility: visible; + } + } + color: ${p => (p.hasErrors ? p.theme.alert.error.color : p.theme.subText)}; + background-color: ${p => + p.hasErrors ? p.theme.alert.error.backgroundLight : p.theme.background}; + box-shadow: inset 0 0 0 1px + ${p => (p.hasErrors ? p.theme.alert.error.border : 'transparent')}; +`; + +const TreeSpacer = styled('div')<{hasStem: boolean; spacerCount: number}>` + grid-column: span 1; + /* Allows TreeBranchIcons to appear connected vertically */ + border-right: 1px solid ${p => (p.hasStem ? p.theme.border : 'transparent')}; + margin-right: -1px; + height: 100%; + width: ${p => (p.spacerCount - 1) * 20 + 3}px; +`; + +const TreeBranchIcon = styled('div')<{hasErrors: boolean}>` + border: 1px solid ${p => (p.hasErrors ? p.theme.alert.error.border : p.theme.border)}; + border-width: 0 0 1px 1px; + border-radius: 0 0 0 5px; + grid-column: span 1; + height: 12px; + align-self: start; + margin-right: ${space(0.5)}; +`; + +const TreeKeyTrunk = styled('div')<{spacerCount: number}>` + grid-column: 1 / 2; + display: grid; + height: 100%; + align-items: center; + grid-template-columns: ${p => (p.spacerCount > 0 ? `auto 1rem 1fr` : '1fr')}; +`; + +const TreeValueTrunk = styled('div')` + grid-column: 2 / 3; + display: grid; + height: 100%; + align-items: center; + min-height: 22px; + grid-template-columns: 1fr auto; + grid-column-gap: ${space(0.5)}; +`; + +const TreeValue = styled('div')<{hasErrors?: boolean}>` + padding: ${space(0.25)} 0; + align-self: start; + font-family: ${p => p.theme.text.familyMono}; + font-size: ${p => p.theme.fontSizeSmall}; + word-break: break-word; + grid-column: span 1; + color: ${p => (p.hasErrors ? 'inherit' : p.theme.textColor)}; +`; + +const TreeKey = styled(TreeValue)<{hasErrors?: boolean}>` + color: ${p => (p.hasErrors ? 'inherit' : p.theme.subText)}; +`; + +/** + * Hidden element to allow browser searching for exact key name + */ +const TreeSearchKey = styled('span')` + font-size: 0; + position: absolute; +`; + +const TreeValueDropdown = styled(DropdownMenu)` + display: block; + margin: 1px; + height: 20px; + .attribute-button { + height: 20px; + min-height: 20px; + padding: 0 ${space(0.75)}; + border-radius: ${space(0.5)}; + z-index: 0; + } +`; + +const AttributeLinkText = styled('span')` + color: ${p => p.theme.linkColor}; + text-decoration: ${p => p.theme.linkUnderline} underline dotted; + margin: 0; + &:hover, + &:focus { + text-decoration: none; + } +`; diff --git a/static/app/views/explore/logs/logsTable.tsx b/static/app/views/explore/logs/logsTable.tsx index da179a507821..5cea82e9ec33 100644 --- a/static/app/views/explore/logs/logsTable.tsx +++ b/static/app/views/explore/logs/logsTable.tsx @@ -16,26 +16,30 @@ import { } from 'sentry/views/explore/contexts/logs/logsPageParams'; import { bodyRenderer, - severityCircleRenderer, + HiddenLogAttributes, + LogAttributesRendererMap, severityTextRenderer, TimestampRenderer, } from 'sentry/views/explore/logs/fieldRenderers'; +import {LogFieldsTree} from 'sentry/views/explore/logs/logFieldsTree'; import { + type OurLogFieldKey, OurLogKnownFieldKey, type OurLogsResponseItem, } from 'sentry/views/explore/logs/types'; -import {useExploreLogsTable} from 'sentry/views/explore/logs/useLogsQuery'; +import { + useExploreLogsTable, + useExploreLogsTableRow, +} from 'sentry/views/explore/logs/useLogsQuery'; import {EmptyStateText} from 'sentry/views/traces/styles'; import { DetailsFooter, DetailsGrid, - DetailsLabel, - DetailsSubGrid, - DetailsValue, DetailsWrapper, getLogColors, HeaderCell, + LogDetailsTitle, LogPanelContent, StyledChevronButton, StyledPanel, @@ -60,11 +64,12 @@ export function LogsTable() { const sortBys = useLogsSortBys(); const setSortBys = useSetLogsSortBys(); - const headers: Array<{align: 'left' | 'right'; field: string; label: string}> = [ - {field: 'log.severity_number', label: t('Severity'), align: 'left'}, - {field: 'log.body', label: t('Message'), align: 'left'}, - {field: 'timestamp', label: t('Timestamp'), align: 'right'}, - ]; + const headers: Array<{align: 'left' | 'right'; field: OurLogFieldKey; label: string}> = + [ + {field: OurLogKnownFieldKey.SEVERITY_NUMBER, label: t('Severity'), align: 'left'}, + {field: OurLogKnownFieldKey.BODY, label: t('Message'), align: 'left'}, + {field: OurLogKnownFieldKey.TIMESTAMP, label: t('Timestamp'), align: 'right'}, + ]; return ( @@ -132,9 +137,13 @@ function LogsRow({dataRow, highlightTerms}: LogsRowProps) { const [expanded, setExpanded] = useState(false); const onClickExpand = useCallback(() => setExpanded(e => !e), [setExpanded]); const theme = useTheme(); + + const severityNumber = dataRow[OurLogKnownFieldKey.SEVERITY_NUMBER]; + const severityText = dataRow[OurLogKnownFieldKey.SEVERITY_TEXT]; + const level = getLogSeverityLevel( - dataRow[OurLogKnownFieldKey.SEVERITY_NUMBER], - dataRow[OurLogKnownFieldKey.SEVERITY_TEXT] + typeof severityNumber === 'number' ? severityNumber : null, + typeof severityText === 'string' ? severityText : null ); const logColors = getLogColors(level, theme); @@ -148,22 +157,35 @@ function LogsRow({dataRow, highlightTerms}: LogsRowProps) { size="zero" borderless /> - {severityCircleRenderer( - dataRow[OurLogKnownFieldKey.SEVERITY_NUMBER], - dataRow[OurLogKnownFieldKey.SEVERITY_TEXT], - logColors - )} - {severityTextRenderer( - dataRow[OurLogKnownFieldKey.SEVERITY_NUMBER], - dataRow[OurLogKnownFieldKey.SEVERITY_TEXT], - logColors - )} + {severityTextRenderer({ + attribute_value: severityText, + tableResultLogRow: dataRow, + extra: { + highlightTerms, + logColors, + useFullSeverityText: true, + renderSeverityCircle: true, + }, + })} - {bodyRenderer(dataRow[OurLogKnownFieldKey.BODY], highlightTerms)} + {bodyRenderer({ + attribute_value: dataRow[OurLogKnownFieldKey.BODY], + extra: { + highlightTerms, + logColors, + wrapBody: false, + }, + })} - + {expanded && } @@ -177,36 +199,61 @@ function LogDetails({ dataRow: OurLogsResponseItem; highlightTerms: string[]; }) { + const severityNumber = dataRow[OurLogKnownFieldKey.SEVERITY_NUMBER]; + const severityText = dataRow[OurLogKnownFieldKey.SEVERITY_TEXT]; + const level = getLogSeverityLevel( - dataRow[OurLogKnownFieldKey.SEVERITY_NUMBER], - dataRow[OurLogKnownFieldKey.SEVERITY_TEXT] + typeof severityNumber === 'number' ? severityNumber : null, + typeof severityText === 'string' ? severityText : null ); + const missingLogId = !dataRow[OurLogKnownFieldKey.ID]; + const {data, isPending} = useExploreLogsTableRow({ + log_id: String(dataRow[OurLogKnownFieldKey.ID] ?? ''), + project_id: String(dataRow[OurLogKnownFieldKey.PROJECT_ID] ?? ''), + enabled: !missingLogId, + }); + const theme = useTheme(); const logColors = getLogColors(level, theme); + + if (missingLogId) { + return ( + + + + + + ); + } return ( - - - Timestamp - - - - - - Severity - - {severityTextRenderer( - dataRow[OurLogKnownFieldKey.SEVERITY_NUMBER], - dataRow[OurLogKnownFieldKey.SEVERITY_TEXT], - logColors, - true - )} - - - - - {bodyRenderer(dataRow['log.body'], highlightTerms, true)} - + {isPending && } + {!isPending && data && ( + + + {t('Log')} + + + + {bodyRenderer({ + attribute_value: dataRow[OurLogKnownFieldKey.BODY], + extra: { + highlightTerms, + logColors, + wrapBody: true, + }, + })} + + + )} ); } diff --git a/static/app/views/explore/logs/styles.tsx b/static/app/views/explore/logs/styles.tsx index 23353a5b014a..f15ddc723399 100644 --- a/static/app/views/explore/logs/styles.tsx +++ b/static/app/views/explore/logs/styles.tsx @@ -69,9 +69,26 @@ export const DetailsGrid = styled(StyledPanel)` padding: ${space(1)} ${space(2)}; `; -export const DetailsSubGrid = styled('div')` +export const LogDetailsTitle = styled('div')` + font-size: ${p => p.theme.fontSizeLarge}; + font-weight: ${p => p.theme.fontWeightBold}; + user-select: none; +`; + +export const LogAttributesTree = styled('div')` display: grid; - grid-template-columns: min-content min-content; + grid-template-columns: min-content min-content min-content; + gap: ${space(1)}; + width: 100%; + + > div { + &:nth-of-type(6n + 4), + &:nth-of-type(6n + 5), + &:nth-of-type(6n + 6) { + background: ${p => p.theme.surface200}; + } + padding: ${space(0.5)} ${space(1)}; + } `; export const DetailsFooter = styled(StyledPanelItem)<{ @@ -101,16 +118,6 @@ export const DetailsFooter = styled(StyledPanelItem)<{ `}; `; -export const DetailsLabel = styled('div')` - font-weight: 600; - min-width: 100px; - color: ${p => p.theme.gray300}; -`; - -export const DetailsValue = styled('div')` - word-break: break-word; -`; - export const StyledChevronButton = styled(Button)` margin-right: ${space(0.5)}; `; diff --git a/static/app/views/explore/logs/types.tsx b/static/app/views/explore/logs/types.tsx index b5181e77392d..78fe23c59b89 100644 --- a/static/app/views/explore/logs/types.tsx +++ b/static/app/views/explore/logs/types.tsx @@ -1,13 +1,20 @@ type OurLogCustomFieldKey = string; // We could brand this for nominal types. +// This enum is used to represent known fields or attributes in the logs response. export enum OurLogKnownFieldKey { + ID = 'id', BODY = 'log.body', SEVERITY_NUMBER = 'log.severity_number', SEVERITY_TEXT = 'log.severity_text', - ORGANIZATION_ID = 'sentry.organization_id', - PROJECT_ID = 'sentry.project_id', + SENTRY_SEVERITY_NUMBER = 'sentry.severity_number', + SENTRY_SEVERITY_TEXT = 'sentry.severity_text', + ORGANIZATION_ID = 'organization_id', + SENTRY_ORGANIZATION_ID = 'sentry.organization_id', + PROJECT_ID = 'project_id', + SENTRY_PROJECT_ID = 'sentry.project_id', SPAN_ID = 'sentry.span_id', TIMESTAMP = 'timestamp', + SENTRY_ITEM_TYPE = 'sentry.item_type', } export type OurLogFieldKey = OurLogCustomFieldKey | OurLogKnownFieldKey; diff --git a/static/app/views/explore/logs/useLogsQuery.tsx b/static/app/views/explore/logs/useLogsQuery.tsx index c1266458cb77..682792f4da53 100644 --- a/static/app/views/explore/logs/useLogsQuery.tsx +++ b/static/app/views/explore/logs/useLogsQuery.tsx @@ -1,4 +1,7 @@ +import {useEffect, useState} from 'react'; + import type EventView from 'sentry/utils/discover/eventView'; +import useProjects from 'sentry/utils/useProjects'; import { useLogsFields, useLogsSearch, @@ -6,7 +9,7 @@ import { } from 'sentry/views/explore/contexts/logs/logsPageParams'; import {useOurlogs} from 'sentry/views/insights/common/queries/useDiscover'; -export interface SpansTableResult { +export interface OurLogsTableResult { eventView: EventView; result: ReturnType; } @@ -28,3 +31,129 @@ export function useExploreLogsTable(options: Parameters[0]) { return {data, isError, isPending}; } + +export interface AttributeAnyValue { + valFloat?: number; + valInt?: string; + valStr?: string; +} + +type LogDetailsAttributes = Record; + +export interface OurLogsTableRowDetails { + attributes: LogDetailsAttributes; + itemId: string; + timestamp: string; + meta?: { + requestId: string; + }; +} + +export function useExploreLogsTableRow(_props: { + log_id: string | number; + project_id: string; + enabled?: boolean; +}) { + const {projects} = useProjects(); + const _project = projects.find(p => p.id === _props.project_id); + + const [isPending, setIsPending] = useState(true); + useEffect(() => { + setTimeout(() => { + setIsPending(false); + }, 500); + }, []); + const mockData: OurLogsTableRowDetails = { + itemId: '01955D0A464B701AB80B98E6CD0CA27C', + timestamp: '2025-03-03T17:25:09Z', + attributes: { + 'sentry.trace_id': { + valStr: 'c72d6f41754040efb9033be11f78e483', + }, + 'sentry.organization_id': { + valInt: '1', + }, + 'sentry.project_id': { + valInt: '2', + }, + 'sentry.item_type': { + valInt: '3', + }, + 'sentry.body': { + valStr: 'user sent message 193: what is a span', + }, + 'sentry.template': { + valStr: 'user sent message $param0: $param1', + }, + 'sentry.span_id': { + valStr: '', + }, + param1: { + valStr: 'what is a span', + }, + 'sentry.severity_text': { + valStr: 'info', + }, + param0: { + valFloat: 193.0, + }, + 'sentry.severity_number': { + valFloat: 10.0, + }, + 'sentry.severity_number.int': { + valInt: '10', + }, + user_id: { + valStr: '12345', + }, + order_id: { + valStr: '67890', + }, + payment_method: { + valStr: 'Credit Card', + }, + payment_status: { + valStr: 'failed', + }, + payment_vendor: { + valStr: 'Stripe', + }, + 'payment.amount': { + valStr: '199.99', + }, + 'payment.retry_count': { + valInt: '2', + }, + 'payment.error_code': { + valStr: 'PAYMENT_TIMEOUT', + }, + 'payment.correlation_id': { + valStr: '1234567890', + }, + 'payment.timestamp': { + valStr: '2025-02-27T21:01:53+00:00', + }, + 'user.id': { + valStr: '12345', + }, + 'user.email': { + valStr: 'test@example.com', + }, + 'this.attribute.is.deeply.nested': { + valStr: 'true', + }, + 'another.deeply.nested.attribute': { + valStr: 'true', + }, + }, + meta: { + requestId: 'bd69b517-6c01-4edf-a9d6-0b06a0e9d24f', + }, + }; + + return { + data: mockData, + isError: false, + isPending, + }; +} From f0741c3ff74bb609e867e64d80c4bf8f4ac18a48 Mon Sep 17 00:00:00 2001 From: Kev Date: Tue, 4 Mar 2025 14:39:46 -0500 Subject: [PATCH 2/4] Use actual endpoint instead of mock data --- .../app/views/explore/logs/fieldRenderers.tsx | 2 +- .../app/views/explore/logs/logFieldsTree.tsx | 2 +- static/app/views/explore/logs/types.tsx | 2 +- .../app/views/explore/logs/useLogsQuery.tsx | 120 +++--------------- 4 files changed, 24 insertions(+), 102 deletions(-) diff --git a/static/app/views/explore/logs/fieldRenderers.tsx b/static/app/views/explore/logs/fieldRenderers.tsx index b022434597a0..1184b1055620 100644 --- a/static/app/views/explore/logs/fieldRenderers.tsx +++ b/static/app/views/explore/logs/fieldRenderers.tsx @@ -23,7 +23,7 @@ import { } from 'sentry/views/explore/logs/utils'; interface FieldRendererProps { - attribute_value: any; + attribute_value: string | number | null; extra: RendererExtra; tableResultLogRow?: OurLogsResponseItem; } diff --git a/static/app/views/explore/logs/logFieldsTree.tsx b/static/app/views/explore/logs/logFieldsTree.tsx index 7f7bd935cb30..16530d7a0ce6 100644 --- a/static/app/views/explore/logs/logFieldsTree.tsx +++ b/static/app/views/explore/logs/logFieldsTree.tsx @@ -490,7 +490,7 @@ function getAttribute( // Replace the key name with the new key name const newKeyName = attributeKey.replace('sentry.', ''); - const attributeValue = attribute.valStr ?? attribute.valFloat ?? attribute.valInt; + const attributeValue = attribute.value; if (!attributeValue) { return undefined; } diff --git a/static/app/views/explore/logs/types.tsx b/static/app/views/explore/logs/types.tsx index 78fe23c59b89..4eba624aa3e8 100644 --- a/static/app/views/explore/logs/types.tsx +++ b/static/app/views/explore/logs/types.tsx @@ -2,7 +2,7 @@ type OurLogCustomFieldKey = string; // We could brand this for nominal types. // This enum is used to represent known fields or attributes in the logs response. export enum OurLogKnownFieldKey { - ID = 'id', + ID = 'sentry.item_id', BODY = 'log.body', SEVERITY_NUMBER = 'log.severity_number', SEVERITY_TEXT = 'log.severity_text', diff --git a/static/app/views/explore/logs/useLogsQuery.tsx b/static/app/views/explore/logs/useLogsQuery.tsx index 682792f4da53..fd8620382fa4 100644 --- a/static/app/views/explore/logs/useLogsQuery.tsx +++ b/static/app/views/explore/logs/useLogsQuery.tsx @@ -1,6 +1,6 @@ -import {useEffect, useState} from 'react'; - import type EventView from 'sentry/utils/discover/eventView'; +import {useQuery} from 'sentry/utils/queryClient'; +import useOrganization from 'sentry/utils/useOrganization'; import useProjects from 'sentry/utils/useProjects'; import { useLogsFields, @@ -33,9 +33,8 @@ export function useExploreLogsTable(options: Parameters[0]) { } export interface AttributeAnyValue { - valFloat?: number; - valInt?: string; - valStr?: string; + type: 'str' | 'int' | 'float' | 'bool'; + value: string | number | null; } type LogDetailsAttributes = Record; @@ -54,106 +53,29 @@ export function useExploreLogsTableRow(_props: { project_id: string; enabled?: boolean; }) { + const organization = useOrganization(); const {projects} = useProjects(); const _project = projects.find(p => p.id === _props.project_id); - const [isPending, setIsPending] = useState(true); - useEffect(() => { - setTimeout(() => { - setIsPending(false); - }, 500); - }, []); - const mockData: OurLogsTableRowDetails = { - itemId: '01955D0A464B701AB80B98E6CD0CA27C', - timestamp: '2025-03-03T17:25:09Z', - attributes: { - 'sentry.trace_id': { - valStr: 'c72d6f41754040efb9033be11f78e483', - }, - 'sentry.organization_id': { - valInt: '1', - }, - 'sentry.project_id': { - valInt: '2', - }, - 'sentry.item_type': { - valInt: '3', - }, - 'sentry.body': { - valStr: 'user sent message 193: what is a span', - }, - 'sentry.template': { - valStr: 'user sent message $param0: $param1', - }, - 'sentry.span_id': { - valStr: '', - }, - param1: { - valStr: 'what is a span', - }, - 'sentry.severity_text': { - valStr: 'info', - }, - param0: { - valFloat: 193.0, - }, - 'sentry.severity_number': { - valFloat: 10.0, - }, - 'sentry.severity_number.int': { - valInt: '10', - }, - user_id: { - valStr: '12345', - }, - order_id: { - valStr: '67890', - }, - payment_method: { - valStr: 'Credit Card', - }, - payment_status: { - valStr: 'failed', - }, - payment_vendor: { - valStr: 'Stripe', - }, - 'payment.amount': { - valStr: '199.99', - }, - 'payment.retry_count': { - valInt: '2', - }, - 'payment.error_code': { - valStr: 'PAYMENT_TIMEOUT', - }, - 'payment.correlation_id': { - valStr: '1234567890', - }, - 'payment.timestamp': { - valStr: '2025-02-27T21:01:53+00:00', - }, - 'user.id': { - valStr: '12345', - }, - 'user.email': { - valStr: 'test@example.com', - }, - 'this.attribute.is.deeply.nested': { - valStr: 'true', - }, - 'another.deeply.nested.attribute': { - valStr: 'true', - }, - }, - meta: { - requestId: 'bd69b517-6c01-4edf-a9d6-0b06a0e9d24f', + const {data, isError, isPending} = useQuery({ + queryKey: ['logs-table-row', _props.log_id, _props.project_id], + queryFn: async () => { + if (!_project) { + throw new Error('Project not found'); + } + const res = await fetch( + `/api/0/projects/${organization.slug}/${_project?.slug}/trace-items/${_props.log_id}/?dataset=ourlogs` + ); + if (!res.ok) { + throw new Error('Failed to fetch log details'); + } + return await res.json(); }, - }; + }); return { - data: mockData, - isError: false, + data, + isError, isPending, }; } From cfcbf4d6ea28b12c0622ec636b39ce83e0986a5c Mon Sep 17 00:00:00 2001 From: Kev Date: Tue, 4 Mar 2025 14:58:09 -0500 Subject: [PATCH 3/4] Delete old code, fix 'any' --- static/app/views/explore/logs/fieldRenderers.tsx | 2 +- static/app/views/explore/logs/styles.tsx | 16 ---------------- 2 files changed, 1 insertion(+), 17 deletions(-) diff --git a/static/app/views/explore/logs/fieldRenderers.tsx b/static/app/views/explore/logs/fieldRenderers.tsx index 1184b1055620..2477410f8937 100644 --- a/static/app/views/explore/logs/fieldRenderers.tsx +++ b/static/app/views/explore/logs/fieldRenderers.tsx @@ -99,7 +99,7 @@ export function bodyRenderer(props: FieldRendererProps) { } function wrappedSeverityTextRenderer(props: { - attribute_value: any; + attribute_value: string | number | null; extra?: RendererExtra; }) { const extra = props.extra || { diff --git a/static/app/views/explore/logs/styles.tsx b/static/app/views/explore/logs/styles.tsx index f15ddc723399..d6403c82775d 100644 --- a/static/app/views/explore/logs/styles.tsx +++ b/static/app/views/explore/logs/styles.tsx @@ -75,22 +75,6 @@ export const LogDetailsTitle = styled('div')` user-select: none; `; -export const LogAttributesTree = styled('div')` - display: grid; - grid-template-columns: min-content min-content min-content; - gap: ${space(1)}; - width: 100%; - - > div { - &:nth-of-type(6n + 4), - &:nth-of-type(6n + 5), - &:nth-of-type(6n + 6) { - background: ${p => p.theme.surface200}; - } - padding: ${space(0.5)} ${space(1)}; - } -`; - export const DetailsFooter = styled(StyledPanelItem)<{ logColors: ReturnType; opaque?: boolean; From e3ba2489d2011fa446450998337d47de0aefb7e9 Mon Sep 17 00:00:00 2001 From: Kev Date: Tue, 4 Mar 2025 14:59:29 -0500 Subject: [PATCH 4/4] one more any --- static/app/views/explore/logs/fieldRenderers.tsx | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/static/app/views/explore/logs/fieldRenderers.tsx b/static/app/views/explore/logs/fieldRenderers.tsx index 2477410f8937..f60199d849e0 100644 --- a/static/app/views/explore/logs/fieldRenderers.tsx +++ b/static/app/views/explore/logs/fieldRenderers.tsx @@ -111,7 +111,10 @@ function wrappedSeverityTextRenderer(props: { export const LogAttributesRendererMap: Record< OurLogFieldKey, - (props: {attribute_value: any; extra?: RendererExtra}) => React.ReactNode + (props: { + attribute_value: string | number | null; + extra?: RendererExtra; + }) => React.ReactNode > = { [OurLogKnownFieldKey.TIMESTAMP]: props => { // Ensure extra is defined for the wrapped function